orionis 0.1.0__py3-none-any.whl

orionis/luminate/installer/setup.py

@@ -0,0 +1,191 @@
+import re
+import os
+import sys
+import shutil
+import tempfile
+import subprocess
+from unicodedata import normalize
+from orionis.framework import SKELETON, DOCS
+from orionis.luminate.installer.output import Output
+from orionis.luminate.contracts.installer.setup_interface import ISetup
+
+class Setup(ISetup):
+    """
+    A class to initialize a Orionis project by performing the following setup actions:
+    1. Sanitize the folder name.
+    2. Clone the repository.
+    3. Create a virtual environment.
+    4. Install dependencies from requirements.txt.
+    5. Set up .env configuration.
+    6. Generate an API key.
+    7. Clean up temporary files and .git origin.
+
+    Parameters
+    ----------
+    output : Output
+        An instance of Output, used to display messages to the console.
+    name_app : str, optional
+        The name of the app to create. If not provided, defaults to "{NAME}_app".
+
+    Attributes
+    ----------
+    output : Output
+        An instance of Output used for logging information.
+    name_app_folder : str
+        The sanitized folder name for the application.
+    """
+
+    def __init__(self, name: str = 'example-app', output = Output):
+        """
+        Initialize OrionislInit class.
+
+        Parameters
+        ----------
+        output : Output
+            An instance of Output to handle logging.
+        name_app : str, optional
+            Name of the application. If not provided, defaults to "example-app".
+        """
+        self.output = output
+        self.output.startInstallation()
+        self.name_app_folder = self._sanitize_folder_name(name)
+
+    def _sanitize_folder_name(self, name: str) -> str:
+        """
+        Sanitize the provided folder name to ensure it is valid across different operating systems.
+
+        Steps:
+        1. Normalize text to remove accents and special characters.
+        2. Convert to lowercase.
+        3. Replace spaces with underscores.
+        4. Remove invalid characters.
+        5. Strip leading and trailing whitespace.
+        6. Enforce length limit (255 characters).
+        7. Ensure the result contains only valid characters.
+
+        Parameters
+        ----------
+        name : str
+            The original folder name to sanitize.
+
+        Returns
+        -------
+        str
+            The sanitized folder name.
+
+        Raises
+        ------
+        ValueError
+            If the sanitized folder name is empty or contains invalid characters.
+        """
+        if not name:
+            self.output.error("Folder name cannot be empty.")
+
+        # Strip leading and trailing whitespace
+        name = name.strip()
+
+        # Normalize to remove accents and special characters
+        name = normalize("NFKD", name).encode("ascii", "ignore").decode("ascii")
+
+        # Convert to lowercase
+        name = name.lower()
+
+        # Replace spaces with underscores
+        name = name.replace(" ", "_")
+
+        # Remove invalid characters for folder names
+        name = re.sub(r'[\\/:*?"<>|]', '', name)
+
+        # Limit the length to 255 characters
+        name = name[:255]
+
+        # Validate against allowed characters
+        if not re.match(r'^[a-z0-9_-]+$', name):
+            self.output.error("The folder name can only contain letters, numbers, underscores, and hyphens.")
+
+        if not name:
+            self.output.error("The sanitized folder name is empty after processing.")
+
+        return name
+
+    def handle(self):
+        """
+        Executes the setup process for initializing the Orionis project.
+
+        This process includes:
+        1. Cloning the repository.
+        2. Creating a virtual environment.
+        3. Installing dependencies from requirements.txt.
+        4. Setting up the .env file.
+        5. Generating an API key.
+        6. Cleaning up temporary files and .git remote origin.
+
+        Raises
+        ------
+        ValueError
+            If there is an error during any subprocess execution.
+        Exception
+            If any unexpected error occurs.
+        """
+        try:
+            # Validate Folder
+            if os.path.exists(self.name_app_folder) and os.path.isdir(self.name_app_folder):
+                self.output.error(f"The folder '{self.name_app_folder}' already exists.")
+
+            # Clone the repository
+            self.output.info(f"Cloning the repository into '{self.name_app_folder}'... (Getting Latest Version)")
+            subprocess.run(["git", "clone", SKELETON, self.name_app_folder], check=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+            self.output.info(f"Repository successfully cloned into '{self.name_app_folder}'.")
+
+            # Change to the project directory
+            project_path = os.path.join(os.getcwd(), self.name_app_folder)
+            os.chdir(project_path)
+            self.output.info(f"Entering directory '{self.name_app_folder}'.")
+
+            # Create a virtual environment
+            self.output.info("Creating virtual environment...")
+            subprocess.run([sys.executable, "-m", "venv", "venv"], check=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+            self.output.info("Virtual environment successfully created.")
+
+            # Virtual environment path
+            venv_path = os.path.join(project_path, "venv", "Scripts" if os.name == "nt" else "bin")
+
+            # Check if requirements.txt exists
+            if not os.path.exists("requirements.txt"):
+                self.output.error(f"'requirements.txt' not found. Please visit the Orionis Docs for more details: {DOCS}")
+
+            # Install dependencies from requirements.txt
+            self.output.info("Installing dependencies from 'requirements.txt'...")
+            subprocess.run([os.path.join(venv_path, "pip"), "install", "-r", "requirements.txt"], check=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+            self.output.info("Dependencies successfully installed.")
+
+            # Create .env
+            example_env_path = os.path.join(project_path, '.env.example')
+            env_path = os.path.join(project_path, '.env')
+            shutil.copy(example_env_path, env_path)
+
+            # Create ApiKey
+            os.chdir(project_path)
+            subprocess.run([sys.executable, '-B', 'reactor', 'key:generate'], capture_output=True, text=True)
+
+            # Remove .git origin
+            subprocess.run(["git", "remote", "remove", "origin"], check=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+
+            # Invalidate Cache File
+            try:
+                temp_dir = tempfile.gettempdir()
+                for filename in os.listdir(temp_dir):
+                    if filename.endswith('started.lab'):
+                        file_path = os.path.join(temp_dir, filename)
+                        os.remove(file_path)
+            except Exception as e:
+                self.output.fail("Unable to delete temporary files created by the framework on the device.")
+
+            # Finish Process Message
+            self.output.info(f"Project '{self.name_app_folder}' successfully created at '{os.path.abspath(project_path)}'.")
+            self.output.endInstallation()
+
+        except subprocess.CalledProcessError as e:
+            self.output.error(f"Error while executing command: {e}")
+        except Exception as e:
+            self.output.error(f"An unexpected error occurred: {e}")

orionis/luminate/installer/upgrade.py

@@ -0,0 +1,42 @@
+import sys
+import subprocess
+from orionis.luminate.installer.output import Output
+from orionis.luminate.contracts.installer.upgrade_interface import IUpgrade
+
+class Upgrade(IUpgrade):
+    """
+    A class responsible for handling the upgrade process of Orionis.
+
+    Methods
+    -------
+    execute() : None
+        Executes the upgrade process to install the latest version of Orionis.
+    """
+
+    @staticmethod
+    def execute():
+        """
+        Handle the --upgrade command to update Orionis to the latest version.
+
+        This method attempts to upgrade Orionis using the pip package manager.
+        It executes a command that installs the latest version of Orionis, ensuring
+        the application is up-to-date.
+
+        Raises
+        ------
+        ValueError
+            If the upgrade process fails or encounters any error during execution.
+
+        Notes
+        -----
+        The upgrade process uses `pip` via the command:
+        `python -m pip install --upgrade orionis`.
+        """
+        output = Output()
+        try:
+            output.info("Starting the upgrade process...")
+            subprocess.check_call([sys.executable, "-m", "pip", "install", "--upgrade", "orionis"])
+        except subprocess.CalledProcessError as e:
+            output.error(message=f"Upgrade failed: {e}")
+        except Exception as e:
+            output.error(message=e)

orionis/luminate/log/logger.py

@@ -0,0 +1,116 @@
+import os
+import logging
+import threading
+from pathlib import Path
+from typing import Optional
+from orionis.luminate.contracts.log.logger_interface import ILogger
+
+class Logguer(ILogger):
+    """
+    A thread-safe singleton logger class for logging messages.
+
+    Attributes
+    ----------
+    logger : logging.Logger
+        The logger instance used for logging messages.
+
+    Methods
+    -------
+    info(message: str)
+        Logs an informational message.
+    error(message: str)
+        Logs an error message.
+    success(message: str)
+        Logs a success message (treated as info).
+    warning(message: str)
+        Logs a warning message.
+    debug(message: str)
+        Logs a debug message.
+    """
+
+    # Singleton instance
+    _instance = None
+
+    # Thread-safe instance creation
+    _lock = threading.Lock()
+
+    def __new__(cls, path: Optional[str] = None, level: int = logging.INFO, filename: Optional[str] = 'orionis.log'):
+        """
+        Creates or returns the singleton instance of the Logguer class.
+
+        Parameters
+        ----------
+        path : str, optional
+            The file path where logs will be stored. If None, a default path is used.
+        level : int, optional
+            The logging level (default is logging.INFO).
+
+        Returns
+        -------
+        Logguer
+            The singleton instance of the logger.
+        """
+        with cls._lock:
+            if cls._instance is None:
+                cls._instance = super(Logguer, cls).__new__(cls)
+                cls._instance._initialize_logger(path, level, filename)
+        return cls._instance
+
+    def _initialize_logger(self, path: Optional[str], level: int, filename: Optional[str] = 'orionis.log'):
+        """
+        Initializes the logger with the specified log file path and logging level.
+
+        Parameters
+        ----------
+        path : str, optional
+            The file path where logs will be stored.
+        level : int
+            The logging level.
+        """
+        try:
+
+            if path is None:
+                base_path = Path(os.getcwd())
+                log_dir = base_path / "storage" / "logs"
+
+                # Check if the log directory exists
+                if log_dir.exists():
+                    path = log_dir / filename
+                else:
+                    path = base_path / filename
+
+            logging.basicConfig(
+                level=level,
+                format="%(asctime)s - %(message)s",
+                datefmt="%Y-%m-%d %H:%M:%S",
+                encoding="utf-8",
+                handlers=[
+                    logging.FileHandler(path)
+                    # logging.StreamHandler()
+                ]
+            )
+
+            self.logger = logging.getLogger(__name__)
+
+        except Exception as e:
+            raise RuntimeError(f"Failed to initialize logger: {e}")
+
+    def info(self, message: str) -> None:
+        """Logs an informational message."""
+        self.logger.info(f"[INFO] - {message}")
+
+    def error(self, message: str) -> None:
+        """Logs an error message."""
+        self.logger.error(f"[ERROR] - {message}")
+
+    def success(self, message: str) -> None:
+        """Logs a success message (treated as info)."""
+        self.logger.info(f"[SUCCESS] - {message}")
+
+    def warning(self, message: str) -> None:
+        """Logs a warning message."""
+        self.logger.warning(f"[WARNING] - {message}")
+
+    def debug(self, message: str) -> None:
+        """Logs a debug message."""
+        self.logger.debug(f"[DEBUG] - {message}")

orionis/luminate/pipelines/cli_pipeline.py

@@ -0,0 +1,116 @@
+import argparse
+from typing import Dict, Any, Optional
+from orionis.luminate.console.parser import Parser
+from orionis.luminate.console.cache import CLICache
+from orionis.luminate.console.base.command import BaseCommand
+from orionis.luminate.contracts.pipelines.cli_pipeline_interface import ICLIPipeline
+
+class CLIPipeline(ICLIPipeline):
+    """
+    Handles the retrieval, parsing, and execution of CLI commands within the Orionis framework.
+
+    This class is responsible for:
+    - Retrieving command metadata from cache.
+    - Parsing command-line arguments dynamically.
+    - Executing the corresponding command with parsed arguments.
+
+    Attributes
+    ----------
+    _command : dict
+        Stores the command's metadata, including its instance and expected arguments.
+    _parsed_arguments : argparse.Namespace
+        Holds parsed arguments after processing user input.
+    """
+
+    def __init__(self):
+        """
+        Initializes the CLIPipeline instance with an empty command cache
+        and a default argument namespace.
+        """
+        self._command: Dict[str, Any] = {}
+        self._parsed_arguments: argparse.Namespace = argparse.Namespace()
+
+    def getCommand(self, signature: str) -> "CLIPipeline":
+        """
+        Retrieves a command from the cache based on its signature.
+
+        Parameters
+        ----------
+        signature : str
+            The unique identifier of the command.
+
+        Returns
+        -------
+        CLIPipeline
+            The current instance of CLIPipeline for method chaining.
+
+        Raises
+        ------
+        ValueError
+            If the command signature is not found in the cache.
+        """
+        try:
+            cache = CLICache().getCommands()
+            self._command = cache.get(signature)
+            return self
+        except KeyError as e:
+            raise ValueError(e)
+
+    def parseArguments(self, vars: Optional[Dict[str, Any]] = None, *args, **kwargs) -> "CLIPipeline":
+        """
+        Parses command-line arguments using the Orionis argument parser.
+
+        Parameters
+        ----------
+        vars : dict, optional
+            A dictionary of predefined variables to be included in parsing.
+        *args
+            Positional arguments for the parser.
+        **kwargs
+            Keyword arguments for the parser.
+
+        Returns
+        -------
+        CLIPipeline
+            The current instance of CLIPipeline for method chaining.
+
+        Raises
+        ------
+        ValueError
+            If an error occurs during argument parsing.
+        """
+        try:
+            arguments = self._command.get("arguments")
+            if arguments:
+                arg_parser = Parser(vars=vars or {}, args=args, kwargs=kwargs)
+                arg_parser.setArguments(arguments=arguments)
+                arg_parser.recognize()
+                self._parsed_arguments = arg_parser.get()
+
+            return self
+
+        except Exception as e:
+            raise ValueError(f"Error parsing arguments: {e}")
+
+    def execute(self) -> Any:
+        """
+        Executes the retrieved command using parsed arguments.
+
+        This method:
+        - Instantiates the command class.
+        - Calls the `handle()` method, passing the parsed arguments.
+
+        Returns
+        -------
+        Any
+            The output of the command execution.
+
+        Raises
+        ------
+        ValueError
+            If the command instance is invalid.
+        """
+        command_class = self._command.get("instance")
+        command_instance: BaseCommand = command_class()
+        command_instance.setArgs(self._parsed_arguments)
+        return command_instance.handle(**vars(self._parsed_arguments))

orionis/luminate/publisher/pypi.py

@@ -0,0 +1,206 @@
+import os
+import sys
+import shutil
+import subprocess
+from orionis.framework import VERSION
+from orionis.luminate.console.output.console import Console
+from orionis.luminate.contracts.publisher.pypi_publisher_interface import IPypiPublisher
+
+class PypiPublisher(IPypiPublisher):
+    """
+    Handles the publishing process of a package to PyPI and repository management.
+
+    This class automates the process of committing changes to a Git repository, building a Python package,
+    uploading it to PyPI, and cleaning up temporary files. It requires a PyPI authentication token.
+
+    Methods
+    -------
+    __init__(token: str = None)
+        Initializes the class with an optional PyPI authentication token.
+
+    gitPush()
+        Commits and pushes changes to the Git repository if modifications are detected.
+
+    build()
+        Compiles the package using `setup.py` to generate distribution files.
+
+    publish()
+        Uploads the package to PyPI using Twine.
+
+    clearRepository()
+        Deletes temporary directories created during the publishing process.
+    """
+
+    def __init__(self, token: str = None):
+        """
+        Initializes the class with an authentication token.
+
+        Parameters
+        ----------
+        token : str, optional
+            Authentication token for PyPI. If not provided, it is retrieved from environment variables.
+
+        Attributes
+        ----------
+        token : str
+            The PyPI authentication token.
+        python_path : str
+            The path to the Python interpreter used in the environment.
+        project_root : str
+            The root directory of the project where the process is executed.
+        """
+        self.token = token or os.getenv("PYPI_TOKEN").strip()
+        self.python_path = sys.executable
+        self.project_root = os.getcwd()
+        self.clearRepository()
+        Console.clear()
+        Console.newLine()
+
+    def gitPush(self):
+        """
+        Commits and pushes changes to the Git repository if there are modifications.
+
+        This method checks for uncommitted changes and stages, commits, and pushes them
+        to the remote Git repository.
+
+        If there are no changes, it logs a message indicating no commits are necessary.
+
+        Raises
+        ------
+        subprocess.CalledProcessError
+            If any of the subprocess calls to Git fail.
+        """
+        subprocess.run(
+            ["git", "rm", "-r", "--cached", "."], capture_output=True, text=True, cwd=self.project_root
+        )
+
+        git_status = subprocess.run(
+            ["git", "status", "--short"], capture_output=True, text=True, cwd=self.project_root
+        )
+        modified_files = git_status.stdout.strip()
+
+        if modified_files:
+            Console.info("📌 Staging files for commit...")
+            subprocess.run(
+                ["git", "add", "."], check=True, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, cwd=self.project_root
+            )
+
+            Console.info(f"✅ Committing changes: '📦 Release version {VERSION}'")
+            subprocess.run(
+                ["git", "commit", "-m", f"📦 Release version {VERSION}"], check=True, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, cwd=self.project_root
+            )
+
+            Console.info("🚀 Pushing changes to the remote repository...")
+            subprocess.run(
+                ["git", "push", "-f"], check=True, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, cwd=self.project_root
+            )
+        else:
+            Console.info("✅ No changes to commit.")
+
+    def build(self):
+        """
+        Compiles the package using `setup.py` to generate distribution files.
+
+        This method runs the `setup.py` script to generate both source (`sdist`)
+        and wheel (`bdist_wheel`) distribution formats for the package.
+
+        Raises
+        ------
+        subprocess.CalledProcessError
+            If the `setup.py` command fails.
+        """
+        try:
+            Console.info("🛠️  Building the package...")
+
+            setup_path = os.path.join(self.project_root, "setup.py")
+            if not os.path.exists(setup_path):
+                Console.error("❌ Error: setup.py not found in the current execution directory.")
+                return
+
+            subprocess.run(
+                [self.python_path, "setup.py", "sdist", "bdist_wheel"], check=True, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, cwd=self.project_root
+            )
+
+            Console.info("✅ Build process completed successfully!")
+        except subprocess.CalledProcessError as e:
+            Console.error(f"❌ Build failed: {e}")
+
+    def publish(self):
+        """
+        Uploads the package to PyPI using Twine.
+
+        This method uses the `twine` command to upload the built distribution files
+        from the `dist/` folder to the PyPI repository.
+
+        Parameters
+        ----------
+        token : str
+            The PyPI authentication token, which is passed during the initialization.
+
+        Raises
+        ------
+        subprocess.CalledProcessError
+            If the Twine command fails during the upload process.
+        ValueError
+            If no token is provided for authentication.
+        """
+        token = self.token
+        if not token:
+            Console.error("❌ Error: PyPI token not found in environment variables.")
+            return
+
+        twine_path = os.path.join(self.project_root, 'venv', 'Scripts', 'twine')
+        twine_path = os.path.abspath(twine_path)
+
+        Console.info("📤 Uploading package to PyPI...")
+        try:
+            subprocess.run(
+                [twine_path, "upload", "dist/*", "-u", "__token__", "-p", token],
+                check=True, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, cwd=self.project_root
+            )
+        except Exception as e:
+            Console.fail(f"🔴 Error loading the package. Try changing the version and retry. Error: {e}")
+            Console.warning("⛔ If the issue persists, review the script in detail.")
+            exit()
+
+        Console.info("🧹 Cleaning up temporary files...")
+        subprocess.run(
+            ["powershell", "-Command", "Get-ChildItem -Recurse -Filter *.pyc | Remove-Item; Get-ChildItem -Recurse -Filter __pycache__ | Remove-Item -Recurse"],
+            check=True, shell=True, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, cwd=self.project_root
+        )
+        self.clearRepository()
+        Console.success(f"✅ [v{VERSION}] - Publishing process completed successfully!")
+        Console.newLine()
+
+    def clearRepository(self):
+        """
+        Deletes temporary directories created during the publishing process.
+
+        This method removes the following directories from the project root:
+        - `build/`
+        - `dist/`
+        - `orionis.egg-info/`
+
+        Raises
+        ------
+        PermissionError
+            If the method fails to delete any of the directories due to insufficient permissions.
+        Exception
+            If any other error occurs during the deletion process.
+        """
+
+        # Remove the log file if it exists
+        if os.path.exists('orionis.log'):
+            os.remove('orionis.log')
+
+        # Remove the build, dist, and egg-info directories
+        folders = ["build", "dist", "orionis.egg-info"]
+        for folder in folders:
+            folder_path = os.path.join(self.project_root, folder)
+            if os.path.exists(folder_path):
+                try:
+                    shutil.rmtree(folder_path)
+                except PermissionError:
+                    Console.error(f"❌ Error: Could not remove {folder_path} due to insufficient permissions.")
+                except Exception as e:
+                    Console.error(f"❌ Error removing {folder_path}: {str(e)}")