semvec/pypi-packages huggingface dataset:
pyelitecloud 0.3.1
Python library to communicate with Arrowhead Alarm devices via EliteCloud
Requires Python: >=3.8

[![license](https://img.shields.io/github/license/toreamun/amshan-homeassistant?style=for-the-badge)](LICENSE)
[![buy_me_a_coffee](https://img.shields.io/badge/If%20you%20like%20it-Buy%20me%20a%20coffee-yellow.svg?style=for-the-badge)](https://www.buymeacoffee.com/ankohanse)


# pyelitecloud

Python library to communicate with Arrowhead Alarm systems via EliteCloud.
This component connects to the remote EliteCloud servers and automatically detects which alarm systems are available there.

Disclaimer: this library is NOT created by Arrowhead Alarm Producs.


# Usage

The library is available from PyPi using:
`pip install pyelitecloud`

See example_api_use.py for an example of usage.


Note that this is still a work in progress with limited (readonly) functionality.
cfdb-models 0.1.0
data models for cfdb
Requires Python: >=3.10

# cfdb-models

<p align="center">
    <em>data models for cfdb</em>
</p>

[![build](https://github.com/mullenkamp/cfdb-models/workflows/Build/badge.svg)](https://github.com/mullenkamp/cfdb-models/actions)
[![codecov](https://codecov.io/gh/mullenkamp/cfdb-models/branch/main/graph/badge.svg)](https://codecov.io/gh/mullenkamp/cfdb-models)
[![PyPI version](https://badge.fury.io/py/cfdb-models.svg)](https://badge.fury.io/py/cfdb-models)

---

**Source Code**: <a href="https://github.com/mullenkamp/cfdb-models" target="_blank">https://github.com/mullenkamp/cfdb-models</a>

---
## Overview
This package is meant to fully define the data model of cfdb using msgspec. This has been separated from the core cfdb package to abstract away the engine implementation from the data model. This will help in defining and assigning attribute templates for things like variables (e.g. cfdb-vars).

## Development

### Setup environment

We use [UV](https://docs.astral.sh/uv/) to manage the development environment and production build. 

```bash
uv sync
```

### Run unit tests

You can run all the tests with:

```bash
uv run pytest
```

### Format the code

Execute the following commands to apply linting and check typing:

```bash
uv run ruff check .
uv run black --check --diff .
uv run mypy --install-types --non-interactive cfdb_models
```

To auto-format:

```bash
uv run black .
uv run ruff check --fix .
```

## License

This project is licensed under the terms of the Apache Software License 2.0.
agent-framework-ollama 1.0.0b260219
Ollama integration for Microsoft Agent Framework.
Requires Python: >=3.10

# Get Started with Microsoft Agent Framework Ollama

Please install this package as the extra for `agent-framework`:

```bash
pip install agent-framework-ollama --pre
```

and see the [README](https://github.com/microsoft/agent-framework/tree/main/python/README.md) for more information.

# Run samples with the Ollama Conector

You can find samples how to run the connector in the [Ollama provider samples](../../samples/02-agents/providers/ollama).
agent-framework-foundry-local 1.0.0b260219
Foundry Local integration for Microsoft Agent Framework.
Requires Python: >=3.10

# Get Started with Microsoft Agent Framework Foundry Local

Please install this package as the extra for `agent-framework`:

```bash
pip install agent-framework-foundry-local --pre
```

and see the [README](https://github.com/microsoft/agent-framework/tree/main/python/README.md) for more information.

## Foundry Local Sample

See the [Foundry Local provider sample](../../samples/02-agents/providers/foundry_local/foundry_local_agent.py) for a runnable example.
agent-framework-orchestrations 1.0.0b260219
Orchestration patterns for Microsoft Agent Framework. Includes SequentialBuilder, ConcurrentBuilder, HandoffBuilder, GroupChatBuilder, and MagenticBuilder.
Requires Python: >=3.10

# Agent Framework Orchestrations

Orchestration patterns for Microsoft Agent Framework. This package provides high-level builders for common multi-agent workflow patterns.

## Installation

```bash
pip install agent-framework-orchestrations --pre
```

## Orchestration Patterns

### SequentialBuilder

Chain agents/executors in sequence, passing conversation context along:

```python
from agent_framework.orchestrations import SequentialBuilder

workflow = SequentialBuilder(participants=[agent1, agent2, agent3]).build()
```

### ConcurrentBuilder

Fan-out to multiple agents in parallel, then aggregate results:

```python
from agent_framework.orchestrations import ConcurrentBuilder

workflow = ConcurrentBuilder(participants=[agent1, agent2, agent3]).build()
```

### HandoffBuilder

Decentralized agent routing where agents decide handoff targets:

```python
from agent_framework.orchestrations import HandoffBuilder

workflow = (
    HandoffBuilder()
    .participants([triage, billing, support])
    .with_start_agent(triage)
    .build()
)
```

### GroupChatBuilder

Orchestrator-directed multi-agent conversations:

```python
from agent_framework.orchestrations import GroupChatBuilder

workflow = GroupChatBuilder(
    participants=[agent1, agent2],
    selection_func=my_selector,
).build()
```

### MagenticBuilder

Sophisticated multi-agent orchestration using the Magentic One pattern:

```python
from agent_framework.orchestrations import MagenticBuilder

workflow = MagenticBuilder(
    participants=[researcher, writer, reviewer],
    manager_agent=manager_agent,
).build()
```

## Documentation

For more information, see the [Agent Framework documentation](https://aka.ms/agent-framework).
agent-framework-durabletask 1.0.0b260219
Durable Task integration for Microsoft Agent Framework.
Requires Python: >=3.10

# Get Started with Microsoft Agent Framework Durable Task

[![PyPI](https://img.shields.io/pypi/v/agent-framework-durabletask)](https://pypi.org/project/agent-framework-durabletask/)

Please install this package via pip:

```bash
pip install agent-framework-durabletask --pre
```

## Durable Task Integration

The durable task integration lets you host Microsoft Agent Framework agents using the [Durable Task](https://github.com/microsoft/durabletask-python) framework so they can persist state, replay conversation history, and recover from failures automatically.

### Basic Usage Example

```python
from durabletask.worker import TaskHubGrpcWorker
from agent_framework.azure import DurableAIAgentWorker

# Create the worker
with TaskHubGrpcWorker(...) as worker:

    # Register the agent worker wrapper
    agent_worker = DurableAIAgentWorker(worker)

    # Register the agent
    agent_worker.add_agent(my_agent)
```

For more details, review the Python [README](https://github.com/microsoft/agent-framework/tree/main/python/README.md) and the samples directory.
agent-framework-mem0 1.0.0b260219
Mem0 integration for Microsoft Agent Framework.
Requires Python: >=3.10

# Get Started with Microsoft Agent Framework Mem0

Please install this package via pip:

```bash
pip install agent-framework-mem0 --pre
```

## Memory Context Provider

The Mem0 context provider enables persistent memory capabilities for your agents, allowing them to remember user preferences and conversation context across different sessions and threads.

### Basic Usage Example

See the [Mem0 basic example](../../samples/02-agents/context_providers/mem0/mem0_basic.py) which demonstrates:

- Setting up an agent with Mem0 context provider
- Teaching the agent user preferences
- Retrieving information using remembered context across new threads
- Persistent memory

## Telemetry

Mem0's telemetry is **disabled by default** when using this package. If you want to enable telemetry, set the environment variable before importing:

```python
import os
os.environ["MEM0_TELEMETRY"] = "true"

from agent_framework.mem0 import Mem0ContextProvider
```
agent-framework-github-copilot 1.0.0b260219
GitHub Copilot integration for Microsoft Agent Framework.
Requires Python: >=3.10

# Get Started with Microsoft Agent Framework GitHub Copilot

Please install this package via pip:

```bash
pip install agent-framework-github-copilot --pre
```

## GitHub Copilot Agent

The GitHub Copilot agent enables integration with GitHub Copilot, allowing you to interact with Copilot's agentic capabilities through the Agent Framework.
agent-framework-azure-ai-search 1.0.0b260219
Azure AI Search integration for Microsoft Agent Framework.
Requires Python: >=3.10

# Get Started with Microsoft Agent Framework Azure AI Search

Please install this package via pip:

```bash
pip install agent-framework-azure-ai-search --pre
```

## Azure AI Search Integration

The Azure AI Search integration provides context providers for RAG (Retrieval Augmented Generation) capabilities with two modes:

- **Semantic Mode**: Fast hybrid search (vector + keyword) with semantic ranking
- **Agentic Mode**: Multi-hop reasoning using Knowledge Bases for complex queries

### Basic Usage Example

See the [Azure AI Search context provider examples](../../samples/02-agents/providers/azure_ai/) which demonstrate:

- Semantic search with hybrid (vector + keyword) queries
- Agentic mode with Knowledge Bases for complex multi-hop reasoning
- Environment variable configuration with Settings class
- API key and managed identity authentication
agent-framework-anthropic 1.0.0b260219
Anthropic integration for Microsoft Agent Framework.
Requires Python: >=3.10

# Get Started with Microsoft Agent Framework Anthropic

Please install this package via pip:

```bash
pip install agent-framework-anthropic --pre
```

## Anthropic Integration

The Anthropic integration enables communication with the Anthropic API, allowing your Agent Framework applications to leverage Anthropic's capabilities.

### Basic Usage Example

See the [Anthropic agent examples](../../samples/02-agents/providers/anthropic/) which demonstrate:

- Connecting to a Anthropic endpoint with an agent
- Streaming and non-streaming responses
agent-framework-redis 1.0.0b260219
Redis integration for Microsoft Agent Framework.
Requires Python: >=3.10

# Get Started with Microsoft Agent Framework Redis

Please install this package via pip:

```bash
pip install agent-framework-redis --pre
```

## Components

### Memory Context Provider

The `RedisProvider` enables persistent context & memory capabilities for your agents, allowing them to remember user preferences and conversation context across sessions and threads.

#### Basic Usage Examples

Review the set of [getting started examples](../../samples/02-agents/context_providers/redis/README.md) for using the Redis context provider.

### Redis Chat Message Store

The `RedisChatMessageStore` provides persistent conversation storage using Redis Lists, enabling chat history to survive application restarts and support distributed applications.

#### Key Features

- **Persistent Storage**: Messages survive application restarts
- **Thread Isolation**: Each conversation thread has its own Redis key
- **Message Limits**: Configurable automatic trimming of old messages
- **Serialization Support**: Full compatibility with Agent Framework thread serialization
- **Production Ready**: Connection pooling, error handling, and performance optimized

#### Basic Usage Examples

See the complete [Redis history provider examples](../../samples/02-agents/conversations/redis_history_provider.py) including:
- User session management
- Conversation persistence across restarts
- Session serialization and deserialization
- Automatic message trimming
- Error handling patterns

### Installing and running Redis

You have 3 options to set-up Redis:

#### Option A: Local Redis with Docker
```bash
docker run --name redis -p 6379:6379 -d redis:8.0.3
```

#### Option B: Redis Cloud
Get a free db at https://redis.io/cloud/

#### Option C: Azure Managed Redis
Here's a quickstart guide to create **Azure Managed Redis** for as low as $12 monthly: https://learn.microsoft.com/en-us/azure/redis/quickstart-create-managed-redis
agent-framework-azure-ai 1.0.0rc1
Azure AI Foundry integration for Microsoft Agent Framework.
Requires Python: >=3.10

# Get Started with Microsoft Agent Framework Azure AI

Please install this package via pip:

```bash
pip install agent-framework-azure-ai --pre
```

and see the [README](https://github.com/microsoft/agent-framework/tree/main/python/README.md) for more information.
agent-framework-azurefunctions 1.0.0b260219
Azure Functions integration for Microsoft Agent Framework.
Requires Python: >=3.10

# Get Started with Microsoft Agent Framework Durable Functions

[![PyPI](https://img.shields.io/pypi/v/agent-framework-azurefunctions)](https://pypi.org/project/agent-framework-azurefunctions/)

Please install this package via pip:

```bash
pip install agent-framework-azurefunctions --pre
```

## Durable Agent Extension

The durable agent extension lets you host Microsoft Agent Framework agents on Azure Durable Functions so they can persist state, replay conversation history, and recover from failures automatically.

### Basic Usage Example

See the durable functions integration sample in the repository to learn how to:

```python
from agent_framework.azure import AgentFunctionApp

_app = AgentFunctionApp()
```

- Register agents with `AgentFunctionApp`
- Post messages using the generated `/api/agents/{agent_name}/run` endpoint

For more details, review the Python [README](https://github.com/microsoft/agent-framework/tree/main/python/README.md) and the samples directory.
agent-framework-bedrock 1.0.0b260219
Amazon Bedrock integration for Microsoft Agent Framework.
Requires Python: >=3.10

# Get Started with Microsoft Agent Framework Bedrock

Install the provider package:

```bash
pip install agent-framework-bedrock --pre
```

## Bedrock Integration

The Bedrock integration enables Microsoft Agent Framework applications to call Amazon Bedrock models with familiar chat abstractions, including tool/function calling when you attach tools through `ChatOptions`.

### Basic Usage Example

See the [Bedrock sample](../../samples/02-agents/providers/amazon/bedrock_chat_client.py) for a runnable end-to-end script that:

- Loads credentials from the `BEDROCK_*` environment variables
- Instantiates `BedrockChatClient`
- Sends a simple conversation turn and prints the response
agent-framework-a2a 1.0.0b260219
A2A integration for Microsoft Agent Framework.
Requires Python: >=3.10

# Get Started with Microsoft Agent Framework A2A

Please install this package via pip:

```bash
pip install agent-framework-a2a --pre
```

## A2A Agent Integration

The A2A agent integration enables communication with remote A2A-compliant agents using the standardized A2A protocol. This allows your Agent Framework applications to connect to agents running on different platforms, languages, or services.

### Basic Usage Example

See the [A2A agent examples](../../samples/04-hosting/a2a/) which demonstrate:

- Connecting to remote A2A agents
- Sending messages and receiving responses
- Handling different content types (text, files, data)
- Streaming responses and real-time interaction
nzshm-common 0.9.2
A small pure python library for shared NZ NSHM data like locations.
Requires Python: <4.0,>=3.10

# nzshm-common

A pure python library of shared objects used in nzshm projects

[![pypi](https://img.shields.io/pypi/v/nzshm-common.svg)](https://pypi.org/project/nzshm-common/)
[![python](https://img.shields.io/pypi/pyversions/nzshm-common.svg)](https://pypi.org/project/nzshm-common/)
[![Build Status](https://github.com/GNS-Science/nzshm-common-py/actions/workflows/dev.yml/badge.svg)](https://github.com/GNS-Science/nzshm-common-py/actions/workflows/dev.yml)
[![codecov](https://codecov.io/gh/GNS-Science/nzshm-common-py/branch/main/graphs/badge.svg)](https://codecov.io/github/GNS-Science/nzshm-common-py)


* Documentation: <https://GNS-Science.github.io/nzshm-common-py>
* GitHub: <https://github.com/GNS-Science/nzshm-common-py>
* PyPI: <https://pypi.org/project/nzshm-common/>
* Free software: GPL-3.0-only

## Installation

```
pip install nzshm-common
```

## Use

```
>>> from nzshm_common.location import location
>>> dir(location)
['LOCATIONS', 'LOCATION_LISTS', '__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', 'location_by_id']
>>>
```