semvec/pypi-packages huggingface dataset:
typemapping 0.1.7
Advanced type compatibility and checking system for Python
License: MIT
Requires Python: >=3.8
Keywords: typing, type-checking, generics, variance, annotations

# 🧬 typemapping

**Advanced Type Compatibility and Runtime Checking for Python 3.8+**

`typemapping` is a powerful and extensible package for deep type introspection and runtime type validation. It goes far beyond Python's built-in `isinstance` and `issubclass`, supporting generic types, `Annotated`, `Union`, specialized collections, and more — with compatibility across Python 3.8+ including `typing_extensions` support.

---

## 🚀 Features

* ✅ Generic type compatibility (`List[int] ~ Sequence[int]`)
* 🧠 Concrete-to-abstract compatibility (`Counter`, `OrderedDict`, `ChainMap`)
* 🔁 Full `Union` and `Optional` type support
* 🛠️ Python 3.8+ `Annotated` compatibility layer
* 🧪 Runtime type validation with container sampling
* 🔍 Field and function argument mapping with `Annotated` metadata extraction
* 📦 Framework-friendly: works with FastAPI, Pydantic, SQLAlchemy, etc.

---

## 📦 Installation

```bash
pip install typemapping
```

> ⚠️ `typing_extensions` is required for full support on Python 3.8.

---

## 🧑‍💻 Example

```python
from typing import List, Annotated
from typemapping.type_check import extended_isinstance

# Check generic type compatibility
print(extended_isinstance([1, 2, 3], List[int]))  # True
print(extended_isinstance([1, 2, 3], List[str]))  # False
```

---

## 🧩 Key APIs

### 🔎 Type Checking & Compatibility

* `extended_isinstance(obj, type_hint)`
* `generic_issubclass(subtype, supertype)`
* `is_equal_type(t1, t2)`
* `defensive_issubclass(cls, classinfo)`

### 🧬 Annotated Type Handling

* `is_annotated_type(type)`
* `strip_annotated(type)`
* `get_annotated_metadata(type)`

### 🧠 Function and Class Introspection

* `get_func_args(func)`
* `map_model_fields(cls)`
* `map_dataclass_fields(cls)`
* `get_field_type(cls, fieldname)`

### 🔁 Origin Compatibility

* `is_equivalent_origin(t1, t2)`
* `get_equivalent_origin(t)`
* `is_fully_compatible(t1, t2)`
* `get_compatibility_chain(t)`

---

## ⚙️ Compatibility

* ✅ Python 3.8 and above
* 🔄 Backward-compatible via `typing_extensions`

---

## 🧪 Running Tests

```bash
pytest
```

---

## 📄 License

MIT License

---

## 🤝 Contributing

Contributions are welcome! Feel free to open issues or submit pull requests.
daqp 0.7.2
DAQP: A dual active-set QP solver
License: MIT

# DAQP
DAQP is a dual active-set solver that solves convex quadratic programs of the form
```
minimize        0.5 x' H x + f' x

subject to      l  <=  x  <= u
		bl <=  Ax <= bu.
```
Binary constraints of the form $A x \in \lbrace b_l, b_u \rbrace$ are also supported, allowing for mixed-integer quadratic programs to be solved.

The code is written in C and is *library free*. DAQP can be interfaced to C, Julia, MATLAB, and Python. 

See [Documentation](https://darnstrom.github.io/daqp/) for an installation guide and basic use of the interfaces. 

## Citing DAQP
```
@article{arnstrom2022dual,
  author={ArnstrÃ¶m, Daniel and Bemporad, Alberto and Axehill, Daniel},
  journal={IEEE Transactions on Automatic Control},
  title={A Dual Active-Set Solver for Embedded Quadratic Programming Using Recursive {LDL}$^{T}$ Updates},
  year={2022},
  volume={67},
  number={8},
  pages={4362-4369},
  doi={10.1109/TAC.2022.3176430}
}
```
sup 0.1.1
A Python package with Rust-based ripgrep implementation
License: MIT
Requires Python: >=3.13

# EXPERIMENT: DO NOT USE THIS OR DEPEND ON THIS

------------

A Python package with Rust-based ripgrep implementation using maturin. This package bundles the full ripgrep binary alongside a Python search API.

## Features

- **Bundled ripgrep binary**: Full ripgrep CLI built from source and included in the wheel
- **Python search API**: Native Python interface for searching
- **Built from source**: All binaries are compiled from source during wheel building
- **Zero runtime dependencies**: ripgrep binary is embedded, no system installation needed
- Python 3.13+ support
- Cross-platform wheels for Linux, macOS, and Windows

## Installation

```bash
pip install sup
```

## Development

### Prerequisites

- Python 3.13+
- Rust toolchain
- maturin

### Setup

```bash
# Clone the repository
git clone <your-repo-url>
cd sup

# Create virtual environment
python -m venv venv
source venv/bin/activate  # On Windows: venv\Scripts\activate

# Install development dependencies
pip install maturin pytest

# Build and install locally
maturin develop
```

### Testing

```bash
pytest tests/
```

### Building Wheels

```bash
# Build wheel for current platform
maturin build --release

# Build wheels for all platforms (via CI)
# Push to GitHub and CI will build wheels for all platforms
```

## Usage

### Python API

```python
from sup import search, RipGrep, ripgrep, get_ripgrep_path

# Simple search using Python API
results = search("pattern", "/path/to/search")
for match in results:
    print(f"{match['file']}:{match['line_number']}: {match['line']}")

# Using RipGrep class directly
rg = RipGrep(r"test\d+")  # Regex pattern
matches = rg.search("/path/to/file.txt")

# Using the bundled ripgrep binary
result = ripgrep("pattern", ".", "--type", "py")
print(result.stdout)

# Get path to the ripgrep binary (extracted to temp directory)
rg_path = get_ripgrep_path()
print(f"ripgrep binary available at: {rg_path}")
```

### Command Line

After installation, you can use the bundled ripgrep via:

```bash
# Use the sup-rg command (installed as console script)
sup-rg pattern /path/to/search

# Or invoke via Python
python -m sup pattern /path/to/search
```

## CI/CD

The project uses GitHub Actions to automatically build wheels for multiple platforms:
- Linux (x86_64, aarch64)
- macOS (x86_64, ARM64)
- Windows (x64, x86)

Wheels are built for Python 3.13 and published to PyPI on tagged releases.

## License

MIT
tscope 0.1.4
A simple Python oscilloscope for displaying 1-dim dynamic data in the command line
License: MIT
Requires Python: >=3.7
Keywords: oscilloscope, terminal, visualization, real-time, data

# TerminalScope

A very simple Python oscilloscope for displaying 1-dim dynamic data in the command line.

- Easy to integrate (no third-party libraries required)
- Support for multiple variables with different colors and symbols
- Lightweight and cross-platform compatibility (Windows, macOS, Linux, etc.)
- Typical use cases:
  - Accessing your Raspberry Pi via SSH and wanting to display sensor data in real-time
  - Debugging your motor PID controller and needing a simple graphical user interface

![screenshot](https://raw.githubusercontent.com/sszxc/TerminalScope/main/media/screenshot.png)

## Installation


### Requirements

- Python 3.7+
- No external dependencies
- Compatible with any terminal that supports ANSI color codes


### From PyPI
```bash
pip install tscope
```

### From Source
```bash
git clone https://github.com/sszxc/TerminalScope.git
cd TerminalScope
pip install -e .
```

## Quick Start

```python
import math
import time
from tscope import TerminalScope

# Create a scope with 3 variables
scope = TerminalScope(["sin(x)", "cos(x)", "ramp"], data_range=(-2, 2))

# Plot data
for i in range(100):
    x = i * 0.1
    scope.plot([math.sin(x), math.cos(x), x % 2 - 1])
    time.sleep(0.1)
```

## License

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