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

oscura/analyzers/packet/payload_patterns.py

@@ -284,90 +284,117 @@ def detect_delimiter(
         >>> result = detect_delimiter(data)
         >>> print(f"Delimiter: {result.delimiter!r}")
     """
-    # Combine payloads if list
-    if isinstance(payloads, list | tuple):
-        data: bytes = b"".join(payloads)
-    else:
-        # Type narrowing: payloads is bytes here
-        data = cast("bytes", payloads)
-
+    data = _combine_payloads(payloads)
     if not data:
-        return DelimiterResult(
-            delimiter=b"",
-            delimiter_type="fixed",
-            confidence=0.0,
-            occurrences=0,
-        )
+        return DelimiterResult(delimiter=b"", delimiter_type="fixed", confidence=0.0, occurrences=0)
 
-    # Default candidates
-    if candidates is None:
-        candidates = [
-            b"\r\n",  # CRLF
-            b"\n",  # LF
-            b"\x00",  # Null
-            b"\r",  # CR
-            b"\x0d\x0a",  # CRLF (explicit)
-        ]
+    candidates = candidates or _default_delimiter_candidates()
 
     best_result = None
     best_score = 0.0
 
     for delim in candidates:
-        if len(delim) == 0:
-            continue
+        result, score = _evaluate_delimiter_candidate(data, delim)
+        if score > best_score:
+            best_score = score
+            best_result = result
 
-        count = data.count(delim)
-        if count < 2:
-            continue
+    return best_result or DelimiterResult(
+        delimiter=b"", delimiter_type="fixed", confidence=0.0, occurrences=0
+    )
 
-        # Calculate score based on frequency and regularity
-        positions = []
-        pos = 0
-        while True:
-            pos = data.find(delim, pos)
-            if pos == -1:
-                break
-            positions.append(pos)
-            pos += len(delim)
 
-        if len(positions) < 2:
-            continue
+def _combine_payloads(payloads: Sequence[bytes] | bytes) -> bytes:
+    """Combine payloads into single bytes object."""
+    if isinstance(payloads, list | tuple):
+        return b"".join(payloads)
+    return cast("bytes", payloads)
 
-        # Calculate interval regularity
-        intervals = [positions[i + 1] - positions[i] for i in range(len(positions) - 1)]
-        if len(intervals) > 0:
-            mean_interval = sum(intervals) / len(intervals)
-            if mean_interval > 0:
-                variance = sum((x - mean_interval) ** 2 for x in intervals) / len(intervals)
-                cv = (variance**0.5) / mean_interval
-                regularity = 1.0 / (1.0 + cv)
-            else:
-                regularity = 0.0
-        else:
-            regularity = 0.0
 
-        # Score combines frequency and regularity
-        score = count * (0.5 + 0.5 * regularity)
+def _default_delimiter_candidates() -> list[bytes]:
+    """Return default delimiter candidates."""
+    return [
+        b"\r\n",  # CRLF
+        b"\n",  # LF
+        b"\x00",  # Null
+        b"\r",  # CR
+        b"\x0d\x0a",  # CRLF (explicit)
+    ]
 
-        if score > best_score:
-            best_score = score
-            best_result = DelimiterResult(
-                delimiter=delim,
-                delimiter_type="fixed",
-                confidence=min(1.0, regularity * 0.8 + 0.2 * min(1.0, count / 10)),
-                occurrences=count,
-                positions=positions,
-            )
 
-    if best_result is None:
-        return DelimiterResult(
-            delimiter=b"",
-            delimiter_type="fixed",
-            confidence=0.0,
-            occurrences=0,
-        )
+def _evaluate_delimiter_candidate(
+    data: bytes, delim: bytes
+) -> tuple[DelimiterResult | None, float]:
+    """Evaluate a delimiter candidate and return result with score."""
+    if len(delim) == 0:
+        return None, 0.0
 
-    return best_result
+    count = data.count(delim)
+    if count < 2:
+        return None, 0.0
+
+    positions = _find_delimiter_positions(data, delim)
+    if len(positions) < 2:
+        return None, 0.0
+
+    regularity = _calculate_interval_regularity(positions)
+    score = count * (0.5 + 0.5 * regularity)
+    confidence = min(1.0, regularity * 0.8 + 0.2 * min(1.0, count / 10))
+
+    result = DelimiterResult(
+        delimiter=delim,
+        delimiter_type="fixed",
+        confidence=confidence,
+        occurrences=count,
+        positions=positions,
+    )
+    return result, score
+
+
+def _find_delimiter_positions(data: bytes, delim: bytes) -> list[int]:
+    """Find all positions of delimiter in data.
+
+    Args:
+        data: Data to search.
+        delim: Delimiter bytes to find.
+
+    Returns:
+        List of positions where delimiter occurs.
+
+    Raises:
+        ValueError: If delimiter is empty.
+    """
+    if len(delim) == 0:
+        raise ValueError("Delimiter cannot be empty")
+
+    positions = []
+    pos = 0
+    while True:
+        pos = data.find(delim, pos)
+        if pos == -1:
+            break
+        positions.append(pos)
+        pos += len(delim)
+    return positions
+
+
+def _calculate_interval_regularity(positions: list[int]) -> float:
+    """Calculate regularity score from delimiter positions."""
+    if len(positions) < 2:
+        return 0.0
+
+    intervals = [positions[i + 1] - positions[i] for i in range(len(positions) - 1)]
+    if len(intervals) == 0:
+        return 0.0
+
+    mean_interval = sum(intervals) / len(intervals)
+    if mean_interval <= 0:
+        return 0.0
+
+    variance = sum((x - mean_interval) ** 2 for x in intervals) / len(intervals)
+    cv = (variance**0.5) / mean_interval
+    regularity: float = 1.0 / (1.0 + cv)
+    return regularity
 
 
 def detect_length_prefix(
@@ -535,8 +562,27 @@ def _find_pattern_in_data(
     data: bytes,
     pattern: bytes | str,
     pattern_type: str,
+    max_matches: int = 100000,
 ) -> list[tuple[int, bytes]]:
-    """Find pattern occurrences in data."""
+    """Find pattern occurrences in data.
+
+    Args:
+        data: Data to search.
+        pattern: Pattern to find.
+        pattern_type: Type of pattern (exact, wildcard, regex).
+        max_matches: Maximum number of matches to return (default 100000).
+
+    Returns:
+        List of (offset, matched_bytes) tuples.
+
+    Raises:
+        ValueError: If max_matches exceeded (prevents infinite loops) or pattern is empty.
+    """
+    # Validate pattern is not empty (prevents infinite loops)
+    if isinstance(pattern, (str, bytes)):
+        if len(pattern) == 0:
+            raise ValueError("Pattern cannot be empty")
+
     matches = []
 
     if pattern_type == "exact":
@@ -550,6 +596,13 @@ def _find_pattern_in_data(
             matches.append((pos, pattern))
             pos += 1
 
+            # Prevent infinite loops from excessive matches
+            if len(matches) >= max_matches:
+                raise ValueError(
+                    f"Pattern match limit exceeded ({max_matches} matches). "
+                    "This may indicate a problematic pattern (e.g., empty or too common)."
+                )
+
     elif pattern_type == "wildcard":
         # Convert wildcard pattern to regex
         if isinstance(pattern, bytes):
@@ -558,6 +611,11 @@ def _find_pattern_in_data(
             try:
                 for match in re.finditer(regex_pattern, data, re.DOTALL):
                     matches.append((match.start(), match.group()))
+                    if len(matches) >= max_matches:
+                        raise ValueError(
+                            f"Pattern match limit exceeded ({max_matches} matches). "
+                            "Wildcard pattern may be too permissive."
+                        )
             except re.error:
                 pass
 
@@ -567,6 +625,11 @@ def _find_pattern_in_data(
         try:
             for match in re.finditer(pattern, data, re.DOTALL):
                 matches.append((match.start(), match.group()))
+                if len(matches) >= max_matches:
+                    raise ValueError(
+                        f"Pattern match limit exceeded ({max_matches} matches). "
+                        "Regex pattern may be too broad."
+                    )
         except re.error:
             pass
 

oscura/analyzers/packet/stream.py

@@ -60,6 +60,9 @@ def stream_file(
         >>> for chunk in stream_file("large_capture.bin"):
         ...     process_chunk(chunk)
     """
+    if chunk_size <= 0:
+        raise ValueError(f"chunk_size must be positive, got {chunk_size}")
+
     path = Path(file_path)
 
     with open(path, "rb") as f:
@@ -87,20 +90,26 @@ def stream_records(
         >>> for record in stream_records("data.bin", record_size=128):
         ...     parse_record(record)
     """
+    if record_size <= 0:
+        raise ValueError(f"record_size must be positive, got {record_size}")
+
     if isinstance(file_or_buffer, bytes):
         buffer: BinaryIO = io.BytesIO(file_or_buffer)
         should_close = True
     elif isinstance(file_or_buffer, str | Path):
-        buffer = open(file_or_buffer, "rb")  # noqa: SIM115
+        buffer = open(file_or_buffer, "rb")
         should_close = True
     else:
         buffer = file_or_buffer
         should_close = False
 
+    # Cache record_size to avoid attribute lookup in tight loop
+    _record_size = record_size
     try:
         while True:
-            record = buffer.read(record_size)
-            if len(record) < record_size:
+            record = buffer.read(_record_size)
+            # Equality check is faster than inequality
+            if len(record) != _record_size:
                 break
             yield record
     finally:
@@ -128,11 +137,16 @@ def stream_packets(
     Yields:
         StreamPacket objects.
 
+    Raises:
+        ValueError: If packet size exceeds MAX_PACKET_SIZE (100MB).
+
     Example:
         >>> header = BinaryParser(">HH")  # sync, length
         >>> for pkt in stream_packets("capture.bin", header_parser=header):
         ...     print(f"Packet: {len(pkt.data)} bytes")
     """
+    MAX_PACKET_SIZE = 100 * 1024 * 1024  # 100MB limit to prevent memory exhaustion
+
     if header_parser is None:
         # Default: 2-byte big-endian length prefix
         header_parser = BinaryParser(">H")
@@ -144,33 +158,50 @@ def stream_packets(
         buffer: BinaryIO = io.BytesIO(file_or_buffer)
         should_close = True
     elif isinstance(file_or_buffer, str | Path):
-        buffer = open(file_or_buffer, "rb")  # noqa: SIM115
+        buffer = open(file_or_buffer, "rb")
         should_close = True
     else:
         buffer = file_or_buffer
         should_close = False
 
+    # Cache sizes and flags to avoid repeated lookups in tight loop
+    _header_size = header_size
+    _length_field = length_field
+    _header_included = header_included
+
     try:
         packet_num = 0
 
         while True:
             # Read header
-            header_bytes = buffer.read(header_size)
-            if len(header_bytes) < header_size:
+            header_bytes = buffer.read(_header_size)
+            if len(header_bytes) != _header_size:
                 break
 
             header = header_parser.unpack(header_bytes)
-            length = header[length_field]
-
-            # Compute payload size
-            payload_size = length - header_size if header_included else length
-
-            if payload_size < 0:
-                break
+            length = header[_length_field]
+
+            # Validate packet size before allocation
+            total_size = length if _header_included else length + _header_size
+            if total_size > MAX_PACKET_SIZE:
+                raise ValueError(
+                    f"Packet size {total_size} bytes exceeds maximum allowed size "
+                    f"{MAX_PACKET_SIZE} bytes (packet {packet_num + 1})"
+                )
+
+            # Compute payload size with optimized branching
+            if _header_included:
+                if length < _header_size:
+                    break
+                payload_size = length - _header_size
+            else:
+                if length < 0:
+                    break
+                payload_size = length
 
             # Read payload
             payload = buffer.read(payload_size)
-            if len(payload) < payload_size:
+            if len(payload) != payload_size:
                 break
 
             packet_num += 1
@@ -197,20 +228,29 @@ def stream_delimited(
     Args:
         file_or_buffer: Source.
         delimiter: Record delimiter (default newline).
-        max_record_size: Maximum record size (default 1MB).
+        max_record_size: Maximum record size (default 1MB). Records exceeding
+            this size will raise ValueError instead of being silently truncated.
 
     Yields:
         Records as bytes (without delimiter).
 
+    Raises:
+        ValueError: If record exceeds max_record_size.
+
     Example:
         >>> for line in stream_delimited("log.txt", b"\\n"):
         ...     process_line(line)
     """
+    if max_record_size <= 0:
+        raise ValueError(f"max_record_size must be positive, got {max_record_size}")
+    if not delimiter:
+        raise ValueError("delimiter cannot be empty")
+
     if isinstance(file_or_buffer, bytes):
         buffer: BinaryIO = io.BytesIO(file_or_buffer)
         should_close = True
     elif isinstance(file_or_buffer, str | Path):
-        buffer = open(file_or_buffer, "rb")  # noqa: SIM115
+        buffer = open(file_or_buffer, "rb")
         should_close = True
     else:
         buffer = file_or_buffer
@@ -223,6 +263,12 @@ def stream_delimited(
             chunk = buffer.read(65536)
             if not chunk:
                 if partial:
+                    # Check final partial record
+                    if len(partial) > max_record_size:
+                        raise ValueError(
+                            f"Record size {len(partial)} bytes exceeds maximum allowed size "
+                            f"{max_record_size} bytes"
+                        )
                     yield partial
                 break
 
@@ -231,16 +277,22 @@ def stream_delimited(
 
             # Yield complete records
             for part in parts[:-1]:
-                if len(part) <= max_record_size:
-                    yield part
+                if len(part) > max_record_size:
+                    raise ValueError(
+                        f"Record size {len(part)} bytes exceeds maximum allowed size "
+                        f"{max_record_size} bytes"
+                    )
+                yield part
 
             # Keep partial record for next iteration
             partial = parts[-1]
 
-            # Guard against memory issues
+            # Guard against memory issues - raise error instead of truncating
             if len(partial) > max_record_size:
-                yield partial[:max_record_size]
-                partial = b""
+                raise ValueError(
+                    f"Partial record size {len(partial)} bytes exceeds maximum allowed size "
+                    f"{max_record_size} bytes"
+                )
 
     finally:
         if should_close:
@@ -299,6 +351,9 @@ def batch(
         >>> for batch_items in batch(stream_packets(f), size=100):
         ...     process_batch(batch_items)
     """
+    if size <= 0:
+        raise ValueError(f"size must be positive, got {size}")
+
     current_batch: list[T] = []
 
     for item in source:
@@ -321,12 +376,15 @@ def take(source: Iterator[T], n: int) -> Iterator[T]:
     Yields:
         First n items.
     """
+    if n < 0:
+        raise ValueError(f"n must be non-negative, got {n}")
+
     count = 0
     for item in source:
         if count >= n:
             break
         yield item
-        count += 1  # noqa: SIM113
+        count += 1
 
 
 def skip(source: Iterator[T], n: int) -> Iterator[T]:
@@ -339,11 +397,14 @@ def skip(source: Iterator[T], n: int) -> Iterator[T]:
     Yields:
         Items after first n.
     """
+    if n < 0:
+        raise ValueError(f"n must be non-negative, got {n}")
+
     count = 0
     for item in source:
         if count >= n:
             yield item
-        count += 1  # noqa: SIM113
+        count += 1
 
 
 __all__ = [

oscura/analyzers/patterns/__init__.py

@@ -127,21 +127,42 @@ def find_motifs(
     return results
 
 
-def extract_motif(data: Any, start: int, length: int) -> NDArray[np.generic]:
+def extract_motif(data: Any, start: int = 0, length: int | None = None) -> NDArray[np.generic]:
     """Extract a motif from data.
 
     Args:
-        data: Input data array.
-        start: Start index.
-        length: Length to extract.
+        data: Input data array. If start and length not provided, attempts to detect and extract
+            the first repeating motif automatically.
+        start: Start index for extraction (default: 0).
+        length: Length to extract. If None, attempts to detect motif length automatically.
 
     Returns:
         Extracted motif as numpy array.
+
+    Raises:
+        ValueError: If automatic detection fails and no length specified.
     """
     import numpy as np
 
     data_arr = np.asarray(data)
-    result = data_arr[start : start + length]
+
+    # If length not specified, try to detect motif automatically
+    if length is None:
+        # Try to find repeating pattern using period detection
+        try:
+            period_result = detect_period(data_arr)
+            if period_result is not None and hasattr(period_result, "period"):
+                length = int(period_result.period)
+            else:
+                # Default to 8 samples if detection fails
+                length = min(8, len(data_arr))
+        except Exception:
+            # Fallback to reasonable default
+            length = min(8, len(data_arr))
+
+    # Ensure we don't exceed array bounds
+    end = min(start + length, len(data_arr))
+    result = data_arr[start:end]
     return result