ostruct-cli 0.3.0__py3-none-any.whl → 0.4.0__py3-none-any.whl

ostruct/cli/file_list.py

@@ -1,7 +1,8 @@
 """FileInfoList implementation providing smart file content access."""
 
 import logging
-from typing import Iterator, List, SupportsIndex, Union, overload
+import threading
+from typing import Iterable, Iterator, List, SupportsIndex, Union, overload
 
 from .file_info import FileInfo
 
@@ -18,6 +19,12 @@ class FileInfoList(List[FileInfo]):
     properties like content return the value directly. For multiple files or directory
     mappings, properties return a list of values.
 
+    This class is thread-safe. All operations that access or modify the internal list
+    are protected by a reentrant lock (RLock). This allows nested method calls while
+    holding the lock, preventing deadlocks in cases like:
+        content property → __len__ → lock
+        content property → __getitem__ → lock
+
     Examples:
         Single file (--file):
             files = FileInfoList([file_info], from_dir=False)
@@ -52,6 +59,7 @@ class FileInfoList(List[FileInfo]):
             len(files),
             from_dir,
         )
+        self._lock = threading.RLock()  # Use RLock for nested method calls
         super().__init__(files)
         self._from_dir = from_dir
 
@@ -66,20 +74,37 @@ class FileInfoList(List[FileInfo]):
         Raises:
             ValueError: If the list is empty
         """
-        if not self:
-            logger.debug("FileInfoList.content called but list is empty")
-            raise ValueError("No files in FileInfoList")
-        if len(self) == 1 and not self._from_dir:
+        # Take snapshot under lock
+        with self._lock:
+            if not self:
+                logger.debug("FileInfoList.content called but list is empty")
+                raise ValueError("No files in FileInfoList")
+
+            # Make a copy of the files we need to access
+            if len(self) == 1 and not self._from_dir:
+                file_info = self[0]
+                is_single = True
+            else:
+                files = list(self)
+                is_single = False
+
+        # Access file contents outside lock to prevent deadlocks
+        try:
+            if is_single:
+                logger.debug(
+                    "FileInfoList.content returning single file content (not from dir)"
+                )
+                return file_info.content
+
             logger.debug(
-                "FileInfoList.content returning single file content (not from dir)"
+                "FileInfoList.content returning list of %d contents (from_dir=%s)",
+                len(files),
+                self._from_dir,
             )
-            return self[0].content
-        logger.debug(
-            "FileInfoList.content returning list of %d contents (from_dir=%s)",
-            len(self),
-            self._from_dir,
-        )
-        return [f.content for f in self]
+            return [f.content for f in files]
+        except Exception as e:
+            logger.error("Error accessing file content: %s", e)
+            raise
 
     @property
     def path(self) -> Union[str, List[str]]:
@@ -92,11 +117,25 @@ class FileInfoList(List[FileInfo]):
         Raises:
             ValueError: If the list is empty
         """
-        if not self:
-            raise ValueError("No files in FileInfoList")
-        if len(self) == 1 and not self._from_dir:
-            return self[0].path
-        return [f.path for f in self]
+        # First get a snapshot of the list state under the lock
+        with self._lock:
+            if not self:
+                raise ValueError("No files in FileInfoList")
+            if len(self) == 1 and not self._from_dir:
+                file_info = self[0]
+                is_single = True
+            else:
+                files = list(self)
+                is_single = False
+
+        # Now access file paths outside the lock
+        try:
+            if is_single:
+                return file_info.path
+            return [f.path for f in files]
+        except Exception as e:
+            logger.error("Error accessing file path: %s", e)
+            raise
 
     @property
     def abs_path(self) -> Union[str, List[str]]:
@@ -109,11 +148,25 @@ class FileInfoList(List[FileInfo]):
         Raises:
             ValueError: If the list is empty
         """
-        if not self:
-            raise ValueError("No files in FileInfoList")
-        if len(self) == 1 and not self._from_dir:
-            return self[0].abs_path
-        return [f.abs_path for f in self]
+        # First get a snapshot of the list state under the lock
+        with self._lock:
+            if not self:
+                raise ValueError("No files in FileInfoList")
+            if len(self) == 1 and not self._from_dir:
+                file_info = self[0]
+                is_single = True
+            else:
+                files = list(self)
+                is_single = False
+
+        # Now access file paths outside the lock
+        try:
+            if is_single:
+                return file_info.abs_path
+            return [f.abs_path for f in files]
+        except Exception as e:
+            logger.error("Error accessing absolute path: %s", e)
+            raise
 
     @property
     def size(self) -> Union[int, List[int]]:
@@ -126,26 +179,39 @@ class FileInfoList(List[FileInfo]):
         Raises:
             ValueError: If the list is empty or if any file size is None
         """
-        if not self:
-            raise ValueError("No files in FileInfoList")
-
-        # For single file not from directory, return its size
-        if len(self) == 1 and not self._from_dir:
-            size = self[0].size
-            if size is None:
-                raise ValueError(
-                    f"Could not get size for file: {self[0].path}"
-                )
-            return size
-
-        # For multiple files, collect all sizes
-        sizes = []
-        for f in self:
-            size = f.size
-            if size is None:
-                raise ValueError(f"Could not get size for file: {f.path}")
-            sizes.append(size)
-        return sizes
+        # First get a snapshot of the list state under the lock
+        with self._lock:
+            if not self:
+                raise ValueError("No files in FileInfoList")
+
+            # Make a copy of the files we need to access
+            if len(self) == 1 and not self._from_dir:
+                file_info = self[0]
+                is_single = True
+            else:
+                files = list(self)
+                is_single = False
+
+        # Now access file sizes outside the lock
+        try:
+            if is_single:
+                size = file_info.size
+                if size is None:
+                    raise ValueError(
+                        f"Could not get size for file: {file_info.path}"
+                    )
+                return size
+
+            sizes = []
+            for f in files:
+                size = f.size
+                if size is None:
+                    raise ValueError(f"Could not get size for file: {f.path}")
+                sizes.append(size)
+            return sizes
+        except Exception as e:
+            logger.error("Error accessing file size: %s", e)
+            raise
 
     def __str__(self) -> str:
         """Get string representation of the file list.
@@ -153,11 +219,12 @@ class FileInfoList(List[FileInfo]):
         Returns:
             str: String representation in format FileInfoList([paths])
         """
-        if not self:
-            return "FileInfoList([])"
-        if len(self) == 1:
-            return f"FileInfoList(['{self[0].path}'])"
-        return f"FileInfoList({[f.path for f in self]})"
+        with self._lock:
+            if not self:
+                return "FileInfoList([])"
+            if len(self) == 1:
+                return f"FileInfoList(['{self[0].path}'])"
+            return f"FileInfoList({[f.path for f in self]})"
 
     def __repr__(self) -> str:
         """Get detailed string representation of the file list.
@@ -169,18 +236,23 @@ class FileInfoList(List[FileInfo]):
 
     def __iter__(self) -> Iterator[FileInfo]:
         """Return iterator over files."""
+        with self._lock:
+            # Create a copy of the list to avoid concurrent modification issues
+            items = list(super().__iter__())
         logger.debug(
-            "Starting iteration over FileInfoList with %d files", len(self)
+            "Starting iteration over FileInfoList with %d files", len(items)
         )
-        return super().__iter__()
+        return iter(items)
 
     def __len__(self) -> int:
         """Return number of files."""
-        return super().__len__()
+        with self._lock:
+            return super().__len__()
 
     def __bool__(self) -> bool:
         """Return True if there are files."""
-        return super().__len__() > 0
+        with self._lock:
+            return super().__len__() > 0
 
     @overload
     def __getitem__(self, index: SupportsIndex, /) -> FileInfo: ...
@@ -191,17 +263,70 @@ class FileInfoList(List[FileInfo]):
     def __getitem__(
         self, index: Union[SupportsIndex, slice], /
     ) -> Union[FileInfo, "FileInfoList"]:
-        """Get file at index."""
-        logger.debug("Getting file at index %s", index)
-        result = super().__getitem__(index)
-        if isinstance(index, slice):
-            if not isinstance(result, list):
+        """Get file at index.
+
+        This method is thread-safe and handles both integer indexing and slicing.
+        For slicing, it ensures the result is always converted to a list before
+        creating a new FileInfoList instance.
+        """
+        with self._lock:
+            logger.debug("Getting file at index %s", index)
+            result = super().__getitem__(index)
+            if isinstance(index, slice):
+                # Always convert to list to handle any sequence type
+                # Cast to Iterable[FileInfo] to satisfy mypy
+                result_list = list(
+                    result if isinstance(result, list) else [result]
+                )
+                return FileInfoList(result_list, self._from_dir)
+            if not isinstance(result, FileInfo):
                 raise TypeError(
-                    f"Expected list from slice, got {type(result)}"
+                    f"Expected FileInfo from index, got {type(result)}"
                 )
-            return FileInfoList(result, self._from_dir)
-        if not isinstance(result, FileInfo):
-            raise TypeError(
-                f"Expected FileInfo from index, got {type(result)}"
-            )
-        return result
+            return result
+
+    def append(self, value: FileInfo) -> None:
+        """Append a FileInfo object to the list."""
+        with self._lock:
+            super().append(value)
+
+    def extend(self, values: Iterable[FileInfo]) -> None:
+        """Extend the list with FileInfo objects.
+
+        Args:
+            values: Iterable of FileInfo objects to add
+        """
+        with self._lock:
+            super().extend(values)
+
+    def insert(self, index: SupportsIndex, value: FileInfo) -> None:
+        """Insert a FileInfo object at the given index.
+
+        Args:
+            index: Position to insert at
+            value: FileInfo object to insert
+        """
+        with self._lock:
+            super().insert(index, value)
+
+    def pop(self, index: SupportsIndex = -1) -> FileInfo:
+        """Remove and return item at index (default last).
+
+        Args:
+            index: Position to remove from (default: -1 for last item)
+
+        Returns:
+            The removed FileInfo object
+        """
+        with self._lock:
+            return super().pop(index)
+
+    def remove(self, value: FileInfo) -> None:
+        """Remove first occurrence of value."""
+        with self._lock:
+            super().remove(value)
+
+    def clear(self) -> None:
+        """Remove all items from list."""
+        with self._lock:
+            super().clear()

ostruct/cli/file_utils.py

@@ -58,7 +58,7 @@ from .errors import (
 from .file_info import FileInfo
 from .file_list import FileInfoList
 from .security import SecurityManager
-from .security_types import SecurityManagerProtocol
+from .security.types import SecurityManagerProtocol
 
 __all__ = [
     "FileInfo",  # Re-exported from file_info
@@ -153,21 +153,21 @@ def collect_files_from_directory(
     allowed_extensions: Optional[List[str]] = None,
     **kwargs: Any,
 ) -> List[FileInfo]:
-    """Collect files from directory.
+    """Collect files from a directory.
 
     Args:
         directory: Directory to collect files from
         security_manager: Security manager for path validation
-        recursive: Whether to collect files recursively
-        allowed_extensions: List of allowed file extensions without dots
+        recursive: Whether to process subdirectories
+        allowed_extensions: List of allowed file extensions (without dot)
         **kwargs: Additional arguments passed to FileInfo.from_path
 
     Returns:
-        List of FileInfo instances
+        List of FileInfo objects
 
     Raises:
         DirectoryNotFoundError: If directory does not exist
-        PathSecurityError: If directory is not allowed
+        PathSecurityError: If directory or any file path is not allowed
     """
     logger.debug(
         "Collecting files from directory: %s (recursive=%s, extensions=%s)",
@@ -176,86 +176,113 @@ def collect_files_from_directory(
         allowed_extensions,
     )
 
-    # Validate directory exists and is allowed
+    # First validate and resolve the directory path
     try:
         abs_dir = str(security_manager.resolve_path(directory))
-        logger.debug("Resolved absolute directory path: %s", abs_dir)
-        logger.debug(
-            "Security manager base_dir: %s", security_manager.base_dir
-        )
-        logger.debug(
-            "Security manager allowed_dirs: %s", security_manager.allowed_dirs
-        )
+        logger.debug("Resolved directory path: %s", abs_dir)
     except PathSecurityError as e:
-        logger.debug("PathSecurityError while resolving directory: %s", str(e))
-        # Let the original error propagate
+        logger.error(
+            "Security violation in directory path: %s (%s)", directory, str(e)
+        )
         raise
 
-    if not os.path.exists(abs_dir):
-        logger.debug("Directory not found: %s (abs: %s)", directory, abs_dir)
-        raise DirectoryNotFoundError(f"Directory not found: {directory}")
     if not os.path.isdir(abs_dir):
-        logger.debug(
-            "Path is not a directory: %s (abs: %s)", directory, abs_dir
-        )
+        logger.error("Path is not a directory: %s", abs_dir)
         raise DirectoryNotFoundError(f"Path is not a directory: {directory}")
 
-    # Collect files
     files: List[FileInfo] = []
-    for root, dirs, filenames in os.walk(abs_dir):
-        logger.debug("Walking directory: %s", root)
-        logger.debug("Found subdirectories: %s", dirs)
-        logger.debug("Found files: %s", filenames)
 
-        if not recursive and root != abs_dir:
-            logger.debug(
-                "Skipping subdirectory (non-recursive mode): %s", root
-            )
-            continue
+    try:
+        for root, dirs, filenames in os.walk(abs_dir):
+            logger.debug("Walking directory: %s", root)
+            logger.debug("Found subdirectories: %s", dirs)
+            logger.debug("Found files: %s", filenames)
 
-        logger.debug("Scanning directory: %s", root)
-        logger.debug("Current files collected: %d", len(files))
-        for filename in filenames:
-            # Get relative path from base directory
-            abs_path = os.path.join(root, filename)
+            # Validate current directory
             try:
-                rel_path = os.path.relpath(abs_path, security_manager.base_dir)
-                logger.debug("Processing file: %s -> %s", abs_path, rel_path)
-            except ValueError as e:
-                # Skip files that can't be made relative
+                security_manager.validate_path(root)
+            except PathSecurityError as e:
+                logger.error(
+                    "Security violation in subdirectory: %s (%s)", root, str(e)
+                )
+                raise
+
+            if not recursive and root != abs_dir:
                 logger.debug(
-                    "Skipping file that can't be made relative: %s (error: %s)",
-                    abs_path,
-                    str(e),
+                    "Skipping subdirectory (non-recursive mode): %s", root
                 )
                 continue
 
-            # Check extension if filter is specified
-            if allowed_extensions is not None:
-                ext = os.path.splitext(filename)[1].lstrip(".")
-                if ext not in allowed_extensions:
+            logger.debug("Scanning directory: %s", root)
+            logger.debug("Current files collected: %d", len(files))
+
+            for filename in filenames:
+                # Get relative path from base directory
+                abs_path = os.path.join(root, filename)
+                try:
+                    rel_path = os.path.relpath(
+                        abs_path, security_manager.base_dir
+                    )
                     logger.debug(
-                        "Skipping file with non-matching extension: %s (ext=%s, allowed=%s)",
-                        filename,
-                        ext,
-                        allowed_extensions,
+                        "Processing file: %s -> %s", abs_path, rel_path
+                    )
+                except ValueError as e:
+                    logger.warning(
+                        "Skipping file that can't be made relative: %s (error: %s)",
+                        abs_path,
+                        str(e),
                     )
                     continue
 
-            try:
-                file_info = FileInfo.from_path(
-                    rel_path, security_manager=security_manager, **kwargs
-                )
-                files.append(file_info)
-                logger.debug("Added file to list: %s", rel_path)
-            except (FileNotFoundError, PathSecurityError) as e:
-                # Skip files that can't be accessed
-                logger.debug(
-                    "Skipping inaccessible file: %s (error: %s)",
-                    rel_path,
-                    str(e),
-                )
-                continue
+                # Check extension if filter is specified
+                if allowed_extensions is not None:
+                    ext = os.path.splitext(filename)[1].lstrip(".")
+                    if ext not in allowed_extensions:
+                        logger.debug(
+                            "Skipping file with disallowed extension: %s",
+                            filename,
+                        )
+                        continue
+
+                # Validate file path before creating FileInfo
+                try:
+                    security_manager.validate_path(abs_path)
+                except PathSecurityError as e:
+                    logger.error(
+                        "Security violation for file: %s (%s)",
+                        abs_path,
+                        str(e),
+                    )
+                    raise
+
+                try:
+                    file_info = FileInfo.from_path(
+                        rel_path, security_manager=security_manager, **kwargs
+                    )
+                    files.append(file_info)
+                    logger.debug("Added file to list: %s", rel_path)
+                except PathSecurityError as e:
+                    # Log and re-raise security errors immediately
+                    logger.error(
+                        "Security violation processing file: %s (%s)",
+                        rel_path,
+                        str(e),
+                    )
+                    raise
+                except (FileNotFoundError, PermissionError) as e:
+                    # Skip legitimate file access errors
+                    logger.warning(
+                        "Skipping inaccessible file: %s (error: %s)",
+                        rel_path,
+                        str(e),
+                    )
+
+    except PathSecurityError:
+        # Re-raise security errors without wrapping
+        raise
+    except Exception as e:
+        logger.error("Error collecting files: %s", str(e))
+        raise
 
     logger.debug("Collected %d files from directory %s", len(files), directory)
     return files