producti_gestio.core package


That’s the core part of the module. It is used to handle the requests and call the user-defined function.



It checks if a request is valid using Filters.

producti_gestio.core.check.check(filters: object = None) → <built-in function callable>

This function is used to check if a request is valid using filters.

It could be used only when the Server is using the function mode (alias using decorator, not handlers).

Here an example:

from producti_gestio import Server, check, Decorator, Filters

@producti_gestio.Decorator # Using this Decorator, the next function will become the server-creator function
def my_server(**kwargs):
    print("Initializing the server")

    @producti_gestio.check(Filters.get) # Using this Decorator, the handler function will check for the requirements (using Filters)
    def my_function(**kwargs):
        return {
            'response_code': 200, # The response code
            'response': {
                'ok': True,
                'message': 'Hello world!'

    return my_function

my_server(allow_get=True) # Create and start the server instance using threads

while True:
  • func (callable) – The native handler function
  • filters (Filter or None) – A Filter object or a None type
  • filters – object or None: (Default value = None)

A callable object

Return type:


producti_gestio.core.request_handler module


It handles the requests checking the configuration, then pass all parameters and headers to the user-defined function.

A request handler must have these requirements:

  • Have a do_GET function
  • Have a do_POST function

When a Server instance is started, the request handler will get the configuration under self.configuration and the handlers under self.handlers.

class producti_gestio.core.request_handler.RequestHandler(request, client_address, server)

Bases: http.server.BaseHTTPRequestHandler

The RequestHandler class is used to handle all requests, after they are checked using the configuration.

It has got two needed methods: do_GET and do_POST, they will be called by the HTTPServer classes, based on the type of the request.

Actually, HEAD and PUT request methods are not supported.

configuration = {'allow_get': False, 'allow_post': True, 'debug': False, 'function': <function RequestHandler.<lambda> at 0x7f58656868c8>, 'ip': '', 'port': 8000}
do_GET() → bool

The GET requests handler, it checks if GET is allowed as method and then parse the request and pass it to a defined function and return a response.

Returns:True if the request succeeded, False if not or GET is not allowed.
Return type:bool
do_POST() → bool

The POST requests handler, it checks if POST is allowed as method and then parse the request and pass it to a defined function and return a response.

Returns:True if the request succeeeded, False if not or POST is not allowed.
Return type:bool
do_request(request_infos: dict) → bool

The do_request function is used to get a response from the handler function or from one of the Handlers and send it to the user.

Parameters:request_infos (dict) – A dictionary that will be passed to the Handler function or the Handler.
Returns:True if all went right, otherwise False.
Return type:bool
handlers = []
parse_post() → <function NewType.<locals>.new_type at 0x7f58656867b8>

The POST parameters parser. It checks the self.headers dictionary, its content-type and if it is ‘multipart/form-data’ or ‘application/x-www-form-urlencoded’, then parses the POST parameters.

Returns:POST parameters in a dictionary, where the keys are the parameter names and the values are their values.
Return type:dict
use_handler = False