feat: finaliser la passe globale docs/normalisation et stabilisation

Author: raidos23

Core/ArkConfigManager.py

@@ -131,19 +131,19 @@
 
 def _deep_merge_dict(base: dict, override: dict) -> dict:
     """
- Recursively merge two dictionaries.
+    Recursively merge two dictionaries.
 
- Cette fonction permet de combiner une configuration de base avec des
- valeurs personnalisées. Les dictionnaires imbriqués sont fusionnés
- plutôt que remplacés, permettant une configuration modulaire.
+    Cette fonction permet de combiner une configuration de base avec des
+    valeurs personnalisées. Les dictionnaires imbriqués sont fusionnés
+    plutôt que remplacés, permettant une configuration modulaire.
 
- Args:
-  base: Dictionnaire de configuration de base
-  override: Dictionnaire contenant les valeurs à surloadr
+    Args:
+     base: Dictionnaire de configuration de base
+     override: Dictionnaire contenant les valeurs à surloadr
 
- Returns:
-  Un nouveau dictionnaire avec les valeurs fusionnées
- """
+    Returns:
+     Un nouveau dictionnaire avec les valeurs fusionnées
+    """
     result = base.copy()
     for key, value in override.items():
         if key in result and isinstance(result[key], dict) and isinstance(value, dict):
@@ -157,25 +157,25 @@ def _deep_merge_dict(base: dict, override: dict) -> dict:
 
 def load_ark_config(workspace_dir: str) -> dict[str, Any]:
     """
- Load ARK configuration from a YAML file.
+    Load ARK configuration from a YAML file.
 
- Cette fonction recherche un file de configuration dans le workspace
- selon un ordre de priorité prédéfini et fusionne la configuration
- utilisateur avec les valeurs par défaut.
+    Cette fonction recherche un file de configuration dans le workspace
+    selon un ordre de priorité prédéfini et fusionne la configuration
+    utilisateur avec les valeurs par défaut.
 
- Fichiers recherchés (ordre de priorité):
- 1. ARK_Main_Config.yaml
- 2. ARK_Main_Config.yml
- 3. .ARK_Main_Config.yaml
- 4. .ARK_Main_Config.yml
+    Fichiers recherchés (ordre de priorité):
+    1. ARK_Main_Config.yaml
+    2. ARK_Main_Config.yml
+    3. .ARK_Main_Config.yaml
+    4. .ARK_Main_Config.yml
 
- Args:
-  workspace_dir: Path absolu vers le directory du workspace
+    Args:
+     workspace_dir: Path absolu vers le directory du workspace
 
- Returns:
-  Dictionnaire complet de configuration, incluant les valeurs par défaut
-  et les personnalisations utilisateur
- """
+    Returns:
+     Dictionnaire complet de configuration, incluant les valeurs par défaut
+     et les personnalisations utilisateur
+    """
     import copy
 
     # Commencer avec une copie complète de la configuration par défaut
@@ -283,41 +283,41 @@ def load_ark_config(workspace_dir: str) -> dict[str, Any]:
 
 def get_dependency_options(config: dict[str, Any]) -> dict[str, Any]:
     """
- Return dependency management options.
+    Return dependency management options.
 
- Returns:
-  Dictionnaire des options de dependencies
- """
+    Returns:
+     Dictionnaire des options de dependencies
+    """
     return config.get("dependencies", {})
 
 
 def get_environment_manager_options(config: dict[str, Any]) -> dict[str, Any]:
     """
-  Return virtual environment manager options.
+    Return virtual environment manager options.
 
-  Returns:
-    Dictionary of environment manager options.
-  """
+    Returns:
+      Dictionary of environment manager options.
+    """
     return config.get("environment_manager", {})
 
 
 def get_build_options(config: dict[str, Any]) -> dict[str, Any]:
     """
-  Return build options.
+    Return build options.
 
-  Returns:
-    Dictionary of build options.
-  """
+    Returns:
+      Dictionary of build options.
+    """
     return config.get("build", {})
 
 
 def get_entrypoint(config: dict[str, Any]) -> Optional[str]:
     """
- Return configured entry point.
+    Return configured entry point.
 
- Returns:
-  Path relatif du point d'entrée ou None
- """
+    Returns:
+     Path relatif du point d'entrée ou None
+    """
     build_opts = get_build_options(config)
     if not isinstance(build_opts, dict):
         return None
@@ -327,15 +327,15 @@ def get_entrypoint(config: dict[str, Any]) -> Optional[str]:
 
 def save_ark_config(workspace_dir: str, config: dict[str, Any]) -> bool:
     """
- Save ARK configuration to ARK_Main_Config.yml.
+    Save ARK configuration to ARK_Main_Config.yml.
 
- Args:
-  workspace_dir: Path du workspace
-  config: Configuration complète à enregistrer
+    Args:
+     workspace_dir: Path du workspace
+     config: Configuration complète à enregistrer
 
- Returns:
-  True si success, False sinon
- """
+    Returns:
+     True si success, False sinon
+    """
     if not workspace_dir or not isinstance(config, dict):
         return False
     try:
@@ -356,15 +356,15 @@ def save_ark_config(workspace_dir: str, config: dict[str, Any]) -> bool:
 
 def set_entrypoint(workspace_dir: str, entrypoint: Optional[str]) -> bool:
     """
- Update entry point in ARK_Main_Config.yml.
+    Update entry point in ARK_Main_Config.yml.
 
- Args:
-  workspace_dir: Path du workspace
-  entrypoint: Path relatif du point d'entrée (ou None pour clearr)
+    Args:
+     workspace_dir: Path du workspace
+     entrypoint: Path relatif du point d'entrée (ou None pour clearr)
 
- Returns:
-  True si success, False sinon
- """
+    Returns:
+     True si success, False sinon
+    """
     if not workspace_dir:
         return False
     cfg = load_ark_config(workspace_dir)
@@ -382,12 +382,12 @@ def set_entrypoint(workspace_dir: str, entrypoint: Optional[str]) -> bool:
 
 def _normalize_exclusion_pattern(pattern: str) -> str:
     """
- Normalize exclusion pattern for reliable cross-platform matching.
+    Normalize exclusion pattern for reliable cross-platform matching.
 
- - Convertit les séparateurs Windows en "/"
- - Retire le préfixe "./"
- - Si le pattern se termine par "/", on l'étend à "/**"
- """
+    - Convertit les séparateurs Windows en "/"
+    - Retire le préfixe "./"
+    - Si le pattern se termine par "/", on l'étend à "/**"
+    """
     p = str(pattern).strip()
     if not p:
         return ""
@@ -403,20 +403,20 @@ def should_exclude_file(
     file_path: str, workspace_dir: str, exclusion_patterns: Optional[list[str]]
 ) -> bool:
     """
-  Determine whether a file must be excluded from compilation.
+    Determine whether a file must be excluded from compilation.
 
-  Compare file path with configured exclusion patterns. The function
-  normalizes separators and combines `Path.match()` with `fnmatch` to
-  support glob patterns like `**` in a cross-platform way.
+    Compare file path with configured exclusion patterns. The function
+    normalizes separators and combines `Path.match()` with `fnmatch` to
+    support glob patterns like `**` in a cross-platform way.
 
-  Args:
-    file_path: Absolute file path to check.
-    workspace_dir: Absolute workspace path.
-    exclusion_patterns: List of exclusion patterns.
+    Args:
+      file_path: Absolute file path to check.
+      workspace_dir: Absolute workspace path.
+      exclusion_patterns: List of exclusion patterns.
 
-  Returns:
-    `True` when file must be excluded, otherwise `False`.
-  """
+    Returns:
+      `True` when file must be excluded, otherwise `False`.
+    """
     try:
         if not file_path or not workspace_dir:
             return False
@@ -482,19 +482,19 @@ def should_exclude_file(
 
 def create_default_ark_config(workspace_dir: str) -> bool:
     """
- Create ARK_Main_Config.yml with default configuration.
+    Create ARK_Main_Config.yml with default configuration.
 
- Cette fonction génère un file de configuration complet avec
- toutes les options disponibles et leurs valeurs par défaut.
- Elle ne remplace pas un file existant.
+    Cette fonction génère un file de configuration complet avec
+    toutes les options disponibles et leurs valeurs par défaut.
+    Elle ne remplace pas un file existant.
 
- Args:
-  workspace_dir: Path du directory du workspace
+    Args:
+     workspace_dir: Path du directory du workspace
 
- Returns:
-  True si le file a été créé avec success, False s'il existe déjà
-  ou si une erreur s'est produite
- """
+    Returns:
+     True si le file a été créé avec success, False s'il existe déjà
+     ou si une erreur s'est produite
+    """
     if not workspace_dir:
         return False
 

Core/Auto_Command_Builder/auto_build.py

@@ -179,8 +179,8 @@ def _load_mapping(
     base_dir: str, workspace_dir: Optional[str] = None
 ) -> tuple[dict[str, dict[str, Optional[str]]], Optional[str]]:
     """Load mapping from environment variable only.
-  Returns `(mapping, used_path)` or `({}, None)` when undefined.
-  """
+    Returns `(mapping, used_path)` or `({}, None)` when undefined.
+    """
     # ENV-only mapping loader; legacy locations disabled
     try:
         env_path = os.environ.get("PYCOMPILER_MAPPING")
@@ -198,9 +198,9 @@ def _load_mapping(
 
 def _parse_requirements(requirements_path: str) -> set[str]:
     """Extract package names from requirements.txt, handling URLs, VCS, and extras.
-  - Supports lines like 'package==1.2', 'package[extra]', 'name @ https://...', 'git+https://...#egg=name'
-  - Ignores comments, markers, and includes (-r ...)
-  """
+    - Supports lines like 'package==1.2', 'package[extra]', 'name @ https://...', 'git+https://...#egg=name'
+    - Ignores comments, markers, and includes (-r ...)
+    """
     found: set[str] = set()
     if not os.path.isfile(requirements_path):
         return found
@@ -259,10 +259,10 @@ def _parse_requirements(requirements_path: str) -> set[str]:
 
 def _scan_imports(py_files: list[str], workspace_dir: str) -> set[str]:
     """Analyze .py files and return imported top-level module names.
- - Ignore venv/, __pycache__/ et folders cachés
- - Ignore files trop volumineux (>1.5 Mo) pour robustesse
- - Tolérant aux erreurs d'encodage/syntaxe
- """
+    - Ignore venv/, __pycache__/ et folders cachés
+    - Ignore files trop volumineux (>1.5 Mo) pour robustesse
+    - Tolérant aux erreurs d'encodage/syntaxe
+    """
     found: set[str] = set()
     # Exclure venv interne
     venv_dir = os.path.abspath(os.path.join(workspace_dir, "venv"))
@@ -312,9 +312,9 @@ def _match_modules_to_mapping(
     modules: set[str], mapping: dict[str, dict[str, Optional[str]]]
 ) -> tuple[dict[str, dict[str, Optional[str]]], dict[str, str]]:
     """Return two dictionaries:
-  - `matched`: `{package_key_in_mapping: mapping_entry}`
-  - `package_to_import_name`: `{package_key_in_mapping: import_name}`
-  """
+    - `matched`: `{package_key_in_mapping: mapping_entry}`
+    - `package_to_import_name`: `{package_key_in_mapping: import_name}`
+    """
     # Build lookup index insensible à la casse et aux tirets
     index = {_norm(name): name for name in mapping.keys()}
 
@@ -395,17 +395,17 @@ def _builder(
 
 def register_auto_builder(engine_id: str, builder) -> None:
     """Register a builder function for a given engine_id.
-  The builder signature must be (matched: dict, pkg_to_import: dict) -> List[str].
-  """
+    The builder signature must be (matched: dict, pkg_to_import: dict) -> List[str].
+    """
     if not engine_id or not callable(builder):
         return
     _ENGINE_BUILDERS[engine_id] = builder
 
 
 def _maybe_load_plugin_auto_builder(engine_id: str) -> None:
     """Optionally load a plugin-provided auto builder for engine_id.
-  Tries to import '<engine_id>.auto_plugins' without failing app logic.
-  """
+    Tries to import '<engine_id>.auto_plugins' without failing app logic.
+    """
     try:
         mod = importlib.import_module(f"{engine_id}.auto_plugins")
         auto_builder = getattr(mod, "AUTO_BUILDER", None)
@@ -580,14 +580,14 @@ def compute_for_all(
     self, engine_ids: Optional[list[str]] = None
 ) -> dict[str, list[str]]:
     """
- Compute auto arguments for all engines (plug-and-play).
- - engine_ids: liste optionnelle d'identifiants de engines à traiter. Si None,
-  on detect automatiquement:
-  * engines enregistrés dans _ENGINE_BUILDERS
-  * engines avec un mapping engine_plugins/<engine_id>/mapping.json
-  * engines embarqués utils/engines/<engine_id>/mapping.json
- Return un dict: { engine_id: List[str] }.
- """
+    Compute auto arguments for all engines (plug-and-play).
+    - engine_ids: liste optionnelle d'identifiants de engines à traiter. Si None,
+     on detect automatiquement:
+     * engines enregistrés dans _ENGINE_BUILDERS
+     * engines avec un mapping engine_plugins/<engine_id>/mapping.json
+     * engines embarqués utils/engines/<engine_id>/mapping.json
+    Return un dict: { engine_id: List[str] }.
+    """
     # Construire la liste ordonnée des moteurs à traiter
     ordered: list[str] = []
     if engine_ids:
@@ -646,11 +646,11 @@ def _load_engine_package_mapping(
     engine_id: str,
 ) -> tuple[dict[str, dict[str, Optional[str]]], Optional[str]]:
     """Load engine-specific mapping from multiple locations with priorities:
-  1) `mapping.json` embedded in imported engine package (`engine_id`)
-  2) `ENGINES/<engine_id>/mapping.json` from project files
-  3) Optional path from `PYCOMPILER_MAPPING` environment variable (merged)
-  Returns `(combined_mapping, primary_used_path)`.
-  """
+    1) `mapping.json` embedded in imported engine package (`engine_id`)
+    2) `ENGINES/<engine_id>/mapping.json` from project files
+    3) Optional path from `PYCOMPILER_MAPPING` environment variable (merged)
+    Returns `(combined_mapping, primary_used_path)`.
+    """
     combined: dict[str, dict[str, Optional[str]]] = {}
     used: Optional[str] = None