monicapf 0.1.1

Python Web Frmaework built for learning purposes.

MonicaPF: Python Web Framework built for learning purposes

MonicaPF it is python web framework

It is WSGI Framework and can be used with any WSGI application server such as Gunicorn

Installation

pip install monicapf

How To Use It:

Basic Usage:

```python
from monicapf.app import Monica


app = Monica()      

Add Allowed Methods:

@app.route('/home', allowed_methods=['get'])
def home(request, response):
    if request.method == 'GET':
        response.text = 'Hello this is home page'
    elif request.method == 'POST':
        response.text = 'POST '

Simple Route:

@app.route('/about')
def about(request, response):
    response.text = 'Hello this is about page'    

Parametrize Route:

@app.route('/hello/{name}')
def hello(request, response, name):
    response.text = f"Just say hello. Hello {name}"    

Class Based Handlers:

@app.route('/books')
class Book:
    def get(self, request, response):
        response.text = 'Books GET request'

    def post(self, request, response):
        response.text = 'Books POST request'


def new_handler(req, res):
    res.text = 'New handler'

app.add_route('/new-handler', new_handler)

Json data:

@app.route('/json')
def json(req, res):
    res.json = {
        'name': 'Request',
        'Body': 'Json response',
    }
```

Add Template

Create "templates" folder and save inside that folder htmls

```python
@app.route('/template')
def template(req, res):
    res.body = app.template(
        'home.html',
        context={'name': 'Bilol', 'title': 'Template working'}
    ) 
```       

Add Static Files

Create "static" folder and save inside that folder static files


```html

<title>{{title}}</title>

{{body}}

This is a paragraph

```

MiddleWare

You can create custom middleware classes by inheriting from the monicapf.middleware.Middleware class and overriding its two methods that are called before and after each request:

from monicapf.api import API
from minocapf.middleware import Middleware


app = API()


class SimpleCustomMiddleware(Middleware):
    def process_request(self, req):
        print("Before dispatch", req.url)

    def process_response(self, req, res):
        print("After dispatch", req.url)


app.add_middleware(SimpleCustomMiddleware)

Unit Tests

The recommended way of writing unit tests is with pytest. There are two built in fixtures that you may want to use when writing unit tests with MonicaPF. The first one is app which is an instance of the main API class:

def test_route_overlap_throws_exception(app):
    @app.route("/")
    def home(req, resp):
        resp.text = "Welcome Home."

    with pytest.raises(AssertionError):
        @app.route("/")
        def home2(req, resp):
            resp.text = "Welcome Home2."

The other one is client that you can use to send HTTP requests to your handlers. It is based on the famous requests and it should feel very familiar:

    def test_parameterized_route(app, client):
    @app.route("/{name}")
    def hello(req, resp, name):
        resp.text = f"hey {name}"

    assert client.get("http://testserver/MonicaPF").text == "hey MonicaPF"