firecrawl 2.4.3__py3-none-any.whl → 2.5.1__py3-none-any.whl

build/lib/tests/test_change_tracking.py

@@ -0,0 +1,98 @@
+import unittest
+from unittest.mock import patch, MagicMock
+import json
+import os
+from firecrawl import FirecrawlApp
+
+class TestChangeTracking(unittest.TestCase):
+    @patch('requests.post')
+    def test_change_tracking_format(self, mock_post):
+        mock_response = MagicMock()
+        mock_response.status_code = 200
+        mock_response.json.return_value = {
+            'success': True,
+            'data': {
+                'markdown': 'Test markdown content',
+                'changeTracking': {
+                    'previousScrapeAt': '2023-01-01T00:00:00Z',
+                    'changeStatus': 'changed',
+                    'visibility': 'visible'
+                }
+            }
+        }
+        mock_post.return_value = mock_response
+
+        app = FirecrawlApp(api_key=os.environ.get('TEST_API_KEY', 'dummy-api-key-for-testing'))
+        result = app.scrape_url('https://example.com', {
+            'formats': ['markdown', 'changeTracking']
+        })
+
+        args, kwargs = mock_post.call_args
+        self.assertEqual(kwargs['json']['formats'], ['markdown', 'changeTracking'])
+        
+        self.assertEqual(result['changeTracking']['previousScrapeAt'], '2023-01-01T00:00:00Z')
+        self.assertEqual(result['changeTracking']['changeStatus'], 'changed')
+        self.assertEqual(result['changeTracking']['visibility'], 'visible')
+
+    @patch('requests.post')
+    def test_change_tracking_options(self, mock_post):
+        mock_response = MagicMock()
+        mock_response.status_code = 200
+        mock_response.json.return_value = {
+            'success': True,
+            'data': {
+                'markdown': 'Test markdown content',
+                'changeTracking': {
+                    'previousScrapeAt': '2023-01-01T00:00:00Z',
+                    'changeStatus': 'changed',
+                    'visibility': 'visible',
+                    'diff': {
+                        'text': '@@ -1,1 +1,1 @@\n-old content\n+new content',
+                        'json': {
+                            'files': [{
+                                'from': None,
+                                'to': None,
+                                'chunks': [{
+                                    'content': '@@ -1,1 +1,1 @@',
+                                    'changes': [{
+                                        'type': 'del',
+                                        'content': '-old content',
+                                        'del': True,
+                                        'ln': 1
+                                    }, {
+                                        'type': 'add',
+                                        'content': '+new content',
+                                        'add': True,
+                                        'ln': 1
+                                    }]
+                                }]
+                            }]
+                        }
+                    },
+                    'json': {
+                        'title': {
+                            'previous': 'Old Title',
+                            'current': 'New Title'
+                        }
+                    }
+                }
+            }
+        }
+        mock_post.return_value = mock_response
+
+        app = FirecrawlApp(api_key=os.environ.get('TEST_API_KEY', 'dummy-api-key-for-testing'))
+        result = app.scrape_url('https://example.com', {
+            'formats': ['markdown', 'changeTracking'],
+            'changeTrackingOptions': {
+                'modes': ['git-diff', 'json'],
+                'schema': {'type': 'object', 'properties': {'title': {'type': 'string'}}}
+            }
+        })
+
+        args, kwargs = mock_post.call_args
+        self.assertEqual(kwargs['json']['formats'], ['markdown', 'changeTracking'])
+        self.assertEqual(kwargs['json']['changeTrackingOptions']['modes'], ['git-diff', 'json'])
+        
+        self.assertEqual(result['changeTracking']['diff']['text'], '@@ -1,1 +1,1 @@\n-old content\n+new content')
+        self.assertEqual(result['changeTracking']['json']['title']['previous'], 'Old Title')
+        self.assertEqual(result['changeTracking']['json']['title']['current'], 'New Title')

firecrawl/__init__.py

@@ -11,9 +11,9 @@ For more information visit https://github.com/firecrawl/
 import logging
 import os
 
-from .firecrawl import FirecrawlApp, JsonConfig, ScrapeOptions # noqa
+from .firecrawl import FirecrawlApp, JsonConfig, ScrapeOptions, ChangeTrackingOptions # noqa
 
-__version__ = "2.4.3"
+__version__ = "2.5.1"
 
 # Define the logger for the Firecrawl project
 logger: logging.Logger = logging.getLogger("firecrawl")

firecrawl/firecrawl.py

@@ -29,7 +29,7 @@ warnings.filterwarnings("ignore", message="Field name \"json\" in \"FirecrawlDoc
 warnings.filterwarnings("ignore", message="Field name \"json\" in \"ChangeTrackingData\" shadows an attribute in parent \"BaseModel\"")
 warnings.filterwarnings("ignore", message="Field name \"schema\" in \"JsonConfig\" shadows an attribute in parent \"BaseModel\"")
 warnings.filterwarnings("ignore", message="Field name \"schema\" in \"ExtractParams\" shadows an attribute in parent \"BaseModel\"")
-
+warnings.filterwarnings("ignore", message="Field name \"schema\" in \"ChangeTrackingOptions\" shadows an attribute in parent \"BaseModel\"")
 
 def get_version():
   try:
@@ -135,6 +135,12 @@ class WebhookConfig(pydantic.BaseModel):
     metadata: Optional[Dict[str, str]] = None
     events: Optional[List[Literal["completed", "failed", "page", "started"]]] = None
 
+class ChangeTrackingOptions(pydantic.BaseModel):
+    """Configuration for change tracking."""
+    modes: Optional[List[Literal["git-diff", "json"]]] = None
+    schema: Optional[Any] = None
+    prompt: Optional[str] = None
+
 class ScrapeOptions(pydantic.BaseModel):
     """Parameters for scraping operations."""
     formats: Optional[List[Literal["markdown", "html", "rawHtml", "content", "links", "screenshot", "screenshot@fullPage", "extract", "json", "changeTracking"]]] = None
@@ -150,6 +156,7 @@ class ScrapeOptions(pydantic.BaseModel):
     removeBase64Images: Optional[bool] = None
     blockAds: Optional[bool] = None
     proxy: Optional[Literal["basic", "stealth"]] = None
+    changeTrackingOptions: Optional[ChangeTrackingOptions] = None
 
 class WaitAction(pydantic.BaseModel):
     """Wait action to perform during scraping."""
@@ -454,6 +461,7 @@ class FirecrawlApp:
             extract: Optional[JsonConfig] = None,
             json_options: Optional[JsonConfig] = None,
             actions: Optional[List[Union[WaitAction, ScreenshotAction, ClickAction, WriteAction, PressAction, ScrollAction, ScrapeAction, ExecuteJavascriptAction]]] = None,
+            change_tracking_options: Optional[ChangeTrackingOptions] = None,
             **kwargs) -> ScrapeResponse[Any]:
         """
         Scrape and extract content from a URL.
@@ -475,6 +483,7 @@ class FirecrawlApp:
           extract (Optional[JsonConfig]): Content extraction settings
           json_options (Optional[JsonConfig]): JSON extraction settings
           actions (Optional[List[Union[WaitAction, ScreenshotAction, ClickAction, WriteAction, PressAction, ScrollAction, ScrapeAction, ExecuteJavascriptAction]]]): Actions to perform
+          change_tracking_options (Optional[ChangeTrackingOptions]): Change tracking settings
 
 
         Returns:
@@ -520,18 +529,28 @@ class FirecrawlApp:
             scrape_params['blockAds'] = block_ads
         if proxy:
             scrape_params['proxy'] = proxy
-        if extract:
-            if hasattr(extract.schema, 'schema'):
-                extract.schema = extract.schema.schema()
-            scrape_params['extract'] = extract.dict(exclude_none=True)
-        if json_options:
-            if hasattr(json_options.schema, 'schema'):
-                json_options.schema = json_options.schema.schema()
-            scrape_params['jsonOptions'] = json_options.dict(exclude_none=True)
+        if extract is not None:
+            extract = self._ensure_schema_dict(extract)
+            if isinstance(extract, dict) and "schema" in extract:
+                extract["schema"] = self._ensure_schema_dict(extract["schema"])
+            scrape_params['extract'] = extract if isinstance(extract, dict) else extract.dict(exclude_none=True)
+        if json_options is not None:
+            json_options = self._ensure_schema_dict(json_options)
+            if isinstance(json_options, dict) and "schema" in json_options:
+                json_options["schema"] = self._ensure_schema_dict(json_options["schema"])
+            scrape_params['jsonOptions'] = json_options if isinstance(json_options, dict) else json_options.dict(exclude_none=True)
         if actions:
             scrape_params['actions'] = [action.dict(exclude_none=True) for action in actions]
+        if change_tracking_options:
+            scrape_params['changeTrackingOptions'] = change_tracking_options.dict(exclude_none=True)
+        
         scrape_params.update(kwargs)
 
+        if 'extract' in scrape_params and scrape_params['extract'] and 'schema' in scrape_params['extract']:
+            scrape_params['extract']['schema'] = self._ensure_schema_dict(scrape_params['extract']['schema'])
+        if 'jsonOptions' in scrape_params and scrape_params['jsonOptions'] and 'schema' in scrape_params['jsonOptions']:
+            scrape_params['jsonOptions']['schema'] = self._ensure_schema_dict(scrape_params['jsonOptions']['schema'])
+
         # Make request
         response = requests.post(
             f'{self.api_url}/v1/scrape',
@@ -1240,13 +1259,15 @@ class FirecrawlApp:
         if proxy is not None:
             scrape_params['proxy'] = proxy
         if extract is not None:
-            if hasattr(extract.schema, 'schema'):
-                extract.schema = extract.schema.schema()
-            scrape_params['extract'] = extract.dict(exclude_none=True)
+            extract = self._ensure_schema_dict(extract)
+            if isinstance(extract, dict) and "schema" in extract:
+                extract["schema"] = self._ensure_schema_dict(extract["schema"])
+            scrape_params['extract'] = extract if isinstance(extract, dict) else extract.dict(exclude_none=True)
         if json_options is not None:
-            if hasattr(json_options.schema, 'schema'):
-                json_options.schema = json_options.schema.schema()
-            scrape_params['jsonOptions'] = json_options.dict(exclude_none=True)
+            json_options = self._ensure_schema_dict(json_options)
+            if isinstance(json_options, dict) and "schema" in json_options:
+                json_options["schema"] = self._ensure_schema_dict(json_options["schema"])
+            scrape_params['jsonOptions'] = json_options if isinstance(json_options, dict) else json_options.dict(exclude_none=True)
         if actions is not None:
             scrape_params['actions'] = [action.dict(exclude_none=True) for action in actions]
         if agent is not None:
@@ -1261,6 +1282,11 @@ class FirecrawlApp:
         params_dict['urls'] = urls
         params_dict['origin'] = f"python-sdk@{version}"
 
+        if 'extract' in params_dict and params_dict['extract'] and 'schema' in params_dict['extract']:
+            params_dict['extract']['schema'] = self._ensure_schema_dict(params_dict['extract']['schema'])
+        if 'jsonOptions' in params_dict and params_dict['jsonOptions'] and 'schema' in params_dict['jsonOptions']:
+            params_dict['jsonOptions']['schema'] = self._ensure_schema_dict(params_dict['jsonOptions']['schema'])
+
         # Make request
         headers = self._prepare_headers(idempotency_key)
         response = self._post_request(f'{self.api_url}/v1/batch/scrape', params_dict, headers)
@@ -1366,13 +1392,15 @@ class FirecrawlApp:
         if proxy is not None:
             scrape_params['proxy'] = proxy
         if extract is not None:
-            if hasattr(extract.schema, 'schema'):
-                extract.schema = extract.schema.schema()
-            scrape_params['extract'] = extract.dict(exclude_none=True)
+            extract = self._ensure_schema_dict(extract)
+            if isinstance(extract, dict) and "schema" in extract:
+                extract["schema"] = self._ensure_schema_dict(extract["schema"])
+            scrape_params['extract'] = extract if isinstance(extract, dict) else extract.dict(exclude_none=True)
         if json_options is not None:
-            if hasattr(json_options.schema, 'schema'):
-                json_options.schema = json_options.schema.schema()
-            scrape_params['jsonOptions'] = json_options.dict(exclude_none=True)
+            json_options = self._ensure_schema_dict(json_options)
+            if isinstance(json_options, dict) and "schema" in json_options:
+                json_options["schema"] = self._ensure_schema_dict(json_options["schema"])
+            scrape_params['jsonOptions'] = json_options if isinstance(json_options, dict) else json_options.dict(exclude_none=True)
         if actions is not None:
             scrape_params['actions'] = [action.dict(exclude_none=True) for action in actions]
         if agent is not None:
@@ -1387,6 +1415,11 @@ class FirecrawlApp:
         params_dict['urls'] = urls
         params_dict['origin'] = f"python-sdk@{version}"
 
+        if 'extract' in params_dict and params_dict['extract'] and 'schema' in params_dict['extract']:
+            params_dict['extract']['schema'] = self._ensure_schema_dict(params_dict['extract']['schema'])
+        if 'jsonOptions' in params_dict and params_dict['jsonOptions'] and 'schema' in params_dict['jsonOptions']:
+            params_dict['jsonOptions']['schema'] = self._ensure_schema_dict(params_dict['jsonOptions']['schema'])
+
         # Make request
         headers = self._prepare_headers(idempotency_key)
         response = self._post_request(f'{self.api_url}/v1/batch/scrape', params_dict, headers)
@@ -1487,13 +1520,15 @@ class FirecrawlApp:
         if proxy is not None:
             scrape_params['proxy'] = proxy
         if extract is not None:
-            if hasattr(extract.schema, 'schema'):
-                extract.schema = extract.schema.schema()
-            scrape_params['extract'] = extract.dict(exclude_none=True)
+            extract = self._ensure_schema_dict(extract)
+            if isinstance(extract, dict) and "schema" in extract:
+                extract["schema"] = self._ensure_schema_dict(extract["schema"])
+            scrape_params['extract'] = extract if isinstance(extract, dict) else extract.dict(exclude_none=True)
         if json_options is not None:
-            if hasattr(json_options.schema, 'schema'):
-                json_options.schema = json_options.schema.schema()
-            scrape_params['jsonOptions'] = json_options.dict(exclude_none=True)
+            json_options = self._ensure_schema_dict(json_options)
+            if isinstance(json_options, dict) and "schema" in json_options:
+                json_options["schema"] = self._ensure_schema_dict(json_options["schema"])
+            scrape_params['jsonOptions'] = json_options if isinstance(json_options, dict) else json_options.dict(exclude_none=True)
         if actions is not None:
             scrape_params['actions'] = [action.dict(exclude_none=True) for action in actions]
         if agent is not None:
@@ -1508,6 +1543,11 @@ class FirecrawlApp:
         params_dict['urls'] = urls
         params_dict['origin'] = f"python-sdk@{version}"
 
+        if 'extract' in params_dict and params_dict['extract'] and 'schema' in params_dict['extract']:
+            params_dict['extract']['schema'] = self._ensure_schema_dict(params_dict['extract']['schema'])
+        if 'jsonOptions' in params_dict and params_dict['jsonOptions'] and 'schema' in params_dict['jsonOptions']:
+            params_dict['jsonOptions']['schema'] = self._ensure_schema_dict(params_dict['jsonOptions']['schema'])
+
         # Make request
         headers = self._prepare_headers(idempotency_key)
         response = self._post_request(f'{self.api_url}/v1/batch/scrape', params_dict, headers)
@@ -1594,7 +1634,7 @@ class FirecrawlApp:
             id (str): The ID of the crawl job.
 
         Returns:
-            CrawlErrorsResponse: A response containing:
+            CrawlErrorsResponse containing:
             * errors (List[Dict[str, str]]): List of errors with fields:
               * id (str): Error ID
               * timestamp (str): When the error occurred
@@ -1657,10 +1697,7 @@ class FirecrawlApp:
             raise ValueError("Either urls or prompt is required")
 
         if schema:
-            if hasattr(schema, 'model_json_schema'):
-                # Convert Pydantic model to JSON schema
-                schema = schema.model_json_schema()
-            # Otherwise assume it's already a JSON schema dict
+            schema = self._ensure_schema_dict(schema)
 
         request_data = {
             'urls': urls or [],
@@ -1789,10 +1826,7 @@ class FirecrawlApp:
         
         schema = schema
         if schema:
-            if hasattr(schema, 'model_json_schema'):
-                # Convert Pydantic model to JSON schema
-                schema = schema.model_json_schema()
-            # Otherwise assume it's already a JSON schema dict
+            schema = self._ensure_schema_dict(schema)
 
         request_data = {
             'urls': urls,
@@ -2424,7 +2458,7 @@ class FirecrawlApp:
         method_params = {
             "scrape_url": {"formats", "include_tags", "exclude_tags", "only_main_content", "wait_for", 
                           "timeout", "location", "mobile", "skip_tls_verification", "remove_base64_images",
-                          "block_ads", "proxy", "extract", "json_options", "actions"},
+                          "block_ads", "proxy", "extract", "json_options", "actions", "change_tracking_options"},
             "search": {"limit", "tbs", "filter", "lang", "country", "location", "timeout", "scrape_options"},
             "crawl_url": {"include_paths", "exclude_paths", "max_depth", "max_discovery_depth", "limit",
                          "allow_backward_links", "allow_external_links", "ignore_sitemap", "scrape_options",
@@ -2455,6 +2489,24 @@ class FirecrawlApp:
         # Additional type validation can be added here if needed
         # For now, we rely on Pydantic models for detailed type validation
 
+    def _ensure_schema_dict(self, schema):
+        """
+        Utility to ensure a schema is a dict, not a Pydantic model class. Recursively checks dicts and lists.
+        """
+        if schema is None:
+            return schema
+        if isinstance(schema, type):
+            # Pydantic v1/v2 model class
+            if hasattr(schema, 'model_json_schema'):
+                return schema.model_json_schema()
+            elif hasattr(schema, 'schema'):
+                return schema.schema()
+        if isinstance(schema, dict):
+            return {k: self._ensure_schema_dict(v) for k, v in schema.items()}
+        if isinstance(schema, (list, tuple)):
+            return [self._ensure_schema_dict(v) for v in schema]
+        return schema
+
 class CrawlWatcher:
     """
     A class to watch and handle crawl job events via WebSocket connection.
@@ -2861,19 +2913,24 @@ class AsyncFirecrawlApp(FirecrawlApp):
             scrape_params['blockAds'] = block_ads
         if proxy:
             scrape_params['proxy'] = proxy
-        if extract:
-            extract_dict = extract.dict(exclude_none=True)
-            if 'schema' in extract_dict and hasattr(extract.schema, 'schema'):
-                extract_dict['schema'] = extract.schema.schema() # Ensure pydantic model schema is converted
-            scrape_params['extract'] = extract_dict
-        if json_options:
-            json_options_dict = json_options.dict(exclude_none=True)
-            if 'schema' in json_options_dict and hasattr(json_options.schema, 'schema'):
-                 json_options_dict['schema'] = json_options.schema.schema() # Ensure pydantic model schema is converted
-            scrape_params['jsonOptions'] = json_options_dict
+        if extract is not None:
+            extract = self._ensure_schema_dict(extract)
+            if isinstance(extract, dict) and "schema" in extract:
+                extract["schema"] = self._ensure_schema_dict(extract["schema"])
+            scrape_params['extract'] = extract if isinstance(extract, dict) else extract.dict(exclude_none=True)
+        if json_options is not None:
+            json_options = self._ensure_schema_dict(json_options)
+            if isinstance(json_options, dict) and "schema" in json_options:
+                json_options["schema"] = self._ensure_schema_dict(json_options["schema"])
+            scrape_params['jsonOptions'] = json_options if isinstance(json_options, dict) else json_options.dict(exclude_none=True)
         if actions:
             scrape_params['actions'] = [action.dict(exclude_none=True) for action in actions]
 
+        if 'extract' in scrape_params and scrape_params['extract'] and 'schema' in scrape_params['extract']:
+            scrape_params['extract']['schema'] = self._ensure_schema_dict(scrape_params['extract']['schema'])
+        if 'jsonOptions' in scrape_params and scrape_params['jsonOptions'] and 'schema' in scrape_params['jsonOptions']:
+            scrape_params['jsonOptions']['schema'] = self._ensure_schema_dict(scrape_params['jsonOptions']['schema'])
+
         # Make async request
         endpoint = f'/v1/scrape'
         response = await self._async_post_request(
@@ -2984,13 +3041,15 @@ class AsyncFirecrawlApp(FirecrawlApp):
         if proxy is not None:
             scrape_params['proxy'] = proxy
         if extract is not None:
-            if hasattr(extract.schema, 'schema'):
-                extract.schema = extract.schema.schema()
-            scrape_params['extract'] = extract.dict(exclude_none=True)
+            extract = self._ensure_schema_dict(extract)
+            if isinstance(extract, dict) and "schema" in extract:
+                extract["schema"] = self._ensure_schema_dict(extract["schema"])
+            scrape_params['extract'] = extract if isinstance(extract, dict) else extract.dict(exclude_none=True)
         if json_options is not None:
-            if hasattr(json_options.schema, 'schema'):
-                json_options.schema = json_options.schema.schema()
-            scrape_params['jsonOptions'] = json_options.dict(exclude_none=True)
+            json_options = self._ensure_schema_dict(json_options)
+            if isinstance(json_options, dict) and "schema" in json_options:
+                json_options["schema"] = self._ensure_schema_dict(json_options["schema"])
+            scrape_params['jsonOptions'] = json_options if isinstance(json_options, dict) else json_options.dict(exclude_none=True)
         if actions is not None:
             scrape_params['actions'] = [action.dict(exclude_none=True) for action in actions]
         if agent is not None:
@@ -3005,6 +3064,11 @@ class AsyncFirecrawlApp(FirecrawlApp):
         params_dict['urls'] = urls
         params_dict['origin'] = f"python-sdk@{version}"
 
+        if 'extract' in params_dict and params_dict['extract'] and 'schema' in params_dict['extract']:
+            params_dict['extract']['schema'] = self._ensure_schema_dict(params_dict['extract']['schema'])
+        if 'jsonOptions' in params_dict and params_dict['jsonOptions'] and 'schema' in params_dict['jsonOptions']:
+            params_dict['jsonOptions']['schema'] = self._ensure_schema_dict(params_dict['jsonOptions']['schema'])
+
         # Make request
         headers = self._prepare_headers(idempotency_key)
         response = await self._async_post_request(
@@ -3115,13 +3179,15 @@ class AsyncFirecrawlApp(FirecrawlApp):
         if proxy is not None:
             scrape_params['proxy'] = proxy
         if extract is not None:
-            if hasattr(extract.schema, 'schema'):
-                extract.schema = extract.schema.schema()
-            scrape_params['extract'] = extract.dict(exclude_none=True)
+            extract = self._ensure_schema_dict(extract)
+            if isinstance(extract, dict) and "schema" in extract:
+                extract["schema"] = self._ensure_schema_dict(extract["schema"])
+            scrape_params['extract'] = extract if isinstance(extract, dict) else extract.dict(exclude_none=True)
         if json_options is not None:
-            if hasattr(json_options.schema, 'schema'):
-                json_options.schema = json_options.schema.schema()
-            scrape_params['jsonOptions'] = json_options.dict(exclude_none=True)
+            json_options = self._ensure_schema_dict(json_options)
+            if isinstance(json_options, dict) and "schema" in json_options:
+                json_options["schema"] = self._ensure_schema_dict(json_options["schema"])
+            scrape_params['jsonOptions'] = json_options if isinstance(json_options, dict) else json_options.dict(exclude_none=True)
         if actions is not None:
             scrape_params['actions'] = [action.dict(exclude_none=True) for action in actions]
         if agent is not None:
@@ -3136,6 +3202,11 @@ class AsyncFirecrawlApp(FirecrawlApp):
         params_dict['urls'] = urls
         params_dict['origin'] = f"python-sdk@{version}"
 
+        if 'extract' in params_dict and params_dict['extract'] and 'schema' in params_dict['extract']:
+            params_dict['extract']['schema'] = self._ensure_schema_dict(params_dict['extract']['schema'])
+        if 'jsonOptions' in params_dict and params_dict['jsonOptions'] and 'schema' in params_dict['jsonOptions']:
+            params_dict['jsonOptions']['schema'] = self._ensure_schema_dict(params_dict['jsonOptions']['schema'])
+
         # Make request
         headers = self._prepare_headers(idempotency_key)
         response = await self._async_post_request(
@@ -3593,10 +3664,7 @@ class AsyncFirecrawlApp(FirecrawlApp):
             raise ValueError("Either urls or prompt is required")
 
         if schema:
-            if hasattr(schema, 'model_json_schema'):
-                # Convert Pydantic model to JSON schema
-                schema = schema.model_json_schema()
-            # Otherwise assume it's already a JSON schema dict
+            schema = self._ensure_schema_dict(schema)
 
         request_data = {
             'urls': urls or [],
@@ -3850,8 +3918,7 @@ class AsyncFirecrawlApp(FirecrawlApp):
             raise ValueError("Either urls or prompt is required")
 
         if schema:
-            if hasattr(schema, 'model_json_schema'):
-                schema = schema.model_json_schema()
+            schema = self._ensure_schema_dict(schema)
 
         request_data = ExtractResponse(
             urls=urls or [],

{firecrawl-2.4.3.dist-info → firecrawl-2.5.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: firecrawl
-Version: 2.4.3
+Version: 2.5.1
 Summary: Python SDK for Firecrawl API
 Home-page: https://github.com/mendableai/firecrawl
 Author: Mendable.ai

firecrawl-2.5.1.dist-info/RECORD

@@ -0,0 +1,33 @@
+build/lib/build/lib/build/lib/firecrawl/__init__.py,sha256=J1HgnaGyIrbk_5clFRTAb3XWfy9m3at1i8RFYzn5O0Q,2593
+build/lib/build/lib/build/lib/firecrawl/firecrawl.py,sha256=RyUiKke08spOP6iSUgJ9_dz6l-D_dkGB4aA6UDPWiXI,188709
+build/lib/build/lib/build/lib/firecrawl/__tests__/e2e_withAuth/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+build/lib/build/lib/build/lib/firecrawl/__tests__/e2e_withAuth/test.py,sha256=-Fq2vPcMo0iQi4dwsUkkCd931ybDaTxMBnZbRfGdDcA,7931
+build/lib/build/lib/build/lib/firecrawl/__tests__/v1/e2e_withAuth/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+build/lib/build/lib/build/lib/firecrawl/__tests__/v1/e2e_withAuth/test.py,sha256=DcCw-cohtnL-t9XPekUtRoQrgg3UCWu8Ikqudf9ory8,19880
+build/lib/build/lib/build/lib/tests/test_change_tracking.py,sha256=_IJ5ShLcoj2fHDBaw-nE4I4lHdmDB617ocK_XMHhXps,4177
+build/lib/build/lib/firecrawl/__init__.py,sha256=J1HgnaGyIrbk_5clFRTAb3XWfy9m3at1i8RFYzn5O0Q,2593
+build/lib/build/lib/firecrawl/firecrawl.py,sha256=RyUiKke08spOP6iSUgJ9_dz6l-D_dkGB4aA6UDPWiXI,188709
+build/lib/build/lib/firecrawl/__tests__/e2e_withAuth/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+build/lib/build/lib/firecrawl/__tests__/e2e_withAuth/test.py,sha256=-Fq2vPcMo0iQi4dwsUkkCd931ybDaTxMBnZbRfGdDcA,7931
+build/lib/build/lib/firecrawl/__tests__/v1/e2e_withAuth/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+build/lib/build/lib/firecrawl/__tests__/v1/e2e_withAuth/test.py,sha256=DcCw-cohtnL-t9XPekUtRoQrgg3UCWu8Ikqudf9ory8,19880
+build/lib/build/lib/tests/test_change_tracking.py,sha256=_IJ5ShLcoj2fHDBaw-nE4I4lHdmDB617ocK_XMHhXps,4177
+build/lib/firecrawl/__init__.py,sha256=J1HgnaGyIrbk_5clFRTAb3XWfy9m3at1i8RFYzn5O0Q,2593
+build/lib/firecrawl/firecrawl.py,sha256=RyUiKke08spOP6iSUgJ9_dz6l-D_dkGB4aA6UDPWiXI,188709
+build/lib/firecrawl/__tests__/e2e_withAuth/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+build/lib/firecrawl/__tests__/e2e_withAuth/test.py,sha256=-Fq2vPcMo0iQi4dwsUkkCd931ybDaTxMBnZbRfGdDcA,7931
+build/lib/firecrawl/__tests__/v1/e2e_withAuth/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+build/lib/firecrawl/__tests__/v1/e2e_withAuth/test.py,sha256=DcCw-cohtnL-t9XPekUtRoQrgg3UCWu8Ikqudf9ory8,19880
+build/lib/tests/test_change_tracking.py,sha256=_IJ5ShLcoj2fHDBaw-nE4I4lHdmDB617ocK_XMHhXps,4177
+firecrawl/__init__.py,sha256=J1HgnaGyIrbk_5clFRTAb3XWfy9m3at1i8RFYzn5O0Q,2593
+firecrawl/firecrawl.py,sha256=RyUiKke08spOP6iSUgJ9_dz6l-D_dkGB4aA6UDPWiXI,188709
+firecrawl/__tests__/e2e_withAuth/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+firecrawl/__tests__/e2e_withAuth/test.py,sha256=-Fq2vPcMo0iQi4dwsUkkCd931ybDaTxMBnZbRfGdDcA,7931
+firecrawl/__tests__/v1/e2e_withAuth/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+firecrawl/__tests__/v1/e2e_withAuth/test.py,sha256=DcCw-cohtnL-t9XPekUtRoQrgg3UCWu8Ikqudf9ory8,19880
+tests/test_change_tracking.py,sha256=_IJ5ShLcoj2fHDBaw-nE4I4lHdmDB617ocK_XMHhXps,4177
+firecrawl-2.5.1.dist-info/LICENSE,sha256=nPCunEDwjRGHlmjvsiDUyIWbkqqyj3Ej84ntnh0g0zA,1084
+firecrawl-2.5.1.dist-info/METADATA,sha256=jBHAE4mNK7Yq2NA2pPSN5_Rg_aVFztHCO1DLN5PaaQ0,7165
+firecrawl-2.5.1.dist-info/WHEEL,sha256=2wepM1nk4DS4eFpYrW1TTqPcoGNfHhhO_i5m4cOimbo,92
+firecrawl-2.5.1.dist-info/top_level.txt,sha256=ytN_R30g2U2qZYFyIm710Z8QeK9FO1Uwa-WPGHXyqjE,27
+firecrawl-2.5.1.dist-info/RECORD,,

{firecrawl-2.4.3.dist-info → firecrawl-2.5.1.dist-info}/top_level.txt

@@ -1,2 +1,4 @@
+build
+dist
 firecrawl
 tests

firecrawl-2.4.3.dist-info/RECORD

@@ -1,12 +0,0 @@
-firecrawl/__init__.py,sha256=VW7ON6xBoqPVlchUkJMjD92NZ_tNC-XsqG-M2sIvbc8,2570
-firecrawl/firecrawl.py,sha256=Q1opxN1JxjbWLEDsSS3P5aEm4f9LEJrZyhd8UdsMVFw,182769
-firecrawl/__tests__/e2e_withAuth/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-firecrawl/__tests__/e2e_withAuth/test.py,sha256=-Fq2vPcMo0iQi4dwsUkkCd931ybDaTxMBnZbRfGdDcA,7931
-firecrawl/__tests__/v1/e2e_withAuth/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-firecrawl/__tests__/v1/e2e_withAuth/test.py,sha256=DcCw-cohtnL-t9XPekUtRoQrgg3UCWu8Ikqudf9ory8,19880
-tests/test_change_tracking.py,sha256=_IJ5ShLcoj2fHDBaw-nE4I4lHdmDB617ocK_XMHhXps,4177
-firecrawl-2.4.3.dist-info/LICENSE,sha256=nPCunEDwjRGHlmjvsiDUyIWbkqqyj3Ej84ntnh0g0zA,1084
-firecrawl-2.4.3.dist-info/METADATA,sha256=XFy99h7X3oruTzlbEWMx3uvxfk-JiQ5FZxZolp5bzSw,7165
-firecrawl-2.4.3.dist-info/WHEEL,sha256=2wepM1nk4DS4eFpYrW1TTqPcoGNfHhhO_i5m4cOimbo,92
-firecrawl-2.4.3.dist-info/top_level.txt,sha256=8T3jOaSN5mtLghO-R3MQ8KO290gIX8hmfxQmglBPdLE,16
-firecrawl-2.4.3.dist-info/RECORD,,