tina4-python 0.2.122__py3-none-any.whl

tina4_python/Session.py

@@ -0,0 +1,342 @@
+#
+# Tina4 - This is not a 4ramework.
+# Copy-right 2007 - current Tina4
+# License: MIT https://opensource.org/licenses/MIT
+#
+# flake8: noqa: E501
+import os
+from http import cookies
+import sys
+import importlib
+import hashlib
+import tina4_python
+from tina4_python.Debug import Debug
+from tina4_python import Constant
+
+class SessionHandler(object):
+    """
+    Base class for session handling.
+    """
+
+    @staticmethod
+    def load(session, _hash):
+        pass
+
+    @staticmethod
+    def set(session, _key, _value):
+        try:
+            session.session_values[_key] = _value
+            session.save()
+            return True
+        except Exception:
+            return False
+
+    @staticmethod
+    def unset(session, _key):
+        if _key in session.session_values:
+            del session.session_values[_key]
+            session.save()
+            return True
+        else:
+            return False
+
+    @staticmethod
+    def get(session, _key):
+        if _key in session.session_values:
+            return session.session_values[_key]
+        else:
+            return None
+
+    @staticmethod
+    def close(session):
+        pass
+
+    @staticmethod
+    def save(session):
+        pass
+
+class SessionFileHandler(SessionHandler):
+    """
+    Session File Handler
+    """
+    @staticmethod
+    def load(session, _hash):
+        session.session_hash = _hash
+        if os.path.isfile(session.session_path + os.sep + _hash):
+            with open(session.session_path + os.sep + _hash, "r") as file:
+                token = file.read()
+                file.close()
+                if tina4_python.tina4_auth.valid(token):
+                    payload = tina4_python.tina4_auth.get_payload(token)
+                    for key in payload:
+                        if key != "expires":
+                            session.set(key, payload[key])
+                else:
+                    Debug("Session expired, starting a new one", Constant.TINA4_LOG_DEBUG)
+                    session.start(_hash)
+        else:
+            Debug("Cannot load session, starting a new one", Constant.TINA4_LOG_DEBUG)
+            session.start(_hash)
+
+    @staticmethod
+    def close(session):
+        try:
+            if os.path.isfile(session.session_path + os.sep + session.session_hash):
+                os.remove(session.session_path + os.sep + session.session_hash)
+            return True
+        except Exception:
+            return False
+
+    @staticmethod
+    def save(session):
+        try:
+            if not os.path.exists(session.session_path):
+                os.makedirs(session.session_path)
+            token = tina4_python.tina4_auth.get_token(payload_data=session.session_values)
+            with open(session.session_path + os.sep + session.session_hash, "w") as file:
+                file.write(token)
+                file.close()
+                return True
+        except Exception as E:
+            Debug("Session save failure", E, Constant.TINA4_LOG_ERROR)
+            return False
+
+class SessionRedisHandler(SessionHandler):
+
+    @staticmethod
+    def __init_redis():
+        try:
+            redis = importlib.import_module("redis")
+        except Exception as e:
+            Debug("Redis not installed, install with pip install redis or poetry add redis", str(e), Constant.TINA4_LOG_ERROR)
+            sys.exit(1)
+
+        if os.getenv("TINA4_SESSION_REDIS_SECRET", "") != "":
+            redis_instance = redis.Redis(host=os.getenv("TINA4_SESSION_REDIS_HOST", "localhost"),
+                                         port=os.getenv("TINA4_SESSION_REDIS_PORT",6379),
+                                         password=os.getenv("TINA4_SESSION_REDIS_SECRET", ""),
+                                         decode_responses=True)
+        else:
+            redis_instance = redis.Redis(host=os.getenv("TINA4_SESSION_REDIS_HOST", "localhost"),
+                                         port=os.getenv("TINA4_SESSION_REDIS_PORT",6379),
+                                         decode_responses=True)
+        return redis_instance
+
+    """
+    Session Redis Handler
+    """
+    @staticmethod
+    def load(session, _hash):
+        """
+        Loads the redis session
+        :param session:
+        :param _hash:
+        :return:
+        """
+        try:
+            session.session_hash = _hash
+            r = SessionRedisHandler.__init_redis()
+            token = r.get(_hash)
+            if tina4_python.tina4_auth.valid(token):
+                payload = tina4_python.tina4_auth.get_payload(token)
+                for key in payload:
+                    if key != "expires":
+                        session.set(key, payload[key])
+            else:
+                Debug("Session expired, starting a new one", Constant.TINA4_LOG_WARNING)
+                _hash = None
+                session.start(_hash)
+        except Exception:
+            Debug("Redis not available, sessions will fail", Constant.TINA4_LOG_ERROR)
+
+
+    @staticmethod
+    def close(session):
+        """
+        Closes the redis session
+        :param session:
+        :return:
+        """
+        r = SessionRedisHandler.__init_redis()
+        try:
+            r.set(session.session_hash, "")
+            return True
+        except Exception:
+            return False
+
+    @staticmethod
+    def save(session):
+        """
+        Saves the redis session
+        :param session:
+        :return:
+        """
+        r = SessionRedisHandler.__init_redis()
+        try:
+            token = tina4_python.tina4_auth.get_token(payload_data=session.session_values)
+            r.set(session.session_hash, token)
+            return True
+        except Exception as e:
+            Debug("Session save failure", str(e), Constant.TINA4_LOG_ERROR)
+            return False
+
+class SessionValkeyHandler(SessionHandler):
+
+    @staticmethod
+    def __init_valkey():
+        try:
+            valkey = importlib.import_module("valkey")
+        except Exception as e:
+            Debug("Valkey not installed, install with pip/uv", str(e), Constant.TINA4_LOG_ERROR)
+            sys.exit(1)
+
+        params = {
+            "host": os.getenv("TINA4_SESSION_VALKEY_HOST", "localhost"),
+            "port": int(os.getenv("TINA4_SESSION_VALKEY_PORT", 6379)),
+            "decode_responses": True
+        }
+        if os.getenv("TINA4_SESSION_VALKEY_SECRET", ""):
+            params["password"] = os.getenv("TINA4_SESSION_VALKEY_SECRET", "")
+            params["username"] = os.getenv("TINA4_SESSION_VALKEY_USER", "default")
+
+        if os.getenv("TINA4_SESSION_VALKEY_SSL", "False").upper() == "TRUE":
+            params["ssl"] = True
+
+        valkey_instance = valkey.Valkey(**params)
+
+        return valkey_instance
+
+    """
+    Session Valkey Handler
+    """
+    @staticmethod
+    def load(session, _hash):
+        """
+        Loads the Valkey session
+        :param session:
+        :param _hash:
+        :return:
+        """
+        try:
+            session.session_hash = _hash
+            r = SessionValkeyHandler.__init_valkey()
+            token = r.get(_hash)
+            if tina4_python.tina4_auth.valid(token):
+                payload = tina4_python.tina4_auth.get_payload(token)
+                for key in payload:
+                    if key != "expires":
+                        session.set(key, payload[key])
+            else:
+                Debug("Session expired, starting a new one", Constant.TINA4_LOG_DEBUG)
+                session.start(_hash)
+        except Exception:
+            Debug("Valkey not available, sessions will fail", Constant.TINA4_LOG_ERROR)
+
+
+    @staticmethod
+    def close(session):
+        """
+        Closes the Valkey session
+        :param session:
+        :return:
+        """
+        r = SessionValkeyHandler.__init_valkey()
+        try:
+            r.set(session.session_hash, "")
+            return True
+        except Exception:
+            return False
+
+    @staticmethod
+    def save(session):
+        """
+        Saves the Valkey session
+        :param session:
+        :return:
+        """
+        r = SessionValkeyHandler.__init_valkey()
+        try:
+            token = tina4_python.tina4_auth.get_token(payload_data=session.session_values)
+            r.set(session.session_hash, token)
+            return True
+        except Exception as e:
+            Debug("Session save failure", str(e), Constant.TINA4_LOG_ERROR)
+            return False
+
+class Session:
+
+    def __init__(self, _default_name="PY_SESS", _default_path="sessions", _default_handler="SessionFileHandler"):
+        self.session_name = _default_name
+        self.cookie = cookies.SimpleCookie()
+        self.session_path = _default_path
+        self.session_values = {}
+        self.session_hash = ""
+        self.default_handler = _default_handler
+        exec("self.default_handler = "+_default_handler)
+
+    def start(self, _hash=None):
+        # create a file for the session?
+        # set the cookie for the session
+        token = tina4_python.tina4_auth.get_token(payload_data=self.session_values)
+        if _hash is None:
+            file_hash = hashlib.md5(token.encode()).hexdigest()
+        else:
+            file_hash = _hash
+        self.session_hash = file_hash
+        self.save()
+
+        return file_hash
+
+    def load(self, _hash):
+        """
+        Loads a session based on the hash
+        :param _hash:
+        :return:
+        """
+        self.default_handler.load(self, _hash)
+
+    def set(self, _key, _value):
+        """
+        Sets a session key value
+        :param _key:
+        :param _value:
+        :return:
+        """
+        return self.default_handler.set(self, _key, _value)
+
+
+    def unset(self, _key):
+        """
+        Unsets the session key
+        :param _key:
+        :return:
+        """
+        return self.default_handler.unset(self, _key)
+
+    def get(self, _key):
+        """
+        Returns false if session cannot be retrieved
+        :param _key:
+        :return:
+        """
+        return self.default_handler.get(self, _key)
+
+    def close(self):
+        """
+        Close the session and remove the file or record
+        :return:
+        """
+        return self.default_handler.close(self)
+
+    def save(self):
+        """
+        Saves the session information
+        :return:
+        """
+        return self.default_handler.save(self)
+
+    def __iter__(self):
+        for key, value in self.session_values.items():
+            if key != "expires":
+                yield key, value
+

tina4_python/ShellColors.py

@@ -0,0 +1,20 @@
+class ShellColors:
+    end = '\033[0m'
+    bold = '\033[1m'
+    under_line = '\033[4m'
+    black = "\033[0;30m"
+    red = "\033[0;31m"
+    green = "\033[0;32m"
+    yellow = "\033[0;33m"
+    blue = "\033[0;34m"
+    magenta = "\033[0;35m"
+    cyan = "\033[0;36m"
+    white = "\033[0;37m"
+    bright_black = "\033[0;90m"
+    bright_red = "\033[0;91m"
+    bright_green = "\033[0;92m"
+    bright_yellow = "\033[0;93m"
+    bright_blue = "\033[0;94m"
+    bright_magenta = "\033[0;95m"
+    bright_cyan = "\033[0;96m"
+    bright_white = "\033[0;97m"

tina4_python/Swagger.py

@@ -0,0 +1,228 @@
+#
+# Tina4 - This is not a 4ramework.
+# Copy-right 2007 - current Tina4
+# License: MIT https://opensource.org/licenses/MIT
+#
+# flake8: noqa: E501
+import os
+import re
+import tina4_python
+from tina4_python import Constant, Debug
+
+
+class Swagger:
+    @staticmethod
+    def set_swagger_value(callback, key_name, value):
+        if callback not in tina4_python.tina4_routes:
+            tina4_python.tina4_routes[callback] = {}
+        if "swagger" not in tina4_python.tina4_routes[callback]:
+            tina4_python.tina4_routes[callback]["swagger"] = {}
+        tina4_python.tina4_routes[callback]["swagger"][key_name] = value
+
+    @staticmethod
+    def add_descripton(description, callback):
+        Swagger.set_swagger_value(callback, "description", description)
+
+    @staticmethod
+    def add_summary(summary, callback):
+        Swagger.set_swagger_value(callback, "summary", summary)
+
+    @staticmethod
+    def add_secure(callback):
+        Swagger.set_swagger_value(callback, "secure", True)
+
+    @staticmethod
+    def add_tags(tags, callback):
+        Swagger.set_swagger_value(callback, "tags", tags)
+
+    @staticmethod
+    def add_example(example, callback):
+        Swagger.set_swagger_value(callback, "example", example)
+
+    @staticmethod
+    def add_params(params, callback):
+        Swagger.set_swagger_value(callback, "params", params)
+
+    @staticmethod
+    def get_path_inputs(route_path):
+        url_segments = route_path.strip('/').split('/')
+        route_segments = route_path.strip('/').split('/')
+        try:
+            variables = {}
+            for i, segment in enumerate(route_segments):
+                if '{' in segment and '}' in segment:  # parameter part
+                    param_name = re.search(r'{(.*?)}', segment).group(1)
+                    variables[param_name] = url_segments[i]
+
+            params = []
+            for variable in variables:
+                params.append({"name": variable, "in": "path", "type": "string"})
+        except Exception as e:
+            Debug.error("Failed to parse path inputs", str(e))
+            return []
+
+        return params
+
+    @staticmethod
+    def get_swagger_entry(url, method, tags, summary, description, produces, security, params=None, example=None,
+                          responses=None):
+
+        if params is None:
+            params = []
+
+        schema = {}
+        if example is not None:
+            schema = {"type": "object", "example": example}
+
+        secure_annotation = [],
+        if security:
+            secure_annotation = [{"bearerAuth": []}]
+
+        new_params = []
+        for param in params:
+            param_value = param.split("=")
+            if len(param_value) < 2:
+                param_value.append("")
+            new_params.append({"name": param_value[0], "in": "query", "type": "string", "default": param_value[1]})
+
+        params = [*new_params, *Swagger.get_path_inputs(url)]
+
+        entry = {
+            "tags": tags,
+            "summary": summary,
+            "description": description,
+            "produces": produces,
+            "parameters": params,
+            "requestBody": {
+                "description": "Example Object",
+                "required": True,
+                "content": {
+                    "application/json": {
+                        "schema": schema
+                    }
+                }
+            },
+            "security": secure_annotation,
+            "responses": responses
+        }
+
+        if method == Constant.TINA4_GET or example is None:
+            del entry["requestBody"]
+
+        return entry
+
+    @staticmethod
+    def parse_swagger(swagger):
+        if "tags" not in swagger:
+            swagger["tags"] = []
+        if "params" not in swagger:
+            swagger["params"] = []
+        if "description" not in swagger:
+            swagger["description"] = ""
+        if "summary" not in swagger:
+            swagger["summary"] = ""
+        if "example" not in swagger:
+            swagger["example"] = None
+        if "secure" not in swagger:
+            swagger["secure"] = None
+
+        if isinstance(swagger["tags"], str):
+            swagger["tags"] = [swagger["tags"]]
+
+        return swagger
+
+    @staticmethod
+    def get_json(request):
+        paths = {}
+        for route in tina4_python.tina4_routes.values():
+
+            if "swagger" in route:
+                if route["swagger"] is not None:
+                    swagger = Swagger.parse_swagger(route["swagger"])
+                    responses = {
+                        "200": {"description": "Success"},
+                        "400": {"description": "Failed"}
+                    }
+
+                    if route["route"] not in paths:
+                        paths[route["route"]] = {}
+                    paths[route["route"]][route["method"].lower()] = Swagger.get_swagger_entry(route["route"],
+                                                                                               route["method"].lower(),
+                                                                                               swagger["tags"],
+                                                                                               swagger["summary"],
+                                                                                               swagger["description"],
+                                                                                               ["application/json",
+                                                                                                "html/text"],
+                                                                                               swagger["secure"],
+                                                                                               swagger["params"],
+                                                                                               swagger["example"],
+                                                                                               responses)
+
+        if "host" in request.headers:
+            host_name = request.headers["host"]
+        else:
+            host_name = os.getenv("HOST_NAME", "localhost")
+
+        json_object = {
+            "openapi": "3.0.0",
+            "host": host_name,
+            "info": {
+                "title": os.getenv("SWAGGER_TITLE", "Tina4 Project(SWAGGER_TITLE)"),
+                "description": os.getenv("SWAGGER_DESCRIPTION", "Description(SWAGGER_DESCRIPTION)"),
+                "version": os.getenv("SWAGGER_VERSION", "1.0.0(SWAGGER_VERSION)")
+            },
+            "components": {
+                "securitySchemes": {"bearerAuth": {"type": "http", "scheme": "bearer", "bearerFormat": "JWT"}}},
+            "basePath": "",
+            "paths": paths
+        }
+
+        return json_object
+
+
+def description(text):
+    def actual_description(callback):
+        Swagger.add_descripton(text, callback)
+        return callback
+
+    return actual_description
+
+
+def summary(text):
+    def actual_summary(callback):
+        Swagger.add_summary(text, callback)
+        return callback
+
+    return actual_summary
+
+
+def secure():
+    def actual_secure(callback):
+        Swagger.add_secure(callback)
+        return callback
+
+    return actual_secure
+
+
+def tags(tags):
+    def actual_tags(callback):
+        Swagger.add_tags(tags, callback)
+        return callback
+
+    return actual_tags
+
+
+def example(example):
+    def actual_example(callback):
+        Swagger.add_example(example, callback)
+        return callback
+
+    return actual_example
+
+
+def params(params):
+    def actual_params(callback):
+        Swagger.add_params(params, callback)
+        return callback
+
+    return actual_params

tina4_python/Template.py

@@ -0,0 +1,107 @@
+#
+# Tina4 - This is not a 4ramework.
+# Copy-right 2007 - current Tina4
+# License: MIT https://opensource.org/licenses/MIT
+#
+# flake8: noqa: E501
+import os
+import json
+import tina4_python
+from tina4_python import Constant
+from tina4_python.Debug import Debug
+from pathlib import Path
+from datetime import datetime, date
+from jinja2 import Environment, FileSystemLoader, Undefined
+from tina4_python.Session import Session
+from random import random as RANDOM
+
+
+class Template:
+    # initializes the twig template engine
+    @staticmethod
+    def init_twig(path):
+        if hasattr(Template, "twig"):
+            Debug("Twig found on " + path, Constant.TINA4_LOG_DEBUG)
+            return Template.twig
+        Debug("Initializing Twig on " + path, Constant.TINA4_LOG_DEBUG)
+        twig_path = Path(path)
+        Template.twig = Environment(loader=FileSystemLoader(Path(twig_path)))
+        Template.twig.add_extension('jinja2.ext.debug')
+        Template.twig.add_extension('jinja2.ext.do')
+        Template.twig.globals['RANDOM'] = RANDOM
+        Template.twig.globals['formToken'] = Template.get_form_token
+        Template.twig.filters['formToken'] = Template.get_form_token_input
+        if Constant.TINA4_LOG_DEBUG in os.getenv("TINA4_DEBUG_LEVEL") or Constant.TINA4_LOG_ALL in os.getenv(
+                "TINA4_DEBUG_LEVEL"):
+            Template.twig.globals['dump'] = Template.dump
+        else:
+            Template.twig.globals['dump'] = Template.production_dump
+        Debug("Twig Initialized on " + path, Constant.TINA4_LOG_INFO)
+        return Template.twig
+
+    @staticmethod
+    def production_dump(param):
+        Debug.error("DUMP FOUND ON PAGE!")
+        return ""
+
+    @staticmethod
+    def dump(param):
+        if param is not None and not isinstance(param, Undefined):
+            def json_serialize(obj):
+                if isinstance(obj, (date, datetime)):
+                    return obj.isoformat()
+                if isinstance(obj, Session):
+                    return obj.session_values
+                raise TypeError("Type %s not serializable to Jinja2 template" % type(obj))
+
+            return "<pre>" + json.dumps(param, indent=True, default=json_serialize) + "</pre>"
+        else:
+            return ""
+
+    @staticmethod
+    def get_form_token(payload={}):
+        return tina4_python.tina4_auth.get_token(payload)
+
+    @staticmethod
+    def get_form_token_input(form_name):
+        return '<input type="hidden" name="formToken" value="' + Template.get_form_token(
+            {"formName": form_name}) + '"><!--"' + str(datetime.now().isoformat()) + '"-->'
+
+    @staticmethod
+    def convert_special_types(obj):
+        if isinstance(obj, dict):
+            return {k: Template.convert_special_types(v) for k, v in obj.items()}
+        elif isinstance(obj, list):
+            return [Template.convert_special_types(i) for i in obj]
+        elif isinstance(obj, (date, datetime)):
+            return obj.isoformat()
+        else:
+            return obj
+
+    @staticmethod
+    def render_twig_template(template_or_file_name, data=None):
+        if data is None:
+            data = {"request": tina4_python.tina4_current_request}
+        else:
+            data.update({"request": tina4_python.tina4_current_request})
+
+        data = Template.convert_special_types(data)
+
+        twig = Template.init_twig(tina4_python.root_path + os.sep + "src" + os.sep + "templates")
+        try:
+            if twig.get_template(template_or_file_name):
+                template = twig.get_template(template_or_file_name)
+                content = template.render(data)
+            else:
+                template = twig.from_string(template_or_file_name)
+                content = template.render(data)
+
+        except Exception as e:
+            Debug("Error rendering twig file", template_or_file_name, e, Constant.TINA4_LOG_ERROR)
+            content = str(e)
+
+        return content
+
+    @staticmethod
+    def render(template_or_file_name, data=None):
+        return Template.render_twig_template(template_or_file_name, data)