simpserver 0.1.1.post1__py3-none-any.whl

simpserver/database.py

@@ -0,0 +1,15 @@
+import mariadb
+from os import environ
+
+DB_CONFIG = {
+    "host": environ.get("DB_HOST", "127.0.0.1"),
+    "port": int(environ.get("DB_PORT", 3306)),
+    "user": environ.get("DB_USER", "root"),
+    "password": environ.get("DB_PASSWORD", "pass"),
+    "database": environ.get("DB_NAME", "teste"),
+}
+
+
+def get_connection_and_cursor() -> tuple[mariadb.Connection, mariadb.Cursor]:
+    conn = mariadb.connect(**DB_CONFIG)
+    return conn, conn.cursor()

simpserver/exceptions.py

@@ -0,0 +1,62 @@
+from http import HTTPStatus
+
+
+class APIError(Exception):
+    """Error handled by api"""
+
+    def __init__(self, status_code: HTTPStatus, response: dict) -> None:
+        self.response = {"error": type(self).__name__} | response
+        self.status_code = status_code
+        super().__init__()
+
+
+class BadRequestError(APIError):
+    """Bad request error"""
+
+    def __init__(self, response: dict) -> None:
+        super().__init__(HTTPStatus.BAD_REQUEST, response)
+
+
+class BodyKeyMissingError(BadRequestError):
+    """When a needed key in body is missing"""
+
+    def __init__(self, key_name: str) -> None:
+        super().__init__({"key_name": key_name})
+
+
+class BodyKeyTypeError(BadRequestError):
+    """When a type of a body key is wrong"""
+
+    def __init__(self, key_name: str, key_type: type) -> None:
+        super().__init__({"key_name": key_name, "type_needed": key_type.__name__})
+
+
+class UrlParamMissingError(BadRequestError):
+    """When a needed param in url is missing"""
+
+    def __init__(self, param_name: str) -> None:
+        super().__init__({"param_name": param_name})
+
+class UrlParamTypeError(BadRequestError):
+    """When a needed param in url is missing"""
+
+    def __init__(self, param_name: str, param_type: type) -> None:
+        super().__init__({"param_name": param_name, "type_needed": param_type.__name__})
+
+class CredentialsError(APIError):
+    """When a login error occours"""
+
+    def __init__(self, ) -> None:
+        super().__init__(HTTPStatus.NOT_FOUND, {"message": "Wrong credentials"})
+
+class InvalidTokenError(APIError):
+    """When a passed token does not exists"""
+
+    def __init__(self, ) -> None:
+        super().__init__(HTTPStatus.UNAUTHORIZED, {"message": "Invalid token"})
+
+class TimeoutError(APIError):
+    """When lost much time in an action"""
+
+    def __init__(self, ) -> None:
+        super().__init__(HTTPStatus.REQUEST_TIMEOUT, {"message": "Timeout"})

simpserver/handler.py

@@ -0,0 +1,112 @@
+from http import HTTPMethod, HTTPStatus
+from http.server import BaseHTTPRequestHandler, HTTPServer
+import json
+import urllib.parse
+import traceback
+import signal
+
+from .exceptions import APIError
+from .router import RouteCallbackReturn, route_get_callback
+
+def timeout_handler(signum, frame):
+    raise TimeoutError()
+
+signal.signal(signal.SIGALRM, timeout_handler)
+
+
+class RequestHandler(BaseHTTPRequestHandler):
+    def __init__(self, request, client_address, server) -> None:
+        super().__init__(request, client_address, server)
+
+    def set_default_headers(self) -> None:
+        self.send_header("Access-Control-Allow-Origin", "*")
+        self.send_header(
+            "Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, OPTIONS"
+        )
+        self.send_header("Access-Control-Allow-Headers", "token, Content-Type")
+        self.send_header("Content-Type", "text/html")
+        self.end_headers()
+
+    def get_body(self) -> dict:
+        content_length = int(self.headers.get("Content-Length", 0))
+        signal.setitimer(signal.ITIMER_REAL, 0.01, 0)
+        body_data = self.rfile.read(content_length).decode("utf-8")
+        signal.setitimer(signal.ITIMER_REAL, 0)
+
+        if not body_data: return {}
+
+        body = json.loads(body_data)
+
+        if not isinstance(body, dict): raise ValueError("Invalid body")
+
+        return body
+
+    def get_url_params(self) -> dict:
+        if "?" not in self.path: return {}
+
+        url_params = {}
+        params_list = self.path.split("?")[1]
+
+        params_list = params_list.split("&") if "&" in params_list else [params_list]
+
+        for param in params_list:
+            name, value = param.split("=")
+            url_params[name] = urllib.parse.unquote_plus(value)
+
+        return url_params
+
+    def run_route(self, method: HTTPMethod) -> None:
+        path = self.path
+        if "?" in path:
+            path = path.split("?")[0]
+
+        route_callback = route_get_callback(path, method)
+
+        if not route_callback:
+            self.send_response(HTTPStatus.NOT_FOUND)
+            self.set_default_headers()
+            return
+
+        status_code = HTTPStatus.OK
+        response: RouteCallbackReturn
+        try:
+            # DONT USE POSITIONAL ARGUMENTS, WILL NOT BE PASSED FORWARD.
+            # This is just in case you want to add some variables on route_callback.
+            # Aways use named parameters like below. Decorators handles just kwargs, not args.
+            # If you want to create a decorator, i think that is better keep this pattern.
+            response = route_callback(req=self,
+                                      body=self.get_body(),
+                                      url_params=self.get_url_params())
+        except APIError as api_error:
+            status_code = api_error.status_code
+            response = api_error.response
+        except:
+            status_code = HTTPStatus.INTERNAL_SERVER_ERROR
+            print(traceback.format_exc())
+            response = {"error": "Internal error"}
+
+        self.send_response(status_code)
+        self.set_default_headers()
+
+        if isinstance(response, str):
+            response = {"message": response}
+
+        self.wfile.write(json.dumps(response).encode("utf-8"))
+
+    def do_GET(self) -> None:
+        self.run_route(HTTPMethod.GET)
+
+    def do_POST(self) -> None:
+        self.run_route(HTTPMethod.POST)
+
+
+def serve_api(ip: str, port: int) -> None:
+    server = HTTPServer(((ip, port)), RequestHandler)
+
+    print(f"Running api at: http://{ip}:{port}")
+
+    try:
+        server.serve_forever()
+    except KeyboardInterrupt:
+        pass
+    server.server_close()

simpserver/router.py

@@ -0,0 +1,187 @@
+from http import HTTPMethod
+from typing import Callable
+import inspect
+
+from .database import get_connection_and_cursor
+from .exceptions import (
+    BodyKeyTypeError,
+    BodyKeyMissingError,
+    InvalidTokenError,
+    UrlParamMissingError,
+    UrlParamTypeError,
+)
+
+
+_routes: dict[HTTPMethod, dict[str, Callable]] = {}
+
+# Parameters is Any | None.
+RouteCallbackReturn = str | dict | list
+RouteCallback = Callable[..., RouteCallbackReturn]
+
+
+def route_add(path: str, method: HTTPMethod, callback: RouteCallback) -> None:
+    if method not in _routes.keys():
+        _routes[method] = {path: callback}
+        return
+
+    if path in _routes[method].keys():
+        raise ValueError(f"Trying to add endpoint: {path} but already exists.")
+
+    _routes[method][path] = callback
+
+
+def route_get_callback(path: str, method: HTTPMethod) -> RouteCallback | None:
+    if method not in _routes.keys() or path not in _routes[method].keys():
+        return None
+
+    return _routes[method][path]
+
+
+class FunctionSignature:
+    def __init__(self, func: RouteCallback) -> None:
+        self.sig             = inspect.signature(func)
+        self.params_names    = self.sig.parameters.keys()
+        self.has_conn        = "conn" in self.params_names
+        self.has_cur         = "cur"  in self.params_names
+        self.has_conn_or_cur = self.has_conn or self.has_cur
+        self.has_req         = "req"  in self.params_names
+        self.has_body        = "body" in self.params_names
+        self.has_kwargs      = "body" in self.params_names
+        self.has_url_params  = "url_params" in self.params_names
+        self.has_user_info   = "user_info" in self.params_names
+
+unsafe_functions: dict[RouteCallback, FunctionSignature] = {}
+
+
+def add_func_sig(func: RouteCallback) -> None:
+    if func in unsafe_functions.keys():
+        print("[WARNIG] - (Re)adding func to func_signatures")
+
+    func_sig = FunctionSignature(func)
+
+    for t in func_sig.sig.parameters.values():
+        if t.kind == inspect.Parameter.VAR_KEYWORD:
+            return
+
+    unsafe_functions[func] = func_sig
+
+def safe_run(func: RouteCallback, params: dict) -> RouteCallbackReturn:
+    if func not in unsafe_functions.keys():
+        return func(**params)
+
+    func_sig = unsafe_functions[func]
+    if not func_sig.has_req: params.pop("req")
+    if not func_sig.has_body: params.pop("body")
+    if not func_sig.has_url_params: params.pop("url_params")
+    if not func_sig.has_user_info: params.pop("user_info", None)
+    else:
+        if not func_sig.has_conn: params.pop("conn")
+        if not func_sig.has_cur: params.pop("cur")
+
+    # If use cursor or connection, the commit() is executed automatically at the end.
+    if func_sig.has_conn_or_cur and not func_sig.has_user_info:
+        conn, cur = get_connection_and_cursor()
+
+        if func_sig.has_conn: params["conn"] = conn
+        if func_sig.has_cur: params["cur"] = cur
+
+        """
+        This solves a bug that if get an error with opened connection, the
+        server freezes. Why? Because was not closed? I dont know.
+        """
+        with conn: 
+            with cur:
+                response = func(**params)
+
+                conn.commit() # Auto committing the db connection.
+                return response
+
+    return func(**params)
+
+
+def route(path: str, method: HTTPMethod):
+    def decorator(func: RouteCallback):
+        def wrapper(**kwargs) -> RouteCallbackReturn:
+            return safe_run(func, kwargs)
+
+        route_add(path, method, wrapper)
+
+        callback = func
+        while callback.__closure__ != None:
+            callback = callback.__closure__[0].cell_contents
+
+        add_func_sig(callback)
+        return wrapper
+
+    return decorator
+
+
+def ensure_body_keys(keys: dict[str, type]):
+    def decorator(func: RouteCallback):
+        def wrapper(**kwargs) -> RouteCallbackReturn:
+            body = kwargs["body"]
+            body_names = body.keys()
+
+            for name, t in keys.items():
+                if name not in body_names: raise BodyKeyMissingError(name)
+
+                try: body[name] = t(body[name])
+                except: raise BodyKeyTypeError(name, t)
+
+            return safe_run(func, kwargs)
+
+        return wrapper
+
+    return decorator
+
+
+def ensure_url_params(params: dict[str, type]):
+    def decorator(func: RouteCallback):
+        def wrapper(**kwargs) -> RouteCallbackReturn:
+            url_params = kwargs["url_params"]
+            url_params_names = url_params.keys()
+
+            for name, t in params.items():
+                if name not in url_params_names:
+                    raise UrlParamMissingError(name)
+                try:
+                    url_params[name] = t(url_params[name])
+                except:
+                    raise UrlParamTypeError(name, t)
+
+            return safe_run(func, kwargs)
+
+        return wrapper
+
+    return decorator
+
+def middleware():
+    def decorator(func: RouteCallback):
+        @ensure_body_keys({"token": str})
+        def wrapper(**kwargs) -> RouteCallbackReturn:
+            from routes.users import logins
+
+            if kwargs["body"]["token"] not in logins.keys():
+                raise InvalidTokenError()
+
+            func_sig = unsafe_functions[func]
+
+            if func_sig.has_user_info:
+                conn, cur = get_connection_and_cursor()
+                kwargs["conn"] = conn
+                kwargs["cur"] = cur
+
+                cur.execute("SELECT * FROM Users WHERE id = ?", (logins[kwargs["body"]["token"]],))
+                row = cur.fetchone()
+
+                kwargs["user_info"] = {"id": row[0], "name": row[1], "password": row[2]}
+
+                with conn: 
+                    with cur:
+                        return safe_run(func, kwargs)
+
+            return safe_run(func, kwargs)
+
+        return wrapper
+
+    return decorator

simpserver-0.1.1.post1.dist-info/METADATA

@@ -0,0 +1,19 @@
+Metadata-Version: 2.4
+Name: simpserver
+Version: 0.1.1.post1
+Summary: A simple solution to create servers http(s).
+Author-email: Manel <manelzaum@icloud.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/Faltrenn/simpserver
+Project-URL: Issues, https://github.com/Faltrenn/simpserver/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.14.2
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: mariadb
+Dynamic: license-file
+
+# SimpleServer
+
+A simple solution to create simples http(s) servers.

simpserver-0.1.1.post1.dist-info/RECORD

@@ -0,0 +1,9 @@
+simpserver/database.py,sha256=0UEBGdzizpkqGuOzwMpNL7aPrke5RpDTcb2y5YcInho,447
+simpserver/exceptions.py,sha256=GDrUaGCmu5qMeu88Av73SGpEE8G84Bs0gVJHw0dR_l4,1907
+simpserver/handler.py,sha256=NkmVAKz1dE1BTWohiZfNlMbryUmXLw8YNdad2hqiLf0,3642
+simpserver/router.py,sha256=VPIXWWjeSTlSKA48TwenAgslC6sMeU1NaDVbYeVZBOo,5809
+simpserver-0.1.1.post1.dist-info/licenses/LICENSE,sha256=bWxsLG7aTQwC9KqF0tyl1USrIdJmOuzBWz6GBg7azco,565
+simpserver-0.1.1.post1.dist-info/METADATA,sha256=iJ5t1IJAEERjX3QialzK0PFUwLqqDK0SWbaak9O2GQg,608
+simpserver-0.1.1.post1.dist-info/WHEEL,sha256=YCfwYGOYMi5Jhw2fU4yNgwErybb2IX5PEwBKV4ZbdBo,91
+simpserver-0.1.1.post1.dist-info/top_level.txt,sha256=Obyq3A8DpN639jnvDK9ZgFUlvoYqyY_EgNUuYMVpf58,11
+simpserver-0.1.1.post1.dist-info/RECORD,,

simpserver-0.1.1.post1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

simpserver-0.1.1.post1.dist-info/licenses/LICENSE

@@ -0,0 +1,13 @@
+Copyright 2026 Emanuel Alves de Medeiros
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+   http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

simpserver-0.1.1.post1.dist-info/top_level.txt

@@ -0,0 +1 @@
+simpserver