pypolyback 0.12.7

DIRECTORIES

/pypolyback (*) - api internal files
/config - json configuration files
/endpoints - backend endpoints
/utils - helper script files

Note (\*): The dir pypolyback will only exists if you didn't install
``pypolyback``'s library from pip

API

Here is present all api files that work behind the endpoints

CONFIG

Here are the configuration files used in the app. They will be send to the endpoint via param api.config

There are 3 special filenames: * prod.json - The oficial configuration file * dev.json - The development configuration file * local.json - The local configuration file (ignore in git)

Note: They really work as following: the api tries to load local.json, then dev.json, then prod.json. So in the oficial release you will only have prod.json

The current config special properties are the following:

{
    "log": bool, //optional. default=False
    "server": {
        "port": int, //optional. default=8888
        "cors": string or False //optional. default=False
    },
    "mail": {
        "host": string,
        "port": int, //optional. default=25 or 587 for TLS
        "tls": bool, //optional. default=False
        "username?": string, //optional. no default
        "password?": string //optional. no default
    }
}

ENDPOINTS

This will be your main dev dir

All files added here will be an endpoint automatically

i.e.: the file endpoints/test/helloworld.py will generate an endpoint /test/helloworld

The file’s code will be the following:

utils = [
    '[util1]',
    '[util2]'
]
[@async]
def [method](req, api):
    [process]

Where [method] is the http request type: * post * get * put * delete * head * options * default - executed when a request is made for any of the above, but it is not implemented

[process] is what you wan the endpoint to do (your code)

[util1] and [util2] are the utils scripts (without .py)

req is cyclone’s request, with these properties included: * params - arguments received from request, an object (primitive, list or dictionary) * send - function to respond the request with an object

req’s complete documentatios in present on cyclone’s site http://cyclone.io/documentation/web.html

api is the object that contains all api functionalities: * config - Configuration dictionary used in the actual scope * debug - function to log messages * error - function to log errors

[@async] is an optional annotation, that makes this method asynchronous.

Note: if async is used you will need to import it (from pypolyback import async)

async complete doc is the same as twisted’s inlineCallback https://twistedmatrix.com/documents/current/api/twisted.internet.defer.html#inlineCallbacks

UTILS

Python files with reusable code, to be called on endpoints.

It will be a normal cod, but with some special funcions:

init(api)

The function that will be executed on server startup
Only one time.

[method](req, api) - [method] being the type of http request

The function that will be called before every request to the function with the same name on the endpoint.
Any result should be stored on the variable `req`, because it is the only local variable on the request.

any(req, api)

The function that will be executed before any request.
Note: thids function will be executed before the later.

APP.py

This file is not needed if you installed from pip

An executable to start your server

STARTING THE SERVER

There are 2 ways to start the server

1. Execute pypolyback --start from terminal on your root project folder (Recomended)

2. Call the method start() from module pypolyback.server (Only recomended if you need to do something before starting the server)