semvec/pypi-packages huggingface dataset:
min-distance 1.0.1
A simple Python package to calculate the minimum distance between two geographic points
Requires Python: >=3.6

# min_distance

[![PyPI version](https://img.shields.io/pypi/v/min_distance.svg)](https://pypi.org/project/min_distance/)
[![Python Version](https://img.shields.io/pypi/pyversions/min_distance.svg)](https://pypi.org/project/min_distance/)

Calculate the minimum distance between two geographic points (latitude and longitude) using the Haversine formula in Python.

---

## Features

- Simple and lightweight Python package
- Accurate distance calculation on Earth’s surface (in kilometers)
- Easy to integrate into any Python project
- Well-tested with unit tests included

---

## Installation

Install via pip:

```bash
pip install min_distance
```

---

## Usage

```python
from min_distance import calculate_min_distance

lat1, lon1 = 40.7128, -74.0060  # New York
lat2, lon2 = 51.5074, -0.1278   # London

distance_km = calculate_min_distance(lat1, lon1, lat2, lon2)
print(f"Distance: {distance_km:.2f} km")
```

---

## API Reference

### `calculate_min_distance(lat1: float, lon1: float, lat2: float, lon2: float) -> float`

Calculate the minimum distance between two points on the Earth specified by latitude and longitude.

- **Parameters:**
  - `lat1`, `lon1`: Latitude and Longitude of the first point in decimal degrees.
  - `lat2`, `lon2`: Latitude and Longitude of the second point in decimal degrees.

- **Returns:** Distance in kilometers as a `float`.

---

## Development

Want to contribute? Feel free to open issues or submit pull requests!

Run tests with:

```bash
python -m unittest discover -s tests
```

---

## License

This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.

---

## Author

Vansh  
[GitHub](https://github.com/vanshbhardwajhere) | [LinkedIn](https://linkedin.com/in/vanshbhardwajhere)
attendance-tool-msp 1.0.3
Automated attendance processing and reporting tool for MSP technical sessions.
Requires Python: >=3.10

# Attendance Tool - MSP

An easy-to-use Python package for automated attendance processing, validation, and professional report generation. Built mainly for Microsoft Student Partners Tech Club (MSP), but works for any technical session or event at Misr International University (MIU).

This package is heavily tested with pytest and clearly documented on Read the Docs. For more details, including example datasets and the full development journey, check out the repository.

## Features
- **CSV Attendance Processing:** Validate and process attendance sheets with robust error handling.
- **Data Validation:** Detects invalid records, missing fields, and edge cases.
- **Report Generation:** Export formatted attendance reports to Word and PDF.
- **Modern GUI:** Interactive, user-friendly interface built with CustomTkinter.
- **Command-Line Support:** Flexible CLI for batch processing and automation.
- **Extensible API:** Easily integrate into other Python projects.

## Installation
```bash
pip install attendance-tool-msp
```

## Usage

### CSV Format Requirements

Your CSV file **must** contain the following columns (headers):

- `Full Name`
- `University ID`
- `Course Code`
- `Course Time`
- `Doctor/TA Name`

These columns are required for successful processing. If any are missing or empty, the tool will raise an error and the file will not be processed.

> **Note:** Columns like `Timestamp` and `Email` are **not required**. The tool does not expect or require a timestamp column. The `University Email` column is only validated if present, but is not mandatory.


### Core Workflow: Processor + Exporter
Use `Processor` and `Exporter` together to process attendance data and generate reports:
```python
from attendance_tool_msp import Processor, Exporter

processor = Processor("data.csv")
valid_rows, invalid_rows = processor.process()

exporter = Exporter(valid_rows, invalid_rows, title="Session Report")
filename_word = exporter.export_word()
filename_pdf = exporter.export_pdf()
```

### Simple GUI Launch
If you prefer not to handle arguments or workflow, just launch the GUI with a single line:
```python
from attendance_tool_msp import launch_gui

launch_gui()
```

### Command-Line Integration
For CLI usage, use the argument parser helpers:
```python
from attendance_tool_msp import initialize_parser, validate_arguments

parser = initialize_parser()
args = parser.parse_args()
mode = validate_arguments(parser, args)
# Use mode to determine workflow (see documentation for details)
```

## Requirements
- Python 3.10+
- python-docx
- docx2pdf
- validators
- customtkinter
- pillow

## Documentation & Repository
- [Repository](https://github.com/mohamedelziat50/attendance-automation-MSP)
- [Documentation](https://attendance-automation-msp.readthedocs.io/)

## MIT License
For the most up-to-date license and project details, visit the [GitHub LICENSE](https://github.com/mohamedelziat50/attendance-automation-MSP/blob/main/LICENSE).
sortinpy 0.1.0
Pacote Python com vários algoritmos de ordenação e busca
Requires Python: >=3.6

````
# sortinpy

Python library providing a collection of classic sorting and searching algorithms implemented from scratch. Designed for educational purposes and practical use in Python projects.

## Installation

To install the package locally for development or usage, navigate to the project root folder (where `setup.py` is located) and run:

```bash
pip install -e .
````

This installs the library in editable mode, so any changes you make to the source code will reflect immediately.

## Usage

Import the specific sorting or searching function you need from `sortinpy` and use it on your lists.

Example with sorting algorithms:

```python
import sortinpy

lst = [5, 3, 2, 8, 1]

# Simple use returning just the sorted list
sorted_list = sortinpy.bubble_sort(lst)
print("Bubble Sort:", sorted_list)

# Using a function with optional statistics output
sorted_list, stats = sortinpy.shell_sort(lst, stats=True)
print("Shell Sort:", sorted_list)
print("Operation counts:", stats)
```

## Available Algorithms

### Sorting Algorithms

* **Bubble Sort** — simple, inefficient, good for learning
* **Insertion Sort** — simple, efficient on nearly sorted data
* **Selection Sort** — simple, always O(n²)
* **Merge Sort** — efficient, stable divide and conquer
* **Quick Sort** — efficient average case, recursive
* **Heap Sort** — efficient, in-place, uses heap data structure
* **Counting Sort** — efficient for integers in small range
* **Radix Sort** — non-comparative sort for integers
* **Shell Sort** — optimized insertion sort with gap sequence
* **Bogo Sort** — educational, randomized and very inefficient
* **Introsort** — hybrid of quicksort and heapsort for efficiency

### Searching Algorithms

* **Binary Search** — fast search on sorted lists
* **Linear Search** — simple search for any list
* **Lower Bound** — finds insertion position (left)
* **Upper Bound** — finds insertion position (right)

## Optional Statistics

Most sorting functions accept an optional boolean parameter (`stats=True`) that makes them return a tuple: the sorted list plus a dictionary containing counts of:

* Comparisons
* Swaps
* Assignments

This allows analyzing algorithm performance on given inputs.

## License

This project is licensed under the MIT License — see the [LICENSE](LICENSE) file for full details.

---

Created by wandsondev

```
```
py-return-success-or-error 0.6.1
A biblioteca `py-return-success-or-error` é uma solução robusta para tratamento de retornos e erros em aplicações Python, seguindo princípios de design limpo e arquitetura limpa.
Requires Python: >=3.13

<img src="https://py-return-success-or-error.readthedocs.io/pt-br/latest/assets/logo.png" width="200" height="200">

# py-return-success-or-error

## Instalação
```bash
pip install py-return-success-or-error
```

## Visão Geral

A biblioteca `py-return-success-or-error` é uma solução robusta para tratamento de retornos e erros em aplicações Python, seguindo princípios de design limpo e arquitetura limpa.

## Principais Componentes

### 1. Tratamento de Retornos
- `ReturnSuccessOrError`: Classe base para representar retornos de operações
- `SuccessReturn`: Representa operações bem-sucedidas
- `ErrorReturn`: Representa operações com erro

### 2. Tratamento de Erros
- `AppError`: Classe base para erros de aplicação personalizados
- `ParametersReturnResult`: Padronização de parâmetros com tratamento de erros

### 3. Casos de Uso
- `UsecaseBase`: Para casos de uso simples sem acesso a fontes de dados
- `UsecaseBaseCallData`: Para casos de uso com acesso a fontes de dados externas

## Recursos Principais

- Suporte a execução de casos de uso em threads separadas
- Tratamento genérico de erros e sucessos
- Tipagem forte e segura
- Padrões de design SOLID
- Suporte a fontes de dados externas

### Principais Características

- **Tratamento Explícito de Resultados**: Fornece uma abordagem clara para lidar com sucessos e erros em operações.
- **Design Orientado a Princípios SOLID**: Utiliza classes abstratas e genéricas para criar uma estrutura flexível e extensível.
- **Segurança de Tipos**: Implementa tipagem genérica para garantir consistência nos retornos.
- **Padrão Singleton**: Utiliza técnicas como singleton para gerenciar instâncias únicas.

### Benefícios

- Reduz a complexidade do tratamento de erros
- Melhora a legibilidade do código
- Facilita a manutenção e evolução de sistemas
- Promove uma arquitetura de software mais limpa e previsível

### Casos de Uso

Ideal para projetos que necessitam de:

- Tratamento consistente de operações que podem falhar
- Arquiteturas de software com alta necessidade de tratamento de erros
- Desenvolvimento de aplicações com requisitos complexos de fluxo de execução

A biblioteca oferece uma abordagem moderna e pythônica para gerenciar retornos de operações, tornando o código mais robusto e expressivo.
adhipk-ascii-art 0.1.0
A Python library for generating ASCII art from images with advanced filtering capabilities
Requires Python: >=3.11

# ASCII Art Library

A Python library for generating ASCII art from images with advanced filtering capabilities.

## Features

- Generate high-quality ASCII art from images
- Sprite-based character rendering for better visual results
- Edge detection using Difference of Gaussians (DoG) filtering
- Configurable character sets and rendering parameters
- Both programmatic API and command-line interface

## Installation

```bash
pip install -e .
```

## Usage

### Command Line Interface

Generate ASCII art from an image:

```bash
ascii-art input.jpg -o output.png
```

Customize edge detection sensitivity:

```bash
ascii-art input.jpg --edge-threshold 70 -o output.png
```

Disable edge detection:

```bash
ascii-art input.jpg --no-edge -o output.png
```

### Programmatic API

```python
from ascii_art import SpriteASCIIGenerator
import cv2

# Create generator with default settings (edge detection enabled)
generator = SpriteASCIIGenerator()

# Load and process an image
img = cv2.imread("input.jpg")
ascii_img = generator.generate_ascii(img)

# Save result
cv2.imwrite("output.png", ascii_img)
```

Customize settings:

```python
from ascii_art import SpriteASCIIGenerator
import cv2

# Create generator with custom settings
settings = {
    "use_edge": True,        # Enable edge detection (default: True)
    "edge_threshold": 70,    # Edge detection sensitivity (default: 90)
    "font_size": 8,          # Font size for characters (default: 8)
    "sharpness": 5,          # Image sharpness (default: 100)
    "white_point": 128       # White point threshold (default: 2)
}

generator = SpriteASCIIGenerator(settings)

# Load and process an image
img = cv2.imread("input.jpg")
ascii_img = generator.generate_ascii(img)

# Save result
cv2.imwrite("output.png", ascii_img)
```

### Configuration

You can customize the ASCII art generation by passing settings to the generator:

```python
settings = {
    "use_edge": True,        # Enable edge detection
    "edge_threshold": 90,    # Edge detection threshold
    "font_size": 8,          # Font size for characters
    "sharpness": 5,          # Image sharpness
    "white_point": 128       # White point threshold
}

generator = SpriteASCIIGenerator(settings)
```

## API Reference

### SpriteASCIIGenerator

Main class for generating ASCII art using sprite-based approach.

#### Methods

- `__init__(settings)`: Initialize the generator with settings
- `generate_ascii(img)`: Generate ASCII art from an image

### DoGFilter

Difference of Gaussians filter for edge detection.

#### Methods

- `__init__(settings)`: Initialize the filter with settings
- `difference_of_gaussian(image)`: Apply DoG filter to an image
- `flow_dog(image)`: Apply flow-based DoG filtering

## Requirements

- Python 3.11+
- OpenCV
- NumPy
- Pillow
- SciPy

## License

MIT
docx-comments-to-text 0.2.2
Extract reviewer comments from .docx files and insert them inline with the text
Requires Python: >=3.13
Keywords: docx, comments, document, text, review

# docx-comments-to-text

Extract reviewer comments from `.docx` files and insert them inline with the text they reference, creating a plain text output that keeps feedback in context.

## Installation

### From PyPI (recommended)
```bash
pip install docx-comments-to-text
```

### From source
```bash
# Clone the repository
git clone https://github.com/platelminto/docx-comments-to-text
cd docx-comments-to-text

# Install in development mode
uv sync --dev
# or: pip install -e .
```

## Usage

### Command Line Interface

```bash
# Basic usage - output to stdout
docx-comments-to-text document.docx

# Save to file
docx-comments-to-text document.docx -o output.txt

# Control author display
docx-comments-to-text document.docx --authors never    # Hide authors
docx-comments-to-text document.docx --authors always   # Always show authors
docx-comments-to-text document.docx --authors auto     # Show authors when multiple exist (default)

# Control comment placement
docx-comments-to-text document.docx --placement inline         # Inline with text (default)
docx-comments-to-text document.docx --placement end-paragraph  # At end of each paragraph
docx-comments-to-text document.docx --placement comments-only  # Comments only with context
```

### Development Usage

If working from source:
```bash
# Run with uv
uv run docx-comments-to-text document.docx

# Or use module syntax
uv run python -m docx_comments_to_text.cli document.docx
```

### Example Output

#### Inline placement (default)
```
Original text with [reviewer feedback] [COMMENT: "This needs clarification"] continues here.
More content [needs examples] [COMMENT John: "Consider adding examples"] and final text.
```

#### End-paragraph placement
```
Original text with reviewer feedback[1] continues here.
More content needs examples[2] and final text.

Comments:
1. This needs clarification
2. John: Consider adding examples
```

#### Comments-only placement
```
"reviewer feedback": This needs clarification
"needs examples": John: Consider adding examples
```

## Features

- Accurate comment positioning and text preservation
- Handles overlapping comments and multiple comment types  
- Configurable author display
- Multiple comment placement styles (inline, end-of-paragraph, comments-only)

## Technical Details

### DOCX Structure
- DOCX files are ZIP archives containing XML files
- `word/document.xml` - main document content
- `word/comments.xml` - comment definitions
- Comment ranges marked with `<w:commentRangeStart>` and `<w:commentRangeEnd>`

### Comment Insertion Strategy
1. Parse document XML to extract text and track character positions
2. Map comment ranges to their start/end positions in the text
3. Sort comments by position for safe insertion (reverse order)
4. Wrap commented text in brackets: `[commented text]`
5. Insert comment content after bracketed text: `[COMMENT: "feedback"]`

## Dependencies

- `python-docx` - DOCX file handling
- `lxml` - XML parsing
- `click` - Command line interface
edgar-httpx 0.1.3
Rate Limiting and Caching HTTPX Client for SEC Edgar Requests
Requires Python: >=3.09
Keywords: edgar, hishel, httpx, pyrate_limiter, sec

HTTPX Transports configured for Edgar SEC

[![PyPI Version](https://badge.fury.io/py/edgar-httpx.svg)](https://pypi.python.org/pypi/edgar-httpx)

[![BuildRelease](https://github.com/paultiq/edgar_httpx/actions/workflows/build_deploy.yml/badge.svg)](https://github.com/paultiq/edgar_httpx/actions/workflows/build_deploy.yml)
[![Tests](https://github.com/paultiq/edgar_httpx/actions/workflows/test.yml/badge.svg)](https://github.com/paultiq/edgar_httpx/actions/workflows/test.yml)
[![Coverage badge](https://github.com/paultiq/edgar_httpx/raw/python-coverage-comment-action-data/badge.svg)](https://github.com/paultiq/edgar_httpx/tree/python-coverage-comment-action-data)
pyrion 0.1.11
A fast and efficient bioinformatics library for genomic data processing
Requires Python: >=3.9
Keywords: bioinformatics, genomics, sequence-analysis, comparative-genomics, numpy, alignment, gene-annotation, liftover

# Pyrion

![PyPI version](https://img.shields.io/badge/version-0.1.11-blue)
![Python](https://img.shields.io/badge/python-3.9%2B-blue)
![License](https://img.shields.io/badge/license-MIT-green)
![Made with Cursor](https://img.shields.io/badge/Made%20with-Cursor-0066cc?style=flat&logo=cursor&logoColor=white)

Tools and abstractions for comparative genomics. Reliable, fast, and minimal-dependency tools 
for common genomics tasks without unnecessary overhead.

Pyrion includes tools for manipulating genomic intervals, genome alignments, and sequences.
It handles common formats like BED (6 or 12), chain, 2bit, and FASTA, and can also parse genePred and GTF annotations.

Work in progress: [plans](TODO.md).

## Installation

```bash
pip install pyrion
```

## Quick Start

See [demo.ipynb](demo.ipynb) for quick examples.

For a more advanced practical example, pls see [TOGA_mini](https://github.com/kirilenkobm/TOGA_mini) repo.

## API Reference

See [API_REFERENCE.md](API_REFERENCE.md) for the complete API documentation.

## License

MIT License - see [LICENSE](LICENSE) file for details.