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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: tina4-python
-Version: 0.2.22
+Version: 0.2.24
 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.24}/pyproject.toml

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

tina4_python-0.2.24/tina4_python/.env

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

tina4_python-0.2.24/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.24/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.24/tina4_python/Response.py

@@ -0,0 +1,94 @@
+#
+# 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 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 content is not None:
+            content_in = content + content_in
+
+        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
+
+        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.24}/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,27 @@ 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
+        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 +103,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,7 +118,7 @@ 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
         for route in tina4_python.tina4_routes.values():
@@ -119,15 +126,16 @@ class Router:
                 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 +148,53 @@ 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"
+                            result.headers["Clear-Site-Data"] = "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
             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 +214,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 +239,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 +258,7 @@ def get(path: str):
     :param arguments:
     :return:
     """
+
     def actual_get(callback):
         route_paths = path.split('|')
         for route_path in route_paths:
@@ -242,6 +274,7 @@ def post(path):
     :param path:
     :return:
     """
+
     def actual_post(callback):
         route_paths = path.split('|')
         for route_path in route_paths:
@@ -257,6 +290,7 @@ def put(path):
     :param path:
     :return:
     """
+
     def actual_put(callback):
         route_paths = path.split('|')
         for route_path in route_paths:
@@ -272,6 +306,7 @@ def patch(path):
     :param path:
     :return:
     """
+
     def actual_patch(callback):
         route_paths = path.split('|')
         for route_path in route_paths:
@@ -287,6 +322,7 @@ def delete(path):
     :param path:
     :return:
     """
+
     def actual_delete(callback):
         route_paths = path.split('|')
         for route_path in route_paths:
@@ -295,6 +331,7 @@ def delete(path):
 
     return actual_delete
 
+
 def cached(is_cached, max_age=60):
     """
     Sets whether the route is cached or not
@@ -302,10 +339,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.24}/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)
 

tina4_python-0.2.24/tina4_python/secrets/domain.cert

@@ -0,0 +1,21 @@
+-----BEGIN CERTIFICATE-----
+MIIDYDCCAkigAwIBAgIUJjBSwd6Q0OCzupqeXqQ7hO8tFNYwDQYJKoZIhvcNAQEL
+BQAwXDELMAkGA1UEBhMCWkExFTATBgNVBAgMDFdFU1RFUk4gQ0FQRTESMBAGA1UE
+BwwJQ0FQRSBUT1dOMQ4wDAYDVQQKDAVUaW5hNDESMBAGA1UEAwwJbG9jYWxob3N0
+MCAXDTI0MDcyNzA4MjQxNVoYDzIyOTgwNTExMDgyNDE1WjBcMQswCQYDVQQGEwJa
+QTEVMBMGA1UECAwMV0VTVEVSTiBDQVBFMRIwEAYDVQQHDAlDQVBFIFRPV04xDjAM
+BgNVBAoMBVRpbmE0MRIwEAYDVQQDDAlsb2NhbGhvc3QwggEiMA0GCSqGSIb3DQEB
+AQUAA4IBDwAwggEKAoIBAQDto8HrQp5L2dFwgutTfct8BxRxfQ+9O4kHyWzhzeO4
+WvLeDqyAA46HsPcb8Ku6hW+SWht9REToALr4hKXCFxUo6KP9KBNkrA0fZsjQM5SP
+Cc197WAL3AG3XpzqN13bOiphVeqLSqAPCZEitd6YQ8IdBHgNX/+JrC8t7KFBzyVx
+nCnTfO5ixdaeKQZhFMcIFrxelm1gBZ0ClgmcCdkIveIMNWpo1a61fiU33Bm5717m
+jy4ncgoL8Q6Vy9KtidmdmXIYbkcf6uEYXvGkyjODUzvF3tbzvMIoMJts0XD52ZQh
+vHq9qaQlB4T69IVkdvS8hCYftPcympOjzpMrojzxQhJZAgMBAAGjGDAWMBQGA1Ud
+EQQNMAuCCWxvY2FsaG9zdDANBgkqhkiG9w0BAQsFAAOCAQEAuaVKMhmsgPso9Vrm
+4emZscFanrzV7W7pXbFxO1wK/XxWQRrxRS40e5SBeDUYJmoVcC9CojbtYSZ0vav2
+CHENA3LPPLi703Z5fe8TxiU64PssJe6IyZ7FveaTiCQ4TdsPPEsq+hoMpXykj/GL
+7holeO6xY2KvrKgEBXOPuniTvPQLJKalfmiHNBg2pEkJeNly9mK/jQQ1kYFz1FaK
+DgNt6DWlTitsx4s85ryKcpYR3jljacPpuPOWiAlNw47jOefTFhBFR9oXxxvAEPRC
+xnc1hXhxsnOzcFuNDAxSa3uW2bZpcEeoJxscjNUqeu/Lk1tFQWLsliJuqKxMBRcD
+qqZ75Q==
+-----END CERTIFICATE-----

tina4_python-0.2.24/tina4_python/secrets/private.key

@@ -0,0 +1,30 @@
+-----BEGIN RSA PRIVATE KEY-----
+Proc-Type: 4,ENCRYPTED
+DEK-Info: AES-256-CBC,C9FC3C8CF276DF95D130298E7F6844AB
+
+9aa638h4jOTIypRhQLDEzB7MTAs9AupUFYttF8T+eJ32EeNB+0FQNfD8r6CEZeMf
+vp64suhWxlJhHRnpKogg9K8ioig36Fy+0Ung/va0ysozb1LZ2ct2QHcCIsyJypzC
+wPe+iEx8GR0zCL88fU//xIlb/SAxAEnFYFW44IpHQMjzZ2PJ7cJswlA80l4Ualc4
+RwTz0ZmEGWUE6CxoSCck26xDn57yH+pm76D98AS78TwgEBKbK8VtC12+Xp4LvP/H
+lgDrcTekTWd/zUfGaL1q3kMIQ1Az4xIDQuxjVcsKsRyTvtHjS1G7AQUPBXc2N6Tm
+zMHUkZR/niqvNZjyyNlaTdQoAdHAswxQKS+NQHegbP3+l8fGFlSG6AVYGl+ALInt
+8DeoYuaZhgRLTEGA+Dkw5TNFgdTqnaZgrXE1AflffYGBX4Q6ddW+rUfJ6s/RHmcj
+eM9rCaFijSTJNupGe3uQJrmtgsAmBhotzYnswkQJwTk+HP0lvf+A7t72OfmBJsqx
+MYdIi4hPKKai3s/Gbu9e/vS7/vYVPNaJAGJ5NJwqa518nxdb2Es/9Lnx7ts9J7lw
+c15xjASh7gQsJojdEbOaaIUCqqi4BQX/koa4V3zPJ5KtZ3qqYzlw1NEOX63IAKLh
+GN3pDiIuYc1by/6HSFDaY1gSx+ZRyn5Ie+4DuFS8W/PVdkE+kPKHCSdQifJ2E9ym
+c2lYA0leKfH5z4SBv9TphwwTtsS8anHTvWyPy1jLHyH81FSr2u13bu0GiY+Q9Q9V
+YJqXM/5M8w8+Nu9pcXDZbrcw2jb3gG1EYHVdXXMM3j/V/fhFmvixng5DDr4ghPNn
+jAH9fX5UD289XzmYzXOhSRW7ovxv3jlFbKxT/Yj2pZwA8FWHG2IVsdHFK/VrjxG8
+QRexMEYjE7gSzgJymc7ML1WgnY1ZFphD/6P5DBt0wWL+23EJ++OCHyVFzS5f4f3Z
+YrJ51iIvyJB33Dq5xdT+peq+rBO9skwlfrn3M/WrD6fmE7sB71CDdNvL0c9yfjJO
+MqxYcRzyClYl5bEB10zEShDMWS5uvJJl93Av+k8ZKm0kE2NXyL+HlaADp1zXzJ8E
+G54LZLOlsJHebATRFLpxJ6lT6N7AUHCH0f0SnyyH+epxbbUlH1uB76beSeLypCw2
+DyQg/aOP3FfuQG8mKmIECZ8qqXtDv3tM9hu/rvzEUkYOUfXi3xpVaRxA2nre9SAB
+7ZVDQv6QWDBHr+6F30znzZEhDqgas+s6MqG5zuEWSmWVja5Fv9JV/mPD8ZUZX5++
+ZYguplD7Ht9sqw3fyrMk7WbSsFEYr2jrHc3lmVAK8g+wmNjJwKCBiR3cmoPFReEF
+B6PZ+cTka1sOrDDz19bsy31yLac2u6o4pg+1yv1iGP4y2VsOyLE3vz3Pvl3i0PP/
+C18loanx66f2sIps7HjcFk8eElhs/tAJ+tANOluhlzSlZhrmRuwXCFd7k+wOB8iI
++pnud/XlZU3invJYi9IHfwNw1dE9dPjchHIXb75py+vpLhkDzWSMEpGlTx8MpTwe
+O4mb4azV8J0vFCq+hvvpHIG7on+NlFYWqjSdBgImo74eSDFTYDtYji5/D3MJQaxw
+-----END RSA PRIVATE KEY-----

tina4_python-0.2.24/tina4_python/secrets/public.key

@@ -0,0 +1,9 @@
+-----BEGIN PUBLIC KEY-----
+MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA7aPB60KeS9nRcILrU33L
+fAcUcX0PvTuJB8ls4c3juFry3g6sgAOOh7D3G/CruoVvklobfURE6AC6+ISlwhcV
+KOij/SgTZKwNH2bI0DOUjwnNfe1gC9wBt16c6jdd2zoqYVXqi0qgDwmRIrXemEPC
+HQR4DV//iawvLeyhQc8lcZwp03zuYsXWnikGYRTHCBa8XpZtYAWdApYJnAnZCL3i
+DDVqaNWutX4lN9wZue9e5o8uJ3IKC/EOlcvSrYnZnZlyGG5HH+rhGF7xpMozg1M7
+xd7W87zCKDCbbNFw+dmUIbx6vamkJQeE+vSFZHb0vIQmH7T3MpqTo86TK6I88UIS
+WQIDAQAB
+-----END PUBLIC KEY-----

tina4_python-0.2.22/tina4_python/Request.py

@@ -1,25 +0,0 @@
-#
-# Tina4 - This is not a 4ramework.
-# Copy-right 2007 - current Tina4
-# License: MIT https://opensource.org/licenses/MIT
-#
-# flake8: noqa: E501
-class Request:
-    """
-    Request object to store parameters, headers, etc.
-    """
-
-    def __init__(self, body=None, params=None, headers=None, request=None, raw_data=None, raw_request=None, raw_content=None):
-        self.body = body if body is not None else None
-        self.params = params if params is not None else {}
-        self.headers = headers if headers is not None else {}
-        self.request = request if request is not None else {}
-        self.cookies = {}
-        self.cookies = {}
-        self.url = None
-        self.session = None
-        self.files = {}
-        self.raw_data = raw_data if raw_data is not None else None
-        self.raw_request = raw_request if raw_request is not None else None
-        self.raw_content = raw_content if raw_content is not None else None
-

tina4_python-0.2.22/tina4_python/Response.py

@@ -1,77 +0,0 @@
-#
-# 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 tina4_python import Constant
-from tina4_python import DatabaseResult
-from tina4_python.Debug import Debug
-
-
-class Response:
-    """
-    response object for router
-    :param content
-    :param http_code
-    :param content_type
-    :param headers
-    """
-
-    def __init__(self, content, http_code=Constant.HTTP_OK, content_type=Constant.TEXT_HTML, headers=None):
-        self.headers = headers if headers is not None else {}
-
-        if content is None:
-            content = ""
-        # try to make content into a dictionary
-        elif not isinstance(content, bool) and not isinstance(content, object) and not isinstance(content, bytes) and not isinstance(content, str) and not isinstance(content, list) and inspect.isclass(type(content)):
-            content = dict(content)
-
-        # check if database result
-        if type(content) is DatabaseResult.DatabaseResult:
-            content_type = Constant.APPLICATION_JSON
-            content = content.to_json()
-
-        # convert the dictionary or list into JSON
-        if not isinstance(content, bool) and type(content) is dict or type(content) is list:
-            content = json.dumps(content)
-            content_type = Constant.APPLICATION_JSON
-
-        if isinstance(content, bool):
-            if content:
-                content = "True"
-            else:
-                content = "False"
-
-        if isinstance(content, ModuleType):
-            content = json.dumps({"error": "Cannot decode object of type "+str(type(content))})
-            content_type = Constant.APPLICATION_JSON
-
-        self.content = content
-        self.http_code = http_code
-        self.content_type = content_type
-
-
-    @staticmethod
-    def redirect(redirect_url):
-        """
-        Redirects a request to redirect_url
-        :param redirect_url:
-        :return:
-        """
-        headers = {}
-        http_code = Constant.HTTP_REDIRECT
-        headers["Location"] = redirect_url
-        return Response("", http_code=http_code, headers=headers)
-
-    def add_header(self, key, value):
-        """
-        Adds a header for the response
-        :param key:
-        :param value:
-        :return:
-        """
-        self.headers[key] = value