Merge remote-tracking branch 'refs/remotes/origin/feature/michaelim/monday-docs-fetcher' into feature/tomersh/allow_non_ascii_updates

# Conflicts:
#	setup.py

Author: tomermonday

setup.py

@@ -15,7 +15,7 @@
 
 setup(
     name="monday-api-python-sdk",  # Required
-    version="1.4.6",  # Required
+    version="1.4.7",  # Required
     description="A Python SDK for interacting with Monday's GraphQL API",  # Optional
     long_description=long_description,  # Optional
     long_description_content_type="text/markdown",  # Optional (see note above)

src/monday_sdk/client.py

@@ -1,18 +1,26 @@
-from .types import MondayClientSettings
-from .modules import BoardModule, ItemModule, UpdateModule, CustomModule, ActivityLogModule
+from .modules import BoardModule, ItemModule, UpdateModule, CustomModule, ActivityLogModule, DocsModule
 from .constants import API_VERSION, DEFAULT_MAX_RETRY_ATTEMPTS
+from .graphql_handler import MondayGraphQL
 
 BASE_HEADERS = {"API-Version": API_VERSION}
 
 
 class MondayClient:
     def __init__(self, token, headers=None, debug_mode=False, max_retry_attempts=DEFAULT_MAX_RETRY_ATTEMPTS):
-
         headers = headers or BASE_HEADERS.copy()
-        self.settings = MondayClientSettings(token, headers, debug_mode, max_retry_attempts)
+        
+        # Create a single GraphQL client instance
+        self._graphql_client = MondayGraphQL(
+            token=token,
+            headers=headers,
+            debug_mode=debug_mode,
+            max_retry_attempts=max_retry_attempts
+        )
 
-        self.boards = BoardModule(self.settings)
-        self.items = ItemModule(self.settings)
-        self.updates = UpdateModule(self.settings)
-        self.activity_logs = ActivityLogModule(self.settings)
-        self.custom = CustomModule(self.settings)
+        # Pass the GraphQL client to each module
+        self.boards = BoardModule(self._graphql_client)
+        self.items = ItemModule(self._graphql_client)
+        self.updates = UpdateModule(self._graphql_client)
+        self.activity_logs = ActivityLogModule(self._graphql_client)
+        self.custom = CustomModule(self._graphql_client)
+        self.docs = DocsModule(self._graphql_client)

src/monday_sdk/constants.py

@@ -1,10 +1,9 @@
 API_URL = "https://api.monday.com/v2"
-API_VERSION = "2023-10"
+API_VERSION = "2025-07"
 TOKEN_HEADER = "Authorization"
 MAX_COMPLEXITY = 10000000  # Monday's API complexity limit per minute
-BASE_HEADERS = {"API-Version": API_VERSION}
 
-DEFAULT_MAX_RETRY_ATTEMPTS = 3
+DEFAULT_MAX_RETRY_ATTEMPTS = 4
 DEFAULT_PAGE_LIMIT_ITEMS = 500
 DEFAULT_PAGE_LIMIT_UPDATES = 1000
 DEFAULT_PAGE_LIMIT_BOARDS = 50

src/monday_sdk/graphql_handler.py

@@ -3,22 +3,22 @@
 import json
 import time
 
+from .constants import API_URL, TOKEN_HEADER, DEFAULT_MAX_RETRY_ATTEMPTS
+from .types import MondayApiResponse
 from .exceptions import MondayQueryError
-from .constants import API_URL, TOKEN_HEADER
-from .types import MondayApiResponse, MondayClientSettings
 
 
 class MondayGraphQL:
     """
     GraphQL client that handles API interactions, response serialization, and error handling.
     """
 
-    def __init__(self, settings: MondayClientSettings):
+    def __init__(self, token: str, headers: dict, debug_mode: bool = False, max_retry_attempts: int = DEFAULT_MAX_RETRY_ATTEMPTS):
         self.endpoint = API_URL
-        self.token = settings.token
-        self.headers = settings.headers
-        self.debug_mode = settings.debug_mode
-        self.max_retry_attempts = settings.max_retry_attempts
+        self.token = token
+        self.headers = headers
+        self.debug_mode = debug_mode
+        self.max_retry_attempts = max_retry_attempts
 
     def execute(self, query: str) -> MondayApiResponse:
         """
@@ -31,6 +31,8 @@ def execute(self, query: str) -> MondayApiResponse:
             MondayApiResponse: The deserialized response from the Monday API.
         """
         current_attempt = 0
+        last_error = None
+        last_status_code = None
 
         while current_attempt < self.max_retry_attempts:
 
@@ -71,13 +73,35 @@ def execute(self, query: str) -> MondayApiResponse:
 
             except (requests.HTTPError, json.JSONDecodeError, MondayQueryError) as e:
                 print(f"Error while executing query: {e}")
+                last_error = e
+                if hasattr(e, 'response') and e.response is not None:
+                    last_status_code = e.response.status_code
                 current_attempt += 1
 
+        # All retries exhausted - raise appropriate error based on the last failure
+        if last_status_code == 504:
+            raise Exception(
+                f"Monday API server encountered an internal error (HTTP 504 Gateway Timeout) "
+                f"for {self.max_retry_attempts} consecutive attempts. The server was unable to process "
+                f"the request within the timeout period. Please try again later or contact support "
+                f"if the issue persists."
+            )
+        elif last_status_code is not None:
+            raise Exception(
+                f"Monday API request failed with HTTP {last_status_code} after {self.max_retry_attempts} attempts. "
+                f"Error: {str(last_error)}"
+            )
+        else:
+            raise Exception(
+                f"Monday API request failed after {self.max_retry_attempts} attempts. "
+                f"Error: {str(last_error)}"
+            )
+
     def _send(self, query: str):
         payload = {"query": query}
         headers = self.headers.copy()
 
         if self.token is not None:
             headers[TOKEN_HEADER] = self.token
 
-        return requests.request("POST", self.endpoint, headers=headers, json=payload)
+        return requests.request("POST", self.endpoint, headers=headers, json=payload)

src/monday_sdk/modules/__init__.py

@@ -3,3 +3,4 @@
 from .updates import UpdateModule
 from .custom import CustomModule
 from .activity_logs import ActivityLogModule
+from .docs import DocsModule

src/monday_sdk/modules/activity_logs.py

@@ -5,7 +5,9 @@
 from typing import Optional, Union, List
 
 
-class ActivityLogModule(MondayGraphQL):
+class ActivityLogModule:
+    def __init__(self, graphql_client: MondayGraphQL):
+        self.client = graphql_client
 
     def fetch_activity_logs_from_board(
         self,
@@ -16,7 +18,7 @@ def fetch_activity_logs_from_board(
         to_date: Optional[str] = None,
     ) -> MondayApiResponse:
         query = get_activity_logs_query(board_ids, limit, page, from_date, to_date)
-        return self.execute(query)
+        return self.client.execute(query)
 
     def fetch_all_activity_logs_from_board(
         self,

src/monday_sdk/modules/boards.py

@@ -7,7 +7,9 @@
 from ..constants import DEFAULT_PAGE_LIMIT_BOARDS, DEFAULT_PAGE_LIMIT_ITEMS
 
 
-class BoardModule(MondayGraphQL):
+class BoardModule:
+    def __init__(self, graphql_client: MondayGraphQL):
+        self.client = graphql_client
     def fetch_boards(
         self,
         limit: Optional[int] = DEFAULT_PAGE_LIMIT_BOARDS,
@@ -18,11 +20,11 @@ def fetch_boards(
         order_by: Optional[BoardsOrderBy] = None,
     ) -> MondayApiResponse:
         query = get_boards_query(ids=ids, limit=limit, page=page, board_kind=board_kind, state=state, order_by=order_by)
-        return self.execute(query)
+        return self.client.execute(query)
 
     def fetch_boards_by_id(self, board_id: Union[int, str]) -> MondayApiResponse:
         query = get_board_by_id_query(board_id)
-        return self.execute(query)
+        return self.client.execute(query)
 
     def fetch_all_items_by_board_id(
         self,
@@ -39,7 +41,7 @@ def fetch_all_items_by_board_id(
 
         while True:
             query = get_board_items_query(board_id, query_params=query_params, cursor=cursor, limit=limit)
-            response = self.execute(query)
+            response = self.client.execute(query)
             items_page = response.data.boards[0].items_page if cursor is None else response.data.next_items_page
 
             items.extend(items_page.items)
@@ -73,4 +75,4 @@ def fetch_item_by_board_id_by_update_date(
 
     def fetch_columns_by_board_id(self, board_id: Union[int, str]) -> MondayApiResponse:
         query = get_columns_by_board_query(board_id)
-        return self.execute(query)
+        return self.client.execute(query)

src/monday_sdk/modules/custom.py

@@ -1,6 +1,8 @@
 from ..graphql_handler import MondayGraphQL
 
 
-class CustomModule(MondayGraphQL):
+class CustomModule:
+    def __init__(self, graphql_client: MondayGraphQL):
+        self.client = graphql_client
     def execute_custom_query(self, custom_query):
-        return self.execute(custom_query)
+        return self.client.execute(custom_query)

src/monday_sdk/modules/docs.py

@@ -0,0 +1,52 @@
+from typing import Optional
+
+from ..query_templates import get_docs_query
+from ..types import MondayApiResponse, Document
+from ..graphql_handler import MondayGraphQL
+
+
+class DocsModule:
+    def __init__(self, graphql_client: MondayGraphQL):
+        self.client = graphql_client
+    def get_document_with_blocks(self, doc_id: str) -> Optional[Document]:
+        """
+        Get document with all its blocks for a specific document ID.
+        
+        Args:
+            doc_id: The document ID to fetch
+            
+        Returns:
+            Document object with all blocks, or None if not found
+        """
+        all_blocks = []
+        document = None
+        page = 1
+        
+        while True:
+            query = get_docs_query(doc_id, page=page)
+            response: MondayApiResponse = self.client.execute(query)
+            
+            # Check if we have docs in the response
+            if not response.data.docs:
+                break
+                
+            # Get the first (and should be only) document
+            doc = response.data.docs[0]
+            
+            # Store the document metadata on first iteration
+            if document is None:
+                document = doc
+                
+            # If no blocks, we're done
+            if not doc.blocks:
+                break
+                
+            all_blocks.extend(doc.blocks)
+            
+            page += 1
+            
+        # Update the document with all collected blocks
+        if document:
+            document.blocks = all_blocks
+            
+        return document

src/monday_sdk/modules/items.py

@@ -6,7 +6,9 @@
 from ..types import Item
 
 
-class ItemModule(MondayGraphQL):
+class ItemModule:
+    def __init__(self, graphql_client: MondayGraphQL):
+        self.client = graphql_client
     """ "
     todo: add types for this module
     """
@@ -21,13 +23,13 @@ def change_custom_column_value(
         for other columns, use this method, for example, for checkbox columns pass {'checked': True}
         """
         query = change_column_value_query(board_id, item_id, column_id, value)
-        return self.execute(query)
+        return self.client.execute(query)
 
     def change_simple_column_value(
         self, board_id: Union[str, int], item_id: Union[str, int], column_id: str, value: str
     ):
         query = change_simple_column_value_query(board_id, item_id, column_id, value)
-        return self.execute(query)
+        return self.client.execute(query)
 
     def change_status_column_value(
         self, board_id: Union[str, int], item_id: Union[str, int], column_id: str, value: str
@@ -50,7 +52,7 @@ def create_item(
         create_labels_if_missing=False,
     ):
         query = create_item_query(board_id, group_id, item_name, column_values, create_labels_if_missing)
-        return self.execute(query)
+        return self.client.execute(query)
 
     def create_subitem(
         self,
@@ -60,13 +62,13 @@ def create_subitem(
         create_labels_if_missing=False,
     ):
         query = create_subitem_query(parent_item_id, subitem_name, column_values, create_labels_if_missing)
-        return self.execute(query)
+        return self.client.execute(query)
 
     def fetch_items_by_column_value(
         self, board_id: Union[str, int], column_id: str, value: str, limit: int = None, cursor: str = None
     ):
         query = get_item_query(board_id, column_id, value, limit, cursor)
-        return self.execute(query)
+        return self.client.execute(query)
 
     def fetch_items_by_id(self, ids: Union[str, int, List[Union[str, int]]]) -> List[Item]:
         if isinstance(ids, (list, set)):
@@ -75,7 +77,7 @@ def fetch_items_by_id(self, ids: Union[str, int, List[Union[str, int]]]) -> List
         else:
             ids_str = str(ids)
         query = get_item_by_id_query(ids_str)
-        response = self.execute(query)
+        response = self.client.execute(query)
         return response.data.items
 
     def change_multiple_column_values(
@@ -86,16 +88,16 @@ def change_multiple_column_values(
         create_labels_if_missing: bool = False,
     ):
         query = update_multiple_column_values_query(board_id, item_id, column_values, create_labels_if_missing)
-        return self.execute(query)
+        return self.client.execute(query)
 
     def move_item_to_group(self, item_id: Union[str, int], group_id: Union[str, int]):
         query = move_item_to_group_query(item_id, group_id)
-        return self.execute(query)
+        return self.client.execute(query)
 
     def archive_item_by_id(self, item_id: Union[str, int]):
         query = archive_item_query(item_id)
-        return self.execute(query)
+        return self.client.execute(query)
 
     def delete_item_by_id(self, item_id: Union[str, int]):
         query = delete_item_query(item_id)
-        return self.execute(query)
+        return self.client.execute(query)