semvec/pypi-packages huggingface dataset:
flask-restalchemy 0.14.1
Flask extension to build REST APIs based on SQLAlchemy models
License: MIT
Requires Python: >=3.6
Keywords: flask sqlalchemy orm

# Flask-RESTAlchemy #

[![build](https://github.com/ESSS/serialchemy/workflows/build/badge.svg)](https://github.com/ESSS/serialchemy/actions)
[![codecov](https://codecov.io/gh/ESSS/flask-restalchemy/branch/master/graph/badge.svg)](https://codecov.io/gh/ESSS/flask-restalchemy)
[![black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
[![black](https://img.shields.io/readthedocs/flask-restalchemy.svg)](https://flask-restalchemy.readthedocs.io/en/latest)

A Flask extension to build REST APIs. It dismiss the need of building *Schema* classes,
since usually all the information needed to serialize an SQLAlchemy instance is in the model
itself.

By adding a model to the API, all its properties will be exposed:

```python
class User(Base):

    __tablename__ = "User"

    id = Column(Integer, primary_key=True)
    firstname = Column(String)
    lastname = Column(String)
    email = Column(String)
    password = Column(String)


api = Api(flask_app)
api.add_model(User, "/user")
```

To change the way properties are serialized, declare only the one that needs a non-default
behaviour:

```python
from serialchemy import ModelSerializer, Field


class UserSerializer(ModelSerializer):

    password = Field(load_only=True)


api = Api(flask_app)
api.add_model(User, "/user", serializer_class=UserSerializer)
```

### Release
A reminder for the maintainers on how to make a new release.

Note that the VERSION should folow the semantic versioning as X.Y.Z
Ex.: v1.0.5

1. Create a ``release-VERSION`` branch from ``upstream/master``.
2. Update ``CHANGELOG.rst``.
3. Push a branch with the changes.
4. Once all builds pass, push a ``VERSION`` tag to ``upstream``.
5. Merge the PR.

[Changelog]: https://regro.github.io/rever-docs/devguide.html#changelog
streampipe 0.1
StreamPipe is a straightforward multi-worker pipeline for streaming data in Python.
License: MIT

# StreamPipe
**StreamPipe** is a simple Python library (a single file!) for running **multi-worker pipelines** on **infinite data streams**. The best part about StreamPipe is that the **order of data is preserved** throughout the pipeline. You can chain order-independent workers (think of image processing functions) and order-dependent workers (think of an object video tracker) on the same StreamPipe!

<p align="center">
  <img src="https://github.com/highvight/streampipe/assets/25797927/95e5a820-eb1a-43f7-ad67-8bd8ff94fb12" width="400" align="center">
</p>



## Installation
```bash
pip3 install streampipe
```

Install from source:
```bash
git clone https://github.com/highvight/streampipe
cd streampipe
pip3 install .
pip3 install .[testing]  # for testing and benchmarks
```

## Usage
Here is a starter. Let's check if you can speed up a reshaping and standardization pipeline for images.

```python
import timeit
import numpy as np
from streampipe import StreamPipe

IMG = np.random.rand(1000, 1000, 3) * 255

def _reshape(img):
    return img[::2, ::2]

def _standardize(img):
    mean = np.mean(img, axis=(0, 1), keepdims=True)
    std = np.std(img, axis=(0, 1), keepdims=True)
    return (img - mean) / std

pipe = StreamPipe()
pipe.add(_reshape, n_workers=4, maxsize=4)
pipe.add(_standardize, n_workers=4, maxsize=4)

def measure_pipe():
    # Starts the workers
    with pipe:
        for _ in range(100):
            pipe.put(IMG)
    # All workers stopped, all items done

def measure_normal():
    for _ in range(100):
        x = _reshape(IMG)
        x = _standardize(x)

print(timeit.timeit(measure_pipe, number=1))  # 1.214164252000046
print(timeit.timeit(measure_normal, number=1))  # 3.083142001007218
```
    
## License

[MIT](https://choosealicense.com/licenses/mit/)
python-opc-lite 0.0.2
Open Package Convention light weight python library
License: MIT
Requires Python: >=3
Keywords: opc,Open Package Convention,pptx,docx,xlsx

# python-opc-lite

python-opc-lite is a light weight python library for Open Package Convention used for Open Office XML packages


## Overview

This library is used to deal with open office xml packages that follow Open Package Convention. 

It is used not only to read and write the packages but also to navigate through the parts of the package by relationships


## More information

- [Documentation](https://python-opc-lite.readthedocs.io/)
  - [Quickstart](https://python-opc-lite.readthedocs.io/en/latest/quickstart.html)
- [Contribute](https://python-opc-lite.readthedocs.io/en/latest/contribution.html)
  - [Issues](https://github.com/kascodeo/python-opc-lite/issues)
  - [Pull requests](https://github.com/kascodeo/python-opc-lite/pulls)
step-pipeline 0.2.7
Pipeline library that simplifies creation of pipelines that run on top of hail Batch and other compute enviornments
License: MIT
Requires Python: >=3.7
Keywords: pipelines,workflows,hail,Batch,cromwell,Terra,dsub,SGE

# step-pipeline


This library serves as a thin layer on top of Hail Batch (and eventually other execution engines) 
to provide the following features:

- Skip steps that already ran and completed successfully (eg. their output files already exist and are newer than their input files). This is done prior to submitting the pipeline to the execution engine.
- Make it easier to switch between different ways of localizing files (copy, gcsfuse, etc.) with minimal changes to pipeline code
- Automatically define pipeline command-line args to force or skip execution of paticular steps
- Use a config file to store various pipeline parameters (eg. cloud project account, etc.)
- Add commands for sending pipeline completion notifications to Slack
- Add commands for profiling pipeline steps while they are running, and saving this info to external storage 
- Generate a diagram of the pipeline execution graph (DAG)

Another longer-term goal is to allow the same pipeline definition to be submitted to different 
backends with minimal changes - including Hail Batch, Terra/Cromwell, and others. 
This can only work for pipelines that use the subset of workflow definition features that is shared
across the relevant execution engines.  

---

### Installation

To install the `step-pipeline` library, run:
```
python3 -m pip install step-pipeline
```

---

### Docs

[API docs](https://bw2.github.io/step-pipeline/docs/_build/html/index.html)

---