tina4-python 0.2.22__tar.gz → 0.2.25__tar.gz

{tina4_python-0.2.22 → tina4_python-0.2.25}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: tina4-python
-Version: 0.2.22
+Version: 0.2.25
 Summary: Tina4Python - This is not another framework for Python
 Author: Andre van Zuydam
 Author-email: andrevanzuydam@gmail.com

{tina4_python-0.2.22 → tina4_python-0.2.25}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "tina4-python"
-version = "0.2.22"
+version = "0.2.25"
 description = "Tina4Python - This is not another framework for Python"
 authors = ["Andre van Zuydam <andrevanzuydam@gmail.com>"]
 readme = "README.md"

tina4_python-0.2.25/tina4_python/.env

@@ -0,0 +1,7 @@
+# Project Settings
+PROJECT_NAME="My Project"
+VERSION=1.0.0
+TINA4_LANGUAGE=en
+TINA4_SECRET=ABCDEF
+TINA4_DEBUG_LEVEL=[TINA4_LOG_ALL]
+API_KEY=f9ca99e18c7bce9c6852df4257a3280b

{tina4_python-0.2.22 → tina4_python-0.2.25}/tina4_python/Debug.py

@@ -66,7 +66,8 @@ class Debug:
                 print(output, "", end="")
             print()
 
-            sys.stdout.flush()
+            if sys.stdout is not None:
+                sys.stdout.flush()
 
         handler.flush()
         logger.removeHandler(handler)

tina4_python-0.2.25/tina4_python/MiddleWare.py

@@ -0,0 +1,71 @@
+
+
+class MiddleWare:
+    def __init__(self, middleware_class):
+        """
+
+        :param middleware_class:
+        """
+        self.before_methods = []
+        self.after_methods = []
+        self.any_methods = []
+        self.middleware_class = middleware_class
+
+        self.methods_list = [method for method in vars(middleware_class) if callable(
+            getattr(middleware_class, method)) and not method.startswith("__")]
+
+        for method in self.methods_list:
+            if method.startswith("before"):
+                self.before_methods.append(method)
+            elif method.startswith("after"):
+                self.after_methods.append(method)
+            else:
+                self.any_methods.append(method)
+
+    def call_before_methods(self, request, response):
+        """
+        Call before methods
+        :param request:
+        :param response:
+        :return:
+        """
+        for method in self.before_methods:
+            method = getattr(self.middleware_class, method)
+            request, response = method(request, response)
+        return request, response
+
+    def call_after_methods(self, request, response):
+        """
+        Call after methods
+        :param request:
+        :param response:
+        :return:
+        """
+        for method in self.after_methods:
+            method = getattr(self.middleware_class, method)
+            request, response = method(request, response)
+        return request, response
+
+    def call_any_methods(self, request, response):
+        """
+        Call any methods
+        :param request:
+        :param response:
+        :return:
+        """
+        for method in self.any_methods:
+            method = getattr(self.middleware_class, method)
+            request, response = method(request, response)
+        return request, response
+
+    def call_direct_method(self, request, response, method_name):
+        """
+        Call direct methods
+        :param request:
+        :param response:
+        :param method_name:
+        :return:
+        """
+        method = getattr(self.middleware_class, method_name)
+        request, response = method(request, response)
+        return request, response

tina4_python-0.2.25/tina4_python/Request.py

@@ -0,0 +1,18 @@
+#
+# Tina4 - This is not a 4ramework.
+# Copy-right 2007 - current Tina4
+# License: MIT https://opensource.org/licenses/MIT
+#
+# flake8: noqa: E501
+import inspect
+
+request = None
+body = None
+params = {}
+headers = {}
+cookies = {}
+url = None
+session = None
+files = {}
+raw_data = None
+raw_content = None

tina4_python-0.2.25/tina4_python/Response.py

@@ -0,0 +1,96 @@
+#
+# Tina4 - This is not a 4ramework.
+# Copy-right 2007 - current Tina4
+# License: MIT https://opensource.org/licenses/MIT
+#
+# flake8: noqa: E501
+import json
+import inspect
+from types import ModuleType
+
+from markdown_it.common.utils import isStrSpace
+
+from tina4_python import Constant
+from tina4_python import DatabaseResult
+from tina4_python.Debug import Debug
+
+headers = {}
+content = ""
+http_code = Constant.HTTP_OK
+content_type = Constant.TEXT_HTML
+
+
+class Response:
+    def __init__(self, content_in=None, http_code_in=None, content_type_in=None,
+                 headers_in=None):
+        global headers
+        global content
+        global http_code
+        global content_type
+
+        if (not isinstance(content_in, bool) and not isinstance(content_in, object)
+                and not isinstance(content_in, bytes)
+                and not isinstance(content_in, str)
+                and not isinstance(content_in, list) and inspect.isclass(type(content_in))):
+            content_in = dict(content_in)
+
+        # check if database result
+        if type(content_in) is DatabaseResult.DatabaseResult:
+            content_type = Constant.APPLICATION_JSON
+            content_in = content_in.to_json()
+
+        # convert the dictionary or list into JSON
+        if not isinstance(content_in, bool) and type(content_in) is dict or type(content_in) is list:
+            content_in = json.dumps(content_in)
+            content_type = Constant.APPLICATION_JSON
+
+        if isinstance(content_in, bool):
+            if content_in:
+                content_in = "True"
+            else:
+                content_in = "False"
+
+        if isinstance(content_in, ModuleType):
+            content_in = json.dumps({"error": "Cannot decode object of type " + str(type(content_in))})
+            content_type = Constant.APPLICATION_JSON
+
+        if content is not None and isinstance(content_in, str):
+            content_in = content + content_in
+
+        self.headers = headers_in if headers_in is not None else headers
+        self.content = content_in if content_in is not None else content
+        self.http_code = http_code_in if http_code_in is not None else http_code
+        self.content_type = content_type_in if content_type_in is not None else content_type
+        headers = self.headers
+        http_code = self.http_code
+        content_type = self.content_type
+        content = self.content
+
+    @staticmethod
+    def redirect(redirect_url):
+        """
+        Redirects a request to redirect_url
+        :param redirect_url:
+        :return:
+        """
+        global headers
+        global content
+        global http_code
+        global content_type
+        headers = {}
+        http_code = Constant.HTTP_REDIRECT
+        headers["Location"] = redirect_url
+        content = ""
+        content_type = Constant.TEXT_HTML
+        return Response("", http_code, content_type, headers)
+
+    @staticmethod
+    def add_header(key, value):
+        """
+        Adds a header for the response
+        :param key:
+        :param value:
+        :return:
+        """
+        global headers
+        headers[key] = value

{tina4_python-0.2.22 → tina4_python-0.2.25}/tina4_python/Router.py

@@ -13,9 +13,10 @@ import io
 import tina4_python
 from tina4_python import Constant
 from tina4_python.Debug import Debug
+from tina4_python import Response
 from tina4_python import Request
-from tina4_python.Response import Response
 from tina4_python.Template import Template
+from tina4_python.MiddleWare import MiddleWare
 
 
 class Router:
@@ -59,18 +60,28 @@ class Router:
     # Renders the URL and returns the content
     @staticmethod
     async def get_result(url, method, request, headers, session):
+        global Request
+        global Response
+
+        Response.headers = {}
+        Response.content = ""
+        Response.http_code = Constant.HTTP_OK
+        Response.content_type = Constant.TEXT_HTML
+        result = None
+
         Debug("Root Path " + tina4_python.root_path + " " + url, method, Constant.TINA4_LOG_DEBUG)
         tina4_python.tina4_current_request["url"] = url
         tina4_python.tina4_current_request["headers"] = headers
 
         # we can add other methods later but right now we validate posts
-        if method in [Constant.TINA4_GET, Constant.TINA4_POST, Constant.TINA4_PUT, Constant.TINA4_PATCH, Constant.TINA4_DELETE]:
+        if method in [Constant.TINA4_GET, Constant.TINA4_POST, Constant.TINA4_PUT, Constant.TINA4_PATCH,
+                      Constant.TINA4_DELETE]:
             content_type = "text/html"
             if "content-type" in headers:
                 content_type = headers["content-type"]
 
             if content_type == "application/json":
-                content = {"error": "403 - Forbidden", "data": {"server": {"url": url}}};
+                content = {"error": "403 - Forbidden", "data": {"server": {"url": url}}}
             else:
                 content = Template.render_twig_template(
                     "errors/403.twig", {"server": {"url": url}})
@@ -93,14 +104,11 @@ class Router:
                     validated = True
 
             if not validated and method != Constant.TINA4_GET:
-                return Response(content, Constant.HTTP_FORBIDDEN, Constant.TEXT_HTML)
+                return Response.Response(content, Constant.HTTP_FORBIDDEN, Constant.TEXT_HTML)
             else:
                 if request["body"] is not None and "formToken" in request["body"]:
                     del request["body"]["formToken"]
 
-        # default response
-        result = Response("", Constant.HTTP_NOT_FOUND, Constant.TEXT_HTML)
-
         # split URL and extract query string
         url_parts = url.split('?')
         url = url_parts[0]
@@ -111,23 +119,25 @@ class Router:
         if os.path.isfile(static_file):
             mime_type = mimetypes.guess_type(url)[0]
             with open(static_file, 'rb') as file:
-                return Response(file.read(), Constant.HTTP_OK, mime_type)
+                return Response.Response(file.read(), Constant.HTTP_OK, mime_type)
 
         old_stdout = None
+        buffer = io.StringIO()
         for route in tina4_python.tina4_routes.values():
             if route["method"] != method:
                 continue
             Debug("Matching route " + route['route'] + " to " + url, Constant.TINA4_LOG_DEBUG)
             if Router.match(url, route['route']):
-                if  "swagger" in route and route["swagger"] is not None and "secure" in route["swagger"]:
+                if "swagger" in route and route["swagger"] is not None and "secure" in route["swagger"]:
                     if route["swagger"]["secure"] and not validated:
-                        return Response(content, Constant.HTTP_FORBIDDEN, Constant.TEXT_HTML)
+                        return Response.Response(content, Constant.HTTP_FORBIDDEN, Constant.TEXT_HTML)
 
                 router_response = route["callback"]
 
                 # Add the inline variables  & construct a Request variable
                 request["params"].update(Router.variables)
 
+
                 Request.request = request  # Add the request object
                 Request.headers = headers  # Add the headers
                 Request.params = request["params"]
@@ -140,31 +150,56 @@ class Router:
 
                 tina4_python.tina4_current_request = Request
 
-                old_stdout = sys.stdout # Memorize the default stdout stream
+                old_stdout = sys.stdout  # Memorize the default stdout stream
                 sys.stdout = buffer = io.StringIO()
-                result = await router_response(request=Request, response=Response)
 
-                if "cache" in route and route["cache"] is not None:
-                    if not route["cache"]["cached"]:
-                        result.headers["Cache-Control"] = "max-age=1, must-revalidate"
-                        result.headers["Pragma"] = "no-cache"
-                        result.headers["Clear-Site-Data"] =  "cache"
+                if "middleware" in route:
+                    middleware_runner = MiddleWare(route["middleware"]["class"])
+
+                    if "methods" in route["middleware"]:
+                        for method in route["middleware"]["methods"]:
+                            Request, Response = middleware_runner.call_direct_method(Request, Response, method)
                     else:
-                        result.headers["Cache-Control"] = "max-age="+str(route["cache"]["max_age"])+", must-revalidate"
-                        result.headers["Pragma"] = "cache"
-                else:
-                    result.headers["Cache-Control"] = "max-age=-1, must-revalidate"
-                    result.headers["Pragma"] = "cache"
+                        Request, Response = middleware_runner.call_before_methods(Request, Response)
+                        Request, Response = middleware_runner.call_any_methods(Request, Response)
+
+                result = await router_response(request=Request, response=Response.Response)
+
+                if "middleware" in route:
+                    middleware_runner = MiddleWare(route["middleware"]["class"])
 
+                    if "methods" in route["middleware"]:
+                        for method in route["middleware"]["methods"]:
+                            Request, result = middleware_runner.call_direct_method(Request, result, method)
+                    else:
+                        Request, result = middleware_runner.call_after_methods(Request, result)
+                        Request, result = middleware_runner.call_any_methods(Request, result)
+
+                if result is not None:
+                    if "cache" in route and route["cache"] is not None:
+                        if not route["cache"]["cached"]:
+                            result.headers["Cache-Control"] = "max-age=1, must-revalidate"
+                            result.headers["Pragma"] = "no-cache"
+                        else:
+                            result.headers["Cache-Control"] = "max-age=" + str(
+                                route["cache"]["max_age"]) + ", must-revalidate"
+                            result.headers["Pragma"] = "cache"
+                    else:
+                        result.headers["Cache-Control"] = "max-age=-1, must-revalidate"
+                        result.headers["Pragma"] = "cache"
 
                 break
 
         if result is None:
-            sys.stdout = old_stdout
+            if old_stdout is not None:
+                sys.stdout = old_stdout
+            else:
+                sys.stdout = buffer = io.StringIO()
+
             try:
-                return Response(json.loads(buffer.getvalue()), Constant.HTTP_OK, Constant.APPLICATION_JSON)
+                return Response.Response(json.loads(buffer.getvalue()), Constant.HTTP_OK, Constant.APPLICATION_JSON)
             except:
-                return Response(buffer.getvalue(), Constant.HTTP_OK, Constant.TEXT_HTML)
+                return Response.Response(buffer.getvalue(), Constant.HTTP_OK, Constant.TEXT_HTML)
 
         # If no route is matched, serve 404
         if result.http_code == Constant.HTTP_NOT_FOUND:
@@ -184,12 +219,12 @@ class Router:
                 result.headers["Pragma"] = "no-cache"
                 content = Template.render_twig_template(twig_file, {"request": tina4_python.tina4_current_request})
                 if content != "":
-                    return Response(content, Constant.HTTP_OK, Constant.TEXT_HTML, result.headers)
+                    return Response.Response(content, Constant.HTTP_OK, Constant.TEXT_HTML, result.headers)
 
         if result.http_code == Constant.HTTP_NOT_FOUND:
             content = Template.render_twig_template(
                 "errors/404.twig", {"server": {"url": url}})
-            return Response(content, Constant.HTTP_NOT_FOUND, Constant.TEXT_HTML)
+            return Response.Response(content, Constant.HTTP_NOT_FOUND, Constant.TEXT_HTML)
 
         return result
 
@@ -209,7 +244,8 @@ class Router:
     def add(method, route, callback):
         Debug("Adding a route: " + route, Constant.TINA4_LOG_DEBUG)
         if not callback in tina4_python.tina4_routes:
-            tina4_python.tina4_routes[callback] = {"route": route, "callback": callback, "method": method, "swagger": None, "cached": False}
+            tina4_python.tina4_routes[callback] = {"route": route, "callback": callback, "method": method,
+                                                   "swagger": None, "cached": False}
         else:
             tina4_python.tina4_routes[callback]["route"] = route
             tina4_python.tina4_routes[callback]["callback"] = callback
@@ -227,6 +263,7 @@ def get(path: str):
     :param arguments:
     :return:
     """
+
     def actual_get(callback):
         route_paths = path.split('|')
         for route_path in route_paths:
@@ -242,6 +279,7 @@ def post(path):
     :param path:
     :return:
     """
+
     def actual_post(callback):
         route_paths = path.split('|')
         for route_path in route_paths:
@@ -257,6 +295,7 @@ def put(path):
     :param path:
     :return:
     """
+
     def actual_put(callback):
         route_paths = path.split('|')
         for route_path in route_paths:
@@ -272,6 +311,7 @@ def patch(path):
     :param path:
     :return:
     """
+
     def actual_patch(callback):
         route_paths = path.split('|')
         for route_path in route_paths:
@@ -287,6 +327,7 @@ def delete(path):
     :param path:
     :return:
     """
+
     def actual_delete(callback):
         route_paths = path.split('|')
         for route_path in route_paths:
@@ -295,6 +336,7 @@ def delete(path):
 
     return actual_delete
 
+
 def cached(is_cached, max_age=60):
     """
     Sets whether the route is cached or not
@@ -302,10 +344,28 @@ def cached(is_cached, max_age=60):
     :param max_age:
     :return:
     """
+
     def actual_cached(callback):
         if callback not in tina4_python.tina4_routes:
             tina4_python.tina4_routes[callback] = {}
         tina4_python.tina4_routes[callback]["cache"] = {"cached": is_cached, "max_age": max_age}
         return callback
 
-    return actual_cached
+    return actual_cached
+
+
+def middleware(middleware, specific_methods=[]):
+    """
+    Sets middleware for the route and methods that need to be called
+    :param middleware:
+    :param specific_methods:
+    :return:
+    """
+
+    def actual_middleware(callback):
+        if callback not in tina4_python.tina4_routes:
+            tina4_python.tina4_routes[callback] = {}
+        tina4_python.tina4_routes[callback]["middleware"] = {"class": middleware, "methods": specific_methods}
+        return callback
+
+    return actual_middleware

{tina4_python-0.2.22 → tina4_python-0.2.25}/tina4_python/Webserver.py

@@ -125,7 +125,7 @@ class Webserver:
                              "Origin, X-Requested-With, Content-Type, Accept, Authorization", headers)
             self.send_header("Access-Control-Allow-Credentials", "True", headers)
             self.send_header("Content-Type", response.content_type, headers)
-            self.send_header("Content-Length", str(len(response.content)), headers)
+            # self.send_header("Content-Length", str(len(response.content)), headers)
             self.send_header("Connection", "Keep-Alive", headers)
             self.send_header("Keep-Alive", "timeout=5, max=30", headers)