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

ostruct/cli/file_info.py

@@ -5,7 +5,7 @@ import logging
 import os
 from typing import Any, Optional
 
-from .errors import FileNotFoundError, PathSecurityError
+from .errors import FileNotFoundError, FileReadError, PathSecurityError
 from .security import SecurityManager
 
 logger = logging.getLogger(__name__)
@@ -45,6 +45,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 +54,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,31 +62,67 @@ class FileInfo:
         self.__size: Optional[int] = None
         self.__mtime: Optional[float] = None
 
-        # First check if file exists
-        abs_path = os.path.abspath(self.__path)
-        logger.debug("Absolute path for %s: %s", path, abs_path)
-
-        if not os.path.exists(abs_path):
-            raise FileNotFoundError(f"File not found: {path}")
-        if not os.path.isfile(abs_path):
-            raise FileNotFoundError(f"Path is not a file: {path}")
-
-        # Then validate security
         try:
             # This will raise PathSecurityError if path is not allowed
-            resolved_path = self.abs_path
+            # 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
             )
-        except PathSecurityError:
+
+            # Check if it's a regular file (not a directory, device, etc.)
+            if not resolved_path.is_file():
+                logger.debug("Not a regular file: %s", resolved_path)
+                raise FileNotFoundError(
+                    f"Not a regular file: {os.path.basename(str(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
-        except Exception as e:
-            raise FileNotFoundError(f"Invalid file path: {e}")
 
-        # 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 FileNotFoundError as e:
+            # Re-raise with standardized message format
+            logger.debug("File not found error: %s", e)
+            raise FileNotFoundError(
+                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:
@@ -141,7 +178,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
@@ -157,7 +195,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
@@ -170,10 +209,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
@@ -183,10 +237,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
@@ -208,35 +272,51 @@ class FileInfo:
         """Prevent setting hash directly."""
         raise AttributeError("Cannot modify hash directly")
 
-    def _read_file(self) -> None:
-        """Read file content and encoding from disk."""
+    @property
+    def exists(self) -> bool:
+        """Check if the file exists.
+
+        Returns:
+            bool: True if the file exists, False otherwise
+        """
         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
+            return os.path.exists(self.abs_path)
+        except (OSError, PathSecurityError):
+            return False
 
-        # Try UTF-8 first
+    @property
+    def is_binary(self) -> bool:
+        """Check if the file appears to be binary.
+
+        Returns:
+            bool: True if the file appears to be binary, False otherwise
+        """
         try:
-            self.__content = raw_content.decode("utf-8")
-            self.__encoding = "utf-8"
-            return
-        except UnicodeDecodeError:
-            pass
+            with open(self.abs_path, "rb") as f:
+                chunk = f.read(1024)
+                return b"\0" in chunk
+        except (OSError, PathSecurityError):
+            return False
 
-        # Fall back to system default encoding
+    def _read_file(self) -> None:
+        """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:
-            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
+            with open(self.abs_path, "rb") as f:
+                raw_content = f.read()
+            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,
@@ -322,3 +402,27 @@ class FileInfo:
             )
         finally:
             del frame  # Avoid reference cycles
+
+    def to_dict(self) -> dict[str, Any]:
+        """Convert file info to a dictionary.
+
+        Returns:
+            Dictionary containing file metadata and content
+        """
+        # Get file stats
+        stats = os.stat(self.abs_path)
+
+        return {
+            "path": self.path,
+            "abs_path": str(self.abs_path),
+            "exists": self.exists,
+            "size": self.size,
+            "content": self.content,
+            "encoding": self.encoding,
+            "hash": self.hash,
+            "mtime": self.mtime,
+            "mtime_ns": (
+                int(self.mtime * 1e9) if self.mtime is not None else None
+            ),
+            "mode": stats.st_mode,
+        }

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()