semvec/pypi-packages huggingface dataset:
sund 2.2.3
A simulation toolbox for ODE and DAE systems, with focus on systems biology applications.
Requires Python: >=3.10
Keywords: sund, simulation, ODE, DAE, modeling, toolbox, systems biology

# SUND toolbox

<img src="https://gitlab.liu.se/ISBgroup/projects/sund/-/raw/main/logo/SUND_logo.png"
     alt="SUND logo"
     style="max-height:300px;width:100%;width:auto;display:block;margin:0 auto 1rem;" />

SUND (Simulation Using Nonlinear Dynamic models) is a Python package for high‑level, object‑oriented modeling and fast simulation of ODE/DAE systems with complex time‑dependent inputs and hierarchical model structures. Models compile against a SUNDIALS backend for performance and can be seamlessly connected by declaring inputs and outputs.

Supported Python: 3.10–3.14 on Linux (x86_64), Windows (x86_64) and macOS (Intel & ARM).

## Requirements

A C++ compiler (GCC, Clang, or MSVC) is required to install SUND and to compile models for efficient simulations. Pre-built wheels are not provided, as model compilation is performed locally. Ensure your system has a working C++ compiler before installing.

## Install

Install using `pip` or `uv` (requires compiler):

```bash
pip install sund   # or: uv add sund
```

## Quick start

Minimal end‑to‑end example:

```python
import sund

# 1. Generate a template model file
sund.save_model_template("example_model.txt", model_name="Example")

# 2. Install (compiles → C extension module under sund/models)
sund.install_model("example_model.txt")

# 3. Load an instance
model = sund.load_model("Example")

# 4. Simulate (time vector in model time unit; default from template is 's')
sim = sund.Simulation(models=[model], time_vector=[0, 1, 2, 3], time_unit=model.time_unit)
sim.simulate()

# 5. Get the results as a dict and print
print(sim.features_as_dict())
```

See the docs for activities (time‑varying inputs), multiple models, events, validation.

## Documentation

Full user & API docs: <https://isbgroup.eu/sund-toolbox> (versioned; latest alias always points to newest release).

## Model validation (optional)

Validate a model file or content before installing:

```python
import sund
results = sund.validate_model_file("example_model.txt", verbose=True)
```

## Citation

If you use SUND in academic work, please cite the project (formal citation text will be added once available).

## Getting help

Open an issue or start a discussion on the project GitLab. Bug reports with a minimal reproducer and model snippet are appreciated.
udft 4.0.0
Unitary discrete Fourier Transform (and related)
Requires Python: >=3.12
Keywords: fft, orthonormal

# UDFT: Unitary Discrete Fourier Transform (and related)

![licence](https://img.shields.io/github/license/forieux/udft) ![pypi](https://img.shields.io/pypi/v/udft) ![status](https://img.shields.io/pypi/status/udft) ![version](https://img.shields.io/pypi/pyversions/udft) ![maintained](https://img.shields.io/maintenance/yes/2025) [![Documentation Status](https://readthedocs.org/projects/udft/badge/?version=latest)](https://udft.readthedocs.io/en/latest/?badge=latest)

This module implements unitary discrete Fourier transform, that is orthonormal
`det(F) = 1` and `F⁻¹ = F^*`. This module existed before the introduction of the
`norm="ortho"` keyword and is now a very (very) thin wrapper around libraries.

It is useful for convolution [1]: they respect the Perceval equality, e.g., the
value of the null frequency is equal to `1/√N * ∑ₙ xₙ`.

```
[1] B. R. Hunt "A matrix theory proof of the discrete convolution theorem", IEEE
Trans. on Audio and Electroacoustics, vol. au-19, no. 4, pp. 285-288, dec. 1971
```

There is also functions related to Fourier and convolution like `ir2fr`.

UDFT use [array API standard](https://data-apis.org/array-api/latest/). Thanks
to this last point, any array library that follow the standard (`Numpy`,
`PyTorch`, `cupy`, ...) can be used by `udft` that use their respective
namespace.

If you are having issues, please let me know

francois.orieux AT universite-paris-saclay.fr

## Installation and documentation

UDFT is just the file `udft.py` and depends on
[array-api-compat](https://data-apis.org/array-api-compat/) and numpy only and
therefor is compatible with `numpy`, `pytorch`, `jax`, `cupy`...

The API is simple and opinionated for good reason. If you need more parameters
or options, I simply encourage you to directly use API of your array library.

Documentation is [here](https://udft.readthedocs.io/en/stable/index.html). I
recommend using [poetry](https://python-poetry.org/) or
[uv](https://docs.astral.sh/uv/) for installation

```
   poetry add udft
```
or
```
   poetry add udft[scipy]
```
For a quick and dirty installation, just copy the `udft.py` file: it is quite
stable, follow the [Semantic Versioning](https://semver.org/spec/v2.0.0.html),
and futur major changes are unlikely.

The code is hosted on [GitHub](https://github.com/forieux/udft).

## License

The code is in the public domain.
alphaticks-data 0.1.0
Add your description here
Requires Python: >=3.12

# alpha-data-py
## A client to fetch data from the alphaticks data base

### Installation

You can install alpha-data-py using the following command:
```shell
pip install alpha-data-py
```

### Usage

In order to use the library, you need an API key from alphaticks. Go to [alphaticks.io](https://alphaticks.io),
Account -> Licenses -> AlphaData and click on **Add credentials**.

Now that you have your credentials ready, you can create a client, fetch a security, and fetch the data you need for 
that security.

```py
import datetime
from adata import Client, FREQ_1M

c = Client(API_KEY, API_SECRET)
secs = c.get_securities()
for s in secs:
    if s.symbol == "BTCUSDT" and s.exchange == "fbinance":
        sec = s

start = datetime.datetime(2022, 1, 1)
end = datetime.datetime(2022, 1, 5)
it = c.get_historical_ohlcv(sec, FREQ_1M, start, end)
while it.next():
    print(it.o, it.h, it.l, it.c, it.v)
```
pyaml-cs-oa 0.1.1
PyAML control system plugin for ophyd-async
Requires Python: >=3.11
Keywords: Accelerator, Commissioning, Digital Twin, EPICS, Operation, Synchrotron, Tango, Tuning

# `pyaml-cs-oa`

**PyAML control system plugin for ophyd-async**

`pyaml-cs-oa` is a plugin for `PyAML` based on `ophyd-async`, which
currently supports EPICS and Tango control systems.

---

## 🔧 Installation

### **Requirements**

- Python **3.11+**

- Depending on your runtime environment, you may want to install support for EPICS or Tango.

### **EPICS CA/PVA Support**

```
pip install pyaml-cs-oa[epics]
```

This installs:

- `ophyd-async[ca,pva]`

### **Tango Support**

```
pip install pyaml-cs-oa[tango]
```

This installs:

- `ophyd-async[tango]`

---

## 🧪 Developer Installation

If you are contributing, debugging, or running the test suite (no test
currently provided):

```
pip install pyaml-cs-oa[dev]
```

This installs:

- `ophyd-async[ca,pva]`
- `ophyd-async[tango]`
- `pre-commit`
- `ruff`
- `mypy`
- `pytest`

### Setup pre-commit hooks

```
pre-commit install
```
desilang 1.0.3
A Hinglish programming language for Indians 🇮🇳
Requires Python: >=3.6

# 🇮🇳 DesiLang (देसी-Lang) for Data Science 📊

**DesiLang** is a powerful, Hinglish programming language designed for Indians. It is now optimized for **Data Analysis**, making it the first "Desi Pandas" for coding.

Created by **Avinash Walton**.

## 🚀 Key Features
- **Hinglish Syntax:** Code naturally using words like `bol` or `bolo`.
- **Data Analysis Ready:** Read CSVs, filter data (`chano`), and calculate stats (`ausat`, `jodo`) easily.
- **Flexible:** Use `bol` or `bolo`, `chano` or `chhano`, `gin` or `gino` – everything works!
- **Logic Support:** Full support for `agar-warna` (If-Else) and `jab tak` (Loops).

## 📦 Installation

Ab DesiLang ko install karna bahut aasaan hai! Terminal mein bas ye likhein:

```
pip install desilang
```


## 🏃 How to Run (Kaise Chalayein)

### Method 1: Direct Command (Best for Users) 🚀
Ek baar install karne ke baad, aap seedha desilang command use kar sakte hain:

```
desilang examples/analyst.desi
```

### Method 2: Source Code (For Developers) 🛠️
Agar aapne code download kiya hai, toh aise bhi chala sakte hain:

```
python -m desilang.main examples/analyst.desi
```


## 📚 Documentation (Syntax Guide)

### 🗣️ Basic Commands
| Command | Alternate | Meaning | Example |
| :--- | :--- | :--- | :--- |
| **bol** | **bolo** | Print / Show | `bolo "Namaste!"` |
| **mano** | - | Variable / Assign | `mano x = 10` |
| **pooch** | - | Input | `mano naam = pooch "Naam?"` |
| **ruko** | - | Sleep (Wait) | `ruko 2` (Wait 2 sec) |
| **safai** | - | Clear Screen | `safai` |

### 📊 Data Analysis (New!)
| Command | Usage | Example Code |
| :--- | :--- | :--- |
| **kholo** | Read CSV File | `mano data = kholo("sales.csv")` |
| **chano** / **chhano** | Filter Data (SQL WHERE) | `chano(data, "city == 'Delhi'")` |
| **jodo** | Sum of Column | `mano total = jodo(data, "price")` |
| **ausat** | Average of Column | `mano avg = ausat(data, "price")` |
| **gin** / **gino** | Count Rows/Items | `mano count = gin(data)` |

### 🧠 Logic Control
| Command | Meaning | Example |
| :--- | :--- | :--- |
| **agar** | If Condition | `agar x > 5` |
| **warna** | Else Condition | `warna` |
| **bas** | End If Block | `bas` |
| **jab tak** | While Loop | `jab tak x < 10` |
| **khatam** | End Loop | `khatam` |



## 🧪 Example Code (```analyst.desi```)
```

safai
bol "--- DATA LOADING ---"
mano sales = kholo("examples/sales.csv")

bol "--- ANALYSIS ---"
mano delhi_data = chano(sales, "city.strip() == 'Delhi'")
bol delhi_data

mano total = jodo(sales, "price")
bol "Total Sales:"
bol total

mano total_rows = gino(sales)
bol "Total Rows:"
bol total_rows
```


## 📜 License
This project is licensed under the MIT License - free to use and modify.
nice_duration 1.1.0
Nice formatting of timedelta instances
Requires Python: >=3.11

# nice_duration

A Python library for formatting durations in a human-readable way. Convert `timedelta` objects or numeric time values into readable strings like `3h20m` or `2w5d`. This module features optional micro-second precision, configurable separators and flexible handling of zero-values.

## Quick Start

```python
from datetime import timedelta
from nice_duration import duration_string

# From timedelta objects
duration_string(timedelta=timedelta(hours=3, minutes=20))  # "3h20m"

# From seconds (int or float)
duration_string(seconds=200)    # "3m20s"
duration_string(seconds=200.9)  # "3h20m" (truncated)

# From milliseconds or microseconds
duration_string(milliseconds=1500)  # "1s" (with default precision)
duration_string(microseconds=1500000)  # "1s"
```

## Precision Control
Control the smallest unit displayed. The `precision` parameter can be one of `weeks`,
`days`, `hours`, `minutes`, `seconds`, `milliseconds` or `microseconds`.

```python
delta = timedelta(weeks=2, days=3, hours=4, minutes=5, seconds=30, microseconds=500000)

duration_string(timedelta=delta, precision="weeks")        # "2w"
duration_string(timedelta=delta, precision="minutes")      # "2w3d4h5m"
duration_string(timedelta=delta, precision="seconds")      # "2w3d4h5m30s"
duration_string(timedelta=delta, precision="milliseconds") # "2w3d4h5m30s500ms"

```

## Flexible Zero Handling
By default, zero values are omitted, but zeroes can be left alone when leading, trailing or infix.

```python
delta = timedelta(days=3, minutes=12)  # Note: no hours

duration_string(timedelta=delta)                          # "3d12m"
duration_string(timedelta=delta, infix_zeroes=True)       # "3d0h12m"
duration_string(timedelta=delta, leading_zeroes=True)     # "0w3d12m"
duration_string(timedelta=delta, trailing_zeroes=True)    # "3d12m0s"
duration_string(timedelta=delta, all_zeroes=True)         # "0w3d0h12m0s"
```

##  Custom Separators
Add spacing or custom separators between units:

```python
delta = timedelta(hours=3, minutes=20)

duration_string(timedelta=delta, separator=" ")     # "3h 20m"
```

## Limitations

- Maximum unit is weeks (because bigger units have no fixed length)
- Float values are truncated

## License

This project is licensed under the MIT License.
si-units 0.11.1
Representation of quantites, i.e. of unit valued scalars and arrays.
Requires Python: >=3.9

# si-units

[![documentation](https://img.shields.io/badge/docs-github--pages-blue)](https://itt-ustutt.github.io/quantity/index.html)
[![PyPI version](https://badge.fury.io/py/si_units.svg)](https://badge.fury.io/py/si_units)

Representation of quantities with SI units.

The package is written with flexibility in mind and is able to represent arbitrarily complex units.
In addition to simple scalar quantities, it can be used to decorate any complex data type (numpy arrays, PyTorch tensors) to provide unit checks.

## Installation and Usage

You can install the package from PyPI

```
pip install si-units
```

For the documentation, see [here](https://itt-ustutt.github.io/quantity/index.html).

To build the wheel or documentation locally, see below.

## Examples

Calculate the pressure of an ideal gas.

```python
from si_units import *
temperature = 25.0 * CELSIUS
volume = 1.5 * METER**3
moles = 75.0 * MOL
pressure = moles * RGAS * temperature / volume
print(pressure) # 123.94785148011941 kPa
```

`numpy` functions can be used with SI units:

```python
from si_units import *
import numpy as np
ms = np.linspace(2.0, 4.0, 3) * METER
sqms = ms**2
print(sqms) # [4, 9, 16] m²
```

## Building from Source

You need a rust compiler to build the wheel locally.
To build the bindings to python, we use [maturin](https://github.com/PyO3/maturin).

Use

``` bash
# in si-units
maturin develop --release
```

to build the package locally.

To build the python wheels, use

```bash
maturin build --release
```

## Building the Documentation

To build the documentation you need `mkdocs-material` and `mkdocstrings-python`. Installing these packages (e.g. using `uv` or `pip`) will also install the needed dependencies. 
During development, use

```bash
# in si-units
mkdocs serve
```

to run a local development server.

To build the documentation for deployment, use

```bash
# in si-units
mkdocs build
```