abstra 3.23.12__py3-none-any.whl → 3.24.1__py3-none-any.whl

abstra_internals/controllers/ai.py

@@ -1,10 +1,17 @@
+import base64
+import io
 from dataclasses import dataclass
 from typing import Any, Dict, List
 
+import pypdfium2 as pdfium
+
 from abstra_internals.cloud_api import get_session_path, get_tunnel_secret_key
 from abstra_internals.contracts_generated import (
     AbstraLibApiAiStreamRequest,
     CloudApiCliAiV2StreamRequest,
+    CloudApiCliAiV2StreamRequestContentItem,
+    CloudApiCliAiV2StreamRequestContentItemAssistantFileInput,
+    CloudApiCliAiV2StreamRequestContentItemAssistantTextInput,
 )
 from abstra_internals.controllers.main import MainController
 from abstra_internals.credentials import resolve_headers
@@ -71,15 +78,96 @@ class AiController:
         self.controller = controller
         self.repos = controller.repositories
 
+    def _extract_pdf_images(self, pdf_bytes: bytes) -> List[bytes]:
+        images = []
+        pdf_io = io.BytesIO(pdf_bytes)
+        for page in pdfium.PdfDocument(pdf_io):
+            bitmap = page.render(
+                scale=4,  # 288 dpi
+                rotation=0,
+            )
+            pil_image = bitmap.to_pil()
+            image_io = io.BytesIO()
+            pil_image.save(image_io, format="png")
+            image_io.seek(0)
+            images.append(image_io.read())
+        return images
+
+    def _process_pdf_content(
+        self, pdf_file: CloudApiCliAiV2StreamRequestContentItemAssistantFileInput
+    ) -> List[CloudApiCliAiV2StreamRequestContentItem]:
+        processed_items = []
+        try:
+            pdf_bytes = base64.b64decode(pdf_file.file_content)
+            images = self._extract_pdf_images(pdf_bytes)
+
+            processed_items.append(
+                CloudApiCliAiV2StreamRequestContentItemAssistantTextInput(
+                    type="text",
+                    text=f"[PDF Document: {pdf_file.file_name} - {len(images)} page(s)]",
+                )
+            )
+
+            for idx, image_bytes in enumerate(images, 1):
+                image_base64 = base64.b64encode(image_bytes).decode("utf-8")
+                processed_items.append(
+                    CloudApiCliAiV2StreamRequestContentItemAssistantFileInput(
+                        type="file",
+                        file_name=f"{pdf_file.file_name}_page_{idx}.png",
+                        file_content=image_base64,
+                    )
+                )
+        except Exception as e:
+            print(f"Error extracting PDF images: {e}")
+            processed_items.append(
+                CloudApiCliAiV2StreamRequestContentItemAssistantTextInput(
+                    type="text",
+                    text=f"[PDF Document: {pdf_file.file_name}]\nNote: Could not extract images from this PDF.",
+                )
+            )
+        return processed_items
+
+    def _process_content(
+        self, content: List[CloudApiCliAiV2StreamRequestContentItem]
+    ) -> List[CloudApiCliAiV2StreamRequestContentItem]:
+        processed_content = []
+
+        for item in content:
+            if isinstance(
+                item, CloudApiCliAiV2StreamRequestContentItemAssistantTextInput
+            ):
+                processed_content.append(item)
+                continue
+
+            if not item.file_name.lower().endswith(".pdf"):
+                processed_content.append(item)
+                continue
+
+            try:
+                processed_pdf_items = self._process_pdf_content(item)
+                processed_content.extend(processed_pdf_items)
+            except Exception as e:
+                print(f"Error extracting PDF images: {e}")
+                processed_content.append(
+                    CloudApiCliAiV2StreamRequestContentItemAssistantTextInput(
+                        type="text",
+                        text=f"[PDF Document: {item.file_name}]\nNote: Could not extract images from this PDF.",
+                    )
+                )
+
+        return processed_content
+
     def send_ai_message(
         self,
         body: AbstraLibApiAiStreamRequest,
     ):
         try:
+            processed_content = self._process_content(body.content)
+
             yield from self.repos.ai.get_ai_messages(
                 CloudApiCliAiV2StreamRequest(
                     conversation_id=body.conversation_id,
-                    content=body.content,
+                    content=processed_content,
                     context={
                         **body.context,
                         "libVersion": str(get_local_package_version()),

abstra_internals/controllers/git.py

@@ -0,0 +1,307 @@
+from abc import ABC, abstractmethod
+from typing import Any, Dict, Optional
+
+import requests
+
+from abstra_internals.credentials import get_credentials
+from abstra_internals.environment import CLOUD_API_CLI_URL, REMOTE_GIT_URL, REMOTE_NAME
+from abstra_internals.repositories.git import (
+    AheadBehindInfo,
+    GitCommit,
+    GitStatusResponse,
+    RemoteGitStatus,
+    create_git_repository,
+)
+from abstra_internals.settings import Settings
+
+
+class EmailProvider(ABC):
+    """Interface that requires a get_email method."""
+
+    @abstractmethod
+    def get_email(self) -> str:
+        pass
+
+
+class DefaultEmailProvider(EmailProvider):
+    """Concrete implementation with a default email."""
+
+    def get_email(self) -> str:
+        return "abstra@mail.com"
+
+
+class GitController:
+    def __init__(self, email_provider: EmailProvider = DefaultEmailProvider()):
+        self.git_repository = create_git_repository(Settings.root_path)
+        self.email_provider = email_provider
+        self.git_email = email_provider.get_email()
+
+    def _ensure_authentication(self) -> bool:
+        try:
+            if self.git_email is None:
+                self.git_email = self.email_provider.get_email()
+
+            if self.git_email is None:
+                print("No email available for git configuration")
+                return False
+
+            self.git_repository.configure_git_user(
+                fallback_email=self.git_email,
+                fallback_name=self.git_email.split("@")[0],
+            )
+
+            credentials = get_credentials()
+            if not credentials:
+                return False
+
+            if self.git_repository.has_remote(REMOTE_NAME):
+                if not self.git_repository.set_remote_url(REMOTE_NAME, REMOTE_GIT_URL):
+                    return False
+            else:
+                if not self.git_repository.add_remote(REMOTE_NAME, REMOTE_GIT_URL):
+                    return False
+
+            config_key = f"http.{REMOTE_GIT_URL}.extraHeader"
+            config_value = f"Api-Authorization: Bearer {credentials}"
+
+            if self.git_repository.get_git_config(config_key) == config_value:
+                return True
+
+            return self.git_repository.set_git_config(config_key, config_value)
+
+        except Exception as e:
+            print(f"Authentication setup failed: {e}")
+            return False
+
+    def _fetch_remote_status(self, branch: str = "main") -> RemoteGitStatus:
+        try:
+            credentials = get_credentials()
+            if not credentials:
+                return RemoteGitStatus(
+                    success=False, message="No authentication credentials available"
+                )
+
+            api_url = f"{CLOUD_API_CLI_URL}/git/status"
+            headers = {"Api-Authorization": f"Bearer {credentials}"}
+            params = {"branch": branch}
+
+            response = requests.get(api_url, headers=headers, params=params, timeout=10)
+
+            if response.status_code == 200:
+                try:
+                    data = response.json()
+
+                    if not isinstance(data, dict):
+                        return RemoteGitStatus(
+                            success=False,
+                            message=f"Unexpected response format. Expected dict, got {type(data).__name__}",
+                        )
+
+                    return RemoteGitStatus(
+                        success=data.get("success", True),
+                        remote_commit=data.get("remote_commit"),
+                        branch=data.get("branch", branch),
+                        has_commits=data.get("has_commits", False),
+                        available_branches=data.get("available_branches", [branch]),
+                        message=data.get("message"),
+                        ahead_behind=None,
+                    )
+                except ValueError as json_error:
+                    return RemoteGitStatus(
+                        success=False, message=f"Invalid JSON response: {json_error}"
+                    )
+            else:
+                response_text = (
+                    response.text[:200] if response.text else "No response body"
+                )
+                return RemoteGitStatus(
+                    success=False,
+                    message=f"API call failed with status {response.status_code}: {response_text}",
+                )
+
+        except Exception as e:
+            return RemoteGitStatus(
+                success=False, message=f"Error fetching remote status: {str(e)}"
+            )
+
+    def get_status(self) -> Dict[str, Any]:
+        self._ensure_authentication()
+
+        status = self.git_repository.get_repository_status()
+
+        remote_status = None
+
+        if status.available:
+            remote_status = self._fetch_remote_status()
+
+            if (
+                remote_status.success
+                and remote_status.remote_commit
+                and status.last_commit
+                and remote_status.remote_commit != status.last_commit.hash
+            ):
+                try:
+                    ahead, behind = self.git_repository.get_ahead_behind_count(
+                        status.last_commit.hash, remote_status.remote_commit
+                    )
+                    remote_status.ahead_behind = AheadBehindInfo(
+                        ahead=ahead, behind=behind
+                    )
+                except Exception as e:
+                    print(f"Failed to calculate ahead/behind: {e}")
+
+                remote_status.has_conflicts = self.git_repository.check_merge_conflicts(
+                    remote_status.remote_commit
+                )
+
+                if remote_status.ahead_behind:
+                    remote_status.has_remote_changes = (
+                        remote_status.ahead_behind.behind > 0
+                    )
+                else:
+                    remote_status.has_remote_changes = (
+                        remote_status.remote_commit != status.last_commit.hash
+                    )
+
+        status_response = GitStatusResponse(
+            available=status.available,
+            git_installed=status.git_installed,
+            is_monorepo=status.is_monorepo,
+            branch=status.branch,
+            branches=status.branches,
+            last_commit=status.last_commit,
+            has_changes=status.has_changes,
+            changed_files=status.changed_files,
+            changed_files_with_status=status.changed_files_with_status,
+            remote_status=remote_status,
+        )
+
+        return status_response.to_dict()
+
+    def checkout_branch(self, branch_name: str) -> Dict[str, Any]:
+        success = self.git_repository.checkout_branch(branch_name)
+
+        message = (
+            f"Switched to branch '{branch_name}'"
+            if success
+            else f"Failed to switch to branch '{branch_name}'"
+        )
+
+        return {"success": success, "message": message}
+
+    def checkout_commit(self, commit_hash: str) -> Dict[str, Any]:
+        success = self.git_repository.checkout_commit(commit_hash)
+
+        message = (
+            f"Switched to commit '{commit_hash[:8]}'"
+            if success
+            else f"Failed to switch to commit '{commit_hash[:8]}'"
+        )
+
+        return {"success": success, "message": message}
+
+    def pull_changes(
+        self, strategy: str, allow_unrelated: bool, conflict_resolution: Optional[str]
+    ) -> Dict[str, Any]:
+        self._ensure_authentication()
+
+        success = self.git_repository.pull_changes(
+            strategy=strategy,
+            allow_unrelated=allow_unrelated,
+            conflict_resolution=conflict_resolution,
+        )
+
+        message = "Successfully pulled changes" if success else "Failed to pull changes"
+
+        return {"success": success, "message": message}
+
+    def commit_changes(self, message: str) -> Dict[str, Any]:
+        commit_message = message.strip()
+        if not commit_message:
+            return {"success": False, "message": "Commit message cannot be empty"}
+
+        success = self.git_repository.commit_changes(commit_message)
+
+        message = (
+            f"Successfully committed changes: {commit_message}"
+            if success
+            else "Failed to commit changes"
+        )
+
+        return {"success": success, "message": message}
+
+    def stash_changes(self, message: str = "WIP") -> Dict[str, Any]:
+        success = self.git_repository.stash_changes(message)
+
+        message = (
+            "Successfully stashed changes" if success else "Failed to stash changes"
+        )
+
+        return {"success": success, "message": message}
+
+    def get_commit_history(
+        self, limit: int = 10, offset: int = 0, branch: Optional[str] = None
+    ) -> Dict[str, Any]:
+        commits = self.git_repository.get_commit_history(
+            limit=limit, offset=offset, branch=branch
+        )
+
+        return {
+            "commits": [self._format_commit(commit) for commit in commits],
+            "hasMore": len(commits) == limit,
+        }
+
+    def push_and_deploy(self, branch: str = "main") -> Dict[str, Any]:
+        self._ensure_authentication()
+
+        success = self.git_repository.push_and_deploy(branch)
+
+        message = (
+            f"Successfully deployed branch '{branch}' to Abstra"
+            if success
+            else f"Failed to deploy branch '{branch}' to Abstra. Push operation failed."
+        )
+
+        return {"success": success, "message": message}
+
+    def get_remotes(self) -> Dict[str, Any]:
+        remotes = self.git_repository.get_remotes()
+
+        return {"remotes": remotes, "hasAbstraRemote": REMOTE_NAME in remotes}
+
+    def revert_commit(self, commit_hash: str) -> Dict[str, Any]:
+        if not commit_hash.strip():
+            return {"success": False, "message": "Commit hash is required"}
+
+        commits = self.git_repository.get_commit_history(limit=200)
+        commit_to_revert = next(
+            (c for c in commits if c.hash.startswith(commit_hash)), None
+        )
+
+        if not commit_to_revert:
+            return {"success": False, "message": f"Commit {commit_hash[:8]} not found"}
+
+        try:
+            success = self.git_repository.revert_commit(commit_hash)
+
+            message = (
+                f"Successfully restored content from commit: {commit_to_revert.message}. A new commit was created with the content from that version."
+                if success
+                else f"Failed to restore content from commit {commit_hash[:8]}. Make sure there are no uncommitted changes and the commit exists."
+            )
+
+            return {"success": success, "message": message}
+
+        except Exception as e:
+            return {
+                "success": False,
+                "message": f"Error restoring content from commit {commit_hash[:8]}: {str(e)}",
+            }
+
+    def _format_commit(self, commit: GitCommit) -> Dict[str, str]:
+        return {
+            "hash": commit.hash,
+            "message": commit.message,
+            "author": commit.author,
+            "date": commit.date,
+        }

abstra_internals/controllers/main.py

@@ -26,7 +26,7 @@ from abstra_internals.entities.execution_context import (
     Response,
     ScriptContext,
 )
-from abstra_internals.interface.cli.deploy import deploy
+from abstra_internals.interface.cli.deploy import deploy_without_git
 from abstra_internals.logger import AbstraLogger
 from abstra_internals.repositories.email import EmailRepository
 from abstra_internals.repositories.execution import ExecutionFilter, ExecutionRepository
@@ -54,7 +54,6 @@ from abstra_internals.services.fs import FileSystemService
 from abstra_internals.services.requirements import RequirementsRepository
 from abstra_internals.settings import Settings
 from abstra_internals.templates import (
-    ensure_abstraignore,
     ensure_dotenv,
     ensure_gitignore,
     new_form_code,
@@ -126,7 +125,6 @@ class MainController:
         repositories.project.initialize_or_migrate()
 
         RequirementsRepository.ensure("abstra")
-        ensure_abstraignore(Settings.root_path)
         ensure_gitignore(Settings.root_path)
         ensure_dotenv(Settings.root_path)
 
@@ -143,7 +141,7 @@ class MainController:
         self.execution_logs_repository = repositories.execution_logs
         self.linter_repository = repositories.linter
 
-    def deploy(self):
+    def deploy_without_git(self):
         self.linter_repository.update_checks()
         issues = self.linter_repository.get_blocking_checks()
 
@@ -152,7 +150,7 @@ class MainController:
                 "Please fix all linter issues before deploying your project."
             )
 
-        deploy()
+        deploy_without_git()
 
     def reset_repositories(self):
         self.execution_repository.clear()
@@ -541,7 +539,7 @@ class MainController:
             ```
 
         Note:
-            - Respects .gitignore and .gitignore patterns when use_ignore=True
+            - Respects .gitignore patterns when use_ignore=True
             - Image mode supports: .png, .jpg, .jpeg, .gif, .svg, .webp, .jfif, .pjp, .pjpeg
             - Module mode uses Python's pkgutil.iter_modules for discovery
             - Paths are always relative to the project root directory
@@ -1432,6 +1430,12 @@ class MainController:
             return {"logged": False, "reason": "NO_API_TOKEN"}
         return get_api_key_info(headers)
 
+    def get_email(self):
+        login = self.get_login()
+        if login.get("logged"):
+            return login.get("info", {}).get("email")
+        return None
+
     def create_login(self, token):
         set_credentials(token)
         return self.get_login()

abstra_internals/environment.py

@@ -110,3 +110,9 @@ SERVER_UUID = lambda: os.getenv(__SERVER_UUID_ENV__)  # noqa: E731
 
 def set_SERVER_UUID(server_uuid: str):
     os.environ[__SERVER_UUID_ENV__] = server_uuid
+
+
+# GIT
+FORCE_GIT_CLIENT = os.getenv("ABSTRA_FORCE_GIT_CLIENT")
+REMOTE_GIT_URL = f"{CLOUD_API_CLI_URL}/git/repo.git"
+REMOTE_NAME = "abstra"

abstra_internals/interface/cli/deploy.py

@@ -28,7 +28,7 @@ def _upload_file(url: str, file_path: pathlib.Path):
         requests.put(url=url, data=f.read())
 
 
-def deploy():
+def deploy_without_git():
     headers = resolve_headers()
     if not headers:
         print(

abstra_internals/interface/cli/editor.py

@@ -80,7 +80,7 @@ def ensure_certificates():
             print(f"Failed to restore certificates: {update_e}")
 
 
-def editor(headless: bool):
+def editor(headless: bool, verbose: bool = False):
     ensure_certificates()
 
     load_dotenv(Settings.root_path / ".env")
@@ -119,6 +119,6 @@ def editor(headless: bool):
     if not headless:
         background_open_editor()
 
-    connect_tunnel()
+    connect_tunnel(verbose=verbose)
 
     server.serve_forever()

abstra_internals/interface/sdk/ai.py

@@ -84,6 +84,7 @@ def parse_nfse(document_path: Union["Path", str]) -> CloudApiCliModelsNfseRespon
     - razao_social_prestador/razao_social_tomador: Company names
     - valor_liquido_centavos/valor_total_centavos: Net/total amounts in cents
     - numero_nota: Invoice number
+    - codigo_servico: Service code number
     - data_emissao: Issue date (YYYY-MM-DD)
     - descricao: Service description
     - endereco_prestador/endereco_tomador: Full addresses

abstra_internals/repositories/git/__init__.py

@@ -0,0 +1,25 @@
+from .native import NativeGitRepository
+from .types import (
+    AheadBehindInfo,
+    GitCommit,
+    GitRepositoryInterface,
+    GitStatus,
+    GitStatusResponse,
+    RemoteGitStatus,
+)
+
+
+def create_git_repository(working_directory) -> GitRepositoryInterface:
+    return NativeGitRepository(working_directory)
+
+
+__all__ = [
+    "GitCommit",
+    "GitStatus",
+    "RemoteGitStatus",
+    "GitStatusResponse",
+    "GitRepositoryInterface",
+    "NativeGitRepository",
+    "create_git_repository",
+    "AheadBehindInfo",
+]