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

ostruct/cli/cli.py

@@ -206,7 +206,6 @@ def _get_type_with_constraints(
     Returns:
         Tuple of (type, field)
     """
-    field_type = field_schema.get("type")
     field_kwargs: Dict[str, Any] = {}
 
     # Add common field metadata
@@ -219,21 +218,40 @@ def _get_type_with_constraints(
     if "readOnly" in field_schema:
         field_kwargs["frozen"] = field_schema["readOnly"]
 
+    field_type = field_schema.get("type")
+
     # Handle array type
     if field_type == "array":
         items_schema = field_schema.get("items", {})
         if not items_schema:
             return (List[Any], Field(**field_kwargs))
 
-        # Create nested model with explicit type annotation
-        array_item_model = create_dynamic_model(
-            items_schema,
-            base_name=f"{base_name}_{field_name}_Item",
-            show_schema=False,
-            debug_validation=False,
-        )
-        array_type: Type[List[Any]] = List[array_item_model]  # type: ignore[valid-type]
-        return (array_type, Field(**field_kwargs))
+        # Create nested model for object items
+        if (
+            isinstance(items_schema, dict)
+            and items_schema.get("type") == "object"
+        ):
+            array_item_model = create_dynamic_model(
+                items_schema,
+                base_name=f"{base_name}_{field_name}_Item",
+                show_schema=False,
+                debug_validation=False,
+            )
+            array_type: Type[List[Any]] = List[array_item_model]  # type: ignore[valid-type]
+            return (array_type, Field(**field_kwargs))
+
+        # For non-object items, use the type directly
+        item_type = items_schema.get("type", "string")
+        if item_type == "string":
+            return (List[str], Field(**field_kwargs))
+        elif item_type == "integer":
+            return (List[int], Field(**field_kwargs))
+        elif item_type == "number":
+            return (List[float], Field(**field_kwargs))
+        elif item_type == "boolean":
+            return (List[bool], Field(**field_kwargs))
+        else:
+            return (List[Any], Field(**field_kwargs))
 
     # Handle object type
     if field_type == "object":
@@ -936,11 +954,7 @@ def create_template_context(
     # Add file variables
     if files:
         for name, file_list in files.items():
-            # For single files, extract the first FileInfo object
-            if len(file_list) == 1:
-                context[name] = file_list[0]
-            else:
-                context[name] = file_list
+            context[name] = file_list  # Always keep FileInfoList wrapper
 
     # Add simple variables
     if variables:
@@ -1828,13 +1842,17 @@ def create_dynamic_model(
                 logger.info("Schema missing type field, assuming object type")
             schema["type"] = "object"
 
-        # Validate root schema is object type
+        # For non-object root schemas, create a wrapper model
         if schema["type"] != "object":
             if debug_validation:
-                logger.error(
-                    "Schema type must be 'object', got %s", schema["type"]
+                logger.info(
+                    "Converting non-object root schema to object wrapper"
                 )
-            raise SchemaValidationError("Root schema must be of type 'object'")
+            schema = {
+                "type": "object",
+                "properties": {"value": schema},
+                "required": ["value"],
+            }
 
         # Create model configuration
         config = ConfigDict(

ostruct/cli/file_info.py

@@ -46,6 +46,8 @@ class FileInfo:
             FileNotFoundError: If the file does not exist
             PathSecurityError: If the path is not allowed
         """
+        logger.debug("Creating FileInfo for path: %s", path)
+
         # Validate path
         if not path:
             raise ValueError("Path cannot be empty")
@@ -61,6 +63,8 @@ class FileInfo:
 
         # 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):
@@ -69,7 +73,10 @@ class FileInfo:
         # Then validate security
         try:
             # This will raise PathSecurityError if path is not allowed
-            self.abs_path
+            resolved_path = self.abs_path
+            logger.debug(
+                "Security-resolved path for %s: %s", path, resolved_path
+            )
         except PathSecurityError:
             raise
         except Exception as e:
@@ -77,6 +84,7 @@ class FileInfo:
 
         # 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()
 
     @property

ostruct/cli/file_list.py

@@ -1,11 +1,14 @@
 """FileInfoList implementation providing smart file content access."""
 
-from typing import List, Union
+import logging
+from typing import Iterator, List, SupportsIndex, Union, overload
 
 from .file_info import FileInfo
 
 __all__ = ["FileInfoList", "FileInfo"]
 
+logger = logging.getLogger(__name__)
+
 
 class FileInfoList(List[FileInfo]):
     """List of FileInfo objects with smart content access.
@@ -44,6 +47,11 @@ class FileInfoList(List[FileInfo]):
             files: List of FileInfo objects
             from_dir: Whether this list was created from a directory mapping
         """
+        logger.debug(
+            "Creating FileInfoList with %d files, from_dir=%s",
+            len(files),
+            from_dir,
+        )
         super().__init__(files)
         self._from_dir = from_dir
 
@@ -59,9 +67,18 @@ class FileInfoList(List[FileInfo]):
             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:
+            logger.debug(
+                "FileInfoList.content returning single file content (not 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]
 
     @property
@@ -149,3 +166,42 @@ class FileInfoList(List[FileInfo]):
             str: Same as str() for consistency
         """
         return str(self)
+
+    def __iter__(self) -> Iterator[FileInfo]:
+        """Return iterator over files."""
+        logger.debug(
+            "Starting iteration over FileInfoList with %d files", len(self)
+        )
+        return super().__iter__()
+
+    def __len__(self) -> int:
+        """Return number of files."""
+        return super().__len__()
+
+    def __bool__(self) -> bool:
+        """Return True if there are files."""
+        return super().__len__() > 0
+
+    @overload
+    def __getitem__(self, index: SupportsIndex, /) -> FileInfo: ...
+
+    @overload
+    def __getitem__(self, index: slice, /) -> "FileInfoList": ...
+
+    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):
+                raise TypeError(
+                    f"Expected list from slice, 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

ostruct/cli/file_utils.py

@@ -132,7 +132,7 @@ def collect_files_from_pattern(
         return []
 
     # Create FileInfo objects
-    files = []
+    files: List[FileInfo] = []
     for path in matched_paths:
         try:
             file_info = FileInfo.from_path(path, security_manager)
@@ -169,37 +169,77 @@ def collect_files_from_directory(
         DirectoryNotFoundError: If directory does not exist
         PathSecurityError: If directory is not allowed
     """
+    logger.debug(
+        "Collecting files from directory: %s (recursive=%s, extensions=%s)",
+        directory,
+        recursive,
+        allowed_extensions,
+    )
+
     # Validate directory exists and is allowed
     try:
         abs_dir = str(security_manager.resolve_path(directory))
-    except PathSecurityError:
+        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
+        )
+    except PathSecurityError as e:
+        logger.debug("PathSecurityError while resolving directory: %s", str(e))
         # Let the original error propagate
         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
+        )
         raise DirectoryNotFoundError(f"Path is not a directory: {directory}")
 
     # Collect files
-    files = []
-    for root, _, filenames in os.walk(abs_dir):
+    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
 
+        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)
-            except ValueError:
+                logger.debug("Processing file: %s -> %s", abs_path, rel_path)
+            except ValueError as e:
                 # Skip files that can't be made relative
+                logger.debug(
+                    "Skipping file that can't be made relative: %s (error: %s)",
+                    abs_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 non-matching extension: %s (ext=%s, allowed=%s)",
+                        filename,
+                        ext,
+                        allowed_extensions,
+                    )
                     continue
 
             try:
@@ -207,10 +247,17 @@ def collect_files_from_directory(
                     rel_path, security_manager=security_manager, **kwargs
                 )
                 files.append(file_info)
-            except (FileNotFoundError, PathSecurityError):
+                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
 
+    logger.debug("Collected %d files from directory %s", len(files), directory)
     return files
 
 
@@ -272,18 +319,38 @@ def collect_files(
         PathSecurityError: If a path is outside the base directory
         DirectoryNotFoundError: If a directory is not found
     """
+    logger.debug(
+        "Collecting files (recursive=%s, extensions=%s):\n  files=%s\n  patterns=%s\n  dirs=%s",
+        dir_recursive,
+        dir_extensions,
+        file_mappings,
+        pattern_mappings,
+        dir_mappings,
+    )
+
     if security_manager is None:
         security_manager = SecurityManager(base_dir=os.getcwd())
+        logger.debug(
+            "Created default security manager with base_dir=%s", os.getcwd()
+        )
+    else:
+        logger.debug(
+            "Using provided security manager with base_dir=%s and allowed_dirs=%s",
+            security_manager.base_dir,
+            security_manager.allowed_dirs,
+        )
 
     # Normalize extensions by removing leading dots
     if dir_extensions:
         dir_extensions = [ext.lstrip(".") for ext in dir_extensions]
+        logger.debug("Normalized extensions: %s", dir_extensions)
 
     files: Dict[str, FileInfoList] = {}
 
     # Process file mappings
     if file_mappings:
         for mapping in file_mappings:
+            logger.debug("Processing file mapping: %s", mapping)
             name, path = _validate_and_split_mapping(mapping, "file")
             if name in files:
                 raise ValueError(f"Duplicate file mapping: {name}")
@@ -292,10 +359,12 @@ def collect_files(
                 path, security_manager=security_manager, **kwargs
             )
             files[name] = FileInfoList([file_info], from_dir=False)
+            logger.debug("Added single file mapping: %s -> %s", name, path)
 
     # Process pattern mappings
     if pattern_mappings:
         for mapping in pattern_mappings:
+            logger.debug("Processing pattern mapping: %s", mapping)
             name, pattern = _validate_and_split_mapping(mapping, "pattern")
             if name in files:
                 raise ValueError(f"Duplicate pattern mapping: {name}")
@@ -305,6 +374,7 @@ def collect_files(
                     pattern, security_manager=security_manager, **kwargs
                 )
             except PathSecurityError as e:
+                logger.debug("Security error in pattern mapping: %s", str(e))
                 raise PathSecurityError(
                     "Pattern mapping error: Access denied: "
                     f"{pattern} is outside base directory and not in allowed directories"
@@ -315,14 +385,24 @@ def collect_files(
                 continue
 
             files[name] = FileInfoList(matched_files, from_dir=False)
+            logger.debug(
+                "Added pattern mapping: %s -> %s (%d files)",
+                name,
+                pattern,
+                len(matched_files),
+            )
 
     # Process directory mappings
     if dir_mappings:
         for mapping in dir_mappings:
+            logger.debug("Processing directory mapping: %s", mapping)
             name, directory = _validate_and_split_mapping(mapping, "directory")
             if name in files:
                 raise ValueError(f"Duplicate directory mapping: {name}")
 
+            logger.debug(
+                "Processing directory mapping: %s -> %s", name, directory
+            )
             try:
                 dir_files = collect_files_from_directory(
                     directory=directory,
@@ -332,11 +412,13 @@ def collect_files(
                     **kwargs,
                 )
             except PathSecurityError as e:
+                logger.debug("Security error in directory mapping: %s", str(e))
                 raise PathSecurityError(
                     "Directory mapping error: Access denied: "
                     f"{directory} is outside base directory and not in allowed directories"
                 ) from e
-            except DirectoryNotFoundError:
+            except DirectoryNotFoundError as e:
+                logger.debug("Directory not found: %s", str(e))
                 raise DirectoryNotFoundError(
                     f"Directory not found: {directory}"
                 )
@@ -346,10 +428,18 @@ def collect_files(
                 files[name] = FileInfoList([], from_dir=True)
             else:
                 files[name] = FileInfoList(dir_files, from_dir=True)
+                logger.debug(
+                    "Added directory mapping: %s -> %s (%d files)",
+                    name,
+                    directory,
+                    len(dir_files),
+                )
 
     if not files:
+        logger.debug("No files found in any mappings")
         raise ValueError("No files found")
 
+    logger.debug("Collected files total mappings: %d", len(files))
     return files
 
 

ostruct/cli/security.py

@@ -96,10 +96,15 @@ class SecurityManager(SecurityManagerProtocol):
         All paths are normalized using realpath to handle symlinks
         and relative paths consistently across platforms.
         """
+        logger = logging.getLogger("ostruct")
+        logger.debug("Initializing SecurityManager")
         self._base_dir = Path(os.path.realpath(base_dir or os.getcwd()))
+        logger.debug("Base directory set to: %s", self._base_dir)
+
         self._allowed_dirs: Set[Path] = set()
         if allowed_dirs:
             for directory in allowed_dirs:
+                logger.debug("Adding allowed directory: %s", directory)
                 self.add_allowed_dir(directory)
 
     @property
@@ -121,14 +126,21 @@ class SecurityManager(SecurityManagerProtocol):
         Raises:
             DirectoryNotFoundError: If directory does not exist
         """
+        logger = logging.getLogger("ostruct")
+        logger.debug("Adding allowed directory: %s", directory)
         real_path = Path(os.path.realpath(directory))
+        logger.debug("Resolved real path: %s", real_path)
+
         if not real_path.exists():
+            logger.debug("Directory not found: %s", directory)
             raise DirectoryNotFoundError(f"Directory not found: {directory}")
         if not real_path.is_dir():
+            logger.debug("Path is not a directory: %s", directory)
             raise DirectoryNotFoundError(
                 f"Path is not a directory: {directory}"
             )
         self._allowed_dirs.add(real_path)
+        logger.debug("Successfully added allowed directory: %s", real_path)
 
     def add_allowed_dirs_from_file(self, file_path: str) -> None:
         """Add allowed directories from a file.

ostruct/cli/template_extensions.py

@@ -9,7 +9,7 @@ from jinja2.ext import Extension
 from jinja2.parser import Parser
 
 
-class CommentExtension(Extension):  # type: ignore[misc]
+class CommentExtension(Extension):
     """Extension that ignores variables inside comment blocks.
 
     This extension ensures that:

ostruct/cli/template_rendering.py

@@ -300,14 +300,6 @@ def render_template(
                     "=== Rendered result (first 1000 chars) ===\n%s",
                     result[:1000],
                 )
-                if "## File:" not in result:
-                    logger.error(
-                        "WARNING: File headers missing from rendered output!"
-                    )
-                    logger.error(
-                        "Template string excerpt: %r", template_str[:200]
-                    )
-                    logger.error("Result excerpt: %r", result[:200])
                 if progress:
                     progress.update(1)
                 return result  # type: ignore[no-any-return]

ostruct/cli/template_validation.py

@@ -87,7 +87,7 @@ __all__ = [
 ]
 
 
-class SafeUndefined(jinja2.StrictUndefined):  # type: ignore[misc]
+class SafeUndefined(jinja2.StrictUndefined):
     """A strict Undefined class that validates attribute access during validation."""
 
     def __getattr__(self, name: str) -> Any:

{ostruct_cli-0.1.4.dist-info → ostruct_cli-0.2.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: ostruct-cli
-Version: 0.1.4
+Version: 0.2.0
 Summary: CLI for OpenAI Structured Output
 Author: Yaniv Golan
 Author-email: yaniv@golan.name

{ostruct_cli-0.1.4.dist-info → ostruct_cli-0.2.0.dist-info}/RECORD

@@ -1,27 +1,27 @@
 ostruct/__init__.py,sha256=X6zo6V7ZNMv731Wi388aTVQngD1410ExGwGx4J6lpyo,187
 ostruct/cli/__init__.py,sha256=dbdUfKRT4ARSHgjsZOmQ-TJT1mHwL7L3xMuilPkhG4Q,411
 ostruct/cli/cache_manager.py,sha256=ej3KrRfkKKZ_lEp2JswjbJ5bW2ncsvna9NeJu81cqqs,5192
-ostruct/cli/cli.py,sha256=uDh7-_pGXgiq2AMo4vDuNMotk5HNIIki_FJFWb2LWTY,69529
+ostruct/cli/cli.py,sha256=jJ60txGOA4ju-4Z057FA8eRnrpxTHDLBn6bZLNsJy9Q,70170
 ostruct/cli/errors.py,sha256=vxfjXpUbsarYJoTBaGFpjpa8wXqOMGQryTh-roUhRuU,9454
-ostruct/cli/file_info.py,sha256=jjsLVDD8YMpVryBzKVdoQsjE33PLA1BBTVqH3VOHbuA,10167
-ostruct/cli/file_list.py,sha256=jTtqNo05GT4m4TpEpd3MT9ZlueH_sQgcjHiERRbt-IY,5217
-ostruct/cli/file_utils.py,sha256=NLbYIum2vB3SOPrG5hsE4Djg5WeStRppIX2v7L1Y9Dg,17404
+ostruct/cli/file_info.py,sha256=SdU_V5g4R0o41tOTlobOF5cibZfb9qS12fK7G2XNfRs,10481
+ostruct/cli/file_list.py,sha256=srrouvhimoklNo69nWjrKyUN-5zTOmtVj_swdBZPBTk,7105
+ostruct/cli/file_utils.py,sha256=uqEvRoWskzKUd5akA-NtdKtLWByKMTXOiVJiiO7uXus,21153
 ostruct/cli/path_utils.py,sha256=jhJsvmxsq0_FU5cWwB-JoEymGbvB2JX9Q0a-dUf0s1w,4461
 ostruct/cli/progress.py,sha256=rj9nVEco5UeZORMbzd7mFJpFGJjbH9KbBFh5oTE5Anw,3415
-ostruct/cli/security.py,sha256=8X3eiK9XN1Fcw6TQ5hxfEb-Dt0vF21vdoXpxr5p-Aos,10332
+ostruct/cli/security.py,sha256=j7oRb7UM_Mndl_CvnQlql8eyudcAVgfCkeQuXIQyME4,10945
 ostruct/cli/security_types.py,sha256=oSNbaKjhZVHB6pQEG_WOUhUYKlw9cl4uGOBx2R9BxRk,1341
 ostruct/cli/template_env.py,sha256=S2ZvxuMQMicodSVqUhrw0kOzbNmlpQjSHtWlOwjXCms,1538
-ostruct/cli/template_extensions.py,sha256=jGj8nKKyWOaN4u271N9luDNZAZ60xGu17qalf9ybibc,1645
+ostruct/cli/template_extensions.py,sha256=tJN3HGAS2yzGI8Up6STPday8NVL0VV6UCClBrtDKYr0,1623
 ostruct/cli/template_filters.py,sha256=SNp7PR4ZbuC9BVUlEgwzd6VZYjI0lsobTabLiJe_sZM,19030
 ostruct/cli/template_io.py,sha256=6rDw2Wx6czK1VntKGUM6cvyMbMWojt41hUlYRpfQuoc,8749
-ostruct/cli/template_rendering.py,sha256=JcxwVppl2Q6dNsH_pAv4hW3LH2if76cvgwrh-VNPpL8,12769
+ostruct/cli/template_rendering.py,sha256=GrQAcKpGe6QEjSVQkOjpegMcor9LzVUikGmmEVgiWCE,12391
 ostruct/cli/template_schema.py,sha256=ckH4rUZnEgfm_BHS9LnMGr8LtDxRmZ0C6UBVrSp8KTc,19604
 ostruct/cli/template_utils.py,sha256=QGgewxU_Tgn81J5U-Y4xfi67CkN2dEqXI7PsaNiI9es,7812
-ostruct/cli/template_validation.py,sha256=ygM_37Cqd2RfOugf9PmhS-Z3WFwDvjPhduB7-C2LMfw,11759
+ostruct/cli/template_validation.py,sha256=q3ACw4TscdekJb3Z3CTYw0YPEYttqjKjm74ap4lWtU4,11737
 ostruct/cli/utils.py,sha256=1UCl4rHjBWKR5EKugvlVGHiHjO3XXmqvkgeAUSyIPDU,831
 ostruct/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-ostruct_cli-0.1.4.dist-info/LICENSE,sha256=QUOY6QCYVxAiH8vdrUTDqe3i9hQ5bcNczppDSVpLTjk,1068
-ostruct_cli-0.1.4.dist-info/METADATA,sha256=N5YTPqzaX97RPeh1IssYTi9pCIY0lW1GwC11GHX2Jdw,5300
-ostruct_cli-0.1.4.dist-info/WHEEL,sha256=IYZQI976HJqqOpQU6PHkJ8fb3tMNBFjg-Cn-pwAbaFM,88
-ostruct_cli-0.1.4.dist-info/entry_points.txt,sha256=NFq9IuqHVTem0j9zKjV8C1si_zGcP1RL6Wbvt9fUDXw,48
-ostruct_cli-0.1.4.dist-info/RECORD,,
+ostruct_cli-0.2.0.dist-info/LICENSE,sha256=QUOY6QCYVxAiH8vdrUTDqe3i9hQ5bcNczppDSVpLTjk,1068
+ostruct_cli-0.2.0.dist-info/METADATA,sha256=uduwQEF87qBeSBhzFg9AWdFqnDM1TdRyvdRwq-IKqZQ,5300
+ostruct_cli-0.2.0.dist-info/WHEEL,sha256=IYZQI976HJqqOpQU6PHkJ8fb3tMNBFjg-Cn-pwAbaFM,88
+ostruct_cli-0.2.0.dist-info/entry_points.txt,sha256=NFq9IuqHVTem0j9zKjV8C1si_zGcP1RL6Wbvt9fUDXw,48
+ostruct_cli-0.2.0.dist-info/RECORD,,