alita-sdk 0.3.603__py3-none-any.whl → 0.3.611__py3-none-any.whl

alita_sdk/tools/figma/api_wrapper.py

@@ -369,50 +369,94 @@ class FigmaApiWrapper(NonCodeIndexerToolkit):
             )
 
     def _base_loader(
-            self,
-            url: Optional[str] = None,
-            file_keys_include: Optional[List[str]] = None,
-            file_keys_exclude: Optional[List[str]] = None,
-            node_ids_include: Optional[List[str]] = None,
-            node_ids_exclude: Optional[List[str]] = None,
-            node_types_include: Optional[List[str]] = None,
-            node_types_exclude: Optional[List[str]] = None,
-            number_of_threads: Optional[int] = None,
-            **kwargs
+        self,
+        urls_or_file_keys: Optional[str] = None,
+        node_ids_include: Optional[List[str]] = None,
+        node_ids_exclude: Optional[List[str]] = None,
+        node_types_include: Optional[List[str]] = None,
+        node_types_exclude: Optional[List[str]] = None,
+        number_of_threads: Optional[int] = None,
+        **kwargs,
     ) -> Generator[Document, None, None]:
-        if url:
-            file_key, node_ids_from_url = self._parse_figma_url(url)
-            # Override include params based on URL
-            file_keys_include = [file_key]
-            if node_ids_from_url and not node_ids_include:
-                node_ids_include = node_ids_from_url
-        
-        # If both include and exclude are provided, use only include
-        if file_keys_include:
-            self._log_tool_event(f"Loading files: {file_keys_include}")
-            for file_key in file_keys_include:
-                self._log_tool_event(f"Loading file `{file_key}`")
-                file = self._client.get_file(file_key, geometry='depth=1') # fetch only top-level structure (only pages without inner components)
-                if not file:
-                    raise ToolException(f"Unexpected error while retrieving file {file_key}. Please try specifying the node-id of an inner page.")
-                # propagate per-call number_of_threads override via metadata so _process_document can respect it
-                metadata = {
-                    'id': file_key,
-                    'file_key': file_key,
-                    'name': file.name,
-                    'updated_on': file.last_modified,
-                    'figma_pages_include': node_ids_include or [],
-                    'figma_pages_exclude': node_ids_exclude or [],
-                    'figma_nodes_include': node_types_include or [],
-                    'figma_nodes_exclude': node_types_exclude or [],
-                }
-                if isinstance(number_of_threads, int) and 1 <= number_of_threads <= 5:
-                    metadata['number_of_threads_override'] = number_of_threads
-                yield Document(page_content=json.dumps(metadata), metadata=metadata)
-        elif file_keys_exclude or node_ids_exclude:
-            raise ValueError("Excludes without parent (file_keys_include) do not make sense.")
-        else:
-            raise ValueError("You must provide file_keys_include or a URL.")
+        """Base loader used by the indexer tool.
+
+        Args:
+            urls_or_file_keys: Comma-separated list of Figma file URLs or raw file keys. Each
+                entry can be:
+                  - a full Figma URL (https://www.figma.com/file/... or /design/...) optionally
+                    with a node-id query parameter, or
+                  - a bare file key string.
+                URL entries are parsed via _parse_figma_url; raw keys are used as-is.
+            node_ids_include: Optional list of top-level node IDs (pages) to include when an
+                entry does not specify node-id in the URL and is not otherwise constrained.
+            node_ids_exclude: Optional list of top-level node IDs (pages) to exclude when
+                node_ids_include is not provided.
+            node_types_include: Optional list of node types to include within each page.
+            node_types_exclude: Optional list of node types to exclude when node_types_include
+                is not provided.
+            number_of_threads: Optional override for number of worker threads to use when
+                processing images.
+        """
+        if not urls_or_file_keys:
+            raise ValueError("You must provide urls_or_file_keys with at least one URL or file key.")
+
+        # Parse the comma-separated entries into concrete (file_key, per_entry_node_ids_include)
+        entries = [item.strip() for item in urls_or_file_keys.split(',') if item.strip()]
+        if not entries:
+            raise ValueError("You must provide urls_or_file_keys with at least one non-empty value.")
+
+        # Validate number_of_threads override once and pass via metadata
+        metadata_threads_override: Optional[int] = None
+        if isinstance(number_of_threads, int) and 1 <= number_of_threads <= 5:
+            metadata_threads_override = number_of_threads
+
+        for entry in entries:
+            per_file_node_ids_include: Optional[List[str]] = None
+            file_key: Optional[str] = None
+
+            # Heuristic: treat as URL if it has a scheme and figma.com host
+            if entry.startswith("http://") or entry.startswith("https://"):
+                file_key, node_ids_from_url = self._parse_figma_url(entry)
+                per_file_node_ids_include = node_ids_from_url
+            else:
+                # Assume this is a raw file key
+                file_key = entry
+
+            if not file_key:
+                continue
+
+            # If URL-derived node IDs exist, they take precedence over global include list
+            effective_node_ids_include = per_file_node_ids_include or node_ids_include or []
+
+            self._log_tool_event(f"Loading file `{file_key}`")
+            try:
+                file = self._client.get_file(file_key, geometry='depth=1')
+            except ToolException as e:
+                # Enrich the error message with the file_key for easier troubleshooting
+                raise ToolException(
+                    f"Failed to retrieve Figma file '{file_key}'. Original error: {e}"
+                ) from e
+
+            if not file:
+                raise ToolException(
+                    f"Unexpected error while retrieving file {file_key}. Please try specifying the node-id of an inner page."
+                )
+
+            metadata = {
+                'id': file_key,
+                'file_key': file_key,
+                'name': file.name,
+                'updated_on': file.last_modified,
+                'figma_pages_include': effective_node_ids_include,
+                'figma_pages_exclude': node_ids_exclude or [],
+                'figma_nodes_include': node_types_include or [],
+                'figma_nodes_exclude': node_types_exclude or [],
+            }
+
+            if metadata_threads_override is not None:
+                metadata['number_of_threads_override'] = metadata_threads_override
+
+            yield Document(page_content=json.dumps(metadata), metadata=metadata)
 
     def has_image_representation(self, node):
         node_type = node.get('type', '').lower()
@@ -672,44 +716,58 @@ class FigmaApiWrapper(NonCodeIndexerToolkit):
                     )
 
     def _index_tool_params(self):
-         """Return the parameters for indexing data."""
-         return {
-             "url": (Optional[str], Field(
-                 description=(
-                     "Full Figma file or page URL to index. Must be in one of the following formats: "
-                     "'https://www.figma.com/file/<FILE_KEY>/...' or 'https://www.figma.com/design/<FILE_KEY>/...'. "
-                     "If present, the 'node-id' query parameter (e.g. '?node-id=<PAGE_ID>') will be used to limit "
-                     "indexing to that page or node. When this URL is provided, it overrides 'file_keys_include' ('node_ids_include')."
-                 ),
-                 default=None)),
-             'number_of_threads': (Optional[int], Field(
-                 description=(
-                     "Optional override for the number of worker threads used when indexing Figma images. "
-                     f"Valid values are from 1 to 5. Default is {DEFAULT_NUMBER_OF_THREADS}."
-                 ),
-                 default=DEFAULT_NUMBER_OF_THREADS,
-                 ge=1,
-                 le=5,
-             )),
-              'file_keys_include': (Optional[List[str]], Field(
-                  description="List of file keys to include in index if project_id is not provided: i.e. ['Fp24FuzPwH0L74ODSrCnQo', 'jmhAr6q78dJoMRqt48zisY']",
-                  default=None)),
-             'file_keys_exclude': (Optional[List[str]], Field(
-                 description="List of file keys to exclude from index. It is applied only if project_id is provided and file_keys_include is not provided: i.e. ['Fp24FuzPwH0L74ODSrCnQo', 'jmhAr6q78dJoMRqt48zisY']",
-                 default=None)),
-             'node_ids_include': (Optional[List[str]], Field(
-                 description="List of top-level nodes (pages) in file to include in index. It is node-id from figma url: i.e. ['123-56', '7651-9230'].",
-                 default=None)),
-             'node_ids_exclude': (Optional[List[str]], Field(
-                 description="List of top-level nodes (pages) in file to exclude from index. It is applied only if node_ids_include is not provided. It is node-id from figma url: i.e. ['Fp24FuzPwH0L74ODSrCnQo', 'jmhAr6q78dJoMRqt48zisY']",
-                 default=None)),
-             'node_types_include': (Optional[List[str]], Field(
-                 description="List type of nodes to include in index: i.e. ['FRAME', 'COMPONENT', 'RECTANGLE', 'COMPONENT_SET', 'INSTANCE', 'VECTOR', ...].",
-                 default=None)),
-             'node_types_exclude': (Optional[List[str]], Field(
-                 description="List type of nodes to exclude from index. It is applied only if node_types_include is not provided: i.e. ['FRAME', 'COMPONENT', 'RECTANGLE', 'COMPONENT_SET', 'INSTANCE', 'VECTOR', ...]",
-                 default=None)),
-         }
+        """Return the parameters for indexing data."""
+        return {
+            "urls_or_file_keys": (str, Field(
+                description=(
+                    "Comma-separated list of Figma file URLs or raw file keys to index. "
+                    "Each entry may be a full Figma URL (with optional node-id query) or a file key. "
+                    "Example: 'https://www.figma.com/file/<FILE_KEY>/...?node-id=<NODE_ID>,Fp24FuzPwH0L74ODSrCnQo'."
+                ))),
+            'number_of_threads': (Optional[int], Field(
+                description=(
+                    "Optional override for the number of worker threads used when indexing Figma images. "
+                    f"Valid values are from 1 to 5. Default is {DEFAULT_NUMBER_OF_THREADS}."
+                ),
+                default=DEFAULT_NUMBER_OF_THREADS,
+                ge=1,
+                le=5,
+            )),
+            'node_ids_include': (Optional[List[str]], Field(
+                description=(
+                    "List of top-level node IDs (pages) to include in the index. Values should match "
+                    "Figma node-id format like ['123-56', '7651-9230']. These include rules are applied "
+                    "for each entry in urls_or_file_keys when the URL does not specify node-id and for "
+                    "each raw file_key entry."
+                ),
+                default=None,
+            )),
+            'node_ids_exclude': (Optional[List[str]], Field(
+                description=(
+                    "List of top-level node IDs (pages) to exclude from the index when node_ids_include "
+                    "is not provided. Values should match Figma node-id format. These exclude rules are "
+                    "applied for each entry in urls_or_file_keys (URLs without node-id and raw fileKey "
+                    "entries)."
+                ),
+                default=None,
+            )),
+            'node_types_include': (Optional[List[str]], Field(
+                description=(
+                    "List of node types to include in the index, e.g. ['FRAME', 'COMPONENT', 'RECTANGLE', "
+                    "'COMPONENT_SET', 'INSTANCE', 'VECTOR', ...]. If provided, only these types are indexed "
+                    "for each page loaded from each urls_or_file_keys entry."
+                ),
+                default=None,
+            )),
+            'node_types_exclude': (Optional[List[str]], Field(
+                description=(
+                    "List of node types to exclude from the index when node_types_include is not provided. "
+                    "These exclude rules are applied to nodes within each page loaded from each "
+                    "urls_or_file_keys entry."
+                ),
+                default=None,
+            )),
+        }
 
     def _send_request(
         self,
@@ -972,8 +1030,7 @@ class FigmaApiWrapper(NonCodeIndexerToolkit):
 
         # Delegate URL and file_key handling to _base_loader
         base_docs = self._base_loader(
-            url=url,
-            file_keys_include=[file_key] if file_key else None,
+            urls_or_file_keys=url or file_key,
             node_ids_include=node_ids_include_list,
             node_ids_exclude=node_ids_exclude_list,
         )

alita_sdk/tools/github/graphql_client_wrapper.py

@@ -1464,6 +1464,7 @@ class GraphQLClientWrapper(BaseModel):
 
         missing_fields = []
         fields_to_update = []
+        updated_fields = []
 
         if fields:
             try:

alita_sdk/tools/utils/text_operations.py

@@ -26,48 +26,119 @@ TEXT_EDITABLE_EXTENSIONS = {
 def parse_old_new_markers(file_query: str) -> List[Tuple[str, str]]:
     """Parse OLD/NEW marker-based edit instructions.
 
-    Extracts pairs of old and new content from a file query using markers in
-    a minimal, regex-based way without additional line splitting logic.
-
-    Supported forms (OLD/NEW blocks must appear in pairs):
-    - OLD <<<< ... >>>> OLD
-      NEW <<<< ... >>>> NEW
-    - If no such pairs are found, we also accept the slightly incorrect
-      "<<<" form as a fallback:
-      OLD <<< ... >>> OLD
-      NEW <<< ... >>> NEW
+    Format:
+
+        OLD <<<<[optional text or newline]
+        ... OLD content ...
+        >>>> OLD
+        NEW <<<<[optional text or newline]
+        ... NEW content ...
+        >>>> NEW
+
+    Rules:
+    - OLD block:
+      - Starts at the first line that contains "OLD <<<<".
+      - OLD content includes:
+        * On that line: everything after the first "OLD <<<<" (if any),
+        * Plus all following lines up to (but not including) the first line
+          that contains ">>>> OLD".
+    - NEW block:
+      - Starts at the first line, after the OLD block, that contains "NEW <<<<".
+      - NEW content includes:
+        * On that line: everything after the first "NEW <<<<" (if any),
+        * Plus all following lines up to (but not including) the first line
+          that contains ">>>> NEW".
+    - Only the first complete OLD/NEW pair is returned.
 
     Args:
         file_query: String containing marked old and new content sections.
 
     Returns:
-        List of (old_content, new_content) tuples, where each content string
-        is the raw inner block (with leading/trailing whitespace stripped),
-        but otherwise unmodified.
+        A list with at most one (old_content, new_content) tuple. Each
+        content string includes newlines but excludes the marker substrings
+        and their closing lines.
     """
-    # Primary pattern: correct 4-< markers
-    pattern_primary = re.compile(
-        r"OLD <<<<(\s*.*?\s*)>>>> OLD"  # OLD block
-        r"\s*"                          # optional whitespace between OLD/NEW
-        r"NEW <<<<(\s*.*?\s*)>>>> NEW",  # NEW block
-        re.DOTALL,
-    )
 
-    matches = pattern_primary.findall(file_query)
+    if not file_query:
+        return []
 
-    # Fallback pattern: accept 3-< markers if no proper 4-< markers found
-    if not matches:
-        pattern_fallback = re.compile(
-            r"OLD <<<(\s*.*?\s*)>>>> OLD"   # OLD block (3 < and 4 > to support previous version)
-            r"\s*"                          # optional whitespace between OLD/NEW
-            r"NEW <<<(\s*.*?\s*)>>>> NEW",  # NEW block (3 < and 4 > to support previous version)
-            re.DOTALL,
-        )
-        matches = pattern_fallback.findall(file_query)
+    lines = file_query.splitlines(keepends=True)
+
+    old_open = "OLD <<<<"
+    old_close = ">>>> OLD"
+    new_open = "NEW <<<<"
+    new_close = ">>>> NEW"
+
+    state = "search_old"  # -> in_old -> search_new -> in_new
+    old_parts: list[str] = []
+    new_parts: list[str] = []
+
+    i = 0
+    n = len(lines)
+
+    # 1. Find OLD block
+    while i < n and state == "search_old":
+        line = lines[i]
+        pos = line.find(old_open)
+        if pos != -1:
+            # Start OLD content after the first "OLD <<<<" on this line
+            after = line[pos + len(old_open):]
+            old_parts.append(after)
+            state = "in_old"
+        i += 1
+
+    if state != "in_old":
+        # No OLD block found
+        return []
+
+    # Collect until a line containing ">>>> OLD"
+    while i < n and state == "in_old":
+        line = lines[i]
+        if old_close in line:
+            # Stop before this line; do not include any part of it
+            state = "search_new"
+        else:
+            old_parts.append(line)
+        i += 1
+
+    if state != "search_new":
+        # Didn't find a proper OLD close
+        return []
+
+    # 2. Find NEW block after OLD
+    while i < n and state == "search_new":
+        line = lines[i]
+        pos = line.find(new_open)
+        if pos != -1:
+            # NEW content starts from the *next* line after the marker line
+            state = "in_new"
+            i += 1
+            break
+        i += 1
+
+    if state != "in_new":
+        # No NEW block found
+        return []
+
+    # Collect until a line containing ">>>> NEW"
+    while i < n and state == "in_new":
+        line = lines[i]
+        close_pos = line.rfind(new_close)
+        if close_pos != -1:
+            # Include content up to but not including the *last* ">>>> NEW" on the line
+            before_close = line[:close_pos]
+            new_parts.append(before_close)
+            break
+        else:
+            new_parts.append(line)
+        i += 1
+
+    if not old_parts or not new_parts:
+        return []
 
-    # Preserve block content exactly as captured so Stage 1 can use exact
-    # substring replacement (including indentation and trailing spaces).
-    return [(old_block, new_block) for old_block, new_block in matches]
+    old_content = "".join(old_parts)
+    new_content = "".join(new_parts)
+    return [(old_content, new_content)]
 
 
 def is_text_editable(filename: str) -> bool:
@@ -250,7 +321,7 @@ def try_apply_edit(
     old_text: str,
     new_text: str,
     file_path: Optional[str] = None,
-) -> Tuple[str, bool]:
+) -> Tuple[str, Optional[str]]:
     """Apply a single OLD/NEW edit with a tolerant fallback.
 
     This helper is used by edit_file to apply one (old_text, new_text) pair:
@@ -271,21 +342,53 @@ def try_apply_edit(
         file_path: Optional path for logging context
     
     Returns:
-        (updated_content, used_fallback)
+        (updated_content, warning_message)
+        - updated_content: resulting content (may be unchanged)
+        - warning_message: human-readable warning if no edit was applied
+          or if the operation was ambiguous; None if an edit was
+          successfully and unambiguously applied.
     """
     # Stage 1: exact match
-    if old_text in content:
-        return content.replace(old_text, new_text), False
+    if old_text:
+        occurrences = content.count(old_text)
+        if occurrences == 1:
+            return content.replace(old_text, new_text, 1), None
+        if occurrences > 1:
+            msg = (
+                "Exact OLD block appears %d times in %s; no replacement applied to avoid ambiguity. "
+                "OLD value: %r" % (
+                    occurrences,
+                    file_path or "<unknown>",
+                    old_text,
+                )
+            )
+            logger.warning(msg)
+            return content, msg
 
     # Stage 2: tolerant match
-    if not old_text.strip() or not content:
-        return content, False
+    if not old_text or not old_text.strip() or not content:
+        msg = None
+        if not old_text or not old_text.strip():
+            msg = (
+                "OLD block is empty or whitespace-only; no replacement applied. "
+                "OLD value: %r" % (old_text,)
+            )
+        elif not content:
+            msg = "Content is empty; no replacement applied."
+        if msg:
+            logger.warning(msg)
+        return content, msg
 
     # Logical OLD: drop empty/whitespace-only lines
     old_lines_raw = old_text.splitlines()
     old_lines = [l for l in old_lines_raw if l.strip()]
     if not old_lines:
-        return content, False
+        msg = (
+            "OLD block contains only empty/whitespace lines; no replacement applied. "
+            "OLD value: %r" % (old_text,)
+        )
+        logger.warning(msg)
+        return content, msg
 
     # Precompute normalized OLD (joined by '\n')
     norm_old = _normalize_for_match("\n".join(old_lines))
@@ -318,29 +421,30 @@ def try_apply_edit(
             candidates.append((start, idx, block))
 
     if not candidates:
-        logger.warning(
-            "Fallback match: normalized OLD block not found in %s.",
-            file_path or "<unknown>",
+        msg = (
+            "Normalized OLD block not found in %s. OLD value: %r"
+            % (file_path or "<unknown>", old_text)
         )
-        return content, False
+        logger.warning(msg)
+        return content, msg
 
     if len(candidates) > 1:
-        logger.warning(
-            "Fallback match: multiple candidate regions for OLD block in %s; "
-            "no change applied to avoid ambiguity.",
-            file_path or "<unknown>",
+        msg = (
+            "Multiple candidate regions for OLD block in %s; "
+            "no change applied to avoid ambiguity. OLD value: %r"
+            % (file_path or "<unknown>", old_text)
         )
-        return content, False
+        logger.warning(msg)
+        return content, msg
 
     start_idx, end_idx, candidate_block = candidates[0]
     updated = content.replace(candidate_block, new_text, 1)
 
     logger.info(
-        "Fallback match: applied tolerant OLD/NEW replacement in %s around lines %d-%d",
+        "Applied tolerant OLD/NEW replacement in %s around lines %d-%d",
         file_path or "<unknown>",
         start_idx + 1,
         start_idx + len(old_lines),
     )
 
-    return updated, True
-
+    return updated, None

{alita_sdk-0.3.603.dist-info → alita_sdk-0.3.611.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: alita_sdk
-Version: 0.3.603
+Version: 0.3.611
 Summary: SDK for building langchain agents using resources from Alita
 Author-email: Artem Rozumenko <artyom.rozumenko@gmail.com>, Mikalai Biazruchka <mikalai_biazruchka@epam.com>, Roman Mitusov <roman_mitusov@epam.com>, Ivan Krakhmaliuk <lifedj27@gmail.com>, Artem Dubrovskiy <ad13box@gmail.com>
 License-Expression: Apache-2.0