semvec/pypi-packages huggingface dataset:
soroban-abacus 0.1.0
A Soroban abacus implementation
Requires Python: >=3.10
Keywords: abacus, soroban

# Soroban Abacus

> A simple Soroban abacus supporting positive integers.

## Installation

```bash
uv venv --pytnon=3.14
uv pip install soroban-abacus
```

## Usage

```python
from soroban import Soroban

abacus = Soroban(ncolumns=5)
print(abacus)

0: ●○ | ○○○○
1: ●○ | ○○○○
2: ●○ | ○○○○
3: ●○ | ○○○○
4: ●○ | ○○○○

abacus.from_decimal(17)
print(abacus)

0: ○● | ●●○○
1: ●○ | ●○○○
2: ●○ | ○○○○
3: ●○ | ○○○○
4: ●○ | ○○○○

abacus.to_svg("soroban1.svg")
```

![](./images/soroban1.svg)


```python
from soroban import Soroban

s = Soroban(12)
s.from_decimal(1234567890)
s.to_svg("soroban2.svg")
```

![](./images/soroban2.svg)
morsaik 0.1.4
Sequence Motif Reactor Simulation, Analysis and Inference Kit.
Requires Python: <4.0,>=3.10

README
======

Welcome to the Motif Reactor Simulation, Analysis and Inference Kit (``morsaik``) repository.

Introduction
------------

In order to investigate RNA reactors as candidates for the origins of life,
efficient simulations are needed
because the space of possible RNA sequences increases exponentially with the length of the strands,
as well as the number of reactions between two strands.
In addition, simulations have to be compared to experimental data for validation and parameter calibration.
Here, we present the ``morsaik`` python package for sqeuence motif (or k-mer) reactor simulation, analysis and inference.
It enables users to simulate RNA sequence motif dynamics in the mean field approximation
as well as to infer the reaction parameters from data
with Bayesian methods and to analyze results by computing observables and plotting.
``morsaik`` simulates an RNA reactor by following the reactions and the concentrations of all strands inside up to a certain length (of four nucleotides by default).
Longer strands are followed indirectly, by tracking the concentrations of their containing sequence motifs of that maximum length.

For a more detailed introduction,
please go to the demos_.

.. _demos: https://github.com/joharkit/morsaik/tree/main/demos

For an overview of the package and its aim,
please refer to the paper_ or the documentation_.

.. _paper: https://github.com/joharkit/morsaik/tree/main/paper
.. _documentation: https://joharkit.github.io/morsaik

Installation
------------

You can install ``morsaik`` from PyPI

.. code-block:: shell

    pip install morsaik

Alternatively, clone the repository from source, go into the directory and install it via ``pip``:

.. code-block:: shell

    git clone https://github.com/joharkit/morsaik.git
    cd morsaik
    pip install .

Contribution
------------

You are very welcome to contribute to this package.
Please open an issue and send a PR with your changes.
Please remember to upgrade the docs and the manual if needed
and adjust the test pipeline, adding new tests eventually.
In case of any questions, please contact me.

Tests
-----

All important functions are tested with tests in the `test` directory.
The `.gitlab-ci.yml` performs all tests automatically.

If you want to run the tests locally, please make sure, everything is installed
and just run

.. code-block:: shell

   pytest

or, if you use ``poetry`` run

.. code-block:: shell

   poetry run pytest

This will start all tests.
Since those are quite a lot, please ensure, you have enough computational
resources.
Else, just specify the test you want to run
as an argument directly after the ``pytest`` command.
colibri-cli 0.1.0
CLI for uploading dbt artifacts to Colibri Pro
Requires Python: >=3.9
Keywords: colibri, dbt, lineage

# Colibri CLI

Upload dbt artifacts to Colibri Cloud for automatic lineage analysis.

## Overview

This CLI is designed to integrate your CI/CD pipeline with Colibri Cloud, syncing your dbt `manifest.json` and `catalog.json` files.
The CLI automatically includes git commit information when available, making it easy to track which code version generated each upload.

## Installation

```bash
pip install colibri-cli
```

## Configuration

Set the following environment variables in your CI/CD environment:

```bash
COLIBRI_API_URL=https://api.colibri-data.com
COLIBRI_API_KEY=your-api-key-here
COLIBRI_PROJECT_ID=your-project-id
```


## Usage

### Upload Artifacts

After running your dbt project, upload the artifacts:

```bash
# Upload from default ./target directory
colibri-pro upload

# Upload from custom directory
colibri-pro upload --target-dir path/to/target

## CI/CD Integration

### GitHub Actions

```yaml
name: Upload dbt Lineage

on:
  push:
    branches: [main]
  workflow_dispatch:

jobs:
  upload-lineage:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
        with:
          fetch-depth: 0  # Fetch full history for git info

      - name: Set up Python
        uses: actions/setup-python@v5
        with:
          python-version: '3.11'

      - name: Install dependencies
        run: |
          pip install dbt-core dbt-duckdb  # or your adapter
          pip install colibri-cli

      - name: Run dbt
        run: |
          dbt deps
          dbt build
          dbt docs generate
        env:
          DBT_PROFILES_DIR: .

      - name: Upload to Colibri Pro
        run: colibri-pro upload
        env:
          COLIBRI_API_URL: ${{ secrets.COLIBRI_API_URL }}
          COLIBRI_API_KEY: ${{ secrets.COLIBRI_API_KEY }}
          COLIBRI_PROJECT_ID: ${{ secrets.COLIBRI_PROJECT_ID }}
```

### GitLab CI

```yaml
upload-lineage:
  stage: deploy
  image: python:3.11
  script:
    - pip install dbt-core dbt-duckdb colibri-cli
    - dbt deps && dbt build && dbt docs generate
    - colibri-pro upload
  variables:
    COLIBRI_API_URL: $COLIBRI_API_URL
    COLIBRI_API_KEY: $COLIBRI_API_KEY
    COLIBRI_PROJECT_ID: $COLIBRI_PROJECT_ID
  only:
    - main
```

### Metadata Included

The CLI automatically includes:
- `git_commit` - Current git commit hash (if available)
- `git_branch` - Current git branch (if available)
- `colibri_cli_version` - CLI version used for upload
- `uploaded_at` - ISO 8601 timestamp of uploads
testfn 0.0.1
Comprehensive self-hosted testing platform for developers (Python SDK)
Requires Python: >=3.10
Keywords: automation, superfunctions, test-runner, testing

# TestFn Python SDK

Comprehensive self-hosted testing platform for developers.

## Overview

TestFn is a developer-first testing solution that combines test execution, analytics, and visual testing into a single self-hosted platform. This is the Python SDK for TestFn.

## Features

- ✅ **Test Execution**: Integration with `pytest` for discovery and execution.
- ✅ **Storage**: Persistent storage of test runs and results using SQLAlchemy (SQLite default).
- ✅ **Analytics**: Flaky test detection, performance regression analysis, and run metrics.
- ✅ **Reporters**: Console and JSON reporters for real-time and post-run output.
- ✅ **Visual Testing**: Pixel-by-pixel screenshot comparison and diff generation.

## Installation

```bash
pip install testfn
```

## Quick Start

### Basic Test Execution

```python
import asyncio
from testfn import test_fn

async def main():
    # Initialize runner
    runner = test_fn(framework="pytest")
    
    # Run tests matching a pattern
    run = await runner.run(["tests/**/*.py"])
    
    print(f"Pass rate: {run.summary.passed / run.summary.total * 100}%")

if __name__ == "__main__":
    asyncio.run(main())
```

### Using Analytics

```python
from testfn import Storage, AnalyticsEngine

async def analyze():
    storage = Storage()
    analytics = AnalyticsEngine(storage)
    
    # Detect flaky tests
    flaky = await analytics.detect_flaky("tests/test_ui.py::test_login")
    print(f"Flaky Score: {flaky.flaky_score}")
    print(f"Recommendation: {flaky.recommendation}")
    
    # Find performance regressions
    regressions = await analytics.find_regressions(
        baseline_run_id="run-1", 
        current_run_id="run-2"
    )
    for reg in regressions:
        print(f"Test {reg['test_id']} got {reg['change']:.1%} slower")
```

### Visual Testing

```python
from testfn import VisualTester

tester = VisualTester(baseline_dir="baselines", diff_dir="diffs")

# Compare two screenshots
passed, score, diff_path = tester.compare_screenshots(
    current_path="screenshots/current.png",
    name="homepage",
    threshold=0.1
)

if not passed:
    print(f"Visual regression detected! Diff at: {diff_path}")
```

## Development

```bash
# Setup virtual environment
python3 -m venv .venv
source .venv/bin/activate

# Install dependencies
pip install -e .[dev]

# Run tests
pytest
```

## License

MIT