semvec/pypi-packages huggingface dataset:
ucow 0.3.0
A Cowgol compiler for 8080/Z80 CP/M
Requires Python: >=3.8
Keywords: 8080, compiler, cowgol, cpm, z80

# ucow

A Python-based Cowgol compiler targeting Z80 CP/M.

## Usage

### Single File Compilation

```bash
# Compile a Cowgol source file to Z80 assembly
python3 -m src.main source.cow -o output.mac

# Assemble with um80
um80 output.mac

# Link with ul80
ul80 output.rel -o output.com
```

### Multi-File Compilation

Compile multiple Cowgol source files together in a single compiler run:

```bash
# Compile all modules together into one assembly file
python3 -m src.main main.cow utils.cow math.cow -o program.mac

# Assemble and link
um80 program.mac
ul80 program.rel -o program.com
```

This approach enables **workspace optimization**: the compiler analyzes the call graph across all modules to determine which subroutines can never be active simultaneously. Subroutines that don't overlap in the call tree share local variable storage, significantly reducing data segment size.

For example, if `sub_a` and `sub_b` each use 100 bytes of locals but never call each other, they share the same 100 bytes instead of using 200 bytes total.

Use `--graph-debug` to see the call graph analysis:

```bash
python3 -m src.main --graph-debug main.cow lib.cow -o output.mac
```

## Include Paths

Use `-I` to add directories to the include search path:

```bash
python3 -m src.main -I ./lib -I ./include source.cow -o output.mac
```

## Compiler Options

| Option | Description |
|--------|-------------|
| `-o OUTPUT` | Output assembly file name |
| `-I PATH` | Add include search path |
| `-O0` | Disable optimization |
| `--no-post-opt` | Disable post-assembly optimization |
| `--graph-debug` | Show call graph analysis |
| `--tokens` | Dump tokens and exit |
| `--ast` | Dump AST and exit |

## Requirements

- Python 3
- um80 (Z80 assembler)
- ul80 (linker)
- cpmemu (for testing)
BAGLE 1.0.3
BAGLE (Bayesian Analysis of Gravitational Lensing Events) is a package to model and fit microlensing events.
Requires Python: >=3.11

# BAGLE: Bayesian Analysis of Gravitational Lensing Events

BAGLE allows modeling of gravitational microlensing events both photometrically and astrometrically. Supported microlensing models include:

- PSPL: point-source, point-lens with (and without) parallax
- BSPL: binary-point-source, point-lens
- PSBL: point-source, binary-point-lens
- FSPL: finite-source, point-lens (minimal support... not well tested yet)
     
All models support fitting data with single or multi-band photometry only, astrometry only, or joint fitting of photometry and astrometry (recommended).

## Documentation
The documentation to the BAGLE code can be found [here](https://bagle.readthedocs.io/en/latest/)

## Installation Instructions

### Install required modules:
Before you can use BAGLE, you will need to install the following modules:

    pip install numpy
    pip install astropy
    pip install matplotlib 
    pip install celerite 
    pip install ephem
    pip install pymultinest
    pip install Pyerfa
    pip install pytest 
    pip install joblib
      
### Install BAGLE from pip or conda (users) or GitHub (developers)
Preferred (on conda-forge):

    conda install BAGLE

or 

    pip install BAGLE

or 

    git clone https://github.com/ninjab3381/BAGLE_Microlensing.git

Test your install by opening python and running:

    import bagle

## Tutorial
A Jupyter Notebook tutorial to see some examples of how to use the code can be found [here](./BAGLE_TUTORIAL.ipynb)

## Developers
After installation of BAGLE source, navigate to the BAGLE_Microlensing folder:

    cd BAGLE_Microlensing/      
      
Then run the tests using the following commands in the BAGLE_Microlensing folder:

    python3 -m pytest tests
      
or you can run the testing scripts individually:
      
    python3 -m pytest tests/test_model.py
    python3 -m pytest tests/test_model_fitter.py
    python3 -m pytest tests/testingmodels.py
heracles-ql 0.2.0
heralces-ql VictoriaMetrics DSL
Requires Python: >=3.11

# HeraclesQL - A Python DSL for writing VictoriaMetrics Queries

### 🚧 HeraclesQL is available now, but this repo is still under construction! 🚧

HeraclesQL is a Python package which provides a type-safe embedded domain specific language for
writing VictoriaMetrics MetricsQL queries.

Highlights include:
  - MetricsQL-like syntax - HeraclesQL will be immediately familiar to anyone who's written MetricsQL or PromQL!
  - Custom Functions and Parameterizable Expressions - No more copy and pasting behavior between alerts!
  - Static Type Safety - MyPy and your editor will catch common problems before they occur!
  - Variables - Complicated alerts can be expressed imperatively!
  - Meta-alerts - Generate alerts about your alerts to avoid common pitfalls!

## Installation

HeraclesQL is available on PyPi. Just `pip install heracles-ql`

HeraclesQL depends on native code in a few places. Right now, we provide binaries for `manylinux_2_34_x86_64`.

Otherwise, we provide an sdist that includes the native source code. In order to build the sdist, you'll need a
modern Go compiler.

## Example

HeraclesQL lets you write MetricsQL queries as Python. For example,

```python
from heracles import ql

v = ql.Selector()

my_query = ql.rate(v.my_interesting_metric(useful="label")[5 * ql.Minute])

print(ql.format(my_query.render()))

# rate(my_interesting_metric{useful="label"}[5m])
```
fluidsim-core 0.9.0
Pure-Python core library for FluidSim framework
Requires Python: >=3.11

FluidSim Core
=============

Pure-Python core library for [FluidSim](https://fluidsim.readthedocs.io)
framework. This package provides generic base classes and utilities to
build new solvers.

**Documentation**:
<https://fluidsim.readthedocs.io/en/latest/generated/fluidsim_core.html>