semvec/pypi-packages huggingface dataset:
chunking-experiment 0.1.0
A package for experimenting with different data chunking strategies
Requires Python: >=3.10

# Chunking Experiment

[![codecov](https://codecov.io/gh/JohnnyTeutonic/ChunkingForPandas/branch/main/graph/badge.svg)](https://codecov.io/gh/JohnnyTeutonic/chunking_experiment)
[![Tests](https://github.com/JohnnyTeutonic/ChunkingForPandas/actions/workflows/test.yml/badge.svg)](https://github.com/JohnnyTeutonic/ChunkingForPandas/actions/workflows/test.yml)

A Python package to chunk pandas/numpy data with different chunking strategies.

## Requirements

- Python 3.10+
- Gradio
- pandas
- pytest
- numpy

## Installation

```bash
pip install chunking-experiment
```

Or:

```bash
make install
```

## Usage

```python
from chunking_experiment import ChunkingExperiment
```

## Create an instance of a Chunking class

```python
class_instance = ChunkingExperiment(
"input.csv",
"output.csv",
n_chunks=3,
chunking_strategy="rows"
)
```

Then perform the chunking:

```python
class_instance.process_chunks()
```

## Run the web interface

Go to the app folder and run the following command:

```python
from gradio_interface import launch_interface
launch_interface()
```

Alternatively, you can run the following command to start the web interface:

```bash
python gradio_interface.py
```

## Features

- Multiple chunking strategies (rows, columns, tokens)
- Support for CSV, JSON, Numpy and Parquet files
- Web interface using Gradio
- Comprehensive test suite
- Documentation using Sphinx
- Benchmarking the chunking strategies

## Development

To install development dependencies:

```bash
pip install -e .[dev]
```

Or:

```bash
make install-dev
```

## Testing

To run tests, run the following command from the root folder:

```bash
pytest
```

## Documentation

To install the documentation dependencies:

```bash
pip install -e .[docs]
```

Or:

```bash
make install-docs
```

To build the documentation:

```bash
make docs
```

To serve the documentation:

```bash
make docs-serve
```

Below are the full list of commands that can be run from the root folder:

```bash
make benchmark
make clean
make docs
make docs-clean
make docs-serve
make install
make install-docs
make lint
make run
make test
make typecheck
```

## License

This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
auto-scroller 0.1.2
A package for detecting hand gestures to control scrolling.
Requires Python: >=3.6

# Auto Scroller

**Auto Scroller** is a Python library for controlling screen scrolling using hand gestures. It leverages a webcam to track hand movements, detect the number of fingers raised, and scroll the screen accordingly.

---

## Features

- **Real-time Hand Tracking**: Uses MediaPipe for efficient hand tracking.
- **Gesture-Based Scrolling**:
  - **Two fingers raised**: Scrolls up.
  - **One finger raised**: Scrolls down.
- **Plug-and-Play**: Simply run the example script or integrate the library into your project.

---

## Installation

Install the library using pip:

```bash
pip install auto_scroller
```
vizexpln 0.1.0
Seamlessly combine the power of Jupyter Notebooks and AI to visualize, and interpret your data. A low-code tool for data visualization and interpretation
Requires Python: <4.0,>=3.12

## vizexpln

### Description

A low-code tool for data visualization and interpretation that seamlessly combines the power of Jupyter Notebooks and AI. It provides an intuitive user interface on notebook that enables users to create visualizations, and generate insights from their data. This makes your exploratory data analysis simple and fast. Powered with Gemini multi-model to generate insights from your visualizations 

### Installation

To install vizexpln using pip, run the following command:

```
pip install vizexpln
```

### Example Usage

Once package is installed, you can import the `VizUI` class and create an instance of it. The `VizUI` class takes a Pandas DataFrame as input and provides a user interface for creating visualizations, and generating insights.
To generate insights from your plot, create a Gemini API key and add it in .env file at your notebook folder

```.env
GOOGLE_API_KEY = <add your key>
THIS IS OPTIONAL, You can still make visualizations
```

```python
import pandas as pd
from vizexpln.UI import VizUI

# Load a Pandas DataFrame from a CSV file
df = pd.read_csv("abc.csv")

# Create an instance of the AnalysisUI class
ui = VizUI(df)

# Show the user interface
ui.show()
```
xml7shi 0.1.0
Simple XML parser without tag structure validation

# xml7shi

A pull-based simple and permissive XML parser for Python.

## Features

- Focuses on practical parsing rather than strict XML specification compliance
- No external dependencies

## Installation

```bash
pip install xml7shi
```

## Usage

```python
import xml7shi

# Parse XML string
xml = '''<?xml version="1.0" encoding="UTF-8"?>
<root>
  <item id="1">First item</item>
  <item id="2">Second item</item>
</root>'''

# Create reader instance
xr = xml7shi.reader(xml)

# Iterate through each 'item' element
for _ in xr.each("item"):
    id = xr["id"]
    # Read the content of the current element
    if xr.read():
        print(f"ID: {id}, Content: {xr.text}")
```

Notes:

- The reader instance `xr` is stateful; its internal state changes with each read operation

## API Reference

`xml7shi.reader`: Main parser class that reads XML content.

Methods:

- `read()`: Read next element
- `find(tag, **kwargs)`: Find next element matching tag and attributes
- `each(tag="", **kwargs)`: Returns a generator that iterates over elements matching the tag and attributes

Notes:

- `kwargs` is a dictionary of attribute names and values to match in the element. For example, `find("item", id="1")` will find the next `<item>` element with matching attributes

## Specifications

For detailed behavior, please refer to [examples/tag.py](examples/tag.py).

**Parser Behavior:**

- The parser is permissive and does not perform strict XML syntax checking
- The parser attempts to parse incomplete XML as much as possible

**Tag Processing:**

- Self-closing tags like `<tag/>` are treated as separate opening and closing tags, i.e., `<tag></tag>`.
- Tag names are converted to lowercase (case-insensitive)
- Tag hierarchy is not recognized; nested tags must be processed by the user

**Attribute Handling:**

- Attribute values can be processed with or without quotes (e.g., both `a=3` and `a="3"` are valid)
- Spaces between attribute names and values are allowed (e.g., `a = 3`)
- All attribute values are treated as strings

**Content Processing:**

- Text content is decoded using html.unescape() to handle HTML entities
- Comments are stored in the values dictionary with the `comment` key
- Comment tags are treated as empty tag names

## Developer Notes

For developers, it is recommended to use `pypa/build` and `pypa/installer` for building and installing this package.

**Building:**

```bash
pip install build
python -m build
```

This will generate wheel and source distribution files in the `dist` directory.

**Installing:**

```bash
pip install installer
python -m installer dist/*.whl
```

Alternatively, you can use `pip` to install the wheel file directly:

```bash
pip install dist/*.whl
```

Using these standard tools ensures a more reliable and reproducible build and installation process.