semvec/pypi-packages huggingface dataset:
Flask-RESTy 6.0.0
Building blocks for REST APIs for Flask
License: MIT
Requires Python: >=3.10
Keywords: rest flask

# Flask-RESTy [![GitHub Actions][build-badge]][build] [![Codecov][codecov-badge]][codecov] [![PyPI][pypi-badge]][pypi] [![marshmallow 3 compatible][marshmallow-badge]][marshmallow-upgrading]

Flask-RESTy provides building blocks for creating REST APIs with [Flask](http://flask.pocoo.org/), [SQLAlchemy](https://www.sqlalchemy.org/), and [marshmallow](https://marshmallow.readthedocs.io/).

```python
from flask_resty import Api, GenericModelView

from . import app, models, schemas


class WidgetViewBase(GenericModelView):
    model = models.Widget
    schema = schemas.WidgetSchema()


class WidgetListView(WidgetViewBase):
    def get(self):
        return self.list()

    def post(self):
        return self.create()


class WidgetView(WidgetViewBase):
    def get(self, id):
        return self.retrieve(id)

    def patch(self, id):
        return self.update(id, partial=True)

    def delete(self, id):
        return self.destroy(id)


api = Api(app, "/api")
api.add_resource("/widgets", WidgetListView, WidgetView)
```

## Documentation

Documentation is available at https://flask-resty.readthedocs.io/.

## License

MIT Licensed. See the bundled [LICENSE](https://github.com/4Catalyzer/flask-resty/blob/master/LICENSE) file for more details.

[build-badge]: https://github.com/4Catalyzer/flask-resty/actions/workflows/main.yml/badge.svg
[build]: https://github.com/4Catalyzer/flask-resty/actions
[pypi-badge]: https://img.shields.io/pypi/v/Flask-RESTy.svg
[pypi]: https://pypi.python.org/pypi/Flask-RESTy
[codecov-badge]: https://img.shields.io/codecov/c/github/4Catalyzer/flask-resty/master.svg
[codecov]: https://codecov.io/gh/4Catalyzer/flask-resty
[marshmallow-badge]: https://badgen.net/badge/marshmallow/3
[marshmallow-upgrading]: https://marshmallow.readthedocs.io/en/latest/upgrading.html
teleflaredb-logger 2025.9.111751
teleflaredb_logger
License: MIT
Requires Python: >=3.6

[![PyPI version](https://badge.fury.io/py/teleflaredb_logger.svg)](https://badge.fury.io/py/teleflaredb_logger)
[![License: MIT](https://img.shields.io/badge/License-MIT-green.svg)](https://opensource.org/licenses/MIT)
[![Downloads](https://static.pepy.tech/badge/teleflaredb_logger)](https://pepy.tech/project/teleflaredb_logger)
[![LinkedIn](https://img.shields.io/badge/LinkedIn-blue)](https://www.linkedin.com/in/eugene-evstafev-716669181/)

# teleflaredb_logger

`teleflaredb_logger` is a Python package designed to simplify the process of logging messages to a Telegram chat using the `teleflask` library and storing them in a `Tarantool` database. It provides a convenient way to send logs and monitor them in real-time via Telegram.

## Installation

To install `teleflaredb_logger`, use pip:

```bash
pip install teleflaredb_logger
```

## Usage

Using `teleflaredb_logger` is straightforward. First, ensure you have configured your `teleflask` application and `Tarantool` database connection.

```python
from teleflaredb_logger import TeleflaskDBLogger

# Assuming you have your teleflask app and tarantool connection configured
# from teleflask import TeleFlask
# from tarantool_orm import Tarantool

# app = TeleFlask(__name__, token="YOUR_TELEGRAM_BOT_TOKEN")
# db = Tarantool("YOUR_TARANTOOL_HOST", port=3301, password="YOUR_PASSWORD")

# Initialize the logger
# logger = TeleflaskDBLogger(app=app, db=db, chat_id="YOUR_CHAT_ID")

# Example logging
# logger.info("This is an informational message.")
# logger.warning("This is a warning message.")
# logger.error("This is an error message.")

# To send a log without using the app and db directly (if they are already globally configured or mocked)
# You can directly use the logger class with necessary parameters
# logger = TeleflaskDBLogger(chat_id="YOUR_CHAT_ID", token="YOUR_TELEGRAM_BOT_TOKEN", host="YOUR_TARANTOOL_HOST")
# logger.info("Another log message.")

```

## Features

*   **Real-time Logging:** Send log messages directly to a Telegram chat.
*   **Database Storage:** Persistently store log messages in a Tarantool database.
*   **Structured Logging:** Supports different log levels (INFO, WARNING, ERROR).
*   **Easy Integration:** Designed to work seamlessly with `teleflask` and `Tarantool`.

## Contributing

Contributions, issues, and feature requests are welcome! Feel free to check the [issues page](https://github.com/chigwell/teleflaredb_logger/issues).

## License

`teleflaredb_logger` is licensed under the [MIT License](https://choosealicense.com/licenses/mit/).

## Author

Eugene Evstafev - [LinkedIn](https://www.linkedin.com/in/eugene-evstafev-716669181/)
soandso 1.0.0
A collection of delightfully arbitrary utilities
License: MIT
Requires Python: >=3.8
Keywords: utilities, tools, fun, arbitrary

# soandso

A delightfully arbitrary collection of Python utilities that do things, other things, and something else entirely.

## Installation
```bash
pip install soandso
```

## Usage
```python
from soandso import do_a_thing, do_another_thing, do_something_else
from soandso import make_it_fancy, count_stuff, generate_nonsense

# Do a thing
result = do_a_thing("laundry")
print(result)  # "Successfully did laundry! ✨"

# Do another thing with intensity
result = do_another_thing(8)
print(result)  # {'thing_done': True, 'intensity_level': 8, ...}

# Do something else with a list
items = ["apple", "banana", "cherry"]
result = do_something_else(items)
print(result)  # ["🎭 apple (processed)", ...]

# Make text fancy
fancy = make_it_fancy("hello world", "sparkles")
print(fancy)  # "✨ ⭐ HELLO WORLD ⭐ ✨"

# Count stuff
counts = count_stuff("hello world")
print(counts)  # {'total': 11, 'without_spaces': 10, ...}

# Generate nonsense
nonsense = generate_nonsense(5)
print(nonsense)  # "flibber jabberwocky snurfle blimp woosh"
```
beautybook 0.1.2
A Dynamic Table Visualization Tool for Iterative Processes
License: MIT
Requires Python: >=3.8
Keywords: Python, Jupyter, notebook, Colab, Data Visualization, Table, IPython, MLOps

# BeautyBook

**BeautyBook** is a lightweight Python class for dynamic, real-time visualization of tabular data in Jupyter and Google Colab notebooks. Designed for iterative workflows like machine learning training loops, it renders a beautifully styled HTML table that updates in-place—no need for manual DataFrame reconstruction or external file writes.

---

## Features

- **Real-time Updates**: Clean, in-place table rendering using `IPython.display`, without cluttering notebook output.
- **Automatic Indexing**: Each entry is auto-numbered for easy tracking.
- **Responsive Styling**: Column widths adapt to content length using `ch` units for optimal readability.
- **Standalone Class**: Fully self-contained—just copy and paste into your notebook.

---

## Installation

BeautyBook is distributed as a single Python class. To use it, simply copy the class definition into a notebook cell:

```pip install beautybook```