semvec/pypi-packages huggingface dataset:
json2png-annotation 0.1.0
A library for converting JSON annotation files to PNG masks
Requires Python: >=3.6

# JSON2PNG Annotation Converter

A Python library for converting JSON annotation files (typically from annotation tools like MakesenseAI, VIA or LabelMe) to PNG mask images, useful for computer vision and machine learning tasks.

## Features

- Convert JSON annotation files to binary PNG masks
- Process multiple JSON files in a directory
- Customizable mask dimensions
- Filter JSON files by filename pattern
- Command-line interface for easy integration into pipelines
- Programmatic API for integration into Python projects

## Installation

### From PyPI (recommended)

```bash
pip install json2png-annotation
```

### From Source

```bash
git clone https://github.com/nguyentran4896/json2png-annotation.git
cd json2png-annotation
pip install -e .
```

## Usage

### Command-line Interface

```bash
# Basic usage
json2png -i /path/to/json/files -o /path/to/output/masks

# Custom dimensions
json2png -i /path/to/json/files -o /path/to/output/masks -w 1024 -t 768

# Filter JSON files by pattern
json2png -i /path/to/json/files -o /path/to/output/masks -p "car_"
```

### Python API

```python
from json2png_annotation import convert_annotations

# Convert all JSON files in a directory
output_files = convert_annotations(
    input_folder="/path/to/json/files",
    output_folder="/path/to/output/masks",
    width=800,
    height=800
)

print(f"Generated {len(output_files)} PNG files")

# With filename pattern filtering
output_files = convert_annotations(
    input_folder="/path/to/json/files",
    output_folder="/path/to/output/masks",
    filename_pattern="car_"
)

# Process a single JSON object
from json2png_annotation.converter import convert_single_annotation

with open("annotation.json", "r") as f:
    json_data = json.load(f)

output_path = convert_single_annotation(
    json_data,
    output_path="output_mask.png",
    width=800,
    height=800
)
```

## Input Format

The library expects JSON annotation files in the following format:

```json
{
  "image_name.jpg": {
    "regions": {
      "0": {
        "shape_attributes": {
          "all_points_x": [100, 200, 300, 100],
          "all_points_y": [100, 100, 200, 200]
        }
      },
      "1": {
        "shape_attributes": {
          "all_points_x": [400, 500, 500, 400],
          "all_points_y": [400, 400, 500, 500]
        }
      }
    }
  }
}
```

## Output

The output is a PNG image with black (0) background and white (255) polygon regions based on the coordinates in the JSON file.

## License

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

## Contributing

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

1. Fork the repository
2. Create your feature branch (`git checkout -b feature/amazing-feature`)
3. Commit your changes (`git commit -m 'Add some amazing feature'`)
4. Push to the branch (`git push origin feature/amazing-feature`)
5. Open a Pull Request
OBRAG 0.1.2
Obsidian RAG assistant with access to your local vault and web search.
Requires Python: >=3.11

# OBRAG
Obsidian-linked RAG Agent.

Installation:

Requires Python >= 3.11:

```python
pip install obrag
obrag --help
```

If there are any issues, reconfiguring with `obrag --reconfigure` should solve problems.

Simple Obsidian-linked RAG CLI for querying note base; API inference and local embeddings with HuggingFace.

To rebuild the vector store, use `obrag --rebuild`.

To skip the CLI and ask a question directly from the terminal, use `obrag --ask QUESTION`.

Happy querying.
eyai 1.0.5
A simple and intuitive wrapper around OpenAI Compatible APIs with tool support
Requires Python: >=3.8
Keywords: ai, assistant, chatgpt, deepseek, function-calling, groq, llm, openai, tools

# EYAI
<small><code>pronounced: /eɪ aɪ/</code></small>

A simple and intuitive wrapper around OpenAI compatible APIs with built-in tool support.

## Features

- Easy-to-use AI assistant with conversation memory
- Simple tool/function calling with decorators
- Automatic conversation history management
- Save and load conversations
- Support for multiple AI providers (OpenAI, Groq, etc.)
- Configurable model parameters

## Installation

```bash
pip install eyai
```

## Quick Start

```python
from eyai import Assistant

assistant = Assistant(api_key="your-api-key-here")

# Simple chat
response = assistant.chat("Hello! What's the weather like?")
print(response)

# With tools
@assistant.tool("Get the current weather for a city")
def get_weather(city: str) -> str:
    # Your weather API logic here
    return f"The weather in {city} is sunny and 72°F"

# The AI can now call your function
response = assistant.chat("What's the weather in New York?")
print(response)  # AI will call get_weather("New York") and respond
```

## Advanced Usage

### Using with Groq

```python
from eyai import Assistant

assistant = Assistant(
    api_key="your-groq-api-key",
    base_url="https://api.groq.com/openai/v1",
    model="llama-3.3-70b-versatile"
)
```

### Multiple Tools

```python
@assistant.tool("Calculate the sum of two numbers")
def add(x: int, y: int) -> int:
    return x + y

@assistant.tool("Get user information from database")
def get_user(user_id: str) -> dict:
    # Your database logic here
    return {"id": user_id, "name": "John Doe"}

response = assistant.chat("Add 5 and 3, then get user info for user123")
```

### Conversation Management

```python
# Get conversation history
history = assistant.get_conversation_history()

# Clear conversation (keeps system prompt)
assistant.clear_conversation()

# Save conversation
assistant.save_conversation("chat_history.json")

# Load conversation
assistant.load_conversation("chat_history.json")
```

## API Reference

### Assistant

```python
Assistant(
    api_key: str,
    base_url: str,
    model: str,
    system_prompt: str = "You are a helpful AI assistant.",
    temperature: float = 0.7,
    max_tokens: Optional[int] = None
)
```

#### Methods

- `chat(message: str) -> str`: Send a message and get a response
- `tool(description: str = "")`: Decorator to register functions as tools
- `get_conversation_history() -> List[Dict[str, Any]]`: Get conversation history
- `clear_conversation()`: Clear conversation history
- `save_conversation(filename: str)`: Save conversation to JSON file
- `load_conversation(filename: str)`: Load conversation from JSON file

## Requirements

- Python 3.8+

## License

MIT License - see LICENSE file for details.

## Contributing

Contributions are welcome! Please feel free to submit a Pull Request.
terminal-ai-chat 0.1.6
A simple CLI tool to talk to an LLM in the terminal.

# terminal-ai
This is a simple CLI tool for chatting to an LLM in the terminal.

Currently, only Gemini is supported, but I'll add Ollama support later. 
Nothing else is planned for now.

****

## Command overview
Consider this a simple overview of *some* of the commands. 
The commands have more functions, which can be viewed by typing chat -h or just typing chat.
There are also some additional commands not mentioned here

- `chat start` - Begin a chat
- `chat once <message>`- Send a single message to the LLM
- `chat list` - List all existing chats
- `chat delete <chat name>` - Delete a chat
- `chat systemprompt <...>` - System prompt configuration
- `chat model <...>` - Model configuration (Add models and API keys here)

When in a chat using `chat start`, there are some in-chat commands. These are:

- `quit/bye/exit` to quit (saves your chat)
- `clear` to clear the chat history (asks for confirmation)
- `retry` to regenerate a new AI response to the previous message
- `save` to save the chat so far
- `systemprompt/system` to display and/or change the system prompt
- `help` to display a help message

Enjoy :)
espn-api 0.45.1
ESPN API

![](https://github.com/cwendt94/espn-api/workflows/Espn%20API/badge.svg)
![](https://github.com/cwendt94/espn-api/workflows/Espn%20API%20Integration%20Test/badge.svg) [![codecov](https://codecov.io/gh/cwendt94/espn-api/branch/master/graphs/badge.svg)](https://codecov.io/gh/cwendt94/espn-api) [![Join the chat at https://gitter.im/ff-espn-api/community](https://badges.gitter.im/ff-espn-api/community.svg)](https://gitter.im/ff-espn-api/community?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge) [![PyPI version](https://badge.fury.io/py/espn-api.svg)](https://badge.fury.io/py/espn-api)<a target="_blank" href="https://www.python.org/downloads/" title="Python version"><img src="https://img.shields.io/badge/python-%3E=_3.8-teal.svg"></a>


## ESPN API
This package uses ESPN's Fantasy API to extract data from any public or private league for **Fantasy Football and Basketball (NHL, MLB, and WNBA are in development)**.  
Please feel free to make suggestions, bug reports, and pull request for features or fixes!

This package was inspired and based off of [rbarton65/espnff](https://github.com/rbarton65/espnff).

## Installing
With Git:
```
git clone https://github.com/cwendt94/espn-api
cd espn-api
python3 setup.py install
```
With pip:
```
pip install espn_api
```

## Usage
### [For Getting Started and API details head over to the Wiki!](https://github.com/cwendt94/espn-api/wiki)
```python
# Football API
from espn_api.football import League
# Basketball API
from espn_api.basketball import League
# Hockey API
from espn_api.hockey import League
# Baseball API
from espn_api.baseball import League
# Init
league = League(league_id=222, year=2019)
```

### Run Tests
```
python3 setup.py nosetests
```
## [Discussions](https://github.com/cwendt94/espn-api/discussions) (new)
If you have any questions about the package, ESPN API data, or want to talk about a feature please start a [discussion](https://github.com/cwendt94/espn-api/discussions)! 


## Issue Reporting
If you find a bug follow the steps below for reporting.

1. Open a [new issue](https://github.com/cwendt94/espn-api/issues) with a brief description of the bug for the title. In the title also add which sport (Football or Basketball)

2. Run the application in debug mode to view ESPN API request's and response's
    ```python
    # ... import statement above
    league = League(league_id=1245, year=2019, debug=True)
    ```
    The application will print all requests and the response from ESPN's API in the console. I would suggest piping the console output to a text file as it will be a lot of data.

3. Find the last log before the crash and copy it in the issue descrption with the line number of the crash or possible bug.

4. Submit the new issue!

I will try to comment on the issue as soon as possible with my thoughts and possible fix!
fs.filefs 1.0.3
A custom filesystem for pyfilesystem2 that allows mounting files from other filesystems.
Requires Python: >=3.9
Keywords: pyfilesystem, filesystem, fs

# fs.filefs: Custom filesystem for pyfilesystem2

[![PyPI version](https://img.shields.io/pypi/v/vuefinder-wsgi)](https://pypi.org/project/fs.filefs/)
[![LICENSE](https://img.shields.io/github/license/abichinger/fs.filefs)](https://github.com/abichinger/fs.filefs/blob/main/LICENSE)

This package provides `FileFS`, a custom filesystem for [pyfilesystem2](https://pyfilesystem2.readthedocs.io/) that allows you to mount files from other filesystems.

## Installation

```sh
pip install fs.filefs
```

## Usage Example

```python
from fs.osfs import OSFS
from fs.filefs import FileFS

image_fs = OSFS("~/images")
file_fs = FileFS()
file_fs.add_file("screenshot_1.png", image_fs)
file_fs.add_file("screenshot_2.png", image_fs, name="img_2.png")

print(file_fs.listdir("/"))  # ['screenshot_1.png', 'img_2.png']
```

## Develpment

```sh
# Install package in editable mode
pip install -e .

# Run tests
python -m unittest discover -s tests
```
botnetics-agent 0.1.8
Simple framework for building Telegram agents with Django
Requires Python: >=3.8

# Botnetics Agent

A simple framework for building Telegram agents with Django.

## Installation

```bash
pip install botnetics-agent
```

## Quick Start

```bash
botnetics init my-agent
cd my-agent
python agent.py
```

Test your agent:
```bash
curl -X POST http://localhost:8000/message/ \
  -H "Content-Type: application/json" \
  -d '{"text": "Hello", "chat_id": "123", "user_id": "456"}'
```

## Features

- Simple message handling with decorators
- Built-in Django web server
- REST API endpoint for message processing
- Easy project scaffolding
- Docker support

## Usage

Create a new agent:
```python
from botnetics import BotneticsApp, Message

app = BotneticsApp(api_key="your-key")

@app.on_message
def handle_message(message: Message):
    return Message(
        text=f"You said: {message.text}",
        chat_id=message.chat_id,
        user_id=message.user_id
    )

app.run()
```

## License

MIT License