semvec/pypi-packages huggingface dataset:
sysmess 0.1.5
Fancy terminal message box renderer using Unicode box characters and ANSI styling
Requires Python: >=3.6

# sysmess

Fancy terminal message box renderer using Unicode box characters and ANSI styling.

Uses a dynamic string buffer for quick and snappy message rendering.

## Installation & Building

  ### Install Via PIP (Recomended)
  ```bash
  pip install sysmess
  ```

  ### Build From Source
  - Clone the repository `git clone https://github.com/canadaluke888/sysmess.git`

  - Build the extension in-place:

    ```bash
    python3 setup.py build
    ```

  - (Optional) Install into your current environment:
  
    - Create a virtual environment: `python3 -m venv .venv` (MacOS & Linux) | `python -m venv .venv` (Windows)

    - Activate virtual environment: `source .venv/bin/activate` (MacOS & Linux) | `.venv/Scripts/Activate` (Windows)

    - Install into current environment:

        ```bash
        pip install .
        ```

## Usage

```python
import sysmess

msg = sysmess.fancy_box(
    "Hello, world!",
    title="Greeting",
    center=True,
    bold=True,
    italic=False,
)
print(msg)

# Measure the width of the box (including borders)
width = sysmess.measure_box_width("Hello, world!", title="Greeting")
print(width)
```

# Use the "round" style for rounded corners
```python
msg = sysmess.fancy_box(
    "Rounded corners!",
    title="Round",
    style="round"
)
print(msg)
```

You can also specify colors for the border, title, and body:

```python
msg = sysmess.fancy_box(
    "Colored message",
    title="Colorful",
    border_color="magenta",
    title_color="cyan",
    body_color="yellow"
)
print(msg)
```

Supported color names: black, red, green, yellow, blue, magenta, cyan, white,
bright_black, bright_red, bright_green, bright_yellow, bright_blue,
bright_magenta, bright_cyan, bright_white.

## Word wrap & max width

By passing `wrap=True`, sysmess will wrap your message text to fit your terminal width (or a specific maximum width via `max_width`):

```python
import sysmess
long_text = "Lorem ipsum dolor sit amet, consectetur adipiscing elit..."
print(sysmess.fancy_box(long_text, wrap=True))
# Or specify a fixed max width:
print(sysmess.fancy_box(long_text, wrap=True, max_width=60))
```

## Blink support

You can make the border, title, or body text blink using the new blink flags:

```python
import sysmess
print(sysmess.fancy_box("Blinking border!", blink_border=True))
print(sysmess.fancy_box("Blinking title!", title="Hey", blink_title=True))
print(sysmess.fancy_box("Blinking body text!", blink_body=True))
```

### Output
![blink_example](assets/demo_video.mov)

## Examples

Once built (or installed), run the demonstration script to see sample outputs:

```bash
python3 examples.py
```

## Ouput

![sysmess_demo](assets/test_output.png)

## Testing

Run the unit tests using the included test runner:

```bash
python3 test.py
```
unicode-stats 0.3.3
Tool to analyze unicode content
Requires Python: >=3.6

# Unicode Stats

Fast analysis of Unicode symbols

Purpose: quickly detect hallucinations such as hieroglyphs and Ukrainian language in various benchmarks

Fast and convenient wrapper for https://www.unicode.org/Public/UNIDATA/Blocks.txt 

## Usage
### Extract Unicode Blocks / Detect Language
```python
from unicode_stats import unicode_block_parser

# Get all symbols
example_text = 'краї́中land'
print(unicode_block_parser.get_stats(example_text))
# > {'Cyrillic (Russian)': {'n': 3, 'symbols': 'арк'}, 'Cyrillic (Ukranian)': {'n': 1, 'symbols': 'ї'}, 'Combining Diacritical Marks': {'n': 1, 'symbols': '́'}, 'CJK Unified Ideographs': {'n': 1, 'symbols': '中'}, 'Basic Latin': {'n': 4, 'symbols': 'lnda'}}

# Get main language
example_text = 'краї́'
print(unicode_block_parser.get_lang(example_text))
# > Cyrillic (Ukranian)

# Get all languages
example_text = 'краї́'
print(unicode_block_parser.get_lang(example_text, return_main_lang=False))
# > ru,Cyrillic (Ukranian),Combining Diacritical Marks

unicode_block_parser.get_single_block("х")
# > Cyrillic (Russian)
```

### Generate Statistics for JSONL Files

**Python**

```python
from unicode_stats.aggregation import AggregatedUnicodeBlockParser
agregated_parser = AggregatedUnicodeBlockParser(columns = "qwen", max_lines=1)
agregated_parser.get_stats("3model_cp.jsonl")
```

|    | block   | column   |    n |   rate | symbols   |   n_symbols | rows   | example_first   | example_last   |
|---:|:--------|:---------|-----:|-------:|:----------|------------:|:-------|:----------------|:---------------|
|  0 | Cyrilic (Russian)   | qwen     | 2161 |  0.777 | оеаи      |       57234 | [0, 1  | Чтобы           | Для р          |
|  1 | Basic   | qwen     | 2778 |  1     | оеаи      |       57234 | [0, 1  | Чтобы           | Для р          |

**Bash**
```bash
unicode_stats 3model_cp.jsonl --columns="qwen"
```
> Aggregated statistics saved to 3model_cp.csv 

## Installation
```bash
pip install dist/unicode_stats-{version}-py3-none-any.whl
```

## Building from Source 
```bash
python -m build
```

If tests fail, the package will not build
## Running Tests
```bash
pytest
package-teste 0.0.1
teste
Requires Python: >=3.8

# package_teste

Description. 
The package package_teste is used to:
	- teste
	- teste

## Installation

Use the package manager [pip](https://pip.pypa.io/en/stable/) to install package_name

```bash
pip install package_teste
```

## Author
David Miranda

## License
[MIT](https://choosealicense.com/licenses/mit/)
gpuprefetch 0.1.0
Package for data prefetching on GPU.

# GPU prefetching
A minimal package for GPU prefetching from disk.

## Installation 🚀
```bash
pip install --upgrade pip uv
uv pip install gpuprefetch
```

## Usage 🔥
The snippet below show how to easily instantiate our prefetching.
```python
from gpuprefetch import Prefetcher

# By default, we do not install jax,
# you need to install it separately if you want to use our converter.
from gpuprefetch.converter import cupy_to_jax

def my_loader():
    # Replace with your real disk I/O
    return np.random.rand(64, 64, 3).astype(np.float32)

with Prefetcher(
    loader=my_loader,   # The callable loading the data
                        # (e.g., from disk)
    dtype=cp.float32,   # Type of data.
    shape=(64,64,3),    # Shape of the data for pre-allocation.
    capacity=100,       # Buffer size.
                        # The larger, the higher the memory
                        # consumption but the lower the latency.
    device="cuda:0",    # Where you want your data to be loaded.
                        # We currently support only cuda devices.
    post=cupy_to_jax,   # By default, we return a cupy array.
                        # You can use one of our efficient converters
                        # on the returned value, pass it as `post`
                        # argument, or pass a custom callable.
                        # We use it as: return post(data)
    nworkers=32,        # We spawn nworkers processes to concurrently
                        # fill the queue.
) as loader_with_prefetching:
    # Inside this block, the workers are active and they are safely
    # killed on exit.
    # You can access the pre-fetched data with:
    prefetched_data = next(loader_with_prefetching)
```

## Citation ☕️
If this was useful in your research software, you can cite this work as:
```bibtex
@software{terpin2025gpuprefetching,
  author       = {Terpin, Antonio},
  title        = {A minimal GPU prefetching package.},
  year         = {2025},
  version      = {1.0.0},
  url          = {https://github.com/antonioterpin/gpu-prefetch},
}
```