# packages

pkgId: a914c44573910b025bdb80b4ad08c9bf6697285bba061288240a5c60de1f5525
name: python-kodexa-help
arch: noarch
version: 7.0.12397101638
epoch: 0
release: 1
summary: Development documents and examples for kodexa
url: https://pypi.org/project/kodexa/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-kodexa-7.0.12397101638-1.src.rpm
location_href: Packages/python-kodexa-help-7.0.12397101638-1.noarch.rpm
checksum_type: sha256
description:
  [![Build and Package with Poetry](https://github.com/kodexa-ai/kodexa/actions/workflows/main.yml/badge.svg?branch=main)](https://github.com/kodexa-ai/kodexa/actions/workflows/main.yml)

  ![img.png](https://docs.kodexa.com/img.png)

  Kodexa is a platform for building intelligent document processing pipelines. It is a set of tools and services that
  allow you to build a pipeline that can take a document, extract the content, and then process it to extract the
  information you need.

  It is built on a set of core principles:

  * **Document Centric** - Kodexa is built around the idea of a document. A document is a collection of content
    nodes that are connected together. This is a powerful model that allows you to build pipelines that can
    extract content from a wide range of sources.

  * **Pipeline Oriented** - Kodexa is built around the idea of a pipeline. A pipeline is a series of steps that
    can be executed on a document. This allows you to build a pipeline that can extract content from a wide range
    of sources.

  * **Extensible** - Kodexa is built around the idea of a pipeline. A pipeline is a series of steps that can be executed
    on a document. This allows you to build a pipeline that can extract content from a wide range of sources.

  * **Label Driven** - Kodexa focuses on the idea of labels. Labels are a way to identify content within a document
    and then use that content to drive the processing of the document.



  This repository contains the Python SDK for Kodexa. The SDK is the primary way to interact with Kodexa. It allows you to
  define actions, models, and pipelines that can be executed on Kodexa. It also includes a complete SDK client for
  working with a Kodexa platform instance.



  Documentation is available at the [Kodexa Support Portal](https://support.kodexa.ai)



  We use poetry to manage our dependencies, so you can install them with:

      poetry install

  You can then run the tests with:

      poetry run pytest



  We welcome contributions to the Kodexa platform. Please see our [contributing guide](CONTRIBUTING.md) for more details.



  Apache 2.0


pkgId: f44306fdfd82d05cccd5f5011afb9617d9f461cbb4e8c37af6b524b66a078306
name: python-kody-clientsdk-python-help
arch: noarch
version: 0.1.7
epoch: 0
release: 1
summary: Development documents and examples for kody-clientsdk-python
url: https://github.com/KodyPay/kody-clientsdk-python
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-kody-clientsdk-python-0.1.7-1.src.rpm
location_href: Packages/python-kody-clientsdk-python-help-0.1.7-1.noarch.rpm
checksum_type: sha256
description:
  The Kody Python Client allows direct communication with the Kody Payments Gateway. It simplifies the integration of Kody payments into your application.
  The SDK is generated from Protobuf gRPC protocols to facilitate communication with the Kody Payments Gateway.


  - grpcio-tools





  Install the Kody Python Client SDK using the following command:

  ```bash
  pip install kody-clientsdk-python
  ```



  Go to the [samples](https://github.com/KodyPay/kody-clientsdk-python/tree/main/versions/3_12/samples) directory for examples on how to use the Kody Python Client.



  This project is licensed under the MIT License.


pkgId: 113b2c9fb424040eabdd1a80b9e08d35b748e4e01a79eafef5a934489df2672c
name: python-kognitos-bdk-poetry-plugin-help
arch: noarch
version: 1.3.2
epoch: 0
release: 1
summary: Development documents and examples for kognitos-bdk-poetry-plugin
url: https://pypi.org/project/kognitos-bdk-poetry-plugin/
rpm_license: Propietary
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-kognitos-bdk-poetry-plugin-1.3.2-1.src.rpm
location_href: Packages/python-kognitos-bdk-poetry-plugin-help-1.3.2-1.noarch.rpm
checksum_type: sha256
description:
  The Poetry plugin for BDK is designed to enhance documentation workflows by automatically generating a comprehensive
  USAGE.md file from the docstrings embedded within a Poetry-managed Python project. This plugin seamlessly integrates
  with the Poetry ecosystem, parsing the docstrings of functions and classes to produce a well-structured and readable
  markdown file that outlines usage examples, input and output concepts, return types, and descriptions.


pkgId: 4b6e928ed8e66406a9496c114fbffecce9b9a71d5ef874f77ea8b55fabdcfe00
name: python-kohlrahbi-help
arch: noarch
version: 1.12.1
epoch: 0
release: 1
summary: Development documents and examples for kohlrahbi
url: https://github.com/Hochfrequenz/kohlrahbi
rpm_license: GPL
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-kohlrahbi-1.12.1-1.src.rpm
location_href: Packages/python-kohlrahbi-help-1.12.1-1.noarch.rpm
checksum_type: sha256
description:
  <p align="center">
    <img src="kohlrahbi-image.png" alt="kohlrahbi-logo" width="512" height="512">
  </p>

  [![License: GPL](https://img.shields.io/badge/License-GPL-yellow.svg)](LICENSE)
  ![Python Versions (officially) supported](https://img.shields.io/pypi/pyversions/kohlrahbi.svg)
  ![Unittests status badge](https://github.com/Hochfrequenz/kohlrahbi/workflows/Unittests/badge.svg)
  ![Coverage status badge](https://github.com/Hochfrequenz/kohlrahbi/workflows/Coverage/badge.svg)
  ![Linting status badge](https://github.com/Hochfrequenz/kohlrahbi/workflows/Linting/badge.svg)
  ![Black status badge](https://github.com/Hochfrequenz/kohlrahbi/workflows/Black/badge.svg)
  ![PyPI](https://img.shields.io/pypi/v/kohlrahbi)

  Kohlrahbi generates machine-readable files from AHB documents.
  Kohlrahbi's sister is [MIG_mose](https://github.com/Hochfrequenz/migmose).

  If you'd like to create a nice diff view of AHBs in different versions, try [`ahlbatross`](https://github.com/Hochfrequenz/ahlbatross).

  If you're looking for a tool to process the **official** BDEW XMLs for AHBs (available since 2024), checkout [fundamend](https://github.com/Hochfrequenz/xml-fundamend-python).



  German utilities exchange data using [EDIFACT](https://en.wikipedia.org/wiki/EDIFACT); This is called market communication (mako).
  The _Forum Datenformate_ of the BDEW publishes the technical regulations of the EDIFACT based market communication on [`edi-energy.de`](https://www.edi-energy.de/).
  These rules are not stable but change twice a year (in theory) or few times per year (in reality).

  Specific rules, which are binding for every German utility are kind of formalised in so called "**A**nwendungs**h**and**b**üchern" (AHB).
  Those AHBs are basically long tables that describe:
  > As a utility, if I want to exchange data about business process XYZ with a market partner, then I have to provide the following information: [...]

  In total the regulations from these Anwendungshandbücher span several thousand pages.
  And by pages, we really _mean_ pages.
  EDIFACT communication is basically the API between German utilities for most of their B2B processes.
  However, the technical specifications of this API are

  * prose
  * on DIN A4 pages.

  The Anwendungshandbücher are the epitome of digitization with some good intentions.

  Although the AHBs are publicly available as PDF or Word files on `edi-energy.de`, they are hardly accessible in a technical sense:

  * You cannot automatically extract information from the AHBs.
  * You cannot run automatic comparisons between different versions.
  * You cannot automatically test your own API against the set of rules, described in the AHBs (as prose).
  * You cannot view or visualize the information from the AHBs in any more intuitive or practical way, than the raw tables from the AHB files.
  * ...any many more...

  The root cause for all these inaccessibility is a technical one:
  Information that are theoretically structured are published in an unstructured format (PDF or Word), which is not suited for technical specifications in IT.

  KohlrAHBi as a tool helps you to break those chains and access the AHBs as you'd expect it from technical specs: easy and automatically instead of with hours of mindless manual work.

  **KohlrAHBi takes the `.docx` files published by `edi-energy.de` as an input and returns truly machine-readable data in a variety of formats (JSON, CSV...) as a result.**

  Hence, KohlrAHBi is the key for unlocking any automation potential that is reliant on information hidden in the Anwendungshandbücher.

  We're all hoping for the day of true digitization on which this repository will become obsolete.



  Kohlrahbi is a Python based tool.
  Therefore you have to make sure, that Python is running on your machine.

  We recommend to use virtual environments to keep your system clean.

  Create a new virtual environment with

  ```bash
  python -m venv .venv
  ```

  The activation of the virtual environment depends on your used OS.



  ```powershell
  .venv\Scripts\activate
  ```



  ```zsh
  source .venv/bin/activate
  ```

  Finally, install the package with

  ```bash
  pip install kohlrahbi
  ```



  Kohlrahbi is a command line tool.
  You can use it in three different ways:

  1. Extract AHB tables for all prüfidentifikatoren or a specific prüfidentifikator of a provided format version.
  2. Extract all conditions for each format of a provided format version.
  3. Extract the change history of a provided format version.

  You can run the following command to get an overview of all available commands and options.

  ```bash
  kohlrahbi --help
  ```

  > [!NOTE]
  > For the following steps we assume that you cloned our [edi_energy_mirror](https://github.com/Hochfrequenz/edi_energy_mirror/) to a neighbouring directory.
  > The `edi_energy_mirror` contains the `.docx` files of the AHBs.
  > The folder structure should look like this:
  > ```plaintext
  > .
  > ├── edi_energy_mirror
  > └── kohlrahbi
  > ```



  To extract the all AHB tables for each pruefi of a specific format version, you can run the following command.

  ```bash
  kohlrahbi ahb --edi-energy-mirror-path ../edi_energy_mirror/ --output-path ./output/ --file-type csv --format-version FV2310
  ```

  To extract the AHB tables for a specific pruefi of a specific format version, you can run the following command.

  ```bash
  kohlrahbi ahb -eemp ../edi_energy_mirror/ --output-path ./output/ --file-type csv --pruefis 13002 --format-version FV2310
  ```

  You can also provide multiple pruefis.

  ```bash
  kohlrahbi ahb -eemp ../edi_energy_mirror/ --output-path ./output/ --file-type csv --pruefis 13002 --pruefis 13003 --pruefis 13005 --format-version FV2310
  ```

  And you can also provide multiple file types.

  ```bash
  kohlrahbi ahb -eemp ../edi_energy_mirror/ --output-path ./output/ --file-type csv --file-type xlsx --file-type flatahb --pruefis 13002 --format-version FV2310
  ```



  To extract all conditions for each format of a specific format version, you can run the following command.

  ```bash
  kohlrahbi conditions -eemp ../edi_energy_mirror/ --output-path ./output/ --format-version FV2310
  ```
  This will provide you with:
  * all conditions
  * all packages

  found in all AHBs (including the condition texts from package tables) within the specified folder with the .docx files.
  The output will be saved for each Edifact format separately as `conditions.json` and `packages.json` in the specified output path.
  Please note that the information regarding the conditions collected here may more comprehensive compared to the information collected for the AHBs above. This is because `conditions` uses a different routine than `ahb`.



  ```bash
  kohlrahbi changehistory -eemp ../edi_energy_mirror/ --output-path ./output/ --format-version FV2310
  ```



  kohlrahbi internally relies on a [specific naming schema](https://github.com/Hochfrequenz/kohlrahbi/blob/22a78dc076c7d5f9248cb9e8707b0cc14a2981d3/src/kohlrahbi/read_functions.py#L57) of the `.docx` files in which the file name holds information about the edifact format and validity period of the AHBs contained within the file.
  The easiest way to be compliant with this naming schema is to clone our [edi_energy_mirror](https://github.com/Hochfrequenz/edi_energy_mirror/) repository to your localhost.



  There is a kohlrahbi based CI pipeline from the edi_energy_mirror mentioned above to the repository [machine-readable_anwendungshandbuecher](https://github.com/Hochfrequenz/machine-readable_anwendungshandbuecher) where you can find scraped AHBs as JSON, CSV or Excel files.



  ```mermaid
  flowchart TB
      S[Start] --> RD[Read docx]
      RD --> RPT[Read all paragraphs <br> and tables]
      RPT --> I[Start iterating]
      I --> NI[Read next item]
      % check for text paragraph %
      NI --> CTP{Text Paragraph?}
      CTP -- Yes --> NI
      CTP -- No --> CCST{Is item just<br>Chapter or Section Title?}
      CCST -- Yes --> CTAenderunghistorie{Is Chapter Title<br>'Änderungshistorie'?}
      CTAenderunghistorie -- Yes --> EXPORT[Export Extract]
      CCST -- No --> CT{Is item a table<br>with prüfis?}
      CT -- Yes --> Extract[Create Extract]
  ```



  The following table shows the page number of the AHBs for each format of the format version FV2310.

  | Format       | Page number | Hint                                                |     |
  | ------------ | ----------- | --------------------------------------------------- | --- |
  | UTILMD Strom | 1064        |                                                     |     |
  | UTILMD Gas   | 345         |                                                     |     |
  | REQOTE       | 264         | together with QUOTES, ORDERS, ORDRSP, ORDCHG        |     |
  | QUOTES       | 264         | together with REQOTE, ORDERS, ORDRSP, ORDCHG        |     |
  | ORDRSP       | 264         | together with REQOTE, QUOTES, ORDERS, ORDCHG        |     |
  | ORDERS       | 264         | together with REQOTE, QUOTES, ORDRSP, ORDCHG        |     |
  | ORDCHG       | 264         | together with REQOTE, QUOTES, ORDERS, ORDRSP        |     |
  | MSCONS       | 164         |                                                     |     |
  | UTILMD MaBis | 133         |                                                     |     |
  | REMADV       | 91          | together with INVOIC                                |     |
  | INVOIC       | 91          | together with REMADV                                |     |
  | IFTSTA       | 82          |                                                     |     |
  | CONTRL       | 72          | together with APERAK, contains no Prüfis            |     |
  | APERAK       | 72          | together with CONTRL, contains no Prüfis            |     |
  | PARTIN       | 69          |                                                     |     |
  | UTILTS       | 34          |                                                     |     |
  | ORDRSP       | 30          | together with ORDERS                                |     |
  | ORDERS       | 30          | together with ORDRSP                                |     |
  | PRICAT       | 25          |                                                     |     |
  | COMDIS       | 10          | good test for tables which are above change history |     |





  To set up the development environment, you have to install the dev dependencies.

  ```bash
  tox -e dev
  ```



  To run the tests, you can use tox.

  ```bash
  tox
  ```

  See our [Python Template Repository](https://github.com/Hochfrequenz/python_template_repository#how-to-use-this-repository-on-your-machine) for detailed explanations.



  You are very welcome to contribute to this template repository by opening a pull request against the main branch.



  This repository is part of the [Hochfrequenz Libraries and Tools for a truly digitized market communication](https://github.com/Hochfrequenz/digital_market_communication/).


pkgId: a94b466adbdcf40d5cd6de266f59ee7c8bc4811e9795ffe2d157b08333b7411b
name: python-kolena-help
arch: noarch
version: 1.49.0
epoch: 0
release: 1
summary: Development documents and examples for kolena
url: https://pypi.org/project/kolena/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-kolena-1.49.0-1.src.rpm
location_href: Packages/python-kolena-help-1.49.0-1.noarch.rpm
checksum_type: sha256
description:
  [Kolena](https://www.kolena.com) is a comprehensive machine learning testing and debugging platform to surface hidden
  model behaviors and take the mystery out of model development. Kolena helps you:
  - Perform high-resolution model evaluation
  - Understand and track behavioral improvements and regressions
  - Meaningfully communicate model capabilities
  - Automate model testing and deployment workflows
  This `kolena` package contains the Python client library for programmatic interaction with the Kolena ML testing
  platform. [Install](https://docs.kolena.com/installing-kolena) with your favorite Python package manager and
  [get started in minutes](https://docs.kolena.com/dataset/quickstart):
  ```
  pip install kolena
  ```

  | [Developer Guide](https://docs.kolena.com) | [Quickstart](https://docs.kolena.com/dataset/quickstart) | [API Reference](https://docs.kolena.com/reference) | [Examples](./examples) |
  | --- | --- | --- | --- |
  | Tutorial and usage documentation | Set up rigorous and repeatable model testing in minutes | Detailed `kolena` typing and function documentation | Reference integrations for different machine learning workflows |


pkgId: ca8db7493a19ca6d87178c9a1f02985fc1b725a0dc340bbc3d85a11001a5065b
name: python-komm-help
arch: noarch
version: 0.14.0
epoch: 0
release: 1
summary: Development documents and examples for komm
url: https://pypi.org/project/komm/
rpm_license: GPL-3.0-only
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-komm-0.14.0-1.src.rpm
location_href: Packages/python-komm-help-0.14.0-1.noarch.rpm
checksum_type: sha256
description:
  _A Python library for communication systems_.

  [![PyPI page](https://badge.fury.io/py/komm.svg)](https://pypi.org/project/komm/)
  [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black/)
  [![Contributions welcome](https://img.shields.io/badge/contributions-welcome-brightgreen.svg)](https://github.com/rwnobrega/komm/issues)

  Welcome to **Komm**!

  <!--intro-start-->

  **Komm** is an open-source library for Python 3 providing tools for analysis and simulation of analog and digital communication systems. This project is inspired by—but is not meant to be compatible with—the MATLAB® [Communications System Toolbox™](https://www.mathworks.com/help/comm/). Other sources of inspiration include [GNU Radio](https://gnuradio.org/), [CommPy](http://veeresht.info/CommPy/), and [SageMath](https://www.sagemath.org/). **Komm** is licensed under the [GNU General Public License v3.0](https://www.gnu.org/licenses/gpl-3.0.en.html).

  <!--intro-end-->

  For library reference, please check the [project's website](https://komm.dev/).

  <!--notes-start-->

  > [!WARNING]
  > Please be advised that this project is currently under development. As such, there may be changes to the project's codebase, including the API.

  <!--notes-end-->



  Before you start, make sure you have [Python](https://www.python.org/) (version 3.10 or later) installed.



  ```bash
  pip install komm
  ```



  ```bash
  pip install git+https://github.com/rwnobrega/komm.git@main
  ```



  First, clone the repository:

  ```bash
  git clone https://github.com/rwnobrega/komm
  cd komm
  ```

  This project uses [PDM](https://pdm-project.org/) for dependency management. After installing PDM, install the dependencies and activate the virtual environment:

  ```bash
  pdm install
  pdm venv activate
  ```



  The test suite is written using the [pytest](https://docs.pytest.org/) framework. To run the tests, execute:

  ```bash
  pytest
  ```



  The documentation is built using [MkDocs](https://www.mkdocs.org/) with the [Material for MkDocs](https://squidfunk.github.io/mkdocs-material/) theme. To serve the documentation locally, run:

  ```bash
  mkdocs serve
  ```



  There are some demos available in the `demo` directory. They are written using [Streamlit](https://streamlit.io/). To run them, execute:

  ```bash
  streamlit run demo/index.py
  ```



  See the [CHANGELOG.md](CHANGELOG.md).


pkgId: cdc942e5284b7a0e7a60949b6aa86e7e43a087905983defd9b9364ff88721eea
name: python-konduktor-nightly-help
arch: noarch
version: 0.1.0.dev20241213104730
epoch: 0
release: 1
summary: Development documents and examples for konduktor-nightly
url: https://pypi.org/project/konduktor-nightly/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-konduktor-nightly-0.1.0.dev20241213104730-1.src.rpm
location_href: Packages/python-konduktor-nightly-help-0.1.0.dev20241213104730-1.noarch.rpm
checksum_type: sha256
description:
  <p align="center">
    <picture>
      <img alt="Trainy Konduktor Logo" src="https://raw.githubusercontent.com/Trainy-ai/konduktor/main/docs/source/images/konduktor-logo-white-no-background.png" width="353" height="64" style="max-width: 100%;">
    </picture>
    <br/>
    <br/>
  </p>

  Konduktor is a source available Run:AI alternative built on [Kubernetes](https://kubernetes.io). Konduktor uses existing open source tools to build a platform that makes it easy for ML Researchers to submit batch jobs and for administrative/infra teams to easily manage GPU clusters.



  Konduktor uses a combination of open source projects. Where tools exist with MIT, Apache, or another compatible open license, we want to use and even contribute to that tool. Where we see gaps in tooling, we build it and open source ourselves.



  Konduktor can be self-hosted and run on any certified Kubernetes distribution or managed by us. Contact us at founders@trainy.ai if you are just interested in the managed version. We're focused on tooling for clusters with NVIDIA cards for now but in the future we may expand to our scope to support other accelerators.

  <p align="center">
    <img alt="architecture" src="https://raw.githubusercontent.com/Trainy-ai/konduktor/main/docs/source/images/architecture.png" width=80%>
  </p>

  For ML researchers
  - [Skypilot](https://skypilot.readthedocs.io/en/latest/docs/index.html) - user friendly batch job framework, where users only need to specify the resource requirements of their job and a script to launch that makes simple to scale work across multiple nodes. Works with most ML application frameworks. [Examples](https://github.com/skypilot-org/skypilot/tree/master/examples)

  ```
  num_nodes: 100

  resources:
    accelerators: H100:8
    cloud: kubernetes
    labels:
      kueue.x-k8s.io/queue-name: user-queue
      kueue.x-k8s.io/priority-class: low-priority

  setup: |
    pip install torch torchvision

  run: |
    torchrun \
    --nproc_per_node 8 \
    --rdzv_id=1 --rdzv_endpoint=$master_addr:1234 \
    --rdzv_backend=c10d --nnodes $num_nodes \
    torch_ddp_benchmark.py --distributed-backend nccl
  ```

  For cluster administrators
  - [DCGM Exporter](https://github.com/NVIDIA/dcgm-exporter), [GPU operator](https://docs.nvidia.com/datacenter/cloud-native/gpu-operator/latest/), [Network Operator](https://github.com/Mellanox/network-operator) - For installing NVIDIA driver, container runtime, and exporting node health metrics.
  - [Kueue](https://kueue.sigs.k8s.io/docs/) - centralized creation of job queues, gang-scheduling, and resource quotas and sharing across projects.
  - [Prometheus](https://prometheus.io/) - For publishing metrics about node health and workload queues.
  - [OpenTelemetry](https://opentelemetry.io/) - For pushing logs from each node
  - [Grafana, Loki](https://grafana.com/) - Visualizations for metrics/logging solution.



  - [Discord](https://discord.com/invite/HQUBJSVgAP)
  - founders@trainy.ai



  Format your code with
  ```
  poetry install --with dev
  bash format.sh
  ```


pkgId: 441322cc57e9858cc302a9e3ac3fe15d68ca7d055d4e8e40848ad5497a3a1d26
name: python-kopf-help
arch: noarch
version: 1.37.4
epoch: 0
release: 1
summary: Development documents and examples for kopf
url: https://github.com/nolar/kopf
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-kopf-1.37.4-1.src.rpm
location_href: Packages/python-kopf-help-1.37.4-1.noarch.rpm
checksum_type: sha256
description:
  [![GitHub](https://img.shields.io/github/stars/nolar/kopf?style=flat&label=GitHub%E2%AD%90%EF%B8%8F)](https://github.com/nolar/kopf)
  [![CI](https://github.com/nolar/kopf/actions/workflows/thorough.yaml/badge.svg)](https://github.com/nolar/kopf/actions/workflows/thorough.yaml)
  [![Supported Python versions](https://img.shields.io/pypi/pyversions/kopf.svg)](https://pypi.org/project/kopf/)
  [![codecov](https://codecov.io/gh/nolar/kopf/branch/main/graph/badge.svg)](https://codecov.io/gh/nolar/kopf)
  [![Coverage Status](https://coveralls.io/repos/github/nolar/kopf/badge.svg?branch=main)](https://coveralls.io/github/nolar/kopf?branch=main)

  **Kopf** —Kubernetes Operator Pythonic Framework— is a framework and a library
  to make Kubernetes operators development easier, just in a few lines of Python code.

  The main goal is to bring the Domain-Driven Design to the infrastructure level,
  with Kubernetes being an orchestrator/database of the domain objects (custom resources),
  and the operators containing the domain logic (with no or minimal infrastructure logic).

  The project was originally started as `zalando-incubator/kopf` in March 2019,
  and then forked as `nolar/kopf` in August 2020: but it is the same codebase,
  the same packages, the same developer(s).

  As of now, the project is in maintenance mode since approximately mid-2021:
  Python, Kubernetes, CI tooling, dependencies are upgraded, new bugs are fixed,
  new versions are released from time to time, but no new big features are added
  — there is nothing to add to this project without exploding its scope
  beyond the "operator framework" definition (ideas are welcome!).




  * https://kopf.readthedocs.io/




  * Simple, but powerful:
    * A full-featured operator in just 2 files: a `Dockerfile` + a Python file (*).
    * Handling functions registered via decorators with a declarative approach.
    * No infrastructure boilerplate code with K8s API communication.
    * Both sync and async handlers, with sync ones being threaded under the hood.
    * Detailed documentation with examples.
  * Intuitive mapping of Python concepts to Kubernetes concepts and back:
    * Marshalling of resources' data to the handlers' kwargs.
    * Marshalling of handlers' results to the resources' statuses.
    * Publishing of logging messages as Kubernetes events linked to the resources.
  * Support anything that exists in K8s:
    * Custom K8s resources.
    * Builtin K8s resources (pods, namespaces, etc).
    * Multiple resource types in one operator.
    * Both cluster and namespaced operators.
  * All the ways of handling that a developer can wish for:
    * Low-level handlers for events received from K8s APIs "as is" (an equivalent of _informers_).
    * High-level handlers for detected causes of changes (creation, updates with diffs, deletion).
    * Handling of selected fields only instead of the whole objects (if needed).
    * Dynamically generated or conditional sub-handlers (an advanced feature).
    * Timers that tick as long as the resource exists, optionally with a delay since the last change.
    * Daemons that run as long as the resource exists (in threads or asyncio-tasks).
    * Validating and mutating admission webhook (with dev-mode tunneling).
    * Live in-memory indexing of resources or their excerpts.
    * Filtering with stealth mode (no logging): by arbitrary filtering functions,
      by labels/annotations with values, presence/absence, or dynamic callbacks.
    * In-memory all-purpose containers to store non-serializable objects for individual resources.
  * Eventual consistency of handling:
    * Retrying the handlers in case of arbitrary errors until they succeed.
    * Special exceptions to request a special retry or to never retry again.
    * Custom limits for the number of attempts or the time.
    * Implicit persistence of the progress that survives the operator restarts.
    * Tolerance to restarts and lengthy downtimes: handles the changes afterwards.
  * Awareness of other Kopf-based operators:
    * Configurable identities for different Kopf-based operators for the same resource kinds.
    * Avoiding double-processing due to cross-pod awareness of the same operator ("peering").
    * Pausing of a deployed operator when a dev-mode operator runs outside of the cluster.
  * Extra toolkits and integrations:
    * Some limited support for object hierarchies with name/labels propagation.
    * Friendly to any K8s client libraries (and is client agnostic).
    * Startup/cleanup operator-level handlers.
    * Liveness probing endpoints and rudimentary metrics exports.
    * Basic testing toolkit for in-memory per-test operator running.
    * Embeddable into other Python applications.
  * Highly configurable (to some reasonable extent).

  (*) _Small font: two files of the operator itself, plus some amount of
  deployment files like RBAC roles, bindings, service accounts, network policies
  — everything needed to deploy an application in your specific infrastructure._




  See [examples](https://github.com/nolar/kopf/tree/main/examples)
  for the examples of the typical use-cases.

  A minimalistic operator can look like this:

  ```python
  import kopf

  @kopf.on.create('kopfexamples')
  def create_fn(spec, name, meta, status, **kwargs):
      print(f"And here we are! Created {name} with spec: {spec}")
  ```

  Numerous kwargs are available, such as `body`, `meta`, `spec`, `status`,
  `name`, `namespace`, `retry`, `diff`, `old`, `new`, `logger`, etc:
  see [Arguments](https://kopf.readthedocs.io/en/latest/kwargs/)

  To run a never-exiting function for every resource as long as it exists:

  ```python
  import time
  import kopf

  @kopf.daemon('kopfexamples')
  def my_daemon(spec, stopped, **kwargs):
      while not stopped:
          print(f"Object's spec: {spec}")
          time.sleep(1)
  ```

  Or the same with the timers:

  ```python
  import kopf

  @kopf.timer('kopfexamples', interval=1)
  def my_timer(spec, **kwargs):
      print(f"Object's spec: {spec}")
  ```

  That easy! For more features, see the [documentation](https://kopf.readthedocs.io/).




  Python 3.8+ is required:
  [CPython](https://www.python.org/) and [PyPy](https://www.pypy.org/)
  are officially supported and tested; other Python implementations can work too.

  We assume that when the operator is executed in the cluster, it must be packaged
  into a docker image with a CI/CD tool of your preference.

  ```dockerfile
  FROM python:3.12
  ADD . /src
  RUN pip install kopf
  CMD kopf run /src/handlers.py --verbose
  ```

  Where `handlers.py` is your Python script with the handlers
  (see `examples/*/example.py` for the examples).

  See `kopf run --help` for other ways of attaching the handlers.




  Please read [CONTRIBUTING.md](https://github.com/nolar/kopf/blob/main/CONTRIBUTING.md)
  for details on our process for submitting pull requests to us, and please ensure
  you follow the [CODE_OF_CONDUCT.md](https://github.com/nolar/kopf/blob/main/CODE_OF_CONDUCT.md).

  To install the environment for the local development,
  read [DEVELOPMENT.md](https://github.com/nolar/kopf/blob/main/DEVELOPMENT.md).




  We use [SemVer](http://semver.org/) for versioning. For the versions available,
  see the [releases on this repository](https://github.com/nolar/kopf/releases).




  This project is licensed under the MIT License —
  see the [LICENSE](https://github.com/nolar/kopf/blob/main/LICENSE) file for details.




  * Thanks to Zalando for starting this project in Zalando's Open-Source Incubator
    in the first place.
  * Thanks to [@side8](https://github.com/side8) and their [k8s-operator](https://github.com/side8/k8s-operator)
    for inspiration.


pkgId: f8cfa838d7f21436b8cfb41e945bf7c7135a5acae929541ab1ce68aad0425478
name: python-kpops-help
arch: noarch
version: 8.3.0
epoch: 0
release: 1
summary: Development documents and examples for kpops
url: https://github.com/bakdata/kpops
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-kpops-8.3.0-1.src.rpm
location_href: Packages/python-kpops-help-8.3.0-1.noarch.rpm
checksum_type: sha256
description:
  [![Build status](https://github.com/bakdata/kpops/actions/workflows/ci.yaml/badge.svg)](https://github.com/bakdata/kpops/actions/workflows/ci.yaml)
  [![pypi](https://img.shields.io/pypi/v/kpops.svg)](https://pypi.org/project/kpops)
  [![versions](https://img.shields.io/pypi/pyversions/kpops.svg)](https://github.com/bakdata/kpops)
  [![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff)
  [![license](https://img.shields.io/github/license/bakdata/kpops.svg)](https://github.com/bakdata/kpops/blob/main/LICENSE)



  - **Deploy Kafka apps to Kubernetes**: KPOps allows to deploy consecutive Kafka Streams applications and producers using an easy-to-read and -write pipeline definition.
  - **Manage Kafka Connectors**: KPOps connects with your Kafka Connect cluster and deploys, validates, and deletes your connectors.
  - **Configure multiple pipelines and steps**: KPOps has various abstractions that simplify configuring multiple pipelines and steps within pipelines by sharing common configuration between different components, such as producers or streaming applications.
  - **Handle your topics and schemas**: KPOps not only creates and deletes your topics but also registers and deletes your schemas.
  - **Clean termination of Kafka components**: KPOps removes your pipeline components (i.e., Kafka Streams applications) from the Kubernetes cluster _and_ cleans up the component-related states (i.e., removing/resetting offset of Kafka consumer groups).
  - **Preview your pipeline changes**: With the KPOps dry-run, you can ensure your pipeline definition is set up correctly. This helps to minimize downtime and prevent potential errors or issues that could impact your production environment.



  For detailed usage and installation instructions, check out
  the [documentation](https://bakdata.github.io/kpops/latest).



  KPOps comes as a [PyPI package](https://pypi.org/project/kpops/).
  You can install it with [pip](https://github.com/pypa/pip):

  ```sh
  pip install kpops
  ```



  Please refer to the [GitHub Actions section](https://bakdata.github.io/kpops/latest/user/references/ci-integration/github-actions) for the documentation.



  We are happy if you want to contribute to this project.
  If you find any bugs or have suggestions for improvements, please open an issue.
  We are also happy to accept your PRs.
  Just open an issue beforehand and let us know what you want to do and why.



  KPOps is licensed under the [MIT License](https://github.com/bakdata/kpops/blob/main/LICENSE).


pkgId: 908cfc21816ca9ea8a03aa2ed688d64c6d043d8e7de03f65be8f2e0fbaa0f10c
name: python-kryptools-help
arch: noarch
version: 0.9.15
epoch: 0
release: 1
summary: Development documents and examples for kryptools
url: https://github.com/teschlg/kryptools
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-kryptools-0.9.15-1.src.rpm
location_href: Packages/python-kryptools-help-0.9.15-1.noarch.rpm
checksum_type: sha256
description:
  Gerald Teschl <Gerald.Teschl@univie.ac.at>

  This package was written for my course on cryptography. Consequently its intention is
  mainly educational, that is, to show how basic algorithms are implemented. In particular,
  you are welcome to read (and modify) the source. Any suggestions on how to make the
  code more readable or make it better are welcome. However, my main goal is to keep
  it simple and readability will be preferred over small speed improvements.

  > **Warning**
  > These tools are intended for experimenting with cryptographic algorithms. They are not intended for use in real applications.

  It does not require any external libraries.

  The tools contained are:

  * number theory: sqrt modulo primes, Jacobi/Legendre symbol, Chinese Remainder Theorem, continued fractions, etc.
  * primes: Sieve of Erathostenes, primality tests, generation of random safe/strong primes
  * solvers for discrete logarithms (naive, Pollard rho, Shanks baby step/giant step, index calculus, quadratic sieve)
  * integer factorization (Fermat, Pollard p-1, Pollard rho, Lenstra's ECM, Dixon, basic quadratic sieve)
  * elliptic curves (Weierstrass form), group operations, order, discrete logarithms
  * linear algebra: Hermite normal form, Gram-Schmidt
  * lattices: Hadamard ratio, Babai rounding/nearest plane algorithm, lattice reduction (Lenstra-Lenstra-Lovaz)

  * Matrix: a class for Matrices (inverse, det, reduced echelon form, etc.)
  * Poly: a class for polynomials (division, modulo)
  * Zmod: a class for the ring of integers modulo an integer
  * GF2: a class for Galois fields GF(2^n)

  * BlockCipher: a class implementing the usual modes of operation (ECB, CBC, GCM, etc.)
  * AESCipher: individual AES operations
  * DESCipher: individual DES operations

  Documentation can be found in the jupyter notebook
  (mostly done, but might not contain everything: use the force, read the source).


pkgId: 51e47872e2b89c797e7ced2409e1f60d5aecce3035ccc753f8fbb763e113a95d
name: python-kubedownscaler-help
arch: noarch
version: 0.4.0
epoch: 0
release: 1
summary: Development documents and examples for kubedownscaler
url: https://github.com/djjudas21/kubedownscaler
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-kubedownscaler-0.4.0-1.src.rpm
location_href: Packages/python-kubedownscaler-help-0.4.0-1.noarch.rpm
checksum_type: sha256
description:
  Scales down Kubernetes Deployments and StatefulSets to 0 replicas, keeps note of the number
  of replicas in annotations, and scales everything back up to the original number of replicas.

  Can operate on a single namespace, or the entire cluster.
  Can operate only on Deployments and StatefulSets that use a specific StorageClass

  Ideal for performing a controlled shutdown, maintenance, etc.

  Uses whatever context your local `kubectl` has.



  ```sh
  pip install kubedownscaler
  ```



  Either `-d|--down` or `-u|--up` must be specified.

  ```
  usage: kubectl downscale [-h] (-d | -u) [--dry-run] [-n NAMESPACE] [--deployments | --no-deployments]
                 [--statefulsets | --no-statefulsets] [--storageclass STORAGECLASS]

  options:
    -h, --help            show this help message and exit
    -d, --down            scale down cluster resources
    -u, --up              scale up to restore state
    --dry-run             don't actually scale anything
    -n NAMESPACE, --namespace NAMESPACE
                          namespace to operate on
    --deployments, --no-deployments
                          scale Deployments (default: True)
    --statefulsets, --no-statefulsets
                          scale StatefulSets (default: True)
    --storageclass STORAGECLASS
                          only scale Deployments and StatefulSets that are consuming a specific StorageClass
  ```



  ```sh
  poetry install
  poetry build
  poetry publish
  ```


pkgId: 4d5e79fc2caf9757063651ba3265a3db8e5d861593a35baf0589d373c9972290
name: python-kurirogram-help
arch: noarch
version: 2.1.34
epoch: 0
release: 1
summary: Development documents and examples for kurirogram
url: https://github.com/pyrogram
rpm_license: LGPLv3
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-kurirogram-2.1.34-1.src.rpm
location_href: Packages/python-kurirogram-help-2.1.34-1.noarch.rpm
checksum_type: sha256
description:
  <p align="center">
      <a href="https://github.com/pyrogram/pyrogram">
          <img src="https://docs.pyrogram.org/_static/pyrogram.png" alt="Pyrogram" width="128">
      </a>
      <br>
      <b>Telegram MTProto API Framework for Python</b>
      <br>
      <a href="https://pyrogram.org">
          Homepage
      </a>
      •
      <a href="https://docs.pyrogram.org">
          Documentation
      </a>
      •
      <a href="https://docs.pyrogram.org/releases">
          Releases
      </a>
      •
      <a href="https://t.me/pyrogram">
          News
      </a>
  </p>



  > Elegant, modern and asynchronous Telegram MTProto API framework in Python for users and bots

  ``` python
  from pyrogram import Client, filters

  app = Client("my_account")


  @app.on_message(filters.private)
  async def hello(client, message):
      await message.reply("Hello from Pyrogram!")


  app.run()
  ```

  **Pyrogram** is a modern, elegant and asynchronous [MTProto API](https://docs.pyrogram.org/topics/mtproto-vs-botapi)
  framework. It enables you to easily interact with the main Telegram API through a user account (custom client) or a bot
  identity (bot API alternative) using Python.



  If you'd like to support Pyrogram, you can consider:

  - [Become a GitHub sponsor](https://github.com/sponsors/delivrance).
  - [Become a LiberaPay patron](https://liberapay.com/delivrance).
  - [Become an OpenCollective backer](https://opencollective.com/pyrogram).



  - **Ready**: Install Pyrogram with pip and start building your applications right away.
  - **Easy**: Makes the Telegram API simple and intuitive, while still allowing advanced usages.
  - **Elegant**: Low-level details are abstracted and re-presented in a more convenient way.
  - **Fast**: Boosted up by [TgCrypto](https://github.com/pyrogram/tgcrypto), a high-performance cryptography library written in C.
  - **Type-hinted**: Types and methods are all type-hinted, enabling excellent editor support.
  - **Async**: Fully asynchronous (also usable synchronously if wanted, for convenience).
  - **Powerful**: Full access to Telegram's API to execute any official client action and more.



  ``` bash
  pip3 install pyrogram
  ```



  - Check out the docs at https://docs.pyrogram.org to learn more about Pyrogram, get started right
  away and discover more in-depth material for building your client applications.
  - Join the official channel at https://t.me/pyrogram and stay tuned for news, updates and announcements.


pkgId: 1f60de2c239a4d2f191e76d23472b0a930bbcd32ec5d7600cea148ec0b403075
name: python-kuru-sdk-help
arch: noarch
version: 0.1.1
epoch: 0
release: 1
summary: Development documents and examples for kuru-sdk
url: https://github.com/kuru/kuru-py-sdk
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-kuru-sdk-0.1.1-1.src.rpm
location_href: Packages/python-kuru-sdk-help-0.1.1-1.noarch.rpm
checksum_type: sha256
description:
  A Python SDK for interacting with Kuru's Central Limit Orderbook (CLOB).



  - Margin Account Management
    - Deposit and withdraw tokens
    - Manage collateral
  - Order Management
    - Place limit and market orders
    - Real-time order tracking via WebSocket
    - Batch order cancellation
  - Advanced Trading Features
    - Post-only orders
    - Fill-or-kill orders
    - Margin trading support
    - Market making utilities



  ```bash
  pip install kuru-sdk
  ```



  The SDK uses the following environment variables:

  ```bash
  RPC_URL=your_ethereum_rpc_url
  PK=your_private_key
  ```



  - Python 3.7+
  - web3.py
  - python-socketio
  - python-dotenv
  - aiohttp



  Here's an example for depositing to the margin account. User needs margin account balance for limit orders.

  Note: The deposit amount is in wei

  ```python
  import asyncio
  import sys
  from pathlib import Path


  project_root = str(Path(__file__).parent.parent)
  sys.path.append(project_root)

  from web3 import Web3
  from kuru_sdk.margin import MarginAccount
  import os
  import json
  import argparse

  from dotenv import load_dotenv

  load_dotenv()

  from kuru_sdk.client import KuruClient


  NETWORK_RPC = os.getenv("RPC_URL")  # Replace with your network RPC
  ADDRESSES = {
      'margin_account': '0x33fa695D1B81b88638eEB0a1d69547Ca805b8949',
      'usdc': '0x9A29e9Bab1f0B599d1c6C39b60a79596b3875f56',
      'wbtc': '0x0000000000000000000000000000000000000000'
  }

  async def main():
      client = KuruClient(
          network_rpc=NETWORK_RPC,
          margin_account_address=ADDRESSES['margin_account'],
          private_key=os.getenv('PK')
      )

      
      await client.deposit(ADDRESSES['usdc'], 100000000000000000000000)

      print(await client.view_margin_balance(ADDRESSES['usdc']))


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

  ```

  Here's a complete example showing how to place orders with different transaction options:

  ```python
  import asyncio
  import os
  from decimal import Decimal
  from web3 import Web3
  from dotenv import load_dotenv

  from kuru_sdk import OrderExecutor, OrderRequest
  from kuru_sdk.orderbook import TxOptions


  load_dotenv()

  async def place_orders():
  async def place_limit_buy(client: KuruClient, price: str, size: str, post_only: bool = False, tx_options: TxOptions = TxOptions()):
      """Place a limit buy order"""

      print(f"Placing limit buy order: {size} units at {price}")

      order = OrderRequest(
          market_address=ADDRESSES['orderbook'],
          order_type='limit',
          side='buy',
          price=price,
          size=size,
          post_only=post_only
      )
      try:
          cloid = "mm_1
          print(f"Placing limit buy order: {size} units at {price}")
          tx_hash = await client.create_order(order, cloid)
          print(f"Transaction hash: {tx_hash}")
          return tx_hash
      except Exception as e:
          print(f"Error placing limit buy order: {str(e)}")
          return None

  if __name__ == "__main__":
      asyncio.run(place_orders())
  ```





  The main class for interacting with the orderbook. It handles order placement, WebSocket connections, and event tracking.

  ```python
  executor = OrderExecutor(
      web3=web3,
      contract_address='CONTRACT_ADDRESS',
      websocket_url='WS_URL',
      private_key='PRIVATE_KEY',  # Optional
      on_order_created=None,      # Optional callback
      on_trade=None,             # Optional callback
      on_order_cancelled=None    # Optional callback
  )
  ```



  ```python

  limit_order = OrderRequest(
      order_type="limit",
      side="buy",           # or "sell"
      price="179.1",        # Price in quote currency
      size="0.1",          # Size in base currency
      post_only=False      # Whether to ensure maker order
  )


  market_order = OrderRequest(
      order_type="market",
      side="buy",           # or "sell"
      size="0.1",
      min_amount_out="170", # Minimum amount to receive
      is_margin=False,      # Whether to use margin
      fill_or_kill=True    # Whether to require complete fill
  )
  ```



  You can customize transaction parameters using `TxOptions`:

  ```python

  tx_options = TxOptions(
      gas_limit=140000,
      gas_price=1000000000,  # 1 gwei
      max_priority_fee_per_gas=0
  )


  tx_options = TxOptions(
      gas_limit=140000,
      gas_price=1000000000,
      max_priority_fee_per_gas=0,
      nonce=web3.eth.get_transaction_count(address)
  )
  ```

  By using `TxOptions` tou can save 1-2 seconds in runtime.



  The SDK provides real-time order updates through WebSocket events:

  ```python
  async def on_order_created(event):
      print(f"Order created - ID: {event.orderId}")
      print(f"Size: {event.size}, Price: {event.price}")
      print(f"Transaction: {event.transactionHash}")

  async def on_trade(event):
      print(f"Trade executed for order {event.orderId}")
      print(f"Filled size: {event.filledSize} @ {event.price}")
      print(f"Maker: {event.makerAddress}")
      print(f"Taker: {event.takerAddress}")

  async def on_order_cancelled(event):
      print(f"Order {event.orderId} cancelled")

  client = KuruClient(
      network_rpc='RPC_URL',
      margin_account_address='MARGIN_ACCOUNT_ADDRESS',
      websocket_url='WS_URL',
      private_key='PRIVATE_KEY'
      on_order_created=on_order_created
      on_trade=on_trade
      on_order_cancelled=on_order_cancelled
  )
  ```



  The SDK handles WebSocket connections automatically, but you need to properly connect and disconnect:
  The client automatically connects to ws. But it has to be manually disabled

  ```python

  await client.disconnect()
  ```


pkgId: 375ef9a43c7d9644566095b185d52c439052bbb32c288d8cebd4f456094a99d5
name: python-kusho-capture-help
arch: noarch
version: 0.1.0
epoch: 0
release: 1
summary: Development documents and examples for kusho-capture
url: https://github.com/kusho-co/kusho-capture
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-kusho-capture-0.1.0-1.src.rpm
location_href: Packages/python-kusho-capture-help-0.1.0-1.noarch.rpm
checksum_type: sha256
description:
  Kusho-capture is a lightweight HTTP traffic capture middleware for Python web applications. It seamlessly integrates with popular frameworks like FastAPI, Flask, and Django to record API traffic for testing, debugging, and monitoring purposes.



  - 🔄 Automatic HTTP traffic capture for API endpoints
  - 🎯 Configurable URL pattern matching
  - 📦 Support for both WSGI and ASGI applications
  - 🔍 Detailed request/response logging
  - ⚡ Async support for modern web frameworks
  - 🎛️ Configurable sampling rate for high-traffic applications
  - 📊 Batch processing of captured events
  - 🚀 Framework auto-detection



  ```bash
  pip install kusho-capture
  ```

  For framework-specific dependencies:

  ```bash
  pip install kusho-capture[fastapi]  # For FastAPI support
  pip install kusho-capture[flask]    # For Flask support
  pip install kusho-capture[django]   # For Django support
  ```





  ```python
  from fastapi import FastAPI
  from kusho_capture import EventCollector, setup_traffic_capture

  app = FastAPI()
  collector = EventCollector(
      collector_url="https://your-collector-endpoint.com",
      sample_rate=0.1,
      batch_size=100
  )

  app = setup_traffic_capture(app, collector, framework="fastapi")

  @app.get("/api/items")
  async def get_items():
      return {"items": ["item1", "item2"]}
  ```



  ```python
  from flask import Flask
  from kusho_capture import EventCollector, setup_traffic_capture

  app = Flask(__name__)
  collector = EventCollector(
      collector_url="https://your-collector-endpoint.com",
      sample_rate=0.1,
      batch_size=100
  )

  app.wsgi_app = setup_traffic_capture(app.wsgi_app, collector, framework="flask")

  @app.route("/api/items")
  def get_items():
      return {"items": ["item1", "item2"]}
  ```



  ```python

  MIDDLEWARE = [
      'kusho_capture.WSGIMiddleware',
      
  ]


  from kusho_capture import EventCollector, setup_traffic_capture

  collector = EventCollector(
      collector_url="https://your-collector-endpoint.com",
      sample_rate=0.1,
      batch_size=100
  )

  application = setup_traffic_capture(application, collector, framework="django")
  ```





  - `collector_url`: URL of your event collection endpoint
  - `batch_size`: Number of events to batch before sending (default: 100)
  - `flush_interval`: Maximum time to wait before sending a batch in seconds (default: 60)
  - `max_queue_size`: Maximum number of events to queue (default: 10000)
  - `sample_rate`: Percentage of requests to capture (default: 0.1 = 10%)



  - `url_patterns`: List of URL patterns to match for capture (default: ['/api/'])
  - `framework`: Auto-detected by default, can be explicitly set to 'fastapi', 'flask', or 'django'



  Captured events include:
  - Timestamp
  - Request path and method
  - Request headers
  - Query parameters
  - Request body (for POST/PUT/PATCH requests)
  - Response status and headers
  - Response time



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



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


pkgId: 61a907393bcc5275ab5c9e15acc6920ba50a33448edb0a3ab65bb22ee49fff96
name: python-kvcommon-help
arch: noarch
version: 0.2.0
epoch: 0
release: 1
summary: Development documents and examples for kvcommon
url: https://github.com/RAVoigt/kvcommon
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-kvcommon-0.2.0-1.src.rpm
location_href: Packages/python-kvcommon-help-0.2.0-1.noarch.rpm
checksum_type: sha256
description:
  Library of miscellaneous common python utils that aren't worthy of their own dedicated libraries yet. Some of these packages will be moved out to their own libs later.

  This library isn't likely to be useful to anyone else; it's just a convenience to save me from copy/pasting between various projects I work on.


  https://pypi.org/project/kvcommon/



  `poetry add kvcommon`


  `pip install kvcommon`



  | Package | Description | Example Usage |
  |---|---|---|
  |`datastore`|An abstraction for a simple dictionary-based key-value datastore with support for schema versions and files as 'backends' (TOML, YAML, etc.)|#TODO|
  |`k8s`|Utils to reduce boilerplate when working with Kubernetes and GKE in Python|#TODO|
  |`logger`|Boilerplate wrapper to get logger with formatting|`from kvcommon import logger as LOG; LOG.get_logger("logger_name")`|
  |`misc`|Obligatory 'misc'
  |`types`|Miscellaneous utils for either converting types or type-hinting|`from kvcommon import types; types.to_bool("false")`|
  |`urls`|Convenience wrappers for URL parsing|`from kvcommon import types; types.to_bool("false")`|


pkgId: 611b133f81a04805fb55f3dadf5788e0b3c1ace2b1b0c8b7b4704343feb227c3
name: python-kwcoco-help
arch: noarch
version: 0.8.7
epoch: 0
release: 1
summary: Development documents and examples for kwcoco
url: https://gitlab.kitware.com/computer-vision/kwcoco
rpm_license: Apache 2
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-kwcoco-0.8.7-1.src.rpm
location_href: Packages/python-kwcoco-help-0.8.7-1.noarch.rpm
checksum_type: sha256
description:
  |GitlabCIPipeline| |GitlabCICoverage| |Appveyor| |Pypi| |PypiDownloads| |ReadTheDocs|
  +------------------+------------------------------------------------------------------------------------------------------------+
  | Read the docs    | https://kwcoco.readthedocs.io                                                                              |
  +------------------+------------------------------------------------------------------------------------------------------------+
  | Gitlab (main)    | https://gitlab.kitware.com/computer-vision/kwcoco                                                          |
  +------------------+------------------------------------------------------------------------------------------------------------+
  | Github (mirror)  | https://github.com/Kitware/kwcoco                                                                          |
  +------------------+------------------------------------------------------------------------------------------------------------+
  | Pypi             | https://pypi.org/project/kwcoco                                                                            |
  +------------------+------------------------------------------------------------------------------------------------------------+
  | Slides           | https://docs.google.com/presentation/d/1OqljzzaZdjzmMg9876J4wFOmdFlJsH2Lc8_7tcqAPUE/edit                   |
  +------------------+------------------------------------------------------------------------------------------------------------+
  | Blog             | https://www.kitware.com/introducing-kwcoco/                                                                |
  +------------------+------------------------------------------------------------------------------------------------------------+
  The main webpage for this project is: https://gitlab.kitware.com/computer-vision/kwcoco
  The kwcoco package is a Python module and command line utility for reading,
  writing, modifying, and interacting with computer vision datasets --- i.e.
  images or videos with raster or vector annotations. A dataset is defined using
  a json file or SQL database that points to assets that exist on disk or on the
  cloud. The Python API provides a way to efficiently load image data and
  associated metadata (e.g. for writing torch datasets). The command line
  application provides a way to quickly summarize, visualize, and perform common
  modifications (e.g. subset, union) on the data.
  The Kitware COCO module defines a variant of the Microsoft COCO format,
  originally developed for the "collected images in context" object detection
  challenge. We are backwards compatible with the original module, but we also
  have improved implementations in several places, including segmentations,
  keypoints, annotation tracks, multi-spectral images, and videos (which
  represents a generic sequence of images).
  A KWCOCO file is a "manifest" that serves as a single reference that points to
  all images, categories, and annotations in a computer vision dataset. Thus,
  when applying an algorithm to a dataset, it is sufficient to have the algorithm
  take one dataset parameter: the path to the KWCOCO file.  Generally a KWCOCO
  file will live in a "bundle" directory along with the data that it references,
  and paths in the KWCOCO file will be relative to the location of the KWCOCO
  file itself.
  The main data structure in this model is largely based on the implementation in
  https://github.com/cocodataset/cocoapi It uses the same efficient core indexing
  data structures, but in our implementation the indexing can be optionally
  turned off, functions are silent by default (with the exception of long running
  processes, which optionally show progress by default). We support helper
  functions that add and remove images, categories, and annotations.
  We have reimplemented the object detection scoring code in the ``kwcoco.metrics``
  submodule.
  The original ``pycocoutils`` API is exposed via the ``kwcoco.compat_dataset.COCO``
  class for drop-in replacement with existing tools that use ``pycocoutils``.
  There is some support for kw18 files in the ``kwcoco.kw18`` module.


pkgId: 20db170fbf94c6b26bda3897c8d92b3a6777e9b66940f522500e6168e04e5655
name: python-kwimage-help
arch: noarch
version: 0.11.2
epoch: 0
release: 1
summary: Development documents and examples for kwimage
url: https://gitlab.kitware.com/computer-vision/kwimage
rpm_license: Apache 2
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-kwimage-0.11.2-1.src.rpm
location_href: Packages/python-kwimage-help-0.11.2-1.noarch.rpm
checksum_type: sha256
description:
  |GitlabCIPipeline| |GitlabCICoverage| |Appveyor| |Pypi| |PypiDownloads| |ReadTheDocs|
  +------------------+-------------------------------------------------------+
  | Read the docs    | https://kwimage.readthedocs.io                        |
  +------------------+-------------------------------------------------------+
  | Gitlab (main)    | https://gitlab.kitware.com/computer-vision/kwimage    |
  +------------------+-------------------------------------------------------+
  | Github (mirror)  | https://github.com/Kitware/kwimage                    |
  +------------------+-------------------------------------------------------+
  | Pypi             | https://pypi.org/project/kwimage                      |
  +------------------+-------------------------------------------------------+
  The main webpage for this project is: https://gitlab.kitware.com/computer-vision/kwimage
  The ``kwimage`` module handles low-level image operations at a high level.
  The core ``kwimage`` is a functional library with image-related helper
  functions that are either unimplemented in or more have a more general
  interface then their opencv counterparts.
  The ``kwimage`` module builds on ``kwarray`` and provides tools commonly needed
  when addressing computer vision problems. This includes functions for reading
  images, resizing, image warp transformations, run-length-encoding, and
  non-maximum-suppression.
  The ``kwimage`` module is also the current home of my annotation data
  structures, which provide efficient ways to interoperate between different
  common annotation formats (e.g. different bounding box / polygon / point
  formats).  These data structures have both a ``.draw`` and ``.draw_on`` method
  for overlaying visualizations on matplotlib axes or numpy image matrices
  respectively.
  Read the docs at: http://kwimage.readthedocs.io/en/main/
  The top-level API is:
      from .algo import (available_nms_impls, daq_spatial_nms, non_max_supression,)
      from .im_alphablend import (ensure_alpha_channel, overlay_alpha_images,
                                  overlay_alpha_layers,)
      from .im_color import (Color,)
      from .im_core import (atleast_3channels, ensure_float01, ensure_uint255,
                            exactly_1channel, find_robust_normalizers,
                            make_channels_comparable, normalize, normalize_intensity,
                            num_channels, padded_slice,)
      from .im_cv2 import (connected_components, convert_colorspace, gaussian_blur,
                           gaussian_patch, imcrop, imresize, imscale, morphology,
                           warp_affine, warp_image, warp_projective,)
      from .im_demodata import (checkerboard, grab_test_image,
                                grab_test_image_fpath,)
      from .im_draw import (draw_boxes_on_image, draw_clf_on_image, draw_header_text,
                            draw_line_segments_on_image, draw_text_on_image,
                            draw_vector_field, fill_nans_with_checkers,
                            make_heatmask, make_orimask, make_vector_field,
                            nodata_checkerboard,)
      from .im_filter import (fourier_mask, radial_fourier_mask,)
      from .im_io import (imread, imwrite, load_image_shape,)
      from .im_runlen import (decode_run_length, encode_run_length, rle_translate,)
      from .im_stack import (stack_images, stack_images_grid,)
      from .structs import (Box, Boxes, Coords, Detections, Heatmap, Mask, MaskList,
                            MultiPolygon, Points, PointsList, Polygon, PolygonList,
                            Segmentation, SegmentationList, smooth_prob,)
      from .transform import (Affine, Linear, Matrix, Projective, Transform,)
      from .util_warp import (add_homog, remove_homog, subpixel_accum,
                              subpixel_align, subpixel_getvalue, subpixel_maximum,
                              subpixel_minimum, subpixel_set, subpixel_setvalue,
                              subpixel_slice, subpixel_translate, warp_points,
                              warp_tensor,)
  NOTE: THE KWIMAGE STRUCTS MAY? EVENTUALLY MOVE TO THE KWANNOT REPO
  (But this transition might take awhile)
  The most notable feature of the ``kwimage`` module are the ``kwimage.structs``
  objects. This includes the primitive ``Boxes``, ``Mask``, and ``Coords`` objects, The
  semi-primitive ``Points``, ``Polygon`` structures, and the composite ``Heatmap`` and
  ``Detections`` structures (note: ``Heatmap`` is just a composite of array-like
  structures).
  The primitive and semi-primitive objects store and manipulate annotation
  geometry, and the composite structures combine primitives into a single
  object that jointly manipulates the primitives using ``warp`` operations.
  The ``Detections`` structure is a meta-structure that associates the other more
  primitive components, and allows a developer to compose them into something
  that represents objects of interest.  The details of this composition are left
  up to the end-application.
  The ``Detections`` object can also be "rasterized" and converted into a ``Heatmap``
  object, which represents the same information, but is in a form that is more
  suitable for use when training convolutional neural networks. Likewise, the
  output of neural networks can be directly encoded in a ``kwimage.Heatmap``
  object. The ``Heatmap.detect`` method can then be used to convert the dense
  heatmap representation into a spare ``Detections`` representation that is more
  suitable for use in an object-detection system. We note that the ``detect``
  function is not a special detection algorithm. The detection algorithm (which
  is outside the scope of kwimage) produces the heatmap, and the ``detect`` method
  effectively "inverts" the ``rasterize`` procedure of ``Detections`` by finding
  peaks in the heatmap, and running non-maximum suppression.
  This module contains data structures for three image annotation primitives:
      * Boxes  # technically this could be made out of Coords, probably not for efficiency and decoupling
      * Mask   # likewise this could be renamed to Raster
      * Coords #
  These primative structures are used to define these metadata-containing composites:
      * Detections
      * Polygon
      * Heatmap
      * MultiPolygon
      * PolygonList
      * MaskList
  All of these structures have a ``self.data`` attribute that holds a pointer to
  the underlying data representation.
  Some of these structures have a ``self.format`` attribute describing the
  underlying data representation.
  Most of the composite structures also have a ``self.meta`` attribute, which
  holds user-level metadata (e.g. info about the classes).


pkgId: 56c4f0653c02fda593a80cedeba2456f628df981ae7ed17c5a99df0f895af0f5
name: python-kyoslib_py-help
arch: noarch
version: 5.3.0
epoch: 0
release: 1
summary: Development documents and examples for kyoslib_py
url: http://github.com/kyosenergy/kyoslib_py
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-kyoslib_py-5.3.0-1.src.rpm
location_href: Packages/python-kyoslib_py-help-5.3.0-1.noarch.rpm
checksum_type: sha256
description:
  Example code:

  ```python
  from kyoslib_py.simulation import Simulation
  simulation_set = Simulation()
  ```



  ```pip install kyoslib_py```



  Python 3.11+



  This project is executing CI checks using **GitHub actions**.

  It will run `pytest` and `black`.



  [Invoke](https://www.pyinvoke.org/) is used for development tasks.

  Tasks are stored in `tasks.py` and are executable using the `inv[oke]` command line tool.

  To see the list of tasks, you can type:

  ```bash
  inv --list
  ```

  For example, before your commits, you should run
  ```bash
  inv format
  ```
  to format your code.



  The package documentation is generated by MkDocs. The correct version can be installed in the project's virtual environment by:

  ```bash
  poetry install
  ```

  Then the documentation can be built, and a server to view it started by:

  ```bash
  mkdocs serve
  ```


pkgId: ec591a3b84379d5663771865756b15f19c04caf7614319150ffcc99c8d7e4177
name: python-l2m2-help
arch: noarch
version: 0.0.39
epoch: 0
release: 1
summary: Development documents and examples for l2m2
url: https://github.com/pkelaita/l2m2
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-l2m2-0.0.39-1.src.rpm
location_href: Packages/python-l2m2-help-0.0.39-1.noarch.rpm
checksum_type: sha256
description:
  [![Tests](https://github.com/pkelaita/l2m2/actions/workflows/tests.yml/badge.svg?timestamp=1734477367)](https://github.com/pkelaita/l2m2/actions/workflows/tests.yml) [![codecov](https://codecov.io/github/pkelaita/l2m2/graph/badge.svg?token=UWIB0L9PR8)](https://codecov.io/github/pkelaita/l2m2) [![PyPI version](https://badge.fury.io/py/l2m2.svg?timestamp=1734477367)](https://badge.fury.io/py/l2m2)

  **L2M2** ("LLM Manager" &rarr; "LLMM" &rarr; "L2M2") is a tiny and very simple LLM manager for Python that exposes lots of models through a unified API. This is useful for evaluation, demos, production applications etc. that need to easily be model-agnostic.

  ![](assets/l2m2_demo.gif)



  - <!--start-count-->31<!--end-count--> supported models (see below) – regularly updated and with more on the way.
  - Session chat memory – even across multiple models or with concurrent memory streams.
  - JSON mode
  - Prompt loading tools



  - **Simple:** Completely unified interface – just swap out the model name.
  - **Tiny:** Only two external dependencies (httpx and typing_extensions).
  - **Fast**: Fully asynchronous if concurrent calls are needed.



  L2M2 currently supports the following models:

  <!--start-model-table-->

  | Model Name            | Provider(s)                                                                   | Model Version(s)                                    |
  | --------------------- | ----------------------------------------------------------------------------- | --------------------------------------------------- |
  | `gpt-4o`              | [OpenAI](https://openai.com/api/)                                             | `gpt-4o-2024-11-20`                                 |
  | `gpt-4o-mini`         | [OpenAI](https://openai.com/api/)                                             | `gpt-4o-mini-2024-07-18`                            |
  | `o1`                  | [OpenAI](https://openai.com/api/)                                             | `o1`                                                |
  | `o1-preview`          | [OpenAI](https://openai.com/api/)                                             | `o1-preview`                                        |
  | `o1-mini`             | [OpenAI](https://openai.com/api/)                                             | `o1-mini`                                           |
  | `gpt-4-turbo`         | [OpenAI](https://openai.com/api/)                                             | `gpt-4-turbo-2024-04-09`                            |
  | `gpt-3.5-turbo`       | [OpenAI](https://openai.com/api/)                                             | `gpt-3.5-turbo-0125`                                |
  | `gemini-2.0-flash`    | [Google](https://ai.google.dev/)                                              | `gemini-2.0-flash-exp`                              |
  | `gemini-1.5-flash`    | [Google](https://ai.google.dev/)                                              | `gemini-1.5-flash`                                  |
  | `gemini-1.5-flash-8b` | [Google](https://ai.google.dev/)                                              | `gemini-1.5-flash-8b`                               |
  | `gemini-1.5-pro`      | [Google](https://ai.google.dev/)                                              | `gemini-1.5-pro`                                    |
  | `claude-3.5-sonnet`   | [Anthropic](https://www.anthropic.com/api)                                    | `claude-3-5-sonnet-latest`                          |
  | `claude-3.5-haiku`    | [Anthropic](https://www.anthropic.com/api)                                    | `claude-3-5-haiku-latest`                           |
  | `claude-3-opus`       | [Anthropic](https://www.anthropic.com/api)                                    | `claude-3-opus-20240229`                            |
  | `claude-3-sonnet`     | [Anthropic](https://www.anthropic.com/api)                                    | `claude-3-sonnet-20240229`                          |
  | `claude-3-haiku`      | [Anthropic](https://www.anthropic.com/api)                                    | `claude-3-haiku-20240307`                           |
  | `command-r`           | [Cohere](https://docs.cohere.com/)                                            | `command-r`                                         |
  | `command-r-plus`      | [Cohere](https://docs.cohere.com/)                                            | `command-r-plus`                                    |
  | `mistral-large`       | [Mistral](https://docs.mistral.ai/deployment/laplateforme/overview/)          | `mistral-large-latest`                              |
  | `ministral-3b`        | [Mistral](https://docs.mistral.ai/deployment/laplateforme/overview/)          | `ministral-3b-latest`                               |
  | `ministral-8b`        | [Mistral](https://docs.mistral.ai/deployment/laplateforme/overview/)          | `ministral-8b-latest`                               |
  | `mistral-small`       | [Mistral](https://docs.mistral.ai/deployment/laplateforme/overview/)          | `mistral-small-latest`                              |
  | `mixtral-8x7b`        | [Groq](https://wow.groq.com/)                                                 | `mixtral-8x7b-32768`                                |
  | `gemma-2-9b`          | [Groq](https://wow.groq.com/)                                                 | `gemma2-9b-it`                                      |
  | `llama-3-8b`          | [Groq](https://wow.groq.com/), [Replicate](https://replicate.com/)            | `llama3-8b-8192`, `meta/meta-llama-3-8b-instruct`   |
  | `llama-3-70b`         | [Groq](https://wow.groq.com/), [Replicate](https://replicate.com/)            | `llama3-70b-8192`, `meta/meta-llama-3-70b-instruct` |
  | `llama-3.1-8b`        | [Groq](https://wow.groq.com/), [Cerebras](https://inference-docs.cerebras.ai) | `llama-3.1-8b-instant`, `llama3.1-8b`               |
  | `llama-3.1-405b`      | [Replicate](https://replicate.com/)                                           | `meta/meta-llama-3.1-405b-instruct`                 |
  | `llama-3.2-1b`        | [Groq](https://wow.groq.com/)                                                 | `llama-3.2-1b-preview`                              |
  | `llama-3.2-3b`        | [Groq](https://wow.groq.com/)                                                 | `llama-3.2-3b-preview`                              |
  | `llama-3.3-70b`       | [Groq](https://wow.groq.com/), [Cerebras](https://inference-docs.cerebras.ai) | `llama-3.3-70b-versatile`, `llama3.3-70b`           |

  <!--end-model-table-->



  - [Requirements](#requirements)
  - [Installation](#installation)
  - **Usage**
    - [Basic Usage](#usage)
    - [Multi-Provider Models](#multi-provider-models)
    - **Memory**
      - [Chat Memory](#memory)
      - [External Memory](#external-memory)
    - [Async Calls](#async-calls)
    - **Tools**
      - [JSON Mode](#tools-json-mode)
      - [Prompt Loader](#tools-prompt-loader)
  - [Other Capabilities](#other-capabilities)
  - [Planned Features](#planned-features)
  - [Contributing](#contributing)
  - [Contact](#contact)



  - Python >= 3.9
  - At least one valid API key for a supported provider



  ```
  pip install l2m2
  ```



  **Import the LLM Client**

  ```python
  from l2m2.client import LLMClient

  client = LLMClient()
  ```

  **Activate Providers**

  To activate any of the providers, set the provider's API key in the corresponding environment variable shown below, and L2M2 will read it in to activate the provider.

  | Provider                | Environment Variable  |
  | ----------------------- | --------------------- |
  | OpenAI                  | `OPENAI_API_KEY`      |
  | Anthropic               | `ANTHROPIC_API_KEY`   |
  | Cohere                  | `CO_API_KEY`          |
  | Google                  | `GOOGLE_API_KEY`      |
  | Groq                    | `GROQ_API_KEY`        |
  | Replicate               | `REPLICATE_API_TOKEN` |
  | Mistral (La Plateforme) | `MISTRAL_API_KEY`     |
  | Cerebras                | `CEREBRAS_API_KEY`    |

  Additionally, you can activate providers programmatically as follows:

  ```python
  client = LLMClient(providers={
      "provider-a": "api-key-a",
      "provider-b": "api-key-b",
      ...
  })


  client.add_provider("provider-c", "api-key-c")
  ```

  **Call your LLM 💬👍**

  The `call` API is the same regardless of model or provider.

  ```python
  response = client.call(
      model="<model name>",
      prompt="<prompt>",
  )
  ```

  `model` and `prompt` are required, while `system_prompt`, `temperature`, and `max_tokens` are optional. When possible, L2M2 uses the provider's default model parameter values when they are not given.

  ```python
  response = client.call(
      model="<model name>",
      prompt="<prompt>",
      system_prompt="<system prompt>",
      temperature=<temperature>,
      max_tokens=<max tokens>,
  )
  ```



  ```python


  from l2m2.client import LLMClient

  client = LLMClient()

  response = client.call(
      model="gpt-4o",
      prompt="How's the weather today?",
      system_prompt="Respond as if you were a pirate.",
  )

  print(response)
  ```

  ```
  >> python3 example.py

  Arrr, matey! The skies be clear as the Caribbean waters today, with the sun blazin' high 'bove us. A fine day fer settin' sail and huntin' fer treasure, it be. But keep yer eye on the horizon, for the weather can turn quicker than a sloop in a squall. Yarrr!
  ```



  Some models are available from multiple providers, such as `llama-3-70b` from both Groq and Replicate. When multiple of such providers are active, you can use the parameter `prefer_provider` to specify which provider to use for a given inference.

  ```python
  response1 = client.call(
      model="llama-3-70b",
      prompt="Hello there",
      prefer_provider="groq",
  ) # Uses Groq

  response2 = client.call(
      model="llama-3-70b",
      prompt="General Kenobi!",
      prefer_provider="replicate",
  ) # Uses Replicate
  ```

  You can also set default preferred providers for the client using `set_preferred_providers`, to avoid having to specify `prefer_provider` for each call.

  ```python
  client.set_preferred_providers({
      "llama-3-70b": "groq",
      "llama-3-8b": "replicate",
  })

  response1 = client.call(model="llama-3-70b", prompt="Hello there") # Uses Groq
  response2 = client.call(model="llama-3-8b", prompt="General Kenobi!") # Uses Replicate
  ```



  L2M2 provides a simple memory system that allows you to maintain context and history across multiple calls and multiple models. There are two types of memory: **`ChatMemory`**, which natively hooks into models' conversation history, and **`ExternalMemory`**, which allows for custom memory implementations. Let's first take a look at `ChatMemory`.

  ```python
  from l2m2.client import LLMClient
  from l2m2.memory import ChatMemory

  client = LLMClient(memory=ChatMemory())

  print(client.call(model="gpt-4o", prompt="My name is Pierce"))
  print(client.call(model="claude-3-haiku", prompt="I am a software engineer."))
  print(client.call(model="llama-3-8b", prompt="What's my name?"))
  print(client.call(model="mixtral-8x7b", prompt="What's my job?"))
  ```

  ```
  Hello, Pierce! How can I help you today?
  A software engineer, you say? That's a noble profession.
  Your name is Pierce.
  You are a software engineer.
  ```

  Chat memory is stored per session, with a sliding window of messages which defaults to the last 40 – this can be configured by passing `memory_window_size` to the client constructor.

  For more control, you can instantiate a `ChatMemory` object on its own and manipulate it directly.

  ```python
  memory = ChatMemory()

  memory.add_user_message("My favorite color is red.")
  memory.add_user_message("My least favorite color is green.")
  memory.add_agent_message("Ok, noted.")

  client = LLMClient(memory=memory)
  print(client.call(model="gpt-4o", prompt="What are my favorite and least favorite colors?"))
  memory.clear()
  print(client.call(model="gpt-4o", prompt="What are my favorite and least favorite colors?"))
  ```

  ```
  Your favorite color is red, and your least favorite color is green.
  I'm sorry, I don't have that information.
  ```

  > [!CAUTION]
  > Some providers such as Anthropic enforce that chat messages in memory strictly alternate between one user and one agent message and will throw an error if this is not the case.

  You can also load in alternate memory streams on the fly using the `alt_memory` parameter in `call` (This is especially useful for parallel memory streams – an example of this is shown in the [Async Calls](#async-calls) section).

  ```python
  m1 = ChatMemory()
  m1.add_user_message("My favorite color is red.")
  m1.add_user_message("My least favorite color is green.")
  m1.add_agent_message("Ok, noted.")

  m2 = ChatMemory()
  m2.add_user_message("My favorite color is blue.")
  m2.add_user_message("My least favorite color is yellow.")
  m2.add_agent_message("Got it.")

  client = LLMClient(memory=m1)
  prompt = "What are my favorite and least favorite colors?"
  print(client.call(model="gpt-4o", prompt=prompt)
  print(client.call(model="gpt-4o", prompt=prompt, alt_memory=m2))
  ```

  ```
  Your favorite color is red, and your least favorite color is green.
  Your favorite color is blue, and your least favorite color is yellow.
  ```

  Finally, memory can be bypassed for a single call by passing `bypass_memory=True` to `call`. This will cause the client to ignore previously stored memory and not write to it for the current call.

  ```python
  client = LLMClient(memory=ChatMemory())
  client.call(model="gpt-4o", prompt="My name is Pierce")
  client.call(model="gpt-4o", prompt="I am 25 years old")

  print(client.call(model="gpt-4o", prompt="What is my name?"))
  print(client.call(model="gpt-4o", prompt="What is my name?", bypass_memory=True))

  client.call(model="gpt-4o", prompt="I am a software engineer", bypass_memory=True)
  print(client.call(model="gpt-4o", prompt="What is my profession?"))
  ```

  ```
  Your name is Pierce.
  I'm sorry, but I don't have access to personal information, so I can't know your name.
  You haven't mentioned your profession yet, Pierce.
  ```



  **`ExternalMemory`** is a simple but powerful memory mode that allows you to define your own memory implementation. This can be useful for more complex memory constructions (e.g., planning, reflecting) or for implementing custom persistence (e.g., saving memory to a database or a file). Its usage is much like `ChatMemory`, but unlike `ChatMemory` you must manage initializing and updating the memory yourself with `get_contents` and `set_contents`.

  Here's a simple example of a custom memory implementation that has a description and a list of previous user/model message pairs:

  ```python


  from l2m2.client import LLMClient
  from l2m2.memory import ExternalMemory

  client = LLMClient(memory=ExternalMemory())

  messages = [
      "My name is Pierce",
      "I am a software engineer",
      "What is my name?",
      "What is my profession?",
  ]

  def update_memory(user_input, model_output):
      memory = client.get_memory() # ExternalMemory object
      contents = memory.get_contents()
      if contents == "":
          contents = "You are mid-conversation with me. Your memory of it is below:\n\n"
      contents += f"Me: {user_input}\nYou: {model_output}\n"
      memory.set_contents(contents)

  for message in messages:
      response = client.call(model="gpt-4o", prompt=message)
      print(response)
      update_memory(message, response)
  ```

  ```
  >> python3 example_external_memory.py

  Nice to meet you, Pierce!
  Nice! What kind of projects do you work on?
  Your name is Pierce.
  You are a software engineer.
  ```

  By default, `ExternalMemory` contents are appended to the system prompt, or passed in as the system prompt if one is not given. Generally, models perform best when external memory is stored in the system prompt; however, you can configure the client to append the memory contents to the user prompt instead as follows:

  ```python
  from l2m2.memory import ExternalMemoryLoadingType

  memory = ExternalMemory(loading_type=ExternalMemoryLoadingType.USER_PROMPT_APPEND)
  client = LLMClient(memory=memory)
  ```

  Similarly to `ChatMemory`, `ExternalMemory` can be passed into `alt_memory` and bypassed with `bypass_memory`.



  L2M2 provides an asynchronous `AsyncLLMClient` in addition to the synchronous `LLMClient`. Its usage is identical to the synchronous client, but it's instantiated using `async with` and is called using `await`.

  ```python
  from l2m2.client import AsyncLLMClient

  async def main():
      async with AsyncLLMClient() as client:
          response = await client.call(
              model="model",
              prompt="prompt",
              system_prompt="system prompt",
              
          )
  ```

  Under the hood, each `AsyncLLMClient` manages its own async http client, so calls are non-blocking. Here's an example of using the `AsyncLLMClient` to make concurrent calls to multiple models and measure the inference times:

  ```python


  import os
  import asyncio
  import timeit
  from l2m2.client import AsyncLLMClient

  async def call_concurrent():
      async with AsyncLLMClient() as client:
          
          calls = [
              ("gpt-4o", "foo"),
              ("claude-3.5-sonnet", "bar"),
              ("gemini-1.5-pro", "baz"),
              ("command-r-plus", "qux"),
              ("llama-3-70b", "quux"),
              ("mixtral-8x7b", "corge"),
          ]
          system_prompt = "The secret word is {}"

          async def call_and_print(model, secret_word):
              start_time = timeit.default_timer()
              response = await client.call(
                  model=model,
                  prompt="What is the secret word? Respond briefly.",
                  system_prompt=system_prompt.format(secret_word),
                  temperature=0.2,
              )
              time = timeit.default_timer() - start_time
              print(f"{model}: {response} ({time:.2f}s)")

          await asyncio.gather(
              *[call_and_print(model, secret_word) for model, secret_word in calls]
          )

  asyncio.run(call_concurrent())
  ```

  ```
  >> python3 example_async.py

  llama-3-70b: The secret word is quux. (0.21s)
  mixtral-8x7b: The secret word is corge. (0.26s)
  gpt-4o: foo (0.62s)
  command-r-plus: The secret word is qux. (0.66s)
  claude-3.5-sonnet: The secret word is bar. (0.70s)
  gemini-1.5-pro: baz (0.73s)
  ```

  As a general rule, I typically find it's best to use the synchronous `LLMClient` for research and demos, and `AsyncLLMClient` for apps.



  One of the most powerful features of `AsyncLLMClient` is the ability to run maintain memory streams in parallel, such as in multi-agent systems with multiple interactions happening concurrently. Here's a simple example of how to easily achieve this using `AsyncLLMClient` and `alt_memory`.

  ```python


  import asyncio
  from l2m2.client import AsyncLLMClient
  from l2m2.memory import ChatMemory

  async def call_concurrent_with_memory():
      m1 = ChatMemory()
      m2 = ChatMemory()

      calls1 = ["My name is Pierce", "My favorite color is red", "I am 25 years old"]
      calls2 = ["My name is Paul", "My favorite color is blue", "I am 60 years old"]
      question = "What is my name, favorite color, and age?"

      async with AsyncLLMClient() as client:
          client.set_preferred_providers({"mixtral-8x7b": "groq"})

          async def make_calls_1():
              for prompt in calls1:
                  await client.call(model="mixtral-8x7b", prompt=prompt, alt_memory=m1)

          async def make_calls_2():
              for prompt in calls2:
                  await client.call(model="mixtral-8x7b", prompt=prompt, alt_memory=m2)

          await asyncio.gather(make_calls_1(), make_calls_2())

          [res1, res2] = await asyncio.gather(
              client.call(model="mixtral-8x7b", prompt=question, alt_memory=m1),
              client.call(model="mixtral-8x7b", prompt=question, alt_memory=m2),
          )

          print("Memory 1:", res1)
          print("Memory 2:", res2)

  asyncio.run(call_concurrent_with_memory())
  ```

  ```
  >> python3 example_parallel_memory.py

  Memory 1: Your name is Pierce, your favorite color is red, and you are 25 years old. I hope this information is helpful!
  Memory 2: Your name is Paul, your favorite color is blue, and you are 60 years old. 😊
  ```



  L2M2 provides an optional `json_mode` flag that enforces JSON formatting on LLM responses. Importantly, this flag is applicable to all models and providers, whether or not they natively support JSON output enforcement. When JSON mode is not natively supported, `json_mode` will apply strategies to maximize the likelihood of valid JSON output.

  ```python


  response = client.call(
      model="gpt-4o",
      prompt="What are the capitals of each state of Australia?",
      system_prompt="Respond with the JSON format {'region': 'capital'}",
      json_mode=True,
  )

  print(response)
  ```

  ```
  >> python3 example_json_mode.py

  {
    "New South Wales": "Sydney",
    "Victoria": "Melbourne",
    "Queensland": "Brisbane",
    "South Australia": "Adelaide",
    "Western Australia": "Perth",
    "Tasmania": "Hobart",
    "Northern Territory": "Darwin",
    "Australian Capital Territory": "Canberra"
  }
  ```

  > [!IMPORTANT]
  > Regardless of the model and even when `json_mode` is enabled, it's crucial to ensure that either the prompt or the system prompt mentions to return the output in JSON - and ideally, to specify the JSON format, as shown above.

  The following models natively support JSON mode via the given provider:

  <!--start-json-native-->

  - `gpt-4o` (via Openai)
  - `gpt-4o-mini` (via Openai)
  - `gpt-4-turbo` (via Openai)
  - `gpt-3.5-turbo` (via Openai)
  - `gemini-2.0-flash` (via Google)
  - `gemini-1.5-flash` (via Google)
  - `gemini-1.5-flash-8b` (via Google)
  - `gemini-1.5-pro` (via Google)
  - `mistral-large` (via Mistral)
  - `ministral-3b` (via Mistral)
  - `ministral-8b` (via Mistral)
  - `mistral-small` (via Mistral)

  <!--end-json-native-->



  For models that do not natively support JSON mode, L2M2 will attempt to enforce JSON formatting by applying one of the following two strategies under the hood:

  1. **Strip**: This is usually the default strategy. It will attempt to extract the JSON from the response by searching for the first instance of `{` and the last instance of `}` in the response, and returning the between substring (inclusive). If no JSON is found, the response will be returned as-is.
  2. **Prepend**: This strategy will attempt to enforce a valid JSON output by inserting a message ending with an opening `{` from the model into the conversation just after the user prompt and just before the model response, and re-prepending the opening `{` to the model response. By default this message is `"Here is the JSON output:"`, but can be customized. More information is available on this strategy [here](https://github.com/anthropics/anthropic-cookbook/blob/main/misc/how_to_enable_json_mode.ipynb). Importantly, the **Prepend** strategy is available whether or not memory is enabled, and will not interfere with memory.

  If you'd like, you can specify a strategy by passing either `JsonModeStrategy.strip()` or `JsonModeStrategy.prepend()` to the `json_mode_strategy` parameter in `call`. If no strategy is given, L2M2 defaults to **Strip** for all models except for Anthropic's models, which will default to **Prepend** (more on this below).

  ```python


  from l2m2.client import LLMClient
  from l2m2.tools import JsonModeStrategy

  client = LLMClient()

  response = client.call(
      model="claude-3-sonnet",
      prompt="What are the capitals of each Canadian province?",
      system_prompt="Respond with the JSON format {'region': 'capital'}",
      json_mode=True,
      json_mode_strategy=JsonModeStrategy.prepend(),
  )

  print(response)
  ```

  ```
  >> python3 example_json_mode.py

  {
    "Alberta": "Edmonton",
    "British Columbia": "Victoria",
    "Manitoba": "Winnipeg",
    "New Brunswick": "Fredericton",
    "Newfoundland and Labrador": "St. John's",
    "Nova Scotia": "Halifax",
    "Ontario": "Toronto",
    "Prince Edward Island": "Charlottetown",
    "Quebec": "Quebec City",
    "Saskatchewan": "Regina"
  }
  ```

  If using prepend, you can customize the message that gets prepended to the opening `{` by passing `custom_prefix` as follows:

  ```python

  response = client.call(
      model="claude-3-sonnet",
      prompt="What are the capitals of each Canadian province?",
      system_prompt="Respond with the JSON format {'region': 'capital'}",
      json_mode=True,
      json_mode_strategy=JsonModeStrategy.prepend(custom_prefix="Here is the JSON with provinces and capitals:"),
  )
  ```

  Ideally, this wouldn't change anything on the output – just under the hood – but this is useful for working with foreign languages, etc.

  > [!TIP]
  > As mentioned above, L2M2 defaults to **prepend** for Anthropic models and **strip** for all others. I _highly_ recommend sticking with these defaults, especially with Anthropic's models. From my personal testing, valid JSON is almost always produced when using prepend with Anthropic's models and almost never produced with strip, and vice versa for other models. I'll gather rigorous data on this eventually, but if anyone has any insights, please let me know!



  L2M2 provides an optional prompt-loading utility that's useful for loading prompts with variables from a file. Usage is simple:

  _prompt.txt_

  ```
  Your name is {{name}} and you are a {{profession}}.
  ```

  ```python


  from l2m2.tools import PromptLoader

  loader = PromptLoader()
  prompt = loader.load_prompt(
      prompt_file="prompt.txt",
      variables={"name": "Pierce", "profession": "software engineer"},
  )
  print(prompt)
  ```

  ```
  >> python3 example_prompt_loader.py

  Your name is Pierce and you are a software engineer.
  ```

  The default variable delimiters are `{{` and `}}`. You can also optionally specify a prompt directory or customize the variable delimiters if needed.

  _path/to/prompts/prompt.txt_

  ```
  Your name is <<name>> and you are a <<profession>>.
  ```

  ```python


  from l2m2.tools import PromptLoader

  loader = PromptLoader(
      prompts_base_dir="path/to/prompts",
      variable_delimiters=("<<", ">>"),
  )
  prompt = loader.load_prompt(
      prompt_file="prompt.txt",
      variables={"name": "Pierce", "profession": "software engineer"},
  )
  print(prompt)
  ```

  ```
  >> python3 example_prompt_loader.py

  Your name is Pierce and you are a software engineer.
  ```





  If you'd like to call a language model from one of the supported providers that isn't officially supported by L2M2 (for example, older models such as `gpt-4-0125-preview`), you can similarly `call_custom` with the additional required parameter `provider`, and pass in the model name expected by the provider's API. Unlike `call`, `call_custom` doesn't guarantee correctness or well-defined behavior.

  ```python
  response = client.call_custom(
      provider="<provider name>",
      model_id="<model id for given provider>",
      prompt="<prompt>",
      ...
  )
  ```



  You can pass in extra parameters to the provider's API (For example, [reasoning_effort](https://platform.openai.com/docs/api-reference/chat/create#chat-create-reasoning_effort) on OpenAI's o1 series) by passing in the `extra_params` parameter to `call` or `call_custom`. These parameters are passed in as a dictionary of key-value pairs, where the values are of type `str`, `int`, or `float`. Similarly, using `extra_params` does not guarantee correctness or well-defined behavior, and you should refer to the provider's documentation for correct usage.

  ```python
  response = client.call(
      model="<model name>",
      prompt="<prompt>",
      extra_params={"foo": "bar", "baz": 123},
      ...
  )
  ```



  - Support for structured outputs where available (Just OpenAI as far as I know)
  - Support for OSS and self-hosted (Hugging Face, Ollama, Gpt4all, etc.)
  - Support for batch APIs where available (OpenAI, Anthropic, etc.)
  - Basic (i.e., customizable & non-opinionated) agent & multi-agent system features
  - Tools for common application workflows: RAG, prompt management, search, etc.
  - Support for streaming responses
  - ...etc.



  Contributions are welcome! Please see the below contribution guide.

  - **Requirements**
    - Python >= 3.13
    - [GNU Make](https://www.gnu.org/software/make/)
  - **Setup**
    - Clone this repository and create a Python virtual environment.
    - Install dependencies: `make init`.
    - Create a feature branch and an [issue](https://github.com/pkelaita/l2m2/issues) with a description of the feature or bug fix.
  - **Develop**
    - Run lint, typecheck and tests: `make` (`make lint`, `make typecheck`, and `make test` can also be run individually).
    - Generate test coverage: `make coverage`.
    - If you've updated the supported models, run `make update-readme` to reflect those changes in the README.
  - **Integration Test**
    - `cd` into `integration_tests`.
    - Create a `.env` file with your API keys, and copy `itests.example.py` to `itests.py`.
    - Write your integration tests in `itests.py`.
    - Run locally with `python itests.py -l`.
      - _Note: make sure to pass the `-l` flag or else it will look for an L2M2 distribution. Additionally, make sure l2m2 is not installed with pip when running the integration tests locally._
    - Once your changes are ready, from the top-level directory run `make build` to create the distribution and `make itest` to run your integration tests against the distribution.
      - _Note: in order to ensure a clean test environment, `make itest` uninstalls all third-party Python packages before running the tests, so make sure to run `make init` when you're done working on integration tests._
  - **Contribute**
    - Create a PR and ping me for a review.
    - Merge!



  If you have requests, suggestions, or any other questions about l2m2 please shoot me a note at [pierce@kelaita.com](mailto:pierce@kelaita.com), open an issue on the [Github repo](https://github.com/pkelaita/l2m2/issues), or DM me on the GenAI Collective [Slack Channel](https://join.slack.com/t/genai-collective/shared_invite/zt-285qq7joi-~bqHwFZcNtqntoRmGirAfQ).

rpm_license:
  MIT License  Copyright (c) 2024 Pierce Kelaita  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: c24e453b5a59dfc9d5d37c348403e72a4d3e97816b64698a698ab28c0a36cb34
name: python-l2winddir-help
arch: noarch
version: 0.0.2
epoch: 0
release: 1
summary: Development documents and examples for l2winddir
url: https://pypi.org/project/l2winddir/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-l2winddir-0.0.2-1.src.rpm
location_href: Packages/python-l2winddir-help-0.0.2-1.noarch.rpm
checksum_type: sha256
description:
  This repository provides tools for predicting wind direction and estimating uncertainty from SAR images acquired by Sentinel-1 (S1), RADARSAT Constellation Mission (RCM), and RADARSAT-2 (RS2) satellites. It utilizes a trained machine learning model built with PyTorch Lightning and Hydra-Zen



  - Prediction Pipeline: Load trained models and make predictions on new data.

  - Hydra-Zen Integration: Flexible configuration management.

  - Output Options: Generate predictions as a pandas DataFrame or an xarray Dataset.

  - Uncertainty Estimation: Predict both wind direction and associated uncertainty.

  - Georeferencing Support: Adjust predictions for geographical reference using dataset metadata.




  ```bash
  git clone https://github.com/jean2262/l2winddir.git
  cd l2winddir
  ```





  Run predictions using the predict.py script:

  ```bash
  python predict.py --model_path <path_to_model> --data_path <path_to_data> --eval <True/False>
  ```

  - Arguments:

      - ```--model_path```: Path to the trained model's directory.

      - ```--data_path```: Path to the data file (NetCDF or xarray-compatible format).

      - ```--eval```: If True, outputs a pandas DataFrame; otherwise, modifies and returns the input xarray Dataset.




  ```bash
  python predict.py --model_path "/path/to/model" --data_path "/path/to/dataset.nc" --eval True
  ```



  You can use the make_prediction function directly in Python scripts:
  ```python
  from predict import make_prediction

  model_path = "/path/to/model"
  data_path = "/path/to/dataset.nc"
  result = make_prediction(model_path=model_path, data_path=data_path, eval=True)

  print(result)
  ```



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


pkgId: eba328258ba29293c00638e7a21b689066a73ec7674728088d49dc9793de3df0
name: python-lab-control-help
arch: noarch
version: 0.7.0
epoch: 0
release: 1
summary: Development documents and examples for lab-control
url: https://pypi.org/project/lab-control/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-lab-control-0.7.0-1.src.rpm
location_href: Packages/python-lab-control-help-0.7.0-1.noarch.rpm
checksum_type: sha256
description:
  This repository contains classes to control lab equipment in a simple and unified way.

  - [Lab Control](#lab-control)
    - [API Reference](#api-reference)
      - [Measurement Devices](#measurement-devices)
      - [Actuation Devices](#actuation-devices)
      - [Other Classes](#other-classes)
    - [Getting Started](#getting-started)
      - [Installation](#installation)
      - [Using Measurement Devices](#using-measurement-devices)
      - [Measurements](#measurements)
        - [`get_measurement()`](#get_measurement)
        - [`measure()`](#measure)
      - [Defaults](#defaults)
      - [Measurement Objects](#measurement-objects)
    - [Other Notes](#other-notes)





  - [E5061B](doc/e5061b.md)
  - [DSOX2024A](doc/dsox2024a.md)
  - [N90X0X](doc/n90x0x.md)
  - [SR785](doc/sr785.md)
    - [SR785.FFT](doc/sr785.md#sr785.FFT)
    - [SR785.SweptSine](doc/sr785.md#sr785.SweptSine)



  - [StepperBoard](doc/stepper_board.md)



  - [common](doc/common.md)
    - [Device](doc/common.md#common.Device)
    - [Measurement](doc/common.md#common.Measurement)
    - [ParamProxy](doc/common.md#common.ParamProxy)
  - [rpc](doc/rpc.md)
    - [BidirectionalLineStream](doc/rpc.md#rpc.BidirectionalLineStream)
    - [SerialBLS](doc/rpc.md#rpc.SerialBLS)
    - [SocketBLS](doc/rpc.md#rpc.SocketBLS)
    - [RpcClient](doc/rpc.md#rpc.RpcClient)
    - [RpcProxy](doc/rpc.md#rpc.RpcProxy)





  The package can be installed from PyPI with pip:

  ```shell
  pip install lab-control
  ```



  All measurement devices inherit from the `Device` class. This means that they have at least three methods, `__init__()`, `get_measurement()`, and `measure()`, which always have the same basic signature except for some additional keyword arguments.

  Some devices also have additional methods like saving a screenshot or automatically adjusting the range.

  When creating and instance of a measurement device, you will need to provide the VISA address of the device and you can also provide a dictionary of default settings, more on the default mechanism later.

  ```python
  from lab_control import DSOX2024A

  dev = DSOX2024A('USB0::0x0957::0x1796::MY60476362::0::INSTR', defaults={'time_points': 1000})
  ```





  The `get_measurement()` method is used to get the current data from the device without changing any settings or explicitly starting a measurement. This is useful when you are mostly working on the device itself and only want to save measurement data.

  You can pass a `name`, `comment`, and additional `meta`data about you experiment or the measurement that will be stored in the `'user'` section of the metadata. If you do not specify a `name` the measurement will be named automatically based on the device, some of the parameters, and the current time.



  To explicably start a measurement with specific parameters you should use the `measure()` method, in addition to the `name`, `comment`, and `meta` parameters that are available in the `get_measurement()` method, you can specify the measurement parameters. A list of the available parameters can be found in the documentation of the specific device. These parameters are generally not exhaustive as most devices have many more settings that are rarely used, the set of available parameters will be extended as needed. You can also set `no_defaults=True` to ignore all default settings and fall back to the current device settings. You will get a warning with a of all parameters that are not specified in the function call or defaults, this can be disabled with `show_warnings=False`.

  The parameters are written to the device and read back, this will ensure, that parameters which were adjusted by the device to be within the allowed range are used.

  Once the parameters are set, continuous measuring is suspended and the device will perform a single shot measurement as far as applicable for the device. This may also include multiple averaging cycles. Depending on the device, the measurement might take a while. After the measurement is done, the data is read from the device and the device is set back to continuous measuring if it was set to continuous measuring before.



  To avoid having to specify all parameters every time everywhere, default settings can be provided on different levels. The fallback order is the following:

  - Function parameters that are passed to the `measure()` method
  - Instance defaults that were specified in the constructor.
  - Class defaults that are sometimes specified in the class definition.
  - Current device settings

  The higher levels override the lower levels. This means that if a parameter is specified in the `measure()` method, it will override the instance defaults, and so on. You should avoid relying on the class defaults or the current device settings, the class defaults are currently still subject to change and the current device settings depend on the prior usage of the device. **If you expect you script to live longer than a day, you should always specify all parameters in the instance defaults or as function parameters to ensure consistency.**

  You can also explicitly ignore a default on any level by setting it to `None`, if this means that the parameters is not specified on any level the device settings will be used. You can use this for example to ignore the class defaults when initializing an instance. Or to use the current device settings when calling the `measure()` method.

  You can also use the `no_defaults` parameter in the `measure()` method to ignore all defaults for a single measurement.



  Both the `get_measurement()` and `measure()` methods return a `Measurement` object. A measurement has three members, `df` which contains tabular data as a pandas `DataFrame`, `meta` which contains metadata as a dictionary, and `attachments` which contains named binary attachments in a dictionary.

  The metadata always contains a `'file'` which contains information about the file itself, like the name, delimiter and index column. The `'user'` section contains user specified data. Finally the `'dev'` section contains the parameters that were used for the measurement.

  Measurements can be saved and loaded to and from disk with the `save()` and `load()` methods. If the measurement contains attachments it needs to be saved with `save_zip()` which will save the measurement and its attachments to a zip file. The zip file can be loaded with the normal `load()` method.

  Measurements have a `_repr_html_()` method for a nicer display in Jupyter notebooks, they can also be plotted with the `plot()` convenience function. Measurements can also be combined by inserting one measurement into another with the `insert()` method.



  The repository uses symlinks so that the example files can access the `src` directory. Git will only recreate the symlinks when symlinks are enables with

  ```shell
  git config core.symlinks true
  ```

  Or with `--global` to enable it for all repositories.


pkgId: 2b65c68ef25807dba8cfe7a1441bfe1cb622d1c2a23634538add2e7fd558b1f6
name: python-labelaction-help
arch: noarch
version: 1.1.4
epoch: 0
release: 1
summary: Development documents and examples for labelaction
url: https://pypi.org/project/labelaction/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-labelaction-1.1.4-1.src.rpm
location_href: Packages/python-labelaction-help-1.1.4-1.noarch.rpm
checksum_type: sha256
description:
  This is a GUI-based tool for annotating animal behavior in video files. Built using Python and PyQt5, this application allows users to load a video, navigate through frames, and label different behaviors for multiple subjects (referred to as "pigeons" in this tool).



  - **Simultaneous annotation of behaviors and postures**: Users can annotate both behaviors (e.g. feeding, drinking, etc.) and postures (e.g. standing, lying down, etc.) of pigeons during video playback, and each annotation can be done independently.
  - **Timeline visualization**: The program provides a visual timeline for each pigeon to show the behavior and posture annotations for quick viewing and editing.

  - **Video frame navigation**: the user can use buttons or shortcut keys (such as 'D' and 'S') to quickly advance or rewind video frames for easy and precise labeling.

  - **Color coding**: Different behaviors and gestures are identified using different colors, making annotation more intuitive and allowing users to quickly identify information by color.

  - **Export function**: Users can export annotation data to CSV file, supporting two formats: original annotation and sorted annotation data, which is convenient for subsequent data analysis and processing.

  - **Multi-pigeon support**:  the program allows independent annotation of multiple pigeons for complex experimental scenarios.



  - **Python** (>= 3.6)
  - **Libraries**: The following libraries are required:
    - `PyQt5`
    - `OpenCV`
    - `pandas`



  This tool is licensed under the MIT License. Feel free to modify and use it as needed.



  - PyQt5 for the GUI and OpenCV for video processing
  - GEMlab : https://www.gemlab.site


  '1.1.4' Updated the review function. Now you can see the bounding box and corresponding ID, behavior and posture of each pigeon in the video area.

  '1.1.3' Add some functionality
  - Support undo when marking, press ctrl+z.
  - Click the annotated area of ​​the status bar to display the annotated information, such as the start frame, end frame, etc.
  - Support annotation review and modification
  - Print annotate operation log to the console

  '1.1.2' Modify the behavior list and posture list

  '1.1.1' fix some bugs, add posture "Tail up" and the posture "lying down" was changed to "Squatting"

  '1.1.0'
  - Supports simultaneous annotation of actions and gestures in videos.
  - Export similar to mot format, export each frame's information to csv file, replace no behavior or gesture with -1
  - Optimize GUI interface and functional details to improve user usability

  '1.0.2' automatically install dependent packages

  '1.0.1' fix some bugs

  '1.0.0' first release


pkgId: a1ce9ba92fa7464c5cfa82ad5d88841e8537555cceba310cfe7b35a02bbcb28b
name: python-labelbox-help
arch: noarch
version: 6.4.0
epoch: 0
release: 1
summary: Development documents and examples for labelbox
url: https://labelbox.com/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-labelbox-6.4.0-1.src.rpm
location_href: Packages/python-labelbox-help-6.4.0-1.noarch.rpm
checksum_type: sha256
description:
  Core mono-module for Labelbox's Python SDK.



  - [Setup](#setup)
  - [Repository Organization](#repository-organization)
  - [Testing](#testing)



  ```bash
  rye sync --all-features # to install labelbox[data] dependencies
  ```



  The SDK source (excluding tests and support tools) is organized into the
  following packages/modules:
  * `data/` package contains code that maps annotations (labels or pre-labels) to
    Python objects, as well as serialization and deserialization tools for converting
    between NDJson and Annotation Types.
  * `orm/` package contains code that supports the general mapping of Labelbox
    data to Python objects. This includes base classes, attribute (field and
    relationship) classes, generic GraphQL queries etc.
  * `schema/` package contains definitions of classes which represent data type
    (e.g. Project, Label etc.). It relies on `orm/` classes for easy and succinct
    object definitions. It also contains custom functionalities and custom GraphQL
    templates where necessary.
  * `client.py` contains the `Client` class that's the client-side stub for
    communicating with Labelbox servers.
  * `exceptions.py` contains declarations for all Labelbox errors.
  * `pagination.py` contains support for paginated relationship and collection
    fetching.
  * `utils.py` contains utility functions.





  ```bash
  rye run unit
  ```



  ```bash
  LABELBOX_TEST_API_KEY="YOUR_API_TEST_KEY" LABELBOX_TEST_ENVIRON="prod" rye run integration
  ```
  For more info on how to get a `LABELBOX_TEST_API_KEY` [Labelbox API key docs](https://labelbox.helpdocs.io/docs/api/getting-started).

  **Integration tests by default will run against your account that you provide an API Key from and modify its data. If you want to run integration tests, without it impacting your existing account, create an additional account using a secondary e-mail on [Labelbox](https://labelbox.com). Free accounts are sufficent for integration testing purposes.**

  You can also use a `.env` file if you prefer instead of needing to type out the environmental overrides every single time you want to run commands. Please add a `--env-file` parameter to the test command (EG `rye --env-file=.env run integration`).



  For testing the impact of the extra installs included with `labelbox[data]`, run the following:

  ```bash
  LABELBOX_TEST_API_KEY="YOUR_API_TEST_KEY" LABELBOX_TEST_ENVIRON="prod" rye run data
  ```

  By default `rye sync` does not install the extra packages needed in `labelbox[data]`. You'll need to run `rye sync --all-features`. Do not checkin `requirements.lock` or `requirements-dev.lock` after doing this.



  Before making a commit, to automatically adhere to our formatting standards, it is recommended to install and activate [pre-commit](https://pre-commit.com/)
  ```shell
  pip install pre-commit
  pre-commit install
  ```
  After the above, running `git commit ...` will attempt to fix formatting,
  and make necessary changes to files. You will then need to stage those files again.

  You may also manually format your code by running the following:
  ```bash
  rye run lint
  ```



  To generate documentation for all modules (`ReadTheDocs`), run the following command.

  ```bash
  rye run docs
  ```


pkgId: c224062d5acab054e8560a993e2863ac50b444703c1ed49dd24d79726e3a5ba8
name: python-labrea-help
arch: noarch
version: 2.0.4
epoch: 0
release: 1
summary: Development documents and examples for labrea
url: https://pypi.org/project/labrea/
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-labrea-2.0.4-1.src.rpm
location_href: Packages/python-labrea-help-2.0.4-1.noarch.rpm
checksum_type: sha256
description:
  A framework for declarative, functional dataset definitions.
  ![](https://img.shields.io/badge/version-2.0.4-blue.svg)
  [![lifecycle](https://img.shields.io/badge/lifecycle-stable-green.svg)](https://www.tidyverse.org/lifecycle/#stable)
  [![PyPI Downloads](https://img.shields.io/pypi/dm/labrea.svg?label=PyPI%20downloads)](https://pypi.org/project/labrea/)
  [![pre-commit](https://img.shields.io/badge/pre--commit-enabled-brightgreen?logo=pre-commit&logoColor=white)](https://github.com/pre-commit/pre-commit)
  [![Coverage](https://raw.githubusercontent.com/8451/labrea/meta/coverage/coverage.svg)](https://github.com/8451/labrea/tree/meta/coverage)
  [![docs](https://img.shields.io/badge/docs-latest-brightgreen.svg?style=flat)](https://8451.github.io/labrea)

  Labrea is available for install via pip.
  ```bash
  pip install labrea
  ````
  Alternatively, you can install the latest development version from GitHub.
  ```bash
  pip install git+https://github.com/8451/labrea@develop
  ```

  See our usage guide [here](docs/source/usage.md).
  Labrea exposes a `dataset` decorator that allows you to define datasets and their dependencies in a declarative manner.
  Dependencies can either be other datasets or `Option`s, which are values that can be passed in at runtime via a
  dictionary.
  ```python
  from labrea import dataset, Option
  import pandas as pd
  @dataset
  def stores(path: str = Option('PATHS.STORES')) -> pd.DataFrame:
      return pd.read_csv(path)
  @dataset
  def transactions(path: str = Option('PATHS.SALES')) -> pd.DataFrame:
      return pd.read_csv(path)
  @dataset
  def sales_by_region(
          stores_: pd.DataFrame = stores,
          transactions_: pd.DataFrame = transactions
  ) -> pd.DataFrame:
      """Merge stores to transactions, sum sales by region"""
      return pd.merge(transactions_, stores_, on='store_id').groupby('region')['sales'].sum().reset_index()
  options = {
      'PATHS': {
          'STORES': 'path/to/stores.csv',
          'SALES': 'path/to/sales.csv'
      }
  }
  stores(options)








  transactions(options)








  sales_by_region(options)






  ```

  If you would like to contribute to **labrea**, please read the
  [Contributing Guide](docs/source/contributing.md).

  A summary of recent updates to **labrea** can be found in the
  [Changelog](docs/source/changelog.md).

  | Maintainer                                                | Email                    |
  |-----------------------------------------------------------|--------------------------|
  | [Austin Warner](https://github.com/austinwarner-8451)     | austin.warner@8451.com   |
  | [Michael Stoepel](https://github.com/michaelstoepel-8451) | michael.stoepel@8451.com |

  - Report a bug or request a feature: https://github.com/8451/labrea/issues/new/choose
  - Documentation: https://8451.github.io/labrea

rpm_license:
  MIT License  Copyright (c) 2024 84.51 LLC. All rights reserved.  Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:  The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.


pkgId: d33324cf16b8e199a016fbaf36c44b6dde519cb45d2b023228dce11f480c3df5
name: python-ladybug-comfort-help
arch: noarch
version: 0.18.65
epoch: 0
release: 1
summary: Development documents and examples for ladybug-comfort
url: https://github.com/ladybug-tools/ladybug-comfort
rpm_license: AGPL-3.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-ladybug-comfort-0.18.65-1.src.rpm
location_href: Packages/python-ladybug-comfort-help-0.18.65-1.noarch.rpm
checksum_type: sha256
description:
  ![Ladybug](http://www.ladybug.tools/assets/img/ladybug.png)

  [![Build Status](https://github.com/ladybug-tools/ladybug-comfort/actions/workflows/ci.yaml/badge.svg)](https://github.com/ladybug-tools/ladybug-comfort/actions)
  [![Coverage Status](https://coveralls.io/repos/github/ladybug-tools/ladybug-comfort/badge.svg)](https://coveralls.io/github/ladybug-tools/ladybug-comfort)

  [![Python 3.10](https://img.shields.io/badge/python-3.10-orange.svg)](https://www.python.org/downloads/release/python-3100/) [![Python 3.7](https://img.shields.io/badge/python-3.7-blue.svg)](https://www.python.org/downloads/release/python-370/) [![Python 2.7](https://img.shields.io/badge/python-2.7-green.svg)](https://www.python.org/downloads/release/python-270/) [![IronPython](https://img.shields.io/badge/ironpython-2.7-red.svg)](https://github.com/IronLanguages/ironpython2/releases/tag/ipy-2.7.8/)



  Ladybug-comfort is a Python library that adds thermal comfort functionalities to
  [ladybug-core](https://github.com/ladybug-tools/ladybug/).





  To install the library use:

  `pip install ladybug-comfort`

  If you want to also include the dependencies needed for thermal mapping use:

  `pip install -U honeybee-energy[mapping]`

  To check if the Ladybug-comfort command line interface is installed correctly,
  use `ladybug-comfort --help`.



  ```python
  """Get the percentage of time outdoor conditions are comfortable with/without sun + wind"""
  from ladybug.epw import EPW
  from ladybug_comfort.collection.utci import UTCI

  epw_file_path = './tests/epw/chicago.epw'
  epw = EPW(epw_file_path)
  utci_obj_exposed = UTCI.from_epw(epw, include_wind=True, include_sun=True)
  utci_obj_protected = UTCI.from_epw(epw, include_wind=False, include_sun=False)

  print(utci_obj_exposed.percent_neutral)  # comfortable percent of time with sun + wind
  print(utci_obj_protected.percent_neutral)  # comfortable percent of time without sun + wind
  ```


  1. Clone this repo locally
  ```console
  git clone git@github.com:ladybug-tools/ladybug-comfort.git



  git clone https://github.com/ladybug-tools/ladybug-comfort.git
  ```
  2. Install dependencies:
  ```console
  cd ladybug-comfort
  pip install -r dev-requirements.txt
  pip install -r requirements.txt
  ```

  3. Run Tests:
  ```console
  python -m pytest ./tests
  ```

  4. Generate Documentation:
  ```console
  sphinx-apidoc -f -e -d 4 -o ./docs ./ladybug_comfort
  sphinx-build -b html ./docs ./docs/_build/docs
  ```



  Ladybug-comfort is a derivative work of the following software projects:

  * [CBE Comfort Tool](https://github.com/CenterForTheBuiltEnvironment/comfort_tool) for indoor thermal comfort calculations.  Available under GPL.
  * [UTCI Fortran Code](http://www.utci.org/utci_doku.php) for outdoor thermal comfort calculations.  Available under MIT.

  Applicable copyright notices for these works can be found within the relevant .py files.


pkgId: 4634e2abc8128503ad3180aa8aae972ded38fdd70562416ec9962d35299beedd
name: python-ladybug-core-help
arch: noarch
version: 0.43.22
epoch: 0
release: 1
summary: Development documents and examples for ladybug-core
url: https://github.com/ladybug-tools/ladybug
rpm_license: AGPL-3.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-ladybug-core-0.43.22-1.src.rpm
location_href: Packages/python-ladybug-core-help-0.43.22-1.noarch.rpm
checksum_type: sha256
description:
  ![Ladybug](http://www.ladybug.tools/assets/img/ladybug.png)

  [![Build Status](https://github.com/ladybug-tools/ladybug/workflows/CI/badge.svg)](https://github.com/ladybug-tools/ladybug/actions)
  [![Coverage Status](https://coveralls.io/repos/github/ladybug-tools/ladybug/badge.svg?branch=master)](https://coveralls.io/github/ladybug-tools/ladybug)

  [![Python 3.7](https://img.shields.io/badge/python-3.7-blue.svg)](https://www.python.org/downloads/release/python-370/) [![Python 2.7](https://img.shields.io/badge/python-2.7-green.svg)](https://www.python.org/downloads/release/python-270/) [![IronPython](https://img.shields.io/badge/ironpython-2.7-red.svg)](https://github.com/IronLanguages/ironpython2/releases/tag/ipy-2.7.8/)



  Ladybug is a Python library to analyze, modify, and visualize EnergyPlus Weather files (epw). You can download epw files from [EPWMap](http://www.ladybug.tools/epwmap/).

  This repository is the core library that is the base for the Ladybug Grasshopper Plugin. For plugin-specific questions and comments refer to [ladybug-grasshopper](https://github.com/ladybug-tools/ladybug-grasshopper).



  For the Legacy Ladybug Grasshopper Plugin see [this repository](https://github.com/ladybug-tools/ladybug-legacy).





  To install the library use:

  `pip install ladybug-core`

  To check if Honeybee command line interface is installed correctly use `ladybug viz` and you
  should get a `viiiiiiiiiiiiizzzzzzzzz!` back in response!



  ```python

  from ladybug.epw import EPW
  epw_data = EPW('path_to_epw_file')
  dry_bulb_temp = epw_data.dry_bulb_temperature


  from ladybug.location import Location
  from ladybug.sunpath import Sunpath


  sydney = Location('Sydney', 'AUS', latitude=-33.87, longitude=151.22, time_zone=10)


  sp = Sunpath.from_location(sydney)
  sun = sp.calculate_sun(month=11, day=15, hour=11.0)

  print('altitude: {}, azimuth: {}'.format(sun.altitude, sun.azimuth))
  >>> altitude: 72.26, azimuth: 32.37
  ```


  1. Clone this repo locally
  ```console
  git clone git@github.com:ladybug-tools/ladybug.git



  git clone https://github.com/ladybug-tools/ladybug.git
  ```
  2. Install dependencies:
  ```console
  cd ladybug
  pip install -r dev-requirements.txt
  pip install -r requirements.txt
  ```

  3. Run Tests:
  ```console
  python -m pytest ./tests
  ```

  4. Generate Documentation:
  ```console
  sphinx-apidoc -f -e -d 4 -o ./docs ./ladybug
  sphinx-build -b html ./docs ./docs/_build/docs
  ```



  Ladybug is a derivative work of the following software projects:

  * [PVLib-python](https://github.com/pvlib/pvlib-python) for solar irradiance calculations. Available under BSD 3-clause.
  * [PsychroLib](https://github.com/psychrometrics/psychrolib) for psychrometric calculations. Available under MIT License.

  Applicable copyright notices for these works can be found within the relevant .py files.


pkgId: 06625726d1e93b92de985f5e23ddc35c66bf733ff6413cb7d9b4453676d225b3
name: python-ladybug-geometry-help
arch: noarch
version: 1.33.13
epoch: 0
release: 1
summary: Development documents and examples for ladybug-geometry
url: https://github.com/ladybug-tools/ladybug-geometry
rpm_license: AGPL-3.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-ladybug-geometry-1.33.13-1.src.rpm
location_href: Packages/python-ladybug-geometry-help-1.33.13-1.noarch.rpm
checksum_type: sha256
description:
  ![Ladybug](http://www.ladybug.tools/assets/img/ladybug.png)

  [![Build Status](https://github.com/ladybug-tools/ladybug-geometry/workflows/CI/badge.svg)](https://github.com/ladybug-tools/ladybug-geometry/actions)
  [![Coverage Status](https://coveralls.io/repos/github/ladybug-tools/ladybug-geometry/badge.svg?branch=master)](https://coveralls.io/github/ladybug-tools/ladybug-geometry?branch=master)

  [![Python 3.7](https://img.shields.io/badge/python-3.7-blue.svg)](https://www.python.org/downloads/release/python-370/) [![Python 2.7](https://img.shields.io/badge/python-2.7-green.svg)](https://www.python.org/downloads/release/python-270/) [![IronPython](https://img.shields.io/badge/ironpython-2.7-red.svg)](https://github.com/IronLanguages/ironpython2/releases/tag/ipy-2.7.8/)



  Ladybug geometry is a Python library that houses geometry objects and geometry
  computations methods used throughout the Ladybug Tools core libraries.

  The library is designed to work with a wide range of Python environments and
  it returns consistent results between them (cPython 2 and 3, IronPython 2).



  `pip install -U ladybug-geometry`





  - Perform Vector Math (Dot, Cross, Angle, Normalize)
  - Calculate Bounding Box for any Geometry (Min, Max, Center)
  - Subdivide Lines and Arcs
  - Compute Perimeter and Area of Planar Geometry
  - Check Concavity and Clockwise Ordering of 2D Geometry
  - Triangulate Planar Geometry
  - Compute Mesh Face Areas, Centroids, and Normals
  - Move Any Geometry
  - Rotate Any Geometry Around an Axis (or in the XY plane)
  - Mirror (Reflect) Any Geometry Over a Plane
  - Scale Any Geometry from a Base Point
  - Check if a 2D Point Inside 2D Polygon
  - Compute [Pole of Inaccessibility](https://en.wikipedia.org/wiki/Pole_of_inaccessibility) for any 2D Polygon
  - Check the Relationship Between 2D Polygons within a Tolerance (inside, outside, overlap)
  - Group 2D Polygons According to Overlaps
  - Perform 2D Polygon Boolean Operations (Union, Intersection, Difference)
  - Intersect Colinear 2D Polygon Segments with one Another (for matching lengths)
  - Join Line Segments into Polylines
  - Calculate 3D Face Plane and Normal from Vertices
  - Compute 3D Face Intersection with a Ray or Line
  - Generate a Quad Mesh Grid from a 3D Face
  - Generate Sub-faces Based on Ratio with a Face (used for window generation)
  - Generate Contours and Contour Fins from a Face (used to generate louvers, fins and overhangs)
  - Split, Union, or Intersect 3D Coplanar Faces with one Another (for matching areas)
  - Solve Adjacencies by Matching 3D Face Geometries
  - Join 3D Faces into 3D Polyfaces
  - Check if a 3D PolyFace is a Closed Solid
  - Ensure All Faces of a Solid 3D PolyFace Point Outwards
  - Compute the Volume of a Closed 3D Polyface
  - Check if a Point is Inside a Closed 3D Polyface



  - Conversion of Curved 3D Surfaces to Planar 3D Faces
  - Fancier Meshing (eg. gridded meshing that completely fills the base surface)
  - Solid Boolean Unions (this should not be needed for anything in Ladybug Tools)



  This library was built by combining capabilities of several different open-source
  (MIT Licensed) projects, establishing a set of standardized geometry objects that
  allowed them all to talk to one another, and adding several other capabilities
  with new code. We as a community owe a huge amount of thanks to the open source projects
  that provided many of the starting capabilities of this package and we are indebted
  to the developers who made their work available under an MIT license for the betterment
  of geometry computation everywhere. Where possible, you will find detailed lists of
  references in the docstrings of this package's source code. A summary of the key
  sources that were used to build this library are as follows:

  - [euclid](https://pypi.org/project/euclid/)
  - [earcut](https://github.com/mapbox/earcut) and [earcut-python](https://github.com/joshuaskelly/earcut-python)
  - [polybooljs](https://github.com/velipso/polybooljs) and [pypolybool](https://github.com/KaivnD/pypolybool)
  - [polylabel](https://github.com/Twista/python-polylabel)
  - [pySTL](https://github.com/proverbialsunrise/pySTL)
  - A countless number of [StackOverflow](https://stackoverflow.com/) experts who answered various geometry questions
  - A countless number of [Wikipedia](https://www.wikipedia.org/) authors who described various geometry algorithms



  We initially debated whether the burden of geometry computation should be placed largely
  on the CAD environments in which Ladybug Tools operates or whether it should be included
  in a dedicated core Python library like this one.

  As we developed the core libraries, it became clear that there are large advantages
  to having it in the core including:

  1. Standardized compatibility of geometry between different CAD plugins (eg. Rhino, Revit), simulation engines (eg. E+, Radiance), and file formats (eg. gbXML, GEM).
  2. The ability to perform geometry operations from the core library CLI without the need for CAD software.
  3. Improved performance (since a dedicated library could be tailored to the use cases of Ladybug Tools).
  4. Reliability and maintain-ability in the face of changes to CAD environments and changing Python conventions.

  Items 1 and 4 above proved to be particularly important and so the decision was made
  that the Ladybug Tools core libraries would have its own geometry library that was
  distinct from CAD plugins.

  Before committing to write our own library, we looked into using or tweaking other
  comprehensive open source geometry libraries for the core including:

  - [Rhino3dm](https://github.com/mcneel/rhino3dm)
  - [Blender API (bpy)](https://docs.blender.org/api/current/)
  - [Boost Geometry](https://www.boost.org/doc/libs/1_78_0/libs/geometry/doc/html/index.html)
  - [Topologic](https://topologic.app/Software/)

  However, Rhino3dm lacks basic geometry computation. The Blender library had many capabilities
  but it only works in Python3 and this could break certain CAD workflows that rely on
  IronPython. Boost Geometry (the geometry library used by the OpenStudio SDK) also had a
  lot of functionality but it clearly has C dependencies, making it unusable from IronPython.
  Topologic also appeared to have C dependencies, though the most relevant issue was
  that its dual license could create challenges for certain use cases of Ladybug Tools.

  After considering the situation further, we realized that many of the capabilities that
  we needed could be achieved by building off the work of various open source MIT-licensed
  projects as long as we committed to using planar geometry. Since all of the geometry
  ultimately going to the engines (Radiance, E+) is planar, we made the decision that
  the core libraries will primarily support planar objects with no NURBS support and
  very limited support for Arcs, Circles, Spheres, Cylinders and Cones.

  Thus this repository was born!



  1. Clone this repo locally
  ```console
  git clone git@github.com:ladybug-tools/ladybug-geometry.git



  git clone https://github.com/ladybug-tools/ladybug-geometry.git
  ```

  2. Install dependencies:
  ```console
  cd ladybug-geometry
  pip install -r dev-requirements.txt
  pip install -r requirements.txt
  ```

  3. Run Tests:
  ```console
  python -m pytests tests/
  ```

  4. Generate Documentation:
  ```console
  sphinx-apidoc -f -e -d 4 -o ./docs ./ladybug_geometry
  sphinx-build -b html ./docs ./docs/_build/docs
  ```


pkgId: 25ae5ccdcb60a884efbfbcc1f7538d96a492cadb7d28a060cccdbc3be1645c1c
name: python-ladybug-geometry-polyskel-help
arch: noarch
version: 1.7.15
epoch: 0
release: 1
summary: Development documents and examples for ladybug-geometry-polyskel
url: https://github.com/ladybug-tools/ladybug-geometry-polyskel
rpm_license: AGPL-3.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-ladybug-geometry-polyskel-1.7.15-1.src.rpm
location_href: Packages/python-ladybug-geometry-polyskel-help-1.7.15-1.noarch.rpm
checksum_type: sha256
description:
  [![Build Status](https://travis-ci.com/ladybug-tools/ladybug-geometry-polyskel.svg?branch=master)](https://travis-ci.com/ladybug-tools/ladybug-geometry-polyskel)
  [![Coverage Status](https://coveralls.io/repos/github/ladybug-tools/ladybug-geometry-polyskel/badge.svg?branch=master)](https://coveralls.io/github/ladybug-tools/ladybug-geometry-polyskel)

  [![Python 3.7](https://img.shields.io/badge/python-3.7-blue.svg)](https://www.python.org/downloads/release/python-370/) [![Python 2.7](https://img.shields.io/badge/python-2.7-green.svg)](https://www.python.org/downloads/release/python-270/) [![IronPython](https://img.shields.io/badge/ironpython-2.7-red.svg)](https://github.com/IronLanguages/ironpython2/releases/tag/ipy-2.7.8/)



  A library with straight skeleton methods using ladybug-geometry.



  Ladybug-geometry-polyskel is a derivative work of the the [polyskel package](https://github.com/Botffy/polyskel)
  by [Ármin Scipiades](https://github.com/Botffy) (@Bottfy), which is, itself, a Python 3
  implementation of the straight skeleton algorithm as described by Felkel and Obdržálek
  in their 1998 conference paper [Straight skeleton implementation](https://github.com/Botffy/polyskel/blob/master/doc/StraightSkeletonImplementation.pdf).

  Key differences between Bottfy's original implementation and this package are:

  * It has been modified for compatibility with both Python 2.7 and Python 3.7.
  * The code as been re-stylized to conform to the PEP8 style guide.
  * Modules have been added to extract core/perimeter polygons from the straight skeleton.



  ```console
  pip install -U ladybug-geometry-polyskel
  ```



  ```python
  import ladybug_geometry_polyskel

  ```




  1. Clone this repo locally
  ```console
  git clone git@github.com:ladybug-tools/ladybug-geometry-polyskel



  git clone https://github.com/ladybug-tools/ladybug-geometry-polyskel
  ```
  2. Install dependencies:
  ```console
  cd ladybug-geometry-polyskel
  pip install -r dev-requirements.txt
  pip install -r requirements.txt
  ```

  3. Run Tests:
  ```console
  python -m pytest tests/
  ```

  4. Generate Documentation:
  ```console
  sphinx-apidoc -f -e -d 4 -o ./docs ./ladybug_geometry_polyskel
  sphinx-build -b html ./docs ./docs/_build/docs
  ```



  Ladybug Geometry Polyskel, Copyright (c) 2021, Ármin Scipiades, Ladybug Tools LLC
  and other contributors. All rights reserved.


pkgId: ecfb8e219e08b38e7630747aa32d2843d478ea811ada7d1952ab76c0f37597c0
name: python-lakefs-sdk-help
arch: noarch
version: 1.45.0
epoch: 0
release: 1
summary: Development documents and examples for lakefs-sdk
url: https://github.com/treeverse/lakeFS/tree/master/clients/python
rpm_license: Apache 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-lakefs-sdk-1.45.0-1.src.rpm
location_href: Packages/python-lakefs-sdk-help-1.45.0-1.noarch.rpm
checksum_type: sha256
description:
  *ActionsApi* | [**get_run**](https://pydocs-sdk.lakefs.io/v1.45/docs/ActionsApi.html#get_run) | **GET** /repositories/{repository}/actions/runs/{run_id} | get a run
  *ActionsApi* | [**get_run_hook_output**](https://pydocs-sdk.lakefs.io/v1.45/docs/ActionsApi.html#get_run_hook_output) | **GET** /repositories/{repository}/actions/runs/{run_id}/hooks/{hook_run_id}/output | get run hook output
  *ActionsApi* | [**list_repository_runs**](https://pydocs-sdk.lakefs.io/v1.45/docs/ActionsApi.html#list_repository_runs) | **GET** /repositories/{repository}/actions/runs | list runs
  *ActionsApi* | [**list_run_hooks**](https://pydocs-sdk.lakefs.io/v1.45/docs/ActionsApi.html#list_run_hooks) | **GET** /repositories/{repository}/actions/runs/{run_id}/hooks | list run hooks
  *AuthApi* | [**add_group_membership**](https://pydocs-sdk.lakefs.io/v1.45/docs/AuthApi.html#add_group_membership) | **PUT** /auth/groups/{groupId}/members/{userId} | add group membership
  *AuthApi* | [**attach_policy_to_group**](https://pydocs-sdk.lakefs.io/v1.45/docs/AuthApi.html#attach_policy_to_group) | **PUT** /auth/groups/{groupId}/policies/{policyId} | attach policy to group
  *AuthApi* | [**attach_policy_to_user**](https://pydocs-sdk.lakefs.io/v1.45/docs/AuthApi.html#attach_policy_to_user) | **PUT** /auth/users/{userId}/policies/{policyId} | attach policy to user
  *AuthApi* | [**create_credentials**](https://pydocs-sdk.lakefs.io/v1.45/docs/AuthApi.html#create_credentials) | **POST** /auth/users/{userId}/credentials | create credentials
  *AuthApi* | [**create_group**](https://pydocs-sdk.lakefs.io/v1.45/docs/AuthApi.html#create_group) | **POST** /auth/groups | create group
  *AuthApi* | [**create_policy**](https://pydocs-sdk.lakefs.io/v1.45/docs/AuthApi.html#create_policy) | **POST** /auth/policies | create policy
  *AuthApi* | [**create_user**](https://pydocs-sdk.lakefs.io/v1.45/docs/AuthApi.html#create_user) | **POST** /auth/users | create user
  *AuthApi* | [**create_user_external_principal**](https://pydocs-sdk.lakefs.io/v1.45/docs/AuthApi.html#create_user_external_principal) | **POST** /auth/users/{userId}/external/principals | attach external principal to user
  *AuthApi* | [**delete_credentials**](https://pydocs-sdk.lakefs.io/v1.45/docs/AuthApi.html#delete_credentials) | **DELETE** /auth/users/{userId}/credentials/{accessKeyId} | delete credentials
  *AuthApi* | [**delete_group**](https://pydocs-sdk.lakefs.io/v1.45/docs/AuthApi.html#delete_group) | **DELETE** /auth/groups/{groupId} | delete group
  *AuthApi* | [**delete_group_membership**](https://pydocs-sdk.lakefs.io/v1.45/docs/AuthApi.html#delete_group_membership) | **DELETE** /auth/groups/{groupId}/members/{userId} | delete group membership
  *AuthApi* | [**delete_policy**](https://pydocs-sdk.lakefs.io/v1.45/docs/AuthApi.html#delete_policy) | **DELETE** /auth/policies/{policyId} | delete policy
  *AuthApi* | [**delete_user**](https://pydocs-sdk.lakefs.io/v1.45/docs/AuthApi.html#delete_user) | **DELETE** /auth/users/{userId} | delete user
  *AuthApi* | [**delete_user_external_principal**](https://pydocs-sdk.lakefs.io/v1.45/docs/AuthApi.html#delete_user_external_principal) | **DELETE** /auth/users/{userId}/external/principals | delete external principal from user
  *AuthApi* | [**detach_policy_from_group**](https://pydocs-sdk.lakefs.io/v1.45/docs/AuthApi.html#detach_policy_from_group) | **DELETE** /auth/groups/{groupId}/policies/{policyId} | detach policy from group
  *AuthApi* | [**detach_policy_from_user**](https://pydocs-sdk.lakefs.io/v1.45/docs/AuthApi.html#detach_policy_from_user) | **DELETE** /auth/users/{userId}/policies/{policyId} | detach policy from user
  *AuthApi* | [**external_principal_login**](https://pydocs-sdk.lakefs.io/v1.45/docs/AuthApi.html#external_principal_login) | **POST** /auth/external/principal/login | perform a login using an external authenticator
  *AuthApi* | [**get_credentials**](https://pydocs-sdk.lakefs.io/v1.45/docs/AuthApi.html#get_credentials) | **GET** /auth/users/{userId}/credentials/{accessKeyId} | get credentials
  *AuthApi* | [**get_current_user**](https://pydocs-sdk.lakefs.io/v1.45/docs/AuthApi.html#get_current_user) | **GET** /user | get current user
  *AuthApi* | [**get_external_principal**](https://pydocs-sdk.lakefs.io/v1.45/docs/AuthApi.html#get_external_principal) | **GET** /auth/external/principals | describe external principal by id
  *AuthApi* | [**get_group**](https://pydocs-sdk.lakefs.io/v1.45/docs/AuthApi.html#get_group) | **GET** /auth/groups/{groupId} | get group
  *AuthApi* | [**get_group_acl**](https://pydocs-sdk.lakefs.io/v1.45/docs/AuthApi.html#get_group_acl) | **GET** /auth/groups/{groupId}/acl | get ACL of group
  *AuthApi* | [**get_policy**](https://pydocs-sdk.lakefs.io/v1.45/docs/AuthApi.html#get_policy) | **GET** /auth/policies/{policyId} | get policy
  *AuthApi* | [**get_user**](https://pydocs-sdk.lakefs.io/v1.45/docs/AuthApi.html#get_user) | **GET** /auth/users/{userId} | get user
  *AuthApi* | [**list_group_members**](https://pydocs-sdk.lakefs.io/v1.45/docs/AuthApi.html#list_group_members) | **GET** /auth/groups/{groupId}/members | list group members
  *AuthApi* | [**list_group_policies**](https://pydocs-sdk.lakefs.io/v1.45/docs/AuthApi.html#list_group_policies) | **GET** /auth/groups/{groupId}/policies | list group policies
  *AuthApi* | [**list_groups**](https://pydocs-sdk.lakefs.io/v1.45/docs/AuthApi.html#list_groups) | **GET** /auth/groups | list groups
  *AuthApi* | [**list_policies**](https://pydocs-sdk.lakefs.io/v1.45/docs/AuthApi.html#list_policies) | **GET** /auth/policies | list policies
  *AuthApi* | [**list_user_credentials**](https://pydocs-sdk.lakefs.io/v1.45/docs/AuthApi.html#list_user_credentials) | **GET** /auth/users/{userId}/credentials | list user credentials
  *AuthApi* | [**list_user_external_principals**](https://pydocs-sdk.lakefs.io/v1.45/docs/AuthApi.html#list_user_external_principals) | **GET** /auth/users/{userId}/external/principals/ls | list user external policies attached to a user
  *AuthApi* | [**list_user_groups**](https://pydocs-sdk.lakefs.io/v1.45/docs/AuthApi.html#list_user_groups) | **GET** /auth/users/{userId}/groups | list user groups
  *AuthApi* | [**list_user_policies**](https://pydocs-sdk.lakefs.io/v1.45/docs/AuthApi.html#list_user_policies) | **GET** /auth/users/{userId}/policies | list user policies
  *AuthApi* | [**list_users**](https://pydocs-sdk.lakefs.io/v1.45/docs/AuthApi.html#list_users) | **GET** /auth/users | list users
  *AuthApi* | [**login**](https://pydocs-sdk.lakefs.io/v1.45/docs/AuthApi.html#login) | **POST** /auth/login | perform a login
  *AuthApi* | [**set_group_acl**](https://pydocs-sdk.lakefs.io/v1.45/docs/AuthApi.html#set_group_acl) | **POST** /auth/groups/{groupId}/acl | set ACL of group
  *AuthApi* | [**update_policy**](https://pydocs-sdk.lakefs.io/v1.45/docs/AuthApi.html#update_policy) | **PUT** /auth/policies/{policyId} | update policy
  *BranchesApi* | [**cherry_pick**](https://pydocs-sdk.lakefs.io/v1.45/docs/BranchesApi.html#cherry_pick) | **POST** /repositories/{repository}/branches/{branch}/cherry-pick | Replay the changes from the given commit on the branch
  *BranchesApi* | [**create_branch**](https://pydocs-sdk.lakefs.io/v1.45/docs/BranchesApi.html#create_branch) | **POST** /repositories/{repository}/branches | create branch
  *BranchesApi* | [**delete_branch**](https://pydocs-sdk.lakefs.io/v1.45/docs/BranchesApi.html#delete_branch) | **DELETE** /repositories/{repository}/branches/{branch} | delete branch
  *BranchesApi* | [**diff_branch**](https://pydocs-sdk.lakefs.io/v1.45/docs/BranchesApi.html#diff_branch) | **GET** /repositories/{repository}/branches/{branch}/diff | diff branch
  *BranchesApi* | [**get_branch**](https://pydocs-sdk.lakefs.io/v1.45/docs/BranchesApi.html#get_branch) | **GET** /repositories/{repository}/branches/{branch} | get branch
  *BranchesApi* | [**list_branches**](https://pydocs-sdk.lakefs.io/v1.45/docs/BranchesApi.html#list_branches) | **GET** /repositories/{repository}/branches | list branches
  *BranchesApi* | [**reset_branch**](https://pydocs-sdk.lakefs.io/v1.45/docs/BranchesApi.html#reset_branch) | **PUT** /repositories/{repository}/branches/{branch} | reset branch
  *BranchesApi* | [**revert_branch**](https://pydocs-sdk.lakefs.io/v1.45/docs/BranchesApi.html#revert_branch) | **POST** /repositories/{repository}/branches/{branch}/revert | revert
  *CommitsApi* | [**commit**](https://pydocs-sdk.lakefs.io/v1.45/docs/CommitsApi.html#commit) | **POST** /repositories/{repository}/branches/{branch}/commits | create commit
  *CommitsApi* | [**get_commit**](https://pydocs-sdk.lakefs.io/v1.45/docs/CommitsApi.html#get_commit) | **GET** /repositories/{repository}/commits/{commitId} | get commit
  *ConfigApi* | [**get_config**](https://pydocs-sdk.lakefs.io/v1.45/docs/ConfigApi.html#get_config) | **GET** /config |
  *ExperimentalApi* | [**abort_presign_multipart_upload**](https://pydocs-sdk.lakefs.io/v1.45/docs/ExperimentalApi.html#abort_presign_multipart_upload) | **DELETE** /repositories/{repository}/branches/{branch}/staging/pmpu/{uploadId} | Abort a presign multipart upload
  *ExperimentalApi* | [**complete_presign_multipart_upload**](https://pydocs-sdk.lakefs.io/v1.45/docs/ExperimentalApi.html#complete_presign_multipart_upload) | **PUT** /repositories/{repository}/branches/{branch}/staging/pmpu/{uploadId} | Complete a presign multipart upload request
  *ExperimentalApi* | [**create_presign_multipart_upload**](https://pydocs-sdk.lakefs.io/v1.45/docs/ExperimentalApi.html#create_presign_multipart_upload) | **POST** /repositories/{repository}/branches/{branch}/staging/pmpu | Initiate a multipart upload
  *ExperimentalApi* | [**create_pull_request**](https://pydocs-sdk.lakefs.io/v1.45/docs/ExperimentalApi.html#create_pull_request) | **POST** /repositories/{repository}/pulls | create pull request
  *ExperimentalApi* | [**create_user_external_principal**](https://pydocs-sdk.lakefs.io/v1.45/docs/ExperimentalApi.html#create_user_external_principal) | **POST** /auth/users/{userId}/external/principals | attach external principal to user
  *ExperimentalApi* | [**delete_user_external_principal**](https://pydocs-sdk.lakefs.io/v1.45/docs/ExperimentalApi.html#delete_user_external_principal) | **DELETE** /auth/users/{userId}/external/principals | delete external principal from user
  *ExperimentalApi* | [**external_principal_login**](https://pydocs-sdk.lakefs.io/v1.45/docs/ExperimentalApi.html#external_principal_login) | **POST** /auth/external/principal/login | perform a login using an external authenticator
  *ExperimentalApi* | [**get_external_principal**](https://pydocs-sdk.lakefs.io/v1.45/docs/ExperimentalApi.html#get_external_principal) | **GET** /auth/external/principals | describe external principal by id
  *ExperimentalApi* | [**get_pull_request**](https://pydocs-sdk.lakefs.io/v1.45/docs/ExperimentalApi.html#get_pull_request) | **GET** /repositories/{repository}/pulls/{pull_request} | get pull request
  *ExperimentalApi* | [**hard_reset_branch**](https://pydocs-sdk.lakefs.io/v1.45/docs/ExperimentalApi.html#hard_reset_branch) | **PUT** /repositories/{repository}/branches/{branch}/hard_reset | hard reset branch
  *ExperimentalApi* | [**list_pull_requests**](https://pydocs-sdk.lakefs.io/v1.45/docs/ExperimentalApi.html#list_pull_requests) | **GET** /repositories/{repository}/pulls | list pull requests
  *ExperimentalApi* | [**list_user_external_principals**](https://pydocs-sdk.lakefs.io/v1.45/docs/ExperimentalApi.html#list_user_external_principals) | **GET** /auth/users/{userId}/external/principals/ls | list user external policies attached to a user
  *ExperimentalApi* | [**merge_pull_request**](https://pydocs-sdk.lakefs.io/v1.45/docs/ExperimentalApi.html#merge_pull_request) | **PUT** /repositories/{repository}/pulls/{pull_request}/merge | merge pull request
  *ExperimentalApi* | [**sts_login**](https://pydocs-sdk.lakefs.io/v1.45/docs/ExperimentalApi.html#sts_login) | **POST** /sts/login | perform a login with STS
  *ExperimentalApi* | [**update_object_user_metadata**](https://pydocs-sdk.lakefs.io/v1.45/docs/ExperimentalApi.html#update_object_user_metadata) | **PUT** /repositories/{repository}/branches/{branch}/objects/stat/user_metadata | rewrite (all) object metadata
  *ExperimentalApi* | [**update_pull_request**](https://pydocs-sdk.lakefs.io/v1.45/docs/ExperimentalApi.html#update_pull_request) | **PATCH** /repositories/{repository}/pulls/{pull_request} | update pull request
  *ExternalApi* | [**create_user_external_principal**](https://pydocs-sdk.lakefs.io/v1.45/docs/ExternalApi.html#create_user_external_principal) | **POST** /auth/users/{userId}/external/principals | attach external principal to user
  *ExternalApi* | [**delete_user_external_principal**](https://pydocs-sdk.lakefs.io/v1.45/docs/ExternalApi.html#delete_user_external_principal) | **DELETE** /auth/users/{userId}/external/principals | delete external principal from user
  *ExternalApi* | [**external_principal_login**](https://pydocs-sdk.lakefs.io/v1.45/docs/ExternalApi.html#external_principal_login) | **POST** /auth/external/principal/login | perform a login using an external authenticator
  *ExternalApi* | [**get_external_principal**](https://pydocs-sdk.lakefs.io/v1.45/docs/ExternalApi.html#get_external_principal) | **GET** /auth/external/principals | describe external principal by id
  *ExternalApi* | [**list_user_external_principals**](https://pydocs-sdk.lakefs.io/v1.45/docs/ExternalApi.html#list_user_external_principals) | **GET** /auth/users/{userId}/external/principals/ls | list user external policies attached to a user
  *HealthCheckApi* | [**health_check**](https://pydocs-sdk.lakefs.io/v1.45/docs/HealthCheckApi.html#health_check) | **GET** /healthcheck |
  *ImportApi* | [**import_cancel**](https://pydocs-sdk.lakefs.io/v1.45/docs/ImportApi.html#import_cancel) | **DELETE** /repositories/{repository}/branches/{branch}/import | cancel ongoing import
  *ImportApi* | [**import_start**](https://pydocs-sdk.lakefs.io/v1.45/docs/ImportApi.html#import_start) | **POST** /repositories/{repository}/branches/{branch}/import | import data from object store
  *ImportApi* | [**import_status**](https://pydocs-sdk.lakefs.io/v1.45/docs/ImportApi.html#import_status) | **GET** /repositories/{repository}/branches/{branch}/import | get import status
  *InternalApi* | [**create_branch_protection_rule_preflight**](https://pydocs-sdk.lakefs.io/v1.45/docs/InternalApi.html#create_branch_protection_rule_preflight) | **GET** /repositories/{repository}/branch_protection/set_allowed |
  *InternalApi* | [**create_commit_record**](https://pydocs-sdk.lakefs.io/v1.45/docs/InternalApi.html#create_commit_record) | **POST** /repositories/{repository}/commits | create commit record
  *InternalApi* | [**create_symlink_file**](https://pydocs-sdk.lakefs.io/v1.45/docs/InternalApi.html#create_symlink_file) | **POST** /repositories/{repository}/refs/{branch}/symlink | creates symlink files corresponding to the given directory
  *InternalApi* | [**delete_repository_metadata**](https://pydocs-sdk.lakefs.io/v1.45/docs/InternalApi.html#delete_repository_metadata) | **DELETE** /repositories/{repository}/metadata | delete repository metadata
  *InternalApi* | [**dump_refs**](https://pydocs-sdk.lakefs.io/v1.45/docs/InternalApi.html#dump_refs) | **PUT** /repositories/{repository}/refs/dump | Dump repository refs (tags, commits, branches) to object store Deprecated: a new API will introduce long running operations
  *InternalApi* | [**get_auth_capabilities**](https://pydocs-sdk.lakefs.io/v1.45/docs/InternalApi.html#get_auth_capabilities) | **GET** /auth/capabilities | list authentication capabilities supported
  *InternalApi* | [**get_garbage_collection_config**](https://pydocs-sdk.lakefs.io/v1.45/docs/InternalApi.html#get_garbage_collection_config) | **GET** /config/garbage-collection |
  *InternalApi* | [**get_lake_fs_version**](https://pydocs-sdk.lakefs.io/v1.45/docs/InternalApi.html#get_lake_fs_version) | **GET** /config/version |
  *InternalApi* | [**get_metadata_object**](https://pydocs-sdk.lakefs.io/v1.45/docs/InternalApi.html#get_metadata_object) | **GET** /repositories/{repository}/metadata/object/{type}/{object_id} | return a lakeFS metadata object by ID
  *InternalApi* | [**get_setup_state**](https://pydocs-sdk.lakefs.io/v1.45/docs/InternalApi.html#get_setup_state) | **GET** /setup_lakefs | check if the lakeFS installation is already set up
  *InternalApi* | [**get_storage_config**](https://pydocs-sdk.lakefs.io/v1.45/docs/InternalApi.html#get_storage_config) | **GET** /config/storage |
  *InternalApi* | [**get_usage_report_summary**](https://pydocs-sdk.lakefs.io/v1.45/docs/InternalApi.html#get_usage_report_summary) | **GET** /usage-report/summary | get usage report summary
  *InternalApi* | [**internal_create_branch_protection_rule**](https://pydocs-sdk.lakefs.io/v1.45/docs/InternalApi.html#internal_create_branch_protection_rule) | **POST** /repositories/{repository}/branch_protection |
  *InternalApi* | [**internal_delete_branch_protection_rule**](https://pydocs-sdk.lakefs.io/v1.45/docs/InternalApi.html#internal_delete_branch_protection_rule) | **DELETE** /repositories/{repository}/branch_protection |
  *InternalApi* | [**internal_delete_garbage_collection_rules**](https://pydocs-sdk.lakefs.io/v1.45/docs/InternalApi.html#internal_delete_garbage_collection_rules) | **DELETE** /repositories/{repository}/gc/rules |
  *InternalApi* | [**internal_get_branch_protection_rules**](https://pydocs-sdk.lakefs.io/v1.45/docs/InternalApi.html#internal_get_branch_protection_rules) | **GET** /repositories/{repository}/branch_protection | get branch protection rules
  *InternalApi* | [**internal_get_garbage_collection_rules**](https://pydocs-sdk.lakefs.io/v1.45/docs/InternalApi.html#internal_get_garbage_collection_rules) | **GET** /repositories/{repository}/gc/rules |
  *InternalApi* | [**internal_set_garbage_collection_rules**](https://pydocs-sdk.lakefs.io/v1.45/docs/InternalApi.html#internal_set_garbage_collection_rules) | **POST** /repositories/{repository}/gc/rules |
  *InternalApi* | [**post_stats_events**](https://pydocs-sdk.lakefs.io/v1.45/docs/InternalApi.html#post_stats_events) | **POST** /statistics | post stats events, this endpoint is meant for internal use only
  *InternalApi* | [**prepare_garbage_collection_commits**](https://pydocs-sdk.lakefs.io/v1.45/docs/InternalApi.html#prepare_garbage_collection_commits) | **POST** /repositories/{repository}/gc/prepare_commits | save lists of active commits for garbage collection
  *InternalApi* | [**prepare_garbage_collection_uncommitted**](https://pydocs-sdk.lakefs.io/v1.45/docs/InternalApi.html#prepare_garbage_collection_uncommitted) | **POST** /repositories/{repository}/gc/prepare_uncommited | save repository uncommitted metadata for garbage collection
  *InternalApi* | [**restore_refs**](https://pydocs-sdk.lakefs.io/v1.45/docs/InternalApi.html#restore_refs) | **PUT** /repositories/{repository}/refs/restore | Restore repository refs (tags, commits, branches) from object store. Deprecated: a new API will introduce long running operations
  *InternalApi* | [**set_garbage_collection_rules_preflight**](https://pydocs-sdk.lakefs.io/v1.45/docs/InternalApi.html#set_garbage_collection_rules_preflight) | **GET** /repositories/{repository}/gc/rules/set_allowed |
  *InternalApi* | [**set_repository_metadata**](https://pydocs-sdk.lakefs.io/v1.45/docs/InternalApi.html#set_repository_metadata) | **POST** /repositories/{repository}/metadata | set repository metadata
  *InternalApi* | [**setup**](https://pydocs-sdk.lakefs.io/v1.45/docs/InternalApi.html#setup) | **POST** /setup_lakefs | setup lakeFS and create a first user
  *InternalApi* | [**setup_comm_prefs**](https://pydocs-sdk.lakefs.io/v1.45/docs/InternalApi.html#setup_comm_prefs) | **POST** /setup_comm_prefs | setup communications preferences
  *InternalApi* | [**stage_object**](https://pydocs-sdk.lakefs.io/v1.45/docs/InternalApi.html#stage_object) | **PUT** /repositories/{repository}/branches/{branch}/objects | stage an object&#39;s metadata for the given branch
  *InternalApi* | [**upload_object_preflight**](https://pydocs-sdk.lakefs.io/v1.45/docs/InternalApi.html#upload_object_preflight) | **GET** /repositories/{repository}/branches/{branch}/objects/stage_allowed |
  *MetadataApi* | [**get_meta_range**](https://pydocs-sdk.lakefs.io/v1.45/docs/MetadataApi.html#get_meta_range) | **GET** /repositories/{repository}/metadata/meta_range/{meta_range} | return URI to a meta-range file
  *MetadataApi* | [**get_range**](https://pydocs-sdk.lakefs.io/v1.45/docs/MetadataApi.html#get_range) | **GET** /repositories/{repository}/metadata/range/{range} | return URI to a range file
  *ObjectsApi* | [**copy_object**](https://pydocs-sdk.lakefs.io/v1.45/docs/ObjectsApi.html#copy_object) | **POST** /repositories/{repository}/branches/{branch}/objects/copy | create a copy of an object
  *ObjectsApi* | [**delete_object**](https://pydocs-sdk.lakefs.io/v1.45/docs/ObjectsApi.html#delete_object) | **DELETE** /repositories/{repository}/branches/{branch}/objects | delete object. Missing objects will not return a NotFound error.
  *ObjectsApi* | [**delete_objects**](https://pydocs-sdk.lakefs.io/v1.45/docs/ObjectsApi.html#delete_objects) | **POST** /repositories/{repository}/branches/{branch}/objects/delete | delete objects. Missing objects will not return a NotFound error.
  *ObjectsApi* | [**get_object**](https://pydocs-sdk.lakefs.io/v1.45/docs/ObjectsApi.html#get_object) | **GET** /repositories/{repository}/refs/{ref}/objects | get object content
  *ObjectsApi* | [**get_underlying_properties**](https://pydocs-sdk.lakefs.io/v1.45/docs/ObjectsApi.html#get_underlying_properties) | **GET** /repositories/{repository}/refs/{ref}/objects/underlyingProperties | get object properties on underlying storage
  *ObjectsApi* | [**head_object**](https://pydocs-sdk.lakefs.io/v1.45/docs/ObjectsApi.html#head_object) | **HEAD** /repositories/{repository}/refs/{ref}/objects | check if object exists
  *ObjectsApi* | [**list_objects**](https://pydocs-sdk.lakefs.io/v1.45/docs/ObjectsApi.html#list_objects) | **GET** /repositories/{repository}/refs/{ref}/objects/ls | list objects under a given prefix
  *ObjectsApi* | [**stat_object**](https://pydocs-sdk.lakefs.io/v1.45/docs/ObjectsApi.html#stat_object) | **GET** /repositories/{repository}/refs/{ref}/objects/stat | get object metadata
  *ObjectsApi* | [**update_object_user_metadata**](https://pydocs-sdk.lakefs.io/v1.45/docs/ObjectsApi.html#update_object_user_metadata) | **PUT** /repositories/{repository}/branches/{branch}/objects/stat/user_metadata | rewrite (all) object metadata
  *ObjectsApi* | [**upload_object**](https://pydocs-sdk.lakefs.io/v1.45/docs/ObjectsApi.html#upload_object) | **POST** /repositories/{repository}/branches/{branch}/objects |
  *PullsApi* | [**create_pull_request**](https://pydocs-sdk.lakefs.io/v1.45/docs/PullsApi.html#create_pull_request) | **POST** /repositories/{repository}/pulls | create pull request
  *PullsApi* | [**get_pull_request**](https://pydocs-sdk.lakefs.io/v1.45/docs/PullsApi.html#get_pull_request) | **GET** /repositories/{repository}/pulls/{pull_request} | get pull request
  *PullsApi* | [**list_pull_requests**](https://pydocs-sdk.lakefs.io/v1.45/docs/PullsApi.html#list_pull_requests) | **GET** /repositories/{repository}/pulls | list pull requests
  *PullsApi* | [**merge_pull_request**](https://pydocs-sdk.lakefs.io/v1.45/docs/PullsApi.html#merge_pull_request) | **PUT** /repositories/{repository}/pulls/{pull_request}/merge | merge pull request
  *PullsApi* | [**update_pull_request**](https://pydocs-sdk.lakefs.io/v1.45/docs/PullsApi.html#update_pull_request) | **PATCH** /repositories/{repository}/pulls/{pull_request} | update pull request
  *RefsApi* | [**diff_refs**](https://pydocs-sdk.lakefs.io/v1.45/docs/RefsApi.html#diff_refs) | **GET** /repositories/{repository}/refs/{leftRef}/diff/{rightRef} | diff references
  *RefsApi* | [**find_merge_base**](https://pydocs-sdk.lakefs.io/v1.45/docs/RefsApi.html#find_merge_base) | **GET** /repositories/{repository}/refs/{sourceRef}/merge/{destinationBranch} | find the merge base for 2 references
  *RefsApi* | [**log_commits**](https://pydocs-sdk.lakefs.io/v1.45/docs/RefsApi.html#log_commits) | **GET** /repositories/{repository}/refs/{ref}/commits | get commit log from ref. If both objects and prefixes are empty, return all commits.
  *RefsApi* | [**merge_into_branch**](https://pydocs-sdk.lakefs.io/v1.45/docs/RefsApi.html#merge_into_branch) | **POST** /repositories/{repository}/refs/{sourceRef}/merge/{destinationBranch} | merge references
  *RepositoriesApi* | [**create_repository**](https://pydocs-sdk.lakefs.io/v1.45/docs/RepositoriesApi.html#create_repository) | **POST** /repositories | create repository
  *RepositoriesApi* | [**delete_gc_rules**](https://pydocs-sdk.lakefs.io/v1.45/docs/RepositoriesApi.html#delete_gc_rules) | **DELETE** /repositories/{repository}/settings/gc_rules |
  *RepositoriesApi* | [**delete_repository**](https://pydocs-sdk.lakefs.io/v1.45/docs/RepositoriesApi.html#delete_repository) | **DELETE** /repositories/{repository} | delete repository
  *RepositoriesApi* | [**dump_status**](https://pydocs-sdk.lakefs.io/v1.45/docs/RepositoriesApi.html#dump_status) | **GET** /repositories/{repository}/dump | Status of a repository dump task
  *RepositoriesApi* | [**dump_submit**](https://pydocs-sdk.lakefs.io/v1.45/docs/RepositoriesApi.html#dump_submit) | **POST** /repositories/{repository}/dump | Backup the repository metadata (tags, commits, branches) and save the backup to the object store.
  *RepositoriesApi* | [**get_branch_protection_rules**](https://pydocs-sdk.lakefs.io/v1.45/docs/RepositoriesApi.html#get_branch_protection_rules) | **GET** /repositories/{repository}/settings/branch_protection | get branch protection rules
  *RepositoriesApi* | [**get_gc_rules**](https://pydocs-sdk.lakefs.io/v1.45/docs/RepositoriesApi.html#get_gc_rules) | **GET** /repositories/{repository}/settings/gc_rules | get repository GC rules
  *RepositoriesApi* | [**get_repository**](https://pydocs-sdk.lakefs.io/v1.45/docs/RepositoriesApi.html#get_repository) | **GET** /repositories/{repository} | get repository
  *RepositoriesApi* | [**get_repository_metadata**](https://pydocs-sdk.lakefs.io/v1.45/docs/RepositoriesApi.html#get_repository_metadata) | **GET** /repositories/{repository}/metadata | get repository metadata
  *RepositoriesApi* | [**list_repositories**](https://pydocs-sdk.lakefs.io/v1.45/docs/RepositoriesApi.html#list_repositories) | **GET** /repositories | list repositories
  *RepositoriesApi* | [**restore_status**](https://pydocs-sdk.lakefs.io/v1.45/docs/RepositoriesApi.html#restore_status) | **GET** /repositories/{repository}/restore | Status of a restore request
  *RepositoriesApi* | [**restore_submit**](https://pydocs-sdk.lakefs.io/v1.45/docs/RepositoriesApi.html#restore_submit) | **POST** /repositories/{repository}/restore | Restore repository from a dump in the object store
  *RepositoriesApi* | [**set_branch_protection_rules**](https://pydocs-sdk.lakefs.io/v1.45/docs/RepositoriesApi.html#set_branch_protection_rules) | **PUT** /repositories/{repository}/settings/branch_protection |
  *RepositoriesApi* | [**set_gc_rules**](https://pydocs-sdk.lakefs.io/v1.45/docs/RepositoriesApi.html#set_gc_rules) | **PUT** /repositories/{repository}/settings/gc_rules |
  *StagingApi* | [**get_physical_address**](https://pydocs-sdk.lakefs.io/v1.45/docs/StagingApi.html#get_physical_address) | **GET** /repositories/{repository}/branches/{branch}/staging/backing | generate an address to which the client can upload an object
  *StagingApi* | [**link_physical_address**](https://pydocs-sdk.lakefs.io/v1.45/docs/StagingApi.html#link_physical_address) | **PUT** /repositories/{repository}/branches/{branch}/staging/backing | associate staging on this physical address with a path
  *TagsApi* | [**create_tag**](https://pydocs-sdk.lakefs.io/v1.45/docs/TagsApi.html#create_tag) | **POST** /repositories/{repository}/tags | create tag
  *TagsApi* | [**delete_tag**](https://pydocs-sdk.lakefs.io/v1.45/docs/TagsApi.html#delete_tag) | **DELETE** /repositories/{repository}/tags/{tag} | delete tag
  *TagsApi* | [**get_tag**](https://pydocs-sdk.lakefs.io/v1.45/docs/TagsApi.html#get_tag) | **GET** /repositories/{repository}/tags/{tag} | get tag
  *TagsApi* | [**list_tags**](https://pydocs-sdk.lakefs.io/v1.45/docs/TagsApi.html#list_tags) | **GET** /repositories/{repository}/tags | list tags

   - [ACL](https://pydocs-sdk.lakefs.io/v1.45/docs/ACL.html)
   - [AbortPresignMultipartUpload](https://pydocs-sdk.lakefs.io/v1.45/docs/AbortPresignMultipartUpload.html)
   - [AccessKeyCredentials](https://pydocs-sdk.lakefs.io/v1.45/docs/AccessKeyCredentials.html)
   - [ActionRun](https://pydocs-sdk.lakefs.io/v1.45/docs/ActionRun.html)
   - [ActionRunList](https://pydocs-sdk.lakefs.io/v1.45/docs/ActionRunList.html)
   - [AuthCapabilities](https://pydocs-sdk.lakefs.io/v1.45/docs/AuthCapabilities.html)
   - [AuthenticationToken](https://pydocs-sdk.lakefs.io/v1.45/docs/AuthenticationToken.html)
   - [BranchCreation](https://pydocs-sdk.lakefs.io/v1.45/docs/BranchCreation.html)
   - [BranchProtectionRule](https://pydocs-sdk.lakefs.io/v1.45/docs/BranchProtectionRule.html)
   - [CherryPickCreation](https://pydocs-sdk.lakefs.io/v1.45/docs/CherryPickCreation.html)
   - [CommPrefsInput](https://pydocs-sdk.lakefs.io/v1.45/docs/CommPrefsInput.html)
   - [Commit](https://pydocs-sdk.lakefs.io/v1.45/docs/Commit.html)
   - [CommitCreation](https://pydocs-sdk.lakefs.io/v1.45/docs/CommitCreation.html)
   - [CommitList](https://pydocs-sdk.lakefs.io/v1.45/docs/CommitList.html)
   - [CommitOverrides](https://pydocs-sdk.lakefs.io/v1.45/docs/CommitOverrides.html)
   - [CommitRecordCreation](https://pydocs-sdk.lakefs.io/v1.45/docs/CommitRecordCreation.html)
   - [CompletePresignMultipartUpload](https://pydocs-sdk.lakefs.io/v1.45/docs/CompletePresignMultipartUpload.html)
   - [Config](https://pydocs-sdk.lakefs.io/v1.45/docs/Config.html)
   - [Credentials](https://pydocs-sdk.lakefs.io/v1.45/docs/Credentials.html)
   - [CredentialsList](https://pydocs-sdk.lakefs.io/v1.45/docs/CredentialsList.html)
   - [CredentialsWithSecret](https://pydocs-sdk.lakefs.io/v1.45/docs/CredentialsWithSecret.html)
   - [CurrentUser](https://pydocs-sdk.lakefs.io/v1.45/docs/CurrentUser.html)
   - [Diff](https://pydocs-sdk.lakefs.io/v1.45/docs/Diff.html)
   - [DiffList](https://pydocs-sdk.lakefs.io/v1.45/docs/DiffList.html)
   - [Error](https://pydocs-sdk.lakefs.io/v1.45/docs/Error.html)
   - [ErrorNoACL](https://pydocs-sdk.lakefs.io/v1.45/docs/ErrorNoACL.html)
   - [ExternalLoginInformation](https://pydocs-sdk.lakefs.io/v1.45/docs/ExternalLoginInformation.html)
   - [ExternalPrincipal](https://pydocs-sdk.lakefs.io/v1.45/docs/ExternalPrincipal.html)
   - [ExternalPrincipalCreation](https://pydocs-sdk.lakefs.io/v1.45/docs/ExternalPrincipalCreation.html)
   - [ExternalPrincipalList](https://pydocs-sdk.lakefs.io/v1.45/docs/ExternalPrincipalList.html)
   - [FindMergeBaseResult](https://pydocs-sdk.lakefs.io/v1.45/docs/FindMergeBaseResult.html)
   - [GarbageCollectionConfig](https://pydocs-sdk.lakefs.io/v1.45/docs/GarbageCollectionConfig.html)
   - [GarbageCollectionPrepareResponse](https://pydocs-sdk.lakefs.io/v1.45/docs/GarbageCollectionPrepareResponse.html)
   - [GarbageCollectionRule](https://pydocs-sdk.lakefs.io/v1.45/docs/GarbageCollectionRule.html)
   - [GarbageCollectionRules](https://pydocs-sdk.lakefs.io/v1.45/docs/GarbageCollectionRules.html)
   - [Group](https://pydocs-sdk.lakefs.io/v1.45/docs/Group.html)
   - [GroupCreation](https://pydocs-sdk.lakefs.io/v1.45/docs/GroupCreation.html)
   - [GroupList](https://pydocs-sdk.lakefs.io/v1.45/docs/GroupList.html)
   - [HookRun](https://pydocs-sdk.lakefs.io/v1.45/docs/HookRun.html)
   - [HookRunList](https://pydocs-sdk.lakefs.io/v1.45/docs/HookRunList.html)
   - [ImportCreation](https://pydocs-sdk.lakefs.io/v1.45/docs/ImportCreation.html)
   - [ImportCreationResponse](https://pydocs-sdk.lakefs.io/v1.45/docs/ImportCreationResponse.html)
   - [ImportLocation](https://pydocs-sdk.lakefs.io/v1.45/docs/ImportLocation.html)
   - [ImportStatus](https://pydocs-sdk.lakefs.io/v1.45/docs/ImportStatus.html)
   - [InstallationUsageReport](https://pydocs-sdk.lakefs.io/v1.45/docs/InstallationUsageReport.html)
   - [InternalDeleteBranchProtectionRuleRequest](https://pydocs-sdk.lakefs.io/v1.45/docs/InternalDeleteBranchProtectionRuleRequest.html)
   - [LoginConfig](https://pydocs-sdk.lakefs.io/v1.45/docs/LoginConfig.html)
   - [LoginInformation](https://pydocs-sdk.lakefs.io/v1.45/docs/LoginInformation.html)
   - [Merge](https://pydocs-sdk.lakefs.io/v1.45/docs/Merge.html)
   - [MergeResult](https://pydocs-sdk.lakefs.io/v1.45/docs/MergeResult.html)
   - [MetaRangeCreation](https://pydocs-sdk.lakefs.io/v1.45/docs/MetaRangeCreation.html)
   - [MetaRangeCreationResponse](https://pydocs-sdk.lakefs.io/v1.45/docs/MetaRangeCreationResponse.html)
   - [ObjectCopyCreation](https://pydocs-sdk.lakefs.io/v1.45/docs/ObjectCopyCreation.html)
   - [ObjectError](https://pydocs-sdk.lakefs.io/v1.45/docs/ObjectError.html)
   - [ObjectErrorList](https://pydocs-sdk.lakefs.io/v1.45/docs/ObjectErrorList.html)
   - [ObjectStageCreation](https://pydocs-sdk.lakefs.io/v1.45/docs/ObjectStageCreation.html)
   - [ObjectStats](https://pydocs-sdk.lakefs.io/v1.45/docs/ObjectStats.html)
   - [ObjectStatsList](https://pydocs-sdk.lakefs.io/v1.45/docs/ObjectStatsList.html)
   - [Pagination](https://pydocs-sdk.lakefs.io/v1.45/docs/Pagination.html)
   - [PathList](https://pydocs-sdk.lakefs.io/v1.45/docs/PathList.html)
   - [Policy](https://pydocs-sdk.lakefs.io/v1.45/docs/Policy.html)
   - [PolicyList](https://pydocs-sdk.lakefs.io/v1.45/docs/PolicyList.html)
   - [PrepareGCUncommittedRequest](https://pydocs-sdk.lakefs.io/v1.45/docs/PrepareGCUncommittedRequest.html)
   - [PrepareGCUncommittedResponse](https://pydocs-sdk.lakefs.io/v1.45/docs/PrepareGCUncommittedResponse.html)
   - [PresignMultipartUpload](https://pydocs-sdk.lakefs.io/v1.45/docs/PresignMultipartUpload.html)
   - [PullRequest](https://pydocs-sdk.lakefs.io/v1.45/docs/PullRequest.html)
   - [PullRequestBasic](https://pydocs-sdk.lakefs.io/v1.45/docs/PullRequestBasic.html)
   - [PullRequestCreation](https://pydocs-sdk.lakefs.io/v1.45/docs/PullRequestCreation.html)
   - [PullRequestCreationResponse](https://pydocs-sdk.lakefs.io/v1.45/docs/PullRequestCreationResponse.html)
   - [PullRequestsList](https://pydocs-sdk.lakefs.io/v1.45/docs/PullRequestsList.html)
   - [RangeMetadata](https://pydocs-sdk.lakefs.io/v1.45/docs/RangeMetadata.html)
   - [Ref](https://pydocs-sdk.lakefs.io/v1.45/docs/Ref.html)
   - [RefList](https://pydocs-sdk.lakefs.io/v1.45/docs/RefList.html)
   - [RefsDump](https://pydocs-sdk.lakefs.io/v1.45/docs/RefsDump.html)
   - [RefsRestore](https://pydocs-sdk.lakefs.io/v1.45/docs/RefsRestore.html)
   - [Repository](https://pydocs-sdk.lakefs.io/v1.45/docs/Repository.html)
   - [RepositoryCreation](https://pydocs-sdk.lakefs.io/v1.45/docs/RepositoryCreation.html)
   - [RepositoryDumpStatus](https://pydocs-sdk.lakefs.io/v1.45/docs/RepositoryDumpStatus.html)
   - [RepositoryList](https://pydocs-sdk.lakefs.io/v1.45/docs/RepositoryList.html)
   - [RepositoryMetadataKeys](https://pydocs-sdk.lakefs.io/v1.45/docs/RepositoryMetadataKeys.html)
   - [RepositoryMetadataSet](https://pydocs-sdk.lakefs.io/v1.45/docs/RepositoryMetadataSet.html)
   - [RepositoryRestoreStatus](https://pydocs-sdk.lakefs.io/v1.45/docs/RepositoryRestoreStatus.html)
   - [ResetCreation](https://pydocs-sdk.lakefs.io/v1.45/docs/ResetCreation.html)
   - [RevertCreation](https://pydocs-sdk.lakefs.io/v1.45/docs/RevertCreation.html)
   - [Setup](https://pydocs-sdk.lakefs.io/v1.45/docs/Setup.html)
   - [SetupState](https://pydocs-sdk.lakefs.io/v1.45/docs/SetupState.html)
   - [StagingLocation](https://pydocs-sdk.lakefs.io/v1.45/docs/StagingLocation.html)
   - [StagingMetadata](https://pydocs-sdk.lakefs.io/v1.45/docs/StagingMetadata.html)
   - [Statement](https://pydocs-sdk.lakefs.io/v1.45/docs/Statement.html)
   - [StatsEvent](https://pydocs-sdk.lakefs.io/v1.45/docs/StatsEvent.html)
   - [StatsEventsList](https://pydocs-sdk.lakefs.io/v1.45/docs/StatsEventsList.html)
   - [StorageConfig](https://pydocs-sdk.lakefs.io/v1.45/docs/StorageConfig.html)
   - [StorageURI](https://pydocs-sdk.lakefs.io/v1.45/docs/StorageURI.html)
   - [StsAuthRequest](https://pydocs-sdk.lakefs.io/v1.45/docs/StsAuthRequest.html)
   - [TagCreation](https://pydocs-sdk.lakefs.io/v1.45/docs/TagCreation.html)
   - [TaskInfo](https://pydocs-sdk.lakefs.io/v1.45/docs/TaskInfo.html)
   - [UnderlyingObjectProperties](https://pydocs-sdk.lakefs.io/v1.45/docs/UnderlyingObjectProperties.html)
   - [UpdateObjectUserMetadata](https://pydocs-sdk.lakefs.io/v1.45/docs/UpdateObjectUserMetadata.html)
   - [UpdateToken](https://pydocs-sdk.lakefs.io/v1.45/docs/UpdateToken.html)
   - [UploadPart](https://pydocs-sdk.lakefs.io/v1.45/docs/UploadPart.html)
   - [UsageReport](https://pydocs-sdk.lakefs.io/v1.45/docs/UsageReport.html)
   - [User](https://pydocs-sdk.lakefs.io/v1.45/docs/User.html)
   - [UserCreation](https://pydocs-sdk.lakefs.io/v1.45/docs/UserCreation.html)
   - [UserList](https://pydocs-sdk.lakefs.io/v1.45/docs/UserList.html)
   - [VersionConfig](https://pydocs-sdk.lakefs.io/v1.45/docs/VersionConfig.html)
  <a id="documentation-for-authorization"></a>

  Authentication schemes defined for the API:
  <a id="basic_auth"></a>

  - **Type**: HTTP basic authentication
  <a id="jwt_token"></a>

  - **Type**: Bearer authentication (JWT)
  <a id="cookie_auth"></a>

  - **Type**: API key
  - **API key parameter name**: internal_auth_session
  - **Location**:
  <a id="oidc_auth"></a>

  - **Type**: API key
  - **API key parameter name**: oidc_auth_session
  - **Location**:
  <a id="saml_auth"></a>

  - **Type**: API key
  - **API key parameter name**: saml_auth_session
  - **Location**:

  services@treeverse.io


pkgId: f900caf74384fb7b0be788990c7bca5be755ad6423ea2109df1afd96db0b4659
name: python-laktory-help
arch: noarch
version: 0.5.8
epoch: 0
release: 1
summary: Development documents and examples for laktory
url: https://github.com/opencubes-ai/laktory
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-laktory-0.5.8-1.src.rpm
location_href: Packages/python-laktory-help-0.5.8-1.noarch.rpm
checksum_type: sha256
description:
  [![pypi](https://img.shields.io/pypi/v/laktory.svg)](https://pypi.org/project/laktory/)
  [![test](https://github.com/okube-ai/laktory/actions/workflows/test.yml/badge.svg)](https://github.com/okube-ai/laktory/actions/workflows/test.yml)
  [![downloads](https://static.pepy.tech/badge/laktory/month)](https://pepy.tech/project/laktory)
  [![versions](https://img.shields.io/pypi/pyversions/laktory.svg)](https://github.com/okube-ai/laktory)
  [![license](https://img.shields.io/github/license/okube-ai/laktory.svg)](https://github.com/okube-ai/laktory/blob/main/LICENSE)

  An open-source DataOps and dataframe-centric ETL framework for building
  lakehouses.

  <img src="docs/images/logo_sg.png" alt="laktory logo" width="85"/>

  Laktory is your all-in-one solution for defining both data transformations and
  Databricks resources. Imagine if Terraform, Databricks Asset Bundles, and dbt
  combined forces—that’s essentially Laktory.

  This open-source framework simplifies the creation, deployment, and execution
  of data pipelines while adhering to essential DevOps practices like version
  control, code reviews, and CI/CD integration. With Apache Spark and Polars
  driving its data transformation, Laktory ensures reliable and scalable data
  processing. Its modular, flexible approach allows you to seamlessly combine SQL
  statements with DataFrame operations.

  <img src="docs/images/laktory_diagram.png" alt="what is laktory" width="800"/>

  Since Laktory pipelines are built on top of Spark and Polars, they can run in
  any environment that supports python—from your local machine to a Kubernetes
  cluster. They can also be deployed and orchestrated as Databricks Jobs or
  [Delta Live Tables](https://www.databricks.com/product/delta-live-tables),
  offering a simple, fully managed, and low-maintenance solution.

  But Laktory goes beyond data pipelines. It empowers you to define and deploy
  your entire Databricks data platform—from Unity Catalog and access grants
  to compute and quality monitoring—providing a complete, modern solution
  for data platform management. This empowers your data team to take full
  ownership of the solution, eliminating the need to juggle multiple technologies.
  Say goodbye to relying on external Terraform experts to handle compute, workspace
  configuration, and Unity Catalog, while your data engineers and analysts try
  to combine Databricks Asset Bundles and dbt to build data pipelines. Laktory
  consolidates these functions, simplifying the entire process and reducing
  the overall cost.

  <img src="docs/images/why_simplicity.png" alt="dataops" width="500"/>



  See [documentation](https://www.laktory.ai/) for more details.


  Install using
  ```commandline
  pip install laktory
  ```

  For more installation options,
  see the [Install](https://www.laktory.ai/install/) section in the documentation.


  ```py
  from laktory import models


  node_brz = models.PipelineNode(
      name="brz_stock_prices",
      source={
          "format": "PARQUET",
          "path": "./data/brz_stock_prices/"
      },
      transformer={
          "nodes": [
          ]
      }
  )

  node_slv = models.PipelineNode(
      name="slv_stock_prices",
      source={
          "node_name": "brz_stock_prices"
      },
      sinks=[{
          "path": "./data/slv_stock_prices",
          "mode": "OVERWRITE",
          "format": "PARQUET",
      }],
      transformer={
          "nodes": [

              
              {
                  "sql_expr": """
                      SELECT
                        data.created_at AS created_at,
                        data.symbol AS symbol,
                        data.open AS open,
                        data.close AS close,
                        data.high AS high,
                        data.low AS low,
                        data.volume AS volume
                      FROM
                        {df}
                  """
              },

              
              {
                  "func_name": "drop_duplicates",
                  "func_kwargs": {
                      "subset": ["created_at", "symbol"]
                  }
              },
          ]
      }
  )

  pipeline = models.Pipeline(
      name="stock_prices",
      nodes=[node_brz, node_slv],
  )

  print(pipeline)


  pipeline.execute(spark=spark)
  ```

  To get started with a more useful example, jump into the [Quickstart](https://www.laktory.ai/quickstart/).



  A comprehensive template on how to deploy a lakehouse as code using Laktory is maintained here:
  https://github.com/okube-ai/lakehouse-as-code.

  In this template, 4 pulumi projects are used to:
  - `{cloud_provider}_infra`: Deploy the required resources on your cloud provider
  - `unity-catalog`: Setup users, groups, catalogs, schemas and manage grants
  - `workspace`: Setup secrets, clusters and warehouses and common files/notebooks
  - `workflows`: The data workflows to build your lakehouse


  <img src="docs/images/okube.png" alt="okube logo" width="85"/>

  [Okube](https://www.okube.ai) is dedicated to building open source frameworks, known as the *kubes*, empowering businesses to build, deploy and operate highly scalable data platforms and AI models.


pkgId: 18371d726d970c9fe81cc91ae154d88709b360543b00e5911604ae77fe8bec74
name: python-lambdapdk-help
arch: noarch
version: 0.1.41
epoch: 0
release: 1
summary: Development documents and examples for lambdapdk
url: https://github.com/siliconcompiler/lambdapdk
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-lambdapdk-0.1.41-1.src.rpm
location_href: Packages/python-lambdapdk-help-0.1.41-1.noarch.rpm
checksum_type: sha256
description:
  The Lambdapdk project includes a number of open source Process Design Kits (PDKs). The original source of these PDKs is documented in the README file for each PDK. Cell level mapping is included to the generic technology independent [Lambdalib](https://github.com/siliconcompiler/lambdalib) library.

  Lambdapdk is supported by the [SiliconCompiler](https://github.com/siliconcompiler/siliconcompiler) project.


  Supported PDKs:

  * [ASAP7](lambdapdk/asap7/README.md)
  * [FreePDK45](lambdapdk/freepdk45/base/README.md)
  * [Skywater130](lambdapdk/sky130/base/README.md)
  * [Global Foundries 180](lambdapdk/gf180/README.md)
  * [IHP 180](https://github.com/IHP-GmbH/IHP-Open-PDK)
  * [interposer](lambdapdk/interposer/README.md)



  [Apache License 2.0](LICENSE)

  Specific PDK licences can be found in their respective folders.



  We use [GitHub Issues](https://github.com/siliconcompiler/lambdapdk/issues)
  for tracking requests and bugs.

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  Copyright 2023 Zero ASIC Corporation  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: b72b94b0a64ed995090c4caddd69148bcbbcdb0e48a14c19b0618fa7ed5a6937
name: python-lamindb-help
arch: noarch
version: 0.77.3
epoch: 0
release: 1
summary: Development documents and examples for lamindb
url: https://pypi.org/project/lamindb/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-lamindb-0.77.3-1.src.rpm
location_href: Packages/python-lamindb-help-0.77.3-1.noarch.rpm
checksum_type: sha256
description:
  [![Stars](https://img.shields.io/github/stars/laminlabs/lamindb?logo=GitHub&color=yellow)](https://github.com/laminlabs/lamindb)
  [![codecov](https://codecov.io/gh/laminlabs/lamindb/branch/main/graph/badge.svg?token=VKMRJ7OWR3)](https://codecov.io/gh/laminlabs/lamindb)
  [![pypi](https://img.shields.io/pypi/v/lamindb?color=blue&label=pypi%20package)](https://pypi.org/project/lamindb)



  Read the [docs](https://docs.lamin.ai).


pkgId: ddb68fe99cf03f659312fb108de417311779193f8b826e244cf992c888018f1f
name: python-landscape-widget
arch: noarch
version: 0.3.4
epoch: 0
release: 1
summary: Jupyter widget for interactive graph visualization
url: https://pypi.org/project/landscape-widget/
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-landscape-widget-0.3.4-1.src.rpm
location_href: Packages/python-landscape-widget-0.3.4-1.noarch.rpm
checksum_type: sha256
description:
  `landscape-widget` is part of [Cobalt](https://cobalt.bluelightai.com), a toolkit for
  illuminating and improving AI models and datasets.

  Visit our website at [bluelightai.com](https://bluelightai.com).

rpm_license:
  BluelightAI Cobalt Commercial Trial License and Non-Commercial License 1.0.0 ============================================================================  ACCEPTANCE  In order to get any license under these terms, you must agree to them as both strict obligations and conditions to all your licenses.  COPYRIGHT LICENSE  The licensor grants you a copyright license for the software to do everything you might do with the software that would otherwise infringe the licensor's copyright in it for any permitted purpose, other than distributing the software or making changes or new works based on the software.  PATENT LICENSE  The licensor grants you a patent license for the software that covers patent claims the licensor can license, or becomes able to license, that you would infringe by using the software.  NONCOMPETE  Providing to others any product that competes with the software is not a permitted purpose.  COMPETITION  If you use this software to market a product as a substitute for the functionality or value of the software, it competes with the software. A product may compete regardless how it is designed or deployed. For example, a product may compete even if it provides its functionality via any kind of interface (including services, libraries or plug-ins), even if it is ported to a different platform or programming language, and even if it is provided free of charge.  FAIR USE  You may have "fair use" rights for the software under the law. These terms do not limit them.  NONCOMMERCIAL PURPOSES  Any noncommercial purpose is a permitted purpose.  PERSONAL USES  Personal use for research, experiment, and testing for the benefit of public knowledge, personal study, private entertainment, hobby projects, amateur pursuits, or religious observance, without any anticipated commercial application, is use for a permitted purpose.  NONCOMMERCIAL ORGANIZATIONS  Use by any charitable organization, educational institution, public research organization, public safety or health organization, environmental protection organization, or government institution is use for a permitted purpose regardless of the source of funding or obligations resulting from the funding.  FREE COMMERCIAL TRIAL  Use for less than 91 consecutive calendar days to evaluate whether the software suits a particular application by a commercial organization, on behalf of you or your company, is use for a permitted purpose. To secure a license for ongoing commercial use, email license@bluelightai.com or contact the company via its website at https://bluelightai.com.  NO OTHER RIGHTS  These terms do not allow you to sublicense or transfer any of your licenses to anyone else, or prevent the licensor from granting licenses to anyone else. These terms do not imply any other licenses.  PATENT DEFENSE  If you make any written claim that the software infringes or contributes to infringement of any patent, your patent license for the software granted under these terms ends immediately. If your company makes such a claim, your patent license ends immediately for work on behalf of your company.  VIOLATIONS  If you violate any of these terms, or do anything with the software not covered by your licenses, all your licenses end immediately.  NO LIABILITY  As far as the law allows, the software comes as is, without any warranty or condition, and the licensor will not be liable to you for any damages arising out of these terms or the use or nature of the software, under any kind of legal claim.  DEFINITIONS  The **licensor** is BluelightAI, Inc.  The **software** is BluelightAI Cobalt, any other software produced by BluelightAI that is necessary to run BluelightAI Cobalt, and all derivative works thereof.  **You** refers to the individual or entity agreeing to these terms.  **Your company** is any legal entity, sole proprietorship, or other kind of organization that you work for, plus all organizations that have control over, are under the control of, or are under common control with that organization.  **Control** means ownership of substantially all the assets of an entity, or the power to direct its management and policies by vote, contract, or otherwise.  Control can be direct or indirect.  **Your licenses** are all the licenses granted to you for the software under *these terms.  **Use** means anything you do with the software requiring one of your licenses.


pkgId: 3f43bda5b7cd56e294024520f027d82474b7216ac6968952e28c5b063cec1e53
name: python-langchain-anthropic-help
arch: noarch
version: 0.3.1
epoch: 0
release: 1
summary: Development documents and examples for langchain-anthropic
url: https://github.com/langchain-ai/langchain
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-langchain-anthropic-0.3.1-1.src.rpm
location_href: Packages/python-langchain-anthropic-help-0.3.1-1.noarch.rpm
checksum_type: sha256
description:
  This package contains the LangChain integration for Anthropic's generative models.



  `pip install -U langchain-anthropic`



  Anthropic recommends using their chat models over text completions.

  You can see their recommended models [here](https://docs.anthropic.com/claude/docs/models-overview#model-recommendations).

  To use, you should have an Anthropic API key configured. Initialize the model as:

  ```
  from langchain_anthropic import ChatAnthropic
  from langchain_core.messages import AIMessage, HumanMessage

  model = ChatAnthropic(model="claude-3-opus-20240229", temperature=0, max_tokens=1024)
  ```



  `message = HumanMessage(content="What is the capital of France?")`



  `response = model.invoke([message])`

  For a more detailed walkthrough see [here](https://python.langchain.com/docs/integrations/chat/anthropic).



  You can use the Claude 2 models for text completions.

  ```python
  from langchain_anthropic import AnthropicLLM

  model = AnthropicLLM(model="claude-2.1", temperature=0, max_tokens=1024)
  response = model.invoke("The best restaurant in San Francisco is: ")
  ```


pkgId: 2218c460a73a40177e879eec39f1325a1fd5d8f4e3c3b0d8d8bae4b93c33abba
name: python-langchain-aws-help
arch: noarch
version: 0.2.10
epoch: 0
release: 1
summary: Development documents and examples for langchain-aws
url: https://github.com/langchain-ai/langchain-aws
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-langchain-aws-0.2.10-1.src.rpm
location_href: Packages/python-langchain-aws-help-0.2.10-1.noarch.rpm
checksum_type: sha256
description:
  This package contains the LangChain integrations with AWS.



  ```bash
  pip install -U langchain-aws
  ```
  All integrations in this package assume that you have the credentials setup to connect with AWS services.



  `ChatBedrock` class exposes chat models from Bedrock.

  ```python
  from langchain_aws import ChatBedrock

  llm = ChatBedrock()
  llm.invoke("Sing a ballad of LangChain.")
  ```



  `BedrockEmbeddings` class exposes embeddings from Bedrock.

  ```python
  from langchain_aws import BedrockEmbeddings

  embeddings = BedrockEmbeddings()
  embeddings.embed_query("What is the meaning of life?")
  ```


  `BedrockLLM` class exposes LLMs from Bedrock.

  ```python
  from langchain_aws import BedrockLLM

  llm = BedrockLLM()
  llm.invoke("The meaning of life is")
  ```


  `AmazonKendraRetriever` class provides a retriever to connect with Amazon Kendra.

  ```python
  from langchain_aws import AmazonKendraRetriever

  retriever = AmazonKendraRetriever(
      index_id="561be2b6d-9804c7e7-f6a0fbb8-5ccd350"
  )

  retriever.get_relevant_documents(query="What is the meaning of life?")
  ```

  `AmazonKnowledgeBasesRetriever` class provides a retriever to connect with Amazon Knowledge Bases.

  ```python
  from langchain_aws import AmazonKnowledgeBasesRetriever

  retriever = AmazonKnowledgeBasesRetriever(
      knowledge_base_id="IAPJ4QPUEU",
      retrieval_config={"vectorSearchConfiguration": {"numberOfResults": 4}},
  )

  retriever.get_relevant_documents(query="What is the meaning of life?")
  ```

  `InMemoryVectorStore` class provides a vectorstore to connect with Amazon MemoryDB.

  ```python
  from langchain_aws.vectorstores.inmemorydb import InMemoryVectorStore

  vds = InMemoryVectorStore.from_documents(
              chunks,
              embeddings,
              redis_url="rediss://cluster_endpoint:6379/ssl=True ssl_cert_reqs=none",
              vector_schema=vector_schema,
              index_name=INDEX_NAME,
          )
  ```



  Here we go over different options for using the vector store as a retriever.

  There are three different search methods we can use to do retrieval. By default, it will use semantic similarity.

  ```python
  retriever=vds.as_retriever()
  ```


pkgId: cef704b25f76e13531db05c5746b3432ce2e9c57f1e23180737a60310294f26d
name: python-langchain-cerebras-help
arch: noarch
version: 0.4.0
epoch: 0
release: 1
summary: Development documents and examples for langchain-cerebras
url: https://github.com/langchain-ai/langchain-cerebras
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-langchain-cerebras-0.4.0-1.src.rpm
location_href: Packages/python-langchain-cerebras-help-0.4.0-1.noarch.rpm
checksum_type: sha256
description:
  This package contains the LangChain integration with Cerebras.

  At Cerebras, we've developed the world's largest and fastest AI processor, the Wafer-Scale Engine-3 (WSE-3). The Cerebras CS-3 system, powered by the WSE-3, represents a new class of AI supercomputer that sets the standard for generative AI training and inference with unparalleled performance and scalability.

  With Cerebras as your inference provider, you can:
  - Achieve unprecedented speed for AI inference workloads
  - Build commercially with high throughput
  - Effortlessly scale your AI workloads with our seamless clustering technology

  Our CS-3 systems can be quickly and easily clustered to create the largest AI supercomputers in the world, making it simple to place and run the largest models. Leading corporations, research institutions, and governments are already using Cerebras solutions to develop proprietary models and train popular open-source models.

  Want to experience the power of Cerebras? Check out our [website](https://cerebras.ai) for more resources and explore options for accessing our technology through the Cerebras Cloud or on-premise deployments!

  For more information about Cerebras Cloud, visit [cloud.cerebras.ai](https://cloud.cerebras.ai/). Our API reference is available at [inference-docs.cerebras.ai](https://inference-docs.cerebras.ai/).



  ```bash
  pip install langchain-cerebras
  ```


  Get an API Key from [cloud.cerebras.ai](https://cloud.cerebras.ai/) and add it to your environment variables:
  ```
  export CEREBRAS_API_KEY="your-api-key-here"
  ```




  See more examples [here](http://python.langchain.com/docs/integrations/chat/cerebras).



  ```python
  from langchain_core.prompts import ChatPromptTemplate
  from langchain_cerebras import ChatCerebras

  chat = ChatCerebras(
      model="llama-3.3-70b",
  )

  system = "You are an expert on animals who must answer questions in a manner that a 5 year old can understand."
  human = "I want to learn more about this animal: {text}"
  prompt = ChatPromptTemplate.from_messages(
      [
          ("system", system),
          ("human", human)
      ]
  )

  chain = prompt | chat
  chain.invoke({"text": "Lion"})
  ```

  Result content:
  ```
  OH BOY! Let me tell you all about LIONS!

  Lions are the kings of the jungle! They're really big and have beautiful, fluffy manes around their necks. The mane is like a big, golden crown!

  Lions live in groups called prides. A pride is like a big family, and the lionesses (that's what we call the female lions) take care of the babies. The lionesses are like the mommies, and they teach the babies how to hunt and play.

  Lions are very good at hunting. They work together to catch their food, like zebras and antelopes. They're super fast and can run really, really fast!

  But lions are also very sleepy. They like to take long naps in the sun, and they can sleep for up to 20 hours a day! Can you imagine sleeping that much?

  Lions are also very loud. They roar really loudly to talk to each other. It's like they're saying, "ROAR! I'm the king of the jungle!"

  And guess what? Lions are very social. They like to play and cuddle with each other. They're like big, furry teddy bears!

  So, that's lions! Aren't they just the coolest?
  ```



  For more information, visit [LangChain's contribution guide](https://python.langchain.com/v0.1/docs/contributing/code/).


  ```
  poetry install --with test,lint,codespell
  ```


  ```
  poetry build
  ```


  Unit tests are completely offline and do not require an API key.
  ```
  make test
  ```


  Integration tests require the environment variable `CEREBRAS_API_KEY` to be set to a valid API key along with a connection to the Cerebras Cloud servers.

  ```
  make integration_test
  ```


  ```
  make lint spell_check check_imports
  ```


pkgId: d1e8bfd3980f5e394c8ca150ca3ebe87644e2d109d69bf58b520cb4444be2c09
name: python-langchain-cfg-build-help
arch: noarch
version: 0.1.13
epoch: 0
release: 1
summary: Development documents and examples for langchain-cfg-build
url: https://pypi.org/project/langchain-cfg-build/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-langchain-cfg-build-0.1.13-1.src.rpm
location_href: Packages/python-langchain-cfg-build-help-0.1.13-1.noarch.rpm
checksum_type: sha256
description:
  要使用 Poetry 將你的 Python 庫發布到 PyPI，以下是具體的步驟。Poetry 提供了非常簡單的命令來管理這一過程，無需手動設置複雜的打包和發布流程。



  首先，確保你的 `pyproject.toml` 文件包含必要的配置信息。這些信息將用於在 PyPI 上顯示你的包的基本資料。


  ```toml
  [tool.poetry]
  name = "your_lib"  # 替換為你的專案名稱
  version = "0.1.0"  # 初次發布的版本號
  description = "A simple common library"
  authors = ["Your Name <your.email@example.com>"]
  repository = "https://github.com/your-username/your-project"
  license = "MIT"  # 替換為適當的 license

  [tool.poetry.dependencies]
  python = "^3.7"
  requests = "^2.25.1"  # 列出你依賴的庫

  [build-system]
  requires = ["poetry-core>=1.0.0"]
  build-backend = "poetry.core.masonry.api"
  ```



  1. **建立 PyPI 帳號**：
     如果你還沒有 PyPI 帳號，請前往 [https://pypi.org/](https://pypi.org/) 註冊一個帳號。

  2. **設定 Poetry 認證**：
     使用 Poetry 的 `poetry config` 命令來設定 PyPI 認證，這樣你可以安全地將包發布到 PyPI。

     執行以下命令來設定 PyPI 帳號和密碼：

     ```bash
     poetry config pypi-token.pypi <YOUR_PYPI_API_TOKEN>
     ```

     - 你可以從 PyPI 的 [API Token](https://pypi.org/manage/account/token/) 頁面生成一個新的 API Token。
     - 替換 `<YOUR_PYPI_API_TOKEN>` 為你從 PyPI 獲得的 API Token。



  在發布之前，先確保你的專案已經被正確打包。使用以下命令生成可發布的包：

  ```bash
  poetry build
  ```

  這會在 `dist/` 目錄下生成 `.tar.gz` 和 `.whl` 格式的包，這兩種格式都是 Python 包的標準發佈格式。



  使用 `poetry publish` 命令將包發布到 PyPI。


  直接執行以下命令即可發布到 PyPI：

  ```bash
  poetry publish --build
  ```


  你可以直接運行以下命令，Poetry 會要求你輸入 PyPI 帳號和密碼：

  ```bash
  poetry publish --build --username <your-pypi-username>
  ```



  發布成功後，你可以前往 [https://pypi.org/](https://pypi.org/) 搜尋你的包並驗證其是否已成功上傳。如果已上傳，你應該能夠在 PyPI 上看到你的包信息，包括版本、說明、安裝指南等。



  在你的包成功發布後，最好在其他環境中進行安裝測試，確保一切運作正常。你可以在新環境中執行：

  ```bash
  pip install your_lib
  ```

  這將從 PyPI 下載並安裝你發布的包。


  1. 確保 `pyproject.toml` 文件已正確配置。
  2. 使用 `poetry config` 設定 PyPI 認證（推薦使用 API Token）。
  3. 使用 `poetry build` 來打包你的專案。
  4. 使用 `poetry publish --build` 來將你的包發布到 PyPI。

  這樣，你的 Python 包就能被其他用戶通過 `pip install` 進行安裝和使用。




  ```shell
  poetry cache clear pypi --all
  ```


pkgId: 66ec5f55bcc9b059b7532e56ff52ef0562f1bb415537ae2956309b0a7140e979
name: python-langchain-community-help
arch: noarch
version: 0.3.12
epoch: 0
release: 1
summary: Development documents and examples for langchain-community
url: https://github.com/langchain-ai/langchain
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-langchain-community-0.3.12-1.src.rpm
location_href: Packages/python-langchain-community-help-0.3.12-1.noarch.rpm
checksum_type: sha256
description:
  [![Downloads](https://static.pepy.tech/badge/langchain_community/month)](https://pepy.tech/project/langchain_community)
  [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)



  ```bash
  pip install langchain-community
  ```



  LangChain Community contains third-party integrations that implement the base interfaces defined in LangChain Core, making them ready-to-use in any LangChain application.

  For full documentation see the [API reference](https://python.langchain.com/api_reference/community/index.html).

  ![Diagram outlining the hierarchical organization of the LangChain framework, displaying the interconnected parts across multiple layers.](https://raw.githubusercontent.com/langchain-ai/langchain/master/docs/static/svg/langchain_stack_112024.svg "LangChain Framework Overview")



  `langchain-community` is currently on version `0.0.x`

  All changes will be accompanied by a patch version increase.



  As an open-source project in a rapidly developing field, we are extremely open to contributions, whether it be in the form of a new feature, improved infrastructure, or better documentation.

  For detailed information on how to contribute, see the [Contributing Guide](https://python.langchain.com/docs/contributing/).


pkgId: 72a85251ca45ba9fc91a1221bb998384f892db9e299bc144e10d91588bba7b40
name: python-langchain-core-help
arch: noarch
version: 0.3.25
epoch: 0
release: 1
summary: Development documents and examples for langchain-core
url: https://github.com/langchain-ai/langchain
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-langchain-core-0.3.25-1.src.rpm
location_href: Packages/python-langchain-core-help-0.3.25-1.noarch.rpm
checksum_type: sha256
description:
  [![Downloads](https://static.pepy.tech/badge/langchain_core/month)](https://pepy.tech/project/langchain_core)
  [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)



  ```bash
  pip install langchain-core
  ```



  LangChain Core contains the base abstractions that power the rest of the LangChain ecosystem.

  These abstractions are designed to be as modular and simple as possible. Examples of these abstractions include those for language models, document loaders, embedding models, vectorstores, retrievers, and more.

  The benefit of having these abstractions is that any provider can implement the required interface and then easily be used in the rest of the LangChain ecosystem.

  For full documentation see the [API reference](https://python.langchain.com/api_reference/core/index.html).



  The concept of a Runnable is central to LangChain Core – it is the interface that most LangChain Core components implement, giving them

  - a common invocation interface (invoke, batch, stream, etc.)
  - built-in utilities for retries, fallbacks, schemas and runtime configurability
  - easy deployment with [LangServe](https://github.com/langchain-ai/langserve)

  For more check out the [runnable docs](https://python.langchain.com/docs/expression_language/interface). Examples of components that implement the interface include: LLMs, Chat Models, Prompts, Retrievers, Tools, Output Parsers.

  You can use LangChain Core objects in two ways:

  1. **imperative**, ie. call them directly, eg. `model.invoke(...)`

  2. **declarative**, with LangChain Expression Language (LCEL)

  3. or a mix of both! eg. one of the steps in your LCEL sequence can be a custom function

  | Feature   | Imperative                      | Declarative    |
  | --------- | ------------------------------- | -------------- |
  | Syntax    | All of Python                   | LCEL           |
  | Tracing   | ✅ – Automatic                  | ✅ – Automatic |
  | Parallel  | ✅ – with threads or coroutines | ✅ – Automatic |
  | Streaming | ✅ – by yielding                | ✅ – Automatic |
  | Async     | ✅ – by writing async functions | ✅ – Automatic |



  LangChain Expression Language (LCEL) is a _declarative language_ for composing LangChain Core runnables into sequences (or DAGs), covering the most common patterns when building with LLMs.

  LangChain Core compiles LCEL sequences to an _optimized execution plan_, with automatic parallelization, streaming, tracing, and async support.

  For more check out the [LCEL docs](https://python.langchain.com/docs/expression_language/).

  ![Diagram outlining the hierarchical organization of the LangChain framework, displaying the interconnected parts across multiple layers.](https://raw.githubusercontent.com/langchain-ai/langchain/master/docs/static/svg/langchain_stack_112024.svg "LangChain Framework Overview")

  For more advanced use cases, also check out [LangGraph](https://github.com/langchain-ai/langgraph), which is a graph-based runner for cyclic and recursive LLM workflows.



  `langchain-core` is currently on version `0.1.x`.

  As `langchain-core` contains the base abstractions and runtime for the whole LangChain ecosystem, we will communicate any breaking changes with advance notice and version bumps. The exception for this is anything in `langchain_core.beta`. The reason for `langchain_core.beta` is that given the rate of change of the field, being able to move quickly is still a priority, and this module is our attempt to do so.

  Minor version increases will occur for:

  - Breaking changes for any public interfaces NOT in `langchain_core.beta`

  Patch version increases will occur for:

  - Bug fixes
  - New features
  - Any changes to private interfaces
  - Any changes to `langchain_core.beta`



  As an open-source project in a rapidly developing field, we are extremely open to contributions, whether it be in the form of a new feature, improved infrastructure, or better documentation.

  For detailed information on how to contribute, see the [Contributing Guide](https://python.langchain.com/docs/contributing/).



  The whole LangChain ecosystem is built on top of LangChain Core, so you're in good company when building on top of it. Some of the benefits:

  - **Modularity**: LangChain Core is designed around abstractions that are independent of each other, and not tied to any specific model provider.
  - **Stability**: We are committed to a stable versioning scheme, and will communicate any breaking changes with advance notice and version bumps.
  - **Battle-tested**: LangChain Core components have the largest install base in the LLM ecosystem, and are used in production by many companies.
  - **Community**: LangChain Core is developed in the open, and we welcome contributions from the community.


pkgId: 770a6f968ff0487a219d34a20cc1307b0a9229f4a4f33ca634c008e155e4ea80
name: python-langchain-cratedb-help
arch: noarch
version: 0.0.0.dev0
epoch: 0
release: 1
summary: Development documents and examples for langchain-cratedb
url: https://github.com/crate/langchain-cratedb
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-langchain-cratedb-0.0.0.dev0-1.src.rpm
location_href: Packages/python-langchain-cratedb-help-0.0.0.dev0-1.noarch.rpm
checksum_type: sha256
description:
  [![Bluesky][badge-bluesky]][project-bluesky]
  [![Release Notes][badge-release-notes]][project-release-notes]
  [![CI][badge-ci]][project-ci]
  [![Downloads per month][badge-downloads-per-month]][project-downloads]

  [![Package version][badge-package-version]][project-pypi]
  [![License][badge-license]][project-license]
  [![Status][badge-status]][project-pypi]
  [![Supported Python versions][badge-python-versions]][project-pypi]

  » [Documentation]
  | [Changelog]
  | [Community Forum]
  | [PyPI]
  | [Issues]
  | [Source code]
  | [License]
  | [CrateDB]

  The `langchain-cratedb` package implements core LangChain abstractions
  using [CrateDB] or [CrateDB Cloud].

  The package is released under the MIT license.

  Feel free to use the abstraction as provided or else modify them / extend them
  as appropriate for your own application. We appreciate contributions of any kind.



  CrateDB is a distributed and scalable SQL database for storing and analyzing
  massive amounts of data in near real-time, even with complex queries.
  It is PostgreSQL-compatible, and based on Lucene.

  LangChain is a composable framework to build context-aware, reasoning
  applications with large language models, leveraging your company’s data
  and APIs.

  LangChain for CrateDB is an AI/ML framework that unlocks the application
  of LLM technologies to hands-on projects, covering many needs end-to-end.
  It builds upon the large array of utilities bundled by the LangChain
  toolkit and the ultra-fast indexing capabilities of CrateDB.

  You can apply [LangChain] to implement text-based applications using commercial
  models, for example provided by [OpenAI], or open-source models, for example
  multilingual text-only and text-image models provided by [Llama], and many more.



  ```bash
  pip install --upgrade langchain-cratedb
  ```



  The package currently supports CrateDB and its Python DB API driver,
  available per [crate] package. It will be automatically installed
  when installing the LangChain adapter.

  You can run [CrateDB Self-Managed], see [CrateDB Installation], or
  use [CrateDB Cloud], the installation-free variant, see
  [CrateDB Cloud Console].



  To learn about the LangChain adapter for CrateDB, please refer to the
  documentation and examples:

  - [Using LangChain with CrateDB]
  - [CrateDB LangChain examples]



  A few notebooks demonstrate how to use the CrateDB vector store functionality
  around its `FLOAT_VECTOR` data type and its `KNN_MATCH` function together with
  LangChain. CrateDBVectorStore

  You will learn how to import and query unstructured data using the
  `CrateDBVectorStore`, for example to create a retrieval augmented generation
  (RAG) pipeline.

  Retrieval-Augmented Generation (RAG) combines a retrieval system, which fetches
  relevant documents, with a generative model, allowing it to incorporate external
  knowledge for more accurate and informed responses.

  - [Example: Basic vector search]
  - [Example: Basic RAG]
  - [Example: Advanced RAG with use case]



  This notebook demonstrates how to load documents from a CrateDB database, using
  LangChain's `SQLDatabase` and `CrateDBLoader` interfaces, based on SQLAlchemy.

  - [Example: Load data from database table]



  The chat message history adapter helps to store and manage chat message history
  in a CrateDB table, for supporting conversational memory.

  - [Example: Chat message history]





  Kudos to the authors of all the many software components this library is
  inheriting from and building upon, most notably the [langchain-postgres]
  package, and [langchain] itself.


  The `langchain-cratedb` package is an open source project, and is
  [managed on GitHub]. The project is still in its infancy, and
  we appreciate contributions of any kind.


  The project uses the MIT license, like the langchain-postgres project
  it is deriving from.


  [CrateDB]: https://cratedb.com/database
  [CrateDB Cloud]: https://cratedb.com/database/cloud
  [CrateDB Cloud Console]: https://console.cratedb.cloud/
  [CrateDB Installation]: https://cratedb.com/docs/guide/install/
  [CrateDB LangChain examples]: https://github.com/crate/cratedb-examples/tree/main/topic/machine-learning/llm-langchain
  [CrateDB Self-Managed]: https://cratedb.com/database/self-managed
  [CrateDBVectorStore]: https://github.com/crate/langchain-cratedb/blob/cratedb/docs/vectorstores.ipynb
  [crate]: https://pypi.org/project/crate/
  [Example: Advanced RAG with use case]: https://github.com/crate/cratedb-examples/blob/main/topic/machine-learning/llm-langchain/cratedb_rag_customer_support_langchain.ipynb
  [Example: Chat message history]: https://github.com/crate/cratedb-examples/blob/main/topic/machine-learning/llm-langchain/conversational_memory.ipynb
  [Example: Basic RAG]: https://github.com/crate/cratedb-examples/blob/main/topic/machine-learning/llm-langchain/cratedb_rag_customer_support.ipynb
  [Example: Basic vector search]: https://github.com/crate/cratedb-examples/blob/main/topic/machine-learning/llm-langchain/vector_search.ipynb
  [Example: Load data from database table]: https://github.com/crate/cratedb-examples/blob/main/topic/machine-learning/llm-langchain/document_loader.ipynb
  [LangChain]: https://www.langchain.com/
  [langchain]: https://github.com/langchain-ai/langchain
  [langchain-postgres]: https://github.com/langchain-ai/langchain-postgres
  [Llama]: https://www.llama.com/
  [OpenAI]: https://openai.com/
  [Using LangChain with CrateDB]: https://cratedb.com/docs/guide/integrate/langchain/

  [Changelog]: https://github.com/crate/langchain-cratedb/blob/cratedb/CHANGES.md
  [Community Forum]: https://community.cratedb.com/
  [Documentation]: https://cratedb.com/docs/guide/integrate/langchain/
  [Issues]: https://github.com/crate/langchain-cratedb/issues
  [License]: https://github.com/crate/langchain-cratedb/blob/cratedb/LICENSE
  [managed on GitHub]: https://github.com/crate/langchain-cratedb
  [PyPI]: https://pypi.org/project/langchain-cratedb/
  [Source code]: https://github.com/crate/langchain-cratedb

  [badge-bluesky]: https://img.shields.io/badge/Bluesky-0285FF?logo=bluesky&logoColor=fff&label=Follow%20%40CrateDB
  [badge-ci]: https://github.com/crate/langchain-cratedb/actions/workflows/ci.yml/badge.svg
  [badge-downloads-per-month]: https://pepy.tech/badge/langchain-cratedb/month
  [badge-license]: https://img.shields.io/github/license/crate/langchain-cratedb.svg
  [badge-package-version]: https://img.shields.io/pypi/v/langchain-cratedb.svg
  [badge-python-versions]: https://img.shields.io/pypi/pyversions/langchain-cratedb.svg
  [badge-release-notes]: https://img.shields.io/github/release/crate/langchain-cratedb?label=Release+Notes
  [badge-status]: https://img.shields.io/pypi/status/langchain-cratedb.svg
  [project-bluesky]: https://bsky.app/search?q=cratedb
  [project-ci]: https://github.com/crate/langchain-cratedb/actions/workflows/ci.yml
  [project-downloads]: https://pepy.tech/project/langchain-cratedb/
  [project-license]: https://github.com/crate/langchain-cratedb/blob/cratedb/LICENSE
  [project-pypi]: https://pypi.org/project/langchain-cratedb
  [project-release-notes]: https://github.com/crate/langchain-cratedb/releases


pkgId: 53818426fce4803515ff1960356e6f02ae8077c38f90db13218bde17426b2d75
name: python-langchain-critique-help
arch: noarch
version: 0.1.1
epoch: 0
release: 1
summary: Development documents and examples for langchain-critique
url: https://github.com/langchain-ai/langchain
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-langchain-critique-0.1.1-1.src.rpm
location_href: Packages/python-langchain-critique-help-0.1.1-1.noarch.rpm
checksum_type: sha256
description:
  This package contains the LangChain integration with Critique, providing tools for grounded search, API design, and dynamic API interactions.



  ```bash
  pip install -U langchain-critique
  ```

  And you should configure credentials by setting the following environment variables:

  * `CRITIQUE_API_KEY` - Get your API key at https://critiquebrowser.app/en/flow-api?view=keys


pkgId: d7089468e4608f4bb1fa670338ff69ac46c4cc95b028b9e2e19c266377cab07a
name: python-langchain-fireworks-help
arch: noarch
version: 0.2.6
epoch: 0
release: 1
summary: Development documents and examples for langchain-fireworks
url: https://github.com/langchain-ai/langchain
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-langchain-fireworks-0.2.6-1.src.rpm
location_href: Packages/python-langchain-fireworks-help-0.2.6-1.noarch.rpm
checksum_type: sha256
description:
  This is the partner package for tying Fireworks.ai and LangChain. Fireworks really strive to provide good support for LangChain use cases, so if you run into any issues please let us know. You can reach out to us [in our Discord channel](https://discord.com/channels/1137072072808472616/)




  To use the `langchain-fireworks` package, follow these installation steps:

  ```bash
  pip install langchain-fireworks
  ```







  1. Sign in to [Fireworks AI](http://fireworks.ai/) to obtain an API Key to access the models, and make sure it is set as the `FIREWORKS_API_KEY` environment variable.

      Once you've signed in and obtained an API key, follow these steps to set the `FIREWORKS_API_KEY` environment variable:
      - **Linux/macOS:** Open your terminal and execute the following command:
      ```bash
      export FIREWORKS_API_KEY='your_api_key'
      ```
      **Note:** To make this environment variable persistent across terminal sessions, add the above line to your `~/.bashrc`, `~/.bash_profile`, or `~/.zshrc` file.

      - **Windows:** For Command Prompt, use:
      ```cmd
      set FIREWORKS_API_KEY=your_api_key
      ```

  2. Set up your model using a model id. If the model is not set, the default model is `fireworks-llama-v2-7b-chat`. See the full, most up-to-date model list on [fireworks.ai](https://fireworks.ai/models).

  ```python
  import getpass
  import os


  llm = Fireworks(
      model="accounts/fireworks/models/mixtral-8x7b-instruct",
      base_url="https://api.fireworks.ai/inference/v1/completions",
  )
  ```




  You can call the model directly with string prompts to get completions.

  ```python

  output = llm.invoke("Who's the best quarterback in the NFL?")
  print(output)
  ```

  ```python

  output = llm.generate(
      [
          "Who's the best cricket player in 2016?",
          "Who's the best basketball player in the league?",
      ]
  )
  print(output.generations)
  ```







  Please checkout how to teach Fireworks function calling model to use a [calculator here](https://github.com/fw-ai/cookbook/blob/main/examples/function_calling/fireworks_langchain_tool_usage.ipynb).

  Fireworks focus on delivering the best experience for fast model inference as well as tool use. You can check out [our blog](https://fireworks.ai/blog/firefunction-v1-gpt-4-level-function-calling) for more details on how it fares compares to GPT-4, the punchline is that it is on par with GPT-4 in terms just function calling use cases, but it is way faster and much cheaper.


  Please check out the [cookbook here](https://github.com/fw-ai/cookbook/blob/main/examples/rag/mongodb_agent.ipynb) for an end to end flow


pkgId: 9029d2a6a53da409a11c8ae01c44015aecaffead00c56da7658511f368620b6e
name: python-langchain-gigachat-help
arch: noarch
version: 0.3.2
epoch: 0
release: 1
summary: Development documents and examples for langchain-gigachat
url: https://github.com/ai-forever/langchain-gigachat
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-langchain-gigachat-0.3.2-1.src.rpm
location_href: Packages/python-langchain-gigachat-help-0.3.2-1.noarch.rpm
checksum_type: sha256
description:
  This is a library integration with [GigaChat](https://giga.chat/).

  [![GitHub Release](https://img.shields.io/github/v/release/ai-forever/langchain-gigachat?style=flat-square)](https://github.com/ai-forever/langchain-gigachat/releases)
  [![GitHub Actions Workflow Status](https://img.shields.io/github/actions/workflow/status/ai-forever/langchain-gigachat/check_diffs.yml?style=flat-square)](https://github.com/ai-forever/langchain-gigachat/actions/workflows/check_diffs.yml)
  [![GitHub License](https://img.shields.io/github/license/ai-forever/langchain-gigachat?style=flat-square)](https://opensource.org/license/MIT)
  [![GitHub Downloads (all assets, all releases)](https://img.shields.io/pypi/dm/langchain-gigachat?style=flat-square?style=flat-square)](https://pypistats.org/packages/langchain-gigachat)
  [![GitHub Repo stars](https://img.shields.io/github/stars/ai-forever/langchain-gigachat?style=flat-square)](https://star-history.com/#ai-forever/langchain-gigachat)
  [![GitHub Open Issues](https://img.shields.io/github/issues-raw/ai-forever/langchain-gigachat)](https://github.com/ai-forever/langchain-gigachat/issues)


  ```bash
  pip install -U langchain-gigachat
  ```


  Follow these simple steps to get up and running quickly.


  To install the package use following command:
  ```shell
  pip install -U langchain-gigachat
  ```



  To initialize chat model:
  ```python
  from langchain_gigachat.chat_models import GigaChat

  giga = GigaChat(credentials="YOUR_AUTHORIZATION_KEY", verify_ssl_certs=False)
  ```

  To initialize embeddings:

  ```python
  from langchain_gigachat.embeddings import GigaChatEmbeddings

  embedding = GigaChatEmbeddings(
      credentials="YOUR_AUTHORIZATION_KEY",
      verify_ssl_certs=False
  )
  ```



  Use the GigaChat object to generate responses:

  ```python
  print(giga.invoke("Hello, world!"))
  ```

  Now you can use the GigaChat object with LangChain's standard primitives to create LLM-applications.


pkgId: 206bd409022e5f591b08ecd3aa2fc03005b0463d9201d5dff67812f34be0d736
name: python-langchain-groq-help
arch: noarch
version: 0.2.2
epoch: 0
release: 1
summary: Development documents and examples for langchain-groq
url: https://github.com/langchain-ai/langchain
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-langchain-groq-0.2.2-1.src.rpm
location_href: Packages/python-langchain-groq-help-0.2.2-1.noarch.rpm
checksum_type: sha256
description:
  At Groq, we've developed the world's first Language Processing Unit™, or LPU. The Groq LPU has a deterministic, single core streaming architecture that sets the standard for GenAI inference speed with predictable and repeatable performance for any given workload.

  Beyond the architecture, our software is designed to empower developers like you with the tools you need to create innovative, powerful AI applications. With Groq as your engine, you can:

  * Achieve uncompromised low latency and performance for real-time AI and HPC inferences 🔥
  * Know the exact performance and compute time for any given workload 🔮
  * Take advantage of our cutting-edge technology to stay ahead of the competition 💪

  Want more Groq? Check out our [website](https://groq.com) for more resources and join our [Discord community](https://discord.gg/JvNsBDKeCG) to connect with our developers!



  Install the integration package:

  ```bash
  pip install langchain-groq
  ```

  Request an [API key](https://wow.groq.com) and set it as an environment variable

  ```bash
  export GROQ_API_KEY=gsk_...
  ```


  See a [usage example](https://python.langchain.com/docs/integrations/chat/groq).



  To develop the `langchain-groq` package, you'll need to follow these instructions:



  ```bash
  poetry install --with test,test_integration,lint,codespell
  ```



  ```bash
  poetry build
  ```



  Unit tests live in `tests/unit_tests` and SHOULD NOT require an internet connection or a valid API KEY.  Run unit tests with

  ```bash
  make tests
  ```



  Integration tests live in `tests/integration_tests` and require a connection to the Groq API and a valid API KEY.

  ```bash
  make integration_tests
  ```



  Run additional tests and linters to ensure your code is up to standard.

  ```bash
  make lint spell_check check_imports
  ```


pkgId: b506b26703da463f179d43cebffd5548a38e0670facf85d3a5add6f1d89f8072
name: python-langchain-help
arch: noarch
version: 0.3.12
epoch: 0
release: 1
summary: Development documents and examples for langchain
url: https://github.com/langchain-ai/langchain
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-langchain-0.3.12-1.src.rpm
location_href: Packages/python-langchain-help-0.3.12-1.noarch.rpm
checksum_type: sha256
description:
  ⚡ Building applications with LLMs through composability ⚡

  [![Release Notes](https://img.shields.io/github/release/langchain-ai/langchain)](https://github.com/langchain-ai/langchain/releases)
  [![lint](https://github.com/langchain-ai/langchain/actions/workflows/lint.yml/badge.svg)](https://github.com/langchain-ai/langchain/actions/workflows/lint.yml)
  [![test](https://github.com/langchain-ai/langchain/actions/workflows/test.yml/badge.svg)](https://github.com/langchain-ai/langchain/actions/workflows/test.yml)
  [![Downloads](https://static.pepy.tech/badge/langchain/month)](https://pepy.tech/project/langchain)
  [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
  [![Twitter](https://img.shields.io/twitter/url/https/twitter.com/langchainai.svg?style=social&label=Follow%20%40LangChainAI)](https://twitter.com/langchainai)
  [![Open in Dev Containers](https://img.shields.io/static/v1?label=Dev%20Containers&message=Open&color=blue&logo=visualstudiocode)](https://vscode.dev/redirect?url=vscode://ms-vscode-remote.remote-containers/cloneInVolume?url=https://github.com/langchain-ai/langchain)
  [![Open in GitHub Codespaces](https://github.com/codespaces/badge.svg)](https://codespaces.new/langchain-ai/langchain)
  [![GitHub star chart](https://img.shields.io/github/stars/langchain-ai/langchain?style=social)](https://star-history.com/#langchain-ai/langchain)
  [![Dependency Status](https://img.shields.io/librariesio/github/langchain-ai/langchain)](https://libraries.io/github/langchain-ai/langchain)
  [![Open Issues](https://img.shields.io/github/issues-raw/langchain-ai/langchain)](https://github.com/langchain-ai/langchain/issues)


  Looking for the JS/TS version? Check out [LangChain.js](https://github.com/langchain-ai/langchainjs).

  To help you ship LangChain apps to production faster, check out [LangSmith](https://smith.langchain.com).
  [LangSmith](https://smith.langchain.com) is a unified developer platform for building, testing, and monitoring LLM applications.
  Fill out [this form](https://www.langchain.com/contact-sales) to speak with our sales team.



  `pip install langchain`
  or
  `pip install langsmith && conda install langchain -c conda-forge`



  Large language models (LLMs) are emerging as a transformative technology, enabling developers to build applications that they previously could not. However, using these LLMs in isolation is often insufficient for creating a truly powerful app - the real power comes when you can combine them with other sources of computation or knowledge.

  This library aims to assist in the development of those types of applications. Common examples of these applications include:

  **❓ Question answering with RAG**

  - [Documentation](https://python.langchain.com/docs/use_cases/question_answering/)
  - End-to-end Example: [Chat LangChain](https://chat.langchain.com) and [repo](https://github.com/langchain-ai/chat-langchain)

  **🧱 Extracting structured output**

  - [Documentation](https://python.langchain.com/docs/use_cases/extraction/)
  - End-to-end Example: [SQL Llama2 Template](https://github.com/langchain-ai/langchain-extract/)

  **🤖 Chatbots**

  - [Documentation](https://python.langchain.com/docs/use_cases/chatbots)
  - End-to-end Example: [Web LangChain (web researcher chatbot)](https://weblangchain.vercel.app) and [repo](https://github.com/langchain-ai/weblangchain)



  Please see [here](https://python.langchain.com) for full documentation on:

  - Getting started (installation, setting up the environment, simple examples)
  - How-To examples (demos, integrations, helper functions)
  - Reference (full API docs)
  - Resources (high-level explanation of core concepts)



  There are five main areas that LangChain is designed to help with.
  These are, in increasing order of complexity:

  **📃 Models and Prompts:**

  This includes prompt management, prompt optimization, a generic interface for all LLMs, and common utilities for working with chat models and LLMs.

  **🔗 Chains:**

  Chains go beyond a single LLM call and involve sequences of calls (whether to an LLM or a different utility). LangChain provides a standard interface for chains, lots of integrations with other tools, and end-to-end chains for common applications.

  **📚 Retrieval Augmented Generation:**

  Retrieval Augmented Generation involves specific types of chains that first interact with an external data source to fetch data for use in the generation step. Examples include summarization of long pieces of text and question/answering over specific data sources.

  **🤖 Agents:**

  Agents involve an LLM making decisions about which Actions to take, taking that Action, seeing an Observation, and repeating that until done. LangChain provides a standard interface for agents, a selection of agents to choose from, and examples of end-to-end agents.

  **🧐 Evaluation:**

  [BETA] Generative models are notoriously hard to evaluate with traditional metrics. One new way of evaluating them is using language models themselves to do the evaluation. LangChain provides some prompts/chains for assisting in this.

  For more information on these concepts, please see our [full documentation](https://python.langchain.com).



  As an open-source project in a rapidly developing field, we are extremely open to contributions, whether it be in the form of a new feature, improved infrastructure, or better documentation.

  For detailed information on how to contribute, see the [Contributing Guide](https://python.langchain.com/docs/contributing/).


pkgId: 7375da9e7a5a495fa90c856fa2fc7483107f4748b09afcc33c714c11abaf68cf
name: python-langchain-localai-help
arch: noarch
version: 0.1.1
epoch: 0
release: 1
summary: Development documents and examples for langchain-localai
url: https://github.com/langchain-ai/langchain
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-langchain-localai-0.1.1-1.src.rpm
location_href: Packages/python-langchain-localai-help-0.1.1-1.noarch.rpm
checksum_type: sha256
description:
  This package contains the LangChain integration with LocalAI



  ```bash
  pip install -U langchain-localai
  ```



  `LocalAIEmbeddings` class exposes embeddings from LocalAI.

  ```python
  from libs.localai.langchain_localai import LocalAIEmbeddings

  embeddings = LocalAIEmbeddings(
      openai_api_base="http://localhost:8080",
      model="embedding-model-name")
  embeddings.embed_query("What is the meaning of life?")
  ```


pkgId: 5a4f7ec741fc1e213c9fe17f11767e59bb0836e6c26bf590ae5878e3054130d9
name: python-langchain-mistralai-help
arch: noarch
version: 0.2.4
epoch: 0
release: 1
summary: Development documents and examples for langchain-mistralai
url: https://github.com/langchain-ai/langchain
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-langchain-mistralai-0.2.4-1.src.rpm
location_href: Packages/python-langchain-mistralai-help-0.2.4-1.noarch.rpm
checksum_type: sha256
description:
  This package contains the LangChain integrations for [MistralAI](https://docs.mistral.ai) through their [mistralai](https://pypi.org/project/mistralai/) SDK.



  ```bash
  pip install -U langchain-mistralai
  ```



  This package contains the `ChatMistralAI` class, which is the recommended way to interface with MistralAI models.

  To use, install the requirements, and configure your environment.

  ```bash
  export MISTRAL_API_KEY=your-api-key
  ```

  Then initialize

  ```python
  from langchain_core.messages import HumanMessage
  from langchain_mistralai.chat_models import ChatMistralAI

  chat = ChatMistralAI(model="mistral-small")
  messages = [HumanMessage(content="say a brief hello")]
  chat.invoke(messages)
  ```

  `ChatMistralAI` also supports async and streaming functionality:

  ```python

  await chat.ainvoke(messages)


  for chunk in chat.stream(messages):
      print(chunk.content, end="", flush=True)
  ```



  With `MistralAIEmbeddings`, you can directly use the default model 'mistral-embed', or set a different one if available.



  `embedding.model = 'mistral-embed'`



  `res_query = embedding.embed_query("The test information")`



  `res_document = embedding.embed_documents(["test1", "another test"])`


pkgId: 55dff0ef67d2613b636dd6c4a39950080875dc79a6ec7a779d6edde848b8ab55
name: python-langchain-neo4j-help
arch: noarch
version: 0.2.0
epoch: 0
release: 1
summary: Development documents and examples for langchain-neo4j
url: https://github.com/langchain-ai/langchain-neo4j
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-langchain-neo4j-0.2.0-1.src.rpm
location_href: Packages/python-langchain-neo4j-help-0.2.0-1.noarch.rpm
checksum_type: sha256
description:
  This package contains the LangChain integration with Neo4j.



  ```bash
  pip install -U langchain-neo4j
  ```





  The `Neo4jGraph` class is a wrapper around Neo4j's Python driver.
  It provides a simple interface for interacting with a Neo4j database.

  ```python
  from langchain_neo4j import Neo4jGraph

  graph = Neo4jGraph(url="bolt://localhost:7687", username="neo4j", password="password")
  graph.query("MATCH (n) RETURN n LIMIT 1;")
  ```



  The `Neo4jChatMessageHistory` class is used to store chat message history in a Neo4j database.
  It stores messages as nodes and creates relationships between them, allowing for easy querying of the conversation history.

  ```python
  from langchain_neo4j import Neo4jChatMessageHistory

  history = Neo4jChatMessageHistory(
      url="bolt://localhost:7687",
      username="neo4j",
      password="password",
      session_id="session_id_1",
  )
  history.add_user_message("hi!")
  history.add_ai_message("whats up?")
  history.messages
  ```



  The `Neo4jVector` class provides functionality for managing a Neo4j vector store.
  It enables you to create new vector indexes, add vectors to existing indexes, and perform queries on indexes.

  ```python
  from langchain.docstore.document import Document
  from langchain_openai import OpenAIEmbeddings

  from langchain_neo4j import Neo4jVector


  docs = [
      Document(
          page_content=(
              "LangChain is a framework to build "
              "with LLMs by chaining interoperable components."
          ),
      )
  ]
  embeddings = OpenAIEmbeddings(
      model="text-embedding-3-large",
      api_key="sk-...",  # Replace with your OpenAI API key
  )
  db = Neo4jVector.from_documents(
      docs,
      embeddings,
      url="bolt://localhost:7687",
      username="neo4j",
      password="password",
  )

  docs_with_score = db.similarity_search_with_score("What is LangChain?", k=1)
  ```



  The `CypherQAChain` class enables natural language interactions with a Neo4j database.
  It uses an LLM and the database's schema to translate a user's question into a Cypher query, which is executed against the database.
  The resulting data is then sent along with the user's question to the LLM to generate a natural language response.

  ```python
  from langchain_openai import ChatOpenAI

  from langchain_neo4j import GraphCypherQAChain, Neo4jGraph

  llm = ChatOpenAI(
      temperature=0,
      api_key="sk-...",  # Replace with your OpenAI API key
  )
  graph = Neo4jGraph(url="bolt://localhost:7687", username="neo4j", password="password")
  chain = GraphCypherQAChain.from_llm(llm=llm, graph=graph, allow_dangerous_requests=True)
  chain.run("Who starred in Top Gun?")
  ```



  Install the test dependencies to run the tests:

  ```bash
  poetry install --with test,test_integration
  ```



  Run the unit tests using:

  ```bash
  make tests
  ```



  1. Start the Neo4j instance using Docker:

      ```bash
      cd tests/integration_tests/docker-compose
      docker-compose -f neo4j.yml up
      ```

  2. Run the tests:

      ```bash
      make integration_tests
      ```



  Install the codespell, lint, and typing dependencies to lint and format your code:

  ```bash
  poetry install --with codespell,lint,typing
  ```

  To format your code, run:

  ```bash
  make format
  ```

  To lint it, run:

  ```bash
  make lint
  ```


pkgId: 3059639b8bdf46a55aa6d16cd37a6974b1d3ab20fec9e4e35e922cb2daa55a87
name: python-langchain-nvidia-ai-endpoints-help
arch: noarch
version: 0.3.6
epoch: 0
release: 1
summary: Development documents and examples for langchain-nvidia-ai-endpoints
url: https://github.com/langchain-ai/langchain-nvidia
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-langchain-nvidia-ai-endpoints-0.3.6-1.src.rpm
location_href: Packages/python-langchain-nvidia-ai-endpoints-help-0.3.6-1.noarch.rpm
checksum_type: sha256
description:
  The `langchain-nvidia-ai-endpoints` package contains LangChain integrations for chat models and embeddings powered by [NVIDIA AI Foundation Models](https://www.nvidia.com/en-us/ai-data-science/foundation-models/), and hosted on [NVIDIA API Catalog.](https://build.nvidia.com/)

  NVIDIA AI Foundation models are community and NVIDIA-built models and are NVIDIA-optimized to deliver the best performance on NVIDIA accelerated infrastructure.  Using the API, you can query live endpoints available on the NVIDIA API Catalog to get quick results from a DGX-hosted cloud compute environment. All models are source-accessible and can be deployed on your own compute cluster using NVIDIA NIM™ microservices which is part of NVIDIA AI Enterprise.

  Models can be exported from NVIDIA’s API catalog with NVIDIA NIM, which is included with the NVIDIA AI Enterprise license, and run them on-premises, giving Enterprises ownership of their customizations and full control of their IP and AI application. NIM microservices are packaged as container images on a per model/model family basis and are distributed as NGC container images through the NVIDIA NGC Catalog. At their core, NIM microservices are containers that provide interactive APIs for running inference on an AI Model. 

  Below is an example on how to use some common functionality surrounding text-generative and embedding models.



  ```python
  %pip install -U --quiet langchain-nvidia-ai-endpoints
  ```



  **To get started:**
  1. Create a free account with [NVIDIA](https://build.nvidia.com/), which hosts NVIDIA AI Foundation models.
  2. Click on your model of choice.
  3. Under Input select the Python tab, and click `Get API Key`. Then click `Generate Key`.
  4. Copy and save the generated key as NVIDIA_API_KEY. From there, you should have access to the endpoints.

  ```python
  import getpass
  import os

  if not os.environ.get("NVIDIA_API_KEY", "").startswith("nvapi-"):
      nvidia_api_key = getpass.getpass("Enter your NVIDIA API key: ")
      assert nvidia_api_key.startswith("nvapi-"), f"{nvidia_api_key[:5]}... is not a valid key"
      os.environ["NVIDIA_API_KEY"] = nvidia_api_key
  ```


  ```python

  from langchain_nvidia_ai_endpoints import ChatNVIDIA

  llm = ChatNVIDIA(model="meta/llama3-70b-instruct", max_tokens=419)
  result = llm.invoke("Write a ballad about LangChain.")
  print(result.content)
  ```


  When ready to deploy, you can self-host models with NVIDIA NIM—which is included with the NVIDIA AI Enterprise software license—and run them anywhere, giving you ownership of your customizations and full control of your intellectual property (IP) and AI applications.

  [Learn more about NIM microservices](https://developer.nvidia.com/blog/nvidia-nim-offers-optimized-inference-microservices-for-deploying-ai-models-at-scale/)

  ```python
  from langchain_nvidia_ai_endpoints import ChatNVIDIA, NVIDIAEmbeddings, NVIDIARerank


  llm = ChatNVIDIA(base_url="http://localhost:8000/v1", model="meta-llama3-8b-instruct")


  embedder = NVIDIAEmbeddings(base_url="http://localhost:8080/v1")


  ranker = NVIDIARerank(base_url="http://localhost:2016/v1")
  ```



  These models natively support streaming, and as is the case with all LangChain LLMs they expose a batch method to handle concurrent requests, as well as async methods for invoke, stream, and batch. Below are a few examples.

  ```python
  print(llm.batch(["What's 2*3?", "What's 2*6?"]))


  ```

  ```python
  for chunk in llm.stream("How far can a seagull fly in one day?"):
      
      print(chunk.content, end="|")
  ```

  ```python
  async for chunk in llm.astream("How long does it take for monarch butterflies to migrate?"):
      print(chunk.content, end="|")
  ```



  Querying `available_models` will still give you all of the other models offered by your API credentials.

  ```python
  [model.id for model in llm.available_models if model.model_type]




















  ```



  All of these models above are supported and can be accessed via `ChatNVIDIA`.

  Some model types support unique prompting techniques and chat messages. We will review a few important ones below.

  **To find out more about a specific model, please navigate to the NVIDIA NIM section of ai.nvidia.com [as linked here](https://docs.api.nvidia.com/nim/).**



  Models such as `meta/llama3-8b-instruct` and `mistralai/mixtral-8x22b-instruct-v0.1` are good all-around models that you can use for with any LangChain chat messages. Example below.

  ```python
  from langchain_nvidia_ai_endpoints import ChatNVIDIA
  from langchain_core.prompts import ChatPromptTemplate
  from langchain_core.output_parsers import StrOutputParser

  prompt = ChatPromptTemplate.from_messages(
      [
          ("system", "You are a helpful AI assistant named Fred."),
          ("user", "{input}")
      ]
  )
  chain = (
      prompt
      | ChatNVIDIA(model="meta/llama3-8b-instruct")
      | StrOutputParser()
  )

  for txt in chain.stream({"input": "What's your name?"}):
      print(txt, end="")
  ```



  These models accept the same arguments and input structure as regular chat models, but they tend to perform better on code-genreation and structured code tasks. An example of this is `meta/codellama-70b` and `google/codegemma-7b`.

  ```python
  prompt = ChatPromptTemplate.from_messages(
      [
          ("system", "You are an expert coding AI. Respond only in valid python; no narration whatsoever."),
          ("user", "{input}")
      ]
  )
  chain = (
      prompt
      | ChatNVIDIA(model="meta/codellama-70b", max_tokens=419)
      | StrOutputParser()
  )

  for txt in chain.stream({"input": "How do I solve this fizz buzz problem?"}):
      print(txt, end="")
  ```



  NVIDIA also supports multimodal inputs, meaning you can provide both images and text for the model to reason over.

  An example model supporting multimodal inputs is `nvidia/neva-22b`.

  These models accept LangChain's standard image formats. Below are examples.

  ```python
  import requests

  image_url = "https://picsum.photos/seed/kitten/300/200"
  image_content = requests.get(image_url).content
  ```

  Initialize the model like so:

  ```python
  from langchain_nvidia_ai_endpoints import ChatNVIDIA

  llm = ChatNVIDIA(model="nvidia/neva-22b")
  ```



  ```python
  from langchain_core.messages import HumanMessage

  llm.invoke(
      [
          HumanMessage(content=[
              {"type": "text", "text": "Describe this image:"},
              {"type": "image_url", "image_url": {"url": image_url}},
          ])
      ])
  ```



  ```python
  import base64
  b64_string = base64.b64encode(image_content).decode('utf-8')
  llm.invoke(
      [
          HumanMessage(content=[
              {"type": "text", "text": "Describe this image:"},
              {"type": "image_url", "image_url": {"url": f"data:image/png;base64,{b64_string}"}},
          ])
      ])
  ```



  The NVIDIA API uniquely accepts images as base64 images inlined within <img> HTML tags. While this isn't interoperable with other LLMs, you can directly prompt the model accordingly.

  ```python
  base64_with_mime_type = f"data:image/png;base64,{b64_string}"
  llm.invoke(
      f'What\'s in this image?\n<img src="{base64_with_mime_type}" />'
  )
  ```



  You can also work with models that support the Completions API. These models accept a `prompt` instead of `messages`.

  ```python
  completions_llm = NVIDIA().bind(max_tokens=512)
  [model.id for model in completions_llm.get_available_models()]







  ```

  ```python
  prompt = "# Function that does quicksort written in Rust without comments:"
  for chunk in completions_llm.stream(prompt):
      print(chunk, end="", flush=True)
  ```




  You can also connect to embeddings models through this package. Below is an example:

  ```python
  from langchain_nvidia_ai_endpoints import NVIDIAEmbeddings

  embedder = NVIDIAEmbeddings(model="NV-Embed-QA")
  embedder.embed_query("What's the temperature today?")
  embedder.embed_documents([
      "The temperature is 42 degrees.",
      "Class is dismissed at 9 PM."
  ])
  ```




  You can connect to ranking models. Below is an example:

  ```python
  from langchain_nvidia_ai_endpoints import NVIDIARerank
  from langchain_core.documents import Document

  query = "What is the GPU memory bandwidth of H100 SXM?"
  passages = [
      "The Hopper GPU is paired with the Grace CPU using NVIDIA's ultra-fast chip-to-chip interconnect, delivering 900GB/s of bandwidth, 7X faster than PCIe Gen5. This innovative design will deliver up to 30X higher aggregate system memory bandwidth to the GPU compared to today's fastest servers and up to 10X higher performance for applications running terabytes of data.",
      "A100 provides up to 20X higher performance over the prior generation and can be partitioned into seven GPU instances to dynamically adjust to shifting demands. The A100 80GB debuts the world's fastest memory bandwidth at over 2 terabytes per second (TB/s) to run the largest models and datasets.",
      "Accelerated servers with H100 deliver the compute power—along with 3 terabytes per second (TB/s) of memory bandwidth per GPU and scalability with NVLink and NVSwitch™.",
  ]

  client = NVIDIARerank(model="nvidia/llama-3.2-nv-rerankqa-1b-v1")

  response = client.compress_documents(
    query=query,
    documents=[Document(page_content=passage) for passage in passages]
  )

  print(f"Most relevant: {response[0].page_content}\nLeast relevant: {response[-1].page_content}")
  ```


pkgId: 644b7ec2a0c76d89171f927af8044f61eafae799667072d9c171d82be2c45c58
name: python-langchain-oceanbase-help
arch: noarch
version: 0.1.0
epoch: 0
release: 1
summary: Development documents and examples for langchain-oceanbase
url: https://pypi.org/project/langchain-oceanbase/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-langchain-oceanbase-0.1.0-1.src.rpm
location_href: Packages/python-langchain-oceanbase-help-0.1.0-1.noarch.rpm
checksum_type: sha256
description:
  This package contains the LangChain integration with OceanBase.

  [OceanBase Database](https://github.com/oceanbase/oceanbase) is a distributed relational database.
  It is developed entirely by Ant Group. The OceanBase Database is built on a common server cluster.
  Based on the Paxos protocol and its distributed structure, the OceanBase Database provides high availability and linear scalability.

  OceanBase currently has the ability to store vectors. Users can easily perform the following operations with SQL:

  - Create a table containing vector type fields;
  - Create a vector index table based on the HNSW algorithm;
  - Perform vector approximate nearest neighbor queries;
  - ...



  ```bash
  pip install -U langchain-oceanbase
  ```

  We recommend using Docker to deploy OceanBase:

  ```shell
  docker run --name=ob433 -e MODE=slim -p 2881:2881 -d oceanbase/oceanbase-ce:4.3.3.0-100000132024100711
  ```

  [More methods to deploy OceanBase cluster](https://github.com/oceanbase/oceanbase-doc/blob/V4.3.1/en-US/400.deploy/500.deploy-oceanbase-database-community-edition/100.deployment-overview.md)



  For a more detailed walkthrough of the OceanBase Wrapper, see [this notebook](./docs/vectorstores.ipynb)


pkgId: 32f467019d84bad96ddd4c126ad2be88b5b33c658791542187d10ec2446a32c2
name: python-langchain-ollama-help
arch: noarch
version: 0.2.2
epoch: 0
release: 1
summary: Development documents and examples for langchain-ollama
url: https://github.com/langchain-ai/langchain
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-langchain-ollama-0.2.2-1.src.rpm
location_href: Packages/python-langchain-ollama-help-0.2.2-1.noarch.rpm
checksum_type: sha256
description:
  This package contains the LangChain integration with Ollama



  ```bash
  pip install -U langchain-ollama
  ```

  You will also need to run the Ollama server locally.
  You can download it [here](https://ollama.com/download).



  `ChatOllama` class exposes chat models from Ollama.

  ```python
  from langchain_ollama import ChatOllama

  llm = ChatOllama(model="llama3-groq-tool-use")
  llm.invoke("Sing a ballad of LangChain.")
  ```



  `OllamaEmbeddings` class exposes embeddings from Ollama.

  ```python
  from langchain_ollama import OllamaEmbeddings

  embeddings = OllamaEmbeddings(model="llama3")
  embeddings.embed_query("What is the meaning of life?")
  ```


  `OllamaLLM` class exposes LLMs from Ollama.

  ```python
  from langchain_ollama import OllamaLLM

  llm = OllamaLLM(model="llama3")
  llm.invoke("The meaning of life is")
  ```


pkgId: 03b80610edffa463aea1f546ab3f2ff015cba9fbbaf55b483c618d14a4d4c2c7
name: python-langchain-openai-help
arch: noarch
version: 0.2.13
epoch: 0
release: 1
summary: Development documents and examples for langchain-openai
url: https://github.com/langchain-ai/langchain
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-langchain-openai-0.2.13-1.src.rpm
location_href: Packages/python-langchain-openai-help-0.2.13-1.noarch.rpm
checksum_type: sha256
description:
  This package contains the LangChain integrations for OpenAI through their `openai` SDK.



  - Install the LangChain partner package
  ```bash
  pip install langchain-openai
  ```
  - Get an OpenAI api key and set it as an environment variable (`OPENAI_API_KEY`)




  See a [usage example](http://python.langchain.com/docs/integrations/llms/openai).

  ```python
  from langchain_openai import OpenAI
  ```

  If you are using a model hosted on `Azure`, you should use different wrapper for that:
  ```python
  from langchain_openai import AzureOpenAI
  ```
  For a more detailed walkthrough of the `Azure` wrapper, see [here](http://python.langchain.com/docs/integrations/llms/azure_openai)




  See a [usage example](http://python.langchain.com/docs/integrations/chat/openai).

  ```python
  from langchain_openai import ChatOpenAI
  ```

  If you are using a model hosted on `Azure`, you should use different wrapper for that:
  ```python
  from langchain_openai import AzureChatOpenAI
  ```
  For a more detailed walkthrough of the `Azure` wrapper, see [here](http://python.langchain.com/docs/integrations/chat/azure_chat_openai)




  See a [usage example](http://python.langchain.com/docs/integrations/text_embedding/openai)

  ```python
  from langchain_openai import OpenAIEmbeddings
  ```

  If you are using a model hosted on `Azure`, you should use different wrapper for that:
  ```python
  from langchain_openai import AzureOpenAIEmbeddings
  ```
  For a more detailed walkthrough of the `Azure` wrapper, see [here](https://python.langchain.com/docs/integrations/text_embedding/azureopenai)


pkgId: 84133242f79ff30ae4051c1e2109d84118830a246fd95f1f59dd28c749ad14b6
name: python-langchain-predictionguard-help
arch: noarch
version: 0.1.1
epoch: 0
release: 1
summary: Development documents and examples for langchain-predictionguard
url: https://predictionguard.com
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-langchain-predictionguard-0.1.1-1.src.rpm
location_href: Packages/python-langchain-predictionguard-help-0.1.1-1.noarch.rpm
checksum_type: sha256
description:
  This page covers how to use the Prediction Guard ecosystem within LangChain.
  It is broken into two parts: installation and setup, and then references to specific Prediction Guard wrappers.



  - Install the PredictionGuard Langchain partner package:
  ```
  pip install langchain-predictionguard
  ```

  - Get a Prediction Guard API key (as described [here](https://docs.predictionguard.com/)) and set it as an environment variable (`PREDICTIONGUARD_API_KEY`)


  |API|Description|Endpoint Docs| Import                                                  | Example Usage                                                                 |
  |---|---|---|---------------------------------------------------------|-------------------------------------------------------------------------------|
  |Chat|Build Chat Bots|[Chat](https://docs.predictionguard.com/api-reference/api-reference/chat-completions)| `from langchain_predictionguard import ChatPredictionGuard` | [ChatPredictionGuard.ipynb](/notebooks/ChatPredictionGuard.ipynb)             |
  |Completions|Generate Text|[Completions](https://docs.predictionguard.com/api-reference/api-reference/completions)| `from langchain_predictionguard import PredictionGuard` | [PredictionGuard.ipynb](/notebooks/PredictionGuard.ipynb)                     |
  |Text Embedding|Embed String to Vectores|[Embeddings](https://docs.predictionguard.com/api-reference/api-reference/embeddings)| `from langchain_predictionguard import PredictionGuardEmbeddings` | [PredictionGuardEmbeddings.ipynb](/notebooks/PredictionGuardEmbeddings.ipynb) |







  See a [usage example](/notebooks/ChatPredictionGuard.ipynb)

  ```python
  from langchain_predictionguard import ChatPredictionGuard
  ```



  ```python

  chat = ChatPredictionGuard(model="Hermes-3-Llama-3.1-8B")

  chat.invoke("Tell me a joke")
  ```





  See a [usage example](/notebooks/PredictionGuardEmbeddings.ipynb)

  ```python
  from langchain_predictionguard import PredictionGuardEmbeddings
  ```


  ```python

  embeddings = PredictionGuardEmbeddings(model="bridgetower-large-itm-mlm-itc")

  text = "This is an embedding example."
  output = embeddings.embed_query(text)
  ```





  See a [usage example](/notebooks/PredictionGuard.ipynb)

  ```python
  from langchain_predictionguard import PredictionGuard
  ```


  ```python

  llm = PredictionGuard(model="Hermes-2-Pro-Llama-3-8B")

  llm.invoke("Tell me a joke about bears")
  ```


pkgId: 607a58583ab43e50ce2797a04da616ac3ab2d5831e3130fe4a77581cce4c2934
name: python-langchain-text-splitters-help
arch: noarch
version: 0.3.3
epoch: 0
release: 1
summary: Development documents and examples for langchain-text-splitters
url: https://github.com/langchain-ai/langchain
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-langchain-text-splitters-0.3.3-1.src.rpm
location_href: Packages/python-langchain-text-splitters-help-0.3.3-1.noarch.rpm
checksum_type: sha256
description:
  [![Downloads](https://static.pepy.tech/badge/langchain_text_splitters/month)](https://pepy.tech/project/langchain_text_splitters)
  [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)



  ```bash
  pip install langchain-text-splitters
  ```



  LangChain Text Splitters contains utilities for splitting into chunks a wide variety of text documents.

  For full documentation see the [API reference](https://python.langchain.com/api_reference/text_splitters/index.html)
  and the [Text Splitters](https://python.langchain.com/docs/modules/data_connection/document_transformers/) module in the main docs.



  `langchain-text-splitters` is currently on version `0.0.x`.

  Minor version increases will occur for:

  - Breaking changes for any public interfaces NOT marked `beta`

  Patch version increases will occur for:

  - Bug fixes
  - New features
  - Any changes to private interfaces
  - Any changes to `beta` features



  As an open-source project in a rapidly developing field, we are extremely open to contributions, whether it be in the form of a new feature, improved infrastructure, or better documentation.

  For detailed information on how to contribute, see the [Contributing Guide](https://python.langchain.com/docs/contributing/).


pkgId: 521130be273f4919a4ab8266813474513853a6eb710f531caffc5b854c440d48
name: python-langchain-xai-help
arch: noarch
version: 0.1.1
epoch: 0
release: 1
summary: Development documents and examples for langchain-xai
url: https://github.com/langchain-ai/langchain
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-langchain-xai-0.1.1-1.src.rpm
location_href: Packages/python-langchain-xai-help-0.1.1-1.noarch.rpm
checksum_type: sha256
description:
  This package contains the LangChain integrations for [xAI](https://x.ai/) through their [APIs](https://console.x.ai).



  - Install the LangChain partner package

  ```bash
  pip install -U langchain-xai
  ```

  - Get your xAI api key from the [xAI Dashboard](https://console.x.ai) and set it as an environment variable (`XAI_API_KEY`)



  This package contains the `ChatXAI` class, which is the recommended way to interface with xAI chat models.


pkgId: 752c973bb6e4721d6728cf5a53199473c01eca685109a746f2ea8169284715d4
name: python-langchain-yt-dlp-help
arch: noarch
version: 0.0.3
epoch: 0
release: 1
summary: Development documents and examples for langchain-yt-dlp
url: https://github.com/aqib0770/langchain-yt-dlp
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-langchain-yt-dlp-0.0.3-1.src.rpm
location_href: Packages/python-langchain-yt-dlp-help-0.0.3-1.noarch.rpm
checksum_type: sha256
description:
  - Fetch YouTube transcripts with support for chunking, translations, and line-based formats.
  - Retrieve additional video metadata (e.g., title, description, author, view count, publish date) using the `yt-dlp` library.


pkgId: ed131c4a616fc849ff39a263c96e12995125471b0096f114ad32bbfeb8cda1b7
name: python-langchain-yt-dlp-help
arch: noarch
version: 0.0.8
epoch: 0
release: 1
summary: Development documents and examples for langchain-yt-dlp
url: https://github.com/aqib0770/langchain-yt-dlp
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-langchain-yt-dlp-0.0.8-1.src.rpm
location_href: Packages/python-langchain-yt-dlp-help-0.0.8-1.noarch.rpm
checksum_type: sha256
description:
  - Retrieve metadata (e.g., title, description, author, view count, publish date) using the `yt-dlp` library.


pkgId: b1ee4b991a582300074e03503a19a3fc1bb84c17e19974ba5da7b791c401c17d
name: python-langer-update-help
arch: noarch
version: 1.0.1
epoch: 0
release: 1
summary: Development documents and examples for langer-update
url: https://pypi.org/project/langer-update/
rpm_license: GPL-3
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-langer-update-1.0.1-1.src.rpm
location_href: Packages/python-langer-update-help-1.0.1-1.noarch.rpm
checksum_type: sha256
description:
  [![PyPI version](https://badge.fury.io/py/yourpackagename.svg)](https://badge.fury.io/py/yourpackagename)

  YourPackageName is a Python package designed to [describe the primary purpose of your package]. With this package, you can [list key features or functionalities].



  - Feature 1: Brief description.
  - Feature 2: Brief description.
  - Feature 3: Brief description.



  Install YourPackageName using pip:

  ```bash
  pip install yourpackagename
  ```



  Here's a basic example to get started:

  ```python
  from yourpackagename import YourMainClass


  example = YourMainClass(parameters)


  result = example.do_something()
  print(result)
  ```



  Contributions are welcome! To contribute:

  1. Fork the repository.
  2. Create a new branch for your feature: `git checkout -b feature-name`.
  3. Commit your changes: `git commit -m 'Add some feature'`.
  4. Push to the branch: `git push origin feature-name`.
  5. Open a pull request.



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



  If you have any questions or feedback, feel free to reach out to [Your Email or GitHub Profile].


pkgId: 58f2dad0278822a8a0f049e64b0ac1f24d4b230249fcfd784c6c7192c6c48125
name: python-langfuse-help
arch: noarch
version: 2.57.0
epoch: 0
release: 1
summary: Development documents and examples for langfuse
url: https://pypi.org/project/langfuse/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-langfuse-2.57.0-1.src.rpm
location_href: Packages/python-langfuse-help-2.57.0-1.noarch.rpm
checksum_type: sha256
description:
  ![GitHub Banner](https://github.com/langfuse/langfuse-python/assets/2834609/3c36488e-6fe6-4a82-b0f5-5419250ddf86)



  [![MIT License](https://img.shields.io/badge/License-MIT-red.svg?style=flat-square)](https://opensource.org/licenses/MIT)
  [![CI test status](https://img.shields.io/github/actions/workflow/status/langfuse/langfuse-python/ci.yml?style=flat-square&label=All%20tests)](https://github.com/langfuse/langfuse-python/actions/workflows/ci.yml?query=branch%3Amain)
  [![PyPI Version](https://img.shields.io/pypi/v/langfuse.svg?style=flat-square&label=pypi+langfuse)](https://pypi.python.org/pypi/langfuse)
  [![GitHub Repo stars](https://img.shields.io/github/stars/langfuse/langfuse?style=flat-square&logo=GitHub&label=langfuse%2Flangfuse)](https://github.com/langfuse/langfuse)
  [![Discord](https://img.shields.io/discord/1111061815649124414?style=flat-square&logo=Discord&logoColor=white&label=Discord&color=%23434EE4)](https://discord.gg/7NXusRtqYU)
  [![YC W23](https://img.shields.io/badge/Y%20Combinator-W23-orange?style=flat-square)](https://www.ycombinator.com/companies/langfuse)



  > [!IMPORTANT]
  > The SDK was rewritten in v2 and released on December 17, 2023. Refer to the [v2 migration guide](https://langfuse.com/docs/sdk/python/low-level-sdk#upgrading-from-v1xx-to-v2xx) for instructions on updating your code.

  ```
  pip install langfuse
  ```



  - Decorators: https://langfuse.com/docs/sdk/python/decorators
  - Low-level SDK: https://langfuse.com/docs/sdk/python/low-level-sdk
  - Langchain integration: https://langfuse.com/docs/integrations/langchain/tracing



  Interfaces:

  - `@observe()` decorator ([docs](https://langfuse.com/docs/sdk/python/decorators))
  - Low-level tracing SDK ([docs](https://langfuse.com/docs/sdk/python/low-level-sdk))
  - Wrapper of Langfuse public API

  Integrations

  - OpenAI SDK ([docs](https://langfuse.com/docs/integrations/openai))
  - LlamaIndex ([docs](https://langfuse.com/docs/integrations/llama-index))
  - LangChain ([docs](https://langfuse.com/docs/integrations/langchain))


pkgId: 653a0fa9b5c3342b0d652bcb5e882a0629e836b938a1ca075cd7078df9b84013
name: python-langgraph-api-help
arch: noarch
version: 0.0.14
epoch: 0
release: 1
summary: Development documents and examples for langgraph-api
url: https://pypi.org/project/langgraph-api/
rpm_license: Elastic-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-langgraph-api-0.0.14-1.src.rpm
location_href: Packages/python-langgraph-api-help-0.0.14-1.noarch.rpm
checksum_type: sha256
description:
  This package implements the LangGraph API for rapid development and testing. Build and iterate on LangGraph agents with a tight feedback loop. The sesrver is backed by a predominently in-memory data store that is persisted to local disk when the server is restarted.

  For production use, see the various [deployment options](https://langchain-ai.github.io/langgraph/concepts/deployment_options/) for the LangGraph API, which are backed by a production-grade database.



  Install the `langgraph-cli` package with the `inmem` extra. Your CLI version must be no lower than `0.1.55`.

  ```bash
  pip install -U langgraph-cli[inmem]
  ```



  1. (Optional) Clone a starter template:

     ```bash
     langgraph new --template new-langgraph-project-python ./my-project
     cd my-project
     ```

     (Recommended) Use a virtual environment and install dependencies:

     ```bash
     python -m venv .venv
     source .venv/bin/activate
     python -m pip install .
     ```

  2. Start the development server:

     ```shell
     langgraph dev --config ./langgraph.json
     ```

  3. The server will launch, opening a browser window with the graph UI. Interact with your graph or make code edits; the server automatically reloads on changes.



  Start the development server:

  ```bash
  langgraph dev
  ```

  Your agent's state (threads, runs, assistants) persists in memory while the server is running - perfect for development and testing. Each run's state is tracked and can be inspected, making it easy to debug and improve your agent's behavior.




  Debug mode lets you attach your IDE's debugger to the LangGraph API server to set breakpoints and step through your code line-by-line.

  1. Install debugpy:

     ```bash
     pip install debugpy
     ```

  2. Start the server in debug mode:

     ```bash
     langgraph dev --debug-port 5678
     ```

  3. Configure your IDE:

     - **VS Code**: Add this launch configuration:
       ```json
       {
         "name": "Attach to LangGraph",
         "type": "debugpy",
         "request": "attach",
         "connect": {
                  "host": "0.0.0.0",
                  "port": 5678
              },
       }
       ```
     - **PyCharm**: Use "Attach to Process" and select the langgraph process

  4. Set breakpoints in your graph code and start debugging.



  ```bash
  langgraph dev [OPTIONS]
  Options:
    --debug-port INTEGER         Enable remote debugging on specified port
    --no-browser                 Skip opening browser on startup
    --n-jobs-per-worker INTEGER  Maximum concurrent jobs per worker process
    --config PATH               Custom configuration file path
    --no-reload                 Disable code hot reloading
    --port INTEGER              HTTP server port (default: 8000)
    --host TEXT                 HTTP server host (default: localhost)
  ```



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


pkgId: 34eca823beb728329ded79267cdfb06527454474907d2e49ed32460b5f0db630
name: python-langgraph-checkpoint-mysql-help
arch: noarch
version: 2.0.8
epoch: 0
release: 1
summary: Development documents and examples for langgraph-checkpoint-mysql
url: https://www.github.com/tjni/langgraph-checkpoint-mysql
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-langgraph-checkpoint-mysql-2.0.8-1.src.rpm
location_href: Packages/python-langgraph-checkpoint-mysql-help-2.0.8-1.noarch.rpm
checksum_type: sha256
description:
  Implementation of LangGraph CheckpointSaver that uses MySQL.

  > [!TIP]
  > The code in this repository tries to mimic the code in [langgraph-checkpoint-postgres](https://github.com/langchain-ai/langgraph/tree/main/libs/checkpoint-postgres) as much as possible to enable keeping in sync with the official checkpointer implementation.

  > [!NOTE]
  > In order to keep the queries close to the Postgres queries, we use features from recent versions of MySQL 8. I'm not sure what the exact minimum version is.



  To use synchronous `PyMySQLSaver`, install `langgraph-checkpoint-mysql[pymysql]`. To use asynchronous `AIOMySQLSaver`, install `langgraph-checkpoint-mysql[aiomysql]`.

  There is currently no support for other drivers.



  > [!IMPORTANT]
  > When using MySQL checkpointers for the first time, make sure to call `.setup()` method on them to create required tables. See example below.

  > [!IMPORTANT]
  > When manually creating MySQL connections and passing them to `PyMySQLSaver` or `AIOMySQLSaver`, make sure to include `autocommit=True`.

  ```python
  from langgraph.checkpoint.mysql.pymysql import PyMySQLSaver

  write_config = {"configurable": {"thread_id": "1", "checkpoint_ns": ""}}
  read_config = {"configurable": {"thread_id": "1"}}

  DB_URI = "mysql://mysql:mysql@localhost:3306/mysql"
  with PyMySQLSaver.from_conn_string(DB_URI) as checkpointer:
      
      checkpointer.setup()
      checkpoint = {
          "v": 1,
          "ts": "2024-07-31T20:14:19.804150+00:00",
          "id": "1ef4f797-8335-6428-8001-8a1503f9b875",
          "channel_values": {
              "my_key": "meow",
              "node": "node"
          },
          "channel_versions": {
              "__start__": 2,
              "my_key": 3,
              "start:node": 3,
              "node": 3
          },
          "versions_seen": {
              "__input__": {},
              "__start__": {
              "__start__": 1
              },
              "node": {
              "start:node": 2
              }
          },
          "pending_sends": [],
      }

      
      checkpointer.put(write_config, checkpoint, {}, {})

      
      checkpointer.get(read_config)

      
      list(checkpointer.list(read_config))
  ```



  ```python
  from langgraph.checkpoint.mysql.aio import AIOMySQLSaver

  async with AIOMySQLSaver.from_conn_string(DB_URI) as checkpointer:
      checkpoint = {
          "v": 1,
          "ts": "2024-07-31T20:14:19.804150+00:00",
          "id": "1ef4f797-8335-6428-8001-8a1503f9b875",
          "channel_values": {
              "my_key": "meow",
              "node": "node"
          },
          "channel_versions": {
              "__start__": 2,
              "my_key": 3,
              "start:node": 3,
              "node": 3
          },
          "versions_seen": {
              "__input__": {},
              "__start__": {
              "__start__": 1
              },
              "node": {
              "start:node": 2
              }
          },
          "pending_sends": [],
      }

      
      await checkpointer.aput(write_config, checkpoint, {}, {})

      
      await checkpointer.aget(read_config)

      
      [c async for c in checkpointer.alist(read_config)]
  ```


pkgId: d6d4714de64daf0194f4a9952bcea5ebc6d5a21a222b1e691bf296dd7fd7c9fb
name: python-langgraph-cli-help
arch: noarch
version: 0.1.62
epoch: 0
release: 1
summary: Development documents and examples for langgraph-cli
url: https://www.github.com/langchain-ai/langgraph
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-langgraph-cli-0.1.62-1.src.rpm
location_href: Packages/python-langgraph-cli-help-0.1.62-1.noarch.rpm
checksum_type: sha256
description:
  The official command-line interface for LangGraph, providing tools to create, develop, and deploy LangGraph applications.



  Install via pip:
  ```bash
  pip install langgraph-cli
  ```

  For development mode with hot reloading:
  ```bash
  pip install "langgraph-cli[inmem]"
  ```




  Create a new LangGraph project from a template
  ```bash
  langgraph new [PATH] --template TEMPLATE_NAME
  ```


  Run LangGraph API server in development mode with hot reloading
  ```bash
  langgraph dev [OPTIONS]
    --host TEXT                 Host to bind to (default: 127.0.0.1)
    --port INTEGER             Port to bind to (default: 2024)
    --no-reload               Disable auto-reload
    --debug-port INTEGER      Enable remote debugging
    --no-browser             Skip opening browser window
    -c, --config FILE        Config file path (default: langgraph.json)
  ```


  Launch LangGraph API server in Docker
  ```bash
  langgraph up [OPTIONS]
    -p, --port INTEGER        Port to expose (default: 8123)
    --wait                   Wait for services to start
    --watch                  Restart on file changes
    --verbose               Show detailed logs
    -c, --config FILE       Config file path
    -d, --docker-compose    Additional services file
  ```


  Build a Docker image for your LangGraph application
  ```bash
  langgraph build -t IMAGE_TAG [OPTIONS]
    --platform TEXT          Target platforms (e.g., linux/amd64,linux/arm64)
    --pull / --no-pull      Use latest/local base image
    -c, --config FILE       Config file path
  ```


  Generate a Dockerfile for custom deployments
  ```bash
  langgraph dockerfile SAVE_PATH [OPTIONS]
    -c, --config FILE       Config file path
  ```



  The CLI uses a `langgraph.json` configuration file with these key settings:

  ```json
  {
    "dependencies": ["langchain_openai", "./your_package"],  // Required: Package dependencies
    "graphs": {
      "my_graph": "./your_package/file.py:graph"            // Required: Graph definitions
    },
    "env": "./.env",                                        // Optional: Environment variables
    "python_version": "3.11",                               // Optional: Python version (3.11/3.12)
    "pip_config_file": "./pip.conf",                        // Optional: pip configuration
    "dockerfile_lines": []                                  // Optional: Additional Dockerfile commands
  }
  ```

  See the [full documentation](https://langchain-ai.github.io/langgraph/docs/cloud/reference/cli.html) for detailed configuration options.



  To develop the CLI itself:

  1. Clone the repository
  2. Navigate to the CLI directory: `cd libs/cli`
  3. Install development dependencies: `poetry install`
  4. Make your changes to the CLI code
  5. Test your changes:
     ```bash
     
     poetry run langgraph --help

     
     cd examples
     poetry install
     poetry run langgraph dev  # or other commands
     ```



  This project is licensed under the terms specified in the repository's LICENSE file.


pkgId: 8bf602330ccd6d06931866bdf3b967dcf3630e42b37a9ff078ab93bcd1ad309f
name: python-langgraph-dynamodb-checkpoint-help
arch: noarch
version: 0.1.0
epoch: 0
release: 1
summary: Development documents and examples for langgraph-dynamodb-checkpoint
url: https://pypi.org/project/langgraph-dynamodb-checkpoint/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-langgraph-dynamodb-checkpoint-0.1.0-1.src.rpm
location_href: Packages/python-langgraph-dynamodb-checkpoint-help-0.1.0-1.noarch.rpm
checksum_type: sha256
description:
  The `langgraph_dynamodb_checkpoint` module provides an implementation for saving checkpoints in DynamoDB for LangGraph applications.



  To install the module, ensure you have Python 3.9 or higher and use the following command:

  `pip install langgraph_dynamodb_checkpoint
  `



  Below is a basic example of how to use the DynamoDB Checkpoint Saver in your LangGraph application.

  `
  from langgraph_dynamodb_checkpoint.dynamodbSaver import DynamoDBSaver
  `

  `
  saver = DynamoDBSaver(table_name='your_table_name', max_read_request_unit=10, max_write_request_unit=10)
  `


pkgId: f5e921714b1fef015f29541315ffcb01ab3ff3857db240b115e1f863c402ef19
name: python-langgraph-dynamodb-saver-help
arch: noarch
version: 0.1.0
epoch: 0
release: 1
summary: Development documents and examples for langgraph-dynamodb-saver
url: https://pypi.org/project/langgraph-dynamodb-saver/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-langgraph-dynamodb-saver-0.1.0-1.src.rpm
location_href: Packages/python-langgraph-dynamodb-saver-help-0.1.0-1.noarch.rpm
checksum_type: sha256
description:
  // @! create readme for included code include=dynamodbSaver.py



  This module provides a DynamoDB-based implementation of the checkpoint saver for LangGraph, allowing you to persist and manage checkpoints using Amazon DynamoDB as the storage backend.



  The `DynamoDBSaver` class implements the `BaseCheckpointSaver` interface and provides functionality to:



  - Automatic table creation with appropriate schema
  - Efficient key-value storage using DynamoDB's partition and sort keys




  with DynamoDBSaver.from_conn_info(table_name='my_checkpoints') as saver:
      
      pass


  saver = DynamoDBSaver('my_checkpoints')


pkgId: c3080ab8f0037b1f77323fecdc82bacda72afb3eff83fc2ac409573256d3127e
name: python-langgraph-help
arch: noarch
version: 0.2.60
epoch: 0
release: 1
summary: Development documents and examples for langgraph
url: https://www.github.com/langchain-ai/langgraph
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-langgraph-0.2.60-1.src.rpm
location_href: Packages/python-langgraph-help-0.2.60-1.noarch.rpm
checksum_type: sha256
description:
  ![Version](https://img.shields.io/pypi/v/langgraph)
  [![Downloads](https://static.pepy.tech/badge/langgraph/month)](https://pepy.tech/project/langgraph)
  [![Open Issues](https://img.shields.io/github/issues-raw/langchain-ai/langgraph)](https://github.com/langchain-ai/langgraph/issues)
  [![Docs](https://img.shields.io/badge/docs-latest-blue)](https://langchain-ai.github.io/langgraph/)

  ⚡ Building language agents as graphs ⚡

  > [!NOTE]
  > Looking for the JS version? Click [here](https://github.com/langchain-ai/langgraphjs) ([JS docs](https://langchain-ai.github.io/langgraphjs/)).



  [LangGraph](https://langchain-ai.github.io/langgraph/) is a library for building stateful, multi-actor applications with LLMs, used to create agent and multi-agent workflows. Compared to other LLM frameworks, it offers these core benefits: cycles, controllability, and persistence. LangGraph allows you to define flows that involve cycles, essential for most agentic architectures, differentiating it from DAG-based solutions. As a very low-level framework, it provides fine-grained control over both the flow and state of your application, crucial for creating reliable agents. Additionally, LangGraph includes built-in persistence, enabling advanced human-in-the-loop and memory features.

  LangGraph is inspired by [Pregel](https://research.google/pubs/pub37252/) and [Apache Beam](https://beam.apache.org/). The public interface draws inspiration from [NetworkX](https://networkx.org/documentation/latest/). LangGraph is built by LangChain Inc, the creators of LangChain, but can be used without LangChain.

  [LangGraph Platform](https://langchain-ai.github.io/langgraph/concepts/langgraph_platform) is infrastructure for deploying LangGraph agents. It is a commercial solution for deploying agentic applications to production, built on the open-source LangGraph framework. The LangGraph Platform consists of several components that work together to support the development, deployment, debugging, and monitoring of LangGraph applications: [LangGraph Server](https://langchain-ai.github.io/langgraph/concepts/langgraph_server) (APIs), [LangGraph SDKs](https://langchain-ai.github.io/langgraph/concepts/sdk) (clients for the APIs), [LangGraph CLI](https://langchain-ai.github.io/langgraph/concepts/langgraph_cli) (command line tool for building the server), [LangGraph Studio](https://langchain-ai.github.io/langgraph/concepts/langgraph_studio) (UI/debugger),

  To learn more about LangGraph, check out our first LangChain Academy course, *Introduction to LangGraph*, available for free [here](https://academy.langchain.com/courses/intro-to-langgraph).



  - **Cycles and Branching**: Implement loops and conditionals in your apps.
  - **Persistence**: Automatically save state after each step in the graph. Pause and resume the graph execution at any point to support error recovery, human-in-the-loop workflows, time travel and more.
  - **Human-in-the-Loop**: Interrupt graph execution to approve or edit next action planned by the agent.
  - **Streaming Support**: Stream outputs as they are produced by each node (including token streaming).
  - **Integration with LangChain**: LangGraph integrates seamlessly with [LangChain](https://github.com/langchain-ai/langchain/) and [LangSmith](https://docs.smith.langchain.com/) (but does not require them).



  LangGraph Platform is a commercial solution for deploying agentic applications to production, built on the open-source LangGraph framework.
  Here are some common issues that arise in complex deployments, which LangGraph Platform addresses:

  - **Streaming support**: LangGraph Server provides [multiple streaming modes](https://langchain-ai.github.io/langgraph/concepts/streaming) optimized for various application needs
  - **Background runs**: Runs agents asynchronously in the background
  - **Support for long running agents**: Infrastructure that can handle long running processes
  - **[Double texting](https://langchain-ai.github.io/langgraph/concepts/double_texting)**: Handle the case where you get two messages from the user before the agent can respond
  - **Handle burstiness**: Task queue for ensuring requests are handled consistently without loss, even under heavy loads



  ```shell
  pip install -U langgraph
  ```



  One of the central concepts of LangGraph is state. Each graph execution creates a state that is passed between nodes in the graph as they execute, and each node updates this internal state with its return value after it executes. The way that the graph updates its internal state is defined by either the type of graph chosen or a custom function.

  Let's take a look at a simple example of an agent that can use a search tool.

  ```shell
  pip install langchain-anthropic
  ```

  ```shell
  export ANTHROPIC_API_KEY=sk-...
  ```

  Optionally, we can set up [LangSmith](https://docs.smith.langchain.com/) for best-in-class observability.

  ```shell
  export LANGSMITH_TRACING=true
  export LANGSMITH_API_KEY=lsv2_sk_...
  ```

  ```python
  from typing import Annotated, Literal, TypedDict

  from langchain_core.messages import HumanMessage
  from langchain_anthropic import ChatAnthropic
  from langchain_core.tools import tool
  from langgraph.checkpoint.memory import MemorySaver
  from langgraph.graph import END, START, StateGraph, MessagesState
  from langgraph.prebuilt import ToolNode



  @tool
  def search(query: str):
      """Call to surf the web."""
      
      if "sf" in query.lower() or "san francisco" in query.lower():
          return "It's 60 degrees and foggy."
      return "It's 90 degrees and sunny."


  tools = [search]

  tool_node = ToolNode(tools)

  model = ChatAnthropic(model="claude-3-5-sonnet-20240620", temperature=0).bind_tools(tools)


  def should_continue(state: MessagesState) -> Literal["tools", END]:
      messages = state['messages']
      last_message = messages[-1]
      
      if last_message.tool_calls:
          return "tools"
      
      return END



  def call_model(state: MessagesState):
      messages = state['messages']
      response = model.invoke(messages)
      
      return {"messages": [response]}



  workflow = StateGraph(MessagesState)


  workflow.add_node("agent", call_model)
  workflow.add_node("tools", tool_node)



  workflow.add_edge(START, "agent")


  workflow.add_conditional_edges(
      
      
      "agent",
      
      should_continue,
  )



  workflow.add_edge("tools", 'agent')


  checkpointer = MemorySaver()





  app = workflow.compile(checkpointer=checkpointer)


  final_state = app.invoke(
      {"messages": [HumanMessage(content="what is the weather in sf")]},
      config={"configurable": {"thread_id": 42}}
  )
  final_state["messages"][-1].content
  ```

  ```
  "Based on the search results, I can tell you that the current weather in San Francisco is:\n\nTemperature: 60 degrees Fahrenheit\nConditions: Foggy\n\nSan Francisco is known for its microclimates and frequent fog, especially during the summer months. The temperature of 60°F (about 15.5°C) is quite typical for the city, which tends to have mild temperatures year-round. The fog, often referred to as "Karl the Fog" by locals, is a characteristic feature of San Francisco\'s weather, particularly in the mornings and evenings.\n\nIs there anything else you\'d like to know about the weather in San Francisco or any other location?"
  ```

  Now when we pass the same `"thread_id"`, the conversation context is retained via the saved state (i.e. stored list of messages)

  ```python
  final_state = app.invoke(
      {"messages": [HumanMessage(content="what about ny")]},
      config={"configurable": {"thread_id": 42}}
  )
  final_state["messages"][-1].content
  ```

  ```
  "Based on the search results, I can tell you that the current weather in New York City is:\n\nTemperature: 90 degrees Fahrenheit (approximately 32.2 degrees Celsius)\nConditions: Sunny\n\nThis weather is quite different from what we just saw in San Francisco. New York is experiencing much warmer temperatures right now. Here are a few points to note:\n\n1. The temperature of 90°F is quite hot, typical of summer weather in New York City.\n2. The sunny conditions suggest clear skies, which is great for outdoor activities but also means it might feel even hotter due to direct sunlight.\n3. This kind of weather in New York often comes with high humidity, which can make it feel even warmer than the actual temperature suggests.\n\nIt's interesting to see the stark contrast between San Francisco's mild, foggy weather and New York's hot, sunny conditions. This difference illustrates how varied weather can be across different parts of the United States, even on the same day.\n\nIs there anything else you'd like to know about the weather in New York or any other location?"
  ```



  1. <details>
      <summary>Initialize the model and tools.</summary>

      - we use `ChatAnthropic` as our LLM. **NOTE:** we need make sure the model knows that it has these tools available to call. We can do this by converting the LangChain tools into the format for OpenAI tool calling using the `.bind_tools()` method.
      - we define the tools we want to use - a search tool in our case. It is really easy to create your own tools - see documentation here on how to do that [here](https://python.langchain.com/docs/modules/agents/tools/custom_tools).
     </details>

  2. <details>
      <summary>Initialize graph with state.</summary>

      - we initialize graph (`StateGraph`) by passing state schema (in our case `MessagesState`)
      - `MessagesState` is a prebuilt state schema that has one attribute -- a list of LangChain `Message` objects, as well as logic for merging the updates from each node into the state
     </details>

  3. <details>
      <summary>Define graph nodes.</summary>

      There are two main nodes we need:

        - The `agent` node: responsible for deciding what (if any) actions to take.
        - The `tools` node that invokes tools: if the agent decides to take an action, this node will then execute that action.
     </details>

  4. <details>
      <summary>Define entry point and graph edges.</summary>

        First, we need to set the entry point for graph execution - `agent` node.

        Then we define one normal and one conditional edge. Conditional edge means that the destination depends on the contents of the graph's state (`MessageState`). In our case, the destination is not known until the agent (LLM) decides.

        - Conditional edge: after the agent is called, we should either:
          - a. Run tools if the agent said to take an action, OR
          - b. Finish (respond to the user) if the agent did not ask to run tools
        - Normal edge: after the tools are invoked, the graph should always return to the agent to decide what to do next
     </details>

  5. <details>
      <summary>Compile the graph.</summary>

      - When we compile the graph, we turn it into a LangChain [Runnable](https://python.langchain.com/v0.2/docs/concepts/#runnable-interface), which automatically enables calling `.invoke()`, `.stream()` and `.batch()` with your inputs
      - We can also optionally pass checkpointer object for persisting state between graph runs, and enabling memory, human-in-the-loop workflows, time travel and more. In our case we use `MemorySaver` - a simple in-memory checkpointer
      </details>

  6. <details>
     <summary>Execute the graph.</summary>

      1. LangGraph adds the input message to the internal state, then passes the state to the entrypoint node, `"agent"`.
      2. The `"agent"` node executes, invoking the chat model.
      3. The chat model returns an `AIMessage`. LangGraph adds this to the state.
      4. Graph cycles the following steps until there are no more `tool_calls` on `AIMessage`:

          - If `AIMessage` has `tool_calls`, `"tools"` node executes
          - The `"agent"` node executes again and returns `AIMessage`

      5. Execution progresses to the special `END` value and outputs the final state.
      And as a result, we get a list of all our chat messages as output.
     </details>




  * [Tutorials](https://langchain-ai.github.io/langgraph/tutorials/): Learn to build with LangGraph through guided examples.
  * [How-to Guides](https://langchain-ai.github.io/langgraph/how-tos/): Accomplish specific things within LangGraph, from streaming, to adding memory & persistence, to common design patterns (branching, subgraphs, etc.), these are the place to go if you want to copy and run a specific code snippet.
  * [Conceptual Guides](https://langchain-ai.github.io/langgraph/concepts/high_level/): In-depth explanations of the key concepts and principles behind LangGraph, such as nodes, edges, state and more.
  * [API Reference](https://langchain-ai.github.io/langgraph/reference/graphs/): Review important classes and methods, simple examples of how to use the graph and checkpointing APIs, higher-level prebuilt components and more.
  * [LangGraph Platform](https://langchain-ai.github.io/langgraph/concepts/#langgraph-platform): LangGraph Platform is a commercial solution for deploying agentic applications in production, built on the open-source LangGraph framework.



  For more information on how to contribute, see [here](https://github.com/langchain-ai/langgraph/blob/main/CONTRIBUTING.md).


pkgId: 041f2764ac356b8345822d1b6b729383ed9d9c7bbc825c17712f77067ac080ba
name: python-langgraph-sdk-help
arch: noarch
version: 0.1.45
epoch: 0
release: 1
summary: Development documents and examples for langgraph-sdk
url: https://www.github.com/langchain-ai/langgraph
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-langgraph-sdk-0.1.45-1.src.rpm
location_href: Packages/python-langgraph-sdk-help-0.1.45-1.noarch.rpm
checksum_type: sha256
description:
  This repository contains the Python SDK for interacting with the LangGraph Cloud REST API.



  To get started with the Python SDK, [install the package](https://pypi.org/project/langgraph-sdk/)

  ```bash
  pip install -U langgraph-sdk
  ```

  You will need a running LangGraph API server. If you're running a server locally using `langgraph-cli`, SDK will automatically point at `http://localhost:8123`, otherwise
  you would need to specify the server URL when creating a client.

  ```python
  from langgraph_sdk import get_client


  client = get_client()


  assistants = await client.assistants.search()


  agent = assistants[0]


  thread = await client.threads.create()


  input = {"messages": [{"role": "human", "content": "what's the weather in la"}]}
  async for chunk in client.runs.stream(thread['thread_id'], agent['assistant_id'], input=input):
      print(chunk)
  ```


pkgId: 813687d1b4cf47a69647eabef93ffcb98ecee2a85735c7e12b01963718a645cf
name: python-langgraph_log_parser-help
arch: noarch
version: 0.1.8
epoch: 0
release: 1
summary: Development documents and examples for langgraph_log_parser
url: https://pypi.org/project/langgraph_log_parser/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-langgraph_log_parser-0.1.8-1.src.rpm
location_href: Packages/python-langgraph_log_parser-help-0.1.8-1.noarch.rpm
checksum_type: sha256
description:
  [![wakatime](https://wakatime.com/badge/user/c88d1b82-ebdd-4842-ad45-93f471842103/project/b6d31f0d-340f-42d5-aa2d-bf3e2e6a0370.svg)](https://wakatime.com/badge/user/c88d1b82-ebdd-4842-ad45-93f471842103/project/b6d31f0d-340f-42d5-aa2d-bf3e2e6a0370)


  Documentation is available at: https://serafinski.github.io/LangGraph-Log-Parser/


  This Python package facilitates the parsing of run logs generated by [LangGraph](https://langchain-ai.github.io/langgraph/). During execution, logs are stored in an SQLite database in an encoded format _(using msgpack)_. These logs are then decoded and exported to a `json` format. Subsequently, the `json` files are transformed into `csv` files for further analysis.

  Once in `csv` format, the data can be analyzed using methods from the [py4pm](https://processintelligence.solutions/static/api/2.7.11/index.html) library. These methods calculate specific statistics related to the multi-agent infrastructure's performance and enable visualizations of the process behavior and execution flow.

  This pipeline provides a streamlined approach for extracting, transforming, and analyzing logs, offering valuable insights into multi-agent systems.


  This package requires Python 3.10 or higher.

  To create virtual environment (using conda), use the following commands:
  ```dotenv
  conda create -n langgraph_log_parser python=3.10
  conda activate langgraph_log_parser
  pip install langgraph_log_parser
  ```

  This example is based on the [Building a Basic Chatbot](https://langchain-ai.github.io/langgraph/tutorials/introduction/#part-1-build-a-basic-chatbot) from LangGraph documentation.
  ```python
  import sqlite3

  from dotenv import load_dotenv
  from typing import Annotated

  from langgraph.checkpoint.sqlite import SqliteSaver
  from typing_extensions import TypedDict
  from langchain_openai import ChatOpenAI
  from langgraph.graph import StateGraph, START, END
  from langgraph.graph.message import add_messages

  from langgraph_log_parser import *

  exp = create_experiment("main")

  load_dotenv()

  conn = sqlite3.connect(exp.database, check_same_thread=False)
  memory = SqliteSaver(conn)

  class State(TypedDict):
      messages: Annotated[list, add_messages]

  graph_builder = StateGraph(State)

  llm = ChatOpenAI(model="gpt-4o-mini")

  def chatbot(state: State):
      return {"messages": [llm.invoke(state["messages"])]}

  graph_builder.add_node("chatbot_node", chatbot)

  graph_builder.add_edge(START, "chatbot_node")
  graph_builder.add_edge("chatbot_node", END)

  graph = graph_builder.compile(checkpointer=memory)

  run_multiple_iterations(graph, 1, 5, {"messages": [("user", "Tell me a joke")]})

  export_sqlite_to_jsons(exp.database, exp.json_dir)

  graph_config = GraphConfig(
      nodes=["chatbot_node"]
  )

  export_jsons_to_csv(exp.json_dir, exp.get_csv_path(), graph_config)

  print()
  event_log = load_event_log(exp.get_csv_path())
  print_analysis(event_log)

  write_report(event_log, exp.reports_all_dir)

  generate_visualizations(event_log, graph, exp.img_dir)
  ```


pkgId: be57debf17ab8b77f8eac1079fdbb6247b602edc4349acb605f9991285d60fea
name: python-langrila-help
arch: noarch
version: 0.4.1
epoch: 0
release: 1
summary: Development documents and examples for langrila
url: https://github.com/taikinman/langrila
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-langrila-0.4.1-1.src.rpm
location_href: Packages/python-langrila-help-0.4.1-1.noarch.rpm
checksum_type: sha256
description:
  Langrila is an open-source third-party python package that is useful to use API-based LLM in the same interface. This package puts emphasis on simple architecture for readability. This package is just personal project.



  1. Sticking to simplicity : This library is motivated by simplifying architecture for readability. Thus too much abstraction should be avoided.
  2. Implementing minimum modules : The more functions each module has, the more complex the source code becomes. Langrila focuses on implementing minimum necessary functions in each module Basically module has only a responsibility expressed by thier module name and main function is implemented in a method easy to understand like `run()` or `arun()` methods except for some.


  - Topic branch are checkout from main branch.
  - Topic branch should be small.


  If necessary, set environment variables to use OpenAI API, Azure OpenAI Service, Gemini API, and Claude API; if using VertexAI or Amazon Bedrock, check each platform's user guide and authenticate in advance VertexAI and Amazon Bedrock.


  - OpenAI
  - Azure OpenAI
  - Gemini on Google AI Studio
  - Gemini on VertexAI
  - Claude on Anthropic
  - Claude on Amazon Bedrock
  - Claude on VertexAI (not tested)


  <details>
  <summary>v0.0.20 -> v0.1.0</summary>

  Interface was updated in v0.1.0, and response format is different from before. Main difference is how to access response text in completion results.

  Before:
  ```python
  response.message["content"]
  ```

  In v0.1.0:
  ```python
  response.message.content[0].text # for single completion
  ```


  For more details, please see [introduction notebook](https://github.com/taikinman/langrila/blob/main/notebooks/01.introduction.ipynb).

  </details>

  <details>
  <summary>v0.0.7 -> v0.0.8</summary>

  Database modules has breaking changes from v0.0.7 to v0.0.8 such as rename of method, change the interface of some methods. For more details, see [this PR](https://github.com/taikinman/langrila/pull/34).

  </details>


  <details>
  <summary>v0.0.2 -> v0.0.3</summary>

  I have integrated gemini api into langrila on v0.0.3. When doing this, the modules for openai and azure openai should be separated from gemini's modules so that unnecessary dependencies won't happen while those components has the same interface. But migration is easy. Basically only thing to do is to change import modules level like `from langrila import OpenAIChatModule` to `from langrila.openai import OpenAIChatModule`. It's the same as other modules related to openai api.

  Second change point is return type of `stream()` and `astream()` method. From v0.0.3, all return types of all chunks is CompletionResults.

  Third point is the name of results class : `RetrievalResult` to `RetrievalResults`. `RetrievalResults` model has collections atribute now. Also similarities was replaced with scores.

  </details>


  Sample notebook [01.introduction.ipynb](https://github.com/taikinman/langrila/blob/main/notebooks/01.introduction.ipynb) includes following contents:

  - Basic usage with simple text prompt
      - Chat Completion of OpenAI
      - Chat Completion on Azure OpenAI
      - Gemini of Google AI Studio
      - Gemini on VertexAI
      - Claude of Anthropic
      - Claude on Amazon Bedrock
  - Universal message system in langrila
  - How to specify system instruction
  - Token management
  - Usage gathering across multiple models
  - Prompt template

  [02.function_calling.ipynb](https://github.com/taikinman/langrila/blob/main/notebooks/02.function_calling.ipynb) instruct function calling in langrila.

  - Basic usage for OpenAI Chat Completion, Gemini and Claude
  - Universal tool config system
  - Limitation for the function calling

  [03.structured_output.ipynb](https://github.com/taikinman/langrila/blob/main/notebooks/03.structured_output.ipynb), you can see:

  - JSON mode output for OpenAI and Gemini
  - Pydantic schema output for OpenAI

  [04.media_and_file_input.ipynb](https://github.com/taikinman/langrila/blob/main/notebooks/04.media_and_file_input.ipynb) show you the following contents:

  - Image input
  - PDF file input
  - Video input
  - Data uploading and analyzing by specifying uri for Gemini

  [05.conversation_memory.ipynb](https://github.com/taikinman/langrila/blob/main/notebooks/05.conversation_memory.ipynb) provides you with how to store conversation history.

  - Way to keep conversation history
  - Multi-tuen conversation
  - Multi-turn conversation with multiple client
  - Multi-turn conversation using tools
  - Multi-turn conversation using tools with multiple client
  - Introduction conversation memory modules:
      - JSONConversationMemory
      - PickleConversationMemory
      - CosmosConversationMemory for Azure Cosmos DB (Thanks to [@rioriost](https://github.com/rioriost))
      - S3ConversationMemory for AWS S3 (Thanks to [@kun432](https://github.com/kun432))

  [06.embedding_text.ipynb](https://github.com/taikinman/langrila/blob/main/notebooks/06.embedding_text.ipynb)

  - For OpenAI
  - For Azure OpenAI
  - For Gemini on Google AI Studio
  - For Gemini on VertexAI

  [07.basic_rag.ipynb](https://github.com/taikinman/langrila/blob/main/notebooks/07.basic_rag.ipynb)

  - For Qdrant
  - For Chroma
  - For Usearch




  - Python >=3.10,<3.13


  Langrila has various extra installation options. See the following installation section and [pyproject.toml](https://github.com/taikinman/langrila/blob/main/pyproject.toml).


  See extra dependencies section in [pyproject.toml](https://github.com/taikinman/langrila/blob/main/pyproject.toml) for more detail installation options.



  ```

  pip install langrila[openai]


  pip install langrila[gemini]


  pip install langrila[claude]


  pip install langrila[openai,gemini,claude]


  pip install langrila[gemini,audio,video,pdf]


  pip install langrila[gemini,vertexai]


  pip install langrila[openai,qdrant]
  ```


  ```

  poetry add langrila --extras openai


  poetry add langrila --extras gemini


  poetry add langrila --extras claude


  poetry add langrila --extras "openai gemini claude"


  poetry add langrila --extras "gemini audio video pdf"


  poetry add langrila --extras "gemini vertexai"


  poetry add langrila --extras "openai qdrant"
  ```



  ```
  git clone git@github.com:taikinman/langrila.git
  ```


  ```
  cd langrila

  pip install -e .{extra packages}
  ```


  ```

  poetry add --editable /path/to/langrila/ --extras "{extra packages}"
  ```


pkgId: 134c330565746d19065a9783a08be7f09f4f19c31178473238a5a9693c65aa85
name: python-langroid-help
arch: noarch
version: 0.28.2
epoch: 0
release: 1
summary: Development documents and examples for langroid
url: https://pypi.org/project/langroid/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-langroid-0.28.2-1.src.rpm
location_href: Packages/python-langroid-help-0.28.2-1.noarch.rpm
checksum_type: sha256
description:
  Langroid requires Python 3.11+. We recommend using a virtual environment.
  Use `pip` to install a bare-bones slim version of `langroid` (from PyPi) to your virtual
  environment:
  ```bash
  pip install langroid
  ```
  The core Langroid package lets you use OpenAI Embeddings models via their API.
  If you instead want to use the `sentence-transformers` embedding models from HuggingFace,
  install Langroid like this:
  ```bash
  pip install "langroid[hf-embeddings]"
  ```
  For many practical scenarios, you may need additional optional dependencies:
  - To use various document-parsers, install langroid with the `doc-chat` extra:
      ```bash
      pip install "langroid[doc-chat]"
      ```
  - For "chat with databases", use the `db` extra:
      ```bash
      pip install "langroid[db]"
      ``
  - You can specify multiple extras by separating them with commas, e.g.:
      ```bash
      pip install "langroid[doc-chat,db]"
      ```
  - To simply install _all_ optional dependencies, use the `all` extra (but note that this will result in longer load/startup times and a larger install size):
      ```bash
      pip install "langroid[all]"
      ```
  <details>
  <summary><b>Optional Installs for using SQL Chat with a PostgreSQL DB </b></summary>
  If you are using `SQLChatAgent`
  (e.g. the script [`examples/data-qa/sql-chat/sql_chat.py`](examples/data-qa/sql-chat/sql_chat.py)),
  with a postgres db, you will need to:
  - Install PostgreSQL dev libraries for your platform, e.g.
    - `sudo apt-get install libpq-dev` on Ubuntu,
    - `brew install postgresql` on Mac, etc.
  - Install langroid with the postgres extra, e.g. `pip install langroid[postgres]`
    or `poetry add langroid[postgres]` or `poetry install -E postgres`.
    If this gives you an error, try `pip install psycopg2-binary` in your virtualenv.
  </details>

  To get started, all you need is an OpenAI API Key.
  If you don't have one, see [this OpenAI Page](https://platform.openai.com/docs/quickstart).
  (Note that while this is the simplest way to get started, Langroid works with practically any LLM, not just those from OpenAI.
  See the guides to using [Open/Local LLMs](https://langroid.github.io/langroid/tutorials/local-llm-setup/),
  and other [non-OpenAI](https://langroid.github.io/langroid/tutorials/non-openai-llms/) proprietary LLMs.)
  In the root of the repo, copy the `.env-template` file to a new file `.env`:
  ```bash
  cp .env-template .env
  ```
  Then insert your OpenAI API Key.
  Your `.env` file should look like this (the organization is optional
  but may be required in some scenarios).
  ```bash
  OPENAI_API_KEY=your-key-here-without-quotes
  OPENAI_ORGANIZATION=optionally-your-organization-id
  ````
  Alternatively, you can set this as an environment variable in your shell
  (you will need to do this every time you open a new shell):
  ```bash
  export OPENAI_API_KEY=your-key-here-without-quotes
  ```
  <details>
  <summary><b>Optional Setup Instructions (click to expand) </b></summary>
  All of the following environment variable settings are optional, and some are only needed
  to use specific features (as noted below).
  - **Qdrant** Vector Store API Key, URL. This is only required if you want to use Qdrant cloud.
    Alternatively [Chroma](https://docs.trychroma.com/) or [LanceDB](https://lancedb.com/) are also currently supported.
    We use the local-storage version of Chroma, so there is no need for an API key.
  - **Redis** Password, host, port: This is optional, and only needed to cache LLM API responses
    using Redis Cloud. Redis [offers](https://redis.com/try-free/) a free 30MB Redis account
    which is more than sufficient to try out Langroid and even beyond.
    If you don't set up these, Langroid will use a pure-python
    Redis in-memory cache via the [Fakeredis](https://fakeredis.readthedocs.io/en/latest/) library.
  - **Momento** Serverless Caching of LLM API responses (as an alternative to Redis).
     To use Momento instead of Redis:
    - enter your Momento Token in the `.env` file, as the value of `MOMENTO_AUTH_TOKEN` (see example file below),
    - in the `.env` file set `CACHE_TYPE=momento` (instead of `CACHE_TYPE=redis` which is the default).
  - **GitHub** Personal Access Token (required for apps that need to analyze git
    repos; token-based API calls are less rate-limited). See this
    [GitHub page](https://docs.github.com/en/authentication/keeping-your-account-and-data-secure/managing-your-personal-access-tokens).
  - **Google Custom Search API Credentials:** Only needed to enable an Agent to use the `GoogleSearchTool`.
    To use Google Search as an LLM Tool/Plugin/function-call,
    you'll need to set up
    [a Google API key](https://developers.google.com/custom-search/v1/introduction#identify_your_application_to_google_with_api_key),
    then [setup a Google Custom Search Engine (CSE) and get the CSE ID](https://developers.google.com/custom-search/docs/tutorial/creatingcse).
    (Documentation for these can be challenging, we suggest asking GPT4 for a step-by-step guide.)
    After obtaining these credentials, store them as values of
    `GOOGLE_API_KEY` and `GOOGLE_CSE_ID` in your `.env` file.
    Full documentation on using this (and other such "stateless" tools) is coming soon, but
    in the meantime take a peek at this [chat example](examples/basic/chat-search.py), which
    shows how you can easily equip an Agent with a `GoogleSearchtool`.
  If you add all of these optional variables, your `.env` file should look like this:
  ```bash
  OPENAI_API_KEY=your-key-here-without-quotes
  GITHUB_ACCESS_TOKEN=your-personal-access-token-no-quotes
  CACHE_TYPE=redis # or momento
  REDIS_PASSWORD=your-redis-password-no-quotes
  REDIS_HOST=your-redis-hostname-no-quotes
  REDIS_PORT=your-redis-port-no-quotes
  MOMENTO_AUTH_TOKEN=your-momento-token-no-quotes # instead of REDIS* variables
  QDRANT_API_KEY=your-key
  QDRANT_API_URL=https://your.url.here:6333 # note port number must be included
  GOOGLE_API_KEY=your-key
  GOOGLE_CSE_ID=your-cse-id
  ```
  </details>
  <details>
  <summary><b>Optional setup instructions for Microsoft Azure OpenAI(click to expand)</b></summary>
  When using Azure OpenAI, additional environment variables are required in the
  `.env` file.
  This page [Microsoft Azure OpenAI](https://learn.microsoft.com/en-us/azure/ai-services/openai/chatgpt-quickstart?tabs=command-line&pivots=programming-language-python#environment-variables)
  provides more information, and you can set each environment variable as follows:
  - `AZURE_OPENAI_API_KEY`, from the value of `API_KEY`
  - `AZURE_OPENAI_API_BASE` from the value of `ENDPOINT`, typically looks like `https://your.domain.azure.com`.
  - For `AZURE_OPENAI_API_VERSION`, you can use the default value in `.env-template`, and latest version can be found [here](https://learn.microsoft.com/en-us/azure/ai-services/openai/whats-new#azure-openai-chat-completion-general-availability-ga)
  - `AZURE_OPENAI_DEPLOYMENT_NAME` is the name of the deployed model, which is defined by the user during the model setup
  - `AZURE_OPENAI_MODEL_NAME` Azure OpenAI allows specific model names when you select the model for your deployment. You need to put precisly the exact model name that was selected. For example, GPT-4 (should be `gpt-4-32k` or `gpt-4`).
  - `AZURE_OPENAI_MODEL_VERSION` is required if `AZURE_OPENAI_MODEL_NAME = gpt=4`, which will assist Langroid to determine the cost of the model


pkgId: 9754dde1e6d7bb6c0fe0c3b52894004be60c466e35104c67cefef504c02ac0d2
name: python-langsmith-help
arch: noarch
version: 0.2.4
epoch: 0
release: 1
summary: Development documents and examples for langsmith
url: https://smith.langchain.com/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-langsmith-0.2.4-1.src.rpm
location_href: Packages/python-langsmith-help-0.2.4-1.noarch.rpm
checksum_type: sha256
description:
   [![Release Notes](https://img.shields.io/github/release/langchain-ai/langsmith-sdk?logo=python)](https://github.com/langchain-ai/langsmith-sdk/releases)
   [![Python Downloads](https://static.pepy.tech/badge/langsmith/month)](https://pepy.tech/project/langsmith)

  This package contains the Python client for interacting with the [LangSmith platform](https://smith.langchain.com/).

  To install:

  ```bash
  pip install -U langsmith
  export LANGSMITH_TRACING=true
  export LANGSMITH_API_KEY=ls_...
  ```

  Then trace:

  ```python
  import openai
  from langsmith.wrappers import wrap_openai
  from langsmith import traceable


  client = wrap_openai(openai.Client())

  @traceable # Auto-trace this function
  def pipeline(user_input: str):
      result = client.chat.completions.create(
          messages=[{"role": "user", "content": user_input}],
          model="gpt-3.5-turbo"
      )
      return result.choices[0].message.content

  pipeline("Hello, world!")
  ```
  See the resulting nested trace [🌐 here](https://smith.langchain.com/public/b37ca9b1-60cd-4a2a-817e-3c4e4443fdc0/r).

  LangSmith helps you and your team develop and evaluate language models and intelligent agents. It is compatible with any LLM application.

  > **Cookbook:** For tutorials on how to get more value out of LangSmith, check out the [Langsmith Cookbook](https://github.com/langchain-ai/langsmith-cookbook/tree/main) repo.

  A typical workflow looks like:

  1. Set up an account with LangSmith.
  2. Log traces while debugging and prototyping.
  3. Run benchmark evaluations and continuously improve with the collected data.

  We'll walk through these steps in more detail below.



  Sign up for [LangSmith](https://smith.langchain.com/) using your GitHub, Discord accounts, or an email address and password. If you sign up with an email, make sure to verify your email address before logging in.

  Then, create a unique API key on the [Settings Page](https://smith.langchain.com/settings), which is found in the menu at the top right corner of the page.

  Note: Save the API Key in a secure location. It will not be shown again.



  You can log traces natively using the LangSmith SDK or within your LangChain application.



  LangSmith seamlessly integrates with the Python LangChain library to record traces from your LLM applications.

  1. **Copy the environment variables from the Settings Page and add them to your application.**

  Tracing can be activated by setting the following environment variables or by manually specifying the LangChainTracer.

  ```python
  import os
  os.environ["LANGSMITH_TRACING_V2"] = "true"
  os.environ["LANGSMITH_ENDPOINT"] = "https://api.smith.langchain.com"

  os.environ["LANGSMITH_API_KEY"] = "<YOUR-LANGSMITH-API-KEY>"

  ```

  > **Tip:** Projects are groups of traces. All runs are logged to a project. If not specified, the project is set to `default`.

  2. **Run an Agent, Chain, or Language Model in LangChain**

  If the environment variables are correctly set, your application will automatically connect to the LangSmith platform.

  ```python
  from langchain_core.runnables import chain

  @chain
  def add_val(x: dict) -> dict:
      return {"val": x["val"] + 1}

  add_val({"val": 1})
  ```



  You can still use the LangSmith development platform without depending on any
  LangChain code.

  1. **Copy the environment variables from the Settings Page and add them to your application.**

  ```python
  import os
  os.environ["LANGCHAIN_ENDPOINT"] = "https://api.smith.langchain.com"
  os.environ["LANGCHAIN_API_KEY"] = "<YOUR-LANGSMITH-API-KEY>"

  ```

  2. **Log traces**

  The easiest way to log traces using the SDK is via the `@traceable` decorator. Below is an example.

  ```python
  from datetime import datetime
  from typing import List, Optional, Tuple

  import openai
  from langsmith import traceable
  from langsmith.wrappers import wrap_openai

  client = wrap_openai(openai.Client())

  @traceable
  def argument_generator(query: str, additional_description: str = "") -> str:
      return client.chat.completions.create(
          [
              {"role": "system", "content": "You are a debater making an argument on a topic."
               f"{additional_description}"
               f" The current time is {datetime.now()}"},
              {"role": "user", "content": f"The discussion topic is {query}"}
          ]
      ).choices[0].message.content



  @traceable
  def argument_chain(query: str, additional_description: str = "") -> str:
      argument = argument_generator(query, additional_description)
      
      return argument

  argument_chain("Why is blue better than orange?")
  ```

  Alternatively, you can manually log events using the `Client` directly or using a `RunTree`, which is what the traceable decorator is meant to manage for you!

  A RunTree tracks your application. Each RunTree object is required to have a `name` and `run_type`. These and other important attributes are as follows:

  - `name`: `str` - used to identify the component's purpose
  - `run_type`: `str` - Currently one of "llm", "chain" or "tool"; more options will be added in the future
  - `inputs`: `dict` - the inputs to the component
  - `outputs`: `Optional[dict]` - the (optional) returned values from the component
  - `error`: `Optional[str]` - Any error messages that may have arisen during the call

  ```python
  from langsmith.run_trees import RunTree

  parent_run = RunTree(
      name="My Chat Bot",
      run_type="chain",
      inputs={"text": "Summarize this morning's meetings."},
      
  )
  parent_run.post()

  child_llm_run = parent_run.create_child(
      name="My Proprietary LLM",
      run_type="llm",
      inputs={
          "prompts": [
              "You are an AI Assistant. The time is XYZ."
              " Summarize this morning's meetings."
          ]
      },
  )
  child_llm_run.post()
  child_llm_run.end(
      outputs={
          "generations": [
              "I should use the transcript_loader tool"
              " to fetch meeting_transcripts from XYZ"
          ]
      }
  )
  child_llm_run.patch()


  child_tool_run = parent_run.create_child(
      name="transcript_loader",
      run_type="tool",
      inputs={"date": "XYZ", "content_type": "meeting_transcripts"},
  )
  child_tool_run.post()

  child_tool_run.end(outputs={"meetings": ["Meeting1 notes.."]})
  child_tool_run.patch()

  child_chain_run = parent_run.create_child(
      name="Unreliable Component",
      run_type="tool",
      inputs={"input": "Summarize these notes..."},
  )
  child_chain_run.post()

  try:
      
      raise ValueError("Something went wrong")
      child_chain_run.end(outputs={"output": "foo"}
      child_chain_run.patch()
  except Exception as e:
      child_chain_run.end(error=f"I errored again {e}")
      child_chain_run.patch()
      pass


  parent_run.end(outputs={"output": ["The meeting notes are as follows:..."]})
  res = parent_run.patch()
  res.result()
  ```



  Once your runs are stored in LangSmith, you can convert them into a dataset.
  For this example, we will do so using the Client, but you can also do this using
  the web interface, as explained in the [LangSmith docs](https://docs.smith.langchain.com/docs/).

  ```python
  from langsmith import Client

  client = Client()
  dataset_name = "Example Dataset"


  runs = client.list_runs(
      project_name="my_project",
      execution_order=1,
      error=False,
  )

  dataset = client.create_dataset(dataset_name, description="An example dataset")
  for run in runs:
      client.create_example(
          inputs=run.inputs,
          outputs=run.outputs,
          dataset_id=dataset.id,
      )
  ```



  Check out the [LangSmith Testing & Evaluation dos](https://docs.smith.langchain.com/docs/evaluation/) for up-to-date workflows.

  For generating automated feedback on individual runs, you can run evaluations directly using the LangSmith client.

  ```python
  from typing import Optional
  from langsmith.evaluation import StringEvaluator


  def jaccard_chars(output: str, answer: str) -> float:
      """Naive Jaccard similarity between two strings."""
      prediction_chars = set(output.strip().lower())
      answer_chars = set(answer.strip().lower())
      intersection = prediction_chars.intersection(answer_chars)
      union = prediction_chars.union(answer_chars)
      return len(intersection) / len(union)


  def grader(run_input: str, run_output: str, answer: Optional[str]) -> dict:
      """Compute the score and/or label for this run."""
      if answer is None:
          value = "AMBIGUOUS"
          score = 0.5
      else:
          score = jaccard_chars(run_output, answer)
          value = "CORRECT" if score > 0.9 else "INCORRECT"
      return dict(score=score, value=value)

  evaluator = StringEvaluator(evaluation_name="Jaccard", grading_function=grader)

  runs = client.list_runs(
      project_name="my_project",
      execution_order=1,
      error=False,
  )
  for run in runs:
      client.evaluate_run(run, evaluator)
  ```




  LangSmith easily integrates with your favorite LLM framework.



  <!-- markdown-link-check-disable -->
  We provide a convenient wrapper for the [OpenAI SDK](https://platform.openai.com/docs/api-reference).

  In order to use, you first need to set your LangSmith API key.

  ```shell
  export LANGCHAIN_API_KEY=<your-api-key>
  ```

  Next, you will need to install the LangSmith SDK:

  ```shell
  pip install -U langsmith
  ```

  After that, you can wrap the OpenAI client:

  ```python
  from openai import OpenAI
  from langsmith import wrappers

  client = wrappers.wrap_openai(OpenAI())
  ```

  Now, you can use the OpenAI client as you normally would, but now everything is logged to LangSmith!

  ```python
  client.chat.completions.create(
      model="gpt-4",
      messages=[{"role": "user", "content": "Say this is a test"}],
  )
  ```

  Oftentimes, you use the OpenAI client inside of other functions.
  You can get nested traces by using this wrapped client and decorating those functions with `@traceable`.
  See [this documentation](https://docs.smith.langchain.com/tracing/faq/logging_and_viewing) for more documentation how to use this decorator

  ```python
  from langsmith import traceable

  @traceable(name="Call OpenAI")
  def my_function(text: str):
      return client.chat.completions.create(
          model="gpt-4",
          messages=[{"role": "user", "content": f"Say {text}"}],
      )

  my_function("hello world")
  ```



  We provide a convenient integration with [Instructor](https://jxnl.github.io/instructor/), largely by virtue of it essentially just using the OpenAI SDK.

  In order to use, you first need to set your LangSmith API key.

  ```shell
  export LANGCHAIN_API_KEY=<your-api-key>
  ```

  Next, you will need to install the LangSmith SDK:

  ```shell
  pip install -U langsmith
  ```

  After that, you can wrap the OpenAI client:

  ```python
  from openai import OpenAI
  from langsmith import wrappers

  client = wrappers.wrap_openai(OpenAI())
  ```

  After this, you can patch the OpenAI client using `instructor`:

  ```python
  import instructor

  client = instructor.patch(OpenAI())
  ```

  Now, you can use `instructor` as you normally would, but now everything is logged to LangSmith!

  ```python
  from pydantic import BaseModel


  class UserDetail(BaseModel):
      name: str
      age: int


  user = client.chat.completions.create(
      model="gpt-3.5-turbo",
      response_model=UserDetail,
      messages=[
          {"role": "user", "content": "Extract Jason is 25 years old"},
      ]
  )
  ```

  Oftentimes, you use `instructor` inside of other functions.
  You can get nested traces by using this wrapped client and decorating those functions with `@traceable`.
  See [this documentation](https://docs.smith.langchain.com/tracing/faq/logging_and_viewing) for more documentation how to use this decorator

  ```python
  @traceable()
  def my_function(text: str) -> UserDetail:
      return client.chat.completions.create(
          model="gpt-3.5-turbo",
          response_model=UserDetail,
          messages=[
              {"role": "user", "content": f"Extract {text}"},
          ]
      )


  my_function("Jason is 25 years old")
  ```




  To learn more about the LangSmith platform, check out the [docs](https://docs.smith.langchain.com/docs/).


pkgId: 8856721392fd8a0b23464e1ee2eb44ff9dc25aafe56bd942ef86a74febfb9a82
name: python-langtask-help
arch: noarch
version: 0.1.2
epoch: 0
release: 1
summary: Development documents and examples for langtask
url: https://pypi.org/project/langtask/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-langtask-0.1.2-1.src.rpm
location_href: Packages/python-langtask-help-0.1.2-1.noarch.rpm
checksum_type: sha256
description:
  [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
  ![Python Version](https://img.shields.io/badge/python-3.10%2B-blue)
  ![Status](https://img.shields.io/badge/status-pre--alpha-red)

  LangTask is a lightweight Python library for rapidly setting up and managing LLM prompts with structured input/output validation. It provides a clean, type-safe interface for working with language models while enforcing schema validation and proper error handling.

  > ⚠️ **Development Status Note**: This is a work-in-progress personal project. The API will change significantly.

  > 📝 **Documentation Note**: This project intentionally includes extensive documentation and inline examples to facilitate better understanding by LLMs. The API.md file can be used as a reference document in LLM chats to enable quick comprehension of the framework's usage patterns.




  - 🔍 **Schema Validation**: Type-safe input and output validation using Pydantic models with dot notation access
  - 🔄 **Provider Flexibility**: Support for multiple LLM providers (currently OpenAI and Anthropic)
  - 📝 **Prompt Management**: Simple directory-based prompt organization and discovery
  - ⚡ **Easy Integration**: Clean API for registering and running prompts
  - 🛠️ **Error Handling**: Comprehensive error hierarchy with detailed feedback
  - 📊 **Logging**: Structured logging with request tracing and performance monitoring



  ```bash
  pip install langtask
  ```




  First, import the library (we'll use this import in all following examples):
  ```python
  import langtask as lt
  ```

  1. Create a prompt directory structure:

  ```
  prompts/
  └── greeting/
      ├── config.yaml           # LLM configuration
      ├── instructions.md       # Prompt template
      ├── input_schema.yaml     # Input validation schema
      └── output_schema.yaml    # Output validation schema (optional)
  ```

  2. Configure your prompt:

  ```yaml

  id: greeting
  display_name: Greeting Generator
  description: Generates personalized greetings
  llm:
    provider: anthropic
    model: claude-3-5-sonnet-20241022
    temperature: 0.7
  ```

  3. Define input schema:

  ```yaml

  name:
    type: string
    description: Name of the person to greet
  style:
    type: string
    description: Style of greeting
    options: ["formal", "casual"]
    required: false  # This field is optional
  ```

  4. Create prompt instructions:

  ```markdown

  Generate a {{STYLE}} greeting for {{Name}}.

  Generate a {{style}} greeting for {{name}}.
  ```

  5. Use in your code:

  ```python

  lt.register("prompts")


  response = lt.run("greeting", {
      "NAME": "Alice",  # Will work
      "style": "casual" # Will also work
  })
  print(response)  # "Hey Alice! How's it going?"


  response = lt.run("analyze-sentiment", {
      "text": "Great product!"
  })
  print(response.sentiment)      # "positive"
  print(response.confidence)     # 0.95
  print(response.word_count)     # 2
  ```




  LangTask handles variable names case-insensitively throughout the system:
  - Template variables like `{{NAME}}`, `{{name}}`, or `{{Name}}` are treated as identical
  - Input parameters can use any case (e.g., `"NAME"`, `"name"`, `"Name"`)
  - Schema definitions use lowercase internally
  - All comparisons and validations are case-insensitive

  Type names in schemas should use JSON Schema conventions:
  - Use `string` instead of `str`
  - Use `integer` instead of `int`
  - Use `number` instead of `float`
  - Use `boolean` instead of `bool`
  - Use `object` instead of `dict`

  Arrays are defined using the `list` attribute on any field (e.g., `list: true`, `list: 3`, `list: "2-5"`, `list: "3+"`)




  LangTask uses a directory-based approach for organizing prompts:

  ```
  prompts/
  ├── greeting/
  │   ├── config.yaml
  │   ├── instructions.md
  │   └── input_schema.yaml
  └── sentiment/
      ├── config.yaml
      ├── instructions.md
      ├── input_schema.yaml
      └── output_schema.yaml
  ```

  Each prompt requires:
  - `config.yaml`: LLM provider settings and prompt metadata
  - `instructions.md`: The actual prompt template with variable placeholders
  - `input_schema.yaml`: Schema defining expected input parameters
  - `output_schema.yaml`: Schema for structured output validation (required for dot notation access)




  Set global defaults for all prompts:

  ```python
  lt.set_global_config({
      "provider": "anthropic",
      "model": "claude-3-5-haiku-20241022",
      "temperature": 0.1
  })
  ```

  Or use provider-specific settings per prompt in `config.yaml`:

  ```yaml
  llm:
    - provider: anthropic
      model: claude-3-5-haiku-20241022
      temperature: 0.7
    - provider: openai
      model: gpt-4
      temperature: 0.5
      max_tokens: 1000
  ```




  When using output schemas, responses are returned as Pydantic models with dot notation access:

  ```yaml

  sentiment:
    type: string
    description: Detected sentiment
    options: ["positive", "negative", "neutral"]
  confidence:
    type: number
    description: Confidence score
    required: false  # Optional field
  word_count:
    type: integer
    description: Number of words analyzed
  ```

  > **Note**: The `options` field can be used with string, integer, and number types as long as all values are of the same type. For example:
  ```yaml
  priority:
    type: integer
    options: [1, 2, 3]

  confidence_intervals:
    type: number
    options: [0.25, 0.5, 0.75, 1.0]
  ```

  ```python

  result = lt.run("analyze-sentiment", {"text": "Great product!"})


  print(result.sentiment)    # "positive"
  print(result.confidence)   # 0.95
  print(f"Analysis based on {result.word_count} words")


  data = result.model_dump()
  ```

  Key benefits:
  - Type-safe field access
  - IDE autocompletion support
  - Immutable response objects
  - Automatic type conversion
  - Clear error messages for invalid access




  LangTask provides comprehensive logging with configurable settings for both console and file output:


  - Colored console output with configurable level
  - File logging with automatic rotation
  - Request ID tracking for operation tracing
  - Performance metrics for monitoring
  - Structured formatting for easy parsing


  Use `set_logs()` to configure logging behavior:

  ```python

  lt.set_logs("./my_logs")


  lt.set_logs(
      path="./app/logs",              # Custom log directory
      console_level="WARNING",        # Less console output
      file_level="DEBUG",            # Detailed file logs
      rotation="100 MB",             # Larger log files
      retention="1 month"            # Keep logs longer
  )


  lt.set_logs()
  ```


  - `path`: Directory for log files (default: './logs')
  - `console_level`: Console logging level (default: 'INFO')
    - Options: 'DEBUG', 'INFO', 'WARNING', 'ERROR', 'CRITICAL'
  - `file_level`: File logging level (default: 'DEBUG')
    - Options: Same as console_level
  - `rotation`: When to rotate log files (default: '10 MB')
    - Size-based: '10 MB', '1 GB', etc.
    - Time-based: '1 day', '1 week', etc.
  - `retention`: How long to keep old logs (default: '1 week')
    - '1 week', '1 month', '90 days', etc.


  - Console: INFO level with color-coded output
  - File: DEBUG level for detailed troubleshooting
  - Location: `./logs/langtask.log`
  - Rotation: 10 MB file size
  - Retention: 1 week


  If the specified log directory cannot be created or accessed:
  - Custom path: Raises FileSystemError
  - Default path: Falls back to console-only logging with warning


  ```
  2024-03-22 10:15:30 | req-123 | INFO    | prompt_loader  | Loading prompt | prompt_id=greeting
  2024-03-22 10:15:30 | req-123 | WARNING | schema_loader  | Unknown field detected | field=custom_param
  2024-03-22 10:15:31 | req-123 | SUCCESS | llm_processor  | Request processed | duration_ms=523.45
  ```




  LangTask supports multiple ways to configure your API keys:

  1. Direct environment variables:
  ```bash

  export ANTHROPIC_API_KEY=sk-ant-...


  export OPENAI_API_KEY=sk-...
  ```

  2. Using `.env` file (recommended for development):
  ```bash

  ANTHROPIC_API_KEY=sk-ant-...
  OPENAI_API_KEY=sk-...
  ```

  Then in your code:
  ```python
  from dotenv import load_dotenv
  load_dotenv()
  ```

  3. Setting in your deployment environment (recommended for production)

  Remember to add `.env` to your `.gitignore` to protect your API keys.




  - Python 3.10 or higher
  - Dependencies:
    - pydantic >= 2.0
    - langchain >= 0.1.0
    - langchain-openai >= 0.0.2
    - langchain-anthropic >= 0.1.1
    - pyyaml >= 6.0
    - python-dotenv >= 0.19.0
    - loguru >= 0.7.0



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



  Contributions are welcome! Feel free to submit an issue or pull request.


pkgId: 858520532f1da0326e7e72f6efe6eba6007fdf268418f65db6b83dcf2dc95d66
name: python-langtest-help
arch: noarch
version: 2.4.0
epoch: 0
release: 1
summary: Development documents and examples for langtest
url: https://www.langtest.org
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-langtest-2.4.0-1.src.rpm
location_href: Packages/python-langtest-help-2.4.0-1.noarch.rpm
checksum_type: sha256
description:
  <p align="center">
    <img src="https://raw.githubusercontent.com/JohnSnowLabs/langtest/main/docs/assets/images/langtest/langtest_logo.png" alt="johnsnowlabs_logo" width="360" style="text-align:center;">
  </p>

  <div align="center">
    <h1 style="text-align: center; vertical-align: middle;">LangTest: Deliver Safe & Effective Language Models</h1>
  </div>

  <p align="center">
      <a href="https://github.com/JohnSnowLabs/langtest/releases">
          <img alt="Release Notes" src="https://img.shields.io/github/v/release/johnsnowlabs/langtest.svg">
      </a>
      <a href="https://www.johnsnowlabs.com/responsible-ai-blog/">
          <img alt="Blog" src="https://img.shields.io/badge/Responsible AI Blogs-8A2BE2">
      </a>
      <a href="https://langtest.org/docs/pages/docs/install">
          <img alt="Documentation" src="https://img.shields.io/website?up_message=online&url=https%3A%2F%2Flangtest.org%2F">
      </a>
      <a href="https://star-history.com/#JohnSnowLabs/langtest">
          <img alt="GitHub star chart" src="https://img.shields.io/github/stars/JohnSnowLabs/langtest?style=social">
      </a>
      <a href="https://github.com/JohnSnowLabs/langtest/issues">
          <img alt="Open Issues" src="https://img.shields.io/github/issues-raw/JohnSnowLabs/langtest">
      </a>
      <a href="https://pepy.tech/project/langtest">
          <img alt="Downloads" src="https://static.pepy.tech/badge/langtest">
      </a>
      <a href="https://github.com/JohnSnowLabs/langtest/actions/workflows/build_and_test.yml">
          <img alt="CI" src="https://github.com/JohnSnowLabs/langtest/actions/workflows/build_and_test.yml/badge.svg">
      </a>
      <a href="https://github.com/JohnSnowLabs/langtest/blob/master/LICENSE" alt="License">
          <img src="https://img.shields.io/badge/License-Apache%202.0-blue.svg" />
      </a>
      <a href="CODE_OF_CONDUCT.md">
          <img alt="Contributor Covenant" src="https://img.shields.io/badge/Contributor%20Covenant-v2.0%20adopted-ff69b4.svg">
      </a>

  ![Langtest Workflow](https://raw.githubusercontent.com/JohnSnowLabs/langtest/main/docs/assets/images/langtest/langtest_flow_graphic.jpeg)

  <p align="center">
    <a href="https://langtest.org/">Project's Website</a> •
    <a href="#key-features">Key Features</a> •
    <a href="#how-to-use">How To Use</a> •
    <a href="#benchmark-datasets">Benchmark Datasets</a> •
    <a href="#community-support">Community Support</a> •
    <a href="#contributing-to-langtest">Contributing</a> •
    <a href="#mission">Mission</a> •
    <a href="#license">License</a>
  </p>



  Take a look at our official page for user documentation and examples: [langtest.org](http://langtest.org/)



  - Generate and execute more than 60 distinct types of tests only with 1 line of code
  - Test all aspects of model quality: robustness, bias, representation, fairness and accuracy.​
  - Automatically augment training data based on test results (for select models)​
  - Support for popular NLP frameworks for NER, Translation and Text-Classifcation: Spark NLP, Hugging Face & Transformers.
  - Support for testing LLMS ( OpenAI, Cohere, AI21, Hugging Face Inference API and Azure-OpenAI LLMs) for question answering, toxicity, clinical-tests, legal-support, factuality, sycophancy, summarization and other popular tests.



  LangTest comes with different datasets to test your models, covering a wide range of use cases and evaluation scenarios. You can explore all the benchmark datasets available [here](https://langtest.org/docs/pages/benchmarks/benchmark), each meticulously curated to challenge and enhance your language models.
  Whether you're focused on Question-Answering, text summarization etc, LangTest ensures you have the right data to push your models to their limits and achieve peak performance in diverse linguistic tasks.



  ```python

  !pip install langtest[transformers]


  from langtest import Harness
  h = Harness(task='ner', model={"model":'dslim/bert-base-NER', "hub":'huggingface'})


  h.generate().run().report()
  ```

  > **Note**
  > For more extended examples of usage and documentation, head over to [langtest.org](https://www.langtest.org)



  You can check out the following LangTest articles:

  | Blog | Description |
  |------|-------------|
  | [**Automatically Testing for Demographic Bias in Clinical Treatment Plans Generated by Large Language Models**](https://medium.com/john-snow-labs/automatically-testing-for-demographic-bias-in-clinical-treatment-plans-generated-by-large-language-ffcf358b6092) | Helps in understanding and testing demographic bias in clinical treatment plans generated by LLM. |
  | [**LangTest: Unveiling & Fixing Biases with End-to-End NLP Pipelines**](https://www.johnsnowlabs.com/langtest-unveiling-fixing-biases-with-end-to-end-nlp-pipelines/) | The end-to-end language pipeline in LangTest empowers NLP practitioners to tackle biases in language models with a comprehensive, data-driven, and iterative approach. |
  | [**Beyond Accuracy: Robustness Testing of Named Entity Recognition Models with LangTest**](https://medium.com/john-snow-labs/beyond-accuracy-robustness-testing-of-named-entity-recognition-models-with-langtest-fb046ace7eb9) | While accuracy is undoubtedly crucial, robustness testing takes natural language processing (NLP) models evaluation to the next level by ensuring that models can perform reliably and consistently across a wide array of real-world conditions. |
  | [**Elevate Your NLP Models with Automated Data Augmentation for Enhanced Performance**](https://medium.com/john-snow-labs/elevate-your-nlp-models-with-automated-data-augmentation-for-enhanced-performance-71aa7812c699) | In this article, we discuss how automated data augmentation may supercharge your NLP models and improve their performance and how we do that using  LangTest. |
  | [**Mitigating Gender-Occupational Stereotypes in AI: Evaluating Models with the Wino Bias Test through Langtest Library**](https://www.johnsnowlabs.com/mitigating-gender-occupational-stereotypes-in-ai-evaluating-language-models-with-the-wino-bias-test-through-the-langtest-library/) | In this article, we discuss how we can test the "Wino Bias” using LangTest. It specifically refers to testing biases arising from gender-occupational stereotypes. |
  | [**Automating Responsible AI: Integrating Hugging Face and LangTest for More Robust Models**](https://www.johnsnowlabs.com/automating-responsible-ai-integrating-hugging-face-and-langtest-for-more-robust-models/) | In this article, we have explored the integration between Hugging Face, your go-to source for state-of-the-art NLP models and datasets, and LangTest, your NLP pipeline’s secret weapon for testing and optimization. |
  | [**Detecting and Evaluating Sycophancy Bias: An Analysis of LLM and AI Solutions**](https://medium.com/john-snow-labs/detecting-and-evaluating-sycophancy-bias-an-analysis-of-llm-and-ai-solutions-ce7c93acb5db) | In this blog post, we discuss the pervasive issue of sycophantic AI behavior and the challenges it presents in the world of artificial intelligence. We explore how language models sometimes prioritize agreement over authenticity, hindering meaningful and unbiased conversations. Furthermore, we unveil a potential game-changing solution to this problem, synthetic data, which promises to revolutionize the way AI companions engage in discussions, making them more reliable and accurate across various real-world conditions. |
  | [**Unmasking Language Model Sensitivity in Negation and Toxicity Evaluations**](https://medium.com/john-snow-labs/unmasking-language-model-sensitivity-in-negation-and-toxicity-evaluations-f835cdc9cabf) | In this blog post, we delve into Language Model Sensitivity, examining how models handle negations and toxicity in language. Through these tests, we gain insights into the models' adaptability and responsiveness, emphasizing the continuous need for improvement in NLP models. |
  | [**Unveiling Bias in Language Models: Gender, Race, Disability, and Socioeconomic Perspectives**](https://medium.com/john-snow-labs/unveiling-bias-in-language-models-gender-race-disability-and-socioeconomic-perspectives-af0206ed0feb) | In this blog post, we explore bias in Language Models, focusing on gender, race, disability, and socioeconomic factors. We assess this bias using the CrowS-Pairs dataset, designed to measure stereotypical biases. To address these biases, we discuss the importance of tools like LangTest in promoting fairness in NLP systems. |
  | [**Unmasking the Biases Within AI: How Gender, Ethnicity, Religion, and Economics Shape NLP and Beyond**](https://medium.com/@chakravarthik27/cf69c203f52c) | In this blog post, we tackle AI bias on how Gender, Ethnicity, Religion, and Economics Shape NLP systems. We discussed strategies for reducing bias and promoting fairness in AI systems. |
  | [**Evaluating Large Language Models on Gender-Occupational Stereotypes Using the Wino Bias Test**](https://medium.com/john-snow-labs/evaluating-large-language-models-on-gender-occupational-stereotypes-using-the-wino-bias-test-2a96619b4960) | In this blog post, we dive into testing the WinoBias dataset on LLMs, examining language models’ handling of gender and occupational roles, evaluation metrics, and the wider implications. Let’s explore the evaluation of language models with LangTest on the WinoBias dataset and confront the challenges of addressing bias in AI. |
  | [**Streamlining ML Workflows: Integrating MLFlow Tracking with LangTest for Enhanced Model Evaluations**](https://medium.com/john-snow-labs/streamlining-ml-workflows-integrating-mlflow-tracking-with-langtest-for-enhanced-model-evaluations-4ce9863a0ff1) | In this blog post, we dive into the growing need for transparent, systematic, and comprehensive tracking of models. Enter MLFlow and LangTest: two tools that, when combined, create a revolutionary approach to ML development. |
  | [**Testing the Question Answering Capabilities of Large Language Models**](https://medium.com/john-snow-labs/testing-the-question-answering-capabilities-of-large-language-models-1bc424d61740) | In this blog post, we dive into enhancing the QA evaluation capabilities using LangTest library. Explore about different evaluation methods that LangTest offers to address the complexities of evaluating Question Answering (QA) tasks. |
  | [**Evaluating Stereotype Bias with LangTest**](https://medium.com/john-snow-labs/evaluating-stereotype-bias-with-langtest-8286af8f0f22) | In this blog post, we are focusing on using the StereoSet dataset to assess bias related to gender, profession, and race.|
  | [**Testing the Robustness of LSTM-Based Sentiment Analysis Models**](https://medium.com/john-snow-labs/testing-the-robustness-of-lstm-based-sentiment-analysis-models-67ed84e42997) | Explore the robustness of custom models with LangTest Insights.|
  | [**LangTest Insights: A Deep Dive into LLM Robustness on OpenBookQA**](https://medium.com/john-snow-labs/langtest-insights-a-deep-dive-into-llm-robustness-on-openbookqa-ab0ddcbd2ab1) | Explore the robustness of Language Models (LLMs) on the OpenBookQA dataset with LangTest Insights.|
  | [**LangTest: A Secret Weapon for Improving the Robustness of Your Transformers Language Models**](https://medium.com/john-snow-labs/langtest-a-secret-weapon-for-improving-the-robustness-of-your-transformers-language-models-9693d64256cc) | Explore the robustness of Transformers Language Models with LangTest Insights.|
  | [**Mastering Model Evaluation: Introducing the Comprehensive Ranking & Leaderboard System in LangTest**](https://medium.com/john-snow-labs/mastering-model-evaluation-introducing-the-comprehensive-ranking-leaderboard-system-in-langtest-5242927754bb) | The Model Ranking & Leaderboard system by John Snow Labs' LangTest offers a systematic approach to evaluating AI models with comprehensive ranking, historical comparisons, and dataset-specific insights, empowering researchers and data scientists to make data-driven decisions on model performance. |
  | [**Evaluating Long-Form Responses with Prometheus-Eval and Langtest**](https://medium.com/john-snow-labs/evaluating-long-form-responses-with-prometheus-eval-and-langtest-a8279355362e) | Prometheus-Eval and LangTest unite to offer an open-source, reliable, and cost-effective solution for evaluating long-form responses, combining Prometheus's GPT-4-level performance and LangTest's robust testing framework to provide detailed, interpretable feedback and high accuracy in assessments. |
  | [**Ensuring Precision of LLMs in Medical Domain: The Challenge of Drug Name Swapping**](https://medium.com/john-snow-labs/ensuring-precision-of-llms-in-medical-domain-the-challenge-of-drug-name-swapping-d7f4c83d55fd) | Accurate drug name identification is crucial for patient safety. Testing GPT-4o with LangTest's **_drug_generic_to_brand_** conversion test revealed potential errors in predicting drug names when brand names are replaced by ingredients, highlighting the need for ongoing refinement and rigorous testing to ensure medical LLM accuracy and reliability. |







  > **Note**
  > To check all blogs, head over to [Blogs](https://www.johnsnowlabs.com/responsible-ai-blog/)



  - [Slack](https://www.johnsnowlabs.com/slack-redirect/) For live discussion with the LangTest community, join the `#langtest` channel
  - [GitHub](https://github.com/JohnSnowLabs/langtest/tree/main) For bug reports, feature requests, and contributions
  - [Discussions](https://github.com/JohnSnowLabs/langtest/discussions) To engage with other community members, share ideas, and show off how you use LangTest!



  While there is a lot of talk about the need to train AI models that are safe, robust, and fair - few tools have been made available to data scientists to meet these goals. As a result, the front line of NLP models in production systems reflects a sorry state of affairs.

  We propose here an early stage open-source community project that aims to fill this gap, and would love for you to join us on this mission. We aim to build on the foundation laid by previous research such as [Ribeiro et al. (2020)](https://arxiv.org/abs/2005.04118), [Song et al. (2020)](https://arxiv.org/abs/2004.00053), [Parrish et al. (2021)](https://arxiv.org/abs/2110.08193), [van Aken et al. (2021)](https://arxiv.org/abs/2111.15512) and many others.

  [John Snow Labs](www.johnsnowlabs.com) has a full development team allocated to the project and is committed to improving the library for years, as we do with other open-source libraries. Expect frequent releases with new test types, tasks, languages, and platforms to be added regularly. We look forward to working together to make safe, reliable, and responsible NLP an everyday reality.


  > **Note**
  > For usage and documentation, head over to [langtest.org](https://langtest.org/docs/pages/docs/data#question-answering)




  We welcome all sorts of contributions:

  - [Ideas](https://github.com/JohnSnowLabs/langtest/discussions/categories/ideas)
  - [Discussions](https://github.com/JohnSnowLabs/langtest/discussions)
  - [Feedback](https://github.com/JohnSnowLabs/langtest/discussions/categories/general)
  - [Documentation](https://www.example.com/documentation)
  - [Bug reports](https://www.example.com/bug-reports)

  A detailed overview of contributing can be found in the **[contributing guide](https://github.com/JohnSnowLabs/langtest/blob/main/CONTRIBUTING.md)**.

  If you are looking to start working with the LangTest codebase, navigate to the GitHub ["issues"](https://github.com/JohnSnowLabs/langtest/issues) tab and start looking through interesting issues. There are a number of issues listed under where you could start out.
  Or maybe through using LangTest you have an idea of your own or are looking for something in the documentation and thinking ‘This can be improved’...you can do something about it!

  Feel free to ask questions on the [Q&A](https://github.com/JohnSnowLabs/langtest/discussions/categories/q-a) discussions.

  As contributors and maintainers to this project, you are expected to abide by LangTest's code of conduct. More information can be found at: [Contributor Code of Conduct](https://github.com/JohnSnowLabs/langtest/blob/release/1.8.0/CODE_OF_CONDUCT.md)




  We have published a [paper](https://www.sciencedirect.com/science/article/pii/S2665963824000071) that you can cite for
  the LangTest library:

  ```bibtex
  @article{nazir2024langtest,
    title={LangTest: A comprehensive evaluation library for custom LLM and NLP models},
    author={Arshaan Nazir, Thadaka Kalyan Chakravarthy, David Amore Cecchini, Rakshit Khajuria, Prikshit Sharma, Ali Tarik Mirik, Veysel Kocaman and David Talby},
    journal={Software Impacts},
    pages={100619},
    year={2024},
    publisher={Elsevier}
  }
  ```




  We would like to acknowledge all contributors of this open-source community project.

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



  LangTest is released under the [Apache License 2.0](https://github.com/JohnSnowLabs/langtest/blob/main/LICENSE), which guarantees commercial use, modification, distribution, patent use, private use and sets limitations on trademark use, liability and warranty.


pkgId: d396458d59b566ee981fdf1858dd3d6c8cc321e72f9cc0c573dcfddfd352e368
name: python-languageFreeAcq-help
arch: noarch
version: 0.0.6
epoch: 0
release: 1
summary: Development documents and examples for languageFreeAcq
url: https://github.com/Hareski/language-free-acq
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-languageFreeAcq-0.0.6-1.src.rpm
location_href: Packages/python-languageFreeAcq-help-0.0.6-1.noarch.rpm
checksum_type: sha256
description:
  To reproduce the experiments of the paper, you can use the script `main.py all` which will
  run the program on all the datasets of the paper. You can also run the program on a specific
  dataset by using the command `main.py dataset_name`.
  The results appear in the console with the following format:
  ```
  FILE_TRAIN: data/_.csv  NB_EXAMPLES: _  FILE_TEST: data/_.csv  KR: (_, _) ACCURACY: _ RELATION: _  NETWORK: _ TIME: _
  ```
  where accuracy is the accuracy of the network on the test set, relation is a boolean indicating
  if the network obtained has the same relation as the one used to generate the dataset, network
  indicates if the network is strictly the same as the one used to generate the dataset.


pkgId: bad98ddfed4a93dd8084c2643194a37ec6babc6cdb79a7528ec51190e943af0b
name: python-lanscape-help
arch: noarch
version: 1.2.4
epoch: 0
release: 1
summary: Development documents and examples for lanscape
url: https://github.com/mdennis281/py-lanscape
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-lanscape-1.2.4-1.src.rpm
location_href: Packages/python-lanscape-help-1.2.4-1.noarch.rpm
checksum_type: sha256
description:
  A python based local network scanner.

  ![screenshot](https://github.com/mdennis281/py-lanscape/raw/main/src/lanscape/static/img/readme1.png)


  ```sh
  pip install lanscape
  python -m lanscape
  ```


   - `--port <port number>` port of the flask app (default: 5001)
   - `--nogui` run in web mode (default: false)
   - `--reloader` essentially flask debug mode- good for local development (default: false)
   - `--logfile` save log output to lanscape.log
   - `--loglevel <level>` set the logger's log level (default: INFO)
   - `--headless` similar to nogui but doesnt try to open a browser (default: false)


  Examples:
  ```shell
  python -m lanscape --reloader
  python -m lanscape --nogui --port 5002
  python -m lanscape --logfile --loglevel DEBUG
  ```




  The program does an ARP lookup to determine the MAC address. This lookup
  can sometimes require admin-level permissions to retrieve accurate results.
  *Try elevating your shell before execution.*


  This is a missing dependency related to the ARP lookup. This is handled in the code, but you would get marginally faster/better results with this installed: [npcap download](https://npcap.com/#download)



  Linux and QT (GUI package) dont seem to play well with each other very well. If you really want the gui (`python -m lanscape --nogui` is almost as good) I had success on ubuntu desktop by running these:
  ```sh
  sudo apt install libcairo2-dev libxt-dev libgirepository1.0-dev
  pip install pycairo PyGObject qtpy PyQt5 PyQtWebEngine
  ```



  Feel free to submit a github issue detailing your experience.


pkgId: 5c2c8e8386f246416800ab63155370e90867e7e2d2d6525289f87355c10f16a6
name: python-lapy-help
arch: noarch
version: 1.1.2
epoch: 0
release: 1
summary: Development documents and examples for lapy
url: https://pypi.org/project/lapy/
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-lapy-1.1.2-1.src.rpm
location_href: Packages/python-lapy-help-1.1.2-1.noarch.rpm
checksum_type: sha256
description:
  [![PyPI version](https://badge.fury.io/py/lapy.svg)](https://pypi.org/project/lapy/)


  LaPy is an open-source Python package for differential geometry on triangle
  and tetrahedra meshes. It includes an FEM solver to estimate the Laplace,
  Poisson or Heat equations. Further functionality includes the computations
  of gradients, divergence, mean-curvature flow, conformal mappings,
  geodesics, ShapeDNA (Laplace spectra), and IO and plotting methods.

  LaPy is written purely in Python 3 without sacrificing speed as almost all
  loops are vectorized, drawing upon efficient and sparse mesh data structures.



  - **TriaMesh**: a class for triangle meshes offering various operations, such as
    fixing orientation, smoothing, curvature, boundary, quality, normals, and
    various efficient mesh datastructures (edges, adjacency matrices). IO from
    OFF, VTK and other formats.
  - **TetMesh**: a class for tetrahedral meshes (orientation, boundary, IO ...)
  - **Solver**: a class for linear FEM computation (Laplace stiffness and mass
    matrix, fast and sparse eigenvalue solver, anisotropic Laplace, Poisson)
  - **io**: module for IO of vertex functions and eigenvector files
  - **diffgeo**: module for gradients, divergence, mean curvature flow, etc.
  - **heat**: module for heat kernel and diffusion
  - **shapedna**: module for the ShapeDNA descriptor of surfaces and solids
  - **plot**: module for interactive visualizations (wrapping plotly)



  The LaPy package is a comprehensive collection of scripts, so we refer to the
  'help' function and docstring of each module / function / class for usage info.
  For example:

  ```
  import lapy as lp
  help(lp.TriaMesh)
  help(lp.Solver)
  ```

  In the `examples` subdirectory, we provide several Jupyter notebooks that
  illustrate prototypical use cases of the toolbox.



  Use the following code to install the latest release of LaPy into your local
  Python package directory:

  `python3 -m pip install lapy`

  Use the following code to install the dev package in editable mode to a location of
  your choice:

  `python3 -m pip install --user --src /my/preferred/location --editable git+https://github.com/Deep-MI/Lapy.git#egg=lapy`

  Several functions, e.g. the Solver, require a sparse matrix decomposition, for which either the LU decomposition (from scipy sparse, default) or the faster Cholesky decomposition (from scikit-sparse cholmod, recommended) can be used. If the parameter flag use_cholmod is True, the code will try to import cholmod from the scikit-sparse package. If this fails, an error will be thrown. If you would like to use cholmod, you need to install scikit-sparse separately, as pip currently cannot install it (conda can). scikit-sparse requires numpy and scipy to be installed separately beforehand.



  The API Documentation can be found at https://deep-mi.org/LaPy .



  If you use this software for a publication please cite both these papers:

  **[1]** Laplace-Beltrami spectra as 'Shape-DNA' of surfaces and solids. Reuter M, Wolter F-E, Peinecke N. Computer-Aided Design. 2006;38(4):342-366. http://dx.doi.org/10.1016/j.cad.2005.10.011

  **[2]** BrainPrint: a discriminative characterization of brain morphology. Wachinger C, Golland P, Kremen W, Fischl B, Reuter M. Neuroimage. 2015;109:232-48. http://dx.doi.org/10.1016/j.neuroimage.2015.01.032 http://www.ncbi.nlm.nih.gov/pubmed/25613439

  Shape-DNA [1] introduces the FEM methods and the Laplace spectra for shape analysis, while BrainPrint [2] focusses on medical applications.

  For Geodesics please also cite:

  [3] Crane K, Weischedel C, Wardetzky M. Geodesics in heat: A new approach to computing distance based on heat flow. ACM Transactions on Graphics. https://doi.org/10.1145/2516971.2516977

  For non-singular mean curvature flow please cite:

  [4] Kazhdan M, Solomon J, Ben-Chen M. 2012. Can Mean-Curvature Flow be Modified to be Non-singular? Comput. Graph. Forum 31, 5, 1745–1754.
  https://doi.org/10.1111/j.1467-8659.2012.03179.x

  For conformal mapping please cite:

  [5] Choi PT, Lam KC, Lui LM. FLASH: Fast Landmark Aligned Spherical Harmonic Parameterization for Genus-0 Closed Brain Surfaces. SIAM Journal on Imaging Sciences, vol. 8, no. 1, pp. 67-94, 2015. https://doi.org/10.1137/130950008

  We invite you to check out our lab webpage at https://deep-mi.org

rpm_license:
  MIT License  Copyright (c) 2020 Deep Medical Imaging Lab (PI Reuter)  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: 30388f8065bd3e7f6b3a92588b85d106bd7bafa849c5ae59c5acd1b573b55acb
name: python-larch6-help
arch: noarch
version: 6.0.36
epoch: 0
release: 1
summary: Development documents and examples for larch6
url: https://pypi.org/project/larch6/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-larch6-6.0.36-1.src.rpm
location_href: Packages/python-larch6-help-6.0.36-1.noarch.rpm
checksum_type: sha256
description:
  This repository contains the under-development next generation of the Larch
  package, for estimating and applying discrete choice models. Version 6
  is a substantial rewrite of the package, changing to a platform that allows
  swapping out the underlying computational engine, so that the same model
  can run in numba or JAX.

  :warning: **This is a work in progress.**  A lot of things are working, but not
  everything.  The interface is quite similar to Larch v5 and existing users will
  likely find it familiar. If you want to try it out, please do, and feel free to
  open issues in the issue tracker.  But, please don't expect it to work perfectly
  yet, especially for more advanced models.




  You can install Larch v6 with pip:

  ```shell
  python -m pip install larch6
  ```

  This will install the package and all of its required dependencies.  Note that
  while the installation name is "larch6", the package import name is "larch", and
  you cannot install both Larch v5 and Larch v6 in the same environment.

  Or you can install it using `conda` to create a new environment:

  ```shell
  conda env create -p ARBORETUM -f https://raw.githubusercontent.com/driftlesslabs/larch/main/envs/arboretum.yml
  conda activate ./ARBORETUM
  ```




  You can install larch for development by running the following script:

  ```shell
  curl -LsSf https://driftless.xyz/larch-dev.sh | bash -s -- -d ~/Git/larix
  ```

  You can change the install directory by changing the `-d` argument.  The script
  will clone the larch repository and install it in the specified directory.  It
  will also install the required dependencies and create a new uv virtual
  environment for development.


pkgId: 17de2f35096453dece12e70b1210451da1c60c97ce2ad01ee058544dfd1df539
name: python-large-image-converter-help
arch: noarch
version: 1.30.5
epoch: 0
release: 1
summary: Development documents and examples for large-image-converter
url: https://pypi.org/project/large-image-converter/
rpm_license: Apache Software License 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-large-image-converter-1.30.5-1.src.rpm
location_href: Packages/python-large-image-converter-help-1.30.5-1.noarch.rpm
checksum_type: sha256
description:
  To install via pip with custom-built wheels:
  ``pip install large-image-converter[sources] --find-links https://girder.github.io/large_image_wheels``
  The ``[sources]`` extra requirement is optional.  When specified, all of the default large-image tile sources are installed for additional metadata extraction and format support.


pkgId: 4c32aaa56d525ea36175c26260e98ca8aeeb9c87b7497cfdce8611fbccd2d416
name: python-large-image-help
arch: noarch
version: 1.30.5
epoch: 0
release: 1
summary: Development documents and examples for large-image
url: https://github.com/girder/large_image
rpm_license: Apache Software License 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-large-image-1.30.5-1.src.rpm
location_href: Packages/python-large-image-help-1.30.5-1.noarch.rpm
checksum_type: sha256
description:
  |build-status| |codecov-io| |license-badge| |doi-badge| |pypi-badge|
  *Python modules to work with large, multiresolution images.*
  Large Image is developed and maintained by the Data & Analytics group at `Kitware, Inc. <https://kitware.com>`_ for processing large geospatial and medical images. This provides the backbone for several of our image analysis platforms including `Resonant GeoData <https://github.com/ResonantGeoData/ResonantGeoData>`_, `HistomicsUI <https://github.com/DigitalSlideArchive/HistomicsUI>`_, and `the Digital Slide Archive <https://digitalslidearchive.github.io/digital_slide_archive/>`_.


pkgId: 7dd37e63e4c70ba39c451f149414fb6fcaf8f8163f2ec54d1871fe52a2dff5e0
name: python-large-image-source-multi-help
arch: noarch
version: 1.30.5
epoch: 0
release: 1
summary: Development documents and examples for large-image-source-multi
url: https://github.com/girder/large_image
rpm_license: Apache Software License 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-large-image-source-multi-1.30.5-1.src.rpm
location_href: Packages/python-large-image-source-multi-help-1.30.5-1.noarch.rpm
checksum_type: sha256
description:
  A tilesource for large_image to composite other tile sources

  See the large-image package for more details.


pkgId: 74be7d7c0ec578ee87ac6c4277ad0dc6980e04c1414757b45851a863c08ffd63
name: python-large-image-tasks-help
arch: noarch
version: 1.30.5
epoch: 0
release: 1
summary: Development documents and examples for large-image-tasks
url: https://pypi.org/project/large-image-tasks/
rpm_license: Apache Software License 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-large-image-tasks-1.30.5-1.src.rpm
location_href: Packages/python-large-image-tasks-help-1.30.5-1.noarch.rpm
checksum_type: sha256
description:
  *****************
  Large Image Tasks
  *****************

  These are Girder Worker tasks used by Large Image.

  The conversion task is typically accessed by selecting the Make Large Image
  icon on the items detail page in Girder, or by accessing the ``POST``
  ``item/{itemId}/tiles`` endpoint.  Using the endpoint allows specifying more
  options and converting an inefficient file into a preferred format.  See the
  ``large_image_converter`` for more details on the various options.

  See the large-image package for more details.


pkgId: 197d50fdeb4f1ed6d1d739e23d1a13c7b71ef4d08cbb8c9053ded01a257b1150
name: python-lasagna-ai-help
arch: noarch
version: 0.10.2
epoch: 0
release: 1
summary: Development documents and examples for lasagna-ai
url: https://pypi.org/project/lasagna-ai/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-lasagna-ai-0.10.2-1.src.rpm
location_href: Packages/python-lasagna-ai-help-0.10.2-1.noarch.rpm
checksum_type: sha256
description:
  - [Installation](#installation)
  - [Used By](#used-by)
  - [Quickstart](#quickstart)
  - [Debug Logging](#debug-logging)
  - [Special Thanks](#special-thanks)
  - [License](#license)

  ```console
  pip install -U lasagna-ai[openai,anthropic]
  ```
  If you want to easily run all the [./examples](./examples), then you can
  install the extra dependencies used by those examples:
  ```console
  pip install -U lasagna-ai[openai,anthropic,example-deps]
  ```

  Lasagna is used in production by:
  [![AutoAuto](https://raw.githubusercontent.com/Rhobota/lasagna-ai/main/logos/autoauto.png)](https://www.autoauto.ai/)

  Here is the _most simple_ agent (it doesn't add *anything* to the underlying model).
  More complex agents would add tools and/or use layers of agents, but not this one!
  Anyway, run it in your terminal and you can chat interactively with the model. 🤩
  (taken from [./examples/quickstart.py](./examples/quickstart.py))
  ```python
  from lasagna import (     # <-- pip install -U lasagna-ai[openai,anthropic]
      known_models,
      build_simple_agent,
  )
  from lasagna.tui import (
      tui_input_loop,
  )
  from typing import List, Callable
  import asyncio
  from dotenv import load_dotenv; load_dotenv()
  MODEL_BINDER = known_models.BIND_OPENAI_gpt_4o_mini()
  async def main() -> None:
      system_prompt = "You are grumpy."
      tools: List[Callable] = []
      my_agent = build_simple_agent(name = 'agent', tools = tools)
      my_bound_agent = MODEL_BINDER(my_agent)
      await tui_input_loop(my_bound_agent, system_prompt)
  if __name__ == '__main__':
      asyncio.run(main())
  ```
  **Want to add your first tool?** LLMs can't natively do arithmetic
  (beyond simple arithmetic with small numbers), so let's give our
  model a tool for doing arithmetic! 😎
  (full example at [./examples/quickstart_with_math_tool.py](./examples/quickstart_with_math_tool.py))
  ```python
  import sympy as sp
  def evaluate_math_expression(expression: str) -> float:
      """
      This tool evaluates a math expression and returns the result.
      Pass math expression as a string, for example:
       - "3 * 6 + 1"
       - "cos(2 * pi / 3) + log(8)"
       - "(4.5/2) + (6.3/1.2)"
       - ... etc
      """
      expr = sp.sympify(expression)
      result = float(expr.evalf())
      return result
      tools: List[Callable] = [
          evaluate_math_expression,
      ]
      my_agent = build_simple_agent(name = 'agent', tools = tools)
  ```
  **Simple RAG:** Everyone's favorite tool: _Retrieval Augmented Generation_ (RAG). Let's GO! 📚💨
  See: [./examples/demo_rag.py](./examples/demo_rag.py)

  This library logs using Python's builtin `logging` module. It logs mostly to `INFO`, so here's a snippet of code you can put in _your_ app to see those traces:
  ```python
  import logging
  logging.basicConfig(
      level=logging.INFO,
      format='s - s - s - s',
  )

  ```

  Special thanks to those who inspired this library:
  - Numa Dhamani (buy her book: [Introduction to Generative AI](https://a.co/d/03dHnRmX))
  - Dave DeCaprio's [voice-stream library](https://github.com/DaveDeCaprio/voice-stream)

  `lasagna-ai` is distributed under the terms of the [MIT](https://spdx.org/licenses/MIT.html) license.

  Layered Agents with toolS And aGeNts and Ai


pkgId: bbe0846f4322fd6c292ba58f2110699e8ef080f42dcafd8f55ac51a006d959d6
name: python-lasvsim-openapi-help
arch: noarch
version: 0.1.8
epoch: 0
release: 1
summary: Development documents and examples for lasvsim-openapi
url: https://github.com/rl-lasvsim/openapi-sdk-python
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-lasvsim-openapi-0.1.8-1.src.rpm
location_href: Packages/python-lasvsim-openapi-help-0.1.8-1.noarch.rpm
checksum_type: sha256
description:
  千行仿真平台的Python SDK。提供了一种简单直观的方式来控制和获取自动驾驶场景的仿真。



  您可以直接从PyPI安装该软件包：

  ```bash
  pip install lasvsim-openapi
  ```



  以下是SDK使用的简单示例：

  ```python
  from lasvsim.client import Client
  from lasvsim.http_client import HttpConfig
  from lasvsim.simulator import SimulatorConfig
  from lasvsim.request_model import Point


  client = Client(
      HttpConfig(
          token="your_token_here",
          endpoint="your_endpoint_here"
      )
  )


  res = client.train_task.get_scene_id_list(task_id)
  print(f"可用场景: {res}")


  simulator = client.init_simulator_from_config(
      SimulatorConfig(
          scenario_id=res.scene_id_list[0],
          scenario_version=res.scene_version_list[0]
      )
  )


  for i in range(10):
      step_res = simulator.step()
      print(f"第 {i} 步结果: {step_res}")
      
      vehicle_ids = simulator.get_vehicle_id_list()
      print(f"车辆ID列表: {vehicle_ids}")

      
      simulator.set_vehicle_control_info(
          vehicle_id="test_vehicle_1",
          ste_wheel=1.2,
          lon_acc=1.1
      )

      
      simulator.set_vehicle_position(
          vehicle_id="test_vehicle_1",
          point=Point(x=-8.75, y=-537.0316, z=0)
      )


  simulator.stop()
  ```






  - `init_from_config(sim_config)`: 从配置初始化仿真器
  - `init_from_sim(simulation_id, addr)`: 从现有仿真初始化仿真器
  - `step()`: 仿真前进一步
  - `stop()`: 停止仿真
  - `reset(reset_traffic_flow)`: 重置仿真器到初始状态，可选择是否重置交通流


  - `get_vehicle_id_list()`: 获取所有车辆ID
  - `get_test_vehicle_id_list()`: 获取测试车辆ID
  - `get_vehicle_base_info(id_list)`: 获取车辆基本信息
  - `get_vehicle_position(id_list)`: 获取车辆位置
  - `get_vehicle_moving_info(id_list)`: 获取车辆运动信息
  - `get_vehicle_control_info(id_list)`: 获取车辆控制参数
  - `get_vehicle_perception_info(vehicle_id)`: 获取车辆感知信息
  - `get_vehicle_reference_lines(vehicle_id)`: 获取可用参考线
  - `get_vehicle_planning_info(vehicle_id)`: 获取车辆规划信息
  - `get_vehicle_navigation_info(vehicle_id)`: 获取车辆导航信息
  - `get_vehicle_collision_status(vehicle_id)`: 检查车辆碰撞状态
  - `get_vehicle_target_speed(vehicle_id)`: 获取车辆目标速度
  - `set_vehicle_position(vehicle_id, point, phi)`: 设置车辆位置和航向角
  - `set_vehicle_control_info(vehicle_id, ste_wheel, lon_acc)`: 设置车辆控制参数
  - `set_vehicle_planning_info(vehicle_id, planning_path)`: 设置车辆规划路径
  - `set_vehicle_moving_info(vehicle_id, u, v, w, u_acc, v_acc, w_acc)`: 设置车辆运动参数
  - `set_vehicle_base_info(vehicle_id, base_info)`: 设置车辆基本信息
  - `set_vehicle_link_nav(vehicle_id, link_nav)`: 设置车辆链接导航信息
  - `set_vehicle_destination(vehicle_id, destination)`: 设置车辆目标点


  - `get_current_stage(junction_id)`: 获取当前交通信号灯阶段
  - `get_movement_signal(movement_id)`: 获取转向信号灯颜色
  - `get_signal_plan(junction_id)`: 获取交通信号灯配时方案
  - `get_movement_list(junction_id)`: 获取路口转向列表


  - `get_ped_id_list()`: 获取所有行人ID
  - `get_ped_base_info(ped_id_list)`: 获取行人基本信息
  - `set_ped_position(ped_id, point, phi)`: 设置行人位置和航向角


  - `get_nmv_id_list()`: 获取所有非机动车ID
  - `get_nmv_base_info(nmv_id_list)`: 获取非机动车基本信息
  - `set_nmv_position(nmv_id, point, phi)`: 设置非机动车位置和航向角


  - `get_scene_id_list(task_id)`: 获取训练任务可用场景列表


  - `get_map(asset_id, asset_version)`: 获取特定资源的地图数据



  - Python >= 3.0
  - requests >= 2.25.0





  如需报告错误或请求新功能，请使用[GitHub Issues](https://github.com/risenlighten-qianxing/openapi-sdk-python/issues)页面。


pkgId: 0b61350f9a2e4010cc553033843478ed85da148e71fa77aa78825a477e00d945
name: python-latch-help
arch: noarch
version: 2.55.0
epoch: 0
release: 1
summary: Development documents and examples for latch
url: https://latch.bio
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-latch-2.55.0-1.src.rpm
location_href: Packages/python-latch-help-2.55.0-1.noarch.rpm
checksum_type: sha256
description:
  The SDK is distributed on pip. Install in a fresh virtual environment for best
  behavior.
  [Virtualenvwrapper](https://virtualenvwrapper.readthedocs.io/en/latest/) is recommended.
  ```
  python3 -m pip install latch
  ```

rpm_license:
  Copyright 2024 LatchBio  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: d91d22e29b31353b35559927cf3a3845d719ea4bde82bb20e967f3caf276714b
name: python-latex-runner-help
arch: noarch
version: 1.1.0
epoch: 0
release: 1
summary: Development documents and examples for latex-runner
url: https://pypi.org/project/latex-runner/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-latex-runner-1.1.0-1.src.rpm
location_href: Packages/python-latex-runner-help-1.1.0-1.noarch.rpm
checksum_type: sha256
description:
  A wrapper around LaTeX to build files which

  - reads [magic comments](#magic-comments) to determine the TeX program and options to be used.
  - filters the output to show only errors, warnings, over-/underfull boxes, tracing commands and prompts.
  - runs [biber](https://ctan.org/pkg/biber) and [makeglossaries](https://ctan.org/pkg/glossaries) if necessary.
  - reruns LaTeX up to -n times if necessary.




  This program supports the following [magic comments](https://texstudio-org.github.io/advanced.html#advanced-header-usage):

  ```tex
  % !TeX root = ../main.tex
  ```

  Run the TeX program with the given file instead.
  This is useful if you have split up your document into multiple files, the current file is included in the main file with [`\input` or `\include`](https://tex.stackexchange.com/questions/246/when-should-i-use-input-vs-include) and you have told vim to build the currently opened file with this program.


  ```tex
  % !TeX program = pdflatex
  ```

  The program used to build the tex file.

  For security reasons programs *not* listed in the `allowed-tex-programs` setting are *not* executed.
  By default the allowed programs are `pdflatex`, `xelatex`, `lualatex`, `latex`, `tex` and `pdftex`.
  You can change these with `latex-runner --edit-config`.


  ```tex
  % !TeX option = -shell-escape
  ```

  A command line option which should be passed to the TeX program.
  You can repeat this comment to enable several command line options.
  I have introduced this type of comment because at the time of this writing `% !TeX program = pdflatex -shell-escape` breaks compilation in [TeX studio](https://www.texstudio.org/).

  For security reasons options *not* listed in the `allowed-tex-options` setting are *not* passed to the TeX program.
  By default the allowed options are `--shell-escape`, `--8bit`, `--interaction=batchmode`, `--interaction=nonstopmode`, `--interaction=scrollmode` and `--interaction=errorstopmode`.
  You can change these with `latex-runner --edit-config`.


  ```tex
  % !TeX jobname = content:*.tex
  ```

  The jobname to pass to LaTeX.
  If this is a [glob pattern](https://docs.python.org/3/library/glob.html) matching several files the LaTeX file will be built several times, once for each jobname.
  The file extension is stripped from the jobname.
  Optionally a path may be specified before, separated by a colon, specifying the directory in which to look for the glob pattern.
  You can use this magic comment multiple times in order to specify multiple glob patterns or literal jobnames.
  (This is not a standard comment supported by other programs as well, I have defined it.)

  For example, let's assume there is a directory called `content` next to the main file.
  This directory contains four files `a.tex`, `b.tex`, `c.tex` and `c.log`.

  - Then `% !TeX jobname = content:*.tex` causes the main file to be built three times with the jobnames `a`, `b` and `c`, generating three pdf files `a.pdf`, `b.pdf` and `c.pdf`.
  - Then `% !TeX jobname = content/*.tex` causes the main file to be built three times with the jobnames `content/a`, `content/b` and `content/c`, generating three pdf files `content/a.pdf`, `content/b.pdf` and `content/c.pdf`.

  You can access the jobname in TeX with the macro `\jobname`.
  For example:

  - `\input{content/\jobname}`
  - or

    ```tex
    \def\comparejobname{a}
    \edef\expandedjobname{\jobname}
    \ifx\comparejobname\expandedjobname
        This is job a.
    \else
        This is not job a.
    \fi
    ```




  You can change settings with

  ```bash
  latex-runner --edit-config
  ```

  You can get help how to configure this program with

  ```bash
  latex-runner --help-config
  ```




  You can install this program via the python package manager [pipx](https://pipx.pypa.io/latest/):

  ```bash
  pipx install latex-runner
  ```




  Copy the following into `~/.vim/after/ftplugin/tex.vim`.
  This will allow you to run LaTeX once with F5, build the pdf completely with Control+F5 and open the pdf at the cursor position in [zathura](https://pwmt.org/projects/zathura/) with Shift+F5 or F6. You can open the log file with F7.

  ```vim
  " build pdf
  nnoremap <buffer> <F5> :exec "!latex-runner -n1 -synctex=1 " .. expand('%:p:S')<cr>
  nnoremap <buffer> <C-F5> :exec "!latex-runner -n5 -synctex=1 " .. expand('%:p:S')<cr>

  " open pdf
  nnoremap <buffer> <S-F5> :exec "silent! !zathura --synctex-forward " .. line('.') .. ":" .. col('.') .. ":" .. expand('%:p') .. " " .. trim(system('latex-runner --get-pdf ' .. expand('%:p:S') .. " 2>/dev/null")) .. " >/dev/null 2>/dev/null &"<cr>:redraw!<cr>
  nnoremap <buffer> <F6> :exec "silent! !zathura --synctex-forward " .. line('.') .. ":" .. col('.') .. ":" .. expand('%:p') .. " " .. trim(system('latex-runner --get-pdf ' .. expand('%:p:S') .. " 2>/dev/null")) .. " >/dev/null 2>/dev/null &"<cr>:redraw!<cr>

  " open log file, return with :bp
  nnoremap <buffer> <F7> :exec "edit " .. trim(system('latex-runner --get-log ' .. expand('%:p:S') .. " 2>/dev/null"))<cr>

  " texdoc, to be used when cursor is in argument of \usepackage
  nnoremap <buffer> K :silent exec '!texdoc <c-r>=expand("<cfile>")<cr> >/dev/null 2>&1 &' \| redraw!<cr>

  " inserting magic comments
  command InsertMagicCommentXelatex     :0put ='% !TeX program = xelatex'
  command InsertMagicCommentPdflatex    :0put ='% !TeX program = pdflatex'
  command InsertMagicCommentShellEscape :1put ='% !TeX option = -shell-escape'
  command InsertMagicCommentRoot        :0put ='% !TeX root = ../main.tex'
  ```



  I am using [mypy](https://www.mypy-lang.org/) for static type checking and [pytest](https://docs.pytest.org/en/latest/) for dynamic testing.
  [tox](https://tox.wiki/en/latest/) creates a virtual environment and installs all dependencies for you.
  You can install tox with [pipx](https://pypa.github.io/pipx/) (`pipx install tox`).

  ```bash
  $ tox
  ```

  In order to make tox work without an internet connection install [devpi](https://devpi.net/docs/devpi/devpi/stable/%2Bd/index.html):

  ```bash
  $ pipx install devpi-server
  $ devpi-init
  $ devpi-gen-config
  $ su



  ```

  and add the following line to your bashrc:

  ```bash
  export PIP_INDEX_URL=http://localhost:3141/root/pypi/+simple/
  ```


pkgId: acb1fb1230356c307beaac4230c6e244b5ad08870b81c9f6b3268095d89f37f3
name: python-latexify-py-help
arch: noarch
version: 0.4.4
epoch: 0
release: 1
summary: Development documents and examples for latexify-py
url: https://github.com/google/latexify_py
rpm_license: Apache Software License 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-latexify-py-0.4.4-1.src.rpm
location_href: Packages/python-latexify-py-help-0.4.4-1.noarch.rpm
checksum_type: sha256
description:
  [![Python](https://img.shields.io/pypi/pyversions/latexify-py.svg)](https://pypi.org/project/latexify-py/)
  [![PyPI Latest Release](https://img.shields.io/pypi/v/latexify-py.svg)](https://pypi.org/project/latexify-py/)
  [![License](https://img.shields.io/pypi/l/latexify-py.svg)](https://github.com/google/latexify_py/blob/main/LICENSE)
  [![Downloads](https://pepy.tech/badge/latexify-py/month)](https://pepy.tech/project/latexify-py)
  [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
  [![Imports: isort](https://img.shields.io/badge/%20imports-isort-%231674b1?style=flat&labelColor=ef8336)](https://pycqa.github.io/isort/)

  `latexify` is a Python package to compile a fragment of Python source code to a
  corresponding $\LaTeX$ expression:

  ![Example of latexify usage](https://raw.githubusercontent.com/google/latexify_py/main/example.jpg)

  `latexify` provides the following functionalities:

  * Libraries to compile Python source code or AST to $\LaTeX$.
  * IPython classes to pretty-print compiled functions.



  1. *Which Python versions are supported?*

     Syntaxes on **Pythons 3.9 to 3.13** are officially supported, or will be supported.

  2. *Which technique is used?*

     `latexify` is implemented as a rule-based system on the official `ast` package.

  3. *Are "AI" techniques adopted?*

     `latexify` is based on traditional parsing techniques.
     If the "AI" meant some techniques around machine learning, the answer is no.



  See the
  [example notebook](https://github.com/google/latexify_py/blob/main/examples/latexify_examples.ipynb),
  which provides several
  use-cases of this library.

  You can also try the above notebook on
  [Google Colaboratory](https://colab.research.google.com/github/google/latexify_py/blob/main/examples/latexify_examples.ipynb).

  See also the official
  [documentation](https://github.com/google/latexify_py/blob/main/docs/index.md)
  for more details.



  To contribute to this project, please refer
  [CONTRIBUTING.md](https://github.com/google/latexify_py/blob/develop/CONTRIBUTING.md).



  This software is currently hosted on <https://github.com/google>, but not officially
  supported by Google.

  If you have any issues and/or questions about this software, please visit the
  [issue tracker](https://github.com/google/latexify_py/issues)
  or contact the [main maintainer](https://github.com/odashi).



  This software adopts the
  [Apache License 2.0](https://github.com/google/latexify_py/blob/develop/LICENSE).


pkgId: 6012e237b06a05efd90344780cb75d0b58e9fb1df43c6f1c3d483e7de1cb7cd3
name: python-lattereview-help
arch: noarch
version: 0.1.0
epoch: 0
release: 1
summary: Development documents and examples for lattereview
url: https://github.com/PouriaRouzrokh/LatteReview
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-lattereview-0.1.0-1.src.rpm
location_href: Packages/python-lattereview-help-0.1.0-1.noarch.rpm
checksum_type: sha256
description:
  [![PyPI version](https://badge.fury.io/py/lattereview.svg)](https://badge.fury.io/py/lattereview)
  [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
  [![Python 3.9+](https://img.shields.io/badge/python-3.9+-blue.svg)](https://www.python.org/downloads/)
  [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
  [![Maintained: yes](https://img.shields.io/badge/Maintained%3F-yes-green.svg)](https://github.com/prouzrokh/lattereview)

  LatteReview is a powerful Python package designed to automate academic literature review processes through AI-powered agents. Just like enjoying a cup of latte ☕, reviewing numerous research articles should be a pleasant, efficient experience that doesn't consume your entire day!



  - Multi-agent review system with customizable roles and expertise
  - Support for multiple review rounds with hierarchical decision-making
  - Flexible model integration (OpenAI, Gemini, Claude, Groq, local models via Ollama)
  - Asynchronous processing for high-performance batch reviews
  - Structured output format with detailed scoring and reasoning
  - Comprehensive cost tracking and memory management
  - Extensible architecture for custom review workflows



  ```bash
  pip install lattereview
  ```



  Here's a simple example of how to set up a review workflow with two primary reviewers and an expert reviewer for conflict resolution:

  ```python
  from lattereview.providers import LiteLLMProvider
  from lattereview.agents import ScoringReviewer
  from lattereview.review_workflow import ReviewWorkflow
  import pandas as pd
  import asyncio


  reviewer1 = ScoringReviewer(
      provider=LiteLLMProvider(model="gpt-4o-mini"),
      name="Alice",
      backstory="a radiologist with expertise in systematic reviews",
      input_description="article title and abstract",
      scoring_task="Evaluate how relevant the article is to artificial intelligence applications in radiology",
      score_set=[1, 2, 3, 4, 5],
      scoring_rules="Rate the relevance on a scale of 1 to 5, where 1 means the article is not at all relevant to AI in radiology, and 5 means it directly focuses on AI applications in radiology.",
      model_args={"temperature": 0.1}  # Low temperature for consistent scoring
  )


  reviewer2 = ScoringReviewer(
      provider=LiteLLMProvider(model="gemini/gemini-1.5-flash"),
      name="Bob",
      backstory="a computer scientist specializing in medical AI",
      input_description="article title and abstract",
      scoring_task="Evaluate how relevant the article is to artificial intelligence applications in radiology",
      score_set=[1, 2, 3, 4, 5],
      scoring_rules="Rate the relevance on a scale of 1 to 5, where 1 means the article is not at all relevant to AI in radiology, and 5 means it directly focuses on AI applications in radiology.",
      model_args={"temperature": 0.8}  # Higher temperature for creative interpretation
  )


  expert = ScoringReviewer(
      provider=LiteLLMProvider(model="gpt-4o"),
      name="Carol",
      backstory="a professor of AI in medical imaging",
      input_description="article title, abstract, and previous reviews",
      scoring_task="Review Alice and Bob's relevance assessments of this article to AI in radiology",
      score_set=[1, 2],
      scoring_rules='Score 1 if you agree with Alice\'s assessment, 2 if you agree with Bob\'s assessment',
      model_args={"temperature": 0.1}  # Low temperature for careful judgment
  )


  workflow = ReviewWorkflow([
      {
          "round": 'A',  # First round: Initial review by both reviewers
          "reviewers": [reviewer1, reviewer2],
          "inputs": ["title", "abstract"]
      },
      {
          "round": 'B',  # Second round: Expert reviews only disagreements
          "reviewers": [expert],
          "inputs": ["title", "abstract", "round-A_Alice_output", "round-A_Bob_output"],
          "filter": lambda row: row["round-A_Alice_score"] != row["round-A_Bob_score"]
      }
  ])


  data = pd.read_excel("articles.xlsx")
  results = asyncio.run(workflow(data))
  ```



  LatteReview offers flexible model integration through multiple providers:

  - **LiteLLMProvider** (Recommended): Supports OpenAI, Anthropic (Claude), Gemini, Groq, and more
  - **OpenAIProvider**: Direct integration with OpenAI and Gemini APIs
  - **OllamaProvider**: Optimized for local models via Ollama

  Note: Models should support async operations and structured JSON outputs for optimal performance.



  Full documentation and API reference will be available in our upcoming preprint paper. [Link to be added]



  - [ ] Development of `AbstractionReviewer` class for automated paper summarization
  - [ ] Support for image-based inputs and multimodal analysis
  - [ ] Development of a no-code web application
  - [ ] Integration of RAG (Retrieval-Augmented Generation) tools
  - [ ] Addition of graph-based analysis tools
  - [ ] Enhanced visualization capabilities
  - [ ] Support for additional model providers



  **Pouria Rouzrokh, MD, MPH, MHPE**
  Medical Practitioner and Machine Learning Engineer
  Incoming Radiology Resident @Yale University
  Former Data Scientist @Mayo Clinic AI Lab

  Find my work:
  [![Twitter Follow](https://img.shields.io/twitter/follow/prouzrokh?style=social)](https://twitter.com/prouzrokh)
  [![LinkedIn](https://img.shields.io/badge/LinkedIn-Connect-blue)](https://linkedin.com/in/pouria-rouzrokh)
  [![Google Scholar](https://img.shields.io/badge/Google%20Scholar-Profile-green)](https://scholar.google.com/citations?user=Ksv9I0sAAAAJ&hl=en)
  [![Email](https://img.shields.io/badge/Email-Contact-red)](mailto:po.rouzrokh@gmail.com)



  If you find LatteReview helpful in your research or work, consider supporting its continued development. Since we're already sharing a virtual coffee break while reviewing papers, maybe you'd like to treat me to a real one? ☕ 😊



  - [Treat me to a coffee](http://ko-fi.com/pouriarouzrokh) on Ko-fi ☕
  - [Star the repository](https://github.com/PouriaRouzrokh/LatteReview) to help others discover the project
  - Submit bug reports, feature requests, or contribute code
  - Share your experience using LatteReview in your research



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



  We welcome contributions! Please feel free to submit a Pull Request.



  If you use LatteReview in your research, please cite our paper:

  ```bibtex

  ```


