Skip to main content

RESTful Flask framework with MongoDB, Redis and Celery integrations

Project description

🙈 Dead Simple Web Framework 🙉

Python Flask MongoDB/Pymongo PyPi

Overview:

A RESTful Flask framework with MongoDB, Redis and Celery integrations:

Backend:

  • Flask [Framework]
  • MongoDB [Database]
  • Redis [Cache]
  • Celery + RabbitMQ [Async Tasks]

Installing:

$ pip install dead-simple-framework

Configuration:

TODO - DOCS

Example Application (demo.py):

* Celery must be running *

$ celery -A demo worker -l info
from dead_simple_framework import Application, Task_Manager, Database, API, Route, RouteHandler, DefaultRouteHandler, Task
from random import choice

sample_config = {
    'routes': {
        'insert': Route( # A route with automatic CRUD support
            url='/insert',
            collection='insert',
        ),
        'demo': Route( # Another route with automatic CRUD support (with all options specified)
            url='/demo',                    # The URL at which the server should handle requests
            defaults=None,                  # Default parameters to pass to the handler function for this URL
            database='db',                  # The database that should be passed to the handler function for this URL 
            collection='demo',              # The collection that should be passed to the handler function for this URL 
            handler=DefaultRouteHandler()   # A class specifying the handler functions to use based on the method used to access the URL 
        ),
        'refresh': Route(  # Route with a handler for the GET method that runs an async task (in this case an API call)
            url='/api/refresh',
            handler=RouteHandler(
                GET=lambda request, payload: str(Task_Manager.run_task('scheduled_call'))
            )
        ),
        'index': Route(  # Route that fetches the cached latest result of an async task (in this case an API call)
            url='/',
            handler=RouteHandler(
                GET=lambda request, payload: str(Task_Manager.get_result('scheduled_call'))
            )
        ),
        'add': Route(  # Route that runs an async task (in this case simple addition) and fetches the result
            url='/add',
            handler=RouteHandler(
                GET=lambda request, payload: str(Task_Manager.run_task('add'))
            )
        ),
    },

    'tasks': { # Async tasks available to the Task_Manager [celery] to schedule or run
        'add': {        # Simple Addition Task (with default arguments) 
            'logic': lambda x,y: x + y,
            'schedule': None,
            'default_args': (2,2)
        },
        'insert': {     # Periodic Database Insert Task 
            'logic': lambda res: Database(collection='insert').connect().insert_one({'test': 'doc', 'result': res}),
            'schedule': {}, # Default - every minute
            'depends_on': 'add' # Return value substituted for `res`
        },
        'call_api': {   # API Call Task
            'logic': lambda url, params=None: str(API.get(url, params, ignore_errors=False, retry_ms=10000, num_retries=20).content),
        },
        'scheduled_call': Task( # Make 3 parallel API calls
            name='scheduled_call',
            logic=lambda: Task_Manager.parallelize([['call_api', [x]] for x in get_websites(3)]),
            schedule={}
        )
    }
}


WEBSITES =[
    "http://www.google.com",
    "http://www.yahoo.com",
    "http://www.ebay.com",
    "http://www.cnn.com",
    "http://www.pbs.org",
    "https://www.reddit.com/",
]

def get_websites(n):
    _websites = [*WEBSITES]
    res = []
    for x in range(n):
        res.append(choice(_websites))
        _websites.remove(res[-1])

    return res


app = Application(sample_config)
if __name__ == '__main__':
    app.run()
  • Starts a local server at http://0.0.0.0:5000/

  • Serves CRUD operations for MongoDB collection demo at endpoint /demo

  • Runs an asynchronous chained value calculation and insert into the insert collection (viewable at /insert)

  • Runs asynchronous parallel API calls and displays the latest result at endpoint / (can be manually run at /api/refresh)

Project details


Release history Release notifications | RSS feed

Download files

Download the file for your platform. If you're not sure which to choose, learn more about installing packages.

Source Distribution

dead_simple_framework-0.9.9.tar.gz (31.7 kB view hashes)

Uploaded Source

Built Distribution

dead_simple_framework-0.9.9-py3-none-any.whl (42.1 kB view hashes)

Uploaded Python 3

Supported by

AWS AWS Cloud computing and Security Sponsor Datadog Datadog Monitoring Fastly Fastly CDN Google Google Download Analytics Microsoft Microsoft PSF Sponsor Pingdom Pingdom Monitoring Sentry Sentry Error logging StatusPage StatusPage Status page