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

oscura/{config → core/config}/settings.py

@@ -6,7 +6,7 @@ configuration options.
 
 
 Example:
-    >>> from oscura.config.settings import get_settings, Settings
+    >>> from oscura.core.config.settings import get_settings, Settings
     >>> settings = get_settings()
     >>> settings.enable_feature("advanced_analysis")
     >>> if settings.is_feature_enabled("advanced_analysis"):

oscura/{config → core/config}/thresholds.py

@@ -15,7 +15,7 @@ from pathlib import Path
 
 import yaml
 
-from oscura.config.schema import validate_against_schema
+from oscura.core.config.schema import validate_against_schema
 from oscura.core.exceptions import ConfigurationError
 
 logger = logging.getLogger(__name__)
@@ -206,129 +206,25 @@ class ThresholdRegistry:
                 # Double-check locking pattern
                 if cls._instance is None:
                     cls._instance = super().__new__(cls)
-                    cls._instance._families = {}  # type: ignore[attr-defined]
-                    cls._instance._profiles = {}  # type: ignore[attr-defined]
-                    cls._instance._session_overrides = {}  # type: ignore[attr-defined]
-                    cls._instance._state_lock = threading.Lock()  # type: ignore[attr-defined]
+                    cls._instance._families = {}
+                    cls._instance._profiles = {}
+                    cls._instance._session_overrides = {}
+                    cls._instance._state_lock = threading.Lock()
                     cls._instance._register_builtins()
         return cls._instance
 
     def _register_builtins(self) -> None:
         """Register built-in logic family definitions."""
-        builtins = [
-            # TTL
-            LogicFamily(
-                name="TTL",
-                VIH=2.0,
-                VIL=0.8,
-                VOH=2.4,
-                VOL=0.4,
-                VCC=5.0,
-                description="Standard TTL (74xx series)",
-            ),
-            # CMOS variants
-            LogicFamily(
-                name="CMOS_5V",
-                VIH=3.5,
-                VIL=1.5,
-                VOH=4.9,
-                VOL=0.1,
-                VCC=5.0,
-                description="CMOS 5V (74HCxx series)",
-            ),
-            LogicFamily(
-                name="LVTTL_3V3",
-                VIH=2.0,
-                VIL=0.8,
-                VOH=2.4,
-                VOL=0.4,
-                VCC=3.3,
-                description="Low Voltage TTL 3.3V",
-            ),
-            LogicFamily(
-                name="LVCMOS_3V3",
-                VIH=2.0,
-                VIL=0.7,
-                VOH=2.4,
-                VOL=0.4,
-                VCC=3.3,
-                description="Low Voltage CMOS 3.3V",
-            ),
-            LogicFamily(
-                name="LVCMOS_2V5",
-                VIH=1.7,
-                VIL=0.7,
-                VOH=2.0,
-                VOL=0.4,
-                VCC=2.5,
-                description="Low Voltage CMOS 2.5V",
-            ),
-            LogicFamily(
-                name="LVCMOS_1V8",
-                VIH=1.17,
-                VIL=0.63,
-                VOH=1.35,
-                VOL=0.45,
-                VCC=1.8,
-                description="Low Voltage CMOS 1.8V",
-            ),
-            LogicFamily(
-                name="LVCMOS_1V5",
-                VIH=0.975,
-                VIL=0.525,
-                VOH=1.125,
-                VOL=0.375,
-                VCC=1.5,
-                description="Low Voltage CMOS 1.5V",
-            ),
-            LogicFamily(
-                name="LVCMOS_1V2",
-                VIH=0.84,  # 0.7 * 1.2
-                VIL=0.36,  # 0.3 * 1.2
-                VOH=1.1,
-                VOL=0.1,
-                VCC=1.2,
-                description="Low Voltage CMOS 1.2V",
-            ),
-            # ECL
-            LogicFamily(
-                name="ECL",
-                VIH=-0.9,
-                VIL=-1.7,
-                VOH=-0.9,
-                VOL=-1.75,
-                VCC=-5.2,
-                description="Emitter-Coupled Logic (ECL 10K)",
-            ),
-        ]
+        builtins = _get_builtin_logic_families()
 
         for family in builtins:
-            self._families[family.name] = family  # type: ignore[attr-defined]
+            self._families[family.name] = family
 
         # Built-in profiles
-        builtin_profiles = [
-            ThresholdProfile(
-                name="strict",
-                base_family="TTL",
-                tolerance=0,
-                description="Exact specification values",
-            ),
-            ThresholdProfile(
-                name="relaxed",
-                base_family="TTL",
-                tolerance=20,
-                description="20% tolerance for real-world signals",
-            ),
-            ThresholdProfile(
-                name="auto",
-                base_family="TTL",
-                tolerance=10,
-                description="Auto-adjusted based on signal confidence",
-            ),
-        ]
+        builtin_profiles = _get_builtin_profiles()
 
         for profile in builtin_profiles:
-            self._profiles[profile.name] = profile  # type: ignore[attr-defined]
+            self._profiles[profile.name] = profile
 
     def get_family(self, name: str) -> LogicFamily:
         """Get logic family by name.
@@ -342,32 +238,56 @@ class ThresholdRegistry:
         Raises:
             KeyError: If family not found
         """
-        with self._state_lock:  # type: ignore[attr-defined]
-            # Try exact match first
-            if name in self._families:  # type: ignore[attr-defined]
-                family = self._families[name]  # type: ignore[attr-defined]
-            # Try case-insensitive match
-            elif name.upper() in self._families:  # type: ignore[attr-defined]
-                family = self._families[name.upper()]  # type: ignore[attr-defined]
-            else:
-                available = list(self._families.keys())  # type: ignore[attr-defined]
-                raise KeyError(f"Logic family '{name}' not found. Available: {available}")
-
-            # Apply session overrides
-            if self._session_overrides:  # type: ignore[attr-defined]
-                return LogicFamily(
-                    name=family.name,
-                    VIH=self._session_overrides.get("VIH", family.VIH),  # type: ignore[attr-defined]
-                    VIL=self._session_overrides.get("VIL", family.VIL),  # type: ignore[attr-defined]
-                    VOH=self._session_overrides.get("VOH", family.VOH),  # type: ignore[attr-defined]
-                    VOL=self._session_overrides.get("VOL", family.VOL),  # type: ignore[attr-defined]
-                    VCC=self._session_overrides.get("VCC", family.VCC),  # type: ignore[attr-defined]
-                    description=family.description,
-                    temperature_range=family.temperature_range,
-                    source="override",
-                )
+        with self._state_lock:
+            family = self._lookup_family(name)
+            return self._apply_overrides_if_needed(family)
+
+    def _lookup_family(self, name: str) -> LogicFamily:
+        """Look up family by name (exact or case-insensitive).
+
+        Args:
+            name: Family name to look up.
+
+        Returns:
+            Logic family definition.
+
+        Raises:
+            KeyError: If family not found.
+        """
+        # Try exact match first
+        if name in self._families:
+            return self._families[name]
+
+        # Try case-insensitive match
+        if name.upper() in self._families:
+            return self._families[name.upper()]
+
+        available = list(self._families.keys())
+        raise KeyError(f"Logic family '{name}' not found. Available: {available}")
+
+    def _apply_overrides_if_needed(self, family: LogicFamily) -> LogicFamily:
+        """Apply session overrides to family if configured.
+
+        Args:
+            family: Base family.
 
-            return family  # type: ignore[no-any-return]
+        Returns:
+            Family with overrides applied, or original if no overrides.
+        """
+        if not self._session_overrides:
+            return family
+
+        return LogicFamily(
+            name=family.name,
+            VIH=self._session_overrides.get("VIH", family.VIH),
+            VIL=self._session_overrides.get("VIL", family.VIL),
+            VOH=self._session_overrides.get("VOH", family.VOH),
+            VOL=self._session_overrides.get("VOL", family.VOL),
+            VCC=self._session_overrides.get("VCC", family.VCC),
+            description=family.description,
+            temperature_range=family.temperature_range,
+            source="override",
+        )
 
     def list_families(self) -> list[str]:
         """List all available logic families.
@@ -375,8 +295,8 @@ class ThresholdRegistry:
         Returns:
             List of family names
         """
-        with self._state_lock:  # type: ignore[attr-defined]
-            return sorted(self._families.keys())  # type: ignore[attr-defined]
+        with self._state_lock:
+            return sorted(self._families.keys())
 
     def register_family(self, family: LogicFamily, *, namespace: str = "user") -> None:
         """Register custom logic family.
@@ -390,7 +310,7 @@ class ThresholdRegistry:
             >>> registry.register_family(custom)
             >>> # Available as "user.my_custom"
         """
-        with self._state_lock:  # type: ignore[attr-defined]
+        with self._state_lock:
             # Namespace custom families
             if namespace and not family.name.startswith(f"{namespace}."):
                 name = f"{namespace}.{family.name}"
@@ -410,7 +330,7 @@ class ThresholdRegistry:
                 source=family.source,
             )
 
-            self._families[name] = family  # type: ignore[attr-defined]
+            self._families[name] = family
             logger.info(f"Registered custom logic family: {name}")
 
     def set_threshold_override(self, **kwargs: float) -> None:
@@ -428,20 +348,20 @@ class ThresholdRegistry:
             >>> registry.set_threshold_override(VIH=2.5, VIL=0.7)
         """
         valid_keys = {"VIH", "VIL", "VOH", "VOL", "VCC"}
-        with self._state_lock:  # type: ignore[attr-defined]
+        with self._state_lock:
             for key, value in kwargs.items():
                 if key not in valid_keys:
                     raise ValueError(f"Invalid threshold key: {key}. Valid: {valid_keys}")
                 if not 0.0 <= value <= 10.0:
                     raise ValueError(f"Threshold {key}={value}V out of range (0-10V)")
-                self._session_overrides[key] = value  # type: ignore[attr-defined]
+                self._session_overrides[key] = value
 
             logger.info(f"Set threshold overrides: {kwargs}")
 
     def reset_overrides(self) -> None:
         """Reset session threshold overrides."""
-        with self._state_lock:  # type: ignore[attr-defined]
-            self._session_overrides.clear()  # type: ignore[attr-defined]
+        with self._state_lock:
+            self._session_overrides.clear()
             logger.info("Reset threshold overrides")
 
     def get_profile(self, name: str) -> ThresholdProfile:
@@ -456,12 +376,12 @@ class ThresholdRegistry:
         Raises:
             KeyError: If profile not found.
         """
-        with self._state_lock:  # type: ignore[attr-defined]
-            if name not in self._profiles:  # type: ignore[attr-defined]
+        with self._state_lock:
+            if name not in self._profiles:
                 raise KeyError(
                     f"Profile '{name}' not found. Available: {list(self._profiles.keys())}"
-                )  # type: ignore[attr-defined]
-            return self._profiles[name]  # type: ignore[no-any-return, attr-defined]
+                )
+            return self._profiles[name]
 
     def apply_profile(self, name: str) -> LogicFamily:
         """Apply a threshold profile.
@@ -490,14 +410,14 @@ class ThresholdRegistry:
             >>> registry.set_threshold_override(VIH=2.5)
             >>> registry.save_profile("my_profile")
         """
-        with self._state_lock:  # type: ignore[attr-defined]
+        with self._state_lock:
             profile = ThresholdProfile(
                 name=name,
                 base_family=base_family or "TTL",
-                overrides=dict(self._session_overrides),  # type: ignore[attr-defined]
+                overrides=dict(self._session_overrides),
                 description=f"User profile {name}",
             )
-            self._profiles[name] = profile  # type: ignore[attr-defined]
+            self._profiles[name] = profile
 
             if path:
                 path = Path(path)
@@ -513,6 +433,128 @@ class ThresholdRegistry:
                 logger.info(f"Saved profile to {path}")
 
 
+def _get_builtin_logic_families() -> list[LogicFamily]:
+    """Get list of built-in logic family definitions.
+
+    Returns:
+        List of standard logic families.
+    """
+    return [
+        # TTL
+        LogicFamily(
+            name="TTL",
+            VIH=2.0,
+            VIL=0.8,
+            VOH=2.4,
+            VOL=0.4,
+            VCC=5.0,
+            description="Standard TTL (74xx series)",
+        ),
+        # CMOS variants
+        LogicFamily(
+            name="CMOS_5V",
+            VIH=3.5,
+            VIL=1.5,
+            VOH=4.9,
+            VOL=0.1,
+            VCC=5.0,
+            description="CMOS 5V (74HCxx series)",
+        ),
+        LogicFamily(
+            name="LVTTL_3V3",
+            VIH=2.0,
+            VIL=0.8,
+            VOH=2.4,
+            VOL=0.4,
+            VCC=3.3,
+            description="Low Voltage TTL 3.3V",
+        ),
+        LogicFamily(
+            name="LVCMOS_3V3",
+            VIH=2.0,
+            VIL=0.7,
+            VOH=2.4,
+            VOL=0.4,
+            VCC=3.3,
+            description="Low Voltage CMOS 3.3V",
+        ),
+        LogicFamily(
+            name="LVCMOS_2V5",
+            VIH=1.7,
+            VIL=0.7,
+            VOH=2.0,
+            VOL=0.4,
+            VCC=2.5,
+            description="Low Voltage CMOS 2.5V",
+        ),
+        LogicFamily(
+            name="LVCMOS_1V8",
+            VIH=1.17,
+            VIL=0.63,
+            VOH=1.35,
+            VOL=0.45,
+            VCC=1.8,
+            description="Low Voltage CMOS 1.8V",
+        ),
+        LogicFamily(
+            name="LVCMOS_1V5",
+            VIH=0.975,
+            VIL=0.525,
+            VOH=1.125,
+            VOL=0.375,
+            VCC=1.5,
+            description="Low Voltage CMOS 1.5V",
+        ),
+        LogicFamily(
+            name="LVCMOS_1V2",
+            VIH=0.84,  # 0.7 * 1.2
+            VIL=0.36,  # 0.3 * 1.2
+            VOH=1.1,
+            VOL=0.1,
+            VCC=1.2,
+            description="Low Voltage CMOS 1.2V",
+        ),
+        # ECL
+        LogicFamily(
+            name="ECL",
+            VIH=-0.9,
+            VIL=-1.7,
+            VOH=-0.9,
+            VOL=-1.75,
+            VCC=-5.2,
+            description="Emitter-Coupled Logic (ECL 10K)",
+        ),
+    ]
+
+
+def _get_builtin_profiles() -> list[ThresholdProfile]:
+    """Get list of built-in threshold profiles.
+
+    Returns:
+        List of standard threshold profiles.
+    """
+    return [
+        ThresholdProfile(
+            name="strict",
+            base_family="TTL",
+            tolerance=0,
+            description="Exact specification values",
+        ),
+        ThresholdProfile(
+            name="relaxed",
+            base_family="TTL",
+            tolerance=20,
+            description="20% tolerance for real-world signals",
+        ),
+        ThresholdProfile(
+            name="auto",
+            base_family="TTL",
+            tolerance=10,
+            description="Auto-adjusted based on signal confidence",
+        ),
+    ]
+
+
 def load_logic_family(path: str | Path) -> LogicFamily:
     """Load logic family from YAML/JSON file.
 

oscura/core/correlation.py

@@ -20,8 +20,8 @@ import asyncio
 import contextvars
 import functools
 import uuid
-from collections.abc import Callable
-from typing import Any, ParamSpec, TypeVar
+from collections.abc import Callable, Coroutine
+from typing import Any, ParamSpec, TypeVar, cast
 
 # Context variable for correlation ID (thread-safe and async-safe)
 _correlation_id: contextvars.ContextVar[str | None] = contextvars.ContextVar(
@@ -180,9 +180,8 @@ def with_correlation_id(
             async def async_wrapper(*args: P.args, **kwargs: P.kwargs) -> R:
                 with CorrelationContext(corr_id):
                     # func returns a Coroutine, we need to await it
-                    coro = func(*args, **kwargs)
-                    # Type assertion for mypy - we know this is a coroutine
-                    return await coro  # type: ignore[misc, no-any-return]
+                    coro = cast("Coroutine[Any, Any, R]", func(*args, **kwargs))
+                    return await coro
 
             return async_wrapper  # type: ignore[return-value]
         else:
@@ -192,7 +191,7 @@ def with_correlation_id(
                 with CorrelationContext(corr_id):
                     return func(*args, **kwargs)
 
-            return sync_wrapper  # type: ignore[return-value]
+            return sync_wrapper
 
     return decorator
 

oscura/core/cross_domain.py

@@ -78,8 +78,6 @@ class CorrelationResult:
         Returns:
             Coherence score based on agreement/conflict ratio.
         """
-        if not self.insights:
-            return 0.5
         total = self.agreements_detected + self.conflicts_detected
         if total == 0:
             return 0.5

oscura/core/debug.py

@@ -5,11 +5,11 @@ verbosity levels for troubleshooting and diagnostics.
 
 
 Example:
-    >>> from oscura.core.debug import enable_debug, is_debug_enabled, debug_context
+    >>> from oscura.core.debug import enable_debug, is_debug_enabled, DebugContext
     >>> enable_debug(level='verbose')
     >>> if is_debug_enabled():
     ...     logger.debug("Extra diagnostic information")
-    >>> with debug_context(level='trace'):
+    >>> with DebugContext(level='trace'):
     ...     # Temporarily increase verbosity
     ...     analyze_complex_signal()
 
@@ -157,7 +157,7 @@ def get_debug_level() -> DebugLevel:
     return DebugLevel(_debug_level.get())
 
 
-class debug_context:
+class DebugContext:
     """Context manager for temporary debug level changes.
 
     Temporarily sets a debug level for the duration of a code block,
@@ -168,7 +168,7 @@ class debug_context:
 
     Example:
         >>> # Normal debug level
-        >>> with debug_context(level='trace'):
+        >>> with DebugContext(level='trace'):
         ...     # Temporarily enable trace-level debugging
         ...     analyze_signal(complex_data)
         >>> # Back to normal debug level
@@ -190,7 +190,7 @@ class debug_context:
         self.token: contextvars.Token | None = None  # type: ignore[type-arg]
         self.previous_log_level: str | None = None
 
-    def __enter__(self) -> debug_context:
+    def __enter__(self) -> DebugContext:
         """Enter the debug context and set new level."""
         # Save current debug level
         self.token = _debug_level.set(self.level)
@@ -226,6 +226,10 @@ class debug_context:
             set_log_level(self.previous_log_level)
 
 
+# Backward compatibility alias (deprecated, use DebugContext)
+debug_context = DebugContext
+
+
 def should_log_debug(min_level: DebugLevel = DebugLevel.NORMAL) -> bool:
     """Check if debug logging should occur at specified level.