elspais 0.11.2__py3-none-any.whl → 0.43.5__py3-none-any.whl

elspais/__init__.py

@@ -19,18 +19,9 @@ except PackageNotFoundError:
 __author__ = "Anspar"
 __license__ = "MIT"
 
-from elspais.core.models import Assertion, ContentRule, ParsedRequirement, Requirement
-from elspais.core.patterns import PatternValidator
-from elspais.core.rules import RuleEngine, RuleViolation, Severity
+from elspais.utilities.patterns import PatternValidator
 
 __all__ = [
     "__version__",
-    "Assertion",
-    "ContentRule",
-    "Requirement",
-    "ParsedRequirement",
     "PatternValidator",
-    "RuleEngine",
-    "RuleViolation",
-    "Severity",
 ]

elspais/{sponsors/__init__.py → associates.py}

@@ -1,8 +1,8 @@
 """
-elspais.sponsors - Sponsor/associated repository configuration loading.
+elspais.associates - Associate repository configuration loading.
 
-Provides functions for loading sponsor configurations from YAML files
-and resolving sponsor spec directories.
+Provides functions for loading associate configurations from YAML files
+and resolving associate spec directories.
 """
 
 import re
@@ -12,16 +12,16 @@ from typing import Any, Dict, List, Optional
 
 
 @dataclass
-class Sponsor:
+class Associate:
     """
-    Represents a sponsor/associated repository configuration.
+    Represents an associate repository configuration.
 
     Attributes:
-        name: Sponsor name (e.g., "callisto")
+        name: Associate name (e.g., "callisto")
         code: Short code used in requirement IDs (e.g., "CAL")
-        enabled: Whether this sponsor is enabled for scanning
+        enabled: Whether this associate is enabled for scanning
         path: Default path relative to project root
-        spec_path: Spec directory within sponsor path (e.g., "spec")
+        spec_path: Spec directory within associate path (e.g., "spec")
         local_path: Override path for local development (from .local.yml)
     """
 
@@ -33,21 +33,34 @@ class Sponsor:
     local_path: Optional[str] = None
 
 
+# Alias for backwards compatibility
+Sponsor = Associate
+
+
 @dataclass
-class SponsorsConfig:
+class AssociatesConfig:
     """
-    Container for sponsor configuration.
+    Container for associate configuration.
 
     Attributes:
-        sponsors: List of Sponsor objects
-        config_file: Path to the sponsors config file
-        local_dir: Default base directory for sponsor repos
+        associates: List of Associate objects
+        config_file: Path to the associates config file
+        local_dir: Default base directory for associate repos
     """
 
-    sponsors: List[Sponsor] = field(default_factory=list)
+    associates: List[Associate] = field(default_factory=list)
     config_file: str = ""
     local_dir: str = "sponsor"
 
+    # Alias property for backwards compatibility
+    @property
+    def sponsors(self) -> List[Associate]:
+        return self.associates
+
+
+# Alias for backwards compatibility
+SponsorsConfig = AssociatesConfig
+
 
 def parse_yaml(content: str) -> Dict[str, Any]:
     """
@@ -156,9 +169,9 @@ def _parse_yaml_value(value: str) -> Any:
     return value
 
 
-def load_sponsors_yaml(yaml_path: Path) -> Dict[str, Any]:
+def load_associates_yaml(yaml_path: Path) -> Dict[str, Any]:
     """
-    Load sponsors configuration from a YAML file.
+    Load associates configuration from a YAML file.
 
     Handles the nested structure:
     ```yaml
@@ -172,27 +185,31 @@ def load_sponsors_yaml(yaml_path: Path) -> Dict[str, Any]:
     ```
 
     Args:
-        yaml_path: Path to the sponsors YAML file
+        yaml_path: Path to the associates YAML file
 
     Returns:
-        Dictionary with sponsor configuration
+        Dictionary with associate configuration
     """
     if not yaml_path.exists():
         return {}
 
     content = yaml_path.read_text(encoding="utf-8")
-    return _parse_sponsors_yaml(content)
+    return _parse_associates_yaml(content)
+
+
+# Alias for backwards compatibility
+load_sponsors_yaml = load_associates_yaml
 
 
-def _parse_sponsors_yaml(content: str) -> Dict[str, Any]:
+def _parse_associates_yaml(content: str) -> Dict[str, Any]:
     """
-    Parse sponsors YAML content with proper handling of nested lists.
+    Parse associates YAML content with proper handling of nested lists.
 
     Args:
         content: YAML file content
 
     Returns:
-        Parsed dictionary with sponsors configuration
+        Parsed dictionary with associates configuration
     """
     result: Dict[str, Any] = {"sponsors": {}}
     current_section = None
@@ -280,43 +297,43 @@ def _parse_sponsors_yaml(content: str) -> Dict[str, Any]:
     return result
 
 
-def load_sponsors_config(
+def load_associates_config(
     config: Dict[str, Any],
     base_path: Optional[Path] = None,
-) -> SponsorsConfig:
+) -> AssociatesConfig:
     """
-    Load sponsor configurations from config files.
+    Load associate configurations from config files.
 
-    Reads the main sponsors config file and applies local overrides.
+    Reads the main associates config file and applies local overrides.
 
     Args:
         config: Main elspais configuration dictionary
         base_path: Base path to resolve relative paths (defaults to cwd)
 
     Returns:
-        SponsorsConfig with loaded sponsors
+        AssociatesConfig with loaded associates
     """
     if base_path is None:
         base_path = Path.cwd()
 
-    sponsors_config = SponsorsConfig()
+    associates_config = AssociatesConfig()
 
-    # Get sponsors section from config
+    # Get sponsors section from config (keeping "sponsors" key for compatibility)
     sponsors_section = config.get("sponsors", {})
     config_file = sponsors_section.get("config_file", "")
-    sponsors_config.config_file = config_file
-    sponsors_config.local_dir = sponsors_section.get("local_dir", "sponsor")
+    associates_config.config_file = config_file
+    associates_config.local_dir = sponsors_section.get("local_dir", "sponsor")
 
     if not config_file:
-        return sponsors_config
+        return associates_config
 
     # Load main sponsors config
     config_path = base_path / config_file
-    main_config = load_sponsors_yaml(config_path)
+    main_config = load_associates_yaml(config_path)
 
     # Load local overrides if present
     local_config_path = config_path.with_suffix(".local.yml")
-    local_overrides = load_sponsors_yaml(local_config_path)
+    local_overrides = load_associates_yaml(local_config_path)
 
     # Parse sponsors from config
     sponsors_data = main_config.get("sponsors", {})
@@ -343,7 +360,7 @@ def load_sponsors_config(
             if isinstance(local_override, dict):
                 local_path = local_override.get("local_path")
 
-        sponsor = Sponsor(
+        associate = Associate(
             name=name,
             code=sponsor_data.get("code", ""),
             enabled=sponsor_data.get("enabled", True),
@@ -351,80 +368,109 @@ def load_sponsors_config(
             spec_path=sponsor_data.get("spec_path", "spec"),
             local_path=local_path,
         )
-        sponsors_config.sponsors.append(sponsor)
+        associates_config.associates.append(associate)
 
-    return sponsors_config
+    return associates_config
 
 
-def resolve_sponsor_spec_dir(
-    sponsor: Sponsor,
-    config: SponsorsConfig,
+# Alias for backwards compatibility
+load_sponsors_config = load_associates_config
+
+
+def resolve_associate_spec_dir(
+    associate: Associate,
+    config: AssociatesConfig,
     base_path: Optional[Path] = None,
 ) -> Optional[Path]:
     """
-    Resolve the spec directory path for a sponsor.
+    Resolve the spec directory path for an associate.
 
     Checks local_path override first, then default path.
 
     Args:
-        sponsor: Sponsor configuration
-        config: Overall sponsors configuration
+        associate: Associate configuration
+        config: Overall associates configuration
         base_path: Base path to resolve relative paths (defaults to cwd)
 
     Returns:
-        Path to sponsor spec directory, or None if not found
+        Path to associate spec directory, or None if not found
     """
     if base_path is None:
         base_path = Path.cwd()
 
-    if not sponsor.enabled:
+    if not associate.enabled:
         return None
 
     # Check local_path override first
-    if sponsor.local_path:
-        spec_dir = Path(sponsor.local_path) / sponsor.spec_path
+    if associate.local_path:
+        spec_dir = Path(associate.local_path) / associate.spec_path
         if not spec_dir.is_absolute():
             spec_dir = base_path / spec_dir
         if spec_dir.exists() and spec_dir.is_dir():
             return spec_dir
 
     # Fall back to default path
-    if sponsor.path:
-        spec_dir = base_path / sponsor.path / sponsor.spec_path
+    if associate.path:
+        spec_dir = base_path / associate.path / associate.spec_path
         if spec_dir.exists() and spec_dir.is_dir():
             return spec_dir
 
     # Try local_dir / name / spec_path
-    spec_dir = base_path / config.local_dir / sponsor.name / sponsor.spec_path
+    spec_dir = base_path / config.local_dir / associate.name / associate.spec_path
     if spec_dir.exists() and spec_dir.is_dir():
         return spec_dir
 
     return None
 
 
-def get_sponsor_spec_directories(
+# Alias for backwards compatibility
+resolve_sponsor_spec_dir = resolve_associate_spec_dir
+
+
+def get_associate_spec_directories(
     config: Dict[str, Any],
     base_path: Optional[Path] = None,
 ) -> List[Path]:
     """
-    Get all sponsor spec directories from configuration.
+    Get all associate spec directories from configuration.
 
     Args:
         config: Main elspais configuration dictionary
         base_path: Base path to resolve relative paths (defaults to cwd)
 
     Returns:
-        List of existing sponsor spec directory paths
+        List of existing associate spec directory paths
     """
     if base_path is None:
         base_path = Path.cwd()
 
-    sponsors_config = load_sponsors_config(config, base_path)
+    associates_config = load_associates_config(config, base_path)
     spec_dirs = []
 
-    for sponsor in sponsors_config.sponsors:
-        spec_dir = resolve_sponsor_spec_dir(sponsor, sponsors_config, base_path)
+    for associate in associates_config.associates:
+        spec_dir = resolve_associate_spec_dir(associate, associates_config, base_path)
         if spec_dir:
             spec_dirs.append(spec_dir)
 
     return spec_dirs
+
+
+# Alias for backwards compatibility
+get_sponsor_spec_directories = get_associate_spec_directories
+
+
+__all__ = [
+    "Associate",
+    "Sponsor",  # alias
+    "AssociatesConfig",
+    "SponsorsConfig",  # alias
+    "parse_yaml",
+    "load_associates_yaml",
+    "load_sponsors_yaml",  # alias
+    "load_associates_config",
+    "load_sponsors_config",  # alias
+    "resolve_associate_spec_dir",
+    "resolve_sponsor_spec_dir",  # alias
+    "get_associate_spec_directories",
+    "get_sponsor_spec_directories",  # alias
+]