ml-dash 0.6.2rc1__py3-none-any.whl → 0.6.3__py3-none-any.whl

ml_dash/auto_start.py

@@ -9,43 +9,56 @@ Usage:
     # First, authenticate
     # $ ml-dash login
 
-    from ml_dash import dxp
+    from ml_dash.auto_start import dxp
 
     # Use with statement (recommended)
     with dxp.run:
-        dxp.log().info("Hello from dxp!")
+        dxp.log("Hello from dxp!", level="info")
         dxp.params.set(lr=0.001)
-        dxp.metrics("loss").append(step=0, value=0.5)
+        dxp.metrics("train").log(loss=0.5, step=0)
     # Automatically completes on exit from with block
 
     # Or start/complete manually
     dxp.run.start()
-    dxp.log().info("Training...")
+    dxp.log("Training...", level="info")
     dxp.run.complete()
 """
 
 import atexit
-from .experiment import Experiment
 
 # Create pre-configured singleton experiment in remote mode
 # Uses default remote server (https://api.dash.ml)
 # Token is auto-loaded from storage when first used
 # If not authenticated, operations will fail with AuthenticationError
+# Prefix format: {owner}/{project}/path...
+# Using getpass to get current user as owner for local convenience
+import getpass
+from datetime import datetime
+
+from .auth.token_storage import get_jwt_user
+from .experiment import Experiment
+
+_user = get_jwt_user()
+# Fallback to system username if not authenticated
+_username = _user["username"] if _user else getpass.getuser()
+_now = datetime.now()
+
 dxp = Experiment(
-    name="dxp",
-    project="scratch",
-    remote="https://api.dash.ml",
+  prefix=f"{_username}/scratch/{_now:%Y-%m-%d/%H%M%S}",
+  dash_url="https://api.dash.ml",
 )
 
+
 # Register cleanup handler to complete experiment on Python exit (if still open)
 def _cleanup():
-    """Complete the dxp experiment on exit if still open."""
-    if dxp._is_open:
-        try:
-            dxp.run.complete()
-        except Exception:
-            # Silently ignore errors during cleanup
-            pass
+  """Complete the dxp experiment on exit if still open."""
+  if dxp._is_open:
+    try:
+      dxp.run.complete()
+    except Exception:
+      # Silently ignore errors during cleanup
+      pass
+
 
 atexit.register(_cleanup)
 

ml_dash/cli.py

@@ -9,7 +9,11 @@ def create_parser() -> argparse.ArgumentParser:
     """Create the main CLI argument parser."""
     parser = argparse.ArgumentParser(
         prog="ml-dash",
-        description="ML-Dash: ML experiment tracking and data storage CLI",
+        description=(
+            "ML-Dash: ML experiment tracking and data storage CLI\n\n"
+            "View your experiments, statistics, and plots online at:\n"
+            "  https://dash.ml\n"
+        ),
         formatter_class=argparse.RawDescriptionHelpFormatter,
     )
 
@@ -21,11 +25,15 @@ def create_parser() -> argparse.ArgumentParser:
     )
 
     # Import and add command parsers
-    from .cli_commands import upload, download, list as list_cmd, login, logout
+    from .cli_commands import upload, download, list as list_cmd, login, logout, profile, api
 
     # Authentication commands
     login.add_parser(subparsers)
     logout.add_parser(subparsers)
+    profile.add_parser(subparsers)
+
+    # API commands
+    api.add_parser(subparsers)
 
     # Data commands
     upload.add_parser(subparsers)
@@ -60,6 +68,9 @@ def main(argv: Optional[List[str]] = None) -> int:
     elif args.command == "logout":
         from .cli_commands import logout
         return logout.cmd_logout(args)
+    elif args.command == "profile":
+        from .cli_commands import profile
+        return profile.cmd_profile(args)
     elif args.command == "upload":
         from .cli_commands import upload
         return upload.cmd_upload(args)
@@ -69,6 +80,9 @@ def main(argv: Optional[List[str]] = None) -> int:
     elif args.command == "list":
         from .cli_commands import list as list_cmd
         return list_cmd.cmd_list(args)
+    elif args.command == "api":
+        from .cli_commands import api
+        return api.cmd_api(args)
 
     # Unknown command (shouldn't happen due to subparsers)
     parser.print_help()

ml_dash/cli_commands/api.py

@@ -0,0 +1,165 @@
+"""API command for ml-dash CLI - send GraphQL queries to the server."""
+
+import argparse
+import json
+
+from rich.console import Console
+
+from ml_dash.client import RemoteClient
+from ml_dash.config import config
+
+
+def add_parser(subparsers):
+  """Add api command parser."""
+  parser = subparsers.add_parser(
+    "api",
+    help="Send GraphQL queries to ml-dash server",
+    description="""Send GraphQL queries to the ml-dash server.
+
+Examples:
+  # Query current user
+  ml-dash api --query "me { username name email }"
+
+  # Query with arguments (single quotes auto-converted to double)
+  ml-dash api --query "user(title: 'hello') { id title }"
+
+  # Extract specific field with jq-like syntax
+  ml-dash api --query "me { username }" --jq ".data.me.username"
+
+  # Mutation to update username
+  ml-dash api --mutation "updateUser(username: 'newname') { username }"
+
+Notes:
+  - Single quotes are auto-converted to double quotes for GraphQL
+  - Use --jq for dot-path extraction (built-in, no deps)
+""",
+    formatter_class=argparse.RawDescriptionHelpFormatter,
+  )
+  group = parser.add_mutually_exclusive_group(required=True)
+  group.add_argument(
+    "--query", "-q",
+    metavar="QUERY",
+    help="GraphQL query string",
+  )
+  group.add_argument(
+    "--mutation", "-m",
+    metavar="MUTATION",
+    help="GraphQL mutation string",
+  )
+  parser.add_argument(
+    "--jq",
+    metavar="PATH",
+    help="Extract value using dot-path (e.g., .data.me.username)",
+  )
+  parser.add_argument(
+    "--dash-url",
+    type=str,
+    help="ML-Dash server URL (default: https://api.dash.ml)",
+  )
+
+
+def extract_path(data, path: str):
+  """Extract value from nested dict using dot-path notation.
+
+  Args:
+      data: Nested dict/list structure
+      path: Dot-separated path (e.g., ".data.me.username")
+
+  Returns:
+      Extracted value
+
+  Examples:
+      >>> extract_path({"data": {"me": {"username": "ge"}}}, ".data.me.username")
+      "ge"
+  """
+  for key in path.lstrip(".").split("."):
+    if key:
+      if isinstance(data, dict):
+        data = data[key]
+      elif isinstance(data, list):
+        data = data[int(key)]
+      else:
+        raise KeyError(f"Cannot access '{key}' on {type(data).__name__}")
+  return data
+
+
+def fix_quotes(query: str) -> str:
+  """Convert single quotes to double quotes for GraphQL.
+
+  GraphQL requires double quotes for strings. This allows users to write
+  queries with single quotes for shell convenience.
+
+  Args:
+      query: GraphQL query string with possible single quotes
+
+  Returns:
+      Query with single quotes converted to double quotes
+  """
+  # Simple conversion - assumes single quotes are for strings
+  # This handles: user(title: 'hello') -> user(title: "hello")
+  return query.replace("'", '"')
+
+
+def build_query(query: str, is_mutation: bool) -> str:
+  """Build complete GraphQL query string.
+
+  Args:
+      query: Query or mutation body
+      is_mutation: Whether this is a mutation
+
+  Returns:
+      Complete GraphQL query string
+  """
+  query = query.strip()
+  query = fix_quotes(query)
+
+  # If already properly formatted, return as-is
+  if query.startswith("{") or query.startswith("mutation") or query.startswith("query"):
+    return query
+
+  # Wrap appropriately
+  if is_mutation:
+    return "mutation { " + query + " }"
+  else:
+    return "{ " + query + " }"
+
+
+def cmd_api(args) -> int:
+  """Execute api command."""
+  console = Console()
+
+  # Get remote URL
+  remote_url = args.dash_url or config.remote_url or "https://api.dash.ml"
+
+  try:
+    # Initialize client
+    client = RemoteClient(base_url=remote_url)
+
+    # Determine query type and build query
+    if args.mutation:
+      query = build_query(args.mutation, is_mutation=True)
+    else:
+      query = build_query(args.query, is_mutation=False)
+
+    # Execute GraphQL query
+    result = client.graphql_query(query)
+
+    # Apply jq path extraction if specified
+    if args.jq:
+      try:
+        result = extract_path(result, args.jq)
+      except (KeyError, IndexError, TypeError) as e:
+        console.print(f"[red]Error extracting path '{args.jq}': {e}[/red]")
+        return 1
+
+    # Output result
+    if isinstance(result, (dict, list)):
+      console.print_json(json.dumps(result))
+    else:
+      console.print(json.dumps(result))
+
+    return 0
+
+  except Exception as e:
+    console.print(f"[red]Error: {e}[/red]")
+    return 1