abstra 3.24.3__py3-none-any.whl → 3.24.4__py3-none-any.whl

abstra_internals/controllers/workflows.py

@@ -368,6 +368,48 @@ class WorkflowController:
             - Changes are persisted immediately to the project configuration
             - Use with caution as it can completely restructure the workflow
         """
+        # Deduplicate transitions from frontend to prevent corrupted state
+        # This handles cases where the client may send duplicate transitions
+        # Rules:
+        # 1. No duplicate IDs (keep first occurrence)
+        # 2. No duplicate source→target pairs (keep last occurrence as an update)
+        # 3. Allow bidirectional: a→b and b→a are both valid
+        if "transitions" in workflow_state_dto:
+            original_count = len(workflow_state_dto["transitions"])
+
+            # Use dict to track transitions by (source, target) pair
+            # This ensures only one transition per direction
+            transitions_by_direction = {}
+
+            for transition in workflow_state_dto["transitions"]:
+                source_id = transition.get("sourceStageId")
+                target_id = transition.get("targetStageId")
+
+                # Skip invalid transitions
+                if not source_id or not target_id:
+                    continue
+
+                # Key by (source, target) to enforce one transition per direction
+                # Note: (a, b) != (b, a), so bidirectional edges are allowed
+                direction_key = (source_id, target_id)
+
+                # Later occurrences replace earlier ones (update semantics)
+                transitions_by_direction[direction_key] = transition
+
+            workflow_state_dto["transitions"] = list(transitions_by_direction.values())
+
+            # Log if duplicates were found and removed
+            deduped_count = len(workflow_state_dto["transitions"])
+            if original_count > deduped_count:
+                from abstra_internals.logger import AbstraLogger
+
+                removed_count = original_count - deduped_count
+                AbstraLogger.warning(
+                    f"Removed {removed_count} duplicate transitions from workflow update "
+                    f"(had {original_count}, now {deduped_count}). "
+                    f"Multiple transitions with same source→target were treated as updates."
+                )
+
         project = self.repos.project.load(include_disabled_stages=True)
 
         for stage_dto in workflow_state_dto["stages"]:

abstra_internals/interface/sdk/ai.py

@@ -4,6 +4,7 @@ from typing import Dict, List, Optional, TypeVar, Union
 from abstra_internals.contracts_generated import (
     CloudApiCliModelsBankStatementResponse,
     CloudApiCliModelsBoletoResponse,
+    CloudApiCliModelsInvoiceResponse,
     CloudApiCliModelsNfeResponse,
     CloudApiCliModelsNfseResponse,
     CloudApiCliModelsUsDriverLicenseResponse,
@@ -174,6 +175,74 @@ def parse_nfe(document_path: Union["Path", str]) -> CloudApiCliModelsNfeResponse
     return CloudApiCliModelsNfeResponse.from_dict(data)
 
 
+def parse_invoice(
+    document_path: Union["Path", str],
+) -> CloudApiCliModelsInvoiceResponse:
+    """
+    Parse an invoice document using AI-powered OCR to extract comprehensive invoice information including supplier and receiver details, financial data, shipping information, and line items.
+
+    The parser extracts 35+ fields including:
+
+    **Supplier Information:**
+    - supplier_name: Name of the supplier/vendor
+    - supplier_address: Supplier's full address
+    - supplier_email: Supplier's email address
+    - supplier_phone: Supplier's phone number
+    - supplier_tax_id: Supplier's tax identification number
+    - supplier_registration: Supplier's registration number
+    - supplier_iban: Supplier's IBAN for payments
+    - supplier_payment_ref: Payment reference number
+    - supplier_website: Supplier's website URL
+
+    **Receiver Information:**
+    - receiver_name: Name of the receiver/customer
+    - receiver_address: Receiver's full address
+    - receiver_email: Receiver's email address
+    - receiver_phone: Receiver's phone number
+    - receiver_tax_id: Receiver's tax identification number
+    - receiver_website: Receiver's website URL
+
+    **Financial Information:**
+    - invoice_id: Invoice number/identifier
+    - invoice_date: Date the invoice was issued
+    - due_date: Payment due date
+    - total_amount: Total invoice amount
+    - net_amount: Net amount (after tax/discount)
+    - total_tax_amount: Total tax amount
+    - freight_amount: Freight/shipping cost
+    - amount_paid_since_last_invoice: Amount paid since last invoice
+    - currency: Currency code (e.g., USD, EUR, BRL)
+    - currency_exchange_rate: Exchange rate if applicable
+    - payment_terms: Payment terms and conditions
+
+    **Shipping Information:**
+    - ship_from_name: Ship-from party name
+    - ship_from_address: Ship-from address
+    - ship_to_name: Ship-to party name
+    - ship_to_address: Ship-to destination address
+    - remit_to_name: Remit-to party name
+    - remit_to_address: Remit-to address for payment
+    - carrier: Shipping carrier name
+    - delivery_date: Expected or actual delivery date
+
+    **Other Information:**
+    - purchase_order: Purchase order number reference
+
+    Args:
+        document_path (Union[Path, str]): The path to the invoice document to be parsed.
+
+    Returns:
+        dict: The parsed invoice data.
+
+    Raises:
+        ValueError: If document path is invalid or parsing fails.
+    """
+    data = SDKContextStore.get_by_thread().ai_sdk.parse_document(
+        document_path, "invoice"
+    )
+    return CloudApiCliModelsInvoiceResponse.from_dict(data)
+
+
 def parse_boleto(document_path: Union["Path", str]) -> CloudApiCliModelsBoletoResponse:
     """
     Parse a Brazilian Boleto (bank slip) document using AI-powered OCR for automated payment processing.

abstra_internals/repositories/git/native.py

@@ -1,7 +1,7 @@
 import shutil
 import subprocess
 from pathlib import Path
-from typing import List, Optional, Tuple
+from typing import Dict, List, Optional, Tuple
 
 from abstra_internals.environment import REMOTE_NAME
 
@@ -19,7 +19,10 @@ class NativeGitRepository(GitRepositoryInterface):
         self._git_available = None
 
     def _run_git_command(
-        self, command: List[str], cwd: Optional[Path] = None
+        self,
+        command: List[str],
+        cwd: Optional[Path] = None,
+        input: Optional[str] = None,
     ) -> Tuple[bool, str, str]:
         """Run a git command and return success, stdout, stderr"""
         try:
@@ -27,7 +30,12 @@ class NativeGitRepository(GitRepositoryInterface):
                 cwd = self.working_directory
 
             result = subprocess.run(
-                ["git"] + command, cwd=cwd, capture_output=True, text=True, timeout=30
+                ["git"] + command,
+                cwd=cwd,
+                capture_output=True,
+                text=True,
+                timeout=30,
+                input=input,
             )
             return result.returncode == 0, result.stdout.strip(), result.stderr.strip()
         except (
@@ -582,3 +590,82 @@ class NativeGitRepository(GitRepositoryInterface):
             return "<<<<<<< " in output or "=======" in output or ">>>>>>> " in output
 
         return False
+
+    def check_ignore(self, path: Path) -> bool:
+        """
+        Check if a path should be ignored according to .gitignore rules.
+        Uses git check-ignore for accurate gitignore handling.
+        """
+        if not self.is_git_repository():
+            return False
+
+        try:
+            # Get path relative to working directory
+            try:
+                relative_path = path.relative_to(self.working_directory)
+            except ValueError:
+                # Path is outside working directory, not ignored
+                return False
+
+            # Use git check-ignore -q (quiet mode, exit code only)
+            success, _, _ = self._run_git_command(
+                ["check-ignore", "-q", str(relative_path)]
+            )
+
+            # Exit code 0 means the path is ignored
+            return success
+
+        except Exception:
+            return False
+
+    def check_ignore_batch(self, paths: List[Path]) -> Dict[Path, bool]:
+        """
+        Check multiple paths at once using git check-ignore --stdin.
+        Much more efficient than checking one path at a time.
+        """
+        if not self.is_git_repository():
+            return {path: False for path in paths}
+
+        results = {}
+        relative_paths = []
+        path_map = {}
+
+        # Convert to relative paths
+        for path in paths:
+            try:
+                rel_path = path.relative_to(self.working_directory)
+                rel_path_str = str(rel_path)
+                relative_paths.append(rel_path_str)
+                path_map[rel_path_str] = path
+            except ValueError:
+                # Path outside working directory, not ignored
+                results[path] = False
+
+        if not relative_paths:
+            return results
+
+        try:
+            # Use git check-ignore with stdin for batch processing
+            input_data = "\n".join(relative_paths)
+            success, stdout, _ = self._run_git_command(
+                ["check-ignore", "--stdin"],
+                cwd=self.working_directory,
+                input=input_data,
+            )
+
+            # git check-ignore --stdin returns the paths that ARE ignored in stdout
+            ignored_paths_set = (
+                set(stdout.strip().split("\n")) if stdout.strip() else set()
+            )
+
+            # Map results back to original paths
+            for rel_path_str, path in path_map.items():
+                results[path] = rel_path_str in ignored_paths_set
+
+        except Exception:
+            # On error, mark all remaining as not ignored
+            for path in paths:
+                if path not in results:
+                    results[path] = False
+
+        return results

abstra_internals/repositories/git/types.py

@@ -271,3 +271,13 @@ class GitRepositoryInterface(ABC):
     ) -> Tuple[int, int]:
         """Calculate ahead/behind count between local and remote commits"""
         pass
+
+    @abstractmethod
+    def check_ignore(self, path: Path) -> bool:
+        """Check if a path should be ignored according to .gitignore rules"""
+        pass
+
+    @abstractmethod
+    def check_ignore_batch(self, paths: List[Path]) -> Dict[Path, bool]:
+        """Check multiple paths at once for better performance"""
+        pass

abstra_internals/repositories/linter/rules/env_in_bundle.py

@@ -17,6 +17,8 @@ class AddEnvToGitIgnore(LinterFix):
         abstraignore_file = Settings.root_path / GITIGNORE_FILEPATH
         with abstraignore_file.open("a") as file:
             file.write("\n.env")
+        # Clear cache after modifying .gitignore
+        FileSystemService.clear_gitignore_cache()
 
 
 class EnvInBundleFound(LinterIssue):

abstra_internals/repositories/project/json_migrations/__init__.py

@@ -23,6 +23,7 @@ from .migration_012 import Migration012
 from .migration_013 import Migration013
 from .migration_014 import Migration014
 from .migration_015 import Migration015
+from .migration_016 import Migration016
 
 MIGRATIONS: List[Type[Migration]] = [
     Migration001,
@@ -40,6 +41,7 @@ MIGRATIONS: List[Type[Migration]] = [
     Migration013,
     Migration014,
     Migration015,
+    Migration016,
 ]
 
 

abstra_internals/repositories/project/json_migrations/migration_016.py

@@ -0,0 +1,17 @@
+from .base_migration import Migration
+
+
+class Migration016(Migration):
+    @staticmethod
+    def target_version() -> str:
+        return "16.0"
+
+    @staticmethod
+    def source_version() -> str:
+        return "15.0"
+
+    def _migrate(self) -> None:
+        for form_data in self.data.get("forms", []):
+            form_data.pop("allow_restart", None)
+            form_data.pop("restart_button_text", None)
+            form_data.pop("welcome_title", None)

abstra_internals/repositories/project/json_migrations/migration_016_test.py

@@ -0,0 +1,141 @@
+from unittest import TestCase
+
+from abstra_internals.repositories.project.json_migrations.migration_016 import (
+    Migration016,
+)
+
+
+class TestMigration016(TestCase):
+    def test_removes_deprecated_form_fields(self):
+        data = {
+            "forms": [
+                {
+                    "id": "f1",
+                    "title": "Form A",
+                    "file": "form_a.py",
+                    "path": "/form-a",
+                    "is_initial": True,
+                    "auto_start": False,
+                    "allow_restart": True,
+                    "restart_button_text": "Start Over",
+                    "welcome_title": "Welcome!",
+                    "end_message": None,
+                    "start_message": None,
+                    "error_message": None,
+                    "timeout_message": None,
+                    "start_button_text": "Begin",
+                    "notification_trigger": {
+                        "variable_name": "notify",
+                        "enabled": False,
+                    },
+                    "access_control": {"is_public": True, "required_roles": []},
+                    "other_field": "should remain",
+                }
+            ],
+            "scripts": [],
+            "jobs": [],
+            "hooks": [],
+            "version": "15.0",
+        }
+        m = Migration016(data)
+        m.apply()
+
+        self.assertEqual(m.data["version"], "16.0")
+
+        form = m.data["forms"][0]
+        self.assertNotIn("allow_restart", form)
+        self.assertNotIn("restart_button_text", form)
+        self.assertNotIn("welcome_title", form)
+
+        self.assertEqual(form["other_field"], "should remain")
+        self.assertEqual(form["title"], "Form A")
+        self.assertEqual(form["path"], "/form-a")
+        self.assertEqual(form["is_initial"], True)
+        self.assertEqual(form["auto_start"], False)
+
+    def test_handles_multiple_forms(self):
+        data = {
+            "forms": [
+                {
+                    "id": "f1",
+                    "title": "Form 1",
+                    "file": "form_1.py",
+                    "path": "/form-1",
+                    "is_initial": True,
+                    "auto_start": False,
+                    "allow_restart": True,
+                    "restart_button_text": "Restart 1",
+                    "welcome_title": "Welcome 1",
+                    "end_message": None,
+                    "start_message": None,
+                    "error_message": None,
+                    "timeout_message": None,
+                    "start_button_text": None,
+                    "notification_trigger": {"variable_name": "n", "enabled": False},
+                    "access_control": {"is_public": True, "required_roles": []},
+                },
+                {
+                    "id": "f2",
+                    "title": "Form 2",
+                    "file": "form_2.py",
+                    "path": "/form-2",
+                    "is_initial": False,
+                    "auto_start": True,
+                    "allow_restart": False,
+                    "restart_button_text": None,
+                    "welcome_title": "Hello",
+                    "end_message": None,
+                    "start_message": None,
+                    "error_message": None,
+                    "timeout_message": None,
+                    "start_button_text": None,
+                    "notification_trigger": {"variable_name": "n", "enabled": False},
+                    "access_control": {"is_public": False, "required_roles": ["admin"]},
+                },
+            ],
+            "scripts": [],
+            "jobs": [],
+            "hooks": [],
+            "version": "15.0",
+        }
+        m = Migration016(data)
+        m.apply()
+
+        for form in m.data["forms"]:
+            self.assertNotIn("allow_restart", form)
+            self.assertNotIn("restart_button_text", form)
+            self.assertNotIn("welcome_title", form)
+
+            self.assertIn("path", form)
+            self.assertIn("is_initial", form)
+            self.assertIn("auto_start", form)
+
+    def test_handles_forms_without_deprecated_fields(self):
+        data = {
+            "forms": [
+                {
+                    "id": "f1",
+                    "title": "Form Without Deprecated Fields",
+                    "file": "form.py",
+                    "path": "/form",
+                    "is_initial": True,
+                    "auto_start": False,
+                    "end_message": None,
+                    "start_message": None,
+                    "error_message": None,
+                    "timeout_message": None,
+                    "start_button_text": None,
+                    "notification_trigger": {"variable_name": "n", "enabled": False},
+                    "access_control": {"is_public": True, "required_roles": []},
+                }
+            ],
+            "scripts": [],
+            "jobs": [],
+            "hooks": [],
+            "version": "15.0",
+        }
+        m = Migration016(data)
+        m.apply()
+
+        self.assertEqual(m.data["version"], "16.0")
+        self.assertEqual(len(m.data["forms"]), 1)

abstra_internals/repositories/project/project.py

@@ -496,11 +496,8 @@ class FormStage(StageWithFile):
     auto_start: Optional[bool] = False
     start_message: Optional[str] = None
     error_message: Optional[str] = None
-    welcome_title: Optional[str] = None
-    allow_restart: Optional[bool] = False
     timeout_message: Optional[str] = None
     start_button_text: Optional[str] = None
-    restart_button_text: Optional[str] = None
     access_control: AccessSettings = field(
         default_factory=lambda: AccessSettings(is_public=False, required_roles=[])
     )
@@ -541,11 +538,8 @@ class FormStage(StageWithFile):
             auto_start=data["auto_start"],
             start_message=data["start_message"],
             error_message=data["error_message"],
-            welcome_title=data["welcome_title"],
-            allow_restart=data["allow_restart"],
             timeout_message=data["timeout_message"],
             start_button_text=data["start_button_text"],
-            restart_button_text=data["restart_button_text"],
             workflow_position=(x, y),
             is_initial=data["is_initial"],
             workflow_transitions=[
@@ -569,22 +563,17 @@ class FormStage(StageWithFile):
 
     @property
     def browser_runner_dto(self):
-        allow_restart = self.allow_restart if self.is_initial else False
-
         return {
             "id": self.id,
             "path": self.path,
             "title": self.title,
             "is_initial": self.is_initial,
             "auto_start": self.auto_start,
-            "allow_restart": allow_restart,
             "end_message": self.end_message,
             "start_message": self.start_message,
             "error_message": self.error_message,
-            "welcome_title": self.welcome_title,
             "timeout_message": self.timeout_message,
             "start_button_text": self.start_button_text,
-            "restart_button_text": self.restart_button_text,
         }
 
     @property
@@ -618,11 +607,8 @@ class FormStage(StageWithFile):
                 "auto_start",
                 "start_message",
                 "error_message",
-                "welcome_title",
-                "allow_restart",
                 "timeout_message",
                 "start_button_text",
-                "restart_button_text",
             ]:
                 setattr(self, attr, value)
             elif attr == "file":
@@ -657,11 +643,8 @@ class FormStage(StageWithFile):
             auto_start=self.auto_start or False,
             start_message=self.start_message,
             error_message=self.error_message,
-            welcome_title=self.welcome_title,
-            allow_restart=self.allow_restart or False,
             timeout_message=self.timeout_message,
             start_button_text=self.start_button_text,
-            restart_button_text=self.restart_button_text,
             workflow_position=[self.workflow_position[0], self.workflow_position[1]],
             transitions=[t.to_abstra_json_dto() for t in self.workflow_transitions],
             is_initial=self.is_initial,
@@ -1222,6 +1205,50 @@ class Project:
         self.jobs = [j for j in self.jobs if j.id != id]
         self.scripts = [s for s in self.scripts if s.id != id]
 
+    @staticmethod
+    def __deduplicate_transitions(transitions: List[dict]) -> List[dict]:
+        """
+        Remove duplicate transitions based on ID and target, keeping only the first occurrence.
+
+        This is necessary to handle corrupted project files that may have accumulated
+        duplicate transitions over time, which can cause performance issues when
+        loading large workflows.
+
+        Rules:
+        1. No duplicate IDs (keeps first occurrence)
+        2. No duplicate targets (keeps first occurrence - since source is implicit from stage)
+        3. Allows bidirectional: a→b and b→a are in different stages, so both valid
+
+        Args:
+            transitions: List of transition dictionaries from the JSON data
+                        (all from the same source stage)
+
+        Returns:
+            List of unique transitions, preserving order
+        """
+        seen_ids = set()
+        seen_targets = set()
+        unique_transitions = []
+
+        for transition in transitions:
+            transition_id = transition.get("id")
+            target_id = transition.get("target_id")
+
+            # Skip if duplicate ID
+            if transition_id in seen_ids:
+                continue
+
+            # Skip if duplicate target (same source→target)
+            if target_id in seen_targets:
+                continue
+
+            # Valid unique transition
+            seen_ids.add(transition_id)
+            seen_targets.add(target_id)
+            unique_transitions.append(transition)
+
+        return unique_transitions
+
     @staticmethod
     def __from_dict(data: dict):
         target_stages = set()
@@ -1230,6 +1257,24 @@ class Project:
 
         stage_keys = ["forms", "hooks", "scripts", "jobs"]
 
+        # Deduplicate transitions in each stage before processing
+        for key in stage_keys:
+            for stage in data[key]:
+                if "transitions" in stage:
+                    original_count = len(stage["transitions"])
+                    stage["transitions"] = Project.__deduplicate_transitions(
+                        stage["transitions"]
+                    )
+                    deduped_count = len(stage["transitions"])
+
+                    # Log warning if duplicates were found
+                    if original_count > deduped_count:
+                        removed_count = original_count - deduped_count
+                        AbstraLogger.warning(
+                            f"Removed {removed_count} duplicate transitions from stage {stage.get('id', 'unknown')} "
+                            f"(had {original_count}, now {deduped_count})"
+                        )
+
         for key in stage_keys:
             for stage in data[key]:
                 nodes.append(Node(id=stage["id"]))