semvec/pypi-packages huggingface dataset:
alpha-avatar-plugins-memory 0.4.1
AlphaAvatar Framework plugin for memory service
Requires Python: >=3.10
Keywords: AI, agents, langchain, llm, memory

# Memory Plugin for AlphaAvatar

Support for storing and managing conversational memory within Avatar, with a unified interface to open-source memory frameworks.
This plugin simplifies memory management so developers don’t need to worry about storage limits, or backend details.

## Features

* **Global Memory (Avatar-wide):** Retrieval and updates of cross-user, Avatar-level memories. This includes memories derived from automatically identified users as well as memories created through the Avatar’s interactions with external tools and the environment.
* **Real-time Context Updates:** Memories are written and refreshed on the fly based on the current dialogue context.

## Installation

```bash
pip install alpha-avatar-plugins-memory
```

---

## Supported Open-Source Memory Frameworks

### Default: **LangChain + Qdrant**

| Module                 | Description                                                                                   | Docs                                                                   |
| ---------------------- | --------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------- |
| **Qdrant** (default) | Combined framework for persona extraction pipelines and vector storage / retrieval.           | [Qdrant](https://qdrant.tech) |
| **LangChain** (default) | Combined framework for persona extraction pipelines and vector storage / retrieval.           | [LangChain](https://www.langchain.com) |
alpha-avatar-plugins-character 0.4.1
AlphaAvatar Framework plugin for virtual character service
Requires Python: >=3.10
Keywords: agents, anime characters, avatar, digital-life, live2d

# Virtual Character Plugin for AlphaAvatar

A modular virtual-character middleware that brings advanced real-time avatar rendering into the AlphaAvatar agent ecosystem. This plugin enables any AlphaAvatar-driven AI agent to seamlessly control high-fidelity virtual characters—handling lip-sync, facial expressions, emotional states, and synchronized video generation.

## Installation

```bash
pip install alpha-avatar-plugins-character
```

---

## Supported Open-Source Virtual Character Frameworks

### Default: AIRI [Github](https://github.com/moeru-ai/airi)

High-fidelity Live2D/VRM real-time renderer, enabling lip-sync, emotion control, and avatar video generation.

```shell
curl https://get.volta.sh | bash

volta install node
volta install pnpm

alphaavatar-airi-install
```

> Note: AIRI performs a Chromium preflight check on startup.
> If Chromium cannot start in headless mode, actionable system dependency
> installation hints will be printed based on your Linux distribution.
moat-lib-broadcast 0.1.3
Broadcasting support for MoaT applications
Requires Python: >=3.8
Keywords: MoaT

# Broadcasting

% start synopsis
% start main

This module provides async broadcasting, with a finite message queue.

The writer does not block; the reader supports data loss detection.

% end synopsis
% end main

## Usage

```python
from moat.lib.broadcast import Broadcaster
import anyio
from contextlib import aclosing

async def reader(bc):
    async with aclosing(bc) as mq:
        async for msg in mq:
            print(f"Received: {msg}")

async with anyio.create_task_group() as tg, Broadcaster() as bc:
    # Start readers
    tg.start_soon(reader, aiter(bc))
    tg.start_soon(reader, bc.reader(10))  # explicit queue length

    # Send messages
    bc("Hello")
    await anyio.sleep(0.01)
    bc("World")
```

## License

This project is part of the MoaT ecosystem and is licensed under the same terms.
moat-link-notify 0.0.2
Notification gateway for MoaT-Link
Requires Python: >=3.8
Keywords: MoaT

# Notification gateway

% start synopsis
% start main

Notification gateway for MoaT-Link.

This package provides notification services for MoaT-Link, allowing you to send
notifications to external services.

% end synopsis

## Backends

Currently the only implemented backend is `ntfy.sh`.

% end main

## Usage

The notification gateway can be configured through MoaT-Link's configuration system.

## License

This project is licensed under the same terms as MoaT.
moat-lib-stream 0.2.0
Stream infrastructure for MoaT applications
Requires Python: >=3.8
Keywords: MoaT

# Stream Infrastructure

% start synopsis
% start main

This module provides base classes for handling data streams in a structured manner.

% end synopsis

## Overview

This package implements infrastructure for building layered communication stacks:

- **BaseMsg** - Message-based communication (Python objects)
- **BaseBlk** - Block-based communication (delimited bytestrings)
- **BaseBuf** - Buffer-based communication (undelimited bytestreams)

## Layered Communication Stacks

Build communication stacks by layering protocols:

```python
from moat.lib.stream import StackedBlk

class Compression(StackedBlk):
    async def snd(self, blk):
        compressed = compress(blk)
        await self.s.send(compressed)

    async def rcv(self):
        blk = await self.s.recv()
        return decompress(blk)

# Stack layers
link = SerialLink(cfg)  # BaseBuf
link = Packetizer(link, cfg)  # StackedBlk
link = Compressor(link, cfg)  # StackedBlk
link = Codec(link, cfg)  # StackedMsg
async with link:
    await link.send({"data": "hello"})
```

% end main

## License

This project is part of the MoaT ecosystem and is licensed under the same terms.
moat-dev-heat 0.1.6
REPLACE ME
Requires Python: >=3.8
Keywords: MoaT

# Turn on the Heat

% start synopsis
% start main

This is a heating controller.

Currently it's a personal project that controls a Solvis controller, buffer,
and heat pump, and a KWB pellet burner, in dual/alternate mode, though the
result is intended to be somewhat more generic.

% end synopsis
% end main
moat-lib-path 0.2.0
Hierarchical path representation and manipulation for MoaT
Requires Python: >=3.8
Keywords: MoaT

# Hierarchical Paths

% start main
% start synopsis

MoaT Paths are immutable sequences that can be represented as dot-separated or
slash-separated strings, with special encoding for various data types.

MoaT paths are typically entered and displayed with dots as separators and
colon as "special" markers. For example, `ext:1.set` is a three-element
path consisting of two strings with an integer in between.

There's a secondary representation that uses slashes (`ext/:1/set`)
for interfacing with the file system or MQTT.

See `pydoc moat.lib.path.Path` for details.

The MoaT ecosystem uses `Path` objects as hierarchical accessors for objects and data.

% end synopsis

## Usage

### Creating paths

```python
from moat.lib.path import Path, P

# Create paths from elements
path = Path()  # empty path

path = P("foo.bar.baz")  # dot notation
assert path == Path.build(("foo", "bar", "baz"))  # assemble from tuples, lists etc.

# Create from various types
path = Path.build(("config", 42, True))  # Mixed types
assert path == P("config:x2a:t")  # config, 0x2a (42), True
```

### Path representation

Paths can be represented in two forms:

**Dot notation**: Elements separated by dots
```python
path = P("foo.bar.baz")
str(path)  # "foo.bar.baz"
```

**Slash notation**: Elements separated by slashes
```python
path = P("foo.bar.baz")
path.slash  # "foo/bar/baz"
```

### Special codes

MoaT paths support non-string path elements. The most common are:

```python
# Inline escapes (within an element):
#   ::  escapes : colon
#   :.  escapes . dot
#   :_  escapes   space
#   :|  escapes / slash

# Type prefixes (start a new element):
#   :t   True
#   :f   False
#   :e   empty string
#   :n   None
#   :42  Simple integer
#   :xAB Hex integer (0xAB)
#   :b01 Binary integer (0b01)
#   :yAB Bytestring, hex encoding
#   :sAB Bytestring, base64 encoding

path = P("config:x2a:t")  # Represents ("config", 42, True)
```

### Path operations

```python
from moat.lib.path import Path

path1 = P("foo.bar")
path2 = P("baz.qux")

# Concatenation
combined = path1 + path2  # Path("foo", "bar", "baz", "qux")

# Element access
path1[0]  # "foo"
path1[-1]  # "bar"

# Slicing
path = Path("a.b.c.d")
path[1:3]  # ("b", "c")

# Length
len(path)  # 4

# Iteration
for elem in path:
    print(elem)

# Appending single element
path = path / "new"  # a.b.c.d.new
```

% end main

## Serialization

MoaT paths integrate with serialization formats:

- **YAML**: Use a `!P` prefix for Path objects (dot notation)
- **CBOR**: List marked with tag 39 ("Identifier")
- **Msgpack**: extension 3 encapsulates path elements
moat-link-gate 0.0.2
Gateway modules for MoaT-Link (KV and MQTT)
Requires Python: >=3.8
Keywords: MoaT

# moat-link-gate

% start synopsis
% start main

Gateway modules for MoaT-Link providing KV and MQTT integrations.

This package provides gateway functionality for MoaT-Link, including:
- MoaT-KV gateway for data storage integration
- "Raw" MQTT, using configurable codecs

% end synopsis

## Features

The gateway bidirectionally translates from MoaT-Link to various other
destinations. Messages are timestamped and marked, so there are no update
cycles.

% end main

## Usage

The gateways can be configured through MoaT-Link's configuration system.

## License

This project is licensed under the same terms as MoaT.
moat-api-bosch 0.1.1
MoaT API wrappers for Bosch Sensortec chips
Requires Python: >=3.11
Keywords: MoaT, Bosch, BMV080, sensor

# MoaT API: Bosch Sensortec

% start synopsis
% start main

This module collects CFFI-based Python wrappers for Bosch Sensortec sensors.

- BMV080 Particulate Matter Sensor

% end synopsis

## Requirements

- BMV080: the shared libraries (`libbmv080.so` / `bmv080.dll`) must be
  obtained from Bosch Sensortec.

## Availability

The Bosch libraries may or may not be available for your OS and architecture.
If they are not, acquire a suitable device (e.g. a Raspberry Pi 4) and use
MoaT-Link to connect to the library remotely.

% end main

## License

This library is licensed under the MIT license. The license of the Bosch
binares unfortunately does not explicitly allow redistribution, thus they
cannot be included here.
moat-lib-ring 0.2.3
A character-based ring buffer
Requires Python: >=3.8
Keywords: MoaT

# moat-lib-ring

% start synopsis
% start main

A simple opinionated character-based ring buffer.

This buffer, well, buffers. It's async compatible and can handle writes
overruns either by delaying the writer or by only keeping the newest data.

% end synopsis

## Async operation

`moat.lib.ring.aio` provides an async version.

Async writes always wait until all bytes have been
delivered to the buffer.

% end main

## Usage

Usage is very simple:

```python
from moat.lib.ring import RingBuffer

# Create buffer
ring = RingBuffer(200)

# write to it
nbytes = ring.write(b'Hello', drop=True)
assert nbytes == 5

# read from it
buf = bytearray(2)
assert ring.readinto(buf) == 2
assert buf == 'He'

```

## Overflow handling

If you write with `drop=True`, which is the default, writing to the buffer
will always succeed and return the length of the bytestring. On overflow,
the last bufsize-1 bytes will be preserved. The first byte you read will be
a null byte, to signal that data was lost.

`drop=False` means that writing will stall instead of destroying data: `write`
will return a smaller length than requested. The caller is responsible for
waiting until there is free space.


## Locking

This code doesn't know if it's called from a thread or not.
If required, please add your own.


# Threaded operation

TODO. Requires a lock and thread-based events (or conditions).
moat-lib-micro 0.3.0
Compatibility layer for CPython/anyio and MicroPython/uasyncio
Requires Python: >=3.8
Keywords: MoaT

# moat-lib-micro

% start main
% start synopsis

Compatibility wrappers for async code that runs run on both CPython/anyio
and MicroPython/asyncio.

% end synopsis

This module provides a unified interface for asynchronous programming that
works across both CPython (using anyio) and MicroPython (using asyncio).
It includes wrappers for logging and timing, common async primitives like
Event, Lock, Queue, or TaskGroup, async context managers, and more.

## Usage

The module provides consistent imports that work on both platforms:

```python
from moat.lib.micro import Event, Lock, Queue, TaskGroup, sleep

# Use these primitives the same way on both CPython and MicroPython

async def worker(evt):
    await evt.wait()

async def example():
    event = Event()
    async with TaskGroup() as tg:
        tg.start_soon(worker, event)
        await sleep(1)
        event.set()
```

% end main

## License

Licensed under the MIT License.
moat-lib-pid 0.8.0
An advanced PID controller
Requires Python: >=3.8
Keywords: MoaT

# moat-lib-pid

% start main
% start synopsis

An advanced PID controller in Python. It does not require a fixed feed
rate, supports anti-windup, and contains an optional first-order filter for
the derivative term.

% end synopsis

This module was vendorized from the advanced-pid module by Erkan Adali <erkanadali91@gmail.com>.

MoaT improvements include

- a `CPID` subclass with a settable reference
- saving internal state, for crash recovery and rebooting
- introspection

## Usage

Usage is very simple:

```python
from moat.lib.pid import PID

# Create PID controller
pid = PID(Kp=2.0, Ki=0.1, Kd=1.0, Tf=0.05)

# Control loop

reference = 1.0

while True:
    # Get current measurement from system
    timestamp, measurement = system.get_measurement()

    # Calculate control signal by using PID controller
    control = pid(reference - measurement, t=timestamp)

    # Feed control signal to system
    system.set_input(control)
```

The package's examples includes a toy mass-spring-damper system model for testing.

% end main

## License

Licensed under the
[MIT License](https://github.com/eadali/advanced-pid/blob/main/LICENSE.md).
moat-lib-proxy 0.1.1
Proxy helpers for serializing and deserializing objects
Requires Python: >=3.8
Keywords: MoaT

# Proxy helpers

% start main
% start synopsis

This module provides proxy helpers for serializing and deserializing objects
across process boundaries or network connections. It includes:

- Transparent proxy objects that can be serialized and reconstructed
- Object registration and name mapping for proxied objects
- Data-carrying proxies (DProxy) for including object state
- Integration with CBOR, msgpack, and other serialization formats

% end synopsis

## Usage

### Basic proxy registration

```python
from moat.lib.proxy import name2obj, obj2name, Proxy

# Register a class for proxying
class MyService:
    def do_something(self):
        return "result"

# Register the class with a name
name2obj("myapp.MyService", MyService)

# Get the proxy name for an object
service = MyService()
proxy_name = obj2name(service)  # Returns "myapp.MyService"
```

### Using proxies

```python
from moat.lib.proxy import as_proxy, get_proxy

# Create a proxy reference to an object
obj = MyService()
proxy = as_proxy(obj)  # Returns a Proxy object

# Later, retrieve the original object
original = get_proxy(proxy)  # Returns the MyService instance
```

### Data-carrying proxies (DProxy)

```python
from moat.lib.proxy import DProxy

class MyData(DProxy):
    """A proxy that includes object state"""

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

    def __reduce__(self):
        # Define how to serialize the object
        return (self.__class__, (self.value,))

# The object can be serialized with its state
data = MyData(42)
# When serialized and deserialized, the value is preserved
```

### Working with serialization

```python
from moat.lib.proxy import wrap_obj, unwrap_obj

# Serialize an object for transmission
class MyObject:
    pass

name2obj("myapp.MyObject", MyObject)
obj = MyObject()

# Wrap for serialization
wrapped = wrap_obj(obj)  # Creates a serializable representation

# Later, unwrap to reconstruct
reconstructed = unwrap_obj(wrapped)  # Returns a MyObject instance
```

## Integration with Serialization Formats

This module integrates with MoaT's serialization libraries:

- **CBOR**: `moat.lib.codec.cbor`
- **Msgpack**: `moat.lib.codec.msgpack`
- **YAML**: Supports proxy references in configuration files

% end main