oscura 0.5.0__py3-none-any.whl → 0.6.0__py3-none-any.whl

oscura/{extensibility → core/extensibility}/validation.py

@@ -6,7 +6,7 @@ security checks.
 
 
 Example:
-    >>> from oscura.extensibility.validation import validate_extension
+    >>> from oscura.core.extensibility.validation import validate_extension
     >>> from pathlib import Path
     >>>
     >>> # Validate a plugin directory

oscura/core/gpu_backend.py

@@ -445,7 +445,7 @@ class GPUBackend:
             return self._to_cpu(counts), self._to_cpu(edges)
         else:
             # CPU fallback
-            return np.histogram(data, bins=bins, range=range, density=density)  # type: ignore[no-any-return]
+            return np.histogram(data, bins=bins, range=range, density=density)
 
     def dot(
         self,
@@ -477,10 +477,12 @@ class GPUBackend:
             gpu_a = self._to_gpu(a)
             gpu_b = self._to_gpu(b)
             result = self._cp.dot(gpu_a, gpu_b)
-            return self._to_cpu(result)  # type: ignore[return-value]
+            return self._to_cpu(result)
         else:
-            # CPU fallback
-            return np.dot(a, b)  # type: ignore[return-value, no-any-return]
+            # CPU fallback - cast result to expected type
+            from typing import cast
+
+            return cast("NDArray[np.float64] | np.float64", np.dot(a, b))
 
     def matmul(
         self,
@@ -511,10 +513,12 @@ class GPUBackend:
             gpu_a = self._to_gpu(a)
             gpu_b = self._to_gpu(b)
             result = self._cp.matmul(gpu_a, gpu_b)
-            return self._to_cpu(result)  # type: ignore[return-value]
+            cpu_result = self._to_cpu(result)
+            return cpu_result
         else:
-            # CPU fallback
-            return np.matmul(a, b)  # type: ignore[return-value, no-any-return]
+            # CPU fallback - cast from Any to expected type
+            result_cpu: NDArray[np.float64] = np.matmul(a, b)
+            return result_cpu
 
 
 # Module-level singleton for convenient access

oscura/core/log_query.py

@@ -218,7 +218,34 @@ class LogQuery:
         """
         results = self._records.copy()
 
-        # Filter by timestamp range
+        # Apply all filters
+        results = self._filter_by_time(results, start_time, end_time)
+        results = self._filter_by_level(results, level)
+        results = self._filter_by_module(results, module, module_pattern)
+        results = self._filter_by_correlation(results, correlation_id)
+        results = self._filter_by_message(results, message_pattern)
+
+        # Apply pagination
+        results = self._apply_pagination(results, offset, limit)
+
+        return results
+
+    def _filter_by_time(
+        self,
+        results: list[LogRecord],
+        start_time: datetime | None,
+        end_time: datetime | None,
+    ) -> list[LogRecord]:
+        """Filter records by timestamp range.
+
+        Args:
+            results: Input records.
+            start_time: Start time filter.
+            end_time: End time filter.
+
+        Returns:
+            Filtered records.
+        """
         if start_time is not None:
             start_str = format_timestamp(start_time, format="iso8601")
             results = [r for r in results if r.timestamp >= start_str]
@@ -227,36 +254,99 @@ class LogQuery:
             end_str = format_timestamp(end_time, format="iso8601")
             results = [r for r in results if r.timestamp <= end_str]
 
-        # Filter by log level
+        return results
+
+    def _filter_by_level(self, results: list[LogRecord], level: str | None) -> list[LogRecord]:
+        """Filter records by log level.
+
+        Args:
+            results: Input records.
+            level: Level filter.
+
+        Returns:
+            Filtered records.
+        """
         if level is not None:
-            results = [r for r in results if r.level == level.upper()]
+            return [r for r in results if r.level == level.upper()]
+        return results
 
-        # Filter by module
+    def _filter_by_module(
+        self,
+        results: list[LogRecord],
+        module: str | None,
+        module_pattern: str | None,
+    ) -> list[LogRecord]:
+        """Filter records by module name.
+
+        Args:
+            results: Input records.
+            module: Exact module filter.
+            module_pattern: Module pattern filter.
+
+        Returns:
+            Filtered records.
+        """
         if module is not None:
             results = [r for r in results if r.module == module]
 
-        # Filter by module pattern
         if module_pattern is not None:
             # Convert glob pattern to regex
             pattern = module_pattern.replace(".", r"\.").replace("*", ".*")
             regex = re.compile(f"^{pattern}$")
             results = [r for r in results if regex.match(r.module)]
 
-        # Filter by correlation ID
+        return results
+
+    def _filter_by_correlation(
+        self, results: list[LogRecord], correlation_id: str | None
+    ) -> list[LogRecord]:
+        """Filter records by correlation ID.
+
+        Args:
+            results: Input records.
+            correlation_id: Correlation ID filter.
+
+        Returns:
+            Filtered records.
+        """
         if correlation_id is not None:
-            results = [r for r in results if r.correlation_id == correlation_id]
+            return [r for r in results if r.correlation_id == correlation_id]
+        return results
 
-        # Filter by message pattern
+    def _filter_by_message(
+        self, results: list[LogRecord], message_pattern: str | None
+    ) -> list[LogRecord]:
+        """Filter records by message pattern.
+
+        Args:
+            results: Input records.
+            message_pattern: Message pattern filter.
+
+        Returns:
+            Filtered records.
+        """
         if message_pattern is not None:
             regex = re.compile(message_pattern)
-            results = [r for r in results if regex.search(r.message)]
+            return [r for r in results if regex.search(r.message)]
+        return results
 
-        # Apply pagination
+    def _apply_pagination(
+        self, results: list[LogRecord], offset: int, limit: int | None
+    ) -> list[LogRecord]:
+        """Apply pagination to results.
+
+        Args:
+            results: Input records.
+            offset: Number to skip.
+            limit: Maximum to return.
+
+        Returns:
+            Paginated records.
+        """
         if offset > 0:
             results = results[offset:]
         if limit is not None:
             results = results[:limit]
-
         return results
 
     def export_logs(

oscura/core/logging.py

@@ -226,9 +226,7 @@ class CompressingTimedRotatingFileHandler(logging.handlers.TimedRotatingFileHand
         # Determine the file that just got rotated
         current_time = int(self.rolloverAt - self.interval)
         time_tuple = time.gmtime(current_time) if self.utc else time.localtime(current_time)
-        dfn = self.rotation_filename(
-            self.baseFilename + "." + self.suffix % time_tuple[:6]  # type: ignore[arg-type]
-        )
+        dfn = self.rotation_filename(self.baseFilename + "." + self.suffix % time_tuple[:6])
 
         # Handle the existing rotated file
         if Path(dfn).exists():
@@ -511,7 +509,7 @@ def configure_logging(
         LOG-002: Hierarchical Log Levels
         LOG-003: Automatic Log Rotation and Retention Policies
     """
-    global _logging_configured, _config  # noqa: PLW0602
+    global _logging_configured, _config
 
     # Update config
     _config.level = level
@@ -523,64 +521,138 @@ def configure_logging(
     root_logger.setLevel(getattr(logging, level.upper()))
 
     # Remove existing handlers and close them to prevent resource leaks
-    for handler in root_logger.handlers[:]:
-        handler.close()
-        root_logger.removeHandler(handler)
+    _cleanup_existing_handlers(root_logger)
 
     # Create formatter
     formatter = StructuredFormatter(format, timestamp_format)
 
     # Add handlers
     if handlers:
-        for name, config in handlers.items():
-            if name == "console":
-                handler = logging.StreamHandler(sys.stderr)
-                handler.setLevel(getattr(logging, config.get("level", level).upper()))
-                handler.setFormatter(formatter)
-                root_logger.addHandler(handler)
-            elif name == "file":
-                filename = config.get("filename", "oscura.log")
-                handler_level = config.get("level", "DEBUG")
-                backup_count = int(config.get("backup_count", 5))
-                compress = config.get("compress", False)
-
-                # Check if time-based rotation is requested
-                when = config.get("when")
-                if when:
-                    # Time-based rotation (LOG-003)
-                    interval = int(config.get("interval", 1))
-                    max_age = config.get("max_age")
-                    handler = CompressingTimedRotatingFileHandler(
-                        filename,
-                        when=when,
-                        interval=interval,
-                        backupCount=backup_count,
-                        compress=compress,
-                        max_age=max_age,
-                    )
-                else:
-                    # Size-based rotation
-                    max_bytes = int(config.get("max_bytes", 10_000_000))
-                    handler = CompressingRotatingFileHandler(
-                        filename,
-                        maxBytes=max_bytes,
-                        backupCount=backup_count,
-                        compress=compress,
-                    )
-
-                handler.setLevel(getattr(logging, handler_level.upper()))
-                handler.setFormatter(formatter)
-                root_logger.addHandler(handler)
+        _add_configured_handlers(root_logger, handlers, formatter, level)
     else:
-        # Default: console only
-        handler = logging.StreamHandler(sys.stderr)
-        handler.setLevel(getattr(logging, level.upper()))
-        handler.setFormatter(formatter)
-        root_logger.addHandler(handler)
+        _add_default_console_handler(root_logger, formatter, level)
 
     _logging_configured = True
 
 
+def _cleanup_existing_handlers(logger: logging.Logger) -> None:
+    """Remove and close existing handlers.
+
+    Args:
+        logger: Logger to cleanup.
+    """
+    for handler in logger.handlers[:]:
+        handler.close()
+        logger.removeHandler(handler)
+
+
+def _add_configured_handlers(
+    logger: logging.Logger,
+    handlers: dict[str, dict[str, Any]],
+    formatter: StructuredFormatter,
+    default_level: str,
+) -> None:
+    """Add configured handlers to logger.
+
+    Args:
+        logger: Logger to add handlers to.
+        handlers: Handler configuration dict.
+        formatter: Formatter to use.
+        default_level: Default log level.
+    """
+    for name, config in handlers.items():
+        if name == "console":
+            _add_console_handler(logger, config, formatter, default_level)
+        elif name == "file":
+            _add_file_handler(logger, config, formatter)
+
+
+def _add_console_handler(
+    logger: logging.Logger,
+    config: dict[str, Any],
+    formatter: StructuredFormatter,
+    default_level: str,
+) -> None:
+    """Add console handler to logger.
+
+    Args:
+        logger: Logger to add handler to.
+        config: Handler configuration.
+        formatter: Formatter to use.
+        default_level: Default log level.
+    """
+    handler = logging.StreamHandler(sys.stderr)
+    handler.setLevel(getattr(logging, config.get("level", default_level).upper()))
+    handler.setFormatter(formatter)
+    logger.addHandler(handler)
+
+
+def _add_file_handler(
+    logger: logging.Logger,
+    config: dict[str, Any],
+    formatter: StructuredFormatter,
+) -> None:
+    """Add file handler to logger with rotation support.
+
+    Args:
+        logger: Logger to add handler to.
+        config: Handler configuration.
+        formatter: Formatter to use.
+    """
+    filename = config.get("filename", "oscura.log")
+    handler_level = config.get("level", "DEBUG")
+    backup_count = int(config.get("backup_count", 5))
+    compress = config.get("compress", False)
+
+    # Check if time-based rotation is requested
+    when = config.get("when")
+    if when:
+        # Time-based rotation
+        interval = int(config.get("interval", 1))
+        max_age = config.get("max_age")
+        time_handler = CompressingTimedRotatingFileHandler(
+            filename,
+            when=when,
+            interval=interval,
+            backupCount=backup_count,
+            compress=compress,
+            max_age=max_age,
+        )
+        time_handler.setLevel(getattr(logging, handler_level.upper()))
+        time_handler.setFormatter(formatter)
+        logger.addHandler(time_handler)
+    else:
+        # Size-based rotation
+        max_bytes = int(config.get("max_bytes", 10_000_000))
+        size_handler = CompressingRotatingFileHandler(
+            filename,
+            maxBytes=max_bytes,
+            backupCount=backup_count,
+            compress=compress,
+        )
+        size_handler.setLevel(getattr(logging, handler_level.upper()))
+        size_handler.setFormatter(formatter)
+        logger.addHandler(size_handler)
+
+
+def _add_default_console_handler(
+    logger: logging.Logger,
+    formatter: StructuredFormatter,
+    level: str,
+) -> None:
+    """Add default console handler when no handlers configured.
+
+    Args:
+        logger: Logger to add handler to.
+        formatter: Formatter to use.
+        level: Log level.
+    """
+    handler = logging.StreamHandler(sys.stderr)
+    handler.setLevel(getattr(logging, level.upper()))
+    handler.setFormatter(formatter)
+    logger.addHandler(handler)
+
+
 def get_logger(name: str) -> logging.Logger:
     """Get a logger with the specified name.
 
@@ -675,7 +747,7 @@ class ErrorContextCapture:
     def from_exception(
         cls,
         exc: BaseException,
-        include_locals: bool = True,  # noqa: ARG003
+        include_locals: bool = True,
         additional_context: dict[str, Any] | None = None,
     ) -> ErrorContextCapture:
         """Create error context from an exception.
@@ -885,14 +957,14 @@ _init_logging()
 
 # Re-export correlation and performance functions for convenience
 # These provide LOG-004 and LOG-006 functionality through this module
-from oscura.core.correlation import (  # noqa: E402
+from oscura.core.correlation import (
     CorrelationContext,
     generate_correlation_id,
     get_correlation_id,
     set_correlation_id,
     with_correlation_id,
 )
-from oscura.core.performance import (  # noqa: E402
+from oscura.core.performance import (
     PerformanceContext,
     PerformanceRecord,
     clear_performance_data,

oscura/core/logging_advanced.py

@@ -603,11 +603,11 @@ class CompressedLogHandler(logging.Handler):
 
     def _open_file(self) -> None:
         """Open current log file."""
-        self._current_file = gzip.open(  # noqa: SIM115
+        self._current_file = gzip.open(
             f"{self.filename}.gz", "ab", compresslevel=self.compression_level
         )
         try:
-            self._current_size = os.path.getsize(f"{self.filename}.gz")  # noqa: PTH202
+            self._current_size = os.path.getsize(f"{self.filename}.gz")
         except OSError:
             self._current_size = 0
 
@@ -621,11 +621,11 @@ class CompressedLogHandler(logging.Handler):
             src = f"{self.filename}.{i}.gz"
             dst = f"{self.filename}.{i + 1}.gz"
             if os.path.exists(src):
-                os.rename(src, dst)  # noqa: PTH104
+                os.rename(src, dst)
 
         # Move current to .1
         if os.path.exists(f"{self.filename}.gz"):
-            os.rename(f"{self.filename}.gz", f"{self.filename}.1.gz")  # noqa: PTH104
+            os.rename(f"{self.filename}.gz", f"{self.filename}.1.gz")
 
         self._open_file()
 
@@ -667,7 +667,7 @@ class EncryptedLogHandler(logging.Handler):
 
             with self._lock:
                 if self._file is None:
-                    self._file = open(self.filename, "ab")  # noqa: SIM115
+                    self._file = open(self.filename, "ab")
 
                 # Write length-prefixed encrypted message
                 length = len(encrypted).to_bytes(4, "big")

oscura/core/memory_limits.py

@@ -16,7 +16,7 @@ References:
 import warnings
 from typing import Any
 
-from oscura.config.memory import get_memory_config
+from oscura.core.config.memory import get_memory_config
 from oscura.utils.memory import estimate_memory
 
 
@@ -93,83 +93,123 @@ def apply_memory_limit(
         If parameters cannot be adjusted to fit memory, a warning is issued
         and the original parameters are returned.
     """
-    # Parse memory limit
-    limit_bytes = parse_memory_limit(max_memory)
+    limit_bytes = _get_effective_memory_limit(max_memory)
     if limit_bytes is None:
-        # Use global config
-        config = get_memory_config()
-        limit_bytes = config.max_memory
-        if limit_bytes is None:
-            # No limit, return params unchanged
-            return params
+        return params
 
     samples = int(samples)
-
-    # Estimate with current parameters
     current_estimate = estimate_memory(operation, samples, **params)
 
     if current_estimate.total <= limit_bytes:
-        # Already within limit
         return params
 
-    # Need to adjust parameters
-    adjusted_params = params.copy()
+    adjusted_params = _adjust_parameters_for_operation(
+        operation, samples, limit_bytes, params.copy()
+    )
+    _validate_adjusted_params(operation, samples, adjusted_params, limit_bytes)
+
+    return adjusted_params
+
+
+def _get_effective_memory_limit(max_memory: int | str | None) -> int | None:
+    """Get effective memory limit from parameter or config."""
+    limit_bytes = parse_memory_limit(max_memory)
+    if limit_bytes is not None:
+        return limit_bytes
 
+    config = get_memory_config()
+    return config.max_memory
+
+
+def _adjust_parameters_for_operation(
+    operation: str, samples: int, limit_bytes: int, params: dict[str, Any]
+) -> dict[str, Any]:
+    """Adjust parameters based on operation type."""
     if operation in ("fft", "psd"):
-        # Reduce nfft if specified
-        if "nfft" in adjusted_params:
-            # Try reducing nfft
-            original_nfft = adjusted_params["nfft"]
-            # Binary search for suitable nfft
-            nfft = _find_max_nfft(operation, samples, limit_bytes, **adjusted_params)
-            if nfft < original_nfft:
-                adjusted_params["nfft"] = nfft
-                warnings.warn(
-                    f"Reduced nfft from {original_nfft} to {nfft} to fit {limit_bytes / 1e6:.1f} MB limit",
-                    UserWarning,
-                    stacklevel=2,
-                )
-
-    elif operation == "spectrogram":
-        # Adjust nperseg and/or nfft
-        original_nperseg = adjusted_params.get("nperseg", 256)
-        original_nfft = adjusted_params.get("nfft", original_nperseg)
-
-        # Try reducing nperseg first
-        nperseg = _find_max_nperseg(samples, limit_bytes, noverlap=adjusted_params.get("noverlap"))
-        if nperseg < original_nperseg:
-            adjusted_params["nperseg"] = nperseg
-            # Adjust noverlap proportionally
-            if "noverlap" in adjusted_params:
-                overlap_ratio = adjusted_params["noverlap"] / original_nperseg
-                adjusted_params["noverlap"] = int(nperseg * overlap_ratio)
-            warnings.warn(
-                f"Reduced nperseg from {original_nperseg} to {nperseg} to fit {limit_bytes / 1e6:.1f} MB limit",
-                UserWarning,
-                stacklevel=2,
-            )
-
-        # Also reduce nfft if needed
-        if "nfft" in adjusted_params and adjusted_params["nfft"] > nperseg:
-            adjusted_params["nfft"] = nperseg
-
-    elif operation == "eye_diagram":
-        # Reduce samples_per_ui or num_uis
-        if "num_uis" in adjusted_params:
-            original_num_uis = adjusted_params["num_uis"]
-            # Calculate max num_uis that fits
-            samples_per_ui = adjusted_params.get("samples_per_ui", 100)
-            max_num_uis = _find_max_num_uis(limit_bytes, samples_per_ui)
-            if max_num_uis < original_num_uis:
-                adjusted_params["num_uis"] = max_num_uis
-                warnings.warn(
-                    f"Reduced num_uis from {original_num_uis} to {max_num_uis} to fit {limit_bytes / 1e6:.1f} MB limit",
-                    UserWarning,
-                    stacklevel=2,
-                )
-
-    # Verify final estimate
-    final_estimate = estimate_memory(operation, samples, **adjusted_params)
+        return _adjust_fft_params(operation, samples, limit_bytes, params)
+
+    if operation == "spectrogram":
+        return _adjust_spectrogram_params(samples, limit_bytes, params)
+
+    if operation == "eye_diagram":
+        return _adjust_eye_diagram_params(limit_bytes, params)
+
+    return params
+
+
+def _adjust_fft_params(
+    operation: str, samples: int, limit_bytes: int, params: dict[str, Any]
+) -> dict[str, Any]:
+    """Adjust FFT/PSD parameters to fit memory limit."""
+    if "nfft" not in params:
+        return params
+
+    original_nfft = params["nfft"]
+    nfft = _find_max_nfft(operation, samples, limit_bytes, **params)
+
+    if nfft < original_nfft:
+        params["nfft"] = nfft
+        warnings.warn(
+            f"Reduced nfft from {original_nfft} to {nfft} to fit {limit_bytes / 1e6:.1f} MB limit",
+            UserWarning,
+            stacklevel=2,
+        )
+
+    return params
+
+
+def _adjust_spectrogram_params(
+    samples: int, limit_bytes: int, params: dict[str, Any]
+) -> dict[str, Any]:
+    """Adjust spectrogram parameters to fit memory limit."""
+    original_nperseg = params.get("nperseg", 256)
+    nperseg = _find_max_nperseg(samples, limit_bytes, noverlap=params.get("noverlap"))
+
+    if nperseg < original_nperseg:
+        params["nperseg"] = nperseg
+
+        if "noverlap" in params:
+            overlap_ratio = params["noverlap"] / original_nperseg
+            params["noverlap"] = int(nperseg * overlap_ratio)
+
+        warnings.warn(
+            f"Reduced nperseg from {original_nperseg} to {nperseg} to fit {limit_bytes / 1e6:.1f} MB limit",
+            UserWarning,
+            stacklevel=2,
+        )
+
+    if "nfft" in params and params["nfft"] > nperseg:
+        params["nfft"] = nperseg
+
+    return params
+
+
+def _adjust_eye_diagram_params(limit_bytes: int, params: dict[str, Any]) -> dict[str, Any]:
+    """Adjust eye diagram parameters to fit memory limit."""
+    if "num_uis" not in params:
+        return params
+
+    original_num_uis = params["num_uis"]
+    samples_per_ui = params.get("samples_per_ui", 100)
+    max_num_uis = _find_max_num_uis(limit_bytes, samples_per_ui)
+
+    if max_num_uis < original_num_uis:
+        params["num_uis"] = max_num_uis
+        warnings.warn(
+            f"Reduced num_uis from {original_num_uis} to {max_num_uis} to fit {limit_bytes / 1e6:.1f} MB limit",
+            UserWarning,
+            stacklevel=2,
+        )
+
+    return params
+
+
+def _validate_adjusted_params(
+    operation: str, samples: int, params: dict[str, Any], limit_bytes: int
+) -> None:
+    """Verify that adjusted parameters fit within memory limit."""
+    final_estimate = estimate_memory(operation, samples, **params)
+
     if final_estimate.total > limit_bytes:
         warnings.warn(
             f"Could not adjust parameters to fit {limit_bytes / 1e6:.1f} MB limit. "
@@ -179,8 +219,6 @@ def apply_memory_limit(
             stacklevel=2,
         )
 
-    return adjusted_params
-
 
 def _find_max_nfft(operation: str, samples: int, limit_bytes: int, **params: Any) -> int:
     """Binary search for maximum nfft that fits memory limit.