sparrow-parse 1.0.3__py3-none-any.whl → 1.0.4a0__py3-none-any.whl

sparrow_parse/__init__.py

@@ -1 +1 @@
-__version__ = '1.0.3'
+__version__ = '1.0.4a'

sparrow_parse/vllm/inference_factory.py

@@ -1,6 +1,6 @@
 from sparrow_parse.vllm.huggingface_inference import HuggingFaceInference
 from sparrow_parse.vllm.local_gpu_inference import LocalGPUInference
-from sparrow_parse.vllm.mlx_inference import MLXInference
+# from sparrow_parse.vllm.mlx_inference import MLXInference
 
 
 class InferenceFactory:
@@ -14,7 +14,8 @@ class InferenceFactory:
             model = self._load_local_model()  # Replace with actual model loading logic
             return LocalGPUInference(model=model, device=self.config.get("device", "cuda"))
         elif self.config["method"] == "mlx":
-            return MLXInference(model_name=self.config["model_name"])
+            # return MLXInference(model_name=self.config["model_name"])
+            return None
         else:
             raise ValueError(f"Unknown method: {self.config['method']}")
 

sparrow_parse/vllm/mlx_inference.py

@@ -1,216 +1,217 @@
-from mlx_vlm import load, generate
-from mlx_vlm.prompt_utils import apply_chat_template
-from mlx_vlm.utils import load_image
-from sparrow_parse.vllm.inference_base import ModelInference
-import os
-import json
-from rich import print
-
-
-class MLXInference(ModelInference):
-    """
-        A class for performing inference using the MLX model.
-        Handles image preprocessing, response formatting, and model interaction.
-        """
-
-    def __init__(self, model_name):
-        """
-        Initialize the inference class with the given model name.
-
-        :param model_name: Name of the model to load.
-        """
-        self.model_name = model_name
-        print(f"MLXInference initialized for model: {model_name}")
-
-
-    @staticmethod
-    def _load_model_and_processor(model_name):
-        """
-        Load the model and processor for inference.
-
-        :param model_name: Name of the model to load.
-        :return: Tuple containing the loaded model and processor.
-        """
-        model, processor = load(model_name)
-        print(f"Loaded model: {model_name}")
-        return model, processor
-
-
-    def process_response(self, output_text):
-        """
-        Process and clean the model's raw output to format as JSON.
-        """
-        try:
-            # Check if we have markdown code block markers
-            if "```" in output_text:
-                # Handle markdown-formatted output
-                json_start = output_text.find("```json")
-                if json_start != -1:
-                    # Extract content between ```json and ```
-                    content = output_text[json_start + 7:]
-                    json_end = content.rfind("```")
-                    if json_end != -1:
-                        content = content[:json_end].strip()
-                        formatted_json = json.loads(content)
-                        return json.dumps(formatted_json, indent=2)
-
-            # Handle raw JSON (no markdown formatting)
-            # First try to find JSON array or object patterns
-            for pattern in [r'\[\s*\{.*\}\s*\]', r'\{.*\}']:
-                import re
-                matches = re.search(pattern, output_text, re.DOTALL)
-                if matches:
-                    potential_json = matches.group(0)
-                    try:
-                        formatted_json = json.loads(potential_json)
-                        return json.dumps(formatted_json, indent=2)
-                    except:
-                        pass
-
-            # Last resort: try to parse the whole text as JSON
-            formatted_json = json.loads(output_text.strip())
-            return json.dumps(formatted_json, indent=2)
-
-        except Exception as e:
-            print(f"Failed to parse JSON: {e}")
-            return output_text
-
-
-    def load_image_data(self, image_filepath, max_width=1250, max_height=1750):
-        """
-        Load and resize image while maintaining its aspect ratio.
-
-        :param image_filepath: Path to the image file.
-        :param max_width: Maximum allowed width of the image.
-        :param max_height: Maximum allowed height of the image.
-        :return: Tuple containing the image object and its new dimensions.
-        """
-        image = load_image(image_filepath)  # Assuming load_image is defined elsewhere
-        width, height = image.size
-
-        # Calculate new dimensions while maintaining the aspect ratio
-        if width > max_width or height > max_height:
-            aspect_ratio = width / height
-            new_width = min(max_width, int(max_height * aspect_ratio))
-            new_height = min(max_height, int(max_width / aspect_ratio))
-            return image, new_width, new_height
-
-        return image, width, height
-
-
-    def inference(self, input_data, mode=None):
-        """
-        Perform inference on input data using the specified model.
-
-        :param input_data: A list of dictionaries containing image file paths and text inputs.
-        :param mode: Optional mode for inference ("static" for simple JSON output).
-        :return: List of processed model responses.
-        """
-        # Handle static mode
-        if mode == "static":
-            return [self.get_simple_json()]
-
-        # Load the model and processor
-        model, processor = self._load_model_and_processor(self.model_name)
-        config = model.config
-        
-        # Determine if we're doing text-only or image-based inference
-        is_text_only = input_data[0].get("file_path") is None
-        
-        if is_text_only:
-            # Text-only inference
-            messages = input_data[0]["text_input"]
-            response = self._generate_text_response(model, processor, config, messages)
-            results = [self.process_response(response)]
-            print("Agent inference completed successfully")
-        else:
-            # Image-based inference
-            file_paths = self._extract_file_paths(input_data)
-            results = self._process_images(model, processor, config, file_paths, input_data)
-        
-        return results
-
-    def _generate_text_response(self, model, processor, config, messages):
-        """
-        Generate a text response for text-only inputs.
-        
-        :param model: The loaded model
-        :param processor: The loaded processor
-        :param config: Model configuration
-        :param messages: Input messages
-        :return: Generated response
-        """
-        prompt = apply_chat_template(processor, config, messages)
-        return generate(
-            model,
-            processor,
-            prompt,
-            max_tokens=4000,
-            temperature=0.0,
-            verbose=False
-        )
-
-    def _process_images(self, model, processor, config, file_paths, input_data):
-        """
-        Process images and generate responses for each.
-        
-        :param model: The loaded model
-        :param processor: The loaded processor
-        :param config: Model configuration
-        :param file_paths: List of image file paths
-        :param input_data: Original input data
-        :return: List of processed responses
-        """
-        results = []
-        for file_path in file_paths:
-            image, width, height = self.load_image_data(file_path)
-            
-            # Prepare messages based on model type
-            messages = self._prepare_messages(input_data, file_path)
-            
-            # Generate and process response
-            prompt = apply_chat_template(processor, config, messages)
-            response = generate(
-                model,
-                processor,
-                prompt,
-                image,
-                resize_shape=(width, height),
-                max_tokens=4000,
-                temperature=0.0,
-                verbose=False
-            )
-            results.append(self.process_response(response))
-            print(f"Inference completed successfully for: {file_path}")
-        
-        return results
-
-    def _prepare_messages(self, input_data, file_path):
-        """
-        Prepare the appropriate messages based on the model type.
-        
-        :param input_data: Original input data
-        :param file_path: Current file path being processed
-        :return: Properly formatted messages
-        """
-        if "mistral" in self.model_name.lower():
-            return input_data[0]["text_input"]
-        else:
-            return [
-                {"role": "system", "content": "You are an expert at extracting structured text from image documents."},
-                {"role": "user", "content": input_data[0]["text_input"]},
-            ]
-
-    @staticmethod
-    def _extract_file_paths(input_data):
-        """
-        Extract and resolve absolute file paths from input data.
-
-        :param input_data: List of dictionaries containing image file paths.
-        :return: List of absolute file paths.
-        """
-        return [
-            os.path.abspath(file_path)
-            for data in input_data
-            for file_path in data.get("file_path", [])
-        ]
+# from mlx_vlm import load, generate
+# from mlx_vlm.prompt_utils import apply_chat_template
+# from mlx_vlm.utils import load_image
+# from sparrow_parse.vllm.inference_base import ModelInference
+# import os
+# import json
+# from rich import print
+#
+#
+# class MLXInference(ModelInference):
+#     """
+#         A class for performing inference using the MLX model.
+#         Handles image preprocessing, response formatting, and model interaction.
+#         """
+#
+#     def __init__(self, model_name):
+#         """
+#         Initialize the inference class with the given model name.
+#
+#         :param model_name: Name of the model to load.
+#         """
+#         self.model_name = model_name
+#         print(f"MLXInference initialized for model: {model_name}")
+#
+#
+#     @staticmethod
+#     def _load_model_and_processor(model_name):
+#         """
+#         Load the model and processor for inference.
+#
+#         :param model_name: Name of the model to load.
+#         :return: Tuple containing the loaded model and processor.
+#         """
+#         model, processor = load(model_name)
+#         print(f"Loaded model: {model_name}")
+#         return model, processor
+#
+#
+#     def process_response(self, output_text):
+#         """
+#         Process and clean the model's raw output to format as JSON.
+#         """
+#         try:
+#             # Check if we have markdown code block markers
+#             if "```" in output_text:
+#                 # Handle markdown-formatted output
+#                 json_start = output_text.find("```json")
+#                 if json_start != -1:
+#                     # Extract content between ```json and ```
+#                     content = output_text[json_start + 7:]
+#                     json_end = content.rfind("```")
+#                     if json_end != -1:
+#                         content = content[:json_end].strip()
+#                         formatted_json = json.loads(content)
+#                         return json.dumps(formatted_json, indent=2)
+#
+#             # Handle raw JSON (no markdown formatting)
+#             # First try to find JSON array or object patterns
+#             for pattern in [r'\[\s*\{.*\}\s*\]', r'\{.*\}']:
+#                 import re
+#                 matches = re.search(pattern, output_text, re.DOTALL)
+#                 if matches:
+#                     potential_json = matches.group(0)
+#                     try:
+#                         formatted_json = json.loads(potential_json)
+#                         return json.dumps(formatted_json, indent=2)
+#                     except:
+#                         pass
+#
+#             # Last resort: try to parse the whole text as JSON
+#             formatted_json = json.loads(output_text.strip())
+#             return json.dumps(formatted_json, indent=2)
+#
+#         except Exception as e:
+#             print(f"Failed to parse JSON: {e}")
+#             return output_text
+#
+#
+#     def load_image_data(self, image_filepath, max_width=1250, max_height=1750):
+#         """
+#         Load and resize image while maintaining its aspect ratio.
+#
+#         :param image_filepath: Path to the image file.
+#         :param max_width: Maximum allowed width of the image.
+#         :param max_height: Maximum allowed height of the image.
+#         :return: Tuple containing the image object and its new dimensions.
+#         """
+#         image = load_image(image_filepath)  # Assuming load_image is defined elsewhere
+#         width, height = image.size
+#
+#         # Calculate new dimensions while maintaining the aspect ratio
+#         if width > max_width or height > max_height:
+#             aspect_ratio = width / height
+#             new_width = min(max_width, int(max_height * aspect_ratio))
+#             new_height = min(max_height, int(max_width / aspect_ratio))
+#             return image, new_width, new_height
+#
+#         return image, width, height
+#
+#
+#     def inference(self, input_data, mode=None):
+#         """
+#         Perform inference on input data using the specified model.
+#
+#         :param input_data: A list of dictionaries containing image file paths and text inputs.
+#         :param mode: Optional mode for inference ("static" for simple JSON output).
+#         :return: List of processed model responses.
+#         """
+#         # Handle static mode
+#         if mode == "static":
+#             return [self.get_simple_json()]
+#
+#         # Load the model and processor
+#         model, processor = self._load_model_and_processor(self.model_name)
+#         config = model.config
+#
+#         # Determine if we're doing text-only or image-based inference
+#         is_text_only = input_data[0].get("file_path") is None
+#
+#         if is_text_only:
+#             # Text-only inference
+#             messages = input_data[0]["text_input"]
+#             response = self._generate_text_response(model, processor, config, messages)
+#             results = [response]
+#         else:
+#             # Image-based inference
+#             file_paths = self._extract_file_paths(input_data)
+#             results = self._process_images(model, processor, config, file_paths, input_data)
+#
+#         return results
+#
+#     def _generate_text_response(self, model, processor, config, messages):
+#         """
+#         Generate a text response for text-only inputs.
+#
+#         :param model: The loaded model
+#         :param processor: The loaded processor
+#         :param config: Model configuration
+#         :param messages: Input messages
+#         :return: Generated response
+#         """
+#         prompt = apply_chat_template(processor, config, messages)
+#         response =  generate(
+#             model,
+#             processor,
+#             prompt,
+#             max_tokens=4000,
+#             temperature=0.0,
+#             verbose=False
+#         )
+#         print("Inference completed successfully")
+#         return response
+#
+#     def _process_images(self, model, processor, config, file_paths, input_data):
+#         """
+#         Process images and generate responses for each.
+#
+#         :param model: The loaded model
+#         :param processor: The loaded processor
+#         :param config: Model configuration
+#         :param file_paths: List of image file paths
+#         :param input_data: Original input data
+#         :return: List of processed responses
+#         """
+#         results = []
+#         for file_path in file_paths:
+#             image, width, height = self.load_image_data(file_path)
+#
+#             # Prepare messages based on model type
+#             messages = self._prepare_messages(input_data, file_path)
+#
+#             # Generate and process response
+#             prompt = apply_chat_template(processor, config, messages)
+#             response = generate(
+#                 model,
+#                 processor,
+#                 prompt,
+#                 image,
+#                 resize_shape=(width, height),
+#                 max_tokens=4000,
+#                 temperature=0.0,
+#                 verbose=False
+#             )
+#             results.append(self.process_response(response))
+#             print(f"Inference completed successfully for: {file_path}")
+#
+#         return results
+#
+#     def _prepare_messages(self, input_data, file_path):
+#         """
+#         Prepare the appropriate messages based on the model type.
+#
+#         :param input_data: Original input data
+#         :param file_path: Current file path being processed
+#         :return: Properly formatted messages
+#         """
+#         if "mistral" in self.model_name.lower():
+#             return input_data[0]["text_input"]
+#         else:
+#             return [
+#                 {"role": "system", "content": "You are an expert at extracting structured text from image documents."},
+#                 {"role": "user", "content": input_data[0]["text_input"]},
+#             ]
+#
+#     @staticmethod
+#     def _extract_file_paths(input_data):
+#         """
+#         Extract and resolve absolute file paths from input data.
+#
+#         :param input_data: List of dictionaries containing image file paths.
+#         :return: List of absolute file paths.
+#         """
+#         return [
+#             os.path.abspath(file_path)
+#             for data in input_data
+#             for file_path in data.get("file_path", [])
+#         ]

{sparrow_parse-1.0.3.dist-info → sparrow_parse-1.0.4a0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: sparrow-parse
-Version: 1.0.3
+Version: 1.0.4a0
 Summary: Sparrow Parse is a Python package (part of Sparrow) for parsing and extracting information from documents.
 Home-page: https://github.com/katanaml/sparrow/tree/main/sparrow-data/parse
 Author: Andrej Baranovskij
@@ -16,15 +16,13 @@ Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 Requires-Dist: rich
 Requires-Dist: transformers >=4.51.3
-Requires-Dist: torchvision >=0.21.0
-Requires-Dist: torch >=2.6.0
+Requires-Dist: torchvision >=0.22.0
+Requires-Dist: torch >=2.7.0
 Requires-Dist: sentence-transformers >=4.1.0
-Requires-Dist: numpy >=2.2.4
+Requires-Dist: numpy >=2.2.5
 Requires-Dist: pypdf >=5.4.0
 Requires-Dist: gradio-client >=1.7.2
 Requires-Dist: pdf2image >=1.17.0
-Requires-Dist: mlx >=0.25.0 ; sys_platform == "darwin" and platform_machine == "arm64"
-Requires-Dist: mlx-vlm ==0.1.23 ; sys_platform == "darwin" and platform_machine == "arm64"
 
 # Sparrow Parse
 

{sparrow_parse-1.0.3.dist-info → sparrow_parse-1.0.4a0.dist-info}/RECORD

@@ -1,4 +1,4 @@
-sparrow_parse/__init__.py,sha256=MpVHFFoITiYyPltTb_qFrdeX2entdTm4x0PczXi3txY,21
+sparrow_parse/__init__.py,sha256=uaGkUYEjwal6HsB_xcaWl4f22MLGxgYjrQfnOg_f2FE,22
 sparrow_parse/__main__.py,sha256=Xs1bpJV0n08KWOoQE34FBYn6EBXZA9HIYJKrE4ZdG78,153
 sparrow_parse/text_extraction.py,sha256=lirPpvz8tnwCMGmoHPK94-vCviybuRyQM-mpvhtp3uY,1124
 sparrow_parse/extractors/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -11,11 +11,11 @@ sparrow_parse/processors/table_structure_processor.py,sha256=BCYnrsqngEu0WpBORce
 sparrow_parse/vllm/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 sparrow_parse/vllm/huggingface_inference.py,sha256=EJnG6PesGKMc_0qGPN8ufE6pSnhAgFu0XjCbaLCNVyM,1980
 sparrow_parse/vllm/inference_base.py,sha256=4mwGoAY63MB4cHZpV0czTkJWEzimmiTzqqzKmLNzgjw,820
-sparrow_parse/vllm/inference_factory.py,sha256=FTM65O-dW2WZchHOrNN7_Q3-FlVoAc65iSptuuUuClM,1166
+sparrow_parse/vllm/inference_factory.py,sha256=Qd8233Xj9321ZhPEBW0bPpk4pfkIOcYnqoyyNcRCByI,1194
 sparrow_parse/vllm/local_gpu_inference.py,sha256=aHoJTejb5xrXjWDIGu5RBQWEyRCOBCB04sMvO2Wyvg8,628
-sparrow_parse/vllm/mlx_inference.py,sha256=vqIkfTd5rP8bnZ8K_CGVEWe_G3E4i3rwN9MfLBDiE3c,8000
-sparrow_parse-1.0.3.dist-info/METADATA,sha256=dIGBhBhtR5rSKj4RbT1PhyrWxKUVUq5AxbJ33FsKNlE,7229
-sparrow_parse-1.0.3.dist-info/WHEEL,sha256=yQN5g4mg4AybRjkgi-9yy4iQEFibGQmlz78Pik5Or-A,92
-sparrow_parse-1.0.3.dist-info/entry_points.txt,sha256=HV5nnQVtr2m-kn6hzY_ynp0zugNCcGovbmnfmQgOyhw,53
-sparrow_parse-1.0.3.dist-info/top_level.txt,sha256=n6b-WtT91zKLyCPZTP7wvne8v_yvIahcsz-4sX8I0rY,14
-sparrow_parse-1.0.3.dist-info/RECORD,,
+sparrow_parse/vllm/mlx_inference.py,sha256=sLSt0qN--RuJAApWX2HgYfX0ZDiZqZbgI7LRxioy73s,8315
+sparrow_parse-1.0.4a0.dist-info/METADATA,sha256=2Jtk-kXCCG_RjTxtq3CPGI-K-nHDZrHsuAxtcBA_nlc,7053
+sparrow_parse-1.0.4a0.dist-info/WHEEL,sha256=yQN5g4mg4AybRjkgi-9yy4iQEFibGQmlz78Pik5Or-A,92
+sparrow_parse-1.0.4a0.dist-info/entry_points.txt,sha256=HV5nnQVtr2m-kn6hzY_ynp0zugNCcGovbmnfmQgOyhw,53
+sparrow_parse-1.0.4a0.dist-info/top_level.txt,sha256=n6b-WtT91zKLyCPZTP7wvne8v_yvIahcsz-4sX8I0rY,14
+sparrow_parse-1.0.4a0.dist-info/RECORD,,