semvec/pypi-packages huggingface dataset:
gigachain-voyageai 0.1.1
An integration package connecting VoyageAI and GigaChain
License: MIT
Requires Python: <4.0,>=3.8.1

# langchain-voyageai

This package contains the LangChain integrations for VoyageAI through their `voyageai` client package.

## Installation and Setup

- Install the LangChain partner package
```bash
pip install gigachain-voyageai
```
- Get an VoyageAI api key and set it as an environment variable (`VOYAGE_API_KEY`) or use the API key as a parameter in the Client.



## Text Embedding Model

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

```python
from langchain_voyageai import VoyageAIEmbeddings
```
gigachain-prompty 0.0.2
An integration package connecting Prompty and GigaChain
License: MIT
Requires Python: <4.0,>=3.8.1

# langchain-prompty

This package contains the LangChain integration with Microsoft Prompty.

## Installation

```bash
pip install -U langchain-prompty
```

## Usage

Use the `create_chat_prompt` function to load `prompty` file as prompt.

```python
from langchain_prompty import create_chat_prompt

prompt = create_chat_prompt('<your .prompty file path>')
```
Then you can use the prompt for next steps.

Here is an example .prompty file:
```prompty
---
name: Basic Prompt
description: A basic prompt that uses the GPT-3 chat API to answer questions
authors:
  - author_1
  - author_2
model:
  api: chat
  configuration:
    azure_deployment: gpt-35-turbo
sample:
  firstName: Jane
  lastName: Doe
  question: What is the meaning of life?
  chat_history: []
---
system:
You are an AI assistant who helps people find information.
As the assistant, you answer questions briefly, succinctly, 
and in a personable manner using markdown and even add some personal flair with appropriate emojis.

{% for item in chat_history %}
{{item.role}}:
{{item.content}}
{% endfor %}


user:
{{input}}

```
gigachain-nomic 0.1.2
An integration package connecting Nomic and GigaChain
License: MIT
Requires Python: <4.0,>=3.8.1

# langchain-nomic

This package contains the LangChain integration with Nomic

## Installation

```bash
pip install -U langchain-nomic
```

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

* `NOMIC_API_KEY`: your nomic API key

## Embeddings

`NomicEmbeddings` class exposes embeddings from Nomic.

```python
from langchain_nomic import NomicEmbeddings

embeddings = NomicEmbeddings()
embeddings.embed_query("What is the meaning of life?")
gigachain-huggingface 0.0.3
An integration package connecting Hugging Face and GigaChain
License: MIT
Requires Python: <4.0,>=3.8.1

# langchain-huggingface

This package contains the LangChain integrations for huggingface related classes.

## Installation and Setup

- Install the LangChain partner package
```bash
pip install langchain-huggingface
```
gigachain-exa 0.1.0
An integration package connecting Exa and GigaChain
License: MIT
Requires Python: <4.0,>=3.8.1

# langchain-exa

This package contains the LangChain integrations for Exa Cloud generative models.

## Installation

```bash
pip install -U langchain-exa
```

## Exa Search Retriever

You can retrieve search results as follows

```python
from langchain_exa import ExaSearchRetriever

exa_api_key = "YOUR API KEY"

# Create a new instance of the ExaSearchRetriever
exa = ExaSearchRetriever(exa_api_key=exa_api_key)

# Search for a query and save the results
results  = exa.invoke("What is the capital of France?")

# Print the results
print(results)
```

## Exa Search Results

You can run the ExaSearchResults module as follows

```python
from langchain_exa import ExaSearchResults

# Initialize the ExaSearchResults tool
search_tool = ExaSearchResults(exa_api_key="YOUR API KEY")

# Perform a search query
search_results = search_tool._run(
    query="When was the last time the New York Knicks won the NBA Championship?",
    num_results=5,
    text_contents_options=True,
    highlights=True
)

print("Search Results:", search_results)
```

## Exa Find Similar Results

You can run the ExaFindSimilarResults module as follows

```python
from langchain_exa import ExaFindSimilarResults

# Initialize the ExaFindSimilarResults tool
find_similar_tool = ExaFindSimilarResults(exa_api_key="YOUR API KEY")

# Find similar results based on a URL
similar_results = find_similar_tool._run(
    url="http://espn.com",
    num_results=5,
    text_contents_options=True,
    highlights=True
)

print("Similar Results:", similar_results)
```
gigachain-azure-dynamic-sessions 0.1.0
An integration package connecting Azure Container Apps dynamic sessions and GigaChain
License: MIT
Requires Python: <4.0,>=3.8.1

# langchain-azure-dynamic-sessions

This package contains the LangChain integration for Azure Container Apps dynamic sessions. You can use it to add a secure and scalable code interpreter to your agents.

## Installation

```bash
pip install -U langchain-azure-dynamic-sessions
```

## Usage

You first need to create an Azure Container Apps session pool and obtain its management endpoint. Then you can use the `SessionsPythonREPLTool` tool to give your agent the ability to execute Python code.

```python
from langchain_azure_dynamic_sessions import SessionsPythonREPLTool


# get the management endpoint from the session pool in the Azure portal
tool = SessionsPythonREPLTool(pool_management_endpoint=POOL_MANAGEMENT_ENDPOINT)

prompt = hub.pull("hwchase17/react")
tools=[tool]
react_agent = create_react_agent(
    llm=llm,
    tools=tools,
    prompt=prompt,
)

react_agent_executor = AgentExecutor(agent=react_agent, tools=tools, verbose=True, handle_parsing_errors=True)

react_agent_executor.invoke({"input": "What is the current time in Vancouver, Canada?"})
```

By default, the tool uses `DefaultAzureCredential` to authenticate with Azure. If you're using a user-assigned managed identity, you must set the `AZURE_CLIENT_ID` environment variable to the ID of the managed identity.
gigachain-airbyte 0.1.1
An integration package connecting Airbyte and GigaChain
License: MIT
Requires Python: <4.0,>=3.9

# langchain-airbyte

This package contains the LangChain integration with Airbyte

## Installation

```bash
pip install -U langchain-airbyte
```

The integration package doesn't have any global environment variables that need to be
set, but some integrations (e.g. `source-github`) may need credentials passed in.

## Document Loaders

`AirbyteLoader` class exposes a single document loader for Airbyte sources.

```python
from langchain_airbyte import AirbyteLoader

loader = AirbyteLoader(
    source="source-faker",
    stream="users",
    config={"count": 100},
)
docs = loader.load()
```
Flask-CKEditor 1.0.0
CKEditor integration for Flask.
License: MIT


Flask-CKEditor
--------------

CKEditor integration for Flask, including image upload, code syntax
highlighting, and more.

Features:

* Integrate with Flask-WTF/WTForms.
* Configure CKEditor through Flask's configuration system.
* Image upload support.
* Code snippet highlighting.
* Built-in CKEditor resources.
gigachain-standard-tests 0.1.1
Standard tests for GigaChain implementations
License: MIT
Requires Python: <4.0,>=3.8.1

# gigachain-standard-tests

This is an INTERNAL library for the LangChain project. It contains the base classes for
a standard set of tests.

## Installation

This package will NOT be regularly published to pypi. It is intended to be installed
directly from github at test time.

Pip:
    
    ```bash
    pip install git+https://github.com/langchain-ai/langchain.git#subdirectory=libs/standard-tests
    ```

Poetry:
    
    ```bash
    poetry add git+https://github.com/langchain-ai/langchain.git#subdirectory=libs/standard-tests
    ```

## Usage

To add standard tests to an integration package's e.g. ChatModel, you need to create

1. A unit test class that inherits from ChatModelUnitTests
2. An integration test class that inherits from ChatModelIntegrationTests

`tests/unit_tests/test_standard.py`:
    
```python
"""Standard LangChain interface tests"""

from typing import Type

import pytest
from langchain_core.language_models import BaseChatModel
from langchain_standard_tests.unit_tests import ChatModelUnitTests

from langchain_parrot_chain import ChatParrotChain


class TestParrotChainStandard(ChatModelUnitTests):
    @pytest.fixture
    def chat_model_class(self) -> Type[BaseChatModel]:
        return ChatParrotChain
```

`tests/integration_tests/test_standard.py`:
    
```python
"""Standard LangChain interface tests"""

from typing import Type

import pytest
from langchain_core.language_models import BaseChatModel
from langchain_standard_tests.integration_tests import ChatModelIntegrationTests

from langchain_parrot_chain import ChatParrotChain


class TestParrotChainStandard(ChatModelIntegrationTests):
    @pytest.fixture
    def chat_model_class(self) -> Type[BaseChatModel]:
        return ChatParrotChain
```

## Reference

The following fixtures are configurable in the test classes. Anything not marked
as required is optional.

- `chat_model_class` (required): The class of the chat model to be tested
- `chat_model_params`: The keyword arguments to pass to the chat model constructor
- `chat_model_has_tool_calling`: Whether the chat model can call tools. By default, this is set to `hasattr(chat_model_class, 'bind_tools)`
- `chat_model_has_structured_output`: Whether the chat model can structured output. By default, this is set to `hasattr(chat_model_class, 'with_structured_output')`
ProjectSystemManager 0.6
ProjectSystemManager is a Python library designed to manage projects by creating, updating, searching, and fetching project details. It allows you to organize projects in a specified directory and store relevant information such as project name, creation date, technologies used, and a summary.
License: MIT
Requires Python: >=3.7
Keywords: project management, python library, project system

# ProjectSystemManager

ProjectSystemManager is a Python library designed to manage projects by creating, updating, searching, and fetching project details. It allows you to organize projects in a specified directory and store relevant information such as project name, creation date, technologies used, and a summary.

## Features

- **Set Project Path**: Define the main directory where projects will be stored.
- **Create Project**: Create a new project directory with a details file.
- **Search Projects**: Search for projects based on keywords, creation dates, and technologies.
- **Update Project**: Update project details such as technologies and summary.
- **Fetch Project Details**: Retrieve details of a specific project.

## Installation

Use pip install ProjectSystemManager

## Usage
The configuration file (config.ini) should be located inside the ProjectSystemManager directory. This file defines the main project directory where all projects will be stored. If the file doesn't exist, it will be created with default settings.

While importing the Library use syntax as follow <br>
from ProjectSystemManager import ProjectManager
## Functions
### SetProjectPath(path)
Set the main project directory path in the config file.
from ProjectSystemManager import project

project.SetProjectPath("E:")
### CreateProject(ProjectName, technologies=None, summary=None, path=None)
Create a new project directory and details file.<br>
project.CreateProject("MyProject", technologies=["Python", "Django"], summary="A web application project")
### SearchProject(keyword=None, start_date=None, end_date=None, path=None)
Search for projects based on keyword, start date, and end date.<br>
results = project.SearchProject(keyword="web", start_date="2023-01-01", end_date="2023-12-31")

### UpdateProject(ProjectName, technologies=None, summary=None, path=None)
Update project details.<br>
project.UpdateProject("MyProject", technologies=["React"], summary="A web application project using React")

### FetchProject(ProjectName, Key=None)
Fetch project details.

details = project.FetchProject("MyProject")
beerxml 0.0.8
The beerxml python package is a powerful tool designed to streamline the process of working with BeerXML files, ensuring that specific beer recipes adhere to the BeerXML standard. BeerXML is a widely adopted XML-based standard for representing brewing recipes, allowing brewers to share and exchange their recipes seamlessly.
License: MIT
Requires Python: <4.0,>=3.10
Keywords: beerxml, beer, xml, beerxml standard

# Beerxml

## Description

The beerxml python package is a powerful tool designed to streamline the process of working with BeerXML files, ensuring that specific beer recipes adhere to the BeerXML standard. BeerXML is a widely adopted XML-based standard for representing brewing recipes, allowing brewers to share and exchange their recipes seamlessly.

## Installation

To install your package, use the following command:

```bash
pip install beerxml
```

## Code Generation

The models in this beerxml package have been generated from [this beerxml json schema](https://github.com/yourownbeer/beerxml-json-schema) with this command:

```
 datamodel-codegen  --input .\schemas\Recipe.json --input-file-type jsonschema --output output.py --snake-case-field --capitalise-enum-members --use-annotated  --use-non-positive-negative-number-constrained-types --output-model-type pydantic_v2.BaseModel
```

## Usage

Import the `BeerxmlParser` class and inject the file content into the class like in the following example:

```python
from beerxml import BeerxmlParser

# Example usage
parser: BeerxmlParser = BeerxmlParser()
with open("path/to/xml.file", "r") as file_content:
    recipe = parser.parse(file_content.read())

print(recipe.name)
print(recipe.hops)
print(recipe.fermentables)
print(recipe.yeasts)
```

## Contributing

We welcome contributions from the community! If you would like to contribute to this project, please follow these guidelines:

### Reporting Issues

If you encounter any issues or have suggestions, please [open an issue](https://github.com/lowmann15/beerxml/issues) on our GitHub repository.

### Pull Requests

1. Fork the repository and create a new branch for your contribution.
1. Write clear and concise commit messages.
1. Include unit tests for your changes
1. Submit a pull request, clearly describing the changes you've made and providing any necessary context.

### Linting and Code Style

We use the following linters to maintain code quality:

- [Ruff](https://github.com/astral-sh/ruff): for formatting.
- [Bandit](https://github.com/PyCQA/bandit): for security checks.
- [Mypy](https://github.com/python/mypy): for type checking.

Before submitting a pull request, ensure that your code passes these checks.

### Unit Testing

All contributions must be accompanied by unit tests using [pytest](https://github.com/pytest-dev/pytest). Test coverage is crucial to ensure the reliability of the codebase.

To run tests locally:

```bash
pytest .
```