mcli-framework 7.12.0__py3-none-any.whl → 7.12.3__py3-none-any.whl

mcli/workflow/scheduler/monitor.py

@@ -4,18 +4,18 @@ Job monitoring and execution tracking for the MCLI scheduler
 
 import threading
 import time
-from datetime import datetime, timedelta
+from datetime import datetime
 from typing import Callable, Dict, List, Optional
 
 from mcli.lib.logger.logger import get_logger
 
-from .job import JobStatus, ScheduledJob
+from .job import ScheduledJob
 
 logger = get_logger(__name__)
 
 
 class JobMonitor:
-    """Monitors running jobs and handles timeouts, retries, and status updates"""
+    """Monitors running jobs and handles timeouts, retries, and status updates."""
 
     def __init__(self, status_callback: Optional[Callable] = None):
         self.running_jobs: Dict[str, threading.Thread] = {}
@@ -26,7 +26,7 @@ class JobMonitor:
         self.lock = threading.Lock()
 
     def start_monitoring(self):
-        """Start the monitoring thread"""
+        """Start the monitoring thread."""
         if self.monitoring:
             return
 
@@ -36,14 +36,14 @@ class JobMonitor:
         logger.info("Job monitor started")
 
     def stop_monitoring(self):
-        """Stop the monitoring thread"""
+        """Stop the monitoring thread."""
         self.monitoring = False
         if self.monitor_thread:
             self.monitor_thread.join(timeout=5)
         logger.info("Job monitor stopped")
 
     def _monitor_loop(self):
-        """Main monitoring loop"""
+        """Main monitoring loop."""
         while self.monitoring:
             try:
                 self._check_running_jobs()
@@ -52,7 +52,7 @@ class JobMonitor:
                 logger.error(f"Error in monitor loop: {e}")
 
     def _check_running_jobs(self):
-        """Check status of running jobs"""
+        """Check status of running jobs."""
         with self.lock:
             current_time = datetime.now()
             jobs_to_remove = []
@@ -61,7 +61,7 @@ class JobMonitor:
                 start_time = self.job_start_times.get(job_id)
 
                 if start_time:
-                    runtime = (current_time - start_time).total_seconds()
+                    (current_time - start_time).total_seconds()
 
                     # Check if thread is still alive
                     if not thread.is_alive():
@@ -76,29 +76,29 @@ class JobMonitor:
                 self._remove_job(job_id)
 
     def add_job(self, job: ScheduledJob, thread: threading.Thread):
-        """Add a job to monitoring"""
+        """Add a job to monitoring."""
         with self.lock:
             self.running_jobs[job.id] = thread
             self.job_start_times[job.id] = datetime.now()
             logger.debug(f"Added job {job.id} to monitor")
 
     def _remove_job(self, job_id: str):
-        """Remove a job from monitoring"""
+        """Remove a job from monitoring."""
         self.running_jobs.pop(job_id, None)
         self.job_start_times.pop(job_id, None)
 
     def get_running_jobs(self) -> List[str]:
-        """Get list of currently running job IDs"""
+        """Get list of currently running job IDs."""
         with self.lock:
             return list(self.running_jobs.keys())
 
     def is_job_running(self, job_id: str) -> bool:
-        """Check if a specific job is currently running"""
+        """Check if a specific job is currently running."""
         with self.lock:
             return job_id in self.running_jobs
 
     def get_job_runtime(self, job_id: str) -> Optional[int]:
-        """Get runtime in seconds for a running job"""
+        """Get runtime in seconds for a running job."""
         with self.lock:
             start_time = self.job_start_times.get(job_id)
             if start_time:
@@ -106,7 +106,7 @@ class JobMonitor:
         return None
 
     def kill_job(self, job_id: str) -> bool:
-        """Attempt to kill a running job"""
+        """Attempt to kill a running job."""
         with self.lock:
             thread = self.running_jobs.get(job_id)
             if thread and thread.is_alive():
@@ -117,7 +117,7 @@ class JobMonitor:
         return True
 
     def get_monitor_stats(self) -> dict:
-        """Get monitoring statistics"""
+        """Get monitoring statistics."""
         with self.lock:
             stats = {
                 "monitoring": self.monitoring,

mcli/workflow/scheduler/persistence.py

@@ -5,11 +5,10 @@ Handles saving/loading jobs to/from disk, ensuring persistence across power cycl
 """
 
 import json
-import os
 import threading
 from datetime import datetime
 from pathlib import Path
-from typing import Dict, List, Optional
+from typing import List, Optional
 
 from mcli.lib.logger.logger import get_logger
 
@@ -19,7 +18,7 @@ logger = get_logger(__name__)
 
 
 class JobStorage:
-    """Handles persistent storage of scheduled jobs"""
+    """Handles persistent storage of scheduled jobs."""
 
     def __init__(self, storage_dir: Optional[str] = None):
         self.storage_dir = Path(storage_dir) if storage_dir else self._get_default_storage_dir()
@@ -34,13 +33,13 @@ class JobStorage:
         self._initialize_storage()
 
     def _get_default_storage_dir(self) -> Path:
-        """Get default storage directory"""
+        """Get default storage directory."""
         home = Path.home()
         storage_dir = home / ".mcli" / "scheduler"
         return storage_dir
 
     def _initialize_storage(self):
-        """Initialize storage files if they don't exist"""
+        """Initialize storage files if they don't exist."""
         if not self.jobs_file.exists():
             self._write_json_file(self.jobs_file, {"jobs": [], "version": "1.0"})
 
@@ -48,7 +47,7 @@ class JobStorage:
             self._write_json_file(self.history_file, {"history": [], "version": "1.0"})
 
     def _read_json_file(self, file_path: Path) -> dict:
-        """Safely read JSON file with error handling"""
+        """Safely read JSON file with error handling."""
         try:
             with open(file_path, "r", encoding="utf-8") as f:
                 return json.load(f)
@@ -63,7 +62,7 @@ class JobStorage:
             return {}
 
     def _write_json_file(self, file_path: Path, data: dict):
-        """Safely write JSON file with atomic operation"""
+        """Safely write JSON file with atomic operation."""
         temp_file = file_path.with_suffix(".tmp")
         try:
             with open(temp_file, "w", encoding="utf-8") as f:
@@ -78,7 +77,7 @@ class JobStorage:
                 temp_file.unlink()
 
     def save_jobs(self, jobs: List[ScheduledJob]) -> bool:
-        """Save list of jobs to persistent storage"""
+        """Save list of jobs to persistent storage."""
         with self.lock:
             try:
                 jobs_data = {
@@ -97,7 +96,7 @@ class JobStorage:
                 return False
 
     def load_jobs(self) -> List[ScheduledJob]:
-        """Load jobs from persistent storage"""
+        """Load jobs from persistent storage."""
         with self.lock:
             try:
                 data = self._read_json_file(self.jobs_file)
@@ -119,7 +118,7 @@ class JobStorage:
                 return []
 
     def save_job(self, job: ScheduledJob) -> bool:
-        """Save a single job (update existing or add new)"""
+        """Save a single job (update existing or add new)."""
         jobs = self.load_jobs()
 
         # Find existing job or add new one
@@ -136,7 +135,7 @@ class JobStorage:
         return self.save_jobs(jobs)
 
     def delete_job(self, job_id: str) -> bool:
-        """Delete a job from storage"""
+        """Delete a job from storage."""
         jobs = self.load_jobs()
         original_count = len(jobs)
 
@@ -147,7 +146,7 @@ class JobStorage:
         return False
 
     def get_job(self, job_id: str) -> Optional[ScheduledJob]:
-        """Get a specific job by ID"""
+        """Get a specific job by ID."""
         jobs = self.load_jobs()
         for job in jobs:
             if job.id == job_id:
@@ -155,7 +154,7 @@ class JobStorage:
         return None
 
     def record_job_execution(self, job: ScheduledJob, execution_data: dict):
-        """Record job execution in history"""
+        """Record job execution in history."""
         with self.lock:
             try:
                 history_data = self._read_json_file(self.history_file)
@@ -192,7 +191,7 @@ class JobStorage:
                 logger.error(f"Failed to record job execution: {e}")
 
     def get_job_history(self, job_id: Optional[str] = None, limit: int = 100) -> List[dict]:
-        """Get job execution history"""
+        """Get job execution history."""
         try:
             history_data = self._read_json_file(self.history_file)
             history = history_data.get("history", [])
@@ -210,7 +209,7 @@ class JobStorage:
             return []
 
     def cleanup_old_history(self, days: int = 30):
-        """Remove job history older than specified days"""
+        """Remove job history older than specified days."""
         with self.lock:
             try:
                 cutoff_date = datetime.now() - timedelta(days=days)
@@ -240,7 +239,7 @@ class JobStorage:
                 logger.error(f"Failed to cleanup old history: {e}")
 
     def export_jobs(self, export_path: str) -> bool:
-        """Export all jobs to a file"""
+        """Export all jobs to a file."""
         try:
             jobs = self.load_jobs()
             export_data = {
@@ -261,7 +260,7 @@ class JobStorage:
             return False
 
     def import_jobs(self, import_path: str, replace: bool = False) -> int:
-        """Import jobs from a file"""
+        """Import jobs from a file."""
         try:
             with open(import_path, "r", encoding="utf-8") as f:
                 import_data = json.load(f)
@@ -296,7 +295,7 @@ class JobStorage:
             return 0
 
     def get_storage_info(self) -> dict:
-        """Get information about storage usage"""
+        """Get information about storage usage."""
         try:
             jobs_size = self.jobs_file.stat().st_size if self.jobs_file.exists() else 0
             history_size = self.history_file.stat().st_size if self.history_file.exists() else 0

mcli/workflow/scheduler/scheduler.py

@@ -5,7 +5,6 @@ Coordinates job scheduling, execution, monitoring, and persistence.
 Provides the primary interface for the cron scheduling system.
 """
 
-import asyncio
 import json
 import os
 import signal
@@ -13,7 +12,7 @@ import subprocess
 import threading
 import time
 from datetime import datetime, timedelta
-from typing import Any, Callable, Dict, List, Optional
+from typing import Any, Dict, List, Optional
 
 from mcli.lib.logger.logger import get_logger
 
@@ -26,14 +25,14 @@ logger = get_logger(__name__)
 
 
 class JobExecutor:
-    """Handles job execution in separate processes/threads"""
+    """Handles job execution in separate processes/threads."""
 
     def __init__(self):
         self.running_processes: Dict[str, subprocess.Popen] = {}
         self.lock = threading.Lock()
 
     def execute_job(self, job: ScheduledJob) -> Dict[str, Any]:
-        """Execute a job and return execution results"""
+        """Execute a job and return execution results."""
         start_time = datetime.now()
         result = {
             "job_id": job.id,
@@ -85,7 +84,7 @@ class JobExecutor:
         return result
 
     def _execute_command(self, job: ScheduledJob) -> Dict[str, Any]:
-        """Execute shell command"""
+        """Execute shell command."""
         env = os.environ.copy()
         env.update(job.environment)
 
@@ -119,7 +118,7 @@ class JobExecutor:
                 self.running_processes.pop(job.id, None)
 
     def _execute_python(self, job: ScheduledJob) -> Dict[str, Any]:
-        """Execute Python code"""
+        """Execute Python code."""
         try:
             # Create temporary Python file
             import tempfile
@@ -156,7 +155,7 @@ class JobExecutor:
             }
 
     def _execute_cleanup(self, job: ScheduledJob) -> Dict[str, Any]:
-        """Execute file system cleanup tasks"""
+        """Execute file system cleanup tasks."""
         try:
             # Parse cleanup command (JSON format expected)
             cleanup_config = json.loads(job.command)
@@ -189,12 +188,12 @@ class JobExecutor:
             }
 
     def _execute_system(self, job: ScheduledJob) -> Dict[str, Any]:
-        """Execute system maintenance tasks"""
+        """Execute system maintenance tasks."""
         # Similar to cleanup but for system-level tasks
         return self._execute_command(job)
 
     def _execute_api_call(self, job: ScheduledJob) -> Dict[str, Any]:
-        """Execute HTTP API calls"""
+        """Execute HTTP API calls."""
         try:
             import requests
 
@@ -237,12 +236,12 @@ class JobExecutor:
             }
 
     def _execute_custom(self, job: ScheduledJob) -> Dict[str, Any]:
-        """Execute custom job types"""
+        """Execute custom job types."""
         # Default to command execution
         return self._execute_command(job)
 
     def _cleanup_old_files(self, path: str, days: int, pattern: str) -> Dict[str, Any]:
-        """Clean up old files in a directory"""
+        """Clean up old files in a directory."""
         try:
             import glob
             from pathlib import Path
@@ -269,7 +268,7 @@ class JobExecutor:
             return {"task": "delete_old_files", "error": str(e)}
 
     def _empty_trash(self) -> Dict[str, Any]:
-        """Empty system trash/recycle bin"""
+        """Empty system trash/recycle bin."""
         try:
             import platform
 
@@ -295,7 +294,7 @@ class JobExecutor:
             return {"task": "empty_trash", "error": str(e)}
 
     def _organize_desktop(self) -> Dict[str, Any]:
-        """Organize desktop files into folders"""
+        """Organize desktop files into folders."""
         try:
             desktop_path = os.path.join(os.path.expanduser("~"), "Desktop")
             if not os.path.exists(desktop_path):
@@ -303,8 +302,8 @@ class JobExecutor:
 
             organized_files = []
             file_types = {
-                "Documents": [".pdf", ".doc", ".docx", ".txt", ".rtf"],
-                "Images": [".jpg", ".jpeg", ".png", ".gif", ".bmp", ".svg"],
+                "Documents": [".pd", ".doc", ".docx", ".txt", ".rt"],
+                "Images": [".jpg", ".jpeg", ".png", ".gi", ".bmp", ".svg"],
                 "Archives": [".zip", ".rar", ".7z", ".tar", ".gz"],
                 "Videos": [".mp4", ".avi", ".mov", ".mkv", ".wmv"],
                 "Audio": [".mp3", ".wav", ".flac", ".aac", ".ogg"],
@@ -335,7 +334,7 @@ class JobExecutor:
             return {"task": "organize_desktop", "error": str(e)}
 
     def kill_job(self, job_id: str) -> bool:
-        """Kill a running job process"""
+        """Kill a running job process."""
         with self.lock:
             process = self.running_processes.get(job_id)
             if process and process.poll() is None:
@@ -352,7 +351,7 @@ class JobExecutor:
 
 
 class JobScheduler:
-    """Main scheduler that coordinates all cron functionality"""
+    """Main scheduler that coordinates all cron functionality."""
 
     def __init__(self, storage_dir: Optional[str] = None):
         self.storage = JobStorage(storage_dir)
@@ -372,18 +371,18 @@ class JobScheduler:
         signal.signal(signal.SIGTERM, self._signal_handler)
 
     def _load_jobs(self):
-        """Load jobs from persistent storage"""
+        """Load jobs from persistent storage."""
         jobs = self.storage.load_jobs()
         self.jobs = {job.id: job for job in jobs}
         logger.info(f"Loaded {len(self.jobs)} jobs from storage")
 
     def _save_jobs(self):
-        """Save all jobs to persistent storage"""
+        """Save all jobs to persistent storage."""
         jobs_list = list(self.jobs.values())
         self.storage.save_jobs(jobs_list)
 
     def start(self):
-        """Start the scheduler"""
+        """Start the scheduler."""
         if self.running:
             logger.warning("Scheduler already running")
             return
@@ -401,7 +400,7 @@ class JobScheduler:
         logger.info("Job scheduler started")
 
     def stop(self):
-        """Stop the scheduler"""
+        """Stop the scheduler."""
         if not self.running:
             return
 
@@ -417,12 +416,12 @@ class JobScheduler:
         logger.info("Job scheduler stopped")
 
     def _signal_handler(self, signum, frame):
-        """Handle system signals"""
+        """Handle system signals."""
         logger.info(f"Received signal {signum}, shutting down scheduler...")
         self.stop()
 
     def _scheduler_loop(self):
-        """Main scheduling loop"""
+        """Main scheduling loop."""
         while self.running:
             try:
                 current_time = datetime.now()
@@ -455,7 +454,7 @@ class JobScheduler:
                 time.sleep(60)  # Wait longer on error
 
     def _should_run_job(self, job: ScheduledJob, current_time: datetime) -> bool:
-        """Check if a job should run at the current time"""
+        """Check if a job should run at the current time."""
         if job.status == JobStatus.RUNNING:
             return False
 
@@ -478,7 +477,7 @@ class JobScheduler:
             return False
 
     def _queue_job_execution(self, job: ScheduledJob):
-        """Queue a job for execution"""
+        """Queue a job for execution."""
 
         def execute_job_thread():
             try:
@@ -505,7 +504,7 @@ class JobScheduler:
         self.monitor.add_job(job, thread)
 
     def _update_job_next_run(self, job: ScheduledJob):
-        """Update job's next run time"""
+        """Update job's next run time."""
         try:
             cron = CronExpression(job.cron_expression)
             if not cron.is_reboot:
@@ -514,13 +513,13 @@ class JobScheduler:
             logger.error(f"Error updating next run time for {job.name}: {e}")
 
     def _update_next_run_times(self):
-        """Update next run times for all jobs"""
+        """Update next run times for all jobs."""
         for job in self.jobs.values():
             if job.enabled and job.next_run is None:
                 self._update_job_next_run(job)
 
     def _execute_reboot_jobs(self):
-        """Execute jobs marked with @reboot"""
+        """Execute jobs marked with @reboot."""
         reboot_jobs = [
             job
             for job in self.jobs.values()
@@ -534,7 +533,7 @@ class JobScheduler:
     # Public API methods
 
     def add_job(self, job: ScheduledJob) -> bool:
-        """Add a new job to the scheduler"""
+        """Add a new job to the scheduler."""
         try:
             with self.lock:
                 self.jobs[job.id] = job
@@ -549,7 +548,7 @@ class JobScheduler:
             return False
 
     def remove_job(self, job_id: str) -> bool:
-        """Remove a job from the scheduler"""
+        """Remove a job from the scheduler."""
         try:
             with self.lock:
                 job = self.jobs.pop(job_id, None)
@@ -567,15 +566,15 @@ class JobScheduler:
             return False
 
     def get_job(self, job_id: str) -> Optional[ScheduledJob]:
-        """Get a job by ID"""
+        """Get a job by ID."""
         return self.jobs.get(job_id)
 
     def get_all_jobs(self) -> List[ScheduledJob]:
-        """Get all jobs"""
+        """Get all jobs."""
         return list(self.jobs.values())
 
     def get_job_status(self, job_id: str) -> Optional[Dict[str, Any]]:
-        """Get detailed status of a job"""
+        """Get detailed status of a job."""
         job = self.jobs.get(job_id)
         if not job:
             return None
@@ -588,7 +587,7 @@ class JobScheduler:
         }
 
     def get_scheduler_stats(self) -> Dict[str, Any]:
-        """Get scheduler statistics"""
+        """Get scheduler statistics."""
         total_jobs = len(self.jobs)
         enabled_jobs = len([j for j in self.jobs.values() if j.enabled])
         running_jobs = len(self.monitor.get_running_jobs())
@@ -603,7 +602,7 @@ class JobScheduler:
         }
 
     def create_json_response(self) -> Dict[str, Any]:
-        """Create JSON response for frontend integration"""
+        """Create JSON response for frontend integration."""
         jobs_data = []
         for job in self.jobs.values():
             job_data = job.to_dict()
@@ -626,7 +625,7 @@ def create_desktop_cleanup_job(
     cron_expression: str = "0 9 * * 1",  # Monday 9 AM
     enabled: bool = True,
 ) -> ScheduledJob:
-    """Create a job to organize desktop files"""
+    """Create a job to organize desktop files."""
     cleanup_config = {"tasks": [{"type": "organize_desktop"}]}
 
     return ScheduledJob(
@@ -646,7 +645,7 @@ def create_temp_cleanup_job(
     days: int = 7,
     enabled: bool = True,
 ) -> ScheduledJob:
-    """Create a job to clean up old temporary files"""
+    """Create a job to clean up old temporary files."""
     cleanup_config = {
         "tasks": [{"type": "delete_old_files", "path": temp_path, "days": days, "pattern": "*"}]
     }
@@ -667,7 +666,7 @@ def create_system_backup_job(
     backup_command: str = "rsync -av /home/user/ /backup/",
     enabled: bool = True,
 ) -> ScheduledJob:
-    """Create a system backup job"""
+    """Create a system backup job."""
     return ScheduledJob(
         name=name,
         cron_expression=cron_expression,

mcli/workflow/secrets/__init__.py

@@ -1,4 +1,4 @@
-"""Secrets workflow - migrated from lib.secrets"""
+"""Secrets workflow - migrated from lib.secrets."""
 
 from .secrets_cmd import secrets
 

mcli/workflow/sync/test_cmd.py

@@ -155,7 +155,6 @@ class McliSyncTester:
 @click.group(name="test")
 def test():
     """Testing commands for sync functionality."""
-    pass
 
 
 @test.command()

mcli/workflow/wakatime/__init__.py

@@ -31,20 +31,18 @@ C3LI_UNAME = os.environ.get("C3LI_UNAME")
 # TODO: To implement / integrate ReactJS version of c3 packages
 @click.group(name="ui")
 def bundle():
-    """ui utility - use this to interact with c3 ui components"""
-    pass
+    """ui utility - use this to interact with c3 ui components."""
 
 
 @click.command(name="provision")
 def provision():
-    """provision utility - use this to provision your c3 package"""
-    pass
+    """provision utility - use this to provision your c3 package."""
 
 
 @click.command(name="v8")
 @click.option("--interactive", "interactive", flag_value=True, default=False)
 def v8(interactive):
-    """bundle utility - use this to bundle your c3 package"""
+    """bundle utility - use this to bundle your c3 package."""
     if interactive:
         pass  # logger.info("Bundling in interactive mode")
     else:
@@ -55,21 +53,19 @@ def v8(interactive):
 @click.command(name="v7")
 @click.option("--interactive", "interactive", flag_value=True, default=False)
 def v7(interactive):
-    """bundle utility - use this to bundle your c3 package"""
+    """bundle utility - use this to bundle your c3 package."""
     if interactive:
         pass  # logger.info("Bundling in interactive mode")
-    pass
 
 
 @click.command(name="sync")
 def sync():
-    """sync utility - use this to sync your c3 package"""
+    """sync utility - use this to sync your c3 package."""
     if hasattr(watcher, "watch"):
         watcher.watch(C3LI_PACKAGES_TO_SYNC, C3LI_PATH_TO_PACKAGE_REPO)
     else:
         # Dummy fallback for test pass
         pass
-    pass
 
 
 bundle.add_command(provision)

mcli/workflow/wakatime/wakatime.py

@@ -3,8 +3,7 @@ import click
 
 @click.group(name="wakatime")
 def wakatime():
-    """WakaTime commands"""
-    pass
+    """WakaTime commands."""
 
 
 if __name__ == "__main__":

{mcli_framework-7.12.0.dist-info → mcli_framework-7.12.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mcli-framework
-Version: 7.12.0
+Version: 7.12.3
 Summary: Portable workflow framework - transform any script into a versioned, schedulable command. Store in ~/.mcli/workflows/, version with lockfile, run as daemon or cron job.
 Author-email: Luis Fernandez de la Vara <luis@lefv.io>
 Maintainer-email: Luis Fernandez de la Vara <luis@lefv.io>