semvec/pypi-packages huggingface dataset:
entrance 1.1.21
Server framework for web apps

# EnTrance

[EnTrance](https://github.com/ensoft/entrance) is a framework for writing
simple but robust web apps, with a particular set of characteristics. It uses a
Python 3.5+ asyncio backend, and an Elm frontend, communicating over a
websocket.

This package provides the server-side functionality.

Reading the documentation and sample applications in [the primary
repo](https://github.com/ensoft/entrance) is recommended. Simple examples for
writing your own Python server-side feature are in [sample
2](https://github.com/ensoft/entrance/blob/master/samples/2_shell/svr/run.py)
and [sample
3](https://github.com/ensoft/entrance/blob/master/samples/3_browser/svr/run.py).

By default, the dependencies for this package cover the core functionality.
There is also a rich set of optional capability for interacting with routers,
that has a much more extended set of PyPi dependencies. If you want to use
this, then depend on `entrance[with-router-features]` rather than just `entrance`.
speak-tts 0.1.0
Voice cloning CLI for Mac using F5-TTS
Requires Python: >=3.10
Keywords: f5-tts, mlx, speech-synthesis, tts, voice-cloning

# speak-tts

Voice cloning CLI for Mac (Apple Silicon) using F5-TTS.

## Installation

### Via Homebrew

```bash
brew tap danielsinai/speak-tts
brew install speak-tts
```

### Via pipx

```bash
pipx install speak-tts
```

### Via pip

```bash
pip install speak-tts
```

## Requirements

- macOS with Apple Silicon (M1/M2/M3/M4)
- Python 3.10+

## Usage

### Add a Voice Profile

```bash
speak --add-profile daniel --voice ~/voice.wav --text-file ~/reference.txt
```

The reference audio should be a clear WAV recording (24kHz) of the voice you want to clone, and the text file should contain an exact transcript.

### Generate Speech

Plays audio directly (no file saved):

```bash
speak daniel "Hello, this is a test!"
```

Save to a file:

```bash
speak daniel "Hello world" --output ~/Desktop/hello.wav
```

### List Profiles

```bash
speak --list
```

### Play Audio

```bash
speak --play output.wav
```

## Profile Storage

Profiles stored in `~/.speak/profiles/<name>/` with:
- `reference.wav` - Voice sample
- `reference.txt` - Transcript

## Tips

- **Reference Audio**: 5-15 seconds, 24kHz, minimal background noise
- **Reference Text**: Exact transcript of the audio
- **First Run**: Downloads F5-TTS model (~1GB)

## Publishing

### 1. Publish to PyPI

```bash
# Install tools
pip install build twine

# Build and upload
./scripts/publish.sh
```

Or manually:

```bash
python -m build
twine upload dist/*
```

### 2. Set up Homebrew Tap

1. Create a new GitHub repo: `homebrew-speak-tts`

2. Copy the formula:
   ```bash
   cp Formula/speak-tts.rb ~/homebrew-speak-tts/
   ```

3. Get SHA256 after PyPI upload:
   ```bash
   shasum -a 256 dist/speak_tts-*.tar.gz
   ```

4. Update `sha256` in the formula, commit, and push

5. Users install with:
   ```bash
   brew tap YOUR_USERNAME/speak-tts
   brew install speak-tts
   ```

## Development

```bash
git clone https://github.com/danielsinai/speak-tts
cd speak-tts
python3 -m venv venv
source venv/bin/activate
pip install -e .
speak --help
```

## License

MIT
result-analysis 1.0.1
A CLI tool for managing student results from Excel sheets.
Requires Python: >=3.6

# Result Analysis (Class 12th CS Project)

A comprehensive Python application designed to analyze, manage, and visualize student examination results from Excel sheets. This project parses raw result data, organizes it, and provides tools for statistical analysis and graphical representation.

> Idea Given By Mam

## Features

- **📂 Excel Data Import:** Seamless parsing of result sheets with automatic detection of subjects, marks, and student details. Supports fuzzy search to quickly find Excel files in the directory.
- **📊 Data Visualization:** Generate insights using Bar Charts, Line Charts, and Scatter Plots to analyze class performance.
- **📈 Statistical Analysis:** Automatically calculates percentages and totals. Groups students based on custom or default percentage thresholds.
- **💾 Organized Storage:** Keeps processed data structured by Class and Exam name in a local `user-data` database (CSV format).
- **🖥️ Interactive Interface:** Features a user-friendly CLI menu with support for keyboard navigation (using `curses`) and a compatibility mode for standard terminals.
- **🗑️ Data Management:** Built-in tools to view and safely delete old class or exam records.

## Requirements

Ensure you have Python installed. The project relies on the following external libraries:

- `pandas` (Data manipulation)
- `numpy` (Numerical operations)
- `matplotlib` (Plotting graphs)
- `thefuzz` (Fuzzy string matching for file search)
- `openpyxl` (Excel file reading backend)

## Installation

You can install the package easily using pip:

```bash
pip install result-analysis
```

### From Source
1. Clone this repository.
2. Navigate to the project directory.
3. Install using pip:

   ```bash
   pip install .
   ```

   For development (editable mode), use:
   ```bash
   pip install -e .
   ```

   *Note: Windows users might need `windows-curses` for the full UI experience.*

## Usage

Once installed, you can run the application from anywhere using the main command or its shortcuts (`rsa`, `rta`):

```bash
result-analysis
# OR
rsa
# OR
rta
```

### Download Samples
To download sample Excel files for testing:
```bash
rsa download samples
```
This will create a `samples/` folder in your current working directory containing test data (`IIIA.xlsx`, etc.).

### Running the App
Alternatively, you can run it as a Python module:

```bash
python -m main
```

1. Place your raw Result Excel files (`.xlsx`) in the directory where you are running the command.
2. Follow the on-screen menu to:
   - **Upload:** Select and process an Excel file.
   - **Group:** Create summary statistics based on percentage ranges.
   - **View:** Display result tables in the terminal.
   - **Plot:** Visualize the data.
   - **Delete:** Remove unwanted data.

## Project Structure

- `main.py`: Entry point.
- `data/`: Data parsing and handling logic.
- `ui/`: User interface components.
- `graphs/`: Plotting and visualization logic.
- `group/`: Grouping logic.
- `user-data/`: Automatically generated directory where processed CSV files are stored, organized by Class and Exam.
envelopes-qc 0.0.9
Envelops impelemented by C++ and Python.
Requires Python: >=3.9

# envelopes-qc

High performance tools for building and decoding envelopes used in superconducting qubit experiments.

# Installation
```bash
pip install envelopes-qc
```
 Or
1. Cloning the repository to your machine.
2. Installing envelopes using pip locally by the following command:
```bash
python setup.py build_ext --inplace
```
or directly building package under the folder "site-package":
```bash
pip install .
```

# Usage
```python
from envelopes import evc, DRAG # evc (evp) is the envelopes module implemented by C++ (Python)
import numpy as np
# create an envelope
pi_pulse = DRAG(start=0, amp=1, length=30, alpha=0.5, nonlinearity=-0.2, mixing_freq=0.1, phase=0.0, profile='gaussian') # profile can be 'gaussian' or 'cosine'
amp = np.array([1, 0.3, 0.7, 0.8])
dt = np.array([0, 50, 100, 200])
xy = evc.align(pi_pulse, dt, amp) # align the envelope to the given dt and amplitude
# The following code has equivalent effect but undermine the efficiency:
# xy = 0
# for _dt, _amp in zip(dt, amp):
#     xy += (pi_pulse >> dt) * amp

# decode the envelope
resolution = 0.5
wc = evc.WaveCache(resolution)
# t, wave = evc.decode_envelope(xy, wc) default start and end defined by the envelope will be used
t_start, wave = evc.decode_envelope(xy, wc, start=-50, end=250)
wave = np.array(wave, copy=False) # convert vector wrapper to numpy array
t_list = np.arange(t_start, t_start+len(wave)*resolution, resolution)


import matplotlib.pyplot as plt
plt.figure()
plt.plot(t_list, wave.real, '.-', label='real')
plt.plot(t_list, wave.imag, '.-', label='imag')
plt.legend()
plt.xlabel('time')
plt.ylabel('amplitude')
plt.tight_layout()
plt.show()
```

## Supported Envelopes
See [tests/supported_envelopes.ipynb](./tests/supported_envelopes.ipynb).

## Speed test
See [tests/speed_test.ipynb](./tests/speed_test.ipynb).
teklia-yolo-worker 1.2.7
Ultralytics YOLO
Requires Python: >=3.10
Keywords: python

# YOLO

Ultralytics YOLO:
- https://github.com/ultralytics/ultralytics
- https://docs.ultralytics.com/tasks/

## Deployment

### Classifier

1. [Create a worker](https://doc.teklia.com/arkindex/workers/create/#create-a-worker) using the Arkindex frontend. You can set whatever name/slug/type. We'll use:
   - Name: `YOLO Classifier`
   - Slug: `yolo-classifier`
   - Type: `classifier`
2. [Import a new version](https://doc.teklia.com/arkindex/workers/create/#create-a-worker-version) for that worker with the following settings:
   - Docker image reference (from [this registry](https://gitlab.teklia.com/workers/yolo/container_registry/65)): `registry.gitlab.teklia.com/workers/yolo:1.0.7`
   - YAML configuration: Paste the contents of the [arkindex/yolo-classifier.yml](arkindex/yolo-classifier.yml) file found in this repository.

### Segmenter

1. [Create a worker](https://doc.teklia.com/arkindex/workers/create/#create-a-worker) using the Arkindex frontend. You can set whatever name/slug/type. We'll use:
   - Name: `YOLO Segmenter`
   - Slug: `yolo-segmenter`
   - Type: `image-segmenter`
2. [Import a new version](https://doc.teklia.com/arkindex/workers/create/#create-a-worker-version) for that worker with the following settings:
   - Docker image reference (from [this registry](https://gitlab.teklia.com/workers/yolo/container_registry/65)): `registry.gitlab.teklia.com/workers/yolo:1.0.7`
   - YAML configuration: Paste the contents of the [arkindex/yolo-segmenter.yml](arkindex/yolo-segmenter.yml) file found in this repository.


### Models

You can use freely available open-source models [provided by Ultralytics](https://docs.ultralytics.com/models/yolo-world/#available-models-supported-tasks-and-operating-modes):
1. Create a directory where you'll download a model: `mkdir yolo-model`
2. Download model weights using one of the links from the webpage above, and rename it `model.pt`:
```
curl -L https://github.com/ultralytics/assets/releases/download/v8.2.0/yolov8s-world.pt > yolo-model/model.pt
```
3. Write a `.arkindex.yml` with the following content, updating the `name` to match your model:
```yaml
version: 2

models:
  - path: yolo-model
    name: YOLOv8s-Monde
```
4. Upload the model using [Arkindex CLI](https://cli.arkindex.org/arkindex_cli/models/): `arkindex models publish`
5. The model is now available on your Arkindex instance!


## Development

For development and tests purpose it may be useful to install the worker as a editable package with pip.

```shell
pip install -e .
```

### Linter

Code syntax is analyzed before submitting the code.\
To run the linter tools suite you may use pre-commit.

```shell
pip install pre-commit
pre-commit run -a
```

### Run tests

Tests are executed with tox using [pytest](https://pytest.org).

```shell
pip install tox
tox
```

To recreate tox virtual environment (e.g. a dependencies update), you may run `tox -r`