Further cleanup

Author: elopez

solc_select/infrastructure/__init__.py

@@ -1,6 +1 @@
-"""
-Infrastructure layer for solc-select.
-
-This package contains low-level infrastructure concerns like
-filesystem operations and HTTP client configuration.
-"""
+"""Infrastructure layer for solc-select."""

solc_select/infrastructure/filesystem.py

@@ -1,9 +1,4 @@
-"""
-Filesystem operations for solc-select.
-
-This module handles file system operations including version storage,
-configuration management, and directory operations.
-"""
+"""Filesystem operations for solc-select."""
 
 import os
 import shutil
@@ -22,80 +17,47 @@ def __init__(self) -> None:
         self._ensure_directories()
 
     def _ensure_directories(self) -> None:
-        """Ensure required directories exist."""
         self.artifacts_dir.mkdir(parents=True, exist_ok=True)
         self.config_dir.mkdir(parents=True, exist_ok=True)
 
     def get_current_version(self) -> SolcVersion | None:
-        """Get the currently selected version.
-
-        Returns:
-            Currently selected version or None if not set
-        """
-        # Check environment variable first
+        """Get the currently selected version."""
         env_version = os.environ.get("SOLC_VERSION")
         if env_version:
             try:
                 return SolcVersion.parse(env_version)
             except ValueError:
                 return None
 
-        # Check global version file
         global_version_file = self.config_dir / "global-version"
         if global_version_file.exists():
             try:
                 with open(global_version_file, encoding="utf-8") as f:
-                    version_str = f.read().strip()
-                    return SolcVersion.parse(version_str)
+                    return SolcVersion.parse(f.read().strip())
             except (OSError, ValueError):
                 return None
 
         return None
 
     def set_global_version(self, version: SolcVersion) -> None:
-        """Set the global version.
-
-        Args:
-            version: Version to set as global
-        """
+        """Set the global version."""
         global_version_file = self.config_dir / "global-version"
         with open(global_version_file, "w", encoding="utf-8") as f:
             f.write(str(version))
 
     def get_version_source(self) -> str:
-        """Get the source of the current version setting.
-
-        Returns:
-            Source description (environment variable or file path)
-        """
+        """Get the source of the current version setting."""
         if os.environ.get("SOLC_VERSION"):
             return "SOLC_VERSION"
-
-        global_version_file = self.config_dir / "global-version"
-        return global_version_file.as_posix()
+        return (self.config_dir / "global-version").as_posix()
 
     def get_artifact_directory(self, version: SolcVersion) -> Path:
-        """Get the directory for a version's artifacts.
-
-        Args:
-            version: Version to get directory for
-
-        Returns:
-            Path to the artifact directory
-        """
+        """Get the directory for a version's artifacts."""
         return self.artifacts_dir / f"solc-{version}"
 
     def get_binary_path(self, version: SolcVersion) -> Path:
-        """Get the path to a version's binary.
-
-        Args:
-            version: Version to get binary path for
-
-        Returns:
-            Path to the binary executable
-        """
-        artifact_dir = self.get_artifact_directory(version)
-        return artifact_dir / f"solc-{version}"
+        """Get the path to a version's binary."""
+        return self.get_artifact_directory(version) / f"solc-{version}"
 
     def cleanup_artifacts_directory(self) -> None:
         """Remove the entire artifacts directory for upgrades."""
@@ -104,24 +66,12 @@ def cleanup_artifacts_directory(self) -> None:
             self.artifacts_dir.mkdir(parents=True, exist_ok=True)
 
     def is_legacy_installation(self, version: SolcVersion) -> bool:
-        """Check if a version uses the old installation format.
-
-        Args:
-            version: Version to check
-
-        Returns:
-            True if using legacy format, False otherwise
-        """
-        # Legacy format: artifacts/solc-{version} (file instead of directory)
+        """Check if a version uses the old installation format (file instead of directory)."""
         legacy_path = self.artifacts_dir / f"solc-{version}"
         return legacy_path.exists() and legacy_path.is_file()
 
     def get_installed_versions(self) -> list[SolcVersion]:
-        """Get list of installed versions by scanning artifacts directory.
-
-        Returns:
-            List of installed SolcVersion objects sorted by version
-        """
+        """Get list of installed versions sorted by version number."""
         if not self.artifacts_dir.exists():
             return []
 
@@ -134,33 +84,17 @@ def get_installed_versions(self) -> list[SolcVersion]:
                     if self.is_installed(version):
                         installed.append(version)
                 except ValueError:
-                    # Skip invalid version directories
                     continue
 
         installed.sort()
         return installed
 
     def is_installed(self, version: SolcVersion) -> bool:
-        """Check if a version is installed.
-
-        Args:
-            version: Version to check
-
-        Returns:
-            True if installed and binary exists, False otherwise
-        """
-        binary_path = self.get_binary_path(version)
-        return binary_path.exists()
+        """Check if a version is installed."""
+        return self.get_binary_path(version).exists()
 
     def ensure_artifact_directory(self, version: SolcVersion) -> Path:
-        """Ensure artifact directory exists for a version.
-
-        Args:
-            version: Version to create directory for
-
-        Returns:
-            Path to the artifact directory
-        """
+        """Ensure artifact directory exists for a version."""
         artifact_dir = self.get_artifact_directory(version)
         artifact_dir.mkdir(parents=True, exist_ok=True)
         return artifact_dir

solc_select/models/__init__.py

@@ -1,5 +1 @@
-"""
-Domain models for solc-select.
-
-This package contains the core business entities and value objects organized by concern.
-"""
+"""Domain models for solc-select."""

solc_select/models/artifacts.py

@@ -17,7 +17,7 @@ class SolcArtifactOnDisk:
     version: SolcVersion
     platform: Platform
     file_path: Path
-    emulation: EmulationCapability | None = None  # Emulation info if not native
+    emulation: EmulationCapability | None = None
 
 
 @dataclass(kw_only=True)
@@ -29,16 +29,14 @@ class SolcArtifact(SolcArtifactOnDisk):
     checksum_keccak256: str | None
 
     def __post_init__(self) -> None:
-        """Validate artifact properties."""
         if not self.download_url:
             raise ValueError("Download URL cannot be empty")
         if not self.checksum_sha256:
             raise ValueError("SHA256 checksum cannot be empty")
+        # Normalize by removing 0x prefix
         if self.checksum_sha256.startswith("0x"):
-            # Normalize by removing 0x prefix
             object.__setattr__(self, "checksum_sha256", self.checksum_sha256[2:])
         if self.checksum_keccak256 and self.checksum_keccak256.startswith("0x"):
-            # Normalize by removing 0x prefix
             object.__setattr__(self, "checksum_keccak256", self.checksum_keccak256[2:])
 
     @property

solc_select/models/platforms.py

@@ -16,44 +16,29 @@ class Platform:
     architecture: str  # 'amd64', 'arm64'
 
     def __post_init__(self) -> None:
-        """Validate platform components."""
         valid_os = {"linux", "darwin", "windows"}
         valid_arch = {"amd64", "arm64"}
-
         if self.os_type not in valid_os:
             raise ValueError(f"Invalid OS type: {self.os_type}")
         if self.architecture not in valid_arch:
             raise ValueError(f"Invalid architecture: {self.architecture}")
 
     def get_capability(self) -> PlatformCapability:
-        """Get the capability declaration for this platform.
-
-        Returns:
-            PlatformCapability for this platform (default if not registered)
-        """
-        # Import at runtime to avoid circular dependency
+        """Get the capability declaration for this platform."""
         from ..platform_capabilities import CAPABILITY_REGISTRY
 
         key = f"{self.os_type}-{self.architecture}"
         return CAPABILITY_REGISTRY.get(key, self._create_default_capability())
 
     def _create_default_capability(self) -> PlatformCapability:
-        """Create default capability (native-only, no emulation).
-
-        Returns:
-            PlatformCapability with only native support
-        """
+        """Create default capability (native-only, no emulation)."""
         platform_id = PlatformIdentifier(self.os_type, self.architecture)
         return PlatformCapability(
             host_platform=platform_id,
             native_support=platform_id,
             emulation_capabilities=[],
         )
 
-    # ========================================
-    # CORE PLATFORM DETECTION
-    # ========================================
-
     @classmethod
     def current(cls) -> "Platform":
         """Get the current system platform."""
@@ -66,7 +51,6 @@ def current(cls) -> "Platform":
         os_type = os_mapping.get(sys.platform)
         if os_type is None:
             raise ValueError(f"Unsupported platform: {sys.platform}")
-
         return cls(os_type=os_type, architecture=cls._get_arch())
 
     @staticmethod
@@ -83,7 +67,6 @@ def _get_arch() -> str:
 
     def get_soliditylang_key(self) -> str:
         """Get the platform key used by binaries.soliditylang.org."""
-        # soliditylang.org uses macosx-amd64 for both Intel and ARM (with Rosetta and universal binaries)
         platform_keys = {
             ("linux", "amd64"): LINUX_AMD64,
             ("linux", "arm64"): LINUX_ARM64,

solc_select/models/repositories.py

@@ -8,53 +8,25 @@
 
 @dataclass(frozen=True)
 class PlatformSupport:
-    """Declares what versions a repository provides for a specific platform.
-
-    Example: Soliditylang provides linux-amd64 binaries from version 0.4.10+
-    """
+    """Declares what versions a repository provides for a specific platform."""
 
     platform: PlatformIdentifier
     version_range: VersionRange
 
     def supports(self, version: SolcVersion, target_platform: PlatformIdentifier) -> bool:
-        """Check if this support matches version + platform.
-
-        Args:
-            version: Version to check
-            target_platform: Platform to check
-
-        Returns:
-            True if this support provides the version for the platform
-        """
+        """Check if this support matches version + platform."""
         return self.platform == target_platform and self.version_range.contains(version)
 
 
 @dataclass
 class RepositoryManifest:
-    """Declarative manifest of what a repository provides.
-
-    Example:
-        SOLIDITYLANG_MANIFEST = RepositoryManifest(
-            repository_id="soliditylang",
-            base_url="https://binaries.soliditylang.org",
-            platform_supports=[...],
-            priority=100,
-        )
-    """
+    """Declarative manifest of what a repository provides."""
 
     repository_id: str  # 'soliditylang', 'crytic', 'alloy'
     base_url: str
     platform_supports: list[PlatformSupport]
     priority: int = 50  # Higher = checked first (100=primary, 50=fallback, 10=legacy)
 
     def supports_version(self, version: SolcVersion, platform: PlatformIdentifier) -> bool:
-        """Check if this repository can provide version for platform.
-
-        Args:
-            version: Version to check
-            platform: Platform to check
-
-        Returns:
-            True if repository provides this version/platform combo
-        """
+        """Check if this repository can provide version for platform."""
         return any(ps.supports(version, platform) for ps in self.platform_supports)