semvec/pypi-packages huggingface dataset:
boron-parallax 1.0.4
The World's First Timeline-Oriented Programming Language
Requires Python: >=3.10

# Parallax

**The World's First Timeline-Oriented Programming Language.**

Parallax is an experimental interpreted programming language that introduces quantum superposition as a first-class data type. Rather than utilizing iterative loops to determine optimal solutions, Parallax enables developers to split the execution timeline, filter for desired states, and collapse the results into deterministic outputs.

---

## Features

* **Superposition:** Variables can exist in multiple states simultaneously. A single variable assignment can spawn branching execution paths.
* **Entanglement:** State history is strictly preserved. Operations on superposed variables propagate across all active timelines automatically.
* **Declarative Pruning:** The `select` keyword allows for the declarative termination of timelines that fail to meet specific logical criteria, effectively optimizing the solution space without manual iteration.
* **VS Code Integration:** Includes full support for the Visual Studio Code environment, featuring custom syntax highlighting and file icon themes.

---

## Installation

The core language compiler and interpreter can be installed directly via pip:

```bash
pip install boron-parallax

```

---

## Quick Start: The Optimization Paradigm

In Parallax, optimization is not achieved through iteration, but through the simultaneous exploration of all possible states. Below is an example demonstrating manufacturing optimization logic.

```javascript
// 1. Initialization
// Create a variable 'speed' that exists in 10 distinct states simultaneously.
let speed = superpose 1, 2, 3, 4, 5, 6, 7, 8, 9, 10

// 2. Execution
// Perform business logic. This mathematical operation executes across
// all 10 timelines instantly and independently.
let quality = 11 - speed
let profit = speed * quality

// 3. Pruning (Timeline Selection)
// Apply constraints to the system. We only retain timelines where
// the 'quality' metric exceeds 5. All other timelines are discarded.
select quality : value > 5

// 4. Observation
// Observe the remaining survivors in the 'profit' variable.
observe profit

// Output:
// The system returns the distribution of valid profit values
// from the surviving timelines (e.g., 10, 18, 24, 28, 30).

```

---

## Usage

### File Execution

To run a Parallax script file:

```bash
prlx script.prlx

```

### Interactive REPL

To launch the Read-Eval-Print Loop for real-time experimentation:

```bash
prlx

```

**Example Session:**

```text
Parallax REPL — superpositional reality online
Type 'exit' to quit
>> let x = superpose 10, 20
>> observe x * 2
OBSERVED: 20: 50.0% | 40: 50.0%

```

---

*Parallax is built using Python and the Lark parsing library.*

```
rust-sasa-python 0.7.2
An ultra-fast package for computing Solvent Accessible Surface Area (SASA/ASA) for proteins
Requires Python: >=3.11

# rust-sasa-python

A high-performance **Python library** for computing SASA (Solvent Accessible Surface Area) using Rust as the backend. This library provides a clean, Pythonic interface to the fast RustSASA calculation engine.

## Features

- 🦀 **Powered by [RustSASA](https://github.com/maxall41/RustSASA)**: Leverages Rust's performance and safety.
- ⚡️ **Ludicrous Speed**: **63X** faster than Biopython, **5X** faster than Freesasa.
- 🐍 **Pythonic Interface**: Clean, intuitive API.
- 🔧 **Configurable**: Customizable probe radius and sampling points.
- 📁 **PDB and mmCIF SUPPORT**: Supports both PDB and mmCIF files.

## Installation

```bash
pip install rust-sasa-python
```

## Quick Start

```python
import rust_sasa_python as sasa

# Simple calculation - use convenience function
result = sasa.calculate_protein_sasa("protein.pdb")
print(f"Total SASA: {result.total:.2f}")

# Builder pattern for more control
calculator = (sasa.SASACalculator("protein.pdb")
              .with_probe_radius(1.2)
              .with_n_points(2000))
result = calculator.calculate_protein()
print(f"Total SASA: {result.total:.2f}")
print(f"Polar SASA: {result.polar:.2f}")
print(f"Non-polar SASA: {result.non_polar:.2f}")
```

See [DOCS](https://github.com/maxall41/rust-sasa-python/blob/main/DOCS.md) for more information and API reference.

## Contributing

Contributions are welcome! Please feel free to submit issues and pull requests.

## License

This project is licensed under the MIT License.

## Related Projects

- [RustSASA](https://github.com/maxall41/RustSASA) - The core Rust library.
- [DPXRust](https://github.com/maxall41/DPXRust) - Rust library for DPX calculations.
veracityLabAuthZ 0.2.0
Shared Cedar authorization helpers for Veracity services.
Requires Python: >=3.10

# veracityLabAuthZ

Shared Cedar authorization helpers for Veracity services.

## Local development

```bash
pip install -e packages/veracityLabAuthZ
```

## Cedar evaluation (cedarpy)

```bash
pip install -e "packages/veracityLabAuthZ[cedarpy]"
```

```python
from veracity_authz import CedarClient, CedarPyConfig, CedarPyEngine
from veracity_authz.context_builder import build_request

policies = """permit(principal, action, resource);"""
entities = []

engine = CedarPyEngine(CedarPyConfig(policies=policies, entities=entities))
client = CedarClient(engine)

request = build_request(
  principal={"type": "User", "id": "user-1"},
  action={"type": "Action", "id": "workspace:read"},
  resource={"type": "Workspace", "id": "ws-1"},
)

decision = client.evaluate(request)
print(decision.allowed)
```

## Tests

```bash
python -m unittest discover -s packages/veracityLabAuthZ/tests
```

## Publishing (PyPI)

GitHub Actions is configured to publish to PyPI using trusted publishing.
PyPI project page (used for the GitHub Actions environment URL): https://pypi.org/p/veracitylabauthz

Manual publish from the repo root (user API token):

```bash
# optional: clean old artifacts
rm -rf packages/veracityLabAuthZ/dist

# build tooling
python -m pip install --upgrade pip build twine

# optional: run tests
python -m unittest discover -s packages/veracityLabAuthZ/tests

# build
python -m build packages/veracityLabAuthZ

# publish (PyPI)
export TWINE_USERNAME="__token__"
export TWINE_PASSWORD="<pypi-api-token>"

python -m twine upload --repository pypi packages/veracityLabAuthZ/dist/*
```

Notes:
- Create a PyPI API token in your PyPI account settings and use it for `TWINE_PASSWORD`.
- Each publish must use a new version; bump `version` in `packages/veracityLabAuthZ/pyproject.toml` before rebuilding.
- For CI, configure a trusted publisher in PyPI for this repo and workflow.
nxdk-pgraph-test-runner 0.1.19
Executes and captures the results of https://github.com/abaire/nxdk_pgraph_tests in an emulator
Requires Python: >=3.10
Keywords: nv2a, pgraph, xbox, xemu

# nxdk-pgraph-test-runner

[![PyPI - Version](https://img.shields.io/pypi/v/nxdk-pgraph-test-runner.svg)](https://pypi.org/project/nxdk-pgraph-test-runner)
[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/nxdk-pgraph-test-runner.svg)](https://pypi.org/project/nxdk-pgraph-test-runner)

-----

## Table of Contents

- [Installation](#installation)
- [Configuration](#configuration)
- [License](#license)

## Purpose

This test harness utilizes
the [nxdk_pgraph_tests](https://github.com/abaire/nxdk_pgraph_tests) project to
exercise the NV2A 3D accelerator on the original Microsoft Xbox. The runner is
intended to be used with an emulator (e.g., [xemu](https://xemu.app)) and is
able to detect and recover from crashes.

## Installation

### Prerequisites

* An xbox emulator (e.g., [xemu](https://xemu.app)) - required

### pip installation

```console
# Optionally create a virtual env
#   pip -m venv .venv
#   source .venv/bin/activate

pip install nxdk-pgraph-test-runner

nxdk-pgraph-test-runner --help
```

## Configuration

A default config may be generated by running the `nxdk-pgraph-test-runner`
command.

### Emulator command line

`"emulator_command = /path/to/emulator {ISO}"`

The command may utilize the following macros:

* `{ISO}` - Replaced with the path to the `nxdk_pgraph_tests.iso` xiso file.

### Example invocation

This is a sample invocation that will run xemu against a previously downloaded
nxdk_pgraph_tests iso. It will create a `results` directory with the results of
the tests.

```shell
nxdk-pgraph-test-runner \
    --override-ftp-ip 10.0.2.2 \
    --iso-path ~/nxdk_pgraph_tests_xiso.iso \
    --emulator-command "/path/to/xemu -dvd_path \"{ISO}\"" \
    -I lo0
```

This assumes that xemu is configured to use NAT networking, so the IP reported
to the pgraph tester is set to the qemu `10.0.2.2` host address and the loopback
interface (-I `lo0`) is used.

## License

`nxdk-pgraph-test-runner` is distributed under the terms of
the [MIT](https://spdx.org/licenses/MIT.html) license.
textual-searchable-selectionlist 0.0.6
Add search to Textual SelectionList.

# Searchable SelectionList
[![image](https://img.shields.io/pypi/v/textual-searchable-selectionlist.svg)](https://pypi.python.org/pypi/textual-searchable-selectionlist)
[![Project License - MIT](https://img.shields.io/pypi/l/textual-searchable-selectionlist.svg)](./LICENSE.txt)

Add search to Textual's [SelectionList](https://textual.textualize.io/widgets/selection_list/).

* Selectable items can be filtered by substring.
* Select one or multiple items.
* Search is case-insensitive.
* Title and description can be customized.

## Installation
```bash
pip install textual-searchable-selectionlist
```

## Usage
```python
from textual_searchable_selectionlist.options import SelectionStrategy
from textual_searchable_selectionlist.select import select, select_enum

selected = select(
    ['John', 'Jane', 'James'],
    selection_strategy=SelectionStrategy.MULTIPLE,
    search_title='Select people',
)

# Enums
# class Color(Enum):
#     RED = 'red'
#     GREEN = 'green'
#
# selected_colors = select_enum(Color, selection_strategy=SelectionStrategy.ONE)
```

## Events and callbacks
Use `selected_callback` when embedding the widget, or listen for the
`SearchableListWidget.Selected` message in your app.

```python
from textual.app import App, ComposeResult
from textual_searchable_selectionlist.options import SelectionStrategy
from textual_searchable_selectionlist.searchable_list_widget import SearchableListWidget


class MyApp(App):
    def compose(self) -> ComposeResult:
        yield SearchableListWidget(
            "Alpha",
            "Beta",
            "Gamma",
            selection_strategy=SelectionStrategy.ONE,
            selected_callback=self._on_selected_callback,
        )

    def _on_selected_callback(self, selected: list[str]):
        self.log(f"Callback selected: {selected}")

    def on_searchable_list_widget_selected(
        self, event: SearchableListWidget.Selected
    ):
        self.log(f"Event selected: {event.selected}")
```

## Testing
There are currently no automated tests. Manual testing can be done by running:
```bash
python tests/manual/searchable_selection_list_select.py
```
lanraragi-api 0.9.60.2
A Python library for LANraragi API.

# lanraragi-api

A Python library for [LANraragi](https://github.com/Difegue/LANraragi) API.

> Many thanks to the author of this wonderful manga server.



## Quick start

Install this package:

```shell
pip install lanraragi_api
```

Get metadata of a random archive:

> See [demo.py](demo.py)

```python
from lanraragi_api import LANraragiAPI
from lanraragi_api.base.archive import Archive

apikey = 'your-key'
server = 'http://127.0.0.1:3000'
api = LANraragiAPI(server, key=apikey)

archives: list[Archive] = api.search.get_random_archives()
print(archives[0])
```



## How to use?

All the APIs in the `lanraragi_api.base` package are
from [the official LANraragi document](https://sugoi.gitbook.io/lanraragi/api-documentation/getting-started), which you will be using in most times.

Functions in the `lanraragi_api.enhanced` package are built on the base APIs, offering useful functionalities.

- `server_side.py` contains server-side functions. The code is the same to that of LANraragi, only translated from Perl to Python.
- `script.py` contains functions for operation and management.



## Release versions

Every release of lanraragi-api is made only for the corresponding release of LANraragi. So you should choose the correct lanraragi-api version based on the server version.

| LANraragi  | lanraragi-api                            |
| ---------- | ---------------------------------------- |
| `v.0.9.0`  | `0.9.0.0`, `0.9.0.1`, ... , `0.9.0.x`    |
| `v.0.9.40` | `0.9.40.0`, `0.9.40.1`, ... , `0.9.40.y` |

In order to make it simple, the first three version numbers are always the same, while the last version number of lanraragi-api serves as patches (just choose the latest one).



## Development

Python version: 3.10

Code formatter: default setting of [VS Code's Black Formatter extension](https://marketplace.visualstudio.com/items?itemName=ms-python.black-formatter)
autodoc_ai 3.0.0
[DEPRECATED] AI-powered documentation generation - use GitHub Copilot or Claude Code instead
Requires Python: <3.13,>=3.10

# autodoc_ai

> **DEPRECATED**: This project is no longer maintained. The functionality it provides is now better served by modern AI coding assistants.

[![PyPI](https://img.shields.io/pypi/v/autodoc_ai)](https://pypi.org/project/autodoc_ai/)

## Alternatives

| Tool | Commit Messages | Doc Updates | Integration |
|------|-----------------|-------------|-------------|
| [GitHub Copilot](https://github.com/features/copilot) | Yes | On request | Native GitHub |
| [Claude Code](https://claude.ai/code) | Yes | Yes | CLI |
| [Cursor](https://cursor.sh) | Yes | Yes | IDE |
| [Aider](https://aider.chat) | Yes | Yes | CLI |

## Why Deprecated?

When autodoc_ai was created in 2024, AI-powered documentation tools were scarce. Now:

- **GitHub Copilot** suggests commit messages natively
- **Claude Code / Cursor** update docs conversationally with full codebase context
- **Aider** provides similar git-integrated AI assistance

These tools offer better UX, deeper integration, and active maintenance.

## Final Version

v3.0.0 is the final release. It will:
- Show deprecation warnings on import
- Remain installable for existing users
- Receive no further updates or security patches

## Migration

Replace `autodoc_ai` usage with:

```bash
# Instead of: autodoc_ai
# Use Claude Code:
claude "update the README based on recent changes"

# Or Cursor/Copilot in your IDE
```

## License

MIT
mindstorms-net 0.1.0
Python package to connect LEGO EV3 and 51515 via ESP32/BLE/serial
Requires Python: >=3.5

# mindstorms-net

**mindstorms-net** allows Python code on LEGO EV3 and LEGO 51515 (SPIKE Prime) to communicate via ESP32 bridge.

- Event-based API
- JSON message protocol
- MicroPython headless ESP32 bridge
- EV3 & SPIKE examples included
Encorsa-e-Factura 0.4.8
A small example package
Requires Python: >=3.8

# Encorsa-e-Factura

## Description

 * Project Description:
 * 
 * This project aims to download invoices from the ANAF portal for clients and input them into WEBCON through an API. 
 * The download and upload parameters are received as arguments in the library.



## Features

- [List the main features of your project.]

## Installation

[Provide instructions on how to install and set up your project.]

For instructions on how to install and set up WEBCON, please refer to the [WEBCON Installation documentation](file:///.../e-Factura-PythonLibrary/DEV/WEBCON%20Installation%20documentation).

## Usage

[Explain how to use your project, including any necessary commands or configurations.]

## Contributing

[Provide guidelines for contributing to your project, if applicable.]

## License

[Specify the license under which your project is distributed.]

## Contact

encorsa.ro
messy-xlsx 0.7.2
A Python library for parsing messy Excel files with intelligent structure detection and formula evaluation
Requires Python: >=3.10
Keywords: data-extraction, excel, pandas, parser, spreadsheet, xlsx

# messy-xlsx

[![Tests](https://github.com/ivan-loh/messy-xlsx/actions/workflows/test.yml/badge.svg)](https://github.com/ivan-loh/messy-xlsx/actions/workflows/test.yml)
[![PyPI version](https://badge.fury.io/py/messy-xlsx.svg)](https://badge.fury.io/py/messy-xlsx)

Parse Excel files (XLSX, XLS, CSV) to pandas DataFrames with structure detection and normalization.

## Install

```bash
pip install messy-xlsx

# Optional: formula evaluation
pip install messy-xlsx[formulas]

# Optional: legacy .xls support
pip install messy-xlsx[xls]
```

## Usage

```python
from messy_xlsx import MessyWorkbook, SheetConfig, read_excel

# Quick read
df = read_excel("data.xlsx")

# With options
df = read_excel("data.xlsx", sheet="Sheet1", skip_rows=2, normalize=False)

# Workbook API
with MessyWorkbook("data.xlsx") as wb:
    df = wb.to_dataframe(sheet="Sheet1")
    all_dfs = wb.to_dataframes()  # All sheets
    structure = wb.get_structure()

# From bytes (S3, cloud storage)
import io
wb = MessyWorkbook(io.BytesIO(content), filename="data.xlsx")
```

## Configuration

```python
config = SheetConfig(
    # Row handling
    skip_rows=0,
    header_rows=1,
    skip_footer=0,
    cell_range=None,              # "A1:F100"

    # Detection
    auto_detect=True,
    header_detection_mode="smart", # "smart", "auto", "manual"
    header_confidence_threshold=0.7,

    # Parsing
    merge_strategy="fill",        # "fill", "skip", "first_only"
    include_hidden=False,
    locale="auto",                # "auto", "en_US", "de_DE"

    # Normalization
    normalize=True,
    normalize_dates=True,
    normalize_numbers=True,
    normalize_whitespace=True,

    # Formulas
    evaluate_formulas=True,
)

wb = MessyWorkbook("data.xlsx", sheet_config=config)
```

## Multi-Sheet

```python
from messy_xlsx import read_all_sheets, analyze_excel

# Read all sheets
results = read_all_sheets("data.xlsx")
for name, df in results.items():
    print(f"{name}: {len(df)} rows")

# Analyze without loading
info = analyze_excel("data.xlsx")
for sheet in info:
    print(f"{sheet.name}: {sheet.row_count} rows, {sheet.column_count} cols")
```

## Output

Output is compatible with BigQuery/Arrow. Mixed-type columns are coerced to strings.

## Dependencies

- Python >= 3.10
- fastexcel >= 0.11
- openpyxl >= 3.1
- pandas >= 2.0
- numpy >= 1.24

Optional:
- formulas, xlcalculator (formula evaluation)
- xlrd (XLS support)

## License

MIT