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

ostruct/cli/file_info.py

@@ -3,9 +3,10 @@
 import hashlib
 import logging
 import os
+from pathlib import Path
 from typing import Any, Optional
 
-from .errors import FileNotFoundError, PathSecurityError
+from .errors import FileReadError, OstructFileNotFoundError, PathSecurityError
 from .security import SecurityManager
 
 logger = logging.getLogger(__name__)
@@ -45,6 +46,7 @@ class FileInfo:
         Raises:
             FileNotFoundError: If the file does not exist
             PathSecurityError: If the path is not allowed
+            PermissionError: If access is denied
         """
         logger.debug("Creating FileInfo for path: %s", path)
 
@@ -53,7 +55,7 @@ class FileInfo:
             raise ValueError("Path cannot be empty")
 
         # Initialize private attributes
-        self.__path = os.path.expanduser(os.path.expandvars(path))
+        self.__path = str(path)
         self.__security_manager = security_manager
         self.__content = content
         self.__encoding = encoding
@@ -61,57 +63,95 @@ class FileInfo:
         self.__size: Optional[int] = None
         self.__mtime: Optional[float] = None
 
-        # First validate security and resolve path
         try:
             # This will raise PathSecurityError if path is not allowed
+            # And FileNotFoundError if the file doesn't exist
             resolved_path = self.__security_manager.resolve_path(self.__path)
             logger.debug(
                 "Security-resolved path for %s: %s", path, resolved_path
             )
 
-            # Now check if the file exists and is accessible
-            if not resolved_path.exists():
-                # Use the original path in the error message
-                raise FileNotFoundError(
-                    f"File not found: {os.path.basename(path)}"
-                )
-
+            # Check if it's a regular file (not a directory, device, etc.)
             if not resolved_path.is_file():
-                raise FileNotFoundError(
-                    f"Not a file: {os.path.basename(path)}"
+                logger.debug("Not a regular file: %s", resolved_path)
+                raise OstructFileNotFoundError(
+                    f"Not a regular file: {os.path.basename(str(path))}"
                 )
 
-        except PathSecurityError:
-            # Re-raise security errors as is
-            raise
-        except FileNotFoundError:
-            # Re-raise file not found errors with simplified message
-            raise FileNotFoundError(
-                f"File not found: {os.path.basename(path)}"
-            )
-        except Exception:  # Catch all other exceptions
-            # Convert other errors to FileNotFoundError with simplified message
-            raise FileNotFoundError(
-                f"File not found: {os.path.basename(path)}"
+        except PathSecurityError as e:
+            # Let security errors propagate directly with context
+            logger.error(
+                "Security error accessing file %s: %s",
+                path,
+                str(e),
+                extra={
+                    "path": path,
+                    "resolved_path": (
+                        str(resolved_path)
+                        if "resolved_path" in locals()
+                        else None
+                    ),
+                    "base_dir": str(self.__security_manager.base_dir),
+                    "allowed_dirs": [
+                        str(d) for d in self.__security_manager.allowed_dirs
+                    ],
+                },
             )
+            raise
 
-        # If content/encoding weren't provided, read them now
-        if self.__content is None or self.__encoding is None:
-            logger.debug("Reading content for %s", path)
-            self._read_file()
+        except OstructFileNotFoundError as e:
+            # Re-raise with standardized message format
+            logger.debug("File not found error: %s", e)
+            raise OstructFileNotFoundError(
+                f"File not found: {os.path.basename(str(path))}"
+            ) from e
+
+        except PermissionError as e:
+            # Handle permission errors with context
+            logger.error(
+                "Permission denied accessing file %s: %s",
+                path,
+                str(e),
+                extra={
+                    "path": path,
+                    "resolved_path": (
+                        str(resolved_path)
+                        if "resolved_path" in locals()
+                        else None
+                    ),
+                },
+            )
+            raise PermissionError(
+                f"Permission denied: {os.path.basename(str(path))}"
+            ) from e
 
     @property
     def path(self) -> str:
-        """Get the relative path of the file."""
-        # If original path was relative, keep it relative
-        if not os.path.isabs(self.__path):
-            try:
-                base_dir = self.__security_manager.base_dir
-                abs_path = self.abs_path
-                return os.path.relpath(abs_path, base_dir)
-            except ValueError:
-                pass
-        return self.__path
+        """Get the path relative to security manager's base directory.
+
+        Returns a path relative to the security manager's base directory.
+        This ensures consistent path handling across the entire codebase.
+
+        Example:
+            security_manager = SecurityManager(base_dir="/base")
+            file_info = FileInfo("/base/file.txt", security_manager)
+            print(file_info.path)  # Outputs: "file.txt"
+
+        Returns:
+            str: Path relative to security manager's base directory
+
+        Raises:
+            ValueError: If the path is not within the base directory
+        """
+        try:
+            abs_path = Path(self.abs_path)
+            base_dir = Path(self.__security_manager.base_dir)
+            return str(abs_path.relative_to(base_dir))
+        except ValueError as e:
+            logger.error("Error making path relative: %s", e)
+            raise ValueError(
+                f"Path {abs_path} must be within base directory {base_dir}"
+            )
 
     @path.setter
     def path(self, value: str) -> None:
@@ -154,7 +194,8 @@ class FileInfo:
         """Get file size in bytes."""
         if self.__size is None:
             try:
-                self.__size = os.path.getsize(self.abs_path)
+                size = os.path.getsize(self.abs_path)
+                self.__size = size
             except OSError:
                 logger.warning("Could not get size for %s", self.__path)
                 return None
@@ -170,7 +211,8 @@ class FileInfo:
         """Get file modification time as Unix timestamp."""
         if self.__mtime is None:
             try:
-                self.__mtime = os.path.getmtime(self.abs_path)
+                mtime = os.path.getmtime(self.abs_path)
+                self.__mtime = mtime
             except OSError:
                 logger.warning("Could not get mtime for %s", self.__path)
                 return None
@@ -183,10 +225,25 @@ class FileInfo:
 
     @property
     def content(self) -> str:
-        """Get the content of the file."""
+        """Get the content of the file.
+
+        Returns:
+            str: The file content
+
+        Raises:
+            FileReadError: If the file cannot be read, wrapping the underlying cause
+                         (FileNotFoundError, UnicodeDecodeError, etc)
+        """
+        if self.__content is None:
+            try:
+                self._read_file()
+            except Exception as e:
+                raise FileReadError(
+                    f"Failed to load content: {self.__path}", self.__path
+                ) from e
         assert (
             self.__content is not None
-        ), "Content should be initialized in constructor"
+        )  # Help mypy understand content is set
         return self.__content
 
     @content.setter
@@ -196,10 +253,20 @@ class FileInfo:
 
     @property
     def encoding(self) -> str:
-        """Get the encoding of the file."""
+        """Get the encoding of the file.
+
+        Returns:
+            str: The file encoding (utf-8 or system)
+
+        Raises:
+            FileReadError: If the file cannot be read or decoded
+        """
+        if self.__encoding is None:
+            # This will trigger content loading and may raise FileReadError
+            self.content
         assert (
             self.__encoding is not None
-        ), "Encoding should be initialized in constructor"
+        )  # Help mypy understand encoding is set
         return self.__encoding
 
     @encoding.setter
@@ -248,34 +315,24 @@ class FileInfo:
             return False
 
     def _read_file(self) -> None:
-        """Read file content and encoding from disk."""
+        """Read and decode file content.
+
+        Implementation detail: Attempts UTF-8 first, falls back to system encoding.
+        All exceptions will be caught and wrapped by the content property.
+        """
         try:
             with open(self.abs_path, "rb") as f:
                 raw_content = f.read()
-        except FileNotFoundError as e:
-            raise FileNotFoundError(f"File not found: {self.__path}") from e
-        except OSError as e:
-            raise FileNotFoundError(
-                f"Could not read file {self.__path}: {e}"
-            ) from e
-
-        # Try UTF-8 first
-        try:
-            self.__content = raw_content.decode("utf-8")
-            self.__encoding = "utf-8"
-            return
-        except UnicodeDecodeError:
-            pass
-
-        # Fall back to system default encoding
-        try:
-            self.__content = raw_content.decode()
-            self.__encoding = "system"
-            return
-        except UnicodeDecodeError as e:
-            raise ValueError(
-                f"Could not decode file {self.__path}: {e}"
-            ) from e
+            try:
+                self.__content = raw_content.decode("utf-8")
+                self.__encoding = "utf-8"
+            except UnicodeDecodeError:
+                # Fall back to system encoding
+                self.__content = raw_content.decode()
+                self.__encoding = "system"
+        except Exception:
+            # Let content property handle all errors
+            raise
 
     def update_cache(
         self,

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
 
@@ -61,25 +69,39 @@ class FileInfoList(List[FileInfo]):
 
         Returns:
             Union[str, List[str]]: For a single file from file mapping, returns its content as a string.
-                                  For multiple files or directory mapping, returns a list of contents.
-
-        Raises:
-            ValueError: If the list is empty
+                                  For multiple files, directory mapping, or empty list, returns a list of contents.
         """
-        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")
+                return []
+
+            # 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]]:
@@ -87,16 +109,27 @@ class FileInfoList(List[FileInfo]):
 
         Returns:
             Union[str, List[str]]: For a single file from file mapping, returns its path as a string.
-                                  For multiple files or directory mapping, returns a list of paths.
-
-        Raises:
-            ValueError: If the list is empty
+                                  For multiple files, directory mapping, or empty list, returns a list of paths.
         """
-        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:
+                return []
+            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 +142,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 +173,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 +213,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 +230,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 +257,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()