semvec/pypi-packages huggingface dataset:
django-celery-model 0.2.1
django-celery-model is an extension to Celery which adds support for tracking Celery tasks assigned to Django model instances.
License: MIT

[django-celery-model](https://github.com/mback2k/django-celery-model) is an
extension to [Celery](https://github.com/celery/celery) which adds support
for tracking Celery tasks assigned to Django model instances.

Installation
------------
Install the latest version from pypi.python.org:

    pip install django-celery-model

Install the development version by cloning the source from github.com:

    pip install git+https://github.com/mback2k/django-celery-model.git

Configuration
-------------
Add the package to your `INSTALLED_APPS`:

    INSTALLED_APPS += (
        'djcelery_model',
    )

Make sure that you are receiving Celery events via:

    CELERY_TASK_TRACK_STARTED = True
    CELERY_TASK_SEND_SENT_EVENT = True
    CELERY_SEND_EVENTS = True

Example
-------
Add the TaskMixin to your Django model:

    from django.db import models
    from django.utils.translation import ugettext_lazy as _
    from djcelery_model.models import TaskMixin

    class MyModel(TaskMixin, models.Model):
        name = models.CharField(_('Name'), max_length=100)

Queue an asynchronous task from your Django model instance:

    from .models import MyModel
    from .tasks import mytask

    mymodel = MyModel.objects.get(name='test instance')
    mymodel.apply_async(mytask, ...)

Retrieve list of asynchronous tasks assigned to your Django model instance:

    mymodel.tasks.all()
    mymodel.tasks.pending()
    mymodel.tasks.started()
    mymodel.tasks.retrying()
    mymodel.tasks.failed()
    mymodel.tasks.successful()
    mymodel.tasks.running()
    mymodel.tasks.ready()

Check for a running or ready asynchronous task for your Django model instance:

    mymodel.has_running_task
    mymodel.has_ready_task

Handle asynchronous task results for your Django model instance:

    mymodel.get_task_results()
    mymodel.get_task_result(task_id)
    mymodel.clear_task_results()
    mymodel.clear_task_result(task_id)

Filter your Django model based upon asynchronous tasks:

    MyModel.objects.with_tasks()
    MyModel.objects.with_pending_tasks()
    MyModel.objects.with_started_tasks()
    MyModel.objects.with_retrying_tasks()
    MyModel.objects.with_failed_tasks()
    MyModel.objects.with_successful_tasks()
    MyModel.objects.with_running_tasks()
    MyModel.objects.with_ready_tasks()

    MyModel.objects.without_tasks()
    MyModel.objects.without_pending_tasks()
    MyModel.objects.without_started_tasks()
    MyModel.objects.without_retrying_tasks()
    MyModel.objects.without_failed_tasks()
    MyModel.objects.without_successful_tasks()
    MyModel.objects.without_running_tasks()
    MyModel.objects.without_ready_tasks()

License
-------
* Released under MIT License
* Copyright (c) 2014-2019 Marc Hoersken <info@marc-hoersken.de>
vault-printer 0.3.1
A program to get all secrets from a vault servers kv_store for printing
License: MIT
Requires Python: >=3.7

# vault_printer ![pylint 10.00][pylint-badge] [![MIT License][license-badge]](LICENSE.md) [![PyPI version][pypi-badge]][pypi-project] [![python version][pypi-python]][pypi-project]
vault_printer is a little program to extract a whole kv_store of a [Vault Server][vaultproject] to stdout in markdown.
This could be used to print it out and store it in a physical safe somewhere. Or at least that's the purpose for which I wrote it.

## Install

Get a stable version from [PyPi][pypi]

`pip install vault_printer`

or via git

`pip install git+https://github.com/DerMolly/vault_printer`

## Usage

E.g extract kv_store `test` from `vault.example.com` and login via ldap:

`vault_printer --ldap vault.example.com test >> passwords.md `

### Help

```
usage: vault_printer [-h] [--version] [-v] [--no-toc] [--no-content]
                     [--ldap | --token] [--username USERNAME]
                     [--password PASSWORD] [--tokenLogin TOKENLOGIN]
                     [url] kv_store

A program to get all secrets from a vault servers kv_store for printing

optional arguments:
  -h, --help            show this help message and exit
  --version             show program's version number and exit
  -v, --verbose         increase verbosity
  --ldap                login via ldap
  --token               login via token

server parameter:
  url                   the url of the vault server
  kv_store              the kv store to export from

output configuration:
  --no-toc              don't print the toc
  --no-content          don't print the content

login parameter:
  --username USERNAME, -u USERNAME
                        the username with which to login, if omitted you'll be
                        asked
  --password PASSWORD, -p PASSWORD
                        the password to login, if omitted you'll be asked
  --tokenLogin TOKENLOGIN, -t TOKENLOGIN
                        the token to login, if omitted you'll be asked
```


### Login

Currently the only supported login methods are:

- Token
- LDAP

Maybe I will add some more in the future. If you need another Login Method feel free to open a [issue][tracker] or even a PR.

### Environment Variables

This program also uses these environment variables if set

`$VAULT_ADDR`  : the url of the vault server  
`$VAULT_TOKEN` : the token to authenticate with the `--token` login method 


[pylint-badge]:   https://mperlet.github.io/pybadge/badges/10.00.svg
[license-badge]:  https://img.shields.io/badge/license-MIT-007EC7.svg
[pypi-badge]:     https://badge.fury.io/py/vault-printer.svg
[pypi-project]:   https://pypi.org/project/vault_printer/
[pypi-python]:    https://img.shields.io/pypi/pyversions/vault-printer
[vaultproject]:   https://www.vaultproject.io/
[pypi]:           https://pypi.org/
[tracker]:        https://github.com/DerMolly/vault_printer/issues
aioli-guestbook 0.3.3
Comprehensive RESTful HTTP API built on top of the Aioli Framework
License: MIT
Requires Python: >=3.6,<4.0
Keywords: aioli_package

aioli-guestbook: RESTful HTTP API Package Example
===

The idea with this example is to show how a CRUD-type RESTful HTTP API package can be built with the Aioli Framework.


Documentation
---

Check out the [Package Documentation](https://aioli-guestbook-example.readthedocs.io) for usage and info about the
HTTP and Service APIs.

Examples
---

Every guestbook needs a guesthouse, right?

Check out the [example directory](/example) to see how [aioli-guestbook](/aioli_guestbook) can be incorporated into an example Guesthouse Application.


Author
---
Robert Wikman \<rbw@vault13.org\>
neptune-resolver-rest 2019.9.15.1625
HTTP Request based resolver for NEPTUNE DNS SERVER
License: MIT
Keywords: NEPTUNE,REST,RESOLVER

# Neptune Resolver Rest
This module is made as a resolving middleware for Neptune DNS server
## Installation
```pip3 install neptune_resolver_rest```
## Connect to server
In config.py edit RESOLVERS variable. Add ```'neptune_resolver_rest'```
It will look like this
```RESOLVERS = ['neptune_resolver_rest']```
Then you need to set settings for this resolver. Those settings are set by creating variable in config.py with upper module name like
```NEPTUNE_RESOLVER_REST = {'base_url':'https://example.com'}```
dictondisk 1.3
Implementation of a dictionary in a temporary directory
License: MIT
Keywords: dictionary dict disk pickle

dictondisk
==========

It's a thing that implements a dictionary, but in a temporary directory.

Why?
---

I had a machine with not a lot of RAM and a script that was RAM-hungry.
Instead of optimizing the script i did _this_ montrostity.

Should you use it?
------------------

Probably not. It's slow. I'm almost certain there are many security flaws in this approach.  

How to use dictondisk?
----------------------

```python
from dictondisk import DictOnDisk

some_dict = DictOnDisk()

some_dict[1] = "One"
some_dict[2] = "Two"
some_dict[3] = "Three"

del some_dict[1]

for key, value in some_dict.items():
    print(key, value)

```

Comparison to the vanilla dict
------------------------------

|            Action            | dict() | DictOnDisk() |
|------------------------------|--------|--------------|
| Preserve insertion order     |   ✔️    |      ❌      |
| len(d)                       |   ✔️    |      ✔️       |
| d[key]                       |   ✔️    |      ✔️       |
| d[key] = value               |   ✔️    |      ✔️       |
| del d[key]                   |   ✔️    |      ✔️       |
| key in d                     |   ✔️    |      ✔️       |
| key not in d                 |   ✔️    |      ✔️       |
| iter(d)                      |   ✔️    |      ✔️       |
| d.clear()                    |   ✔️    |      ✔️       |
| d.copy()                     |   ✔️    |      ✔️       |
| d.fromkeys()                 |   ✔️    |      ✔️       |
| d.get(key[, default])        |   ✔️    |      ✔️       |
| d.items()                    |   ✔️    |      ✔️       |
| d.keys()                     |   ✔️    |      ✔️       |
| d.pop(key[, default])        |   ✔️    |      ✔️       |
| d.popitem()                  |   ✔️    |      ✔️       |
| d.setdefault(key[, default]) |   ✔️    |      ✔️       |
| d.update([other])            |   ✔️    |      ✔️       |
| d.values()                   |   ✔️    |      ✔️       |
| bool(d)                      |   ✔️    |      ✔️       |
| d1 == d2                     |   ✔️    |      ✔️       |
| d1 != d2                     |   ✔️    |      ✔️       |