semvec/pypi-packages huggingface dataset:
zpy-flask-msc 0.0.1
Helper layer for apis development with Python and Flask
Requires Python: >=3.6

<p align="center">
  <a  href="https://github.com/NoeCruzMW/zpy-flask-msc-docs"><img width="150" src="https://lh3.googleusercontent.com/a-/AOh14GjLO5qYYR5nQl5hgavUKz4Dv3LVzWDvGtV4xNam=s600-k-no-rp-mo" alt="Zurck'z"></a>
</p>
<p align="center">
    <em>ZPy Flask MSC, Layer for build microservices</em>
</p>
<p align="center"></p>

---

# ZPy Flask MSC

> Zurck'z Py Flask Micro Services Core

This package contains some helpers features for build python microservices using Flask framework

ZPy use the following packages:

- pycryptodome
- Flask
- marshmallow
- cx-Oracle

## Requirements

- Python 3.6+
- Boto 3+
- Oracle Client

## Installation

Use the package manager [pip](https://pip.pypa.io/en/stable/) to install py flask micro service core .

```bash
pip install boto3
pip install zpy
```

## Features

Contains some helper features with specific integrations.

- Api
  - Api Builder
  - Response Builder
  - Models
  - Hooks
  - Middlewares
  - Exceptions
  - Repositories
    - Only oracle repository implementation for functions calling.
- Cloud Implementations
  - AWS Services
    - S3
    - SSM
    - Firehose
    - SQS
- Custom
  - Plugings
- Database
  - Only Oracle implementation
    - Functions executor
- Logger
  - Stream
- Utils
  - Collections
  - Cipher
  - Functions
  - gzip

## Basic Usage

Define restful resource

```python
from zpy.api.resource import ZResource, HTTP_METHODS


class UserResource(ZResource):

    def __init__(self, **kwargs) -> None:
        super().__init__()
        # Receive any dependency by keywords arguments

    def get(self):
        l, i = super().new_operation()
        try:
            return self.success({"user": {"name":"Zurckz"}}, logger=l)
        except Exception as e:
            return self.handle_exceptions(e, l, i)

```

Setup api

```python
#Define api
@api(base='/v1', config=config)
def create_api():
    #Set all supported resource for this web service.
    return \
    [
        ZResource('/', UserResource)
    ]
```

Local Dev Deploy

```python
from api import create_api

app = create_api()

# 🚨 Only use it in local tests 💻
if __name__ == "__main__":
    app.run(host="localhost", debug=True)

```


## Contributing

Pull requests are welcome. For major changes, please open an issue first to discuss what you would like to change.

Please make sure to update tests as appropriate.

## License

[MIT](https://choosealicense.com/licenses/mit/)

## Authors

[Noé Cruz](https://www.linkedin.com/in/zurckz/)
Flask-Matomo-D 0.0.3
Track requests to your Flask website with Matomo

# Flask-Matomo-D

![](https://img.shields.io/badge/license-MIT-blue.svg?style=flat-square)
[![PyPI](https://img.shields.io/pypi/v/flask-matomo-d.svg?style=flat-square&colorB=dfb317)](https://pypi.org/project/flask-matomo-d/)

Flask-Matomo-D is a library which lets you track the requests of your Flask website using Matomo (Piwik).

## Installation

```
pip install flask-matomo-d
```

## Usage

```python
from flask import Flask, render_template
from flask_matomo import *

app = Flask(__name__)
matomo = Matomo(app,
                matomo_url="https://matomo.mydomain.com",
                id_site=5,
                token_auth="XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX",
                secure=True,
                allowed_paths=None,
                custom_action_name_by_path=None)

@app.route("/")
def index():
  return render_template("index.html")

if __name__ == "__main__":
  app.run()
```

In the code above:

1. The *Matomo* object is created by passing in the Flask application and arguments to configure Matomo.
2. The *matomo_url* parameter is the url to your Matomo installation.
3. The *id_site* parameter is the id of your site. This is used if you track several websites with on Matomo installation. It can be found if you open your Matomo dashboard, change to site you want to track and look for &idSite= in the url.
4. The *token_auth* parameter can be found in the area API in the settings of Matomo. It is required for tracking the ip address.
5. The *secure* parameter indicates whether the verification of trusted certificates is performed, by default is True.
6. The *allowed_paths* indicates allowed paths of every incoming request to be tracked, use regex sintax. Ex: 'dasd|paht1|admin'
7. The *custom_action_name_by_path* parameter set custom action_name identifying a part of the String that contains the Request.path. Ex:
  url: `http://www.example.com/myapplication/generic/page.html?x=y`
  Request.path: `/generic/page.html`

  custom_action_name_by_path = {'generic': 'Generic Action in Etc'}

  Every requests that contain "generic" in their url path will have their default action_name modified, which is the name of the method invoked in Flask, by the value of the key that was identified. For more info read [tracking-api](https://developer.matomo.org/api-reference/tracking-api)

# Docs
  Matomo [tracking-api](https://developer.matomo.org/api-reference/tracking-api)
  Flask [api](https://tedboy.github.io/flask/index.html)

## Meta

Lucas Hild - [https://lucas-hild.de](https://lucas.hild.de)
This project is licensed under the MIT License - see the LICENSE file for details
aurem 1.1.0
AUto REgressive Models for seismic phase picking
Requires Python: >=3.6

[![travis-build](https://app.travis-ci.com/mbagagli/aurem.svg?branch=master)](https://app.travis-ci.com/mbagagli/aurem)

# AuReM picker

_**Au**to **Re**gressive **M**odels for seismic phase picking_

**Version:** 1.1.0

**Author:** Matteo Bagagli

**Date:** 09/2021


### Introduction

This package provides a variety of **AU**to **RE**gressive **M**odels seismic pickers.
It contains the AIC and REC picking algorithm, and their **CF calculations** are fully **written in C** for faster run times "under the hood".
But, you'll just need to use python ... :)

See references for more details.

### Setup

Currently there are 2 different ways to install the package.

#### Developer
If you prefer you can create a python environment with conda or pyenv, and then clone the project

```
$ conda create -n aurem python=3.7
$ conda activate aurem
$ cd where/the/code/is
$ pip install .
# Install pytest and check everything works fine
$ pip install pytest ; pytest
```

Jupyter notebook example and tutorials can be found in the project's `books` folder.
Library dependencies are stored in `requirements.txt`

Contributors are welcome as well as any suggestion for the project improvement!

#### PyPI
From version `1.1.0` the package is hosted to PyPI repository. Therefore, once the environment is created, you would just need to type:

```
$ conda activate aurem
$ pip install aurem
```
and be ready to go ...

### References

**AIC**
- Maeda 1985: A method for reading and checking phase times in autoprocessing system of seismic wave data

**REC**
- Madarshahian at al. 2020: Bayesian Estimation of Acoustic Emission Arrival Times for Source Localization
pylightnix 0.3.0
A Nix-style immutable data management library in Python
Requires Python: >=3.6

![coverage](https://codecov.io/gh/stagedml/pylightnix/branch/master/graph/badge.svg)

Pylightnix
==========

Pylightnix is a minimalistic Python library for managing filesystem-based
immutable data objects, inspired by [Purely Functional Software Deployment Model
thesis by Eelco Dolstra](https://edolstra.github.io/pubs/phd-thesis.pdf) and the
[Nix](https://nixos.org) package manager.

The library may be thought as of low-level API for creating caching wrappers
for a subset of Python functions. In particular, Pylightnix allows user to

* Prepare (or, in our terms - **instantiate**) the computation plan aimed at
  creating a tree of linked immutable stage objects, stored in the filesystem.
* Implement (in our terms - **realize**) the prepared computation plan, access
  the resulting artifacts. Pylightnix is able to handle **non-deterministic**
  results of the computation. As one example, it is possible to define a stage
  depending on best top-10 instances (in a user-defined sense) of prerequisite
  stages.
* Handle changes in the computation plan, re-use the existing artifacts
  whenever possible.
* Gain full control over all aspects of the cached data including the
  garbage-collection.

Documentation
-------------

QuickStart [[PDF]](https://raw.github.com/stagedml/pylightnix-docs/master/Pylightnix-QuickStart-latest.pdf) |
API Referece [[MD]](./docs/Reference.md)

Demos:

* [GNU Hello](./docs/demos/HELLO.md), turns Pylightnix into a toy
  package manager to build the GNU Hello from sources.
* [MDRUN](./docs/demos/MDRUN.py), evaluate code sections in a Markdown document,
  and cache the results betwee runs.

(Outdated)

Manual [[PDF]](https://raw.github.com/stagedml/pylightnix-docs/master/Pylightnix-Manual-latest.pdf) |

* [Ultimatum tutorial](https://github.com/grwlf/ultimatum-game/blob/master/docs/Pylightnix.md),
  managing experiments.
* [MNIST demo](./docs/demos/MNIST.md) shows some machine learning specific.
* [REPL demo](./docs/demos/REPL.md) illustrates how to debug stage sequences.