oscura 0.5.1__py3-none-any.whl → 0.7.0__py3-none-any.whl

oscura/core/memory_monitor.py

@@ -24,7 +24,7 @@ from contextlib import contextmanager
 from dataclasses import dataclass
 from typing import TYPE_CHECKING, Any
 
-from oscura.config.memory import get_memory_config
+from oscura.core.config.memory import get_memory_config
 from oscura.utils.memory import get_available_memory, get_max_memory
 
 if TYPE_CHECKING:
@@ -97,7 +97,7 @@ class MemoryMonitor:
         if max_memory is None:
             self.max_memory = get_max_memory()
         elif isinstance(max_memory, str):
-            from oscura.config.memory import _parse_memory_string
+            from oscura.core.config.memory import _parse_memory_string
 
             self.max_memory = _parse_memory_string(max_memory)
         else:

oscura/core/memory_progress.py

@@ -131,7 +131,7 @@ class MemoryLogger:
         # Initialize CSV writer if needed
         if self.format == "csv":
             self._csv_writer = csv.DictWriter(
-                self._file_handle,  # type: ignore[arg-type]
+                self._file_handle,
                 fieldnames=[
                     "timestamp",
                     "operation",
@@ -144,9 +144,9 @@ class MemoryLogger:
                     "message",
                 ],
             )
-            self._csv_writer.writeheader()  # type: ignore[attr-defined]
+            self._csv_writer.writeheader()
             if self.auto_flush:
-                self._file_handle.flush()  # type: ignore[attr-defined]
+                self._file_handle.flush()
 
         return self
 
@@ -155,7 +155,7 @@ class MemoryLogger:
         # Note: exc_val and exc_tb intentionally unused but required for Python 3.11+ compatibility
         # Write summary for JSON format
         if self.format == "json" and self._file_handle:
-            summary = {  # type: ignore[unreachable]
+            summary = {
                 "entries": [asdict(entry) for entry in self._entries],
                 "summary": self._get_summary_dict(),
             }
@@ -163,7 +163,7 @@ class MemoryLogger:
 
         # Close file
         if self._file_handle:
-            self._file_handle.close()  # type: ignore[unreachable]
+            self._file_handle.close()
             self._file_handle = None
 
     def log_operation(
@@ -213,8 +213,8 @@ class MemoryLogger:
         self._entries.append(entry)
 
         # Write to file
-        if self._file_handle and self.format == "csv":  # type: ignore[unreachable]
-            self._csv_writer.writerow(asdict(entry))  # type: ignore[unreachable]
+        if self._file_handle and self.format == "csv":
+            self._csv_writer.writerow(asdict(entry))
             if self.auto_flush:
                 self._file_handle.flush()
 

oscura/core/memory_warnings.py

@@ -20,7 +20,7 @@ import warnings
 from enum import Enum
 from typing import TYPE_CHECKING
 
-from oscura.config.memory import get_memory_config
+from oscura.core.config.memory import get_memory_config
 from oscura.utils.memory import get_available_memory, get_memory_pressure
 
 if TYPE_CHECKING:

oscura/core/numba_backend.py

@@ -43,11 +43,11 @@ import numpy as np
 
 # Try to import Numba
 try:
-    from numba import guvectorize as _numba_guvectorize  # type: ignore[import-not-found]
-    from numba import jit as _numba_jit  # type: ignore[import-not-found]
-    from numba import njit as _numba_njit  # type: ignore[import-not-found]
-    from numba import prange as _numba_prange  # type: ignore[import-not-found]
-    from numba import vectorize as _numba_vectorize  # type: ignore[import-not-found]
+    from numba import guvectorize as _numba_guvectorize
+    from numba import jit as _numba_jit
+    from numba import njit as _numba_njit
+    from numba import prange as _numba_prange
+    from numba import vectorize as _numba_vectorize
 
     HAS_NUMBA = True
 except ImportError:
@@ -92,7 +92,7 @@ else:
         # Handle both @njit and @njit() syntax
         if len(args) == 1 and callable(args[0]) and not kwargs:
             return decorator(args[0])  # type: ignore[no-any-return]
-        return decorator  # type: ignore[no-any-return]
+        return decorator
 
     def prange(*args: Any, **kwargs: Any) -> range:
         """Fallback to regular range when Numba is not available.
@@ -122,7 +122,7 @@ else:
 
         if len(args) == 1 and callable(args[0]):
             return decorator(args[0])  # type: ignore[no-any-return]
-        return decorator  # type: ignore[no-any-return]
+        return decorator
 
     def guvectorize(*args: Any, **kwargs: Any) -> Callable[[F], F]:
         """No-op decorator when Numba is not available.
@@ -140,7 +140,7 @@ else:
 
         if len(args) == 1 and callable(args[0]):
             return decorator(args[0])  # type: ignore[no-any-return]
-        return decorator  # type: ignore[no-any-return]
+        return decorator
 
     def jit(*args: Any, **kwargs: Any) -> Callable[[F], F]:
         """No-op decorator when Numba is not available.
@@ -162,7 +162,7 @@ else:
 
         if len(args) == 1 and callable(args[0]) and not kwargs:
             return decorator(args[0])  # type: ignore[no-any-return]
-        return decorator  # type: ignore[no-any-return]
+        return decorator
 
 
 def get_optimal_numba_config(
@@ -202,7 +202,7 @@ def get_optimal_numba_config(
 # Example Numba-optimized functions for common operations
 
 
-@njit(cache=True)  # type: ignore[misc,untyped-decorator]
+@njit(cache=True)  # type: ignore[untyped-decorator]  # Numba JIT decorator
 def find_crossings_numba(
     data: np.ndarray,  # type: ignore[type-arg]
     threshold: float,
@@ -233,7 +233,7 @@ def find_crossings_numba(
     return np.array(crossings, dtype=np.int64)
 
 
-@njit(parallel=True, cache=True)  # type: ignore[misc,untyped-decorator]
+@njit(parallel=True, cache=True)  # type: ignore[untyped-decorator]  # Numba JIT decorator
 def moving_average_numba(
     data: np.ndarray,  # type: ignore[type-arg]
     window_size: int,
@@ -259,7 +259,7 @@ def moving_average_numba(
     return result
 
 
-@njit(cache=True)  # type: ignore[misc,untyped-decorator]
+@njit(cache=True)  # type: ignore[untyped-decorator]  # Numba JIT decorator
 def argrelextrema_numba(
     data: np.ndarray,  # type: ignore[type-arg]
     comparator: int,
@@ -297,7 +297,7 @@ def argrelextrema_numba(
     return np.array(extrema, dtype=np.int64)
 
 
-@njit(cache=True)  # type: ignore[misc,untyped-decorator]
+@njit(cache=True)  # type: ignore[untyped-decorator]  # Numba JIT decorator
 def interpolate_linear_numba(
     x: np.ndarray,  # type: ignore[type-arg]
     y: np.ndarray,  # type: ignore[type-arg]

oscura/{plugins → core/plugins}/__init__.py

@@ -5,18 +5,18 @@ for extending Oscura functionality.
 
 
 Example:
-    >>> from oscura.plugins import discover_plugins, get_plugin
+    >>> from oscura.core.plugins import discover_plugins, get_plugin
     >>> plugins = discover_plugins()
     >>> for plugin in plugins:
     ...     print(f"{plugin.name} v{plugin.version}")
 """
 
-from oscura.plugins.base import (
+from oscura.core.plugins.base import (
     PluginBase,
     PluginCapability,
     PluginMetadata,
 )
-from oscura.plugins.cli import (
+from oscura.core.plugins.cli import (
     PluginInstaller,
     cli_disable_plugin,
     cli_enable_plugin,
@@ -25,12 +25,12 @@ from oscura.plugins.cli import (
     cli_plugin_info,
     cli_validate_plugin,
 )
-from oscura.plugins.discovery import (
+from oscura.core.plugins.discovery import (
     discover_plugins,
     get_plugin_paths,
     scan_directory,
 )
-from oscura.plugins.isolation import (
+from oscura.core.plugins.isolation import (
     IsolationManager,
     Permission,
     PermissionSet,
@@ -38,7 +38,7 @@ from oscura.plugins.isolation import (
     ResourceLimits,
     get_isolation_manager,
 )
-from oscura.plugins.lifecycle import (
+from oscura.core.plugins.lifecycle import (
     DependencyGraph,
     DependencyInfo,
     PluginHandle,
@@ -48,12 +48,12 @@ from oscura.plugins.lifecycle import (
     get_lifecycle_manager,
     set_plugin_directories,
 )
-from oscura.plugins.manager import (
+from oscura.core.plugins.manager import (
     PluginManager,
     get_plugin_manager,
     reset_plugin_manager,
 )
-from oscura.plugins.registry import (
+from oscura.core.plugins.registry import (
     PluginRegistry,
     get_plugin,
     get_plugin_registry,
@@ -61,7 +61,7 @@ from oscura.plugins.registry import (
     list_plugins,
     register_plugin,
 )
-from oscura.plugins.versioning import (
+from oscura.core.plugins.versioning import (
     Migration,
     MigrationManager,
     VersionCompatibilityLayer,

oscura/{plugins → core/plugins}/base.py

@@ -112,7 +112,7 @@ class PluginMetadata:
             return False
 
 
-class PluginBase(ABC):  # noqa: B024
+class PluginBase(ABC):
     """Base class for all Oscura plugins.
 
     Subclass this to create a plugin. Define class attributes for
@@ -143,8 +143,8 @@ class PluginBase(ABC):  # noqa: B024
     description: str = ""
     homepage: str = ""
     license: str = ""
-    capabilities: list[PluginCapability] = []  # noqa: RUF012
-    requires_plugins: list[tuple[str, str]] = []  # (name, version_spec)  # noqa: RUF012
+    capabilities: list[PluginCapability] = []
+    requires_plugins: list[tuple[str, str]] = []  # (name, version_spec)
 
     def __init__(self) -> None:
         """Initialize plugin instance."""
@@ -174,7 +174,7 @@ class PluginBase(ABC):  # noqa: B024
             )
         return self._metadata
 
-    def on_load(self) -> None:  # noqa: B027
+    def on_load(self) -> None:
         """Called when plugin is loaded.
 
         Override to register capabilities, initialize resources, etc.
@@ -196,7 +196,7 @@ class PluginBase(ABC):  # noqa: B024
         """
         self._config = config
 
-    def on_enable(self) -> None:  # noqa: B027
+    def on_enable(self) -> None:
         """Called when plugin is enabled.
 
         Override to activate plugin functionality, start services, etc.
@@ -205,7 +205,7 @@ class PluginBase(ABC):  # noqa: B024
             PLUG-002: Plugin Registration - lifecycle hooks
         """
 
-    def on_disable(self) -> None:  # noqa: B027
+    def on_disable(self) -> None:
         """Called when plugin is disabled.
 
         Override to pause plugin functionality, stop services, etc.
@@ -214,7 +214,7 @@ class PluginBase(ABC):  # noqa: B024
             PLUG-002: Plugin Registration - lifecycle hooks
         """
 
-    def on_unload(self) -> None:  # noqa: B027
+    def on_unload(self) -> None:
         """Called when plugin is unloaded.
 
         Override to clean up resources.

oscura/{plugins → core/plugins}/cli.py

@@ -13,9 +13,9 @@ import tempfile
 from pathlib import Path
 from urllib.parse import urlparse
 
-from oscura.plugins.discovery import discover_plugins, get_plugin_paths
-from oscura.plugins.lifecycle import get_lifecycle_manager
-from oscura.plugins.registry import get_plugin_registry
+from oscura.core.plugins.discovery import discover_plugins, get_plugin_paths
+from oscura.core.plugins.lifecycle import get_lifecycle_manager
+from oscura.core.plugins.registry import get_plugin_registry
 
 logger = logging.getLogger(__name__)
 

oscura/{plugins → core/plugins}/discovery.py

@@ -5,7 +5,7 @@ and Python entry points.
 
 
 Example:
-    >>> from oscura.plugins.discovery import discover_plugins
+    >>> from oscura.core.plugins.discovery import discover_plugins
     >>> plugins = discover_plugins()
     >>> for plugin in plugins:
     ...     print(f"Found: {plugin.name} v{plugin.version}")
@@ -20,9 +20,9 @@ import os
 import sys
 from dataclasses import dataclass
 from pathlib import Path
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Any
 
-from oscura.plugins.base import PluginBase, PluginMetadata
+from oscura.core.plugins.base import PluginBase, PluginMetadata
 
 if TYPE_CHECKING:
     from collections.abc import Iterator
@@ -256,47 +256,11 @@ def _load_plugin_from_yaml(yaml_path: Path) -> DiscoveredPlugin | None:
         return None
 
     try:
-        with open(yaml_path, encoding="utf-8") as f:
-            data = yaml.safe_load(f)
-
+        data = _read_yaml_file(yaml_path)
         if not isinstance(data, dict):
             return None
 
-        # Extract metadata
-        metadata = PluginMetadata(
-            name=data.get("name", yaml_path.parent.name),
-            version=data.get("version", "0.0.0"),
-            api_version=data.get("api_version", "1.0.0"),
-            author=data.get("author", ""),
-            description=data.get("description", ""),
-            homepage=data.get("homepage", ""),
-            license=data.get("license", ""),
-            path=yaml_path.parent,
-            enabled=data.get("enabled", True),
-        )
-
-        # Parse dependencies
-        if "dependencies" in data:
-            deps = data["dependencies"]
-            if isinstance(deps, list):
-                for dep in deps:
-                    if isinstance(dep, dict):
-                        if "plugin" in dep:
-                            metadata.dependencies[dep["plugin"]] = dep.get("version", "*")
-                        elif "package" in dep:
-                            metadata.dependencies[dep["package"]] = dep.get("version", "*")
-
-        # Parse provides
-        if "provides" in data:
-            provides = data["provides"]
-            if isinstance(provides, list):
-                for item in provides:
-                    if isinstance(item, dict):
-                        for key, value in item.items():
-                            if key not in metadata.provides:
-                                metadata.provides[key] = []
-                            metadata.provides[key].append(value)
-
+        metadata = _build_plugin_metadata(yaml_path, data)
         compatible = metadata.is_compatible_with(OSCURA_API_VERSION)
 
         return DiscoveredPlugin(
@@ -306,16 +270,96 @@ def _load_plugin_from_yaml(yaml_path: Path) -> DiscoveredPlugin | None:
         )
 
     except Exception as e:
-        return DiscoveredPlugin(
-            metadata=PluginMetadata(
-                name=yaml_path.parent.name,
-                version="0.0.0",
-                path=yaml_path.parent,
-            ),
-            path=yaml_path.parent,
-            compatible=False,
-            load_error=str(e),
-        )
+        return _create_failed_plugin(yaml_path.parent, str(e))
+
+
+def _read_yaml_file(yaml_path: Path) -> Any:
+    """Read and parse YAML file.
+
+    Args:
+        yaml_path: Path to YAML file.
+
+    Returns:
+        Parsed YAML data.
+    """
+    with open(yaml_path, encoding="utf-8") as f:
+        return yaml.safe_load(f)
+
+
+def _build_plugin_metadata(yaml_path: Path, data: dict[str, Any]) -> PluginMetadata:
+    """Build plugin metadata from YAML data.
+
+    Args:
+        yaml_path: Path to plugin.yaml file.
+        data: Parsed YAML data.
+
+    Returns:
+        PluginMetadata instance.
+    """
+    metadata = PluginMetadata(
+        name=data.get("name", yaml_path.parent.name),
+        version=data.get("version", "0.0.0"),
+        api_version=data.get("api_version", "1.0.0"),
+        author=data.get("author", ""),
+        description=data.get("description", ""),
+        homepage=data.get("homepage", ""),
+        license=data.get("license", ""),
+        path=yaml_path.parent,
+        enabled=data.get("enabled", True),
+    )
+
+    _parse_plugin_dependencies(metadata, data)
+    _parse_plugin_provides(metadata, data)
+
+    return metadata
+
+
+def _parse_plugin_dependencies(metadata: PluginMetadata, data: dict[str, Any]) -> None:
+    """Parse plugin dependencies from YAML data.
+
+    Args:
+        metadata: PluginMetadata to update.
+        data: Parsed YAML data.
+    """
+    if "dependencies" not in data:
+        return
+
+    deps = data["dependencies"]
+    if not isinstance(deps, list):
+        return
+
+    for dep in deps:
+        if not isinstance(dep, dict):
+            continue
+
+        if "plugin" in dep:
+            metadata.dependencies[dep["plugin"]] = dep.get("version", "*")
+        elif "package" in dep:
+            metadata.dependencies[dep["package"]] = dep.get("version", "*")
+
+
+def _parse_plugin_provides(metadata: PluginMetadata, data: dict[str, Any]) -> None:
+    """Parse plugin provides from YAML data.
+
+    Args:
+        metadata: PluginMetadata to update.
+        data: Parsed YAML data.
+    """
+    if "provides" not in data:
+        return
+
+    provides = data["provides"]
+    if not isinstance(provides, list):
+        return
+
+    for item in provides:
+        if not isinstance(item, dict):
+            continue
+
+        for key, value in item.items():
+            if key not in metadata.provides:
+                metadata.provides[key] = []
+            metadata.provides[key].append(value)
 
 
 def _load_plugin_from_module(module_path: Path) -> DiscoveredPlugin | None:
@@ -328,77 +372,113 @@ def _load_plugin_from_module(module_path: Path) -> DiscoveredPlugin | None:
         DiscoveredPlugin or None if load fails.
     """
     try:
-        # Add parent to path temporarily
         parent = str(module_path.parent)
-        if parent not in sys.path:
+        added_path = parent not in sys.path
+
+        if added_path:
             sys.path.insert(0, parent)
-            added_path = True
-        else:
-            added_path = False
 
         try:
-            # Import the module
-            module_name = module_path.name
-            spec = importlib.util.spec_from_file_location(module_name, module_path / "__init__.py")
+            module = _import_plugin_module(module_path)
+            if module is None:
+                return None
 
-            if spec is None or spec.loader is None:
+            plugin_class = _find_plugin_class(module)
+            if plugin_class is None:
                 return None
 
-            module = importlib.util.module_from_spec(spec)
-            spec.loader.exec_module(module)
+            return _create_discovered_plugin(plugin_class, module_path)
 
-            # Look for Plugin class
-            plugin_class = None
+        finally:
+            if added_path:
+                sys.path.remove(parent)
 
-            # Check for explicit Plugin class
-            if hasattr(module, "Plugin"):
-                plugin_class = module.Plugin
-            elif hasattr(module, "plugin"):
-                plugin_class = module.plugin
+    except Exception as e:
+        return _create_failed_plugin(module_path, str(e))
 
-            # Check for any PluginBase subclass
-            if plugin_class is None:
-                for attr_name in dir(module):
-                    attr = getattr(module, attr_name)
-                    if (
-                        isinstance(attr, type)
-                        and issubclass(attr, PluginBase)
-                        and attr is not PluginBase
-                    ):
-                        plugin_class = attr
-                        break
 
-            if plugin_class is None:
-                return None
+def _import_plugin_module(module_path: Path) -> Any:
+    """Import plugin module from path.
 
-            # Create instance and get metadata
-            instance = plugin_class()
-            metadata = instance.metadata
-            metadata.path = module_path
+    Args:
+        module_path: Path to plugin package.
 
-            compatible = metadata.is_compatible_with(OSCURA_API_VERSION)
+    Returns:
+        Imported module or None.
+    """
+    module_name = module_path.name
+    spec = importlib.util.spec_from_file_location(module_name, module_path / "__init__.py")
 
-            return DiscoveredPlugin(
-                metadata=metadata,
-                path=module_path,
-                compatible=compatible,
-            )
+    if spec is None or spec.loader is None:
+        return None
 
-        finally:
-            if added_path:
-                sys.path.remove(parent)
+    module = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(module)
+    return module
 
-    except Exception as e:
-        return DiscoveredPlugin(
-            metadata=PluginMetadata(
-                name=module_path.name,
-                version="0.0.0",
-                path=module_path,
-            ),
-            path=module_path,
-            compatible=False,
-            load_error=str(e),
-        )
+
+def _find_plugin_class(module: Any) -> type | None:
+    """Find plugin class in module.
+
+    Args:
+        module: Imported module to search.
+
+    Returns:
+        Plugin class or None.
+    """
+    # Check explicit names first
+    if hasattr(module, "Plugin"):
+        plugin_attr = module.Plugin
+        if isinstance(plugin_attr, type):
+            return plugin_attr
+    if hasattr(module, "plugin"):
+        plugin_attr = module.plugin
+        if isinstance(plugin_attr, type):
+            return plugin_attr
+
+    # Search for PluginBase subclass
+    for attr_name in dir(module):
+        attr = getattr(module, attr_name)
+        if isinstance(attr, type) and issubclass(attr, PluginBase) and attr is not PluginBase:
+            return attr
+
+    return None
+
+
+def _create_discovered_plugin(plugin_class: type, module_path: Path) -> DiscoveredPlugin:
+    """Create DiscoveredPlugin from plugin class.
+
+    Args:
+        plugin_class: Plugin class to instantiate.
+        module_path: Path to plugin module.
+
+    Returns:
+        DiscoveredPlugin instance.
+    """
+    instance = plugin_class()
+    metadata = instance.metadata
+    metadata.path = module_path
+    compatible = metadata.is_compatible_with(OSCURA_API_VERSION)
+
+    return DiscoveredPlugin(metadata=metadata, path=module_path, compatible=compatible)
+
+
+def _create_failed_plugin(module_path: Path, error: str) -> DiscoveredPlugin:
+    """Create DiscoveredPlugin for failed load.
+
+    Args:
+        module_path: Path to plugin.
+        error: Error message.
+
+    Returns:
+        DiscoveredPlugin with error.
+    """
+    return DiscoveredPlugin(
+        metadata=PluginMetadata(name=module_path.name, version="0.0.0", path=module_path),
+        path=module_path,
+        compatible=False,
+        load_error=error,
+    )
 
 
 __all__ = [

oscura/{plugins → core/plugins}/lifecycle.py

@@ -20,7 +20,7 @@ from typing import TYPE_CHECKING, Any
 if TYPE_CHECKING:
     from collections.abc import Callable
 
-from oscura.plugins.base import PluginBase, PluginMetadata
+from oscura.core.plugins.base import PluginBase, PluginMetadata
 
 logger = logging.getLogger(__name__)