semvec/pypi-packages huggingface dataset:
dquadratic 0.1.0
The package is used to find the roots and the nature of a quadratic equation.
Requires Python: >=3.0

### This is a Quadratic Equation Package for beginners. It is used to find the roots of a quadratic equation and identify the discriminant.
    - Feature 1: Roots of the equation.
    - Feature 2: Discriminant of the eqution and the nature of the roots.
filmo 0.0.3
Software Development Kit (SDK) for MovieLens API
Requires Python: >=3.13

# MovieLens SDK - `filmo`

Un SDK Python simple pour interagir avec l’API REST MovieLens. Il est conçu pour les **Data Analysts** et **Data Scientists**, avec une prise en charge native de **Pydantic**, **dictionnaires** et **DataFrames Pandas**.

[![PyPI version](https://badge.fury.io/py/moviesdk.svg)](https://badge.fury.io/py/moviesdk)
[![License: MIT](https://img.shields.io/badge/License-MIT-green.svg)](https://opensource.org/licenses/MIT)

---

## Installation

```bash
pip install filmo
```

---

## Configuration

```python
from filmo import MovieClient, MovieConfig

# Configuration avec l’URL de votre API (Render ou locale)
config = MovieConfig(movie_base_url="[https://consultant-data3.onrender.com")
client = MovieClient(config=config)
```

---

## Tester le SDK

### 1. Health check

```python
client.health_check()
# Retourne : {"status": "ok"}
```

### 2. Récupérer un film

```python
movie = client.get_movie(1)
print(movie.title)
```

### 3. Liste de films au format DataFrame

```python
df = client.list_movies(limit=5, output_format="pandas")
print(df.head())
```

---

## Modes de sortie disponibles

Toutes les méthodes de liste (`list_movies`, `list_ratings`, etc.) peuvent retourner :

- des objets **Pydantic** (défaut)
- des **dictionnaires**
- des **DataFrames Pandas**

Exemple :

```python
client.list_movies(limit=10, output_format="dict")
client.list_ratings(limit=10, output_format="pandas")
```

---

## Tester en local

Vous pouvez aussi utiliser une API locale :

```python
config = MovieConfig(movie_base_url="http://localhost:8000")
client = MovieClient(config=config)
```

---

## Public cible

- Data Analysts
- Data Scientists
- Étudiants et curieux en Data
- Développeurs Python

---

## Licence

MIT License

---

## Liens utiles

- API Render : [https://consultant-data3.onrender.com](https://consultant-data3.onrender.com)
- PyPI : [https://pypi.org/project/filmo/#description](https://pypi.org/project/filmo/#description)
rexdsl 0.0.3
custom regex dsl designed in rply for simplicity
Requires Python: >=3.10

- domain specific language designed for regex
- uses rply as engine

class Rex:
    def __init__(self, block: str):
        self._build_lexer()
        self._build_parser()

        tokens = self.lexer.lex(block)
        self.pattern = self.parser.parse(tokens)

    def _build_lexer(self):
        rules = {
            "STRING":    r"'[^']*'",
            "NUMBER":    r"\d+",
            "OR":        r"(?i)or",
            "AND":       r"(?i)and",
            "SEMICOLON": r";",

            # constants
            "ALPHANUM":  r"_ALPHANUM",
        }

        lg = LexerGenerator()
        for name, pattern in rules.items():
            lg.add(name, pattern)

        lg.ignore(r"\s+")
        self.lexer = lg.build()

    def _build_parser(self):
        pg = ParserGenerator(["STRING", "NUMBER", "ALPHANUM", "OR", "AND", "SEMICOLON"])

        # Start
        pg.production("start : sequences SEMICOLON")(lambda p: p[0])

        # OR sequences
        pg.production("sequences : sequence OR sequences")(lambda p: f"(?:{p[0]})|(?:{p[2]})")
        pg.production("sequences : sequence")(lambda p: p[0])

        # AND sequences
        pg.production("sequence : statement AND sequence")(lambda p: f"{p[0]}{p[2]}")
        pg.production("sequence : statement")(lambda p: p[0])

        # Unified statement handler
        def statement(p, x):
            tok_type = p[0].gettokentype()
            match tok_type:
                case "STRING":
                    text = p[0].getstr()[1:-1]
                case "_ALPHANUM":
                    text = r"[A-Za-z0-9]"
            count = int(p[1].getstr()) if x == 2 else 1
            return f"(?:{text}){{{count}}}"


        pg.production("statement : STRING NUMBER")(lambda p: statement(p, len(p)))
        pg.production("statement : STRING")(lambda p: statement(p, len(p)))
        pg.production("statement : ALPHANUM NUMBER")(lambda p: statement(p, len(p)))
        pg.production("statement : ALPHANUM")(lambda p: statement(p, len(p)))

        self.parser = pg.build()

    def exists(self, block: str):
        return bool(regex.fullmatch(self.pattern, block))