semvec/pypi-packages huggingface dataset:
syrinx 0.1.2
Simple static site generator
Requires Python: >=3.10

# Syrinx

<img src="http://syrinx.site/assets/logo_syrinx.png" width="70" alt="logo of singing bird with pan flute as vocal chords">


> *Spreadsheet to website*

[website](https://syrinx.site)

Simple static site generator in python


## Deployment options

### DO App Platform + "Pull"

This is the simplest option. Commit the `dist` directory with generated html files and assets to your github repository. Next create a DigitalOcean App Platform "App", and point it to your github repository. Configure it to find the files in the `dist` directory. 

### DO App Platform + "Push"

This gives you more control over both the server environment as well as the deployment pipeline, but it is more involved. You'd include two files in your repository: a `Dockerfile` specifying the server, and a DigitalOcean App specification in yaml. In the deployment pipeline you then build the docker container and push it to a central registry. In the app specification you'd list the container registry address, and using the commandline tool `doctl` you tell DigitalOcean to schedule a deployment from the new container.
xlea 1.0.0
python library that makes it easy to convert Excel tables into ORM-like objects
Requires Python: >=3.9

# XLEA

`xlea` is a python library that makes it easy to convert Excel tables into ORM-like objects.

The library focised on **schema-driven** parsing of tabular data, where column resolution, validation and type conversion are handled explicitly and predictably.

> ⚠️ XLEAA is a work in progress. The public API is stabilizing, and core concepts are already in place.

## Features

- Declarative schema definition
Describe tabular data using Python classes with type annotations and column descriptors.

- Automatic column resolution
Columns are matched by name, regular expression, or custom predicate — no hard-coded indexes.

- Type-driven value conversion
Cell values are automatically cast using schema type annotations with explicit error reporting.

- Header-aware parsing
Support for multi-row headers and complex header layouts via schema configuration.

- Pluggable provider architecture
File formats are handled by interchangeable providers, selected automatically by file extension.

- Excel formats out of the box
Native support for .xlsx, .xls, and .xlsb via dedicated providers.

- Row-level validation
Custom validators can be attached to columns to enforce domain-specific constraints.

- Graceful handling of invalid data
Optionally skip rows with invalid values instead of failing the entire read.

## Example

### Defining a Schema

```python
from typing import Optional

from xlea import Schema, Column


age_name = lambda name: name.startswith("Age")
age_validator = lambda val: val.isnumeric()

@config(header_rows=2)
class Person(Schema):
    id: str = Column("ID")
    fullname: str = Column("Profile;Last Name, First Name", ignore_case=True)
    age: int = Column(age_name, validator=age_validator, skip_invalid_row=True)
    city: Optional[str] = Column("City", required=False, default="Voronezh")
```

### Reading an Excel file

```python
import xlea
from xlea.providers.openpyxl import OpenPyXlProvider

from schemas import Person


def main():
    persons = xlea.read(OpenPyXlProvider("test_data.xlsx"), schema=Person)
    # or with automatic provider selection
    persons = xlea.autoread("test_data.xlsx", schema=Person)

    for p in persons:
        print(p.id, p.fullname, p.age)


if __name__ == "__main__":
    main()
```