accli 2.0.5__tar.gz → 2.0.7__tar.gz

{accli-2.0.5 → accli-2.0.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: accli
-Version: 2.0.5
+Version: 2.0.7
 Summary: IIASA Accelerator Client
 Author-email: Wrufesh S <wrufesh@gmail.com>
 License: The MIT License (MIT)

{accli-2.0.5 → accli-2.0.7}/accli/AcceleratorTaskDispatcher.py

@@ -3,11 +3,12 @@ import zipfile
 import hashlib
 import shutil
 import tempfile
+import fnmatch
 from typing import Optional, Dict, List
 
 import requests
 from functools import lru_cache
-from pydantic import BaseModel, model_validator
+from pydantic import BaseModel, model_validator, Field
 from accli.AcceleratorTerminalCliProjectService import AcceleratorTerminalCliProjectService
 from accli.token import (
     get_token, get_server_url,
@@ -48,23 +49,38 @@ def get_file_sha1(file_path):
     return sha1_hash.hexdigest()
 
 
-def copy_tree(src, dst):
+def copy_tree(src, dst, include=None, exclude=None, root_src=None):
     """Recursively copy from src to dst, excluding .git folders."""
+    if root_src is None:
+        root_src = src
     for item in os.listdir(src):
         src_path = os.path.join(src, item)
         dst_path = os.path.join(dst, item)
+        rel_path = os.path.relpath(src_path, root_src)
 
         if os.path.isdir(src_path):
             if item == '.git':
                 continue
+            if exclude:
+                excludes = [e.strip() for e in exclude.split(',') if e.strip()]
+                if any(fnmatch.fnmatch(rel_path, p) or fnmatch.fnmatch(item, p) for p in excludes):
+                    continue
             os.makedirs(dst_path, exist_ok=True)
-            copy_tree(src_path, dst_path)
+            copy_tree(src_path, dst_path, include, exclude, root_src)
         else:
+            if exclude:
+                excludes = [e.strip() for e in exclude.split(',') if e.strip()]
+                if any(fnmatch.fnmatch(rel_path, p) or fnmatch.fnmatch(item, p) for p in excludes):
+                    continue
+            if include:
+                includes = [i.strip() for i in include.split(',') if i.strip()]
+                if not any(fnmatch.fnmatch(rel_path, p) or fnmatch.fnmatch(item, p) for p in includes):
+                    continue
             shutil.copy2(src_path, dst_path)
 
 
 @lru_cache(maxsize=None)
-def push_folder_job(directory):
+def push_folder_job(directory, include=None, exclude=None):
     server_url = get_server_url()
     project_slug = get_project_slug()
     _, access_token, _ = exchange_refresh_token(project_slug)
@@ -76,7 +92,7 @@ def push_folder_job(directory):
     )
 
     repo_dir = tempfile.mkdtemp()
-    copy_tree(directory, repo_dir)
+    copy_tree(directory, repo_dir, include, exclude)
 
     if os.path.isfile(f'{repo_dir}/wkube.py'):
         os.remove(f'{repo_dir}/wkube.py')
@@ -152,7 +168,9 @@ class WKubeTaskMeta(BaseModel):
 class WKubeTaskKwargs(BaseModel):
     docker_image: Optional[str] = None
 
-    job_folder: str = './'
+    job_folder: str = Field('./', description="Path to the directory containing job files. Must be a valid existing directory.")
+    include: Optional[str] = Field(None, description="Comma-separated wildcard patterns to include (e.g. '*.py, data/*')")
+    exclude: Optional[str] = Field(None, description="Comma-separated wildcard patterns to exclude (e.g. '*.txt, .venv/*')")
 
     repo_url: Optional[str] = None  # required when docker image is not present
     repo_branch: Optional[str] = None  # required when docker image is not present
@@ -172,6 +190,10 @@ class WKubeTaskKwargs(BaseModel):
         result = super().model_dump(*args, **kwargs)
         if 'job_folder' in result:
             del result['job_folder']
+        if 'include' in result:
+            del result['include']
+        if 'exclude' in result:
+            del result['exclude']
         return result
 
     @model_validator(mode="before")
@@ -179,10 +201,19 @@ class WKubeTaskKwargs(BaseModel):
     def validate_root(cls, values):
         if not values.get('docker_image'):
             job_folder = values.get('job_folder', './')
+            include = values.get('include')
+            exclude = values.get('exclude')
+
+            if not os.path.isdir(job_folder):
+                raise ValueError(
+                    f"Invalid job_folder: '{job_folder}' does not exist or is not a directory. "
+                    f"Help: job_folder must be a valid path. You can also use 'include' and 'exclude' "
+                    f"with comma-separated wildcards (e.g., include='*.py, data/*', exclude='*.txt, .venv/*')."
+                )
 
             if not (values.get('repo_url') and values.get('repo_branch')):
                 remote_url, branch_name = push_folder_job(
-                    os.path.abspath(job_folder)
+                    os.path.abspath(job_folder), include, exclude
                 )
                 values['repo_url'] = remote_url
                 values['repo_branch'] = branch_name

{accli-2.0.5 → accli-2.0.7}/accli/_version.py

@@ -1,3 +1,3 @@
 # Please strictly put double quote to use this info for git tag 
 # Read a developer guide for git tag command with regex
-VERSION = "v2.0.5"
+VERSION = "v2.0.7"

{accli-2.0.5 → accli-2.0.7}/accli/cli.py

@@ -2,6 +2,7 @@ import glob
 import importlib.util
 import os
 import re
+import time
 import warnings
 import hashlib
 import json
@@ -588,7 +589,7 @@ mount_app = typer.Typer(
 app.add_typer(mount_app, name="mount")
 
 
-def find_available_windows_drive(preferred: str = "W") -> str:
+def find_available_windows_drive(preferred: str) -> str:
     """Finds an available Windows drive letter, starting with preferred, then checking others."""
     import os
     preferred = preferred.upper()
@@ -604,14 +605,56 @@ def find_available_windows_drive(preferred: str = "W") -> str:
     raise RuntimeError("No available Windows drive letters found.")
 
 
-def start_windows_explorer_refresher(mount_point: str, interval: int):
+def validate_project_slug(server_url: str, project_slug: str) -> None:
+    """
+    Validates that project_slug exists on the backend before launching the mount daemon.
+    Exchanges the stored refresh token for a cas_token, then calls
+    GET /api/v1/aterm-cli/{slug}/ (authenticated via XetCASAuthorizationService).
+    - 200 → project exists and user is authorized; proceed with mount
+    - 403 / 404 → project not found or no access → exit with clear message
+    """
+    import requests as _requests
+    from accli.token import exchange_refresh_token
+
+    try:
+        cas_token, _access_token, _expires = exchange_refresh_token(project_slug)
+    except SystemExit:
+        raise
+    except Exception as e:
+        print(f"[bold red]ERROR: Could not obtain access token for project '{project_slug}': {e}[/bold red]")
+        raise typer.Exit(1)
+
+    verify_ssl = not bool(os.environ.get("ACCLI_DEBUG"))
+    url = f"{server_url.rstrip('/')}/api/v1/aterm-cli/{project_slug}/"
+    try:
+        resp = _requests.get(
+            url,
+            headers={"Authorization": f"Bearer {cas_token}"},
+            verify=verify_ssl,
+            timeout=10,
+        )
+    except _requests.exceptions.RequestException as e:
+        print(f"[bold red]ERROR: Could not reach backend to validate project slug: {e}[/bold red]")
+        raise typer.Exit(1)
+
+    if resp.status_code in (403, 404):
+        print(f"[bold red]ERROR: Project '{project_slug}' not found or you do not have access.[/bold red]")
+        projects_url = f"{server_url.rstrip('/')}/projects/"
+        print(f"[yellow]Hint: Check the project slug in the web GUI: [link={projects_url}]{projects_url}[/link][/yellow]")
+        raise typer.Exit(1)
+    elif not resp.ok:
+        print(f"[bold red]ERROR: Unexpected server response ({resp.status_code}) when validating project slug.[/bold red]")
+        raise typer.Exit(1)
+
+
+def start_nfs_watcher(mount_point: str, interval: int):
     """Starts a lightweight background watcher in the user session that notifies Explorer when remote changes occur."""
     import sys
     import subprocess
     from pathlib import Path
     
-    refresher_script = Path(__file__).parent / "windows_refresher.py"
-    if not refresher_script.is_file():
+    watcher_script = Path(__file__).parent / "nfs_watcher.py"
+    if not watcher_script.is_file():
         return
     
     # Locate Python interpreter (prefer pythonw to run completely windowless if available)
@@ -627,13 +670,13 @@ def start_windows_explorer_refresher(mount_point: str, interval: int):
         # DETACHED_PROCESS (0x00000008) | CREATE_NEW_PROCESS_GROUP (0x00000200) | CREATE_NO_WINDOW (0x08000000)
         creationflags = 0x08000008 | 0x00000200
         proc = subprocess.Popen(
-            [executable, str(refresher_script), str(mount_point), str(interval)],
+            [executable, str(watcher_script), str(mount_point), str(interval)],
             creationflags=creationflags,
             stdout=subprocess.DEVNULL,
             stderr=subprocess.DEVNULL,
             close_fds=True
         )
-        pid_file = Path("C:/ProgramData/accli/refresher.pid")
+        pid_file = Path.home() / ".accli" / "nfs_watcher.pid"
         try:
             pid_file.parent.mkdir(parents=True, exist_ok=True)
             pid_file.write_text(str(proc.pid), encoding="utf-8")
@@ -643,16 +686,33 @@ def start_windows_explorer_refresher(mount_point: str, interval: int):
         pass
 
 
-def stop_windows_explorer_refresher():
-    """Stops any active background Explorer watcher process."""
+def stop_nfs_watcher(mount_point: str):
+    """Signals and stops any active background NFS watcher process."""
+    import os
     import subprocess
     from pathlib import Path
+    import ctypes
+    kernel32 = ctypes.windll.kernel32
     
-    pid_file = Path("C:/ProgramData/accli/refresher.pid")
+    # 1. Graceful cooperative shutdown via Windows Named Event
+    try:
+        EVENT_MODIFY_STATE = 0x0002
+        drive = Path(mount_point).drive.upper().rstrip(":")
+        evt_name = f"Local\\accli_watcher_{drive}_stop" if drive else "Local\\accli_watcher_stop"
+        h_evt = kernel32.OpenEventW(EVENT_MODIFY_STATE, False, evt_name)
+        if h_evt:
+            kernel32.SetEvent(h_evt)
+            kernel32.CloseHandle(h_evt)
+            time.sleep(0.1)
+    except Exception:
+        pass
+
+    # 2. Clean up user-scoped PID file
+    pid_file = Path.home() / ".accli" / "nfs_watcher.pid"
     if pid_file.is_file():
         try:
             pid_str = pid_file.read_text(encoding="utf-8").strip()
-            if pid_str:
+            if pid_str and pid_str != str(os.getpid()):
                 subprocess.run(["taskkill", "/F", "/PID", pid_str], capture_output=True)
         except Exception:
             pass
@@ -660,18 +720,6 @@ def stop_windows_explorer_refresher():
             pid_file.unlink()
         except Exception:
             pass
-            
-    # Also clean up any lingering windows_refresher.py processes
-    try:
-        cleanup_cmd = [
-            "powershell.exe", "-NoProfile", "-NonInteractive", "-ExecutionPolicy", "Bypass", "-Command",
-            "Get-CimInstance Win32_Process -Filter \"name='python.exe' or name='pythonw.exe'\" | "
-            "Where-Object { $_.CommandLine -like '*windows_refresher.py*' } | "
-            "ForEach-Object { Stop-Process -Id $_.ProcessId -Force -ErrorAction SilentlyContinue }"
-        ]
-        subprocess.run(cleanup_cmd, capture_output=True)
-    except Exception:
-        pass
 
 
 def enable_windows_nfs_features():
@@ -873,6 +921,10 @@ def mount_start(
         print("[bold red]ERROR: Mode must be either 'bucket' or 'repo'.[/bold red]")
         raise typer.Exit(1)
 
+    # Validate project slug against backend before doing any heavy work
+    print(f"[cyan]Validating project '{project_slug}'...[/cyan]")
+    validate_project_slug(server_url, project_slug)
+
     # Ensure binaries are downloaded and cached
     try:
         mount_downloader.ensure_binaries(version=binary_version, use_fuse=fuse)
@@ -1053,20 +1105,24 @@ def mount_start(
                 
                 run_res = subprocess.run(["schtasks", "/run", "/tn", "accli-mount-nfs"], capture_output=True, text=True)
                 if run_res.returncode == 0:
-                    import time
                     print("[cyan]Waiting for elevated NFS daemon to initialize...[/cyan]")
                     time.sleep(2.0)
                     
                     # Map the network drive in the CURRENT user session (so it is visible in Explorer)
                     mount_cmd = [
                         "C:\\Windows\\System32\\mount.exe",
-                        "-o", "nolock,anon,mtype=hard,rsize=32,wsize=32,timeout=60",
+                        "-o", "mtype=hard",
+                        "-o", "timeout=10",
+                        "-o", "rsize=32",
+                        "-o", "wsize=32",
+                        "-o", "anon",
+                        "-o", "nolock",
                         "\\\\127.0.0.1\\!",
                         str(mount_point_abs)
                     ]
                     mount_res = subprocess.run(mount_cmd, capture_output=True, text=True)
                     if mount_res.returncode == 0:
-                        start_windows_explorer_refresher(str(mount_point_abs), interval=30)
+                        start_nfs_watcher(str(mount_point_abs), interval=30)
                         print(f"[bold green][OK] NFS mount successfully mapped at [white]{mount_point_abs}[/white]![/bold green]")
                         print("[cyan]Use 'umount' or 'accli mount stop' to unmount the drive.[/cyan]")
                         return
@@ -1078,8 +1134,8 @@ def mount_start(
                         raise typer.Exit(1)
                 else:
                     print("[bold red][ERROR] Failed to execute Scheduled Task 'accli-mount-nfs'.[/bold red]")
-                    if run_res.stderr:
-                        print(f"[red]{run_res.stderr.strip()}[/red]")
+                    if trigger_res.stderr:
+                        print(f"[red]{trigger_res.stderr.strip()}[/red]")
                     print("[yellow]Falling back to UAC elevation...[/yellow]")
                     has_task = False
             except Exception as e:
@@ -1089,30 +1145,26 @@ def mount_start(
                 print("[yellow]Falling back to UAC elevation...[/yellow]")
                 has_task = False
 
+        # Fallback or standard spawn path
         try:
             if is_admin:
-                # Already running as Administrator - spawn decoupled background process directly
-                creationflags = 0x00000008
                 process = subprocess.Popen(
                     args,
                     env=env,
-                    creationflags=creationflags,
-                    stdout=log_file,
-                    stderr=subprocess.STDOUT,
-                    close_fds=True
+                    stdout=subprocess.DEVNULL,
+                    stderr=subprocess.DEVNULL,
+                    creationflags=subprocess.CREATE_NO_WINDOW
                 )
-                
-                # Startup verification (1-second boot poll)
-                import time
+                print(f"[cyan]Waiting for NFS daemon to initialize...[/cyan]")
                 time.sleep(1.0)
+                
+                # Check if process crashed on boot
                 if process.poll() is not None:
-                    # Process has already terminated!
-                    print(f"[bold red][ERROR] Failed to start Windows NFS mount process (exit code {process.returncode}).[/bold red]")
+                    print(f"[bold red][ERROR] NFS daemon failed to start (exit code {process.returncode}).[/bold red]")
                     try:
-                        if log_file_path.is_file():
-                            with open(log_file_path, "r", encoding="utf-8") as lf:
-                                lines = lf.readlines()
-                                last_lines = "".join(lines[-10:])
+                        if Path(log_file_path).exists():
+                            with open(log_file_path, "r", encoding="utf-8", errors="ignore") as lf:
+                                last_lines = "".join(lf.readlines()[-15:])
                                 print("[red]Recent log output:[/red]")
                                 print(f"[dim]{last_lines.strip()}[/dim]")
                     except Exception:
@@ -1120,7 +1172,7 @@ def mount_start(
                     print(f"[yellow]Please check the log file at {log_file_path} for more details.[/yellow]")
                     raise typer.Exit(1)
                     
-                start_windows_explorer_refresher(str(mount_point_abs), interval=30)
+                start_nfs_watcher(str(mount_point_abs), interval=30)
                 print(f"[bold green][OK] NFS mount process spawned successfully (PID: {process.pid}).[/bold green]")
                 print(f"[cyan]Use 'umount' or 'accli mount stop' to unmount the drive.[/cyan]")
             else:
@@ -1156,19 +1208,23 @@ def mount_start(
                     raise typer.Exit(1)
                     
                 print("[cyan]Waiting for elevated NFS daemon to initialize...[/cyan]")
-                import time
                 time.sleep(2.0)
                 
                 # Map the network drive in the CURRENT user session (so it is visible in Explorer)
                 mount_cmd = [
                     "C:\\Windows\\System32\\mount.exe",
-                    "-o", "nolock,anon,mtype=hard,rsize=32,wsize=32,timeout=60",
+                    "-o", "mtype=hard",
+                    "-o", "timeout=10",
+                    "-o", "rsize=32",
+                    "-o", "wsize=32",
+                    "-o", "anon",
+                    "-o", "nolock",
                     "\\\\127.0.0.1\\!",
                     str(mount_point_abs)
                 ]
                 mount_res = subprocess.run(mount_cmd, capture_output=True, text=True)
                 if mount_res.returncode == 0:
-                    start_windows_explorer_refresher(str(mount_point_abs), interval=30)
+                    start_nfs_watcher(str(mount_point_abs), interval=30)
                     print(f"[bold green][OK] NFS mount successfully mapped at [white]{mount_point_abs}[/white]![/bold green]")
                     print("[cyan]Use 'umount' or 'accli mount stop' to unmount the drive.[/cyan]")
                 else:
@@ -1306,8 +1362,8 @@ def mount_stop(
         except Exception:
             is_admin = False
 
-        # 0. Stop Explorer background refresher
-        stop_windows_explorer_refresher()
+        # 0. Stop background NFS watcher
+        stop_nfs_watcher(str(mount_point_abs))
 
         # 1. Unmap the network drive in the user session
         res = subprocess.run(["C:\\Windows\\System32\\umount.exe", "-f", str(mount_point_abs)], capture_output=True, text=True)
@@ -1329,7 +1385,6 @@ def mount_stop(
             print("[cyan]Triggering elevated NFS daemon termination via Task Scheduler...[/cyan]")
             subprocess.run(["schtasks", "/run", "/tn", "accli-umount-nfs"], capture_output=True)
             # Poll for up to 5 seconds to ensure hf-mount-nfs.exe has fully terminated
-            import time
             for _ in range(10):
                 time.sleep(0.5)
                 task_check = subprocess.run(["tasklist", "/FI", "IMAGENAME eq hf-mount-nfs.exe"], capture_output=True, text=True)

accli-2.0.7/accli/nfs_watcher.py

@@ -0,0 +1,224 @@
+import os
+import sys
+import time
+import ctypes
+import subprocess
+from pathlib import Path
+from datetime import datetime
+
+# Windows Shell Notification constants
+SHCNE_UPDATEDIR = 0x00001000
+SHCNF_PATHW = 0x0005
+
+# Win32 Synchronization constants
+SYNCHRONIZE = 0x00100000
+WAIT_OBJECT_0 = 0x00000000
+WAIT_TIMEOUT = 0x00000102
+ERROR_ALREADY_EXISTS = 183
+EVENT_MODIFY_STATE = 0x0002
+
+kernel32 = ctypes.windll.kernel32
+
+
+def log(msg: str):
+    timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+    line = f"[{timestamp}] [Watcher] {msg}"
+    print(line, flush=True)
+    try:
+        log_file = Path.home() / ".accli" / "nfs_watcher.log"
+        log_file.parent.mkdir(parents=True, exist_ok=True)
+        with open(log_file, "a", encoding="utf-8") as f:
+            f.write(line + "\n")
+    except Exception:
+        pass
+
+
+def get_sync_names(mount_point: str):
+    """Returns unique Named Mutex and Event names based on mount drive."""
+    drive = Path(mount_point).drive.upper().rstrip(":")
+    tag = drive if drive else "DEFAULT"
+    return f"Local\\accli_watcher_{tag}_mutex", f"Local\\accli_watcher_{tag}_stop"
+
+
+def get_open_explorer_paths(script_path: Path, mount_point: str) -> list[str]:
+    """Queries open Windows Explorer windows to get paths currently viewed under mount_point."""
+    if not script_path.is_file():
+        return []
+    try:
+        res = subprocess.run(
+            [
+                "powershell.exe", "-NoProfile", "-NonInteractive", "-ExecutionPolicy", "Bypass",
+                "-File", str(script_path), mount_point, "ListOpenPaths"
+            ],
+            capture_output=True,
+            text=True,
+            creationflags=0x08000000  # CREATE_NO_WINDOW
+        )
+        if res.returncode == 0 and res.stdout:
+            return [p.strip() for p in res.stdout.splitlines() if p.strip()]
+    except Exception as e:
+        log(f"Error querying open explorer paths: {e}")
+    return []
+
+
+def notify_explorer(script_path: Path, mount_point: str, path_str: str):
+    """Notifies Windows Shell and refreshes Explorer windows for path_str."""
+    log(f"Broadcasting SHChangeNotify on '{path_str}'...")
+    try:
+        ctypes.windll.shell32.SHChangeNotify(
+            SHCNE_UPDATEDIR,
+            SHCNF_PATHW,
+            path_str,
+            None
+        )
+    except Exception as e:
+        log(f"SHChangeNotify error: {e}")
+
+    if script_path.is_file():
+        try:
+            subprocess.run(
+                [
+                    "powershell.exe", "-NoProfile", "-NonInteractive", "-ExecutionPolicy", "Bypass",
+                    "-File", str(script_path), mount_point, "Refresh", path_str
+                ],
+                capture_output=True,
+                text=True,
+                creationflags=0x08000000  # CREATE_NO_WINDOW
+            )
+        except Exception as e:
+            log(f"COM refresh error: {e}")
+
+
+def scan_directory_state(dir_path: Path):
+    """
+    Fast snapshot of a single directory using os.scandir().
+    Avoids recursive network traversal. Returns dict of entry_name -> (is_dir, size, mtime_ns).
+    """
+    state = {}
+    try:
+        if not dir_path.exists():
+            return None
+        with os.scandir(dir_path) as it:
+            for entry in it:
+                try:
+                    st = entry.stat(follow_symlinks=False)
+                    is_dir = entry.is_dir(follow_symlinks=False)
+                    state[entry.name] = (is_dir, st.st_size if not is_dir else -1, st.st_mtime_ns)
+                except (OSError, PermissionError):
+                    continue
+        return state
+    except Exception:
+        return None
+
+
+def describe_changes(old_state, new_state):
+    old_keys = set(old_state.keys())
+    new_keys = set(new_state.keys())
+    added = new_keys - old_keys
+    removed = old_keys - new_keys
+    modified = {k for k in (old_keys & new_keys) if old_state[k] != new_state[k]}
+    
+    parts = []
+    if added:
+        parts.append(f"Added: {list(added)[:5]}")
+    if removed:
+        parts.append(f"Removed: {list(removed)[:5]}")
+    if modified:
+        parts.append(f"Modified: {list(modified)[:5]}")
+    return "; ".join(parts)
+
+
+def run_watcher(mount_point: str, interval: float):
+    """
+    Optimized NFS watcher:
+    - Waits on a Named Event for instant, 0-CPU sleeping and clean shutdown.
+    - Inspects only directories currently viewed in Windows Explorer (View-Scoped).
+    - Uses shallow os.scandir() to avoid recursive network tree walking.
+    """
+    drive_root = mount_point.rstrip("\\/") + "\\"
+    script_path = Path(__file__).parent / "refresh_explorer.ps1"
+    interval_ms = max(500, int(interval * 1000))
+
+    mutex_name, stop_event_name = get_sync_names(mount_point)
+
+    # 1. Single-instance protection via Named Mutex
+    mutex = kernel32.CreateMutexW(None, True, mutex_name)
+    if kernel32.GetLastError() == ERROR_ALREADY_EXISTS:
+        log(f"Another watcher is already active for {drive_root} ({mutex_name}). Exiting.")
+        sys.exit(0)
+
+    # 2. Named Event for clean cooperative shutdown
+    stop_event = kernel32.CreateEventW(None, True, False, stop_event_name)
+
+    # 3. Write user-scoped fallback PID file
+    pid_file = Path.home() / ".accli" / "nfs_watcher.pid"
+    try:
+        pid_file.parent.mkdir(parents=True, exist_ok=True)
+        pid_file.write_text(str(os.getpid()), encoding="utf-8")
+    except Exception:
+        pass
+
+    log(f"Starting view-scoped NFS watcher on '{drive_root}' (poll interval: {interval}s)...")
+
+    cached_states = {}
+
+    try:
+        while True:
+            # Sleep via WaitForSingleObject: 0% CPU, immediate wakeup on stop signal
+            wait_res = kernel32.WaitForSingleObject(stop_event, interval_ms)
+            if wait_res == WAIT_OBJECT_0:
+                log("Stop event signaled. Gracefully exiting watcher.")
+                break
+
+            # If drive is unmounted or inaccessible, idle until available
+            if not Path(drive_root).exists():
+                continue
+
+            # Query which folders under mount_point are currently open in Explorer
+            open_dirs = get_open_explorer_paths(script_path, mount_point)
+
+            # If no Explorer window is viewing the mount, zero network I/O needed
+            if not open_dirs:
+                if cached_states:
+                    cached_states.clear()
+                continue
+
+            # Check each active directory
+            for dir_str in open_dirs:
+                dpath = Path(dir_str)
+                current_state = scan_directory_state(dpath)
+                if current_state is None:
+                    continue
+
+                last_state = cached_states.get(dir_str)
+                if last_state is not None:
+                    if current_state != last_state:
+                        diff_summary = describe_changes(last_state, current_state)
+                        log(f"Change detected in '{dir_str}' -> {diff_summary}")
+                        notify_explorer(script_path, mount_point, dir_str)
+                        cached_states[dir_str] = current_state
+                else:
+                    cached_states[dir_str] = current_state
+
+    finally:
+        # Cleanup
+        try:
+            if pid_file.is_file():
+                pid_file.unlink()
+        except Exception:
+            pass
+        if stop_event:
+            kernel32.CloseHandle(stop_event)
+        if mutex:
+            kernel32.CloseHandle(mutex)
+        log("Watcher terminated.")
+
+
+if __name__ == "__main__":
+    if len(sys.argv) < 3:
+        print("Usage: python nfs_watcher.py <mount_point> <interval_seconds>")
+        sys.exit(1)
+    mp = sys.argv[1]
+    poll_int = float(sys.argv[2])
+    run_watcher(mp, poll_int)
+

accli-2.0.7/accli/refresh_explorer.ps1

@@ -0,0 +1,60 @@
+param(
+    [Parameter(Position=0)]
+    [string]$MountPoint,
+    [Parameter(Position=1)]
+    [ValidateSet("ListOpenPaths", "Refresh")]
+    [string]$Action,
+    [Parameter(Position=2)]
+    [string]$TargetFolder
+)
+
+$ErrorActionPreference = "SilentlyContinue"
+$mountClean = $MountPoint.TrimEnd("\/")
+
+$shell = New-Object -ComObject Shell.Application
+
+if ($Action -eq "ListOpenPaths") {
+    $foundPaths = [System.Collections.Generic.HashSet[string]]::new([System.StringComparer]::OrdinalIgnoreCase)
+    foreach ($win in $shell.Windows()) {
+        try {
+            $p = $win.Document.Folder.Self.Path
+            if (-not $p) {
+                $u = [System.Uri]$win.LocationURL
+                if ($u.IsFile) { $p = $u.LocalPath }
+            }
+            if ($p) {
+                $pClean = $p.TrimEnd("\/")
+                if ($pClean -eq $mountClean -or $pClean.StartsWith($mountClean + "\", [System.StringComparison]::OrdinalIgnoreCase)) {
+                    [void]$foundPaths.Add($pClean)
+                }
+            }
+        } catch {}
+    }
+    foreach ($path in $foundPaths) {
+        Write-Output $path
+    }
+}
+else {
+    $targetClean = if ($TargetFolder) { $TargetFolder.TrimEnd("\/") } else { "" }
+    foreach ($win in $shell.Windows()) {
+        try {
+            $winPath = $win.Document.Folder.Self.Path
+            if (-not $winPath) {
+                $u = [System.Uri]$win.LocationURL
+                if ($u.IsFile) { $winPath = $u.LocalPath }
+            }
+            if ($winPath) {
+                $winClean = $winPath.TrimEnd("\/")
+                if ($targetClean) {
+                    if ($winClean -eq $targetClean -or $winClean.StartsWith($targetClean + "\", [System.StringComparison]::OrdinalIgnoreCase)) {
+                        $win.Refresh()
+                    }
+                } else {
+                    if ($winClean -eq $mountClean -or $winClean.StartsWith($mountClean + "\", [System.StringComparison]::OrdinalIgnoreCase)) {
+                        $win.Refresh()
+                    }
+                }
+            }
+        } catch {}
+    }
+}

{accli-2.0.5 → accli-2.0.7}/accli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: accli
-Version: 2.0.5
+Version: 2.0.7
 Summary: IIASA Accelerator Client
 Author-email: Wrufesh S <wrufesh@gmail.com>
 License: The MIT License (MIT)

{accli-2.0.5 → accli-2.0.7}/accli.egg-info/SOURCES.txt

@@ -13,10 +13,10 @@ accli/cli.py
 accli/common.py
 accli/gui.py
 accli/mount_downloader.py
+accli/nfs_watcher.py
 accli/refresh_explorer.ps1
 accli/setup-nfs.ps1
 accli/token.py
-accli/windows_refresher.py
 accli.egg-info/PKG-INFO
 accli.egg-info/SOURCES.txt
 accli.egg-info/dependency_links.txt

accli-2.0.5/accli/refresh_explorer.ps1

@@ -1,12 +0,0 @@
-$ErrorActionPreference = "SilentlyContinue"
-$mountPoint = $args[0]
-if (-not $mountPoint) { $mountPoint = "W:" }
-$mountClean = $mountPoint.TrimEnd("\/")
-
-$shell = New-Object -ComObject Shell.Application
-foreach ($win in $shell.Windows()) {
-    $url = $win.LocationURL
-    if ($url -and ($url -like "*$mountClean*" -or $win.Path -like "*$mountClean*")) {
-        $win.Refresh()
-    }
-}

accli-2.0.5/accli/windows_refresher.py

@@ -1,159 +0,0 @@
-import os
-import sys
-import time
-import ctypes
-import subprocess
-from pathlib import Path
-from datetime import datetime
-
-# Windows Shell Notification constants
-SHCNE_UPDATEDIR = 0x00001000
-SHCNF_PATHW = 0x0005
-
-
-def log(msg: str):
-    timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
-    print(f"[{timestamp}] [Watcher] {msg}", flush=True)
-
-
-def notify_explorer(path_str: str):
-    """Notifies Windows Shell / Explorer to refresh views for path_str."""
-    log(f"Broadcasting SHChangeNotify on '{path_str}'...")
-    try:
-        ctypes.windll.shell32.SHChangeNotify(
-            SHCNE_UPDATEDIR,
-            SHCNF_PATHW,
-            path_str,
-            None
-        )
-    except Exception as e:
-        log(f"SHChangeNotify error: {e}")
-
-    try:
-        script_path = Path(__file__).parent / "refresh_explorer.ps1"
-        if script_path.is_file():
-            log(f"Executing COM window refresh for '{path_str}'...")
-            res = subprocess.run(
-                [
-                    "powershell.exe", "-NoProfile", "-NonInteractive", "-ExecutionPolicy", "Bypass",
-                    "-File", str(script_path), path_str
-                ],
-                capture_output=True,
-                text=True,
-                creationflags=0x08000000  # CREATE_NO_WINDOW
-            )
-            if res.stdout and res.stdout.strip():
-                log(f"COM output: {res.stdout.strip()}")
-            if res.stderr and res.stderr.strip():
-                log(f"COM error: {res.stderr.strip()}")
-            log("Explorer windows refreshed.")
-    except Exception as e:
-        log(f"COM refresh error: {e}")
-
-
-def scan_directory_state(root_path: Path):
-    """
-    Fast snapshot of directory state: mapping of relative_path -> (size, mtime_ns).
-    Returns None if root_path is not accessible or unmounted.
-    """
-    state = {}
-    try:
-        if not root_path.exists():
-            return None
-        
-        for root, dirs, files in os.walk(root_path):
-            for name in files:
-                full_path = os.path.join(root, name)
-                try:
-                    st = os.stat(full_path)
-                    rel = os.path.relpath(full_path, root_path)
-                    state[rel] = (st.st_size, st.st_mtime_ns)
-                except (OSError, PermissionError):
-                    continue
-            for name in dirs:
-                full_path = os.path.join(root, name)
-                try:
-                    st = os.stat(full_path)
-                    rel = os.path.relpath(full_path, root_path)
-                    state[rel] = (-1, st.st_mtime_ns)
-                except (OSError, PermissionError):
-                    continue
-        return state
-    except Exception:
-        return None
-
-
-def describe_changes(old_state, new_state):
-    old_keys = set(old_state.keys())
-    new_keys = set(new_state.keys())
-    added = new_keys - old_keys
-    removed = old_keys - new_keys
-    modified = {k for k in (old_keys & new_keys) if old_state[k] != new_state[k]}
-    
-    parts = []
-    if added:
-        parts.append(f"Added: {list(added)[:5]}")
-    if removed:
-        parts.append(f"Removed: {list(removed)[:5]}")
-    if modified:
-        parts.append(f"Modified: {list(modified)[:5]}")
-    return "; ".join(parts)
-
-
-def run_watcher(mount_point: str, interval: float):
-    """
-    Periodically inspects mount_point for remote additions/deletions/modifications.
-    Triggers Windows Shell & open Explorer window refreshes whenever changes are detected.
-    """
-    drive_root = mount_point.rstrip("\\/") + "\\"
-    root_path = Path(drive_root)
-    
-    log(f"Starting watcher on '{drive_root}' (poll interval: {interval}s)...")
-    
-    # Baseline snapshot
-    try:
-        last_state = scan_directory_state(root_path)
-    except Exception as e:
-        last_state = None
-        log(f"Initial scan error: {e}")
-
-    if last_state is not None:
-        log(f"Initial baseline snapshot indexed {len(last_state)} items on '{drive_root}'.")
-    else:
-        log(f"Warning: Could not read '{drive_root}'. Waiting for drive to become available...")
-    
-    while True:
-        try:
-            time.sleep(interval)
-        except (KeyboardInterrupt, SystemExit):
-            log("Watcher stopped.")
-            break
-        except Exception as e:
-            log(f"Sleep interrupted: {e}")
-            continue
-            
-        try:
-            current_state = scan_directory_state(root_path)
-            if current_state is None:
-                continue
-                
-            if last_state is not None:
-                if current_state != last_state:
-                    diff_summary = describe_changes(last_state, current_state)
-                    log(f"Change detected on '{drive_root}' -> {diff_summary}")
-                    notify_explorer(drive_root)
-                    last_state = current_state
-            else:
-                last_state = current_state
-                log(f"Baseline established: {len(last_state)} items found.")
-        except Exception as e:
-            log(f"Loop error: {e}")
-
-
-if __name__ == "__main__":
-    if len(sys.argv) < 3:
-        print("Usage: python windows_refresher.py <mount_point> <interval_seconds>")
-        sys.exit(1)
-    mp = sys.argv[1]
-    poll_int = float(sys.argv[2])
-    run_watcher(mp, poll_int)