semvec/pypi-packages huggingface dataset:
madness 0.7.0
wsgi microframework suitable for building modular DRY RESTful APIs
Requires Python: >3.6

# madness: a method for your madness

It is built upon WSGI and the fabulous [werkzeug](https://github.com/pallets/werkzeug) routing system, like Flask.



## Guiding Principles

[Don't repeat yourself](https://en.wikipedia.org/wiki/Don%27t_repeat_yourself)

[Dependency inversion principle](https://en.wikipedia.org/wiki/Dependency_inversion_principle)

[Do One Thing and Do It Well.](https://en.wikipedia.org/wiki/Unix_philosophy#Do_One_Thing_and_Do_It_Well)

[The Zen of Python](https://www.python.org/dev/peps/pep-0020/)

## Goals

[Cohesion](https://en.wikipedia.org/wiki/Cohesion_(computer_science))


## Installing

```console
$ pip install -U madness
```

## A Simple Example

```python
from madness import application, get

def hello():
    return 'Hello, world!'

if __name__ == '__main__':
    application(get('/', hello)).run()
```

## Routing

* route and variants

* routes and variants

* defaults

* url parameters

```python
from madness import routes, route, get, post, index

def hello():
  return 'world'

def bar():
  return 'zing!'

# recommended style

urls = routes(
  index(hello),
  routes(
    index(lambda: 'foo')
    route(bar, methods=['GET', 'POST', 'PUT']),
    path = '/foo'
  )
)

# flat style

urls = routes(
  route('/', hello, methods=['GET']),
  route('/foo', lambda: 'foo', methods=['GET']),
  route('/foo/bar', bar, methods=['GET', 'POST', 'PUT']),
)

# add GET to all routes

urls = routes(
  route('/', hello),
  route('/foo', lambda: 'foo'),
  route('/foo/bar', bar, methods=['POST', 'PUT']),
  methods = ['GET']
)


```

## Abstractions (Dependency inversion principle)

* g

* extending g

* madness.G and g_factory


## Middleware (Coroutines)

as decorator

as serializer

as request-contextmanager

as response contextmanager

as request-response contextmanager

as error handler


## Extensions

* json

* cors
ModuleUltra 0.1.14
Tools to make pipelines easier to run and distribute for large biological datasets

ModuleUltra
===========

.. image:: https://img.shields.io/circleci/project/github/dcdanko/ModuleUltra/master.svg
    :alt: CircleCI master

.. image:: https://img.shields.io/pypi/v/ModuleUltra.svg
    :target: https://pypi.python.org/pypi/ModuleUltra
    :alt: Latest PyPI version

.. image:: https://www.codefactor.io/repository/github/dcdanko/ModuleUltra/badge
    :target: https://www.codefactor.io/repository/github/dcdanko/ModuleUltra
    :alt: CodeFactor

.. image:: https://img.shields.io/pypi/pyversions/ModuleUltra.svg
    :alt: PyPI - Python version

.. image:: https://img.shields.io/pypi/dm/ModuleUltra.svg
    :alt: PyPI - Downloads

.. image:: https://img.shields.io/github/license/dcdanko/ModuleUltra.svg
    :alt: Github license

Easy to use pipelines for large biological datasets.

Goals
-----

Bioinformatics pipelines often involve a large number of files with complex organization and metadata, complex paths, and lots of dependencies. ModuleUltra is intended to make it easier run and distribute complex pipelines. It is built on top of DataSuper and SnakeMake. ModuleUltra defines both an API and CLI. 

ModuleUltra is probably overkill for small projects, it has been designed in particular for the MetaSUB project which has thousands of samples and complex analysis pipelines. ModuleUltra makes it easier to do consistent analysis on thousands of samples across many sites.

MetaSUB is also developing a program called DataSuper which tracks complex data and metadata.

In summary:
 - ModuleUltra makes it easy to install complex pipelines
 - ModuleUltra makes it easy to run pipelines only on slected subsets of the data
 - ModuleUltra makes it easy to run parts of large complex pipelines
 - ModuleUltra automatically tracks output of pipelines in DataSuper
 - ModuleUltra allows you to write most of your pipelines logic in SnakeMake, a popular pipeline system
 - ModuleUltra reduces the amount of boilerplate code necessary to make a pipeline

ModuleUltra is intended to improve reproducibility, features are being added to improve file provenance.

Installation
------------

Be aware that ModuleUltra is still an Alpha. There are still bugs and some unimplemented features.

ModuleUltra is currently being used on Ubuntu and RHEL systems. It should work on any *nix system.

To install:


.. code-block:: bash
   
    git clone <url>   

    python setup.py develop


Licence
-------
MIT License

Authors
-------

`ModuleUltra` was written by `David C. Danko <dcdanko@gmail.com>`_.
allot 0.2
A more fine-grained functools.singledispatch
Requires Python: >=3.6

allot |b-pypi| |b-travis| |b-codecov|
=====================================

.. |b-pypi| image:: https://img.shields.io/pypi/v/allot.svg
   :target: https://pypi.org/project/allot
.. |b-travis| image:: https://travis-ci.com/flying-sheep/allot.svg?branch=master
   :target: https://travis-ci.com/flying-sheep/allot
.. |b-codecov| image:: https://codecov.io/gh/flying-sheep/allot/branch/master/graph/badge.svg
   :target: https://codecov.io/gh/flying-sheep/allot

Like ``functools.singledispatch``, but will allow to register multiple functions for each class.

If a registered function decides it cannot handle the value after inspecting it, it can give up and let others try their luck:

.. code:: python

   from allot import allot, Pass

   @allot
   def f(obj):
       return 'object'

   @f.register(int)
   def f_small_integer(obj):
       if obj > 10:
           return Pass
       return 'small integer'

   assert f('a string') == 'object'
   assert f(3) == 'small integer'
   assert f(10) == 'object'