semvec/pypi-packages huggingface dataset:
django-minio-storage-py-pa 0.0.2
Django file storage using the minio python client
License: MIT

# django-minio-storage

[![Build Status](https://travis-ci.org/py-pa/django-minio-storage.svg?branch=master)](https://travis-ci.org/py-pa/django-minio-storage)

# IMPORTANT NOTE ABOUT THIS FORK

- This is a fork https://github.com/tomhoule/django-minio-storage with fixes
  and improvements.

- The final goal of this fork is do fixes and make the project ready to be
  maintained by [jazzband](https://jazzband.co/).

- Avoiding forking is always preferable so if the original maintainer can get
  involved in this process we would be very happy.

- This fork attempts to not break API's which exists in release versions unless
  the API's themselves are broken.

- This fork currently does not officially support python 2, if the original
  maintainer gets involved and strongly disagree with this decision py2 support
  can be reinstated (No active removal has been done except for the Travis)

- Depending on future maintainer circumstances **this repository might be fully
  removed or moved** and **the -py-pa suffixed packages released to pypi.org
  will stop being published and in removed 6 months after the last published
  version.**

# django-minio-storage

Use [minio](https://minio.io) for django static and media file storage.

Minio is accessed through the Amazon S3 API, so existing django file
storage adapters for S3 should work, but in practice they are hard to
configure. This project uses the minio python client instead. Inspiration has
been drawn from `django-s3-storage` and `django-storages`.

# usage & documentation

See the [docs/](docs/) directory for all documentation files or 
[docs/usage.md](docs/usage.md) for quick installation and usage guides.
tails 0.0.1
Utilities for Sanic apps
License: MIT
Keywords: sanic

Tails: A Sidekick for Sanic apps
================================

A collection of utilities for Sanic (and/or Stellata and/or Webpack)
apps.

CLI
---

Suppose you have a project called ``foo``.

Run database migrations:

::

    tails foo migrate

Build webpack assets:

::

    tails foo build

Run a debug server that reloads on server + asset changes:

::

    tails foo server --watch --build

Run a production server:

::

    tails foo server --production --host=0.0.0.0 --port=9000

Run multiple projects at once:

::

    tails ~/foo/foo ~/bar/bar server --port=9001 --port=9002

Reset to a fresh database with no data:

::

    tails foo reset

Resource
--------

Return JSON or HTML pages:

::

    import foo
    import tails.resource

    @foo.app.route('/')
    async def index():
        return tails.resource.html(
            title='What a great page',
            external_css=['https://fonts.googleapis.com/icon?family=Material+Icons'],
            js=['/static/build/js/index.js'],
            css['/static/build/css/index.css']
        )

    @foo.app.route('/api')
    async def api():
        data = ...
        return tails.resource.json({
            'data': data
        })
rupee 0.0.1
A fully-featured cache for Python applications.
License: MIT
Keywords: cache caching redis memcache memcached

Rupee: Python [STRIKEOUT:Cashing] Caching
=========================================

Rupee is a simple, but fully-featured caching library for Python 3.

Engines
-------

Rupee supports caching using process memory, Redis, and Memcached.

For Redis support:

::

    pip install redis

For Memcached support, you can use ``pylibmc``:

::

    pip install pylibmc

or ``python-memcache``:

::

    pip install python-memcache

Cache Access
------------

You can create cache instances like this:

::

    memory = rupee.engine.Memory()
    memcached = rupee.engine.Memcached(['localhost:11211'])
    redis = rupee.engine.Redis('localhost:6379')

All instances conform to the same API, which offer the get/set/delete
operations you'd expect:

::

    cache = rupee.engine.Memcached(['localhost:11211'])
    cache.set('foo', 'bar', ttl=3600)
    cache.set_multi({'baz': 1, 'qux': 2})
    cache.get('baz') == 1
    cache.get_multi(['foo', 'qux']) == {'foo': 'bar', 'qux': 2}
    cache.delete('qux')
    cache.delete_all(['foo', 'baz'])
    cache.delete_all_data()

Cached Decorators
-----------------

You can decorate functions to be cache their results:

::

    cache = rupee.engine.Redis('localhost:6379')

    @rupee.cached(cache, ttl=3600)
    def foo(bar, baz):
        return _some_expensive_thing(bar, baz)

To clear the cache entry for a function call:

::

    foo.dirty(1, 2)

For functions that perform bulk operations, you can use the multi-cache
decorator:

::

    @rupee.multi_cached(cache):
    def get(items):
        return {item: _some_expensive_thing(item) for item in items}

Functions decorated with ``multi_cached`` must take a single list as an
argument and return a dictionary keyed on the items in that list. Then,
results for each item will be cached separately, and only the needed
items will be passed to the function. To illustrate:

::

    get([1, 2, 3]) # calls _some_expensive_thing on 1, 2, and 3
    get([1, 2, 3]) # _some_expensive_thing is never called
    get([2, 3, 4]) # calls _some_expensive_thing only on 4