semvec/pypi-packages huggingface dataset:
cache4py 0.0.1
Caching simplified.
License: MIT
Requires Python: >=3.6.0


# cache4py: Caching simplified.

## Getting started

### Installation
Install using pip: `$ pip install cache4py`

### Usage
```python
from cache4py.decorators import cache
from cache4py.storage.redis import RedisBackend

# You can choose memcached, redis or default (python's dict) as a backend.
redis_backend = RedisBackend(url='localhost', port='6379')

@cache(backend=redis_backend)
def my_function_one(*args, **kwargs):
    # do something awesome
    return
```

### Options
1. Keys
2. Eviction policies (coming soon)
3. Backend
4. Max memory limit (coming soon)
5. Key expiry time (coming soon)



## Contributing to cache4py

Refer CONTRIBUTING.md

## Issue tracking

Create issues at [cache4py/issues](https://github.com/nitinl/cache4py/issues).

## Authors

* **Nitin Labhishetty ([lnitin94@gmail.com](mailto:lnitin94@gmail.com))**
* **Vaibhav Tulsyan ([vstulsyan@gmail.com](mailto:vstulsyan@gmail.com))**
tflunifiedapi 0.2.1
Python wrapper for Transport for London (TfL) Unified API
License: MIT

# TfL-python-api

Transport for London (TfL) Unified API is released [here](https://api.tfl.gov.uk/) is for open data users to use in their own software and services. 

## Get Started

To use the TfL Unified API, developers should [register](https://api-portal.tfl.gov.uk/) for an Application ID (`app_id`) and Application Key (`app_key`).

```python
from tfl.client import Client
from tfl.api_token import ApiToken

app_id = 'APPLICATION ID'
app_key = 'APPLICATION KEY'

token = ApiToken(app_id, app_key)

client = Client(token)
print (client.get_line_meta_modes())
print (client.get_lines(mode="bus")[0])
print (client.get_lines(line_id="victoria")[0])
```

## API Documentation

This Python library provide a thin wrapper around the TfL Unified APIs. See the [Transport for London Unified API](https://api.tfl.gov.uk/) for more details.
obj.server.udp 4
udp listening server that can echo udp datagram to channels.
License: MIT


OBJ.SERVER.UDP is a package part of the OBJ namespace. It provides a server that can relay udp datagrams to channels. 

OBJ is a pure python package that provides an object class that can save/load objects in JSON format to disk.
Files are saved with a timestamp in their filename, so searching in a time related manner becomes possible.

OBJ has a "no-clause MIT license" that should be the most liberal license you can get at the year 2018.

| pypi: https://pypi.org/project/obj | source: http://bitbucket.org/bthate/obj | email: bthate@dds.nl

modules
=======

OBJ contains the following modules:

::

 base		- the base module containing the Object class providing load/save to JSON functionality.
 bots		- bots package.
 bus		- send text to a list of registered handlers.
 cli		- the command line interface bot giving access to the bot from the shell.
 cmds		- commands subpackage containing the above listed commands.
 db		- database functionality that can search through objects stored on disk.
 event		- the Event class generated on bots when data is read from the socket.
 handler	- the event handler of the bot.
 loader		- Loader class to load modules from ob space into the program.
 shell		- shell related startup, cli arguments parsing and logging.
 thr		- thread module to launch, kill threads.
 users		- provides user management code.

usage
=====

The basic class is Object that inherits from object and add load/save methods to a standard object:

 >>> from obj.base import Object
 >>> o = Object()
 >>> p = o.save()
 >>> oo = Object()
 >>> oo.load(p)   
 >>> o == oo
 >>> True

Next class is Obj, a dict combined with Object provides a usable "dotted access" dict:

 >>> from obj.base import Obj
 >>> o = Obj()
 >>> o.test = "test1"
 >>> p = o.save()
 >>> oo = Obj()
 >>> oo.load(p)
 >>> oo.test == "test1"
 >>> True

shell
=====

You can get a OBJ shell working by running python3 -m obj.bots.shell.

OBJ shell has the following commands::

 cfg		- show config files.
 cmds		- show list of commands.
 deleted	- show deleted objects.
 ed		- edit saved objects.
 exit		- stop the CLI.
 find		- find objects in the datastore.
 fleet		- show list of registered handlers.
 kill		- stop a thread.
 last		- show last record of a object.
 load		- load a module.
 log		- log some text.
 ls		- list subdirectories in the workdir.
 meet		- add a user
 perm		- change permissions of a user.
 ps		- show running threads.
 reboot		- reboot the CLI.
 rm		- set the deleted flag on an object.
 rmperm		- remove permissions.
 test		- echo test response.
 todo		- store a todo item.
 unload		- unload a module.
 uptime 	- show uptime.
 user		- user lookup.
 version	- show OBJ version.

programming
===========

Programming your own commands for the CLI is easy, your can load modules with the -m option.
A command is a function with one argument, the event that was generated on the bot::

 def mycommand(event):

     <<< your code here >>>

You can use event.reply() to send response back to the user.