semvec/pypi-packages huggingface dataset:
pyreprint 0.1.0
Enhanced print() with decorators, formatting, and style patterns
Requires Python: >=3.8
Keywords: decorators, formatting, jupyter, output, print, rich, terminal

# PyRePrint

Enhanced `print()` with decorators, formatting, and style patterns.

## Installation

```bash
pip install pyreprint
```

## Quick Start

```python
from pyreprint import reprint

# Standard print behavior
reprint("Hello, World!")

# With decorators
reprint("Section Title", before="=", after="=", width=40)
# ========================================
# Section Title
# ========================================

# Using styles
reprint("Important!", style="banner", width=40)
# ****************************************
# *             Important!               *
# ****************************************
```

## Decorator Functions

```python
from pyreprint import line, header, box, banner

print(line("=", 40))        # ========================================
print(header("Title"))      # Title\n=====
print(box("Content"))       # +-------+\n| Content |\n+-------+
print(banner("WELCOME", width=40))
```

## Built-in Styles

```python
from pyreprint import reprint

reprint("Text", style="section")   # Lines above and below
reprint("Text", style="header")    # Underlined
reprint("Text", style="box")       # In a box
reprint("Text", style="banner")    # Centered banner
reprint("Text", style="success")   # [OK] Text
reprint("Text", style="warning")   # !! WARNING !! Text
reprint("Text", style="error")     # [ERROR] Text
```

## Custom Styles

```python
from pyreprint import register_style, reprint

@register_style("custom")
def custom_style(text, **kwargs):
    return f">>> {text} <<<"

reprint("Hello", style="custom")  # >>> Hello <<<
```

## Output Capture

```python
from pyreprint import capture_output

with capture_output() as captured:
    print("This is captured")

print(captured.stdout)  # "This is captured\n"
```

## Rich Integration

```python
from pyreprint import rprint, panel, rule

rprint("[bold red]Error:[/bold red] Something went wrong")
rule("Section")
panel("Important", title="Notice")
```

## Sklearn-style Repr

```python
from pyreprint import ReprMixin

class MyModel(ReprMixin):
    def __init__(self, alpha=1.0, max_iter=100):
        self.alpha = alpha
        self.max_iter = max_iter

model = MyModel(alpha=0.5)
print(model)  # MyModel(alpha=0.5, max_iter=100)
```

## Documentation

Full documentation: https://colinconwell.github.io/PyRePrint

## License

GPL-3.0-or-later
openapi-client-gen 0.3.0
Generate Python async clients from OpenAPI specs with ExternalService pattern
Requires Python: >=3.10

# openapi-client-gen

Generate Python async API clients from OpenAPI 3.x specifications with Pydantic v2 support.

## Features

- Generates Pydantic v2 models from OpenAPI schemas
- Creates async service classes extending `ExternalService`
- Handles query parameters, path parameters, and request bodies
- Supports custom Jinja2 templates for service generation
- Automatic enum value normalization (lowercase)
- Handles Python reserved words in parameter names
- Deduplicates operation names automatically

## Installation

```bash
pip install openapi-client-gen
```

For full schema generation (recommended):

```bash
pip install openapi-client-gen[schemas]
```

## Quick Start

### CLI Usage

```bash
openapi-client-gen -i openapi.json -o ./client

openapi-client-gen -i openapi.json -o ./client --no-lowercase-enums

openapi-client-gen -i openapi.json -o ./client --template my_service.jinja2
```

### Programmatic Usage

```python
from pathlib import Path
from openapi_client_gen import parse_openapi, generate_schemas, generate_service

spec = parse_openapi(Path("openapi.json"))

generate_schemas(
    spec_path=Path("openapi.json"),
    output_path=Path("client/schemas.py"),
    lowercase_enums=True,
)

generate_service(
    spec=spec,
    output_path=Path("client/service.py"),
)
```

## Generated Code Structure

```
client/
  __init__.py
  schemas.py
  service.py
```

## Requirements

- Python 3.10+
- `external_service` library (for generated clients)
- `jinja2` (for template rendering)
- `pydantic>=2.0` (for schema validation)

### Optional

- `datamodel-code-generator` (for better schema generation)

## API Reference

### `parse_openapi(spec_path: Path) -> ParsedSpec`

Parse an OpenAPI JSON file and return a structured representation.

### `generate_schemas(spec_path: Path, output_path: Path, lowercase_enums: bool = True)`

Generate Pydantic models from OpenAPI schemas.

### `generate_service(spec: ParsedSpec, output_path: Path, template_path: Path | None = None)`

Generate an async service class from parsed specification.

## Custom Templates

You can provide custom Jinja2 templates for service generation. The template receives:

- `operations`: List of `Operation` objects
- `schema_imports`: List of schema names to import
- `title`: API title
- `version`: API version

## License

MIT
NiveshPy 1.0.0a2
A simple python library for all your investment needs.
Requires Python: >=3.11
Keywords: finance, investment, mutual funds

# NiveshPy

NiveshPy is a financial CLI designed for managing mutual funds and investment portfolios. It provides functionalities to fetch fund prices, manage portfolios, and calculate performance.

**Documentation**: [http://yashovardhan99.github.io/niveshpy](http://yashovardhan99.github.io/niveshpy)

NiveshPy is targeted towards Indian :india: markets, but the API is built to support any financial security.

## Quick Start

To get started, install NiveshPy from [PyPi](https://pypi.org/project/NiveshPy/):

```sh
pip install niveshpy
```

After installing, you can simply start using NiveshPy:

```sh
niveshpy <command>
```

Learn more by checking our [CLI documentation](http://yashovardhan99.github.io/niveshpy/cli)

## Work in progress

This project is a work in progress. The public API is still in development and unstable.

## License

This project is licensed under the MIT License. See the [LICENSE](LICENSE) file for more details.
fabricatio-checkpoint 0.3.0
An extension of fabricatio
Requires Python: <3.15,>=3.12

# `fabricatio-checkpoint`

[MIT](https://img.shields.io/badge/license-MIT-blue.svg)
![Python Versions](https://img.shields.io/pypi/pyversions/fabricatio-checkpoint)
[![PyPI Version](https://img.shields.io/pypi/v/fabricatio-checkpoint)](https://pypi.org/project/fabricatio-checkpoint/)
[![PyPI Downloads](https://static.pepy.tech/badge/fabricatio-checkpoint/week)](https://pepy.tech/projects/fabricatio-checkpoint)
[![PyPI Downloads](https://static.pepy.tech/badge/fabricatio-checkpoint)](https://pepy.tech/projects/fabricatio-checkpoint)
[![Bindings: PyO3](https://img.shields.io/badge/bindings-pyo3-green)](https://github.com/PyO3/pyo3)
[![Build Tool: uv + maturin](https://img.shields.io/badge/built%20with-uv%20%2B%20maturin-orange)](https://github.com/astral-sh/uv)

An extension of fabricatio.

---

## 📦 Installation

This package is part of the `fabricatio` monorepo and can be installed as an optional dependency using either pip or uv:

```bash
pip install fabricatio[checkpoint]
# or
uv pip install fabricatio[checkpoint]
```

For a full installation that includes this package and all other components of `fabricatio`:

```bash
pip install fabricatio[full]
# or
uv pip install fabricatio[full]
```

## 🔍 Overview

Provides version control and checkpointing capabilities for fabricatio workflows, allowing users to save, rollback, and
manage states of their worktrees using a git-like shadow repository system. It enables seamless state management during
complex AI-driven processes, supporting both individual file rollbacks and full worktree resets to maintain workflow
consistency and enable experimentation.

## 🧩 Key Features

- **Checkpoint Saving**: Save current worktree state with custom messages to preserve progress at any point
- **Selective Rollback**: Rollback individual files to previous checkpoints without affecting other files
- **Full Reset**: Reset entire worktree to any saved checkpoint state for complete state restoration
- **Diff Tracking**: Retrieve file differences between checkpoints to understand changes over time
- **Shadow Repository Management**: Automatic handling of git-like shadow repositories with configurable caching
- **Workflow Integration**: Seamless integration with fabricatio agents for reliable state management in AI workflows

## 🔗 Dependencies

Core dependencies:

- `fabricatio-core` - Core interfaces and utilities

No additional dependencies required.

## 📄 License

MIT – see [LICENSE](../../LICENSE)
reservation-calendar 1.0
A Reservation Calendar System
Requires Python: >=3.11

# Reservation Calendar

This module allows you to create a week based calendar for your reservations.

For seasonal resorts, this module calculates week numbers and reservation dates based on a reference day (Memorial Day by default). The calendar is lightweight and uses pure Python with no external dependencies.

Inspired by Fun Valley Family Resort in South Fork, Colorado, USA.

## How it works

At Fun Valley guests are allowed to book "their" dates for the following year at checkout.  Since the resort is seasonal, opening on Memorial Day each year, the calendar slides forward and backward every 7th year.  Every 7th year there are 6 weeks in May.

If you stay in a cabin on June 9th, 2023 (Friday) thru June 11th, 2023 (Monday), you can book the same DAYS for the following year.  The calendar will show you the dates for the following year, June 7th, 2024 (Friday) thru June 10th, 2024 (Monday).

Since reservations are based on the day of the week in the given week of the season, the dates are calculated based on the day of the week of the current reservation.

## How to use it

```python
from reservation_calendar import ReservationCalendar

calendar = ReservationCalendar()

# Get week number and weekday number for a given date
date = datetime(2023, 6, 9)
week_number, weekday_number = calendar.get_week_info(date)
print("Week number:", week_number)
print("Weekday number:", weekday_number)

# Get day name for a given date
day_name = calendar.get_day_name(date)
print("Day name:", day_name)


print(f"Future Reservation Dates for {date}:")
for year in range(2024, 2035):
  print(f"{calendar.get_reservation_start_date(date, year)}")
```

### Output

```text
Week number: 2
Weekday number: 5
Day name: Friday
Future Reservation Dates for 2023-06-09:
2024-06-07
2025-06-06
2026-06-05
2027-06-11
2028-06-09
2029-06-08
2030-06-07
2031-06-06
2032-06-11
2033-06-10
2034-06-09
```
flask-peewee 3.1.0
flask admin, api, auth, forms and more with peewee

This package is in maintenance-only mode!
=========================================

I'm sorry to announce that flask-peewee will now be in maintenance-only mode. This decision is motivated by a number of factors:

* `Flask-Admin <https://flask-admin.readthedocs.io/en/latest/>`_ provides a superior admin interface and has support for peewee models.
* `Flask-Security <https://pythonhosted.org/Flask-Security/>`_ and `Flask-Login <https://flask-login.readthedocs.io/en/latest/>`_ both provide authentication functionality, and work well with Peewee.
* Most importantly, though, I do not find myself wanting to work on flask-peewee.

I plan on rewriting the ``Database`` and ``REST API`` portions of flask-peewee and repackaging them as a new library, but flask-peewee as it stands currently will be in maintenance-only mode.

flask-peewee
============

provides a layer of integration between the `flask <http://flask.pocoo.org/>`_
web framework and the `peewee orm <https://peewee.readthedocs.io/>`_.

batteries included:

* admin interface
* authentication
* rest api

requirements:

* `flask <https://github.com/mitsuhiko/flask>`_
* `peewee <https://github.com/coleifer/peewee>`_
* `wtforms <https://github.com/wtforms/wtforms>`_
* `wtf-peewee <https://github.com/coleifer/wtf-peewee>`_
* python 2.5 or greater


check out the `documentation <https://flask-peewee.readthedocs.io/>`_.


admin interface
---------------

influenced heavily by the `django <http://djangoproject.com>`_ admin, provides easy
create/edit/delete functionality for your project's models.

.. image:: http://i.imgur.com/EtzdO.jpg


rest api
--------

influenced by `tastypie <https://github.com/toastdriven/django-tastypie>`_, provides
a way to expose a RESTful interface for your project's models.

::

    curl localhost:5000/api/user/
    {
      "meta": {
        "model": "user",
        "next": "",
        "page": 1,
        "previous": ""
      },
      "objects": [
        {
          "username": "admin",
          "admin": true,
          "email": "",
          "join_date": "2011-09-16 18:34:49",
          "active": true,
          "id": 1
        },
        {
          "username": "coleifer",
          "admin": false,
          "email": "coleifer@gmail.com",
          "join_date": "2011-09-16 18:35:56",
          "active": true,
          "id": 2
        }
      ]
    }


installing
----------

I recommend installing in a virtualenv.  to get started::

    # create a new virtualenv
    virtualenv --no-site-packages project
    cd project/
    source bin/activate

    # install this project (will install dependencies as well)
    pip install flask-peewee


example app
-----------

the project ships with an example app, which is a silly twitter clone.  to
start the example app, ``cd`` into the "example" directory and execute
the ``run_example.py`` script::

    cd example/
    python run_example.py

if you would like to test out the admin area, log in as "admin/admin" and navigate to:

http://127.0.0.1:5000/admin/

you can check out the REST api at the following url:

http://127.0.0.1:5000/api/message/
wtf-peewee 3.1.0
wtforms integration for peewee

# wtf-peewee

this project, based on the code found in ``wtforms.ext``, provides a bridge
between peewee models and wtforms, mapping model fields to form fields.

## example usage:

first, create a couple basic models and then use the model_form class factory
to create a form for the Entry model:
```python
from peewee import *
from wtfpeewee.orm import model_form
import wtforms

class PasswordField(TextField):
    """ Custom-defined field example. """
    def wtf_field(self, model, **kwargs):
        return wtforms.PasswordField(**kwargs)

class Blog(Model):
    name = CharField()

    def __unicode__(self):
        return self.name

class Entry(Model):
    blog = ForeignKeyField(Blog)
    title = CharField()
    body = TextField()
    protected = PasswordField()

    def __unicode__(self):
        return self.title

# create a form class for use with the Entry model
EntryForm = model_form(Entry)
```

Example implementation for an "edit" view using Flask:

```python
@app.route('/entries/<int:entry_id>/', methods=['GET', 'POST'])
def edit_entry(entry_id):
    try:
        entry = Entry.get(id=entry_id)
    except Entry.DoesNotExist:
        abort(404)

    if request.method == 'POST':
        form = EntryForm(request.form, obj=entry)
        if form.validate():
            form.populate_obj(entry)
            entry.save()
            flash('Your entry has been saved')
    else:
        form = EntryForm(obj=entry)

    return render_template('blog/entry_edit.html', form=form, entry=entry)
```
Example template for above view:
```jinja
{% extends "layout.html" %}
{% block body %}
  <h2>Edit {{ entry.title }}</h2>

  <form method="post" action="">
    {% for field in form %}
      <p>{{ field.label }} {{ field }}</p>
    {% endfor %}
    <p><button type="submit">Submit</button></p>
  </form>
{% endblock %}
```