semvec/pypi-packages huggingface dataset:
rsyncy 2.1.0
A status/progress bar for rsync.


# rsyncy (python version)

A status/progress bar for [rsync](https://github.com/WayneD/rsync).

![gif of rsyncy -a a/ b](https://raw.githubusercontent.com/laktak/rsyncy/readme/readme/demo-y.gif "rsyncy -a a/ b")


## Status Bar

```
[########################::::::]  80% |      19.17G |      86.65MB/s | 0:03:18 | #306 | scan 46% (2410)\
```

The status bar shows the following information:

Description | Sample
--- | ---
Progress bar with percentage of the total transfer | `[########################::::::]  80%`
Bytes transferred | `19.17G`
Transfer speed | `86.65MB/s`
Elapsed time since starting rsync | `0:03:18`
Number of files transferred | `#306`
Files to scan/check<br>- percentage completed<br>- (number of files)<br>- spinner | `scan 46% (2410)\`

The spinner indicates that rsync is still checking if files need to be updated. Until this process completes the progress bar may decrease as new files are found.


## Installation

See https://github.com/laktak/rsyncy


## Usage

`rsyncy` is a wrapper around `rsync`.

- You run `rsyncy` with the same arguments as it will pass them to `rsync` internally.
- Do not specify any `--info` arguments, rsyncy will automatically add `--info=progress2` and `-hv` internally.

```
# simple example
$ rsyncy -a FROM/ TO
```
alumath-kheoml 0.1.1
A matrix operations library developed by alumath_kheoml group at African Leadership University
Requires Python: >=3.6

# alumath_kheoml

A Python library for matrix operations developed at African Leadership University. This package provides matrix operations and was created as part of a machine learning course.

## Installation

You can install the package directly from PyPI:

```bash
pip install alumath_kheoml
```

## Usage

### Basic Matrix Operations

```python
import numpy as np
from alumath_kheoml import Matrix, matrix_multiply

# Create matrices
A = Matrix(np.array([[1, 2], [3, 4]]))
B = Matrix(np.array([[5, 6], [7, 8]]))

# Matrix multiplication using function
C = matrix_multiply(A.data, B.data)
print(C)

# Matrix multiplication using Matrix class method
D = A.multiply(B)
print(D)

# Matrix multiplication using @ operator
E = A @ B
print(E)

# Transpose
F = A.transpose()
print(F)
```

### Working with Different Matrix Dimensions

```python
import numpy as np
from alumath_kheoml import Matrix

# Create matrices of different dimensions
A = Matrix(np.array([[1, 2, 3], [4, 5, 6]]))  # 2x3
B = Matrix(np.array([[7, 8], [9, 10], [11, 12]]))  # 3x2

# Multiply them
C = A @ B  # Should result in a 2x2 matrix
print(C)

# This will fail due to incompatible dimensions
try:
    D = B @ A
except ValueError as e:
    print(f"Error: {e}")
```

## Authors

- Group 4 [kheoML] - ALU ML Course
n2k 0.5.0
Library to communicate with NMEA2000 devices.
Requires Python: >=3.11
Keywords: NMEA2000, CAN

# NMEA2000
NMEA2000 library for Raspberry Pi. Fork of https://github.com/ttlappalainen/NMEA2000

This library is still in an alpha state and is currently missing support for the following:

- several messages (as noted by the `todo` comments in [n2k/messages.py](n2k/messages.py)
- testing for the included messages
- support for transport protocol messages
- support for group functions
- proper logging
- good documentation. For now only the expected values for the messages are documented

The interface for creating messages will likely change in the future.

## Installing the library
If you want to use this library for a project, simply install it via pip:

```bash
pip install n2k
```


## Contributing

### Setup dev environment
First make sure you have python installed.

Then run
```bash
./prepare.sh
source .venv/bin/activate
```
to setup your virtual environment, install dependencies and setup pre-commit hooks.

If you choose to use VS Code as your editor, there are some extension recommendations that will automatically show up, as well as some pre-configured workspace settings.

### Build Documentation
```bash
cd docs && make clean && make html
```

### Build and publish package
```bash
python -m build && twine upload dist/*
```
python-luca-bds 1.0.1
This library provides a set of tools for interacting with the LUCA BDS API. It allows you to perform queries and execute operations in the LUCA environment using secure connections
Requires Python: >=3.9
Keywords: LUCA BDS, Data, Analytics

# LUCA BDS

[LUCA BDS](https://luca-bds.com/) is a business intelligence platform designed to centralize access to all your company's information, empowering users with real-time data analysis and visualization tools for informed decision-making. This library provides a set of tools for interacting with the [LUCA BDS](https://luca-bds.com/) API. It allows you to perform queries and execute operations in the LUCA environment using secure connections.

## Installation

You can install the library via PyPI. Make sure to have Python installed on your machine, then run:

```bash
pip install python-luca-bds
```

## Usage

Below is an example of how to use the LUCA BDS client to connect to the server and test some functionality:

```python
from luca.connectors import LucaConnector
from luca.querys import query

# LUCA connection configuration
luca_conn = LucaConnector(
    server_url='https://luca-bds-domain/luca-api',
    username='user',
    password='pass'
)

# Retrieve connection information
info = luca_conn.info()
print(info)

# Execute a query by name
result, pag, state = query(
    conn=luca_conn,
    name='Prueba',
    environment='DES'
)
print(result)

# Execute a query by ID
result, pag, state = query(
    conn=luca_conn,
    id=364,
    environment='DES',
    input_variables=[{'Usuario': 'luca', 'Sistema': 'LUCA'}]
)
print(result)
print(pag)
print(state)
```
claude-transcript 1.0.0
Convert Claude Code JSONL sessions to readable markdown transcripts
Requires Python: >=3.8

# Claude Transcript

Convert Claude Code JSONL session files to readable markdown transcripts with the exact same output as the physical-sessions command.

## Installation

### Install as a tool (recommended)

```bash
uv tool install claude-transcript
```

### Install in current environment

```bash
uv add claude-transcript
# or
pip install claude-transcript
```

## Usage

```bash
# Basic usage
claude-transcript session.jsonl

# Custom output filename
claude-transcript session.jsonl -o custom_name.md

# Upload to GitHub Gist after generation
claude-transcript session.jsonl --upload-gist

# Show help
claude-transcript --help
```

## Features

- **Exact output compatibility**: Produces the same markdown format as Claude Code's built-in physical-sessions command
- **Zero dependencies**: Pure Python with no external dependencies
- **Comprehensive parsing**: Handles all JSONL entry types including tool operations, sidechains, and timing information
- **GitHub Gist integration**: Optional upload to share transcripts easily
- **Tool operations display**: Shows detailed information about file edits, searches, and other actions taken during the session

## Example Output

The tool generates clean, readable markdown transcripts that include:

- Session metadata and timing information  
- Conversational turns with user requests and assistant responses
- Detailed tool operation logs (file edits, searches, bash commands, etc.)
- Parallel task execution details from sidechains
- Professional formatting suitable for documentation or sharing

## Requirements

- Python 3.8 or higher
- No external dependencies required
- Optional: GitHub CLI (`gh`) for gist upload functionality

## Development

This tool is built as a standalone script with PEP 723 inline dependencies, making it easy to run directly with `uv run` or package as a proper Python package.

## License

MIT License - see LICENSE file for details.