orionis 0.257.0__tar.gz → 0.258.0__tar.gz

{orionis-0.257.0/orionis.egg-info → orionis-0.258.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: orionis
-Version: 0.257.0
+Version: 0.258.0
 Summary: Orionis Framework – Elegant, Fast, and Powerful.
 Home-page: https://github.com/orionis-framework/framework
 Author: Raul Mauricio Uñate Castro

{orionis-0.257.0 → orionis-0.258.0}/orionis/framework.py

@@ -5,7 +5,7 @@
 NAME = "orionis"
 
 # Current version of the framework
-VERSION = "0.257.0"
+VERSION = "0.258.0"
 
 # Full name of the author or maintainer of the project
 AUTHOR = "Raul Mauricio Uñate Castro"

orionis-0.258.0/orionis/luminate/app.py

@@ -0,0 +1,19 @@
+from orionis.luminate.foundation.config.startup import Configuration
+from orionis.luminate.foundation.skeletom.startup import SkeletomConfiguration
+
+class Orionis:
+
+    def __init__(
+        self,
+        skeletom: SkeletomConfiguration = None,
+        config: Configuration = None
+    ):
+        """
+        Initializes the Orionis instance with optional configuration objects.
+
+        Args:
+            skeletom (SkeletomConfiguration, optional): Custom Skeletom configuration.
+            config (Configuration, optional): Custom application configuration.
+        """
+        self.__skeletom = skeletom or SkeletomConfiguration()
+        self.__config = config or Configuration()

orionis-0.258.0/orionis/luminate/foundation/config/roots/paths.py

@@ -0,0 +1,446 @@
+from dataclasses import asdict, dataclass, field
+from pathlib import Path
+from typing import Dict
+from orionis.luminate.foundation.config.exceptions.integrity import OrionisIntegrityException
+
+@dataclass(frozen=True, kw_only=True)
+class Paths:
+    """
+    A frozen dataclass representing the canonical directory and file structure
+    for a Laravel-inspired Python project.
+
+    This class provides type-safe access to all standard project paths and includes
+    validation to ensure path integrity. All paths are relative to the project root.
+
+    Attributes are organized into logical groups:
+    - Application components (controllers, models, services)
+    - Resources (views, assets, translations)
+    - Routing configuration
+    - Configuration and database
+    - Storage locations
+    """
+
+    # --- Application Paths ---
+    console_scheduler: str = field(
+        default='app/console/kernel.py',
+        metadata={
+            'description': 'Path to the console scheduler (Kernel) file.',
+            'type': 'file',
+            'required': True
+        }
+    )
+
+    console_commands: str = field(
+        default='app/console/commands',
+        metadata={
+            'description': 'Directory containing custom Artisan-style console commands.',
+            'type': 'directory',
+            'required': True
+        }
+    )
+
+    http_controllers: str = field(
+        default='app/http/controllers',
+        metadata={
+            'description': 'Directory containing HTTP controller classes.',
+            'type': 'directory',
+            'required': True
+        }
+    )
+
+    http_middleware: str = field(
+        default='app/http/middleware',
+        metadata={
+            'description': 'Directory containing HTTP middleware classes.',
+            'type': 'directory',
+            'required': True
+        }
+    )
+
+    http_requests: str = field(
+        default='app/http/requests',
+        metadata={
+            'description': 'Directory containing HTTP form request validation classes.',
+            'type': 'directory',
+            'required': False
+        }
+    )
+
+    models: str = field(
+        default='app/models',
+        metadata={
+            'description': 'Directory containing ORM model classes.',
+            'type': 'directory',
+            'required': True
+        }
+    )
+
+    providers: str = field(
+        default='app/providers',
+        metadata={
+            'description': 'Directory containing service provider classes.',
+            'type': 'directory',
+            'required': True
+        }
+    )
+
+    events: str = field(
+        default='app/events',
+        metadata={
+            'description': 'Directory containing event classes.',
+            'type': 'directory',
+            'required': False
+        }
+    )
+
+    listeners: str = field(
+        default='app/listeners',
+        metadata={
+            'description': 'Directory containing event listener classes.',
+            'type': 'directory',
+            'required': False
+        }
+    )
+
+    notifications: str = field(
+        default='app/notifications',
+        metadata={
+            'description': 'Directory containing notification classes.',
+            'type': 'directory',
+            'required': False
+        }
+    )
+
+    jobs: str = field(
+        default='app/jobs',
+        metadata={
+            'description': 'Directory containing queued job classes.',
+            'type': 'directory',
+            'required': False
+        }
+    )
+
+    policies: str = field(
+        default='app/policies',
+        metadata={
+            'description': 'Directory containing authorization policy classes.',
+            'type': 'directory',
+            'required': False
+        }
+    )
+
+    exceptions: str = field(
+        default='app/exceptions',
+        metadata={
+            'description': 'Directory containing exception handler classes.',
+            'type': 'directory',
+            'required': True
+        }
+    )
+
+    services: str = field(
+        default='app/services',
+        metadata={
+            'description': 'Directory containing business logic service classes.',
+            'type': 'directory',
+            'required': False
+        }
+    )
+
+    # --- Resource Paths ---
+    views: str = field(
+        default='resources/views',
+        metadata={
+            'description': 'Directory containing template view files.',
+            'type': 'directory',
+            'required': True
+        }
+    )
+
+    lang: str = field(
+        default='resources/lang',
+        metadata={
+            'description': 'Directory containing internationalization files.',
+            'type': 'directory',
+            'required': False
+        }
+    )
+
+    assets: str = field(
+        default='resources/assets',
+        metadata={
+            'description': 'Directory containing frontend assets (JS, CSS, images).',
+            'type': 'directory',
+            'required': False
+        }
+    )
+
+    # --- Routing Paths ---
+    routes_web: str = field(
+        default='routes/web.py',
+        metadata={
+            'description': 'Path to the web routes definition file.',
+            'type': 'file',
+            'required': True
+        }
+    )
+
+    routes_api: str = field(
+        default='routes/api.py',
+        metadata={
+            'description': 'Path to the API routes definition file.',
+            'type': 'file',
+            'required': False
+        }
+    )
+
+    routes_console: str = field(
+        default='routes/console.py',
+        metadata={
+            'description': 'Path to the console routes definition file.',
+            'type': 'file',
+            'required': False
+        }
+    )
+
+    routes_channels: str = field(
+        default='routes/channels.py',
+        metadata={
+            'description': 'Path to the broadcast channels routes file.',
+            'type': 'file',
+            'required': False
+        }
+    )
+
+    # --- Configuration & Database Paths ---
+    config: str = field(
+        default='config',
+        metadata={
+            'description': 'Directory containing application configuration files.',
+            'type': 'directory',
+            'required': True
+        }
+    )
+
+    migrations: str = field(
+        default='database/migrations',
+        metadata={
+            'description': 'Directory containing database migration files.',
+            'type': 'directory',
+            'required': True
+        }
+    )
+
+    seeders: str = field(
+        default='database/seeders',
+        metadata={
+            'description': 'Directory containing database seeder files.',
+            'type': 'directory',
+            'required': False
+        }
+    )
+
+    factories: str = field(
+        default='database/factories',
+        metadata={
+            'description': 'Directory containing model factory files.',
+            'type': 'directory',
+            'required': False
+        }
+    )
+
+    # --- Storage Paths ---
+    storage_logs: str = field(
+        default='storage/logs',
+        metadata={
+            'description': 'Directory containing application log files.',
+            'type': 'directory',
+            'required': True
+        }
+    )
+
+    storage_framework: str = field(
+        default='storage/framework',
+        metadata={
+            'description': 'Directory for framework-generated files (cache, sessions, views).',
+            'type': 'directory',
+            'required': True
+        }
+    )
+
+    storage_sessions: str = field(
+        default='storage/framework/sessions',
+        metadata={
+            'description': 'Directory containing session files.',
+            'type': 'directory',
+            'required': False
+        }
+    )
+
+    storage_cache: str = field(
+        default='storage/framework/cache',
+        metadata={
+            'description': 'Directory containing framework cache files.',
+            'type': 'directory',
+            'required': False
+        }
+    )
+
+    storage_views: str = field(
+        default='storage/framework/views',
+        metadata={
+            'description': 'Directory containing compiled view files.',
+            'type': 'directory',
+            'required': False
+        }
+    )
+
+    def __post_init__(self) -> None:
+        """
+        Validates all path fields after initialization.
+
+        Raises:
+            OrionisIntegrityException: If any path is invalid (empty or not a string)
+        """
+        for field_name, field_info in self.__dataclass_fields__.items():
+            value = getattr(self, field_name)
+            metadata:dict = field_info.metadata
+
+            if not isinstance(value, str) or not value.strip():
+                raise OrionisIntegrityException(
+                    f"Invalid path value for '{field_name}': {value!r}. Must be non-empty string."
+                )
+
+            if metadata.get('required', False) and not value:
+                raise OrionisIntegrityException(
+                    f"Required path '{field_name}' cannot be empty."
+                )
+
+    # --- Path Accessors ---
+    def getConsoleScheduler(self) -> Path:
+        """Get Path object for console scheduler file."""
+        return Path(self.console_scheduler)
+
+    def getConsoleCommands(self) -> Path:
+        """Get Path object for console commands directory."""
+        return Path(self.console_commands)
+
+    def getHttpControllers(self) -> Path:
+        """Get Path object for HTTP controllers directory."""
+        return Path(self.http_controllers)
+
+    def getHttpMiddleware(self) -> Path:
+        """Get Path object for HTTP middleware directory."""
+        return Path(self.http_middleware)
+
+    def getHttpRequests(self) -> Path:
+        """Get Path object for HTTP requests directory."""
+        return Path(self.http_requests)
+
+    def getModels(self) -> Path:
+        """Get Path object for models directory."""
+        return Path(self.models)
+
+    def getProviders(self) -> Path:
+        """Get Path object for service providers directory."""
+        return Path(self.providers)
+
+    def getEvents(self) -> Path:
+        """Get Path object for events directory."""
+        return Path(self.events)
+
+    def getListeners(self) -> Path:
+        """Get Path object for event listeners directory."""
+        return Path(self.listeners)
+
+    def getNotifications(self) -> Path:
+        """Get Path object for notifications directory."""
+        return Path(self.notifications)
+
+    def getJobs(self) -> Path:
+        """Get Path object for queued jobs directory."""
+        return Path(self.jobs)
+
+    def getPolicies(self) -> Path:
+        """Get Path object for authorization policies directory."""
+        return Path(self.policies)
+
+    def getExceptions(self) -> Path:
+        """Get Path object for exceptions directory."""
+        return Path(self.exceptions)
+
+    def getServices(self) -> Path:
+        """Get Path object for services directory."""
+        return Path(self.services)
+
+    def getViews(self) -> Path:
+        """Get Path object for views directory."""
+        return Path(self.views)
+
+    def getLang(self) -> Path:
+        """Get Path object for language files directory."""
+        return Path(self.lang)
+
+    def getAssets(self) -> Path:
+        """Get Path object for assets directory."""
+        return Path(self.assets)
+
+    def getRoutesWeb(self) -> Path:
+        """Get Path object for web routes file."""
+        return Path(self.routes_web)
+
+    def getRoutesApi(self) -> Path:
+        """Get Path object for API routes file."""
+        return Path(self.routes_api)
+
+    def getRoutesConsole(self) -> Path:
+        """Get Path object for console routes file."""
+        return Path(self.routes_console)
+
+    def getRoutesChannels(self) -> Path:
+        """Get Path object for broadcast channels routes file."""
+        return Path(self.routes_channels)
+
+    def getConfig(self) -> Path:
+        """Get Path object for config directory."""
+        return Path(self.config)
+
+    def getMigrations(self) -> Path:
+        """Get Path object for migrations directory."""
+        return Path(self.migrations)
+
+    def getSeeders(self) -> Path:
+        """Get Path object for seeders directory."""
+        return Path(self.seeders)
+
+    def getFactories(self) -> Path:
+        """Get Path object for model factories directory."""
+        return Path(self.factories)
+
+    def getStorageLogs(self) -> Path:
+        """Get Path object for logs directory."""
+        return Path(self.storage_logs)
+
+    def getStorageFramework(self) -> Path:
+        """Get Path object for framework storage directory."""
+        return Path(self.storage_framework)
+
+    def getStorageSessions(self) -> Path:
+        """Get Path object for sessions storage directory."""
+        return Path(self.storage_sessions)
+
+    def getStorageCache(self) -> Path:
+        """Get Path object for cache storage directory."""
+        return Path(self.storage_cache)
+
+    def getStorageViews(self) -> Path:
+        """Get Path object for compiled views storage directory."""
+        return Path(self.storage_views)
+
+    def toDict(self) -> Dict[str, str]:
+        """
+        Returns a dictionary representation of all paths.
+        Returns:
+            Dict[str, str]: Dictionary mapping field names to path strings
+        """
+        return asdict(self)

{orionis-0.257.0 → orionis-0.258.0}/orionis/luminate/foundation/config/startup.py

@@ -9,6 +9,7 @@ from orionis.luminate.foundation.config.filesystems.entitites.filesystems import
 from orionis.luminate.foundation.config.logging.entities.logging import Logging
 from orionis.luminate.foundation.config.mail.entities.mail import Mail
 from orionis.luminate.foundation.config.queue.entities.queue import Queue
+from orionis.luminate.foundation.config.roots.paths import Paths
 from orionis.luminate.foundation.config.session.entities.session import Session
 from orionis.luminate.foundation.config.testing.entities.testing import Testing
 
@@ -17,6 +18,7 @@ class Configuration:
     """
     Configuration class encapsulates all major configuration sections for the application.
     Attributes:
+        paths (Paths): Paths configuration settings.
         app (App): Application configuration settings.
         auth (Auth): Authentication configuration settings.
         cache (Cache): Cache configuration settings.
@@ -29,6 +31,12 @@ class Configuration:
         session (Session): Session configuration settings.
         testing (Testing): Testing configuration settings.
     """
+    paths : Paths = field(
+        default_factory=Paths,
+        metadata={
+            "description": "Paths configuration settings."
+        }
+    )
 
     app : App = field(
         default_factory=App,
@@ -109,32 +117,82 @@ class Configuration:
 
     def __post_init__(self):
         """
-        Post-initialization method to ensure integrity of configuration sections.
+        Validates the types of the configuration attributes after initialization.
         Raises:
-            OrionisIntegrityException: If any configuration section is not of the expected type.
+            OrionisIntegrityException: If any of the following attributes are not instances of their expected types:
+                - paths (Paths)
+                - app (App)
+                - auth (Auth)
+                - cache (Cache)
+                - cors (Cors)
+                - database (Database)
+                - filesystems (Filesystems)
+                - logging (Logging)
+                - mail (Mail)
+                - queue (Queue)
+                - session (Session)
+                - testing (Testing)
         """
+
+        if not isinstance(self.paths, Paths):
+            raise OrionisIntegrityException(
+                f"Invalid type for 'paths': expected Paths, got {type(self.paths).__name__}"
+            )
+
         if not isinstance(self.app, App):
-            raise OrionisIntegrityException("app must be an instance of App")
+            raise OrionisIntegrityException(
+                f"Invalid type for 'app': expected App, got {type(self.app).__name__}"
+            )
+
         if not isinstance(self.auth, Auth):
-            raise OrionisIntegrityException("auth must be an instance of Auth")
+            raise OrionisIntegrityException(
+                f"Invalid type for 'auth': expected Auth, got {type(self.auth).__name__}"
+            )
+
         if not isinstance(self.cache, Cache):
-            raise OrionisIntegrityException("cache must be an instance of Cache")
+            raise OrionisIntegrityException(
+                f"Invalid type for 'cache': expected Cache, got {type(self.cache).__name__}"
+            )
+
         if not isinstance(self.cors, Cors):
-            raise OrionisIntegrityException("cors must be an instance of Cors")
+            raise OrionisIntegrityException(
+                f"Invalid type for 'cors': expected Cors, got {type(self.cors).__name__}"
+            )
+
         if not isinstance(self.database, Database):
-            raise OrionisIntegrityException("database must be an instance of Database")
+            raise OrionisIntegrityException(
+                f"Invalid type for 'database': expected Database, got {type(self.database).__name__}"
+            )
+
         if not isinstance(self.filesystems, Filesystems):
-            raise OrionisIntegrityException("filesystems must be an instance of Filesystems")
+            raise OrionisIntegrityException(
+                f"Invalid type for 'filesystems': expected Filesystems, got {type(self.filesystems).__name__}"
+            )
+
         if not isinstance(self.logging, Logging):
-            raise OrionisIntegrityException("logging must be an instance of Logging")
+            raise OrionisIntegrityException(
+                f"Invalid type for 'logging': expected Logging, got {type(self.logging).__name__}"
+            )
+
         if not isinstance(self.mail, Mail):
-            raise OrionisIntegrityException("mail must be an instance of Mail")
+            raise OrionisIntegrityException(
+                f"Invalid type for 'mail': expected Mail, got {type(self.mail).__name__}"
+            )
+
         if not isinstance(self.queue, Queue):
-            raise OrionisIntegrityException("queue must be an instance of Queue")
+            raise OrionisIntegrityException(
+                f"Invalid type for 'queue': expected Queue, got {type(self.queue).__name__}"
+            )
+
         if not isinstance(self.session, Session):
-            raise OrionisIntegrityException("session must be an instance of Session")
+            raise OrionisIntegrityException(
+                f"Invalid type for 'session': expected Session, got {type(self.session).__name__}"
+            )
+
         if not isinstance(self.testing, Testing):
-            raise OrionisIntegrityException("testing must be an instance of Testing")
+            raise OrionisIntegrityException(
+                f"Invalid type for 'testing': expected Testing, got {type(self.testing).__name__}"
+            )
 
     def toDict(self) -> dict:
         """

{orionis-0.257.0 → orionis-0.258.0}/orionis/luminate/services/introspection/dependencies/entities/class_dependencies.py

@@ -1,6 +1,6 @@
 from dataclasses import dataclass
 from typing import Any, Dict, List
-from orionis.luminate.support.introspection.dependencies.entities.resolved_dependencies import ResolvedDependency
+from orionis.luminate.services.introspection.dependencies.entities.resolved_dependencies import ResolvedDependency
 
 @dataclass(frozen=True, kw_only=True)
 class ClassDependency:
@@ -34,26 +34,8 @@ class ClassDependency:
                 f"'resolved' must be a dict, got {type(self.resolved).__name__}"
             )
 
-        for key in self.resolved:
-            if not isinstance(key, ResolvedDependency):
-                raise TypeError(
-                    f"All keys in 'resolved' must be ResolvedDependency, "
-                    f"found {type(key).__name__}"
-                )
-            if key is None:
-                raise ValueError("'resolved' cannot contain None keys")
-
         # Validate 'unresolved' is a list of non-empty strings
         if not isinstance(self.unresolved, list):
             raise TypeError(
                 f"'unresolved' must be a list, got {type(self.unresolved).__name__}"
-            )
-
-        for item in self.unresolved:
-            if not isinstance(item, str):
-                raise TypeError(
-                    f"All items in 'unresolved' must be str, "
-                    f"found {type(item).__name__}"
-                )
-            if not item.strip():
-                raise ValueError("'unresolved' cannot contain empty strings")
+            )

{orionis-0.257.0 → orionis-0.258.0}/orionis/luminate/services/introspection/dependencies/entities/method_dependencies.py

@@ -1,6 +1,6 @@
 from dataclasses import dataclass
 from typing import Any, Dict, List
-from orionis.luminate.support.introspection.dependencies.entities.resolved_dependencies import ResolvedDependency
+from orionis.luminate.services.introspection.dependencies.entities.resolved_dependencies import ResolvedDependency
 
 @dataclass(frozen=True, kw_only=True)
 class MethodDependency:
@@ -35,30 +35,8 @@ class MethodDependency:
                 f"'resolved' must be a dict, got {type(self.resolved).__name__}"
             )
 
-        for dependency in self.resolved:
-            if not isinstance(dependency, ResolvedDependency):
-                raise TypeError(
-                    f"All keys in 'resolved' must be ResolvedDependency instances, "
-                    f"found {type(dependency).__name__}"
-                )
-            if dependency is None:
-                raise ValueError("'resolved' cannot contain None keys")
-
         # Validate 'unresolved' is a list of valid parameter names
         if not isinstance(self.unresolved, list):
             raise TypeError(
                 f"'unresolved' must be a list, got {type(self.unresolved).__name__}"
-            )
-
-        for param in self.unresolved:
-            if not isinstance(param, str):
-                raise TypeError(
-                    f"All items in 'unresolved' must be strings, "
-                    f"found {type(param).__name__}"
-                )
-            if not param.strip():
-                raise ValueError("'unresolved' cannot contain empty parameter names")
-            if not param.isidentifier():
-                raise ValueError(
-                    f"Parameter name '{param}' must be a valid Python identifier"
-                )
+            )