semvec/pypi-packages huggingface dataset:
terminal-video-player-py 1.0.2
A cli to play videos in the terminal.
Requires Python: >=3.9

# Terminal Video Player (tvp)

This Command Line Interface Tool can be used to play videos in the terminal.

## Installation

`pip install terminal-video-player-py`

## Usage

### Video Playback

`tvp [-h] [-a] [-c] [-chars CHARACTERS] [-rt] video_path downscale`

To play a video, you can simply call `tvp <video_path> <downscale> [optional arguments]`.

Example:
``` bash
tvp <path> 8 -a -rt
```
This will play the video in real time and downscaled 8 times. It will also playback the video's audio.

## Arguments

| Argument  | Description |
| ------------- | ------------- |
| **-h, --help**  | Show help information about the CLI  |
| **-a, --audio**  | Play video audio  |
| **-c, --colored**  | Set the output to be colored(may not work on some terminals)  |
| **-chars string, --characters string**  | Custom characters(low density to high)  |
| **-rt, --realtime**  | Play the video in real time  |

## Uninstall

`pip uninstall terminal-video-player-py`
aioscgi 2.3.1
An ASGI server that speaks SCGI.
Requires Python: >=3.11

What is aioscgi?
================

aioscgi is a container implementing the Asynchronous Server Gateway Interface
(ASGI_) to serve up asynchronous Web applications via the Simple Common Gateway
Interface protocol.


What is SCGI?
=============

SCGI is a protocol used for communication between HTTP servers and Web
applications. Compared to CGI, SCGI is more efficient because it does not fork
and execute a separate instance of the application for every request; instead,
the application is launched ahead of time and receives multiple requests
(either sequentially or concurrently) via socket connections. Compared to
FastCGI, SCGI is a much simpler protocol as it uses a separate socket
connection for each request, rather than including framing within a single
connection to multiplex requests (a feature which is rarely used in FastCGI
anyway due to the lack of per-request flow control).

See the Wikipedia_ and Python_ SCGI pages for more information.


How do I install it?
====================

aioscgi’s releases are published on PyPI for installation through pip. You can
run ``pip install aioscgi``.

For development, the source is available at GitLab_ and GitHub_.


How do I use it?
================

aioscgi installs an ``aioscgi`` executable. If your ASGI application callable
is named ``myapp`` and is in a file called ``mypackage/mymodule.py``, you might
run ``aioscgi --unix-socket /path/to/socket mypackage.mymodule:myapp``. For
full details on available options, run ``aioscgi --help``.


.. _ASGI: https://asgi.readthedocs.io/
.. _Wikipedia: https://en.wikipedia.org/wiki/Simple_Common_Gateway_Interface
.. _Python: http://www.python.ca/scgi/
.. _GitLab: https://gitlab.com/Hawk777/aioscgi
.. _GitHub: https://github.com/Hawk777/aioscgi
curator-evals 0.0.2
A package for evaluating coding curators
Requires Python: >=3.7

# Curator Evals

This is a package for evaluating coding curators.

## Installation

```bash
pip install curator-evals
```

## Usage 

```python
from curator_evals.code_curator_eval.evaluation_classification_code_curator import evaluate_model

evaluate_model(config_path="configs/code_curator_eval.yaml")
```

## Configuration

The configuration is done through a YAML file.

Example config: 

```yaml

model:
  name: "accounts/fireworks/models/llama-v3p3-70b-instruct"
  api_key: ${FIREWORKS_API_KEY}  # Environment variable reference
  base_url: "https://api.fireworks.ai/inference/v1"
  max_tokens: 2048
  temperature: 0

dataset:
  name: "collinear-ai/coding_curators_evaluation_dataset"
  splits: ["humanevalpack", "mbpp"]
  input_column: "instruction"
  output_column: "solution"
  label_column: "label"
  total_rows: 20

output:
  file: "../data/classification_humanevalpack_eval"
```

If no dataset is provided, the evaluation will be done on the default dataset, which is 
currently set to both splits of the `collinear-ai/coding_curators_evaluation_dataset`.

You can import the function and pass in the config path to evaluate the model.

```python
from curator_evals.code_curator_eval.evaluation_classification_code_curator import evaluate_model

evaluate_model(config_path="/home/tsach/curator-evals/configs/code_curator_eval.yaml")
```
malama 0.1.6
Universal document assistant using popular AI models (PDF, Word, Excel)
Requires Python: >=3.6

# 📁 Malama FileParse

**Malama FileParse** is a flexible and extensible framework for querying content from **PDF, DOCX, and Excel** files using **any large language model (LLM)** such as OpenAI, Gemini, Claude, Mistral, DeepSeek, and more.

> 🔍 Upload a file → Load context (optionally with page/range control) → Ask intelligent questions → Get accurate LLM-powered responses.

---

## ✨ Features

- ✅ Extracts content from **PDF**, **DOCX**, and **XLSX** files
- 📄 Supports full-document or partial (page-based) extraction for applicable formats
- 🤖 Works with **any LLM** by passing the desired model name
- 🔌 Easily extendable to new AI providers or formats
- 🧠 Unified prompt structure and clean response interface
- ⚙️ Minimal dependencies and easy integration

---

## 📂 Supported File Types

| File Type | Description                                             |
|-----------|------------------------------------------               |
| **PDF**   | Supports full and paginated text extraction             |
| **DOCX**  | Extracts paragraphs and tables in document order        |
| **XLSX**  | Reads sheet names and cell contents in readable format  |

---

## 🤖 Supported LLMs

Malama FileParse accepts **any valid model name** for the provider you configure.  
Here are some examples you can use out of the box:

| Provider         | Example Models (not restricted)                    |
|------------------|----------------------------------------------------|
| **OpenAI**       | `gpt-3.5-turbo`, `gpt-4`                           |
| **Gemini**       | `gemini-1.5-pro`, `gemini-1.0`                     |
| **Anthropic**    | `claude-3-sonnet`, `claude-3-opus`                 |
| **Groq**         | `llama3-70b-8192`, `mixtral-8x7b`                  |
| **Mistral**      | `mistral-medium`, `mistral-tiny`                   |
| **Cohere**       | `command-r`, `command-r-plus`                      |
| **DeepSeek**     | `deepseek-coder`, `deepseek-r1`                    |
| **Together.ai**  | `Qwen2-72B`, `Falcon-180B` *(via API key)*         |
| **Amazon Titan** | *(Coming Soon via Boto3 integration)*              |

You can pass **any model name** recognized by your chosen provider—no hardcoded restrictions.
Prefer your own model name to work around different models of LLM provider.

---

## 📦 Installation

```bash
pip install malama
pyxlmapper 0.0.2.4
Mapper and parser for hierarchical spreadsheets
Requires Python: >=3.8

# pyxlmapper
This library can help reading and mapping hierarchical .xlsx spreadsheets like this one:
![example image](./docs/example_main.png)

into data such as:
```json
[
  {
    "category": {
      "group_a": {
        "a": "...",
        "b": "..."
      },
      "group_b": {
        "c": "...",
        "d": "...",
      }
    },
    "lone_field": "...",
  },
  ...
]
```

Or this:
```json
[
  {
    "category.group_a.a": "...",
    "category.group_a.b": "...",
    "category.group_b.c": "...",
    "category.group_b.d": "...",
    "lone_field": "...",
  },
  ...
]
```

# Installation
WARNING: `PyPI` has no package yet. Name clame is pending: https://github.com/pypi/support/issues/5471
```sh
pip install pyxlmapper
```

# Usage
You can write your own mapper or use code generation to infer mapper automatically

## Writing and using mapper
`pyxlmapper` uses DSL based on python classes. First, you need to define a mapper class that
inherits `SpreadsheetMapper`. And then define all headers. Class nesting is resambling headers nesting
in the spreadsheet. You do not need to specify offsets manually, it will be calculated automatically,
considering that header are nested from top to bottom and column order is from left to right without gaps
(by default, but could be modified). For the example from above, the mapper would look like this:

```python
import json
import openpyxl
from pyxlmapper import SpreadsheetMapper


class Mapper(SpreadsheetMapper):
    class Category:
        class GroupA:
            class A:
                pass

            class B:
                pass

        class GroupB:
            class C:
                pass

            class D:
                pass

    class LoneField:
        pass



# Open spreadhseet:
wb = openpyxl.open('data.xlsx', data_only=True)
ws = wb['sheet name']  # or ws.active for the first one

# instantiate mapper:
mapper = Mapper()

data = []

for row in mapper.map_rows(ws, start_at=3):
    print(row)
    # OR
    data.append(row)

# Save a file
with open('output.json', 'w') as fd:
    fd.write(json.dump(data, fd))
```

## Syntax
### Class name
Class names are used to automaticaly derive `input_name` and `output_name` if not provided.
`input_name` would be derived as such: `SomeFieldName` into `Some Field Name`. `output_name` on the
other hand would be derived as `some_field_name`.

### `output_name` (str)
If specified, used as an override for the name of the field in the output JSON file.

Example:
```python
class Mapper(SpreadsheetMapper):
    class SomeField:
        output_name = "other_name"
```

### `input_name` (str)
If specified, used as an override for the column name in the xlsx spreadsheet.

Example:
```python
class Mapper(SpreadsheetMapper):
    class SomeField:
        input_name = "You can use ::any:: symbols"
```

### `offset` tuple[int, int]
Specifies an offset, relative to default position. Useful when some column or row is skipped

Format: `offset = (v_offset: int, h_offset: int)`

```python
class Mapper(SpreadsheetMapper):
    class SomeField:
        offset = (0, 1)  # To skip a column
```
pylevelframework 0.1.1
A Python-based command-line server with controller management
Requires Python: >=3.11

# PyLevel

A Python-based command-line server with controller management, configuration handling, and process management capabilities.

## Installation

1. Clone the repository:
```bash
git clone https://github.com/py-level/py-level.git
cd py-level
```

2. Install the package:
```bash
pip install -e .
```

## Quick Start

1. Start the server:
```bash
pylevel serve --port 8000 --workers 4
```

2. Create a controller:
```bash
pylevel make:controller UserController
```

3. Check server status:
```bash
pylevel status
```

For a complete list of commands and their options, see [COMMANDS.md](COMMANDS.md).

## Environment Variables

You can configure the server using environment variables prefixed with `PYLEVEL_`:

```bash
export PYLEVEL_PORT=8000
export PYLEVEL_WORKERS=4
export PYLEVEL_HOST=127.0.0.1
```

## Development

### Project Structure

```
slave/
├── __init__.py         # Package initialization
├── __main__.py        # Entry point
├── cli.py             # Command-line interface
├── config.py          # Configuration management
├── controllers.py     # Controller management
├── process.py         # Process management
└── app/
    └── controllers/   # Controller implementations
        └── base_controller.py
```

### Creating a Custom Controller

```python
from typing import Dict, Any
from slave.app.controllers.base_controller import BaseController

class UserController(BaseController):
    async def get(self, request: Dict[str, Any]) -> Dict[str, Any]:
        # Validate request
        rules = {
            'id': {'required': True, 'type': int}
        }
        if not self.validate(rules):
            return self.get_response()
            
        # Process request
        user_id = request['id']
        return self.success({'id': user_id, 'name': 'John Doe'})
```

## Documentation

- [Commands Documentation](COMMANDS.md) - Detailed information about all available commands
- [Contributing Guidelines](CONTRIBUTING.md) - Guidelines for contributing to the project
- [API Documentation](docs/API.md) - API reference and examples

## Contributing

1. Fork the repository
2. Create a feature branch
3. Commit your changes
4. Push to the branch
5. Create a Pull Request

## License

This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.