salla-gitpuller 1.0.0__tar.gz → 1.0.2__tar.gz

salla_gitpuller-1.0.2/PKG-INFO

@@ -0,0 +1,35 @@
+Metadata-Version: 2.4
+Name: salla_gitpuller
+Version: 1.0.2
+Summary: A lightweight utility to git pull a repository using SSH deploy keys stored in environment variables
+Author-email: Muhammad Zahid <zahidmuhammad127@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/Zahid07/gitpuller
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# gitpuller
+
+## Usage
+
+```python
+from gitpuller import GitPullExecutor
+
+executor = GitPullExecutor(slack_webhook_url="your_webhook_url", use_mage_ai=True)
+result = executor.execute_with_alerting(
+    repo_path="/path/to/repo",
+    git_url="git@github.com:user/repo.git",
+    branch="master",
+    workspace_name="workspace1"
+)
+```
+
+## Build
+
+```bash
+rm -rf build dist *.egg-info
+python -m build
+```
+
+Upload to PyPI and update version in `pyproject.toml`.

salla_gitpuller-1.0.2/README.md

@@ -0,0 +1,24 @@
+# gitpuller
+
+## Usage
+
+```python
+from gitpuller import GitPullExecutor
+
+executor = GitPullExecutor(slack_webhook_url="your_webhook_url", use_mage_ai=True)
+result = executor.execute_with_alerting(
+    repo_path="/path/to/repo",
+    git_url="git@github.com:user/repo.git",
+    branch="master",
+    workspace_name="workspace1"
+)
+```
+
+## Build
+
+```bash
+rm -rf build dist *.egg-info
+python -m build
+```
+
+Upload to PyPI and update version in `pyproject.toml`.

{salla_gitpuller-1.0.0 → salla_gitpuller-1.0.2}/gitpuller/__init__.py

@@ -1,19 +1,19 @@
-from .gitpull import GitPullExecutor
-from .alert_manager import AlertManager
-from .state_manager import StateManager, InMemoryStateManager, MageAIStateManager
-from .slack_notifier import SlackNotifier
-from .utils import transform_custom, get_repo_path, get_env_base_path
-
-
-__version__ = "1.0.0"
-__all__ = [
-    "GitPullExecutor",
-    "AlertManager",
-    "StateManager",
-    "InMemoryStateManager",
-    "MageAIStateManager",
-    "SlackNotifier",
-    "transform_custom", 
-    "get_repo_path", 
-    "get_env_base_path"
+from .gitpull import GitPullExecutor
+from .alert_manager import AlertManager
+from .state_manager import StateManager, InMemoryStateManager, MageAIStateManager
+from .slack_notifier import SlackNotifier
+from .utils import transform_custom, get_repo_path, get_env_base_path
+
+
+__version__ = "1.0.0"
+__all__ = [
+    "GitPullExecutor",
+    "AlertManager",
+    "StateManager",
+    "InMemoryStateManager",
+    "MageAIStateManager",
+    "SlackNotifier",
+    "transform_custom", 
+    "get_repo_path", 
+    "get_env_base_path"
 ]

{salla_gitpuller-1.0.0 → salla_gitpuller-1.0.2}/gitpuller/alert_manager.py

@@ -1,63 +1,63 @@
-from datetime import datetime, timedelta
-from typing import Any, Dict, Optional, Tuple
-from .state_manager import StateManager, InMemoryStateManager, MageAIStateManager
-
-class AlertManager:    
-    def __init__(self, state_manager: Optional[StateManager] = None, use_mage_ai: bool = False):
-        if state_manager is not None:
-            self.state_manager = state_manager
-        elif use_mage_ai:
-            try:
-                self.state_manager = MageAIStateManager()
-            except ImportError:
-                print("⚠️ Mage AI not available, falling back to in-memory state manager")
-                self.state_manager = InMemoryStateManager()
-        else:
-            self.state_manager = InMemoryStateManager()
-    
-    def should_send_alert(
-        self, 
-        pipeline_uuid: str, 
-        current_error: str, 
-        suppression_hours: int = 1
-    ) -> Tuple[bool, Dict[str, Any]]:
-        
-        state = self.state_manager.load_alert_state(pipeline_uuid)
-        last_error = state.get("last_error_message")
-        last_alert_time_str = state.get("last_alert_time")
-        
-        # If no previous alert, always send
-        if not last_error or not last_alert_time_str:
-            return True, {"last_error_message": None, "last_alert_time": None}
-        
-        # If error is different, always send
-        if last_error != current_error:
-            return True, {"last_error_message": last_error, "last_alert_time": last_alert_time_str}
-        
-        # Same error - check if enough time has passed
-        try:
-            last_alert_time = datetime.fromisoformat(last_alert_time_str)
-            time_since_last_alert = datetime.now() - last_alert_time
-            
-            if time_since_last_alert >= timedelta(hours=suppression_hours):
-                return True, {"last_error_message": last_error, "last_alert_time": last_alert_time_str}
-            else:
-                return False, {"last_error_message": last_error, "last_alert_time": last_alert_time_str}
-        except (ValueError, TypeError):
-            # If we can't parse the time, send the alert to be safe
-            return True, {"last_error_message": last_error, "last_alert_time": last_alert_time_str}
-    
-    def save_alert_state(
-        self, 
-        pipeline_uuid: str, 
-        error_message: str, 
-        alert_time: datetime, 
-        pipeline_status: str
-    ) -> None:
-        """Save alert state."""
-        self.state_manager.save_alert_state(pipeline_uuid, error_message, alert_time, pipeline_status)
-    
-    def clear_alert_state(self, pipeline_uuid: str) -> None:
-        """Clear alert state on success."""
-        self.state_manager.clear_alert_state(pipeline_uuid)
-
+from datetime import datetime, timedelta
+from typing import Any, Dict, Optional, Tuple
+from .state_manager import StateManager, InMemoryStateManager, MageAIStateManager
+
+class AlertManager:    
+    def __init__(self, state_manager: Optional[StateManager] = None, use_mage_ai: bool = False):
+        if state_manager is not None:
+            self.state_manager = state_manager
+        elif use_mage_ai:
+            try:
+                self.state_manager = MageAIStateManager()
+            except ImportError:
+                print("⚠️ Mage AI not available, falling back to in-memory state manager")
+                self.state_manager = InMemoryStateManager()
+        else:
+            self.state_manager = InMemoryStateManager()
+    
+    def should_send_alert(
+        self, 
+        pipeline_uuid: str, 
+        current_error: str, 
+        suppression_hours: int = 1
+    ) -> Tuple[bool, Dict[str, Any]]:
+        
+        state = self.state_manager.load_alert_state(pipeline_uuid)
+        last_error = state.get("last_error_message")
+        last_alert_time_str = state.get("last_alert_time")
+        
+        # If no previous alert, always send
+        if not last_error or not last_alert_time_str:
+            return True, {"last_error_message": None, "last_alert_time": None}
+        
+        # If error is different, always send
+        if last_error != current_error:
+            return True, {"last_error_message": last_error, "last_alert_time": last_alert_time_str}
+        
+        # Same error - check if enough time has passed
+        try:
+            last_alert_time = datetime.fromisoformat(last_alert_time_str)
+            time_since_last_alert = datetime.now() - last_alert_time
+            
+            if time_since_last_alert >= timedelta(hours=suppression_hours):
+                return True, {"last_error_message": last_error, "last_alert_time": last_alert_time_str}
+            else:
+                return False, {"last_error_message": last_error, "last_alert_time": last_alert_time_str}
+        except (ValueError, TypeError):
+            # If we can't parse the time, send the alert to be safe
+            return True, {"last_error_message": last_error, "last_alert_time": last_alert_time_str}
+    
+    def save_alert_state(
+        self, 
+        pipeline_uuid: str, 
+        error_message: str, 
+        alert_time: datetime, 
+        pipeline_status: str
+    ) -> None:
+        """Save alert state."""
+        self.state_manager.save_alert_state(pipeline_uuid, error_message, alert_time, pipeline_status)
+    
+    def clear_alert_state(self, pipeline_uuid: str) -> None:
+        """Clear alert state on success."""
+        self.state_manager.clear_alert_state(pipeline_uuid)
+

{salla_gitpuller-1.0.0 → salla_gitpuller-1.0.2}/gitpuller/gitpull.py

@@ -1,202 +1,194 @@
-import os
-import subprocess
-from typing import Dict, Any, Optional
-from datetime import datetime
-from .alert_manager import AlertManager
-from .slack_notifier import SlackNotifier
-
-class GitPullExecutor:    
-    def __init__(
-        self,
-        slack_webhook_url: Optional[str] = None,
-        use_mage_ai: bool = False,
-        state_manager: Optional[Any] = None
-    ):
-        self.slack_notifier = SlackNotifier(webhook_url=slack_webhook_url)
-        self.alert_manager = AlertManager(state_manager=state_manager, use_mage_ai=use_mage_ai)
-    
-    def normalize_ssh_key(self, key_material: str) -> str:
-        if not key_material:
-            return key_material
-        
-        # Remove any quotes that might be wrapping the key
-        key_material = key_material.strip().strip('"').strip("'")
-        
-        # Handle literal \n sequences
-        if "\\n" in key_material:
-            key_material = key_material.replace("\\n", "\n")
-        
-        # Ensure proper line endings
-        if not key_material.endswith("\n"):
-            key_material += "\n"
-        
-        return key_material
-    
-    def prepare_ssh_key(
-        self, 
-        key_material: str, 
-        key_filename: str = "deploy_key",
-        ssh_dir: str = "/home/src/.ssh"
-    ) -> str:
-        os.makedirs(ssh_dir, exist_ok=True)
-        os.chmod(ssh_dir, 0o700)
-        
-        key_path = os.path.join(ssh_dir, key_filename)
-        
-        # Write key with restricted permissions
-        with open(key_path, "w") as f:
-            f.write(key_material)
-        os.chmod(key_path, 0o600)
-        
-        return key_path
-    
-    def execute_git_pull(
-        self,
-        repo_path: str,
-        git_url: str,
-        branch: str = "master",
-        ssh_key: Optional[str] = None,
-        workspace_name: Optional[str] = None,
-        key_filename: Optional[str] = None,
-        ssh_dir: str = "/home/src/.ssh"
-    ) -> Dict[str, Any]:
-        if not os.path.exists(repo_path):
-            raise ValueError(f"Repo path does not exist: {repo_path}")
-        
-        # Get SSH key
-        if not ssh_key and workspace_name:
-            key_env_name = f"{workspace_name}_SSHKEY"
-            ssh_key = os.environ.get(key_env_name)
-            if not ssh_key:
-                raise ValueError(f"Missing env var {key_env_name} with the PRIVATE deploy key")
-        elif not ssh_key:
-            raise ValueError("SSH key is required. Provide it directly or set workspace_name.")
-        
-        # Normalize key
-        ssh_key = self.normalize_ssh_key(ssh_key)
-        
-        # Prepare key file
-        if not key_filename:
-            key_filename = f"{workspace_name}_deploy" if workspace_name else "deploy_key"
-        
-        key_path = self.prepare_ssh_key(ssh_key, key_filename, ssh_dir)
-        
-        # Execute git pull
-        cmd = [
-            "git",
-            "-c",
-            f"core.sshCommand=ssh -i {key_path} -o IdentitiesOnly=yes -o StrictHostKeyChecking=accept-new",
-            "pull",
-            git_url,
-            branch,
-        ]
-        
-        git_output = ""
-        git_status = "success"
-        key_env_var_used = f"{workspace_name}_SSHKEY" if workspace_name else "N/A"
-        
-        original_dir = None
-        try:
-            original_dir = os.getcwd()
-            os.chdir(repo_path)
-            
-            result = subprocess.run(
-                cmd,
-                capture_output=True,
-                text=True,
-                check=True,
-            )
-            git_output = result.stdout
-            git_status = "success"
-        except subprocess.CalledProcessError as e:
-            git_output = (e.stdout or "") + (e.stderr or "")
-            git_status = "error"
-            raise
-        finally:
-            if original_dir:
-                try:
-                    os.chdir(original_dir)
-                except Exception:
-                    pass
-            # Clean up the key file
-            try:
-                os.remove(key_path)
-            except Exception:
-                pass
-        
-        return {
-            "workspace": workspace_name or "N/A",
-            "repo_path": repo_path,
-            "git_pull_status": git_status,
-            "git_pull_output": git_output.strip(),
-            "key_env_var_used": key_env_var_used,
-        }
-    
-    def execute_with_alerting(
-        self,
-        repo_path: str,
-        git_url: str,
-        branch: str = "master",
-        ssh_key: Optional[str] = None,
-        workspace_name: Optional[str] = None,
-        pipeline_uuid: str = "auto_git_pull",
-        suppression_hours: int = 1,
-        key_filename: Optional[str] = None,
-        ssh_dir: str = "/home/src/.ssh"
-    ) -> Dict[str, Any]:
-        repo_name = git_url.split('/')[-1].replace('.git', '')
-        
-        try:
-            result = self.execute_git_pull(
-                repo_path=repo_path,
-                git_url=git_url,
-                branch=branch,
-                ssh_key=ssh_key,
-                workspace_name=workspace_name,
-                key_filename=key_filename,
-                ssh_dir=ssh_dir
-            )
-            
-            # Clear alert state on success
-            self.alert_manager.clear_alert_state(pipeline_uuid)
-            
-            return result
-            
-        except Exception as e:
-            git_output = str(e)
-            error_signature = git_output.strip()[:500]
-            
-            # Check if we should send alert
-            should_alert, _ = self.alert_manager.should_send_alert(
-                pipeline_uuid,
-                error_signature,
-                suppression_hours=suppression_hours
-            )
-            
-            if should_alert:
-                # Send alert
-                self.slack_notifier.send_alert(repo_name, git_output[:1500])
-                
-                # Save alert state
-                self.alert_manager.save_alert_state(
-                    pipeline_uuid,
-                    error_signature,
-                    datetime.now(),
-                    pipeline_status="failed"
-                )
-            else:
-                # Alert suppressed
-                state = self.alert_manager.state_manager.load_alert_state(pipeline_uuid)
-                last_alert_time = state.get("last_alert_time")
-                if last_alert_time:
-                    try:
-                        from datetime import datetime, timedelta
-                        last_alert_dt = datetime.fromisoformat(last_alert_time)
-                        time_since = datetime.now() - last_alert_dt
-                        print(f"🔇 Alert suppressed - same error occurred {time_since} ago (suppression window: {suppression_hours} hour(s))")
-                    except:
-                        print(f"🔇 Alert suppressed - same error within suppression window ({suppression_hours} hour(s))")
-            
-            # Re-raise the exception
-            raise
-
+import os
+import subprocess
+from typing import Dict, Any, Optional
+from datetime import datetime
+from .alert_manager import AlertManager
+from .slack_notifier import SlackNotifier
+
+class GitPullExecutor:    
+    def __init__(
+        self,
+        slack_webhook_url: Optional[str] = None,
+        use_mage_ai: bool = False,
+        state_manager: Optional[Any] = None
+    ):
+        self.slack_notifier = SlackNotifier(webhook_url=slack_webhook_url)
+        self.alert_manager = AlertManager(state_manager=state_manager, use_mage_ai=use_mage_ai)
+    
+    def normalize_ssh_key(self, key_material: str) -> str:
+        if not key_material:
+            return key_material
+        
+        # Remove any quotes that might be wrapping the key
+        key_material = key_material.strip().strip('"').strip("'")
+        
+        # Handle literal \n sequences
+        if "\\n" in key_material:
+            key_material = key_material.replace("\\n", "\n")
+        
+        # Ensure proper line endings
+        if not key_material.endswith("\n"):
+            key_material += "\n"
+        
+        return key_material
+    
+    def prepare_ssh_key(
+        self, 
+        key_material: str, 
+        key_filename: str = "deploy_key",
+        ssh_dir: str = "/home/src/.ssh"
+    ) -> str:
+        os.makedirs(ssh_dir, exist_ok=True)
+        os.chmod(ssh_dir, 0o700)
+        
+        key_path = os.path.join(ssh_dir, key_filename)
+        
+        # Write key with restricted permissions
+        with open(key_path, "w") as f:
+            f.write(key_material)
+        os.chmod(key_path, 0o600)
+        
+        return key_path
+    
+    def execute_git_pull(
+        self,
+        repo_path: str,
+        git_url: str,
+        branch: str = "master",
+        ssh_key: Optional[str] = None,
+        workspace_name: Optional[str] = None,
+        key_filename: Optional[str] = None,
+        ssh_dir: str = "/home/src/.ssh"
+    ) -> Dict[str, Any]:
+        if not os.path.exists(repo_path):
+            raise ValueError(f"Repo path does not exist: {repo_path}")
+        
+        # Validate SSH key
+        if not ssh_key:
+            raise ValueError("SSH key is required. Provide it directly as a parameter.")
+        
+        # Normalize key
+        ssh_key = self.normalize_ssh_key(ssh_key)
+        
+        # Prepare key file
+        if not key_filename:
+            key_filename = f"{workspace_name}_deploy" if workspace_name else "deploy_key"
+        
+        key_path = self.prepare_ssh_key(ssh_key, key_filename, ssh_dir)
+        
+        # Execute git pull
+        cmd = [
+            "git",
+            "-c",
+            f"core.sshCommand=ssh -i {key_path} -o IdentitiesOnly=yes -o StrictHostKeyChecking=accept-new",
+            "pull",
+            git_url,
+            branch,
+        ]
+        
+        git_output = ""
+        git_status = "success"
+        
+        original_dir = None
+        try:
+            original_dir = os.getcwd()
+            os.chdir(repo_path)
+            
+            result = subprocess.run(
+                cmd,
+                capture_output=True,
+                text=True,
+                check=True,
+            )
+            git_output = result.stdout
+            git_status = "success"
+        except subprocess.CalledProcessError as e:
+            git_output = (e.stdout or "") + (e.stderr or "")
+            git_status = "error"
+            raise
+        finally:
+            if original_dir:
+                try:
+                    os.chdir(original_dir)
+                except Exception:
+                    pass
+            # Clean up the key file
+            try:
+                os.remove(key_path)
+            except Exception:
+                pass
+        
+        return {
+            "workspace": workspace_name or "N/A",
+            "repo_path": repo_path,
+            "git_pull_status": git_status,
+            "git_pull_output": git_output.strip(),
+        }
+    
+    def execute_with_alerting(
+        self,
+        repo_path: str,
+        git_url: str,
+        branch: str = "master",
+        ssh_key: Optional[str] = None,
+        workspace_name: Optional[str] = None,
+        pipeline_uuid: str = "auto_git_pull",
+        suppression_hours: int = 1,
+        key_filename: Optional[str] = None,
+        ssh_dir: str = "/home/src/.ssh"
+    ) -> Dict[str, Any]:
+        repo_name = git_url.split('/')[-1].replace('.git', '')
+        
+        try:
+            result = self.execute_git_pull(
+                repo_path=repo_path,
+                git_url=git_url,
+                branch=branch,
+                ssh_key=ssh_key,
+                workspace_name=workspace_name,
+                key_filename=key_filename,
+                ssh_dir=ssh_dir
+            )
+            
+            # Clear alert state on success
+            self.alert_manager.clear_alert_state(pipeline_uuid)
+            
+            return result
+            
+        except Exception as e:
+            git_output = str(e)
+            error_signature = git_output.strip()[:500]
+            
+            # Check if we should send alert
+            should_alert, _ = self.alert_manager.should_send_alert(
+                pipeline_uuid,
+                error_signature,
+                suppression_hours=suppression_hours
+            )
+            
+            if should_alert:
+                # Send alert
+                self.slack_notifier.send_alert(repo_name, git_output[:1500])
+                
+                # Save alert state
+                self.alert_manager.save_alert_state(
+                    pipeline_uuid,
+                    error_signature,
+                    datetime.now(),
+                    pipeline_status="failed"
+                )
+            else:
+                # Alert suppressed
+                state = self.alert_manager.state_manager.load_alert_state(pipeline_uuid)
+                last_alert_time = state.get("last_alert_time")
+                if last_alert_time:
+                    try:
+                        last_alert_dt = datetime.fromisoformat(last_alert_time)
+                        time_since = datetime.now() - last_alert_dt
+                        print(f"🔇 Alert suppressed - same error occurred {time_since} ago (suppression window: {suppression_hours} hour(s))")
+                    except:
+                        print(f"🔇 Alert suppressed - same error within suppression window ({suppression_hours} hour(s))")
+            
+            # Re-raise the exception
+            raise
+

{salla_gitpuller-1.0.0 → salla_gitpuller-1.0.2}/gitpuller/slack_notifier.py

@@ -1,60 +1,58 @@
-import os
-import requests
-from typing import Optional, Dict, Any
-
-
-class SlackNotifier:
-    
-    def __init__(self, webhook_url: Optional[str] = None):
-        self.webhook_url = webhook_url or os.environ.get("CDM_SLACK_WEBHOOK_URL")
-        if not self.webhook_url:
-            raise ValueError(
-                "Slack webhook URL is required. "
-                "Provide it as parameter or set CDM_SLACK_WEBHOOK_URL environment variable."
-            )
-    
-    def create_failure_payload(self, repo_name: str, error_output: str) -> Dict[str, Any]:
-        payload = {
-            "text": f"Automate Git Pull Pipeline Failed",
-            "blocks": [
-                {
-                    "type": "header",
-                    "text": {
-                        "type": "plain_text",
-                        "text": f":alert: Automate Git Pull Pipeline Failed :alert:"
-                    }
-                },
-                {
-                    "type": "divider"
-                },
-                {
-                    "type": "section",
-                    "text": {
-                        "type": "mrkdwn",
-                        "text": f"*Repository:* `{repo_name}`"
-                    }
-                }
-            ]
-        }
-        
-        if error_output:
-            payload["blocks"].append({
-                "type": "section",
-                "text": {
-                    "type": "mrkdwn",
-                    "text": f"*Error Output:*\n```{error_output[:1500]}```"
-                }
-            })
-        
-        return payload
-    
-    def send_alert(self, repo_name: str, error_output: str = "") -> bool:
-        try:
-            payload = self.create_failure_payload(repo_name, error_output)
-            response = requests.post(self.webhook_url, json=payload, timeout=10)
-            response.raise_for_status()
-            print("✅ Alert sent to Slack")
-            return True
-        except Exception as e:
-            print(f"⚠️ Failed to send Slack alert: {e}")
+import requests
+from typing import Optional, Dict, Any
+
+
+class SlackNotifier:
+    
+    def __init__(self, webhook_url: Optional[str] = None):
+        if not webhook_url:
+            raise ValueError(
+                "Slack webhook URL is required. Provide it as parameter."
+            )
+        self.webhook_url = webhook_url
+    
+    def create_failure_payload(self, repo_name: str, error_output: str) -> Dict[str, Any]:
+        payload = {
+            "text": f"Automate Git Pull Pipeline Failed",
+            "blocks": [
+                {
+                    "type": "header",
+                    "text": {
+                        "type": "plain_text",
+                        "text": f":alert: Automate Git Pull Pipeline Failed :alert:"
+                    }
+                },
+                {
+                    "type": "divider"
+                },
+                {
+                    "type": "section",
+                    "text": {
+                        "type": "mrkdwn",
+                        "text": f"*Repository:* `{repo_name}`"
+                    }
+                }
+            ]
+        }
+        
+        if error_output:
+            payload["blocks"].append({
+                "type": "section",
+                "text": {
+                    "type": "mrkdwn",
+                    "text": f"*Error Output:*\n```{error_output[:1500]}```"
+                }
+            })
+        
+        return payload
+    
+    def send_alert(self, repo_name: str, error_output: str = "") -> bool:
+        try:
+            payload = self.create_failure_payload(repo_name, error_output)
+            response = requests.post(self.webhook_url, json=payload, timeout=10)
+            response.raise_for_status()
+            print("✅ Alert sent to Slack")
+            return True
+        except Exception as e:
+            print(f"⚠️ Failed to send Slack alert: {e}")
             return False

{salla_gitpuller-1.0.0 → salla_gitpuller-1.0.2}/gitpuller/state_manager.py

@@ -1,113 +1,113 @@
-from typing import Any, Dict, Optional
-from datetime import datetime
-
-class StateManager:    
-    def load_alert_state(self, pipeline_uuid: str) -> Dict[str, Any]:
-        """Load alert state for a pipeline."""
-        raise NotImplementedError
-    
-    def save_alert_state(
-        self, 
-        pipeline_uuid: str, 
-        error_message: str, 
-        alert_time: datetime, 
-        pipeline_status: str
-    ) -> None:
-        """Save alert state for a pipeline."""
-        raise NotImplementedError
-    
-    def clear_alert_state(self, pipeline_uuid: str) -> None:
-        """Clear alert state for a pipeline."""
-        raise NotImplementedError
-
-class InMemoryStateManager(StateManager):    
-    def __init__(self):
-        self._state: Dict[str, Dict[str, Any]] = {}
-    
-    def load_alert_state(self, pipeline_uuid: str) -> Dict[str, Any]:
-        """Load alert state from memory."""
-        return self._state.get(pipeline_uuid, {
-            "last_alert_time": None,
-            "last_error_message": None
-        })
-    
-    def save_alert_state(
-        self, 
-        pipeline_uuid: str, 
-        error_message: str, 
-        alert_time: datetime, 
-        pipeline_status: str
-    ) -> None:
-        """Save alert state to memory."""
-        self._state[pipeline_uuid] = {
-            "last_alert_time": alert_time.isoformat(),
-            "last_error_message": error_message,
-            "pipeline_status": pipeline_status,
-            "last_alert_timestamp": alert_time.isoformat()
-        }
-    
-    def clear_alert_state(self, pipeline_uuid: str) -> None:
-        """Clear alert state from memory."""
-        if pipeline_uuid in self._state:
-            self._state[pipeline_uuid] = {
-                "last_alert_time": None,
-                "last_error_message": None,
-                "pipeline_status": "success"
-            }
-
-class MageAIStateManager(StateManager):    
-    def __init__(self):
-        try:
-            from mage_ai.data_preparation.variable_manager import (
-                set_global_variable, 
-                get_global_variable
-            )
-            self._set_global_variable = set_global_variable
-            self._get_global_variable = get_global_variable
-        except ImportError:
-            raise ImportError(
-                "Mage AI is not installed. Install it with: pip install mage-ai"
-            )
-    
-    def load_alert_state(self, pipeline_uuid: str) -> Dict[str, Any]:
-        try:
-            last_error_message = self._get_global_variable(pipeline_uuid, 'last_error_message')
-            last_alert_time = self._get_global_variable(pipeline_uuid, 'last_alert_time')
-            
-            if last_error_message and last_alert_time:
-                return {
-                    "last_alert_time": last_alert_time,
-                    "last_error_message": last_error_message
-                }
-        except Exception as e:
-            print(f"⚠️ Warning: Could not load alert state from global variables: {e}")
-        
-        return {
-            "last_alert_time": None,
-            "last_error_message": None
-        }
-    
-    def save_alert_state(
-        self, 
-        pipeline_uuid: str, 
-        error_message: str, 
-        alert_time: datetime, 
-        pipeline_status: str
-    ) -> None:
-        try:
-            self._set_global_variable(pipeline_uuid, 'last_error_message', error_message)
-            self._set_global_variable(pipeline_uuid, 'last_alert_time', alert_time.isoformat())
-            self._set_global_variable(pipeline_uuid, 'pipeline_status', pipeline_status)
-            self._set_global_variable(pipeline_uuid, 'last_alert_timestamp', alert_time.isoformat())
-            print(f"✅ Saved alert state to global variables: error_message, pipeline_status={pipeline_status}")
-        except Exception as e:
-            print(f"⚠️ Warning: Could not save alert state to global variables: {e}")
-    
-    def clear_alert_state(self, pipeline_uuid: str) -> None:
-        try:
-            self._set_global_variable(pipeline_uuid, 'last_error_message', None)
-            self._set_global_variable(pipeline_uuid, 'last_alert_time', None)
-            self._set_global_variable(pipeline_uuid, 'pipeline_status', 'success')
-            print("✅ Cleared alert state from global variables")
-        except Exception as e:
+from typing import Any, Dict, Optional
+from datetime import datetime
+
+class StateManager:    
+    def load_alert_state(self, pipeline_uuid: str) -> Dict[str, Any]:
+        """Load alert state for a pipeline."""
+        raise NotImplementedError
+    
+    def save_alert_state(
+        self, 
+        pipeline_uuid: str, 
+        error_message: str, 
+        alert_time: datetime, 
+        pipeline_status: str
+    ) -> None:
+        """Save alert state for a pipeline."""
+        raise NotImplementedError
+    
+    def clear_alert_state(self, pipeline_uuid: str) -> None:
+        """Clear alert state for a pipeline."""
+        raise NotImplementedError
+
+class InMemoryStateManager(StateManager):    
+    def __init__(self):
+        self._state: Dict[str, Dict[str, Any]] = {}
+    
+    def load_alert_state(self, pipeline_uuid: str) -> Dict[str, Any]:
+        """Load alert state from memory."""
+        return self._state.get(pipeline_uuid, {
+            "last_alert_time": None,
+            "last_error_message": None
+        })
+    
+    def save_alert_state(
+        self, 
+        pipeline_uuid: str, 
+        error_message: str, 
+        alert_time: datetime, 
+        pipeline_status: str
+    ) -> None:
+        """Save alert state to memory."""
+        self._state[pipeline_uuid] = {
+            "last_alert_time": alert_time.isoformat(),
+            "last_error_message": error_message,
+            "pipeline_status": pipeline_status,
+            "last_alert_timestamp": alert_time.isoformat()
+        }
+    
+    def clear_alert_state(self, pipeline_uuid: str) -> None:
+        """Clear alert state from memory."""
+        if pipeline_uuid in self._state:
+            self._state[pipeline_uuid] = {
+                "last_alert_time": None,
+                "last_error_message": None,
+                "pipeline_status": "success"
+            }
+
+class MageAIStateManager(StateManager):    
+    def __init__(self):
+        try:
+            from mage_ai.data_preparation.variable_manager import (
+                set_global_variable, 
+                get_global_variable
+            )
+            self._set_global_variable = set_global_variable
+            self._get_global_variable = get_global_variable
+        except ImportError:
+            raise ImportError(
+                "Mage AI is not installed. Install it with: pip install mage-ai"
+            )
+    
+    def load_alert_state(self, pipeline_uuid: str) -> Dict[str, Any]:
+        try:
+            last_error_message = self._get_global_variable(pipeline_uuid, 'last_error_message')
+            last_alert_time = self._get_global_variable(pipeline_uuid, 'last_alert_time')
+            
+            if last_error_message and last_alert_time:
+                return {
+                    "last_alert_time": last_alert_time,
+                    "last_error_message": last_error_message
+                }
+        except Exception as e:
+            print(f"⚠️ Warning: Could not load alert state from global variables: {e}")
+        
+        return {
+            "last_alert_time": None,
+            "last_error_message": None
+        }
+    
+    def save_alert_state(
+        self, 
+        pipeline_uuid: str, 
+        error_message: str, 
+        alert_time: datetime, 
+        pipeline_status: str
+    ) -> None:
+        try:
+            self._set_global_variable(pipeline_uuid, 'last_error_message', error_message)
+            self._set_global_variable(pipeline_uuid, 'last_alert_time', alert_time.isoformat())
+            self._set_global_variable(pipeline_uuid, 'pipeline_status', pipeline_status)
+            self._set_global_variable(pipeline_uuid, 'last_alert_timestamp', alert_time.isoformat())
+            print(f"✅ Saved alert state to global variables: error_message, pipeline_status={pipeline_status}")
+        except Exception as e:
+            print(f"⚠️ Warning: Could not save alert state to global variables: {e}")
+    
+    def clear_alert_state(self, pipeline_uuid: str) -> None:
+        try:
+            self._set_global_variable(pipeline_uuid, 'last_error_message', None)
+            self._set_global_variable(pipeline_uuid, 'last_alert_time', None)
+            self._set_global_variable(pipeline_uuid, 'pipeline_status', 'success')
+            print("✅ Cleared alert state from global variables")
+        except Exception as e:
             print(f"⚠️ Warning: Could not clear alert state: {e}")

{salla_gitpuller-1.0.0 → salla_gitpuller-1.0.2}/gitpuller/utils.py

@@ -1,35 +1,35 @@
-import os
-
-
-def get_repo_path() -> str:
-    """
-    Returns the current working repository path (directory of this script).
-    """
-    return os.getcwd()
-
-
-def get_env_base_path() -> str:
-    """
-    Returns the value of the ENV environment variable.
-    """
-    return os.environ.get("ENV", "")
-
-
-def transform_custom() -> tuple[str, str]:
-    """
-    Returns a tuple of (repo_path, base_path)
-    """
-    repo_path = get_repo_path()
-    base_path = get_env_base_path()
-
-    if not repo_path:
-        raise Exception("Unable to determine repository path.")
-
-    return repo_path, base_path
-
-
-def test_output(output) -> None:
-    """
-    Simple test function to validate non-empty output.
-    """
-    assert output is not None, "Output is undefined"
+import os
+
+
+def get_repo_path() -> str:
+    """
+    Returns the current working repository path (directory of this script).
+    """
+    return os.getcwd()
+
+
+def get_env_base_path() -> str:
+    """
+    Returns the value of the ENV environment variable.
+    """
+    return os.environ.get("ENV", "")
+
+
+def transform_custom() -> tuple[str, str]:
+    """
+    Returns a tuple of (repo_path, base_path)
+    """
+    repo_path = get_repo_path()
+    base_path = get_env_base_path()
+
+    if not repo_path:
+        raise Exception("Unable to determine repository path.")
+
+    return repo_path, base_path
+
+
+def test_output(output) -> None:
+    """
+    Simple test function to validate non-empty output.
+    """
+    assert output is not None, "Output is undefined"

{salla_gitpuller-1.0.0 → salla_gitpuller-1.0.2}/pyproject.toml

@@ -1,19 +1,19 @@
-[build-system]
-requires = ["setuptools>=61.0"]
-build-backend = "setuptools.build_meta"
-
-[project]
-name = "salla_gitpuller"
-version = "1.0.0"
-description = "A lightweight utility to git pull a repository using SSH deploy keys stored in environment variables"
-readme = "README.md"
-authors = [
-  { name="Muhammad Zahid", email="zahidmuhammad127@gmail.com" }
-]
-license = { text = "MIT" }
-dependencies = []
-
-[project.urls]
-Homepage = "https://github.com/Zahid07/gitpuller"
-
-
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "salla_gitpuller"
+version = "1.0.2"
+description = "A lightweight utility to git pull a repository using SSH deploy keys stored in environment variables"
+readme = "README.md"
+authors = [
+  { name="Muhammad Zahid", email="zahidmuhammad127@gmail.com" }
+]
+license = { text = "MIT" }
+dependencies = []
+
+[project.urls]
+Homepage = "https://github.com/Zahid07/gitpuller"
+
+

salla_gitpuller-1.0.2/salla_gitpuller.egg-info/PKG-INFO

@@ -0,0 +1,35 @@
+Metadata-Version: 2.4
+Name: salla_gitpuller
+Version: 1.0.2
+Summary: A lightweight utility to git pull a repository using SSH deploy keys stored in environment variables
+Author-email: Muhammad Zahid <zahidmuhammad127@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/Zahid07/gitpuller
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# gitpuller
+
+## Usage
+
+```python
+from gitpuller import GitPullExecutor
+
+executor = GitPullExecutor(slack_webhook_url="your_webhook_url", use_mage_ai=True)
+result = executor.execute_with_alerting(
+    repo_path="/path/to/repo",
+    git_url="git@github.com:user/repo.git",
+    branch="master",
+    workspace_name="workspace1"
+)
+```
+
+## Build
+
+```bash
+rm -rf build dist *.egg-info
+python -m build
+```
+
+Upload to PyPI and update version in `pyproject.toml`.

salla_gitpuller-1.0.0/PKG-INFO

@@ -1,33 +0,0 @@
-Metadata-Version: 2.4
-Name: salla_gitpuller
-Version: 1.0.0
-Summary: A lightweight utility to git pull a repository using SSH deploy keys stored in environment variables
-Author-email: Muhammad Zahid <zahidmuhammad127@gmail.com>
-License: MIT
-Project-URL: Homepage, https://github.com/Zahid07/gitpuller
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Dynamic: license-file
-
-# gitpuller
-
-This is how to use this
-
-from gitpuller import git_pull, transform_custom
-
-repo_path, base_path = transform_custom()
-result = git_pull(repo_path, "workspace1", "git@github.com:youruser/yourrepo.git", "1234")
-print(result)
-
-
-## New Build
-
-Clean up the orignal build
-
-rm -rf build dist *.egg-info
-
-Make a new build
-
-python -m build
-
-Then Upload to PyPi and dont forget to change the version in pyproject.toml

salla_gitpuller-1.0.0/README.md

@@ -1,22 +0,0 @@
-# gitpuller
-
-This is how to use this
-
-from gitpuller import git_pull, transform_custom
-
-repo_path, base_path = transform_custom()
-result = git_pull(repo_path, "workspace1", "git@github.com:youruser/yourrepo.git", "1234")
-print(result)
-
-
-## New Build
-
-Clean up the orignal build
-
-rm -rf build dist *.egg-info
-
-Make a new build
-
-python -m build
-
-Then Upload to PyPi and dont forget to change the version in pyproject.toml

salla_gitpuller-1.0.0/salla_gitpuller.egg-info/PKG-INFO

@@ -1,33 +0,0 @@
-Metadata-Version: 2.4
-Name: salla_gitpuller
-Version: 1.0.0
-Summary: A lightweight utility to git pull a repository using SSH deploy keys stored in environment variables
-Author-email: Muhammad Zahid <zahidmuhammad127@gmail.com>
-License: MIT
-Project-URL: Homepage, https://github.com/Zahid07/gitpuller
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Dynamic: license-file
-
-# gitpuller
-
-This is how to use this
-
-from gitpuller import git_pull, transform_custom
-
-repo_path, base_path = transform_custom()
-result = git_pull(repo_path, "workspace1", "git@github.com:youruser/yourrepo.git", "1234")
-print(result)
-
-
-## New Build
-
-Clean up the orignal build
-
-rm -rf build dist *.egg-info
-
-Make a new build
-
-python -m build
-
-Then Upload to PyPi and dont forget to change the version in pyproject.toml