semvec/pypi-packages huggingface dataset:
stream-buffer 0.1.0
A lightweight circular buffer for handling stream data with fast appending and retrieval.
Requires Python: >=3.8

# stream-buffer 

A lightweight circular buffer for handling stream data with fast appending and retrieval.

## Motivation

While working with live ticker data from okx, I realized that there was no lightweight buffer that offers fast appending and range based queries for streaming applications. Thus this buffer was created to address this gap.


## Use Cases

- You need fast time-based appends and efficient range retrievals.

- You want to store only the latest N entries (rolling buffer).

- You’re working with streaming APIs, market data, sensor feeds, or event logs.

- You need custom indexing (e.g., timestamps, floats) but want lower overhead than Pandas.

- You want a minimal and dependency-light alternative to DataFrames or reactive pipelines.


## Installation

```bash
pip install stream-buffer
```


## Example

```python
from stream_buffer import StreamBuffer
from datetime import datetime, timedelta

# Initialize a buffer with a maximum size of 3
timestamps = [datetime.now() + timedelta(seconds=i) for i in range(5)]
buf = StreamBuffer(max_size=3)

# Add items with explicit datetime keys
for i, ts in enumerate(timestamps):
    buf.add(f"price-{i}", key=ts)

# The buffer now contains only the last 3 items (circular behavior)
print("Buffer contents (key, value):")
for k, v in buf:
    print(k, v)

# Access by index (supports negative indices)
print("\nFirst item:", buf[0])
print("Last item:", buf[-1])

# Slicing
print("\nSlice [0:2]:", buf[0:2])

# Membership test (by key)
key_to_check = buf[1][0]
print(f"\nIs key {key_to_check} in buffer?", key_to_check in buf)

# Get by key (exact and neighbors)
print("\nGet by exact key:", buf.get(key_to_check))
print("Get by non-existent key (neighbors):", buf.get(key_to_check + 0.5, force_exact=False))

# Range query (all items between two keys)
start_key = buf[0][0]
end_key = buf[-1][0]
print("\nRange query:", buf.get_range(start_key, end_key))

# Convert to list
print("\nBuffer as list:", buf.to_list())

# Buffer length
print("\nBuffer length:", len(buf))

# Clear the buffer
buf.clear()
print("\nBuffer cleared. Length:", len(buf))
```

**Expected Output**
```
Buffer contents (key, value):
1750881382.592505 price-2
1750881383.592508 price-3
1750881384.59251 price-4

First item: (np.float64(1750881382.592505), 'price-2')
Last item: (np.float64(1750881384.59251), 'price-4')

Slice [0:2]: [(np.float64(1750881382.592505), 'price-2'), (np.float64(1750881383.592508), 'price-3')]

Is key 1750881383.592508 in buffer? True

Get by exact key: price-3
Get by non-existent key (neighbors): ('price-3', None, 'price-4')

Range query: [(np.float64(1750881382.592505), 'price-2'), (np.float64(1750881383.592508), 'price-3')]

Buffer as list: [(np.float64(1750881382.592505), 'price-2'), (np.float64(1750881383.592508), 'price-3'), (np.float64(1750881384.59251), 'price-4')]

Buffer length: 3

Buffer cleared. Length: 0
```
doc-reading-mcp 0.1.1
A simple doc reader and converter MCP service to pdf, docx and markdown
Requires Python: >=3.13

# Document Reading and Converter Tool

The goal is to have a tool that can read and edit files, using Cursor or Claude Desktop.

The `filesystem` MCP already allows reading, writing and editing documents, but is limited in that it cannot:

- Read pdfs or docx files
- Reads the full document, which can cause context overflow

To address these issues, we create:

- A fresh `doc-reading-mcp` mcp service allowing for document conversions between pdf, docx and markdown.

## Features

- PDF to Markdown conversion using marker-pdf
- DOCX to Markdown conversion using pandoc
- Markdown to DOCX conversion using pandoc
- Markdown to PDF conversion using pandoc

## Prerequisites

- Python 3.10 or higher
- [pandoc] (https://pandoc.org/installing.html) installed on your system
- [uv] (https://docs.astral.sh/uv/) for Python package management 

# Installation

```bash
uv add doc-reading-mcp
```

Or install directly from the source:

```bash
uv add git+https://github.com/mffrydman/doc-reading-mcp.git
```

# Usage

## Run as a standalone server

```bash
uv run mcp install -m doc_reading_mcp
```

Or run directly:

```bash
uv run -m doc_reading_mcp
```

## Use with MCP Inspector

```bash
npx @modelcontextprotocol/inspector uvx run -m doc_reading_mcp
```

## Configure in Claude Desktop, Cursor or Windsurf

Add this to your MCP Configuration:

```json
{
    "mcpServers": {
        "doc-reading-mcp": {
            "command": "uvx",
            "args": [
                "doc-reading-mcp",
            ]
        }
    }
}
```

Run in Cursor/Windsurf/Claude using the following configuration:
```json
    "doc-reading-mcp": {
        "command": "uv",
        "args": [
            "--directory",
            "/absolute/path/to/mffrydman/doc-reading-mcp",
            "run",
            "-m",
            "doc_reading_mcp"
        ]
    }
```

Replace
- `/absolute/path/to/` with the actual path on your system.
ergolog 0.1.2
A minimal, ergonomic python logging wrapper
Requires Python: >=3.9

# ergolog
A minimal, ergonomic python logging wrapper

## Intallation

```shell
uv add ergolog
# or
pip install ergolog
```

## Basic Usage


```py
from ergolog import eg

eg.debug('debug')
eg.info('info')
eg.warning('warning')
eg.error('error')
eg.critical('critical')
```

```
[DEBUG   ] ergo (main.py:3) debug
[INFO    ] ergo (main.py:4) info
[WARNING ] ergo (main.py:5) warning
[ERROR   ] ergo (main.py:6) error
[CRITICAL] ergo (main.py:7) critical
```

## Advanced Usage

Named loggers

```py
from ergolog import eg

eg('test').debug('named logger')

```

```
[DEBUG   ] ergo.test (main.py:3) named logger
```

Tags


```py
from ergolog import eg

with eg.tag('tag1'):
    eg.info('one tag')
    with eg.tag('tag2'):
        eg.info('two tags')
    eg.info('one tag again')
```

```
[INFO    ] ergo [tag1] (main.py:4) one tag
[INFO    ] ergo [tag1, tag2] (main.py:6) two tags
[INFO    ] ergo [tag1] (main.py:7) one tag again
```

Tag Decorator

```py
from ergolog import eg

@eg.tag('inner')
def inner():
    eg.info('test')

@eg.tag('outer')
def outer():
    eg.debug('before')
    inner()

    eg.debug('after')

eg.debug('start')
outer()
eg.debug('end')
```

```
[DEBUG   ] ergo (main.py:14) start
[DEBUG   ] ergo [outer] (main.py:9) before
[INFO    ] ergo [outer, inner] (main.py:5) test
[DEBUG   ] ergo [outer] (main.py:12) after
```

Kwarg Tags

```py
from ergolog import eg

with eg.tag(keyword='tags', comma='multiple'):
    eg.debug('')
    with eg.tag('regular tag'):
        eg.info('')
        with eg.tag(more='keywords'):
            eg.info('')
    eg.debug('')
```

```
[DEBUG   ] ergo [keyword=tags, comma=multiple] (main.py:4) 
[INFO    ] ergo [keyword=tags, comma=multiple, regular tag] (main.py:6) 
[INFO    ] ergo [keyword=tags, comma=multiple, regular tag, more=keywords] (main.py:8)
[DEBUG   ] ergo [keyword=tags, comma=multiple] (main.py:9)
```

<!-- 
Job IDs

```py
from ergolog import eg

with eg.tag('job'):
    eg.info('')
    with eg.tag('job'):
        eg.info('nested job ID')
    eg.info('')
```

```
[INFO    ] ergo [job=34bfbe] (main.py:4) 
[INFO    ] ergo [job=34bfbe, job=80dbc9] (main.py:6) nested job ID
[INFO    ] ergo [job=34bfbe] (main.py:7)
```
-->
h2o-notebook 0.6.4
Python client for H2O Notebook Labs
Requires Python: >=3.8

# `h2o-notebook`

[![pypi](https://img.shields.io/pypi/v/h2o-notebook?style=flat-square)](https://pypi.org/project/h2o-notebook/)

Python client for [H2O Notebook Labs](https://docs.h2o.ai/notebook/).

## Installation

```sh
pip install h2o-notebook
```

## Usage

Visit the [documentation](https://docs.h2o.ai/notebook/py/initialization) for more information.