orionis 0.257.0__tar.gz → 0.265.0__tar.gz

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

@@ -1,14 +1,27 @@
 Metadata-Version: 2.4
 Name: orionis
-Version: 0.257.0
+Version: 0.265.0
 Summary: Orionis Framework – Elegant, Fast, and Powerful.
 Home-page: https://github.com/orionis-framework/framework
 Author: Raul Mauricio Uñate Castro
 Author-email: raulmauriciounate@gmail.com
 Keywords: orionis,framework,python,orionis-framework,django,flask,fastapi,starlettewerkzeuguvicorn
-Classifier: Programming Language :: Python :: 3
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Web Environment
+Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Typing :: Typed
+Classifier: Topic :: Internet :: WWW/HTTP
+Classifier: Topic :: Internet :: WWW/HTTP :: Dynamic Content
+Classifier: Topic :: Internet :: WWW/HTTP :: WSGI
+Classifier: Topic :: Software Development :: Libraries :: Application Frameworks
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Requires-Python: >=3.12
 Description-Content-Type: text/markdown
 License-File: LICENCE

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

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

{orionis-0.257.0 → orionis-0.265.0}/orionis/luminate/_application.py

@@ -4,14 +4,14 @@ from orionis.luminate._contracts.container.container import IContainer
 from orionis.luminate._contracts.foundation.bootstraper import IBootstrapper
 from orionis.luminate._contracts.providers.service_provider import IServiceProvider
 from orionis.luminate._container.container import Container
-from orionis.luminate._foundation.config.config_bootstrapper import ConfigBootstrapper
+# from orionis.luminate._foundation.config.config_bootstrapper import ConfigBootstrapper
 from orionis.luminate._foundation.console.command_bootstrapper import CommandsBootstrapper
 from orionis.luminate._foundation.environment.environment_bootstrapper import EnvironmentBootstrapper
 from orionis.luminate._foundation.exceptions.exception_bootstrapper import BootstrapRuntimeError
 from orionis.luminate._foundation.providers.service_providers_bootstrapper import ServiceProvidersBootstrapper
-from orionis.luminate.support.patterns.singleton import SingletonMeta
+# from orionis.luminate.support.patterns.singleton import SingletonMeta
 
-class Application(metaclass=SingletonMeta):
+class Application:
     """
     Main application class that follows the Singleton pattern.
 
@@ -96,9 +96,10 @@ class Application(metaclass=SingletonMeta):
         RuntimeError
             If the application instance does not exist.
         """
-        if cls not in SingletonMeta._instances:
-            raise RuntimeError("Application instance does not exist. Please create an instance first.")
-        return SingletonMeta._instances[cls]
+        pass
+        # if cls not in SingletonMeta._instances:
+        #     raise RuntimeError("Application instance does not exist. Please create an instance first.")
+        # return SingletonMeta._instances[cls]
 
     @classmethod
     def destroy(cls) -> None:
@@ -112,8 +113,9 @@ class Application(metaclass=SingletonMeta):
         -------
         None
         """
-        if cls in SingletonMeta._instances:
-            del SingletonMeta._instances[cls]
+        pass
+        # if cls in SingletonMeta._instances:
+        #     del SingletonMeta._instances[cls]
 
     def withProviders(self, providers: List[Type[IServiceProvider]] = None) -> "Application":
         """
@@ -193,7 +195,7 @@ class Application(metaclass=SingletonMeta):
         """
         bootstrappers = [
             {'property': self._env, 'instance': EnvironmentBootstrapper()},
-            {'property': self._config, 'instance': ConfigBootstrapper()},
+            # {'property': self._config, 'instance': ConfigBootstrapper()},
             {'property': self._commands, 'instance': CommandsBootstrapper()},
             {'property': self._service_providers, 'instance': ServiceProvidersBootstrapper(self._custom_providers)},
         ]

{orionis-0.257.0 → orionis-0.265.0}/orionis/luminate/_contracts/facades/facade.py

@@ -1,5 +1,5 @@
 from orionis.luminate._container.container import Container
-from orionis.luminate.support.async.async_io import AsyncExecutor
+# from orionis.luminate.support.async.async_io import AsyncExecutor
 
 class FacadeMeta(type):
     """
@@ -34,4 +34,5 @@ class Facade(metaclass=FacadeMeta):
         Resolves the service by using the AsyncExecutor to make it from the Container.
         It's like calling the butler to fetch something from the pantry.
         """
-        return AsyncExecutor.run(Container().make(cls.getFacadeAccessor()))
+        pass
+        # return AsyncExecutor.run(Container().make(cls.getFacadeAccessor()))

{orionis-0.257.0 → orionis-0.265.0}/orionis/luminate/_facades/files/path_facade.py

@@ -1,7 +1,7 @@
 import os
 from orionis.luminate._contracts.facades.files.path_facade import IPath
 from orionis.luminate._contracts.services.files.path_resolver_service import IPathResolverService
-from orionis.luminate._services.files.path_resolver_service import PathResolverService
+# from orionis.luminate._services.files.path_resolver_service import PathResolverService
 
 class Path(IPath):
     """
@@ -66,7 +66,7 @@ class Path(IPath):
         route = os.path.normpath(route)
 
         # Resolve path (Note: The service container is not used here)
-        path_resolver_service : IPathResolverService = PathResolverService()
+        path_resolver_service : None#IPathResolverService = PathResolverService()
         return path_resolver_service.resolve(route)
 
     @staticmethod

{orionis-0.257.0 → orionis-0.265.0}/orionis/luminate/_foundation/environment/environment_bootstrapper.py

@@ -1,6 +1,6 @@
 from typing import Dict
 from orionis.luminate._contracts.foundation.environment.environment_bootstrapper import IEnvironmentBootstrapper
-from orionis.luminate.support.environment.env import Env
+# from orionis.luminate.support.environment.env import Env
 # from orionis.luminate.services.environment.environment_service import EnvironmentService
 
 class EnvironmentBootstrapper(IEnvironmentBootstrapper):
@@ -44,7 +44,7 @@ class EnvironmentBootstrapper(IEnvironmentBootstrapper):
         If the file does not exist, it creates an empty `.env` file. If the file exists,
         it loads the environment variables into the `_environment_vars` dictionary.
         """
-        environment_service =Env()
+        environment_service =Env() # type: ignore
         self._environment_vars = environment_service.all()
 
     def get(self, key: str = None) -> str:

{orionis-0.257.0 → orionis-0.265.0}/orionis/luminate/_providers/files/paths_provider.py

@@ -1,6 +1,6 @@
 from orionis.luminate._contracts.services.files.path_resolver_service import IPathResolverService
 from orionis.luminate._providers.service_provider import ServiceProvider
-from orionis.luminate._services.files.path_resolver_service import PathResolverService
+# from orionis.luminate._services.files.path_resolver_service import PathResolverService
 
 class PathResolverProvider(ServiceProvider):
 
@@ -8,7 +8,8 @@ class PathResolverProvider(ServiceProvider):
         """
         Registers services or bindings into the given container.
         """
-        self.app.singleton(IPathResolverService, PathResolverService)
+        pass
+        # self.app.singleton(IPathResolverService, PathResolverService)
 
     async def boot(self) -> None:
         """

orionis-0.265.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.265.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)