byteit 1.2.0__tar.gz → 1.3.0__tar.gz

{byteit-1.2.0 → byteit-1.3.0}/CHANGELOG.md

@@ -7,6 +7,16 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [1.3.0] - 2026-07-29
+
+### Added
+- `ParseType.HANDWRITTEN` (`"handwritten"`) parse mode for handwritten documents.
+
+### Changed
+- Renamed `ExtractionType` to `ParseType`.
+- Renamed `ProcessingOptions.extraction_type` to `ProcessingOptions.parse_type`
+  (API payload key is now `parse_type`).
+
 ## [1.2.0] - 2026-07-28
 
 ### Added

{byteit-1.2.0/byteit.egg-info → byteit-1.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: byteit
-Version: 1.2.0
+Version: 1.3.0
 Summary: AI-powered document intelligence platform - Turn your data into structured data with a single line of code.
 Author-email: ByteIT GmbH <support@byteit.ai>
 License: Apache-2.0
@@ -302,7 +302,7 @@ result = client.parse(
     processing_options={
         "languages": ["de", "en"],
         "page_range": "1-5",
-        "extraction_type": "complex",
+        "parse_type": "complex",
     },
 )
 ```
@@ -313,7 +313,7 @@ Supported fields:
 |---|---|---|---|
 | `languages` | `list[str]` | `["en"]` | Language codes for OCR/parsing |
 | `page_range` | `str` | `""` (all pages) | Pages to process, e.g. `"1-5"` or `"1,3,5"` |
-| `extraction_type` | `str` | `"auto"` | One of `"auto"`, `"complex"`, `"ocr"`, etc. |
+| `parse_type` | `str` | `"auto"` | One of `"auto"`, `"complex"`, `"handwritten"` |
 | `image_annotations` | `bool` | `False` | Enable image annotation extraction |
 | `force_image_annotations` | `bool` | `False` | Force annotation extraction even when the image is detected as useless |
 | `table_enrichment` | `bool` | `False` | Enable table enrichment |

{byteit-1.2.0 → byteit-1.3.0}/README.md

@@ -264,7 +264,7 @@ result = client.parse(
     processing_options={
         "languages": ["de", "en"],
         "page_range": "1-5",
-        "extraction_type": "complex",
+        "parse_type": "complex",
     },
 )
 ```
@@ -275,7 +275,7 @@ Supported fields:
 |---|---|---|---|
 | `languages` | `list[str]` | `["en"]` | Language codes for OCR/parsing |
 | `page_range` | `str` | `""` (all pages) | Pages to process, e.g. `"1-5"` or `"1,3,5"` |
-| `extraction_type` | `str` | `"auto"` | One of `"auto"`, `"complex"`, `"ocr"`, etc. |
+| `parse_type` | `str` | `"auto"` | One of `"auto"`, `"complex"`, `"handwritten"` |
 | `image_annotations` | `bool` | `False` | Enable image annotation extraction |
 | `force_image_annotations` | `bool` | `False` | Force annotation extraction even when the image is detected as useless |
 | `table_enrichment` | `bool` | `False` | Enable table enrichment |

{byteit-1.2.0 → byteit-1.3.0}/byteit/ByteITClient.py

@@ -160,7 +160,7 @@ class ByteITClient:
             output: Optional file path to save the result to disk.
             processing_options: ProcessingOptions or dict with keys:
                 ``languages`` (list[str]), ``page_range`` (str), and
-                ``extraction_type`` (str or ExtractionType).
+                ``parse_type`` (str or ParseType).
                 ``image_annotations`` (bool), ``force_image_annotations`` (bool),
                 ``table_enrichment`` (bool)
             output_format: Optional output format override. When omitted, the
@@ -230,7 +230,7 @@ class ByteITClient:
                 paths.
             processing_options: ProcessingOptions or dict with keys:
                 ``languages`` (list[str]), ``page_range`` (str), and
-                ``extraction_type`` (str or ExtractionType).
+                ``parse_type`` (str or ParseType).
             queue_for_batch: When ``True``, the job is queued for batch
                 processing at a reduced credit cost. Processing is not
                 immediate.

{byteit-1.2.0 → byteit-1.3.0}/byteit/__init__.py

@@ -28,13 +28,13 @@ from .models.CustomJob import CustomJob
 from .models.CustomJobList import CustomJobList
 from .models.DocumentMetadata import DocumentMetadata
 from .models.DocumentType import DocumentType
-from .models.ExtractionType import ExtractionType
 from .models.ExtractJob import ExtractJob
 from .models.ExtractJobList import ExtractJobList
 from .models.JobList import JobList
 from .models.JobStatus import JobStatus
 from .models.OutputFormat import OutputFormat
 from .models.ParseJob import ParseJob
+from .models.ParseType import ParseType
 from .models.ProcessingOptions import ProcessingOptions
 from .models.SavedSchema import SavedSchema
 from .models.SavedSchemaList import SavedSchemaList
@@ -49,7 +49,7 @@ except ImportError:
 try:
     __version__ = version("byteit")
 except PackageNotFoundError:
-    __version__ = "1.2.0"  # fallback, keep in sync with pyproject.toml
+    __version__ = "1.3.0"  # fallback, keep in sync with pyproject.toml
 
 try:
     from .models.ExtractionSchema import ExtractionSchema  # noqa: F401
@@ -104,7 +104,7 @@ __all__ = [
     "DocumentMetadata",
     "DocumentType",
     "ProcessingOptions",
-    "ExtractionType",
+    "ParseType",
     "ExtractJob",
     "ExtractJobList",
     "OutputFormat",

byteit-1.3.0/byteit/models/ParseType.py

@@ -0,0 +1,11 @@
+"""Document parse type value object."""
+
+from enum import Enum
+
+
+class ParseType(Enum):
+    """Document parse type enumeration."""
+
+    AUTO = "auto"
+    COMPLEX = "complex"
+    HANDWRITTEN = "handwritten"

{byteit-1.2.0 → byteit-1.3.0}/byteit/models/ProcessingOptions.py

@@ -3,7 +3,7 @@
 from dataclasses import dataclass, field
 from typing import Any
 
-from byteit.models.ExtractionType import ExtractionType
+from byteit.models.ParseType import ParseType
 
 
 def _default_list() -> list[str]:
@@ -24,7 +24,7 @@ class ProcessingOptions:
         force_image_annotations: Force image annotation extraction even when
             image is detected as useless
         table_enrichment: Enable table enrichment
-        extraction_type: Extraction mode used by the backend parser
+        parse_type: Parse mode used by the backend parser
     """
 
     languages: list[str] = field(default_factory=_default_list)
@@ -32,26 +32,26 @@ class ProcessingOptions:
     image_annotations: bool = field(default=False)
     force_image_annotations: bool = field(default=False)
     table_enrichment: bool = field(default=False)
-    extraction_type: ExtractionType | str = field(default=ExtractionType.AUTO)
+    parse_type: ParseType | str = field(default=ParseType.AUTO)
 
     @staticmethod
-    def _parse_extraction_type(
-        extraction_type: ExtractionType | str,
-    ) -> ExtractionType:
-        """Parse extraction type into an enum value."""
-        if isinstance(extraction_type, ExtractionType):
-            return extraction_type
-
-        normalized_extraction_type = extraction_type.lower()
-        for value in ExtractionType:
-            if value.value == normalized_extraction_type:
+    def _parse_parse_type(
+        parse_type: ParseType | str,
+    ) -> ParseType:
+        """Parse parse type into an enum value."""
+        if isinstance(parse_type, ParseType):
+            return parse_type
+
+        normalized_parse_type = parse_type.lower()
+        for value in ParseType:
+            if value.value == normalized_parse_type:
                 return value
 
-        raise ValueError(f"Invalid extraction type: {extraction_type}")
+        raise ValueError(f"Invalid parse type: {parse_type}")
 
     def __post_init__(self) -> None:
         """Normalize processing option values after initialization."""
-        self.extraction_type = self._parse_extraction_type(self.extraction_type)
+        self.parse_type = self._parse_parse_type(self.parse_type)
 
         if self.force_image_annotations:
             self.image_annotations = True
@@ -79,7 +79,7 @@ class ProcessingOptions:
         if self.table_enrichment:
             result["table_enrichment"] = self.table_enrichment
 
-        result["extraction_type"] = self.extraction_type.value
+        result["parse_type"] = self.parse_type.value
 
         return result
 
@@ -98,7 +98,7 @@ class ProcessingOptions:
         image_annotations = data.get("image_annotations", False)
         force_image_annotations = data.get("force_image_annotations", False)
         table_enrichment = data.get("table_enrichment", False)
-        extraction_type = data.get("extraction_type", ExtractionType.AUTO)
+        parse_type = data.get("parse_type", ParseType.AUTO)
 
         return cls(
             languages=languages,
@@ -106,5 +106,5 @@ class ProcessingOptions:
             image_annotations=image_annotations,
             force_image_annotations=force_image_annotations,
             table_enrichment=table_enrichment,
-            extraction_type=extraction_type,
+            parse_type=parse_type,
         )

{byteit-1.2.0 → byteit-1.3.0}/byteit/models/__init__.py

@@ -4,13 +4,13 @@ from .CustomJob import CustomJob
 from .CustomJobList import CustomJobList
 from .DocumentMetadata import DocumentMetadata
 from .DocumentType import DocumentType
-from .ExtractionType import ExtractionType
 from .ExtractJob import ExtractJob
 from .ExtractJobList import ExtractJobList
 from .JobList import JobList
 from .JobStatus import JobStatus
 from .OutputFormat import OutputFormat
 from .ParseJob import ParseJob
+from .ParseType import ParseType
 from .ProcessingOptions import ProcessingOptions
 from .SavedSchema import SavedSchema
 from .SavedSchemaList import SavedSchemaList
@@ -22,12 +22,11 @@ __all__ = [
     "DocumentType",
     "ExtractJob",
     "ExtractJobList",
-    "ExtractionType",
-    "ExtractionType",
     "JobList",
     "JobStatus",
     "OutputFormat",
     "ParseJob",
+    "ParseType",
     "ProcessingOptions",
     "SavedSchema",
     "SavedSchemaList",

{byteit-1.2.0 → byteit-1.3.0}/byteit/validations.py

@@ -11,7 +11,7 @@ VALID_PROCESSING_OPTIONS: set[str] = {
     "image_annotations",
     "force_image_annotations",
     "table_enrichment",
-    "extraction_type",
+    "parse_type",
 }
 
 # Multi-file upload limits. Mirror the backend

{byteit-1.2.0 → byteit-1.3.0/byteit.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: byteit
-Version: 1.2.0
+Version: 1.3.0
 Summary: AI-powered document intelligence platform - Turn your data into structured data with a single line of code.
 Author-email: ByteIT GmbH <support@byteit.ai>
 License: Apache-2.0
@@ -302,7 +302,7 @@ result = client.parse(
     processing_options={
         "languages": ["de", "en"],
         "page_range": "1-5",
-        "extraction_type": "complex",
+        "parse_type": "complex",
     },
 )
 ```
@@ -313,7 +313,7 @@ Supported fields:
 |---|---|---|---|
 | `languages` | `list[str]` | `["en"]` | Language codes for OCR/parsing |
 | `page_range` | `str` | `""` (all pages) | Pages to process, e.g. `"1-5"` or `"1,3,5"` |
-| `extraction_type` | `str` | `"auto"` | One of `"auto"`, `"complex"`, `"ocr"`, etc. |
+| `parse_type` | `str` | `"auto"` | One of `"auto"`, `"complex"`, `"handwritten"` |
 | `image_annotations` | `bool` | `False` | Enable image annotation extraction |
 | `force_image_annotations` | `bool` | `False` | Force annotation extraction even when the image is detected as useless |
 | `table_enrichment` | `bool` | `False` | Enable table enrichment |

{byteit-1.2.0 → byteit-1.3.0}/byteit.egg-info/SOURCES.txt

@@ -30,20 +30,20 @@ byteit/models/DocumentType.py
 byteit/models/ExtractJob.py
 byteit/models/ExtractJobList.py
 byteit/models/ExtractionSchema.py
-byteit/models/ExtractionType.py
 byteit/models/JobList.py
 byteit/models/JobStatus.py
 byteit/models/OutputFormat.py
 byteit/models/ParseJob.py
+byteit/models/ParseType.py
 byteit/models/ProcessingOptions.py
 byteit/models/SavedSchema.py
 byteit/models/SavedSchemaList.py
 byteit/models/__init__.py
-tests/__init__.py
-tests/test_client.py
-tests/test_connectors.py
-tests/test_exceptions.py
-tests/test_integration.py
-tests/test_models.py
-tests/test_package_init.py
-tests/test_progress.py
+tests/unit/__init__.py
+tests/unit/test_client.py
+tests/unit/test_connectors.py
+tests/unit/test_exceptions.py
+tests/unit/test_integration.py
+tests/unit/test_models.py
+tests/unit/test_package_init.py
+tests/unit/test_progress.py

{byteit-1.2.0 → byteit-1.3.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "byteit"
-version = "1.2.0"
+version = "1.3.0"
 description = "AI-powered document intelligence platform - Turn your data into structured data with a single line of code."
 readme = "README.md"
 requires-python = ">=3.8"

{byteit-1.2.0/tests → byteit-1.3.0/tests/unit}/test_client.py

@@ -9,6 +9,7 @@ import requests
 from pydantic import Field
 
 from byteit import ByteITClient
+from byteit._rate_limit import RateLimitedSubmitter
 from byteit.connectors import LocalFileInputConnector
 from byteit.exceptions import (
     APIKeyError,
@@ -20,10 +21,10 @@ from byteit.exceptions import (
     ValidationError,
 )
 from byteit.models.ExtractionSchema import ExtractionSchema
-from byteit.models.ExtractionType import ExtractionType
 from byteit.models.ExtractJob import ExtractJob
 from byteit.models.OutputFormat import OutputFormat
 from byteit.models.ParseJob import ParseJob
+from byteit.models.ParseType import ParseType
 from byteit.models.ProcessingOptions import ProcessingOptions
 from byteit.models.SavedSchema import SavedSchema
 from byteit.models.SavedSchemaList import SavedSchemaList
@@ -289,7 +290,7 @@ class TestDownloadParseResult:
 class TestCreateJob:
     """Test _create_job method."""
 
-    @patch.object(ByteITClient, "_request")
+    @patch.object(RateLimitedSubmitter, "_request")
     @patch.object(ByteITClient, "_get_parse_job_details")
     def test_create_job_with_local_file(self, mock_get_status, mock_request):
         """Create job with local file uploads correctly."""
@@ -305,13 +306,13 @@ class TestCreateJob:
         output_connector = Mock()
         output_connector.to_dict.return_value = {"type": "localfile"}
 
-        result = client._create_job(connector, output_connector, OutputFormat.TXT)
+        result = client._create_job(connector, output_connector)
 
         assert result == mock_job
         mock_request.assert_called_once()
         mock_get_status.assert_called_once_with("job_123")
 
-    @patch.object(ByteITClient, "_request")
+    @patch.object(RateLimitedSubmitter, "_request")
     def test_create_job_with_s3(self, mock_request):
         """Create job with S3 connector."""
         client = ByteITClient("test_key")
@@ -336,44 +337,24 @@ class TestCreateJob:
         output_connector = Mock()
         output_connector.to_dict.return_value = {"type": "localfile"}
 
-        result = client._create_job(connector, output_connector, OutputFormat.JSON)
+        result = client._create_job(connector, output_connector)
 
         assert isinstance(result, ParseJob)
         assert result.id == "job_123"
 
-    @patch.object(ByteITClient, "_request")
-    def test_create_job_serializes_excel_format_as_zip(self, mock_request):
-        """Serialize Excel output format as zip in the job creation payload."""
+    def test_create_job_serializes_excel_format_as_zip(self):
+        """Serialize Excel output format as zip in the job payload."""
         client = ByteITClient("test_key")
-        mock_request.return_value = {
-            "job": {
-                "id": "job_excel",
-                "created_at": "2024-01-01T00:00:00Z",
-                "updated_at": "2024-01-01T00:00:00Z",
-                "processing_status": "pending",
-                "result_format": "zip",
-            }
-        }
-
-        file_obj = Mock()
-        file_obj.closed = False
-
-        connector = Mock()
-        connector.to_dict.return_value = {"type": "localfile"}
-        connector.get_file_data.return_value = ("test.pdf", file_obj)
 
-        output_connector = Mock()
-        output_connector.to_dict.return_value = {"type": "localfile"}
-
-        result = client._create_job(connector, output_connector, OutputFormat.EXCEL)
+        data = client._build_localfile_job_data(
+            processing_options=None,
+            result_format=OutputFormat.EXCEL,
+            queue_for_batch=False,
+        )
 
-        assert isinstance(result, ParseJob)
-        assert result.result_format == "zip"
-        request_kwargs = mock_request.call_args.kwargs
-        assert request_kwargs["data"]["output_format"] == "zip"
-        file_obj.close.assert_called_once()
+        assert data["output_format"] == "zip"
 
-    @patch.object(ByteITClient, "_request")
+    @patch.object(RateLimitedSubmitter, "_request")
     @patch.object(ByteITClient, "_get_parse_job_details")
     def test_create_job_uses_parse_jobs_collection_path(
         self, mock_get_status, mock_request
@@ -390,14 +371,14 @@ class TestCreateJob:
         output_connector = Mock()
         output_connector.to_dict.return_value = {"type": "localfile"}
 
-        client._create_job(connector, output_connector, OutputFormat.MD)
+        client._create_job(connector, output_connector)
 
         assert mock_request.call_args.args[:2] == (
             "POST",
             "/v1/jobs/parse-jobs/",
         )
 
-    @patch.object(ByteITClient, "_request")
+    @patch.object(RateLimitedSubmitter, "_request")
     @patch.object(ByteITClient, "_get_parse_job_details")
     def test_create_job_sends_queue_for_batch_when_true(
         self, mock_get_status, mock_request
@@ -417,14 +398,14 @@ class TestCreateJob:
         client._create_job(
             connector,
             output_connector,
-            OutputFormat.JSON,
+            None,
             queue_for_batch=True,
         )
 
         request_kwargs = mock_request.call_args.kwargs
         assert request_kwargs["data"]["queue_for_batch"] == "true"
 
-    @patch.object(ByteITClient, "_request")
+    @patch.object(RateLimitedSubmitter, "_request")
     @patch.object(ByteITClient, "_get_parse_job_details")
     def test_create_job_omits_queue_for_batch_by_default(
         self, mock_get_status, mock_request
@@ -441,7 +422,7 @@ class TestCreateJob:
         output_connector = Mock()
         output_connector.to_dict.return_value = {"type": "localfile"}
 
-        client._create_job(connector, output_connector, OutputFormat.JSON)
+        client._create_job(connector, output_connector)
 
         request_kwargs = mock_request.call_args.kwargs
         assert "queue_for_batch" not in request_kwargs["data"]
@@ -451,7 +432,7 @@ class TestCreateJobRateLimitHandling:
     """Test adaptive rate-limit handling during parse job submission."""
 
     @patch("time.sleep")
-    @patch.object(ByteITClient, "_request")
+    @patch.object(RateLimitedSubmitter, "_request")
     @patch.object(ByteITClient, "_get_parse_job_details")
     def test_create_job_retries_after_rate_limit(
         self, mock_get_status, mock_request, mock_sleep
@@ -471,14 +452,14 @@ class TestCreateJobRateLimitHandling:
         output_connector = Mock()
         output_connector.to_dict.return_value = {"type": "localfile"}
 
-        client._create_job(connector, output_connector, OutputFormat.JSON)
+        client._create_job(connector, output_connector)
 
         assert mock_request.call_count == 2
         mock_sleep.assert_called_once_with(2.0)
-        assert client._submission_delay == 1.0
+        assert client._rate_limiter._submission_delay == 1.0
 
     @patch("time.sleep")
-    @patch.object(ByteITClient, "_request")
+    @patch.object(RateLimitedSubmitter, "_request")
     @patch.object(ByteITClient, "_get_parse_job_details")
     def test_create_job_spaces_subsequent_submissions_after_rate_limit(
         self, mock_get_status, mock_request, mock_sleep
@@ -495,16 +476,16 @@ class TestCreateJobRateLimitHandling:
         output_connector = Mock()
         output_connector.to_dict.return_value = {"type": "localfile"}
 
-        client._submission_delay = 2.0
-        client._last_submission_at = 100.0
+        client._rate_limiter._submission_delay = 2.0
+        client._rate_limiter._last_submission_at = 100.0
 
         with patch("time.monotonic", side_effect=[101.0, 102.5]):
-            client._create_job(connector, output_connector, OutputFormat.JSON)
+            client._create_job(connector, output_connector)
 
         mock_sleep.assert_called_once_with(1.0)
 
     @patch("time.sleep")
-    @patch.object(ByteITClient, "_request")
+    @patch.object(RateLimitedSubmitter, "_request")
     def test_create_job_raises_after_max_rate_limit_retries(
         self, mock_request, mock_sleep
     ):
@@ -522,7 +503,7 @@ class TestCreateJobRateLimitHandling:
         output_connector.to_dict.return_value = {"type": "localfile"}
 
         with pytest.raises(RateLimitError, match="Too many requests"):
-            client._create_job(connector, output_connector, OutputFormat.JSON)
+            client._create_job(connector, output_connector)
 
         assert mock_request.call_count == 3
         assert mock_sleep.call_count == 2
@@ -691,7 +672,7 @@ class TestParse:
         mock_wait.assert_called_once_with(
             "job_123", input_connector=mock_connector, job=mock_job
         )
-        mock_download.assert_called_once_with("job_123")
+        mock_download.assert_called_once_with("job_123", result_format=None)
 
     @patch.object(ByteITClient, "_download_parse_result")
     @patch.object(ByteITClient, "_wait_for_completion")
@@ -854,7 +835,6 @@ class TestSubmitJob:
             input_connector=mock_input_conn,
             output_connector=mock_output_conn,
             processing_options=None,
-            result_format=OutputFormat.JSON,
             queue_for_batch=False,
         )
 
@@ -879,14 +859,12 @@ class TestSubmitJob:
 
         client._submit_job(
             "test.pdf",
-            {"extraction_type": "complex"},
+            {"parse_type": "complex"},
             OutputFormat.JSON,
         )
 
         call_kwargs = mock_create.call_args[1]
-        assert call_kwargs["processing_options"].extraction_type is (
-            ExtractionType.COMPLEX
-        )
+        assert call_kwargs["processing_options"].parse_type is (ParseType.COMPLEX)
 
     @patch.object(ByteITClient, "_create_job")
     @patch.object(ByteITClient, "_to_output_connector")

{byteit-1.2.0/tests → byteit-1.3.0/tests/unit}/test_models.py

@@ -3,10 +3,10 @@
 import pytest
 
 from byteit.models.DocumentMetadata import DocumentMetadata
-from byteit.models.ExtractionType import ExtractionType
 from byteit.models.JobList import JobList
 from byteit.models.JobStatus import JobStatus
 from byteit.models.ParseJob import ParseJob
+from byteit.models.ParseType import ParseType
 from byteit.models.ProcessingOptions import ProcessingOptions
 from byteit.models.SavedSchema import SavedSchema
 from byteit.models.SavedSchemaList import SavedSchemaList
@@ -164,27 +164,27 @@ class TestProcessingOptions:
 
         assert options.languages == ["en"]
         assert options.page_range == ""
-        assert options.extraction_type is ExtractionType.AUTO
+        assert options.parse_type is ParseType.AUTO
 
     def test_to_dict(self):
         """to_dict serializes options."""
         options = ProcessingOptions(
             languages=["en", "es"],
             page_range="1-5",
-            extraction_type=ExtractionType.COMPLEX,
+            parse_type=ParseType.COMPLEX,
         )
 
         result = options.to_dict()
 
         assert result["languages"] == ["en", "es"]
         assert result["page_range"] == "1-5"
-        assert result["extraction_type"] == "complex"
+        assert result["parse_type"] == "complex"
 
-    def test_from_dict_parses_extraction_type(self):
-        """from_dict converts extraction_type strings into enums."""
-        options = ProcessingOptions.from_dict({"extraction_type": "complex"})
+    def test_from_dict_parses_parse_type(self):
+        """from_dict converts parse_type strings into enums."""
+        options = ProcessingOptions.from_dict({"parse_type": "complex"})
 
-        assert options.extraction_type is ExtractionType.COMPLEX
+        assert options.parse_type is ParseType.COMPLEX
 
     def test_force_image_annotations_enables_image_annotations(self):
         """force_image_annotations implies image_annotations."""
@@ -195,10 +195,16 @@ class TestProcessingOptions:
         assert options.to_dict()["force_image_annotations"] is True
         assert options.to_dict()["image_annotations"] is True
 
-    def test_invalid_extraction_type_raises_error(self):
-        """Invalid extraction type values are rejected."""
-        with pytest.raises(ValueError, match="Invalid extraction type"):
-            ProcessingOptions(extraction_type="invalid")
+    def test_accepts_handwritten_parse_type(self):
+        """HANDWRITTEN is a valid parse type."""
+        options = ProcessingOptions(parse_type="handwritten")
+
+        assert options.parse_type is ParseType.HANDWRITTEN
+
+    def test_invalid_parse_type_raises_error(self):
+        """Invalid parse type values are rejected."""
+        with pytest.raises(ValueError, match="Invalid parse type"):
+            ProcessingOptions(parse_type="invalid")
 
 
 class TestSavedSchema:

byteit-1.2.0/byteit/models/ExtractionType.py

@@ -1,10 +0,0 @@
-"""Document extraction type value object."""
-
-from enum import Enum
-
-
-class ExtractionType(Enum):
-    """Document extraction type enumeration."""
-
-    AUTO = "auto"
-    COMPLEX = "complex"