Buckets:

download
raw
10.1 kB
"""
NeuroGraph CLI - Command-line interface for NeuroGraph API.
Usage:
neurograph-cli health
neurograph-cli token create "hello world"
neurograph-cli token get 123
neurograph-cli token list --limit 10
neurograph-cli token query --text "hello" --top-k 5
neurograph-cli apikey create --name "My Key" --expires 30
neurograph-cli apikey list
"""
import sys
import json
from typing import Optional
import argparse
from .client import NeuroGraphClient
from .exceptions import NeuroGraphError
from .logging import setup_logging, get_logger
import logging
def create_client(args) -> NeuroGraphClient:
"""Create client from CLI arguments."""
return NeuroGraphClient(
base_url=args.base_url,
username=args.username,
password=args.password,
api_key=args.api_key,
)
def cmd_health(args):
"""Health check command."""
client = create_client(args)
try:
health = client.health.check()
print(json.dumps({
"status": health.status,
"version": health.version,
}, indent=2))
finally:
client.close()
def cmd_status(args):
"""System status command."""
client = create_client(args)
try:
status = client.health.status()
print(json.dumps({
"api_version": status.api_version,
"runtime_version": status.runtime_version,
"tokens_count": status.tokens_count,
"uptime_seconds": status.uptime_seconds,
"memory_usage_mb": status.memory_usage_mb,
}, indent=2))
finally:
client.close()
def cmd_token_create(args):
"""Create token command."""
client = create_client(args)
try:
token = client.tokens.create(text=args.text, metadata=args.metadata)
print(json.dumps({
"id": token.id,
"text": token.text,
"embedding": token.embedding if args.show_embedding else f"[{len(token.embedding)} dimensions]",
"metadata": token.metadata,
}, indent=2))
finally:
client.close()
def cmd_token_get(args):
"""Get token command."""
client = create_client(args)
try:
token = client.tokens.get(token_id=args.token_id)
print(json.dumps({
"id": token.id,
"text": token.text,
"embedding": token.embedding if args.show_embedding else f"[{len(token.embedding)} dimensions]",
"metadata": token.metadata,
}, indent=2))
finally:
client.close()
def cmd_token_list(args):
"""List tokens command."""
client = create_client(args)
try:
tokens = client.tokens.list(limit=args.limit, offset=args.offset)
for token in tokens:
print(json.dumps({
"id": token.id,
"text": token.text,
"metadata": token.metadata,
}))
finally:
client.close()
def cmd_token_delete(args):
"""Delete token command."""
client = create_client(args)
try:
client.tokens.delete(token_id=args.token_id)
print(f"Token {args.token_id} deleted")
finally:
client.close()
def cmd_token_query(args):
"""Query tokens command."""
client = create_client(args)
try:
# Get query vector from text
if args.text:
query_token = client.tokens.create(text=args.text)
query_vector = query_token.embedding
# Clean up temporary token
client.tokens.delete(query_token.id)
else:
print("Error: --text is required for query", file=sys.stderr)
sys.exit(1)
# Query
results = client.tokens.query(
query_vector=query_vector,
top_k=args.top_k,
)
for result in results:
print(json.dumps({
"token_id": result.token.id,
"text": result.token.text,
"similarity": result.similarity,
}))
finally:
client.close()
def cmd_apikey_create(args):
"""Create API key command."""
client = create_client(args)
try:
api_key = client.api_keys.create(
name=args.name,
scopes=args.scopes,
expires_in_days=args.expires,
)
print(json.dumps({
"key_id": api_key.key_id,
"api_key": api_key.api_key,
"name": api_key.name,
"scopes": api_key.scopes,
}, indent=2))
print("\n⚠️ Save this key! It won't be shown again.", file=sys.stderr)
finally:
client.close()
def cmd_apikey_list(args):
"""List API keys command."""
client = create_client(args)
try:
keys = client.api_keys.list()
for key in keys:
print(json.dumps({
"key_id": key.key_id,
"name": key.name,
"key_prefix": key.key_prefix,
"is_active": key.is_active,
"scopes": key.scopes,
}))
finally:
client.close()
def cmd_apikey_revoke(args):
"""Revoke API key command."""
client = create_client(args)
try:
client.api_keys.revoke(key_id=args.key_id)
print(f"API key {args.key_id} revoked")
finally:
client.close()
def main():
"""Main CLI entry point."""
parser = argparse.ArgumentParser(
description="NeuroGraph CLI - Command-line interface for NeuroGraph API"
)
# Global arguments
parser.add_argument(
"--base-url",
default="http://localhost:8000",
help="API base URL (default: http://localhost:8000)",
)
parser.add_argument("--username", help="Username for authentication")
parser.add_argument("--password", help="Password for authentication")
parser.add_argument("--api-key", help="API key for authentication")
parser.add_argument("--debug", action="store_true", help="Enable debug logging")
subparsers = parser.add_subparsers(dest="command", help="Command to run")
# Health command
parser_health = subparsers.add_parser("health", help="Check API health")
parser_health.set_defaults(func=cmd_health)
# Status command
parser_status = subparsers.add_parser("status", help="Get system status")
parser_status.set_defaults(func=cmd_status)
# Token commands
parser_token = subparsers.add_parser("token", help="Token operations")
token_subparsers = parser_token.add_subparsers(dest="token_command")
# token create
parser_token_create = token_subparsers.add_parser("create", help="Create token")
parser_token_create.add_argument("text", help="Text for token")
parser_token_create.add_argument("--metadata", type=json.loads, help="Metadata (JSON)")
parser_token_create.add_argument("--show-embedding", action="store_true", help="Show full embedding")
parser_token_create.set_defaults(func=cmd_token_create)
# token get
parser_token_get = token_subparsers.add_parser("get", help="Get token")
parser_token_get.add_argument("token_id", type=int, help="Token ID")
parser_token_get.add_argument("--show-embedding", action="store_true", help="Show full embedding")
parser_token_get.set_defaults(func=cmd_token_get)
# token list
parser_token_list = token_subparsers.add_parser("list", help="List tokens")
parser_token_list.add_argument("--limit", type=int, default=10, help="Limit (default: 10)")
parser_token_list.add_argument("--offset", type=int, default=0, help="Offset (default: 0)")
parser_token_list.set_defaults(func=cmd_token_list)
# token delete
parser_token_delete = token_subparsers.add_parser("delete", help="Delete token")
parser_token_delete.add_argument("token_id", type=int, help="Token ID")
parser_token_delete.set_defaults(func=cmd_token_delete)
# token query
parser_token_query = token_subparsers.add_parser("query", help="Query similar tokens")
parser_token_query.add_argument("--text", required=True, help="Query text")
parser_token_query.add_argument("--top-k", type=int, default=10, help="Top K results (default: 10)")
parser_token_query.set_defaults(func=cmd_token_query)
# API Key commands
parser_apikey = subparsers.add_parser("apikey", help="API key operations")
apikey_subparsers = parser_apikey.add_subparsers(dest="apikey_command")
# apikey create
parser_apikey_create = apikey_subparsers.add_parser("create", help="Create API key")
parser_apikey_create.add_argument("--name", required=True, help="Key name")
parser_apikey_create.add_argument("--scopes", nargs="+", help="Scopes")
parser_apikey_create.add_argument("--expires", type=int, help="Expiration in days")
parser_apikey_create.set_defaults(func=cmd_apikey_create)
# apikey list
parser_apikey_list = apikey_subparsers.add_parser("list", help="List API keys")
parser_apikey_list.set_defaults(func=cmd_apikey_list)
# apikey revoke
parser_apikey_revoke = apikey_subparsers.add_parser("revoke", help="Revoke API key")
parser_apikey_revoke.add_argument("key_id", help="Key ID")
parser_apikey_revoke.set_defaults(func=cmd_apikey_revoke)
# Parse arguments
args = parser.parse_args()
# Setup logging
if args.debug:
setup_logging(level=logging.DEBUG)
else:
setup_logging(level=logging.WARNING)
# Check for command
if not hasattr(args, "func"):
parser.print_help()
sys.exit(1)
# Run command
try:
args.func(args)
except NeuroGraphError as e:
print(f"Error: {e.message}", file=sys.stderr)
if args.debug:
print(f"Error code: {e.error_code}", file=sys.stderr)
print(f"Details: {e.details}", file=sys.stderr)
sys.exit(1)
except KeyboardInterrupt:
print("\nAborted", file=sys.stderr)
sys.exit(130)
except Exception as e:
print(f"Unexpected error: {e}", file=sys.stderr)
if args.debug:
import traceback
traceback.print_exc()
sys.exit(1)
if __name__ == "__main__":
main()

Xet Storage Details

Size:
10.1 kB
·
Xet hash:
9a4aa48b2b2c2d3a4065d9a2db7892cca6f16b9c26fe006a7e199730a8f7c7da

Xet efficiently stores files, intelligently splitting them into unique chunks and accelerating uploads and downloads. More info.