setting cache does not work

Author: Carreau

tools/last_user_activity.py

@@ -19,22 +19,22 @@
 import argparse
 
 orgs = [
-    "binder-examples",
-    "binderhub-ci-repos",
+    # "binder-examples",
+    # "binderhub-ci-repos",
     "ipython",
-    "jupyter",
-    "jupyter-book",
-    "jupyter-governance",
-    "jupyter-incubator",
-    "jupyter-server",
-    "jupyter-standards",
-    "jupyter-widgets",
-    "jupyterhub",
-    "jupyterlab",
-    "jupyter-xeus",
-    "jupytercon",
-    "voila-dashboards",
-    "voila-gallery",
+    # "jupyter",
+    # "jupyter-book",
+    # "jupyter-governance",
+    # "jupyter-incubator",
+    # "jupyter-server",
+    # "jupyter-standards",
+    # "jupyter-widgets",
+    # "jupyterhub",
+    # "jupyterlab",
+    # "jupyter-xeus",
+    # "jupytercon",
+    # "voila-dashboards",
+    # "voila-gallery",
 ]
 
 token = os.getenv("GH_TOKEN")
@@ -76,95 +76,98 @@ async def get_org_members(session: aiohttp.ClientSession, org: str) -> List[Dict
     Pagination is handled automatically (100 items per page).
     """
     cache_key = f"org_members_{org}"
-    if cache_key in cache:
-        return cache[cache_key]
+    
+    # Try to get from cache
+    cached_data = cache.get(cache_key)
+    if cached_data is not None:
+        print(f"[cyan]Cache hit for {org} members[/cyan]")
+        return cached_data
 
+    print(f"[yellow]Cache miss for {org} members - fetching from API[/yellow]")
     members = []
-    for page in count(1):
-        url = f"https://api.github.com/orgs/{org}/members?page={page}&per_page=100"
-        async with session.get(url, headers=headers) as response:
-            if response.status != 200:
-                print(f"[red]Error fetching members for {org}: {response.status}[/red]")
-                break
-                
-            page_members = await response.json()
-            if not page_members:
-                break
-                
-            members.extend(page_members)
 
-    cache.set(cache_key, members, expire=3600 * 24)
-    return members
+    try:
+        for page in count(1):
+            url = f"https://api.github.com/orgs/{org}/members?page={page}&per_page=100"
+            async with session.get(url, headers=headers) as response:
+                if response.status != 200:
+                    print(f"[red]Error fetching members for {org}: {response.status}[/red]")
+                    break
+                    
+                page_members = await response.json()
+                if not page_members:
+                    break
+                    
+                members.extend(page_members)
+        
+        # Cache the results
+        cache.set(cache_key, members, expire=3600 * 24)  # 24 hours
+        print(f"[green]Cached {len(members)} members for {org}[/green]")
+        return members
+        
+    except Exception as e:
+        print(f"[red]Error fetching members for {org}: {str(e)}[/red]")
+        return []
 
 async def get_user_activity(session: aiohttp.ClientSession, username: str) -> Optional[datetime]:
-    """Fetch the last public activity date for a GitHub user.
-
-    Parameters
-    ----------
-    session : aiohttp.ClientSession
-        The HTTP session to use for requests
-    username : str
-        The GitHub username to check
-
-    Returns
-    -------
-    Optional[datetime]
-        The datetime of the user's last public activity,
-        or None if no activity was found or an error occurred
-
-    Notes
-    -----
-    Results are cached for 24 hours to minimize API requests.
-    Only public events are considered for activity tracking.
-    """
+    """Fetch the last public activity date for a GitHub user."""
     cache_key = f"user_activity_{username}"
-    if cache_key in cache:
-        return cache[cache_key]
-
-    url = f"https://api.github.com/users/{username}/events/public"
-    async with session.get(url, headers=headers) as response:
-        if response.status == 200:
-            events = await response.json()
-            if events:
-                last_activity = datetime.fromisoformat(events[0]["created_at"].replace('Z', '+00:00'))
-                cache.set(cache_key, last_activity, expire=3600 * 24)
-                return last_activity
-    return None
+    
+    # Try to get from cache
+    cached_data = cache.get(cache_key)
+    if cached_data is not None:
+        print(f"[cyan]Cache hit for {username} activity[/cyan]")
+        return cached_data
 
-def clear_cache() -> None:
-    """Clear the disk cache.
+    print(f"[yellow]Cache miss for {username} activity - fetching from API[/yellow]")
 
-    Removes all cached data, forcing fresh API requests on next run.
+    try:
+        print(f"Getting activity for {username}")
+        url = f"https://api.github.com/users/{username}/events/public"
+        async with session.get(url, headers=headers) as response:
+            if response.status == 200:
+                print(f"Got activity for {username}")
+                events = await response.json()
+                if events:
+                    last_activity = datetime.fromisoformat(events[0]["created_at"].replace('Z', '+00:00'))
+                    # Cache the results
+                    cache.set(cache_key, last_activity, expire=3600 * 24)  # 24 hours
+                    print(f"[green]Cached activity for {username}[/green]")
+                    return last_activity
+                else:
+                    print(f"[yellow]No activity found for {username}[/yellow]")
+                    cache.set(cache_key, None, expire=3600 * 24)
+            else:
+                print(f"[red]Error fetching activity for {username}: {response.status}[/red]")
+    except Exception as e:
+        print(f"[red]Error fetching activity for {username}: {str(e)}[/red]")
 
-    Notes
-    -----
-    This is useful when you want to ensure you're getting the latest data
-    or if the cache becomes corrupted.
-    """
-    if pathlib.Path(CACHE_DIR).exists():
+    return None
+
+def get_cache_size() -> str:
+    """Get the current cache size in a human-readable format."""
+    try:
+        cache_path = pathlib.Path(CACHE_DIR)
+        if cache_path.exists():
+            total_size = sum(f.stat().st_size for f in cache_path.rglob('*') if f.is_file())
+            return f"{total_size / 1024 / 1024:.1f} MB"
+    except Exception:
+        pass
+    return "unknown size"
+
+def clear_cache() -> None:
+    """Clear the disk cache."""
+    try:
         cache.clear()
         print("[green]Cache cleared successfully[/green]")
-    else:
-        print("[yellow]No cache directory found[/yellow]")
+    except Exception as e:
+        print(f"[red]Error clearing cache: {str(e)}[/red]")
 
 async def main():
-    """Main execution function.
-    
-    Fetches and displays the last activity for all members across specified organizations.
-    Uses disk caching to minimize API requests and handles GitHub API rate limits.
-
-    Notes
-    -----
-    The results are displayed organization by organization, with members sorted
-    by their last activity date (most recent first).
-    """
-    # Add cache info at start
-    cache_path = pathlib.Path(CACHE_DIR)
-    if cache_path.exists():
-        cache_size = sum(f.stat().st_size for f in cache_path.rglob('*') if f.is_file())
-        print(f"[blue]Using cache directory: {CACHE_DIR} ({cache_size / 1024 / 1024:.1f} MB)[/blue]")
-    else:
-        print("[yellow]Creating new cache directory[/yellow]")
+    """Main execution function."""
+    # Show cache status
+    print(f"[blue]Cache directory: {CACHE_DIR} (size: {get_cache_size()})[/blue]")
+    print(f"[blue]Cache contains {len(cache)} items[/blue]")
 
     async with aiohttp.ClientSession() as session:
         # Check rate limit
@@ -213,6 +216,7 @@ async def main():
 if __name__ == "__main__":
     parser = argparse.ArgumentParser(description="GitHub Organization Activity Tracker")
     parser.add_argument('--clear-cache', action='store_true', help='Clear the cache before running')
+    parser.add_argument('--debug', action='store_true', help='Show debug information')
     args = parser.parse_args()
 
     if args.clear_cache: