robyn 0.73.0__cp311-cp311-macosx_10_12_x86_64.whl

robyn/dependency_injection.py

@@ -0,0 +1,71 @@
+"""This is Robyn's dependency injection file."""
+
+from typing import Any
+
+
+class DependencyMap:
+    def __init__(self) -> None:
+        self.global_dependency_map: dict[str, Any] = {}
+        # {'router': {'dependency_name': dependency_class}
+        self.router_dependency_map: dict[str, dict[str, Any]] = {}
+
+    def add_router_dependency(self, router, **kwargs):
+        """Adds a dependency to a route.
+
+        Args:
+            router App Object: The route to add the dependency to.
+            kwargs (dict): The dependencies to add to the route.
+        """
+        if router not in self.router_dependency_map:
+            self.router_dependency_map[router] = {}
+
+        self.router_dependency_map[router].update(**kwargs)
+
+    def add_global_dependency(self, **kwargs):
+        """Adds a dependency to all routes.
+
+        Args:
+            kwargs (dict): The dependencies to add to all routes.
+        """
+        for name, element in kwargs.items():
+            self.global_dependency_map.update({name: element})
+
+    def get_router_dependencies(self, router):
+        """Gets the dependencies for a specific route.
+
+        Args:
+            router
+
+        Returns:
+            dict: The dependencies for the specified route.
+        """
+        return self.router_dependency_map.get(router, {})
+
+    def get_global_dependencies(self):
+        """Gets the dependencies for a route.
+
+        Args:
+            route (str): The route to get the dependencies for.
+        """
+        return self.global_dependency_map
+
+    def merge_dependencies(self, target_router):
+        """
+        Merge dependencies from this DependencyMap into another router's DependencyMap.
+
+        Args:
+            target_router: The router with which to merge dependencies.
+
+        This method iterates through the dependencies of this DependencyMap and adds any dependencies
+        that are not already present in the target router's DependencyMap.
+        """
+        for dep_key in self.get_global_dependencies():
+            if dep_key in target_router.dependencies.get_global_dependencies():
+                continue
+            target_router.dependencies.get_global_dependencies()[dep_key] = self.get_global_dependencies()[dep_key]
+
+    def get_dependency_map(self, router) -> dict:
+        return {
+            "global_dependencies": self.get_global_dependencies(),
+            "router_dependencies": self.get_router_dependencies(router),
+        }

robyn/env_populator.py

@@ -0,0 +1,35 @@
+import logging
+import os
+from pathlib import Path
+
+logger = logging.getLogger(__name__)
+
+
+# parse the configuration file returning a list of tuples (key, value) containing the environment variables
+def parser(config_path=None, project_root=""):
+    """Find robyn.env file in root of the project and parse it"""
+    if config_path is None:
+        config_path = Path(project_root) / "robyn.env"
+
+    if config_path.exists():
+        with open(config_path, "r") as f:
+            for line in f:
+                if line.startswith("#"):
+                    continue
+                yield line.strip().split("=")
+
+
+# check for the environment variables set in cli and if not set them
+def load_vars(variables=None, project_root=""):
+    """Main function"""
+
+    if variables is None:
+        variables = parser(project_root=project_root)
+
+    for var in variables:
+        if var[0] in os.environ:
+            logger.info(" Variable %s already set", var[0])
+            continue
+        else:
+            os.environ[var[0]] = var[1]
+            logger.info(" Variable %s set to %s", var[0], var[1])

robyn/events.py

@@ -0,0 +1,6 @@
+from enum import Enum
+
+
+class Events(Enum):
+    STARTUP = "startup"
+    SHUTDOWN = "shutdown"

robyn/exceptions.py

@@ -0,0 +1,32 @@
+import http
+
+
+class HTTPException(Exception):
+    def __init__(self, status_code: int, detail: str | None = None) -> None:
+        if detail is None:
+            detail = http.HTTPStatus(status_code).phrase
+        self.status_code = status_code
+        self.detail = detail
+
+    def __str__(self) -> str:
+        return f"{self.status_code}: {self.detail}"
+
+    def __repr__(self) -> str:
+        class_name = self.__class__.__name__
+        return f"{class_name}(status_code={self.status_code}, detail={self.detail})"
+
+
+class WebSocketException(Exception):
+    def __init__(self, code: int, reason: str | None = None) -> None:
+        self.code = code
+        self.reason = reason or ""
+
+    def __str__(self) -> str:
+        return f"{self.code}: {self.reason}"
+
+    def __repr__(self) -> str:
+        class_name = self.__class__.__name__
+        return f"{class_name}(code={self.code}, reason={self.reason})"
+
+
+__all__ = ["HTTPException", "WebSocketException"]

robyn/jsonify.py

@@ -0,0 +1,13 @@
+import orjson
+
+
+def jsonify(input_dict: dict) -> str:
+    """
+    This function serializes input dict to a json string
+
+    Attributes:
+        input_dict dict: response of the function
+    """
+    output_binary = orjson.dumps(input_dict)
+    output_str = output_binary.decode("utf-8")
+    return output_str

robyn/logger.py

@@ -0,0 +1,80 @@
+import logging
+from enum import Enum
+from typing import Optional
+
+
+class Colors(Enum):
+    BLUE = "\033[94m"
+    CYAN = "\033[96m"
+    GREEN = "\033[92m"
+    YELLOW = "\033[93m"
+    RED = "\033[91m"
+
+
+class Logger:
+    HEADER = "\033[95m"
+    ENDC = "\033[0m"
+    BOLD = "\033[1m"
+    UNDERLINE = "\033[4m"
+
+    def __init__(self):
+        self.logger = logging.getLogger(__name__)
+
+    def _format_msg(
+        self,
+        msg: str,
+        color: Optional[Colors],
+        bold: bool,
+        underline: bool,
+    ):
+        result = msg
+        if color is not None:
+            result = f"{color.value}{result}{Logger.ENDC}"
+        if bold:
+            result = f"{Logger.BOLD}{result}"
+        if underline:
+            result = f"{Logger.UNDERLINE}{result}"
+        return result
+
+    def error(
+        self,
+        msg: str,
+        *args,
+        color: Optional[Colors] = Colors.RED,
+        bold: bool = False,
+        underline: bool = False,
+    ):
+        self.logger.error(self._format_msg(msg, color, bold, underline), *args)
+
+    def warn(
+        self,
+        msg: str,
+        *args,
+        color: Optional[Colors] = Colors.YELLOW,
+        bold: bool = False,
+        underline: bool = False,
+    ):
+        self.logger.warn(self._format_msg(msg, color, bold, underline), *args)
+
+    def info(
+        self,
+        msg: str,
+        *args,
+        color: Optional[Colors] = Colors.GREEN,
+        bold: bool = False,
+        underline: bool = False,
+    ):
+        self.logger.info(self._format_msg(msg, color, bold, underline), *args)
+
+    def debug(
+        self,
+        msg: str,
+        *args,
+        color: Colors = Colors.BLUE,
+        bold: bool = False,
+        underline: bool = False,
+    ):
+        self.logger.debug(self._format_msg(msg, color, bold, underline), *args)
+
+
+logger = Logger()