alita-sdk 0.3.322__py3-none-any.whl → 0.3.324__py3-none-any.whl

alita_sdk/runtime/langchain/document_loaders/AlitaExcelLoader.py

@@ -16,10 +16,11 @@ from typing import Iterator
 import pandas as pd
 from json import loads
 
-from langchain_core.tools import ToolException
+from openpyxl import load_workbook
 from langchain_core.documents import Document
 from .AlitaTableLoader import AlitaTableLoader
     
+cell_delimeter = " | "
 
 class AlitaExcelLoader(AlitaTableLoader):
 
@@ -39,32 +40,65 @@ class AlitaExcelLoader(AlitaTableLoader):
 
     def get_content(self):
         try:
-            dfs = pd.read_excel(self.file_path, sheet_name=self.sheet_name)
+            # Load the workbook
+            workbook = load_workbook(self.file_path, data_only=True)  # `data_only=True` ensures we get cell values, not formulas
 
-            if self.excel_by_sheets:
+            if self.sheet_name:
+                # If a specific sheet name is provided, parse only that sheet
+                if self.sheet_name in workbook.sheetnames:
+                    sheet_content = self.parse_sheet(workbook[self.sheet_name])
+                    return sheet_content
+                else:
+                    raise ValueError(f"Sheet '{self.sheet_name}' does not exist in the workbook.")
+            elif self.excel_by_sheets:
+                # Parse each sheet individually and return as a dictionary
                 result = {}
-                for sheet_name, df in dfs.items():
-                    df.fillna('', inplace=True)
-                    result[sheet_name] = self.parse_sheet(df)
+                for sheet_name in workbook.sheetnames:
+                    sheet_content = self.parse_sheet(workbook[sheet_name])
+                    result[sheet_name] = sheet_content
                 return result
             else:
+                # Combine all sheets into a single string result
                 result = []
-                for sheet_name, df in dfs.items():
-                    string_content = self.parse_sheet(df)
-                    result.append(f"====== Sheet name: {sheet_name} ======\n{string_content}")
+                for sheet_name in workbook.sheetnames:
+                    sheet_content = self.parse_sheet(workbook[sheet_name])
+                    result.append(f"====== Sheet name: {sheet_name} ======\n{sheet_content}")
                 return "\n\n".join(result)
         except Exception as e:
-            return ToolException(f"Error reading Excel file: {e}")
+            return f"Error reading Excel file: {e}"
 
-    def parse_sheet(self, df):
-        df.fillna('', inplace=True)
+    def parse_sheet(self, sheet):
+        """
+        Parses a single sheet, extracting text and hyperlinks, and formats them.
+        """
+        sheet_content = []
 
+        for row in sheet.iter_rows():
+            row_content = []
+            for cell in row:
+                if cell.hyperlink:
+                    # If the cell has a hyperlink, format it as Markdown
+                    hyperlink = cell.hyperlink.target
+                    cell_value = cell.value or ''  # Use cell value or empty string
+                    row_content.append(f"[{cell_value}]({hyperlink})")
+                else:
+                    # If no hyperlink, use the cell value (computed value if formula)
+                    row_content.append(str(cell.value) if cell.value is not None else "")
+            # Join the row content into a single line using `|` as the delimiter
+            sheet_content.append(cell_delimeter.join(row_content))
+
+        # Format the sheet content based on the return type
         if self.return_type == 'dict':
-            return df.to_dict(orient='records')
+            # Convert to a list of dictionaries (each row is a dictionary)
+            headers = sheet_content[0].split(cell_delimeter) if sheet_content else []
+            data_rows = sheet_content[1:] if len(sheet_content) > 1 else []
+            return [dict(zip(headers, row.split(cell_delimeter))) for row in data_rows]
         elif self.return_type == 'csv':
-            return df.to_csv()
+            # Return as CSV (newline-separated rows, comma-separated values)
+            return "\n".join([",".join(row.split(cell_delimeter)) for row in sheet_content])
         else:
-            return df.to_string(index=False)
+            # Default: Return as plain text (newline-separated rows, pipe-separated values)
+            return "\n".join(sheet_content)
 
     def load(self) -> list:
         docs = []

alita_sdk/runtime/langchain/document_loaders/AlitaPDFLoader.py

@@ -1,4 +1,5 @@
 import pymupdf
+import fitz
 from langchain_community.document_loaders import PyPDFLoader
 
 from .ImageParser import ImageParser
@@ -43,8 +44,59 @@ class AlitaPDFLoader:
         return text_content
 
     def read_pdf_page(self, report, page, index):
-        text_content = f'Page: {index}\n'
-        text_content += page.get_text()
+        # Extract text in block format (to more accurately match hyperlinks to text)
+        text_blocks = page.get_text("blocks")  # Returns a list of text blocks
+        words = page.get_text("words")  # Returns words with their coordinates
+
+        # Extract hyperlinks
+        links = page.get_links()
+
+        # Create a list to store the modified text
+        modified_text = []
+
+        for block in text_blocks:
+            block_rect = fitz.Rect(block[:4])  # Coordinates of the text block
+            block_text = block[4]  # The actual text of the block
+
+            # Check if there are hyperlinks intersecting with this text block
+            for link in links:
+                if "uri" in link:  # Ensure this is a hyperlink
+                    link_rect = link["from"]  # Coordinates of the hyperlink area
+                    link_uri = link["uri"]  # The URL of the hyperlink
+
+                    # Expand the hyperlink area slightly to account for inaccuracies
+                    link_rect = fitz.Rect(
+                        link_rect.x0 - 1, link_rect.y0 - 1, link_rect.x1 + 1, link_rect.y1 + 1
+                    )
+
+                    # Find words that are inside the hyperlink area
+                    link_text = []
+                    for word in words:
+                        word_rect = fitz.Rect(word[:4])  # Coordinates of the word
+                        word_text = word[4]
+
+                        # Check if the word rectangle is fully inside the hyperlink rectangle
+                        if link_rect.contains(word_rect):
+                            link_text.append(word_text)
+                        # If the word partially intersects, check vertical alignment
+                        elif link_rect.intersects(word_rect):
+                            # Condition: The word must be on the same line as the hyperlink
+                            if abs(link_rect.y0 - word_rect.y0) < 2 and abs(link_rect.y1 - word_rect.y1) < 2:
+                                link_text.append(word_text)
+
+                    # Format the hyperlink in Markdown
+                    full_text = " ".join(link_text) if link_text else "No text"
+                    hyperlink = f"[{full_text}]({link_uri})"
+
+                    # Replace the hyperlink text in the block with the formatted hyperlink
+                    block_text = block_text.replace(full_text, hyperlink)
+
+            # Add the processed text block to the result
+            modified_text.append(block_text)
+
+        # Combine all text blocks into the final text for the page
+        text_content = f'Page: {index}\n' + "\n".join(modified_text)
+
         if self.extract_images:
             images = page.get_images(full=True)
             for i, img in enumerate(images):

alita_sdk/runtime/langchain/langraph_agent.py

@@ -584,11 +584,19 @@ def create_graph(
             entry_point = clean_string(schema['entry_point'])
         except KeyError:
             raise ToolException("Entry point is not defined in the schema. Please define 'entry_point' in the schema.")
-        if state.items():
-            state_default_node = StateDefaultNode(default_vars=set_defaults(state))
-            lg_builder.add_node(state_default_node.name, state_default_node)
-            lg_builder.set_entry_point(state_default_node.name)
-            lg_builder.add_conditional_edges(state_default_node.name, TransitionalEdge(entry_point))
+        # if state.items():
+        #     state_default_node = StateDefaultNode(default_vars=set_defaults(state))
+        #     lg_builder.add_node(state_default_node.name, state_default_node)
+        #     lg_builder.set_entry_point(state_default_node.name)
+        #     lg_builder.add_conditional_edges(state_default_node.name, TransitionalEdge(entry_point))
+        for key, value in state.items():
+            if 'type' in value and 'value' in value:
+                # set default value for state variable if it is defined in the schema
+                state_default_node = StateDefaultNode(default_vars=state)
+                lg_builder.add_node(state_default_node.name, state_default_node)
+                lg_builder.set_entry_point(state_default_node.name)
+                lg_builder.add_conditional_edges(state_default_node.name, TransitionalEdge(entry_point))
+                break
         else:
             # if no state variables are defined, set the entry point directly
             lg_builder.set_entry_point(entry_point)
@@ -694,7 +702,7 @@ class LangGraphAgentRunnable(CompiledStateGraph):
         
         # Append current input to existing messages instead of overwriting
         if input.get('input'):
-            current_message = HumanMessage(content=input.get('input'))
+            current_message = input.get('input')[-1]
             if input.get('messages'):
                 # Ensure existing messages are LangChain objects
                 input['messages'] = [convert_dict_to_message(msg) for msg in input['messages']]

alita_sdk/runtime/tools/application.py

@@ -31,7 +31,8 @@ def formulate_query(kwargs):
             chat_history = []
             for each in kwargs.get('chat_history')[:]:
                 chat_history.append(AIMessage(each))
-    result = {"input": kwargs.get('task'), "chat_history": chat_history}
+    input_message = AIMessage(content=kwargs.get('task'))
+    result = {"input": [input_message], "chat_history": chat_history}
     for key, value in kwargs.items():
         if key not in ("task", "chat_history"):
             result[key] = value

alita_sdk/runtime/tools/llm.py

@@ -14,8 +14,7 @@ logger = logging.getLogger(__name__)
 
 
 def create_llm_input_with_messages(
-    prompt: Dict[str, str], 
-    messages: List[BaseMessage], 
+    prompt: Dict[str, str],
     params: Dict[str, Any]
 ) -> List[BaseMessage]:
     """
@@ -23,13 +22,12 @@ def create_llm_input_with_messages(
     
     Args:
         prompt: The prompt configuration with template
-        messages: List of chat history messages
         params: Additional parameters for prompt formatting
         
     Returns:
         List of messages to send to LLM
     """
-    logger.info(f"Creating LLM input with messages: {len(messages)} messages, params: {params}")
+    logger.info(f"Creating LLM input with params: {params}")
     
     # Build the input messages
     input_messages = []
@@ -47,9 +45,13 @@ def create_llm_input_with_messages(
             raise ToolException(error_msg)
     
     # Add the chat history messages
+    messages = params.get('messages', [])
     if messages:
         input_messages.extend(messages)
-    
+    else:
+        # conditionally add a default human message if no chat history
+        input_messages.extend([HumanMessage(content="Reply to this message.")])
+
     return input_messages
 
 
@@ -124,12 +126,13 @@ class LLMNode(BaseTool):
         # Create parameters for prompt formatting from state
         params = {}
         if isinstance(state, dict):
-            for var in self.input_variables or []:
-                if var != "messages" and var in state:
-                    params[var] = state[var]
+            params = {var: state[var] for var in (self.input_variables or []) if var != "messages" and var in state}
+            # message as a part of chat history added ONLY if "messages" is in input_variables
+            if "messages" in (self.input_variables or []):
+                params["messages"] = messages
         
         # Create LLM input with proper message handling
-        llm_input = create_llm_input_with_messages(self.prompt, messages, params)
+        llm_input = create_llm_input_with_messages(self.prompt, params)
         
         # Get the LLM client, potentially with tools bound
         llm_client = self.client
@@ -268,17 +271,14 @@ class LLMNode(BaseTool):
                     if json_output_vars:
                         try:
                             response = _extract_json(content) or {}
-                            response_data = {key: response.get(key) for key in json_output_vars if key in response}
-                            
-                            # Always add the messages to the response
-                            new_messages = messages + [AIMessage(content=content)]
-                            response_data['messages'] = new_messages
-                            
-                            return response_data
+                            response_data = {key: response.get(key, content) for key in json_output_vars}
                         except (ValueError, json.JSONDecodeError) as e:
-                            # LLM returned non-JSON content, treat as plain text
-                            logger.warning(f"Expected JSON output but got plain text. Output variables specified: {json_output_vars}. Error: {e}")
-                            # Fall through to plain text handling
+                            logger.warning(
+                                f"Expected JSON output but got plain text. Output variables specified: {json_output_vars}. Error: {e}")
+                            response_data = {var: content for var in json_output_vars}
+                        new_messages = messages + [AIMessage(content=content)]
+                        response_data['messages'] = new_messages
+                        return response_data
                     
                     # Simple text response (either no output variables or JSON parsing failed)
                     new_messages = messages + [AIMessage(content=content)]

alita_sdk/tools/figma/api_wrapper.py

@@ -4,6 +4,7 @@ import logging
 import re
 from enum import Enum
 from typing import Dict, List, Generator, Optional, Union
+from urllib.parse import urlparse, parse_qs
 
 import requests
 from FigmaPy import FigmaPy
@@ -238,6 +239,7 @@ class FigmaApiWrapper(NonCodeIndexerToolkit):
 
     def _base_loader(
             self,
+            file_or_page_url: Optional[str] = None,
             project_id: Optional[str] = None,
             file_keys_include: Optional[List[str]] = None,
             file_keys_exclude: Optional[List[str]] = None,
@@ -247,6 +249,24 @@ class FigmaApiWrapper(NonCodeIndexerToolkit):
             node_types_exclude: Optional[List[str]] = None,
             **kwargs
     ) -> Generator[Document, None, None]:
+        if file_or_page_url:
+            # If URL is provided and valid, extract and override file_keys_include and node_ids_include
+            try:
+                parsed = urlparse(file_or_page_url)
+                path_parts = parsed.path.strip('/').split('/')
+    
+                # Check if the path matches the expected format
+                if len(path_parts) >= 2 and path_parts[0] == 'design':
+                    file_keys_include = [path_parts[1]]
+                    if len(path_parts) == 3:
+                        # To ensure url structure matches Figma's format with 3 path segments
+                        query_params = parse_qs(parsed.query)
+                        if "node-id" in query_params:
+                            node_ids_include = query_params.get('node-id', [])
+            except Exception as e:
+                raise ToolException(
+                    f"Unexpected error while processing Figma url {file_or_page_url}: {e}")
+        
         # If both include and exclude are provided, use only include
         if file_keys_include:
             self._log_tool_event(f"Loading files: {file_keys_include}")
@@ -364,8 +384,11 @@ class FigmaApiWrapper(NonCodeIndexerToolkit):
     def _index_tool_params(self):
         """Return the parameters for indexing data."""
         return {
+            "file_or_page_url": (Optional[str], Field(
+                description="Url to file or page to index: i.e. https://www.figma.com/design/[YOUR_FILE_KEY]/Login-page-designs?node-id=[YOUR_PAGE_ID]",
+                default=None)),
             "project_id": (Optional[str], Field(
-                description="ID of the project to list files from: i.e. 55391681'",
+                description="ID of the project to list files from: i.e. 55391681",
                 default=None)),
             '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']",

{alita_sdk-0.3.322.dist-info → alita_sdk-0.3.324.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: alita_sdk
-Version: 0.3.322
+Version: 0.3.324
 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

{alita_sdk-0.3.322.dist-info → alita_sdk-0.3.324.dist-info}/RECORD

@@ -44,7 +44,7 @@ alita_sdk/runtime/langchain/assistant.py,sha256=1Eq8BIefp8suhbC9CssoOXtC-plkemoU
 alita_sdk/runtime/langchain/chat_message_template.py,sha256=kPz8W2BG6IMyITFDA5oeb5BxVRkHEVZhuiGl4MBZKdc,2176
 alita_sdk/runtime/langchain/constants.py,sha256=eHVJ_beJNTf1WJo4yq7KMK64fxsRvs3lKc34QCXSbpk,3319
 alita_sdk/runtime/langchain/indexer.py,sha256=0ENHy5EOhThnAiYFc7QAsaTNp9rr8hDV_hTK8ahbatk,37592
-alita_sdk/runtime/langchain/langraph_agent.py,sha256=5fTT2FyRFSLIbQxm8KkxT_-bkoABmZzZA_V3-9nPse0,44296
+alita_sdk/runtime/langchain/langraph_agent.py,sha256=jbUlqWFly055uSu0pe0qfUvi5L4CoSUCyMHUFVyNMck,44818
 alita_sdk/runtime/langchain/mixedAgentParser.py,sha256=M256lvtsL3YtYflBCEp-rWKrKtcY1dJIyRGVv7KW9ME,2611
 alita_sdk/runtime/langchain/mixedAgentRenderes.py,sha256=asBtKqm88QhZRILditjYICwFVKF5KfO38hu2O-WrSWE,5964
 alita_sdk/runtime/langchain/store_manager.py,sha256=i8Fl11IXJhrBXq1F1ukEVln57B1IBe-tqSUvfUmBV4A,2218
@@ -56,13 +56,13 @@ alita_sdk/runtime/langchain/document_loaders/AlitaCSVLoader.py,sha256=3ne-a5qIkB
 alita_sdk/runtime/langchain/document_loaders/AlitaConfluenceLoader.py,sha256=NzpoL4C7UzyzLouTSL_xTQw70MitNt-WZz3Eyl7QkTA,8294
 alita_sdk/runtime/langchain/document_loaders/AlitaDirectoryLoader.py,sha256=fKezkgvIcLG7S2PVJp1a8sZd6C4XQKNZKAFC87DbQts,7003
 alita_sdk/runtime/langchain/document_loaders/AlitaDocxMammothLoader.py,sha256=9hi5eHgDIfa9wBWqTuwMM6D6W64czrDTfZl_htooe8Y,5943
-alita_sdk/runtime/langchain/document_loaders/AlitaExcelLoader.py,sha256=CKFL13TXCyqQa_fl6EmR6q9O9cT_w0tQzoQQFmfCpi8,3712
+alita_sdk/runtime/langchain/document_loaders/AlitaExcelLoader.py,sha256=P17csHx94JkXiyo1a2V-CrfP2E5XCG4uZC31ulZ_Ab4,5817
 alita_sdk/runtime/langchain/document_loaders/AlitaGitRepoLoader.py,sha256=5WXGcyHraSVj3ANHj_U6X4EDikoekrIYtS0Q_QqNIng,2608
 alita_sdk/runtime/langchain/document_loaders/AlitaImageLoader.py,sha256=QwgBJE-BvOasjgT1hYHZc0MP0F_elirUjSzKixoM6fY,6610
 alita_sdk/runtime/langchain/document_loaders/AlitaJSONLoader.py,sha256=Nav2cgCQKOHQi_ZgYYn_iFdP_Os56KVlVR5nHGXecBc,3445
 alita_sdk/runtime/langchain/document_loaders/AlitaJiraLoader.py,sha256=M2q3YThkps0yAZOjfoLcyE7qycVTYKcXEGtpmp0N6C8,10950
 alita_sdk/runtime/langchain/document_loaders/AlitaMarkdownLoader.py,sha256=RGHDfleYTn7AAc3H-yFZrjm06L0Ux14ZtEJpFlVBNCA,2474
-alita_sdk/runtime/langchain/document_loaders/AlitaPDFLoader.py,sha256=toXdQbT9TuBCdB4t62t2cPalBY_2RZy2lqKSMU7YVhw,3386
+alita_sdk/runtime/langchain/document_loaders/AlitaPDFLoader.py,sha256=usSrPnYQ3dDOJDdg6gBDTnBJnHiqjLxd_kvOBfRyVxY,5946
 alita_sdk/runtime/langchain/document_loaders/AlitaPowerPointLoader.py,sha256=SKAAPo3DfMtRPxICKrPzlXXkC5RfaeiRj7lejLXTi7o,2337
 alita_sdk/runtime/langchain/document_loaders/AlitaPythonLoader.py,sha256=m_7aq-aCFVb4vXZsJNinfN1hAuyy_S0ylRknv_ahxDc,340
 alita_sdk/runtime/langchain/document_loaders/AlitaQtestLoader.py,sha256=CUVVnisxm7b5yZWV6rn0Q3MEEaO1GWNcfnz5yWz8T0k,13283
@@ -105,14 +105,14 @@ alita_sdk/runtime/toolkits/tools.py,sha256=Ea3LO6voPNysdzVB7jYMZIqSMtda7LCq_6fkV
 alita_sdk/runtime/toolkits/vectorstore.py,sha256=BGppQADa1ZiLO17fC0uCACTTEvPHlodEDYEzUcBRbAA,2901
 alita_sdk/runtime/tools/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 alita_sdk/runtime/tools/agent.py,sha256=m98QxOHwnCRTT9j18Olbb5UPS8-ZGeQaGiUyZJSyFck,3162
-alita_sdk/runtime/tools/application.py,sha256=mC2_ZFx4WLHc98Gzll88Vw6cqyx2cmbig2IeJBtHRdg,2836
+alita_sdk/runtime/tools/application.py,sha256=j6H2OFteb7h2Yhxk1ipA-i5g3BvfmTfPuMxbfLPEa0E,2891
 alita_sdk/runtime/tools/artifact.py,sha256=yIn-kfI9OWoaxbBeqdqF0M1HPeMtNnvZ_pCPoUIwnCk,8708
 alita_sdk/runtime/tools/datasource.py,sha256=pvbaSfI-ThQQnjHG-QhYNSTYRnZB0rYtZFpjCfpzxYI,2443
 alita_sdk/runtime/tools/echo.py,sha256=spw9eCweXzixJqHnZofHE1yWiSUa04L4VKycf3KCEaM,486
 alita_sdk/runtime/tools/function.py,sha256=ZFpd7TGwIawze2e7BHlKwP0NHwNw42wwrmmnXyJQJhk,2600
 alita_sdk/runtime/tools/graph.py,sha256=MbnZYqdmvZY7SGDp43lOVVIjUt5ARHSgj43mdtBjSjQ,3092
 alita_sdk/runtime/tools/indexer_tool.py,sha256=whSLPevB4WD6dhh2JDXEivDmTvbjiMV1MrPl9cz5eLA,4375
-alita_sdk/runtime/tools/llm.py,sha256=NsrsP-SblyxDdzgMCn9_OBUL0sUGDVS5yqer49V7ciE,15069
+alita_sdk/runtime/tools/llm.py,sha256=lVg8t785JLrB2kwIQjpigfhZZP9-BRu-SEUQw6DQyh8,15128
 alita_sdk/runtime/tools/loop.py,sha256=uds0WhZvwMxDVFI6MZHrcmMle637cQfBNg682iLxoJA,8335
 alita_sdk/runtime/tools/loop_output.py,sha256=U4hO9PCQgWlXwOq6jdmCGbegtAxGAPXObSxZQ3z38uk,8069
 alita_sdk/runtime/tools/mcp_server_tool.py,sha256=trGraI8-AwdbNmTKMjfmlBxgTDMTE4-21heCVtd_lz0,4156
@@ -235,7 +235,7 @@ alita_sdk/tools/custom_open_api/api_wrapper.py,sha256=sDSFpvEqpSvXHGiBISdQQcUecf
 alita_sdk/tools/elastic/__init__.py,sha256=iwnSRppRpzvJ1da2K3Glu8Uu41MhBDCYbguboLkEbW0,2818
 alita_sdk/tools/elastic/api_wrapper.py,sha256=pl8CqQxteJAGwyOhMcld-ZgtOTFwwbv42OITQVe8rM0,1948
 alita_sdk/tools/figma/__init__.py,sha256=W6vIMMkZI2Lmpg6_CRRV3oadaIbVI-qTLmKUh6enqWs,4509
-alita_sdk/tools/figma/api_wrapper.py,sha256=SjTKCq8FrW1nCP1uFuRw8A2WVKnzEyRmKEr8e3W4QjE,26174
+alita_sdk/tools/figma/api_wrapper.py,sha256=SFuvjhxYgey1qGsO9sakFpY1bK1RSzgAH-uJsAp7FnE,27477
 alita_sdk/tools/github/__init__.py,sha256=2rHu0zZyZGnLC5CkHgDIhe14N9yCyaEfrrt7ydH8478,5191
 alita_sdk/tools/github/api_wrapper.py,sha256=uDwYckdnpYRJtb0uZnDkaz2udvdDLVxuCh1tSwspsiU,8411
 alita_sdk/tools/github/github_client.py,sha256=nxnSXsDul2PPbWvYZS8TmAFFmR-5ALyakNoV5LN2D4U,86617
@@ -349,8 +349,8 @@ alita_sdk/tools/zephyr_scale/api_wrapper.py,sha256=kT0TbmMvuKhDUZc0i7KO18O38JM9S
 alita_sdk/tools/zephyr_squad/__init__.py,sha256=0ne8XLJEQSLOWfzd2HdnqOYmQlUliKHbBED5kW_Vias,2895
 alita_sdk/tools/zephyr_squad/api_wrapper.py,sha256=kmw_xol8YIYFplBLWTqP_VKPRhL_1ItDD0_vXTe_UuI,14906
 alita_sdk/tools/zephyr_squad/zephyr_squad_cloud_client.py,sha256=R371waHsms4sllHCbijKYs90C-9Yu0sSR3N4SUfQOgU,5066
-alita_sdk-0.3.322.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-alita_sdk-0.3.322.dist-info/METADATA,sha256=B4mgVK36EvdhTCCHhCGVQEUVdxRdpRuAE_FLC9eXVFQ,18897
-alita_sdk-0.3.322.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-alita_sdk-0.3.322.dist-info/top_level.txt,sha256=0vJYy5p_jK6AwVb1aqXr7Kgqgk3WDtQ6t5C-XI9zkmg,10
-alita_sdk-0.3.322.dist-info/RECORD,,
+alita_sdk-0.3.324.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+alita_sdk-0.3.324.dist-info/METADATA,sha256=uxEEUIMIOSP9WwGk_YaGjp2hDLTynd35eEWo4SPjHUc,18897
+alita_sdk-0.3.324.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+alita_sdk-0.3.324.dist-info/top_level.txt,sha256=0vJYy5p_jK6AwVb1aqXr7Kgqgk3WDtQ6t5C-XI9zkmg,10
+alita_sdk-0.3.324.dist-info/RECORD,,