semvec/pypi-packages huggingface dataset:
testcato 1.2.5
A package for categorizing test results.
License: MIT

# testcato

A Python package for automatically categorizing pytest test results (passed, failed, skipped) and
enabling AI-assisted debugging of test failures.

## Install

```bash
pip install testcato
```


## Project Structure

- `testcato/` - main package directory
    - `categorizer.py` - core logic for categorizing test results
    - `llm_provider.py` - module to add support for different large language models (LLMs)
- `tests/` - unit tests for the package
- `setup.py` - package setup configuration
- `requirements.txt` - dependencies
- `LICENSE` - license file


## Features

- Automatically categorize pytest test results into structured categories like passed, failed, and skipped.
- Generate detailed JSONL reports with tracebacks for failed tests, timestamped for easy reference.
- AI-assisted debugging support for failed tests using integrated GPT models.
- Easily add support for other LLM providers via a modular llm_provider system.
- Runs seamlessly with the `--testcato` pytest option to enable enhanced test reporting.
- Configuration via an automatically created `testcato_config.yaml` file for AI agent setup.


## Usage with pytest

Run pytest with the `--testcato` flag to enable the collection and categorization of test results.

```bash
pytest --testcato
```

This will create a `testcato_result` folder in your working directory containing JSONL files with
detailed failure information.

## Configuration

The `testcato_config.yaml` file will be generated automatically when you first import or install the
package, if it doesn't already exist. Configure your AI agents here, for example:

```yaml
default: gpt

gpt:
  type: openai
  model: gpt-4
  api_key: YOUR_OPENAI_API_KEY
  api_url: https://api.openai.com/v1/chat/completions
```

Avoid committing API keys to version control; use environment variables or secret managers instead.

## Adding Support for New LLM Providers

- To add support for other large language models, implement the provider interface in `llm_provider.py`,
register your provider, and update the configuration.
- If the package uses a registry or factory pattern for LLM providers, add your new provider to the registry
so it can be selected dynamically based on configuration or parameters.

Example provider skeleton:

```python
class MyNewLLMProvider:
    def __init__(self, api_key):
        self.api_key = api_key

    def send_prompt(self, prompt):
        # Implement API call here
        response = ...  # Call API with prompt and api_key
        return response.get("text", "")
```


## Testing

Unit tests are located in the `tests/` directory. Install development dependencies and run tests using pytest:

```bash
pip install -r requirements.txt
pytest
```


## Troubleshooting

If `testcato_config.yaml` is missing or malformed, AI debugging features will be disabled. Ensure the config
file exists and is properly formatted.

When running pytest, use the `--testcato` option to enable testcato features:

```bash
pytest --testcato
```
a003558 0.1.25
A003558 – universal clock
License: MIT
Requires Python: >=3.10

# A003558 Universal Clock

WELKOM  
Dit project combineert **kunst, mindfulness en ecologie**.  
De klok visualiseert de recursieve structuur van [OEIS A003558](https://oeis.org/A003558) en verbindt getallen met ritme, tijd en patronen.

---

## 🌟 Wat kun je ermee?

- Plotten van cycli en patronen in 2D  
- 3D visualisatie van octaëders en kubusrelaties  
- Automatische tests zodat niets breekt  
- Werkend op elk platform (mits dependencies aanwezig)

---

## 🚀 Installeren

1. Clone de repo:

```bash
git clone https://github.com/bramdhontsr/A003558-universal-clock.git
cd A003558-universal-clock
tmin 1.0.1
A comprehensive pipe thickness analysis tool for mechanical integrity engineering
License: MIT
Requires Python: >=3.8

# TMIN - Pipe Thickness Analysis Tool

<p align="left">
  <img src="https://github.com/user-attachments/assets/52007543-8109-44ff-845e-c6a809a89a38" alt="TMIN Logo" width="700" />
</p>

[![Downloads](https://pepy.tech/badge/tmin)](https://pepy.tech/project/tmin)
[![PyPI version](https://badge.fury.io/py/tmin.svg)](https://badge.fury.io/py/tmin)
![License](https://img.shields.io/pypi/l/tmin)
[![Tests](https://github.com/AndrewTrepagnier/tmin/workflows/Tests/badge.svg)](https://github.com/AndrewTrepagnier/tmin/actions)
[![codecov](https://codecov.io/gh/AndrewTrepagnier/tmin/branch/main/graph/badge.svg)](https://codecov.io/gh/AndrewTrepagnier/tmin)
[![Python Versions](https://img.shields.io/pypi/pyversions/tmin.svg)](https://pypi.org/project/tmin/)
[![Blog](https://img.shields.io/badge/Updates-blog-purple)](https://your-blog-link.com)
[![Blog](https://img.shields.io/badge/dev-wiki-gold)](https://github.com/AndrewTrepagnier/tmin/wiki)
[![Blog](https://img.shields.io/badge/Important-DesignDoc-pink)](https://your-blog-link.com)

TMIN (an abbreviation for "minimum thickness") is an open source python package designed to help engineers determine if corroded process piping in refineries and pertrochemical plants are **safe** and **API-compliant** — in seconds.

Many oil and gas companies are faced with maintaining thousands of miles of 100+ year old piping networks supporting multi-million dollar/year processing operations. There is rarely a simple solution to immediately shutdown a process pipe - as these shutdowns more often than not impact other units and cost companies millions in time and resources.

***TMIN can be used as a conservative and rapid engineering support tool for assessing piping inspection data and determine how close the pipe is to its end of service life.***

---

# How to install and get started

### Installation:

```bash
pip install tmin
```

### Basic Usage
```python
from tmin import PIPE

# Create pipe instance
pipe = PIPE(
    pressure=50,           # Design pressure (psi)
    nps=2,                 # Nominal pipe size (inches)
    schedule=40,           # Pipe schedule
    pressure_class=150,    # Pressure class
    metallurgy="Intermediate/Low CS",
    yield_stress=23333     # Yield stress (psi)
)

# Analyze measured thickness
results = pipe.analyze(
    measured_thickness=0.060,  # Measured thickness (inches)
    year_inspected=2023        # Optional: inspection year
)

print(f"Flag: {results['flag']}")
print(f"Status: {results['status']}")
print(f"Governing thickness: {results['governing_thickness']:.4f} inches")
```

## Docker Usage

Run TMIN in a container:

```bash
# Build and run
./docker.sh build
./docker.sh run

# Or test functionality
./docker.sh test
```

## License

MIT License
skpoly 0.1.2
Polynomial basis transformers for scikit-learn.
License: MIT
Requires Python: >=3.10
Keywords: feature-engineering, machine-learning, polynomials, scikit-learn

# skpoly

<p align="center">
  <img src="https://raw.githubusercontent.com/alexshtf/skpoly/refs/heads/master/skpoly_logo.png" alt="skpoly logo" width="360" />
</p>

`skpoly` provides drop-in polynomial feature generators that integrate with scikit-learn pipelines. The library focuses on smooth orthogonal bases such as Bernstein and Legendre polynomials, letting you capture non-linear structure with well-conditioned numerical behavior.

The project expands on the the blog series, beginning with the post [“Are polynomial features the root of all evil?”](https://alexshtf.github.io/2024/01/21/Bernstein.html).

## Documentation

Explore the [documentation](https://skpoly.readthedocs.io/en/latest/).

## Quick start

Create a pipeline that first rescales each input dimension and then expands it with Bernstein features before fitting a linear model:

```python
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import MinMaxScaler
from sklearn.linear_model import Ridge
from skpoly import BernsteinFeatures

pipeline = make_pipeline(
    MinMaxScaler(),
    BernsteinFeatures(degree=8),
    Ridge(alpha=1e-2),
)

pipeline.fit(X_train, y_train)
y_pred = pipeline.predict(X_test)
```

The `MinMaxScaler` step keeps every feature inside the default `[0, 1]` range assumed by
the polynomial bases, which in turn preserves the well-conditioned behavior of the
Bernstein and Legendre transforms.

## Pairwise interaction features

For multivariate inputs you can enable tensor-product features to model pairwise (and higher-order) interactions between coordinates. Setting `tensor_product=True` expands the basis with every combination of the univariate polynomials:

```python
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import MinMaxScaler
from sklearn.linear_model import LogisticRegression
from skpoly import LegendreFeatures

pipeline = make_pipeline(
    MinMaxScaler(),
    LegendreFeatures(degree=5, tensor_product=True),
    LogisticRegression(),
)
```

## Development

Clone the repository and install dependencies using [uv](https://github.com/astral-sh/uv):

```bash
git clone https://github.com/alexshtf/skpoly.git
cd skpoly
uv venv
source .venv/bin/activate
uv sync
```

Using `uv` keeps dependency resolution fast and reproducible.

## Citation

- **Use the `CITATION.cff` file.** Most reference managers and services like GitHub's
  "Cite this repository" option can import the citation metadata directly from
  `CITATION.cff`.
- **Grab the BibTeX entry.** If you prefer to add the reference manually, cite the
  project as follows.

```bibtex
@software{Shtoff_skpoly_2025,
  author = {Alex Shtoff},
  title = {skpoly: Polynomial basis transformers for scikit-learn},
  url = {https://github.com/alexshtf/skpoly},
  version = {0.1.0},
  year = {2025}
}
```