PyPI - gosset - Versions diffs - 0.3.2__py3-none-any.whl - Mend

gosset 0.3.2__py3-none-any.whl

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (13) hide show

gosset/__init__.py +34 -0
gosset/auth.py +261 -0
gosset/cli.py +151 -0
gosset/client.py +933 -0
gosset/entities.py +263 -0
gosset/output.py +95 -0
gosset/resolve.py +118 -0
gosset-0.3.2.dist-info/METADATA +272 -0
gosset-0.3.2.dist-info/RECORD +13 -0
gosset-0.3.2.dist-info/WHEEL +5 -0
gosset-0.3.2.dist-info/entry_points.txt +3 -0
gosset-0.3.2.dist-info/licenses/LICENSE +202 -0
gosset-0.3.2.dist-info/top_level.txt +1 -0

gosset/__init__.py ADDED Viewed

@@ -0,0 +1,34 @@
+"""
+Gosset CLI & SDK — command-line and programmatic access to Gosset's drug,
+trial, company, deal and news data.
+"""
+# Single source of truth: the version lives in pyproject.toml and is read back
+# from the installed distribution metadata. It used to be duplicated here as a
+# literal, so a release could ship a package whose __version__ disagreed with
+# its own filename and nothing would catch it.
+#
+# The fallback covers running from a source checkout that was never installed —
+# there is no distribution metadata to read then, and a wrong-but-plausible
+# number would be worse than an obviously-unreleased one.
+#
+# Caveat, verified rather than assumed: this resolves by DISTRIBUTION NAME
+# across the environment, not by the source tree being imported. Importing
+# from a checkout while a different gosset is installed reports the INSTALLED
+# version (observed: a source tree reporting 0.2.3 from an unrelated env).
+# That is the accepted trade of this idiom: it guarantees the property that
+# matters — a published artifact's __version__ is, by construction, the
+# version in its own filename — at the cost of ambiguity in dev trees.
+from importlib.metadata import PackageNotFoundError as _PackageNotFoundError
+from importlib.metadata import version as _distribution_version
+try:
+    __version__ = _distribution_version("gosset")
+except _PackageNotFoundError:  # pragma: no cover - source tree, not installed
+    __version__ = "0.0.0.dev0"
+from .auth import get_oauth_token
+from .client import GossetClient, GossetAPIError
+__all__ = ["get_oauth_token", "GossetClient", "GossetAPIError", "__version__"]

gosset/auth.py ADDED Viewed

@@ -0,0 +1,261 @@
+"""
+OAuth authentication for Gosset API
+"""
+import os
+import time
+import threading
+import webbrowser
+from http.server import HTTPServer, BaseHTTPRequestHandler
+from urllib.parse import parse_qs, urlparse
+import requests
+API_BASE_URL = os.environ.get("OAUTH_BASE_URL", "https://api.gosset.ai")
+REDIRECT_URI = "http://localhost:8765/callback"
+class CallbackHandler(BaseHTTPRequestHandler):
+    """Handle OAuth callback"""
+    auth_code = None
+    def do_GET(self):
+        # Parse query parameters
+        query = urlparse(self.path).query
+        params = parse_qs(query)
+        if 'code' in params:
+            CallbackHandler.auth_code = params['code'][0]
+            self.send_response(200)
+            self.send_header('Content-type', 'text/html')
+            self.end_headers()
+            self.wfile.write(b"""
+                <html><body>
+                <h1>Authorization successful!</h1>
+                <p>You can close this window and return to the terminal.</p>
+                </body></html>
+            """)
+        else:
+            self.send_response(400)
+            self.send_header('Content-type', 'text/html')
+            self.end_headers()
+            error = params.get('error', ['Unknown error'])[0]
+            self.wfile.write(f"<html><body><h1>Authorization failed: {error}</h1></body></html>".encode())
+    def log_message(self, format, *args):
+        pass  # Suppress logging
+def get_oauth_token(base_url=None, quiet=False):
+    """
+    Get OAuth token through interactive browser flow
+    Args:
+        base_url: Optional custom API base URL
+        quiet: If True, suppress informational output
+    Returns:
+        str: OAuth access token if successful, None otherwise
+    """
+    if base_url is None:
+        base_url = API_BASE_URL
+    if not quiet:
+        print("=" * 70)
+        print("Interactive OAuth Token Acquisition")
+        print("=" * 70)
+        print()
+    # Step 1: Register a client
+    if not quiet:
+        print("Step 1: Registering OAuth client...")
+    try:
+        register_response = requests.post(
+            f"{base_url}/oauth/register",
+            json={"redirect_uris": [REDIRECT_URI]},
+            headers={"Content-Type": "application/json"}
+        )
+        if register_response.status_code != 201:
+            if not quiet:
+                print(f"✗ Failed to register client: {register_response.text}")
+            return None
+        client_data = register_response.json()
+        client_id = client_data["client_id"]
+        client_secret = client_data["client_secret"]
+        if not quiet:
+            print(f"✓ Client registered: {client_id}")
+    except Exception as e:
+        if not quiet:
+            print(f"✗ Error registering client: {e}")
+        return None
+    # Step 2: Start local server for callback
+    if not quiet:
+        print("\nStep 2: Starting local callback server...")
+    try:
+        server = HTTPServer(('localhost', 8765), CallbackHandler)
+    except OSError as e:
+        # The commonest way to hit this is running `gosset get-key` twice: the
+        # first is still holding the port while it waits for the browser, so the
+        # second dies here. An unhandled OSError traceback is a poor answer to
+        # what is really "you already have one of these running".
+        if not quiet:
+            print(f"\u2717 Could not start the callback server on port 8765: {e}")
+            print("  Another `gosset get-key`/`get-token` is probably still waiting")
+            print("  for authorization. Finish or cancel it, then retry.")
+        return None
+    server_thread = threading.Thread(target=server.serve_forever)
+    server_thread.daemon = True
+    server_thread.start()
+    if not quiet:
+        print(f"✓ Callback server running on {REDIRECT_URI}")
+    # Step 3: Open browser for authorization
+    if not quiet:
+        print("\nStep 3: Opening browser for authorization...")
+    # Build authorization URL
+    auth_url = f"{base_url}/oauth/authorize"
+    params = {
+        "response_type": "code",
+        "client_id": client_id,
+        "redirect_uri": REDIRECT_URI,
+        "scope": "read write",
+        "state": "test123"
+    }
+    auth_url_with_params = f"{auth_url}?" + "&".join([f"{k}={v}" for k, v in params.items()])
+    if not quiet:
+        print(f"Authorization URL: {auth_url_with_params}")
+        print("\nOpening browser... (if it doesn't open, copy the URL above)")
+    webbrowser.open(auth_url_with_params)
+    # Wait for callback
+    if not quiet:
+        print("\nWaiting for authorization...")
+    timeout = 120  # 2 minutes
+    start_time = time.time()
+    while CallbackHandler.auth_code is None and (time.time() - start_time) < timeout:
+        time.sleep(0.5)
+    server.shutdown()
+    if not CallbackHandler.auth_code:
+        if not quiet:
+            print(f"✗ No authorization received within {timeout}s")
+            print("  The browser must complete the flow on THIS machine — the")
+            print("  callback server listens on its localhost:8765, so opening the")
+            print("  URL elsewhere cannot reach it. On a headless host this can")
+            print("  never succeed; run it where you have a browser.")
+        return None
+    if not quiet:
+        print(f"✓ Authorization code received")
+    # Step 4: Exchange code for token
+    if not quiet:
+        print("\nStep 4: Exchanging code for access token...")
+    try:
+        token_response = requests.post(
+            f"{base_url}/oauth/token",
+            data={
+                "grant_type": "authorization_code",
+                "code": CallbackHandler.auth_code,
+                "client_id": client_id,
+                "client_secret": client_secret,
+                "redirect_uri": REDIRECT_URI
+            }
+        )
+        if token_response.status_code != 200:
+            if not quiet:
+                print(f"✗ Failed to get token: {token_response.text}")
+            return None
+        token_data = token_response.json()
+        access_token = token_data["access_token"]
+        if not quiet:
+            print("\n" + "=" * 70)
+            print("SUCCESS! Your OAuth token:")
+            print("=" * 70)
+            print(f"\n{access_token}\n")
+            print("To use this token, set it as an environment variable:")
+            print(f"export GOSSET_API_KEY='{access_token}'")
+            print("\nOr add to your ~/.bashrc or ~/.zshrc")
+            print("\nNote: GOSSET_OAUTH_TOKEN also works for backward compatibility")
+            print("=" * 70)
+        return access_token
+    except Exception as e:
+        if not quiet:
+            print(f"✗ Error getting token: {e}")
+        return None
+def get_api_key(base_url=None, quiet=False):
+    """Run the OAuth browser flow, then exchange the result for a durable API key.
+    `get_oauth_token` returns an OAuth ACCESS TOKEN, which the REST API cannot
+    accept: its auth validates a bearer against accounts.users by token/api_key
+    and never consults the OAuth store. So the token that flow produces fails on
+    every `gosset drugs`-style call, with an unhelpful "Authentication failed".
+    The OAuth flow is still the right way to establish WHO you are — it is the
+    only credential a CLI can obtain from a browser unattended. This adds the
+    missing second step: hand that identity to /api_key/from_oauth/ and get back
+    the key the API actually accepts. One command, one credential.
+    """
+    import os
+    import requests
+    base = (base_url or os.environ.get("GOSSET_API_URL")
+            or "https://api.gosset.ai").rstrip("/")
+    token = get_oauth_token(base_url=base_url, quiet=quiet)
+    if not token:
+        return None
+    if not quiet:
+        print("\nExchanging for a durable API key...")
+    try:
+        resp = requests.post(
+            f"{base}/api_key/from_oauth/",
+            headers={"Authorization": f"Bearer {token}"},
+            timeout=30,
+        )
+    except requests.RequestException as e:
+        if not quiet:
+            print(f"\u2717 Could not reach {base}: {e}")
+        return None
+    if resp.status_code != 200:
+        if not quiet:
+            print(f"\u2717 Exchange failed ({resp.status_code}): {resp.text[:200]}")
+        return None
+    api_key = (resp.json() or {}).get("api_key")
+    if not api_key:
+        if not quiet:
+            print("\u2717 Exchange returned no api_key")
+        return None
+    if not quiet:
+        print("\u2713 API key ready\n")
+        print(api_key)
+        print("\nSet it with:")
+        print(f"  export GOSSET_API_KEY='{api_key}'")
+    return api_key

gosset/cli.py ADDED Viewed

@@ -0,0 +1,151 @@
+"""
+Command-line interface for the Gosset CLI.
+Sub-commands:
+  drugs / trials / companies / deals / news   entity search (name↔id resolved for you)
+  ptrs <nct>                                   probability of technical & regulatory success
+  timeline <nct>                               predicted primary-completion timeline
+  get-key                                      obtain an API key (recommended)
+  get-token                                    obtain a raw OAuth token (MCP)
+  version                                      print the version
+Output is JSON by default (agent / jq friendly); pass --table for a human table.
+Auth: --api-key or $GOSSET_API_KEY (get one with `gosset get-key`).
+"""
+import sys
+import json
+import argparse
+from .auth import get_api_key, get_oauth_token
+from . import __version__
+from .entities import add_entity_parsers
+from .client import GossetClient, GossetAPIError
+def get_key_command(args):
+    """The credential users actually want: an API key the REST API accepts."""
+    key = get_api_key(base_url=args.base_url, quiet=args.quiet)
+    if key:
+        if args.quiet:
+            print(key)
+        return 0
+    return 1
+def get_token_command(args):
+    """Raw OAuth access token — for MCP, NOT for the REST API.
+    Kept because it is documented and in use, but it is not what you want for
+    `gosset drugs`: the REST API validates bearers against accounts.users and
+    rejects OAuth tokens, so this one authenticates nothing here. `get-key`
+    runs the same browser flow and returns the usable credential.
+    """
+    token = get_oauth_token(base_url=args.base_url, quiet=args.quiet)
+    if token:
+        if args.quiet:
+            print(token)
+        elif not args.quiet:
+            print("\nNote: this is an OAuth token, for MCP clients.")
+            print("For the CLI and SDK use `gosset get-key` instead.")
+        return 0
+    return 1
+def version_command(args):
+    print(f"Gosset CLI v{__version__}")
+    return 0
+def ptrs_command(client, args):
+    res = client.estimate_ptrs({"nct_id": args.nct_id})
+    print(json.dumps(res, indent=2, default=str))
+    return 0
+def timeline_command(client, args):
+    res = client.estimate_remaining_time(args.nct_id, as_of=args.as_of)
+    print(json.dumps(res, indent=2, default=str))
+    return 0
+def _auth_parent():
+    """Shared auth flags applied to every command that needs the API."""
+    p = argparse.ArgumentParser(add_help=False)
+    p.add_argument("--api-key", default=None,
+                   help="Bearer token (default: $GOSSET_API_KEY)")
+    p.add_argument("--base-url", default=None,
+                   help="API base URL (default: https://api.gosset.ai or $GOSSET_API_URL)")
+    return p
+def main():
+    """Main CLI entry point."""
+    parser = argparse.ArgumentParser(
+        description="Gosset CLI — command-line access to Gosset drugs, trials, companies, deals, news.",
+        prog="gosset",
+    )
+    parser.add_argument("--version", action="version", version=f"%(prog)s {__version__}")
+    subparsers = parser.add_subparsers(dest="command", help="Available commands")
+    auth = _auth_parent()
+    # Entity search commands: drugs / trials / companies / deals / news
+    add_entity_parsers(subparsers, parents=[auth])
+    # ptrs
+    pt = subparsers.add_parser("ptrs", parents=[auth],
+                               help="Estimate probability of technical & regulatory success for a trial")
+    pt.add_argument("nct_id", help="ClinicalTrials.gov id, e.g. NCT05599191")
+    pt.set_defaults(func=ptrs_command, _needs_client=True)
+    # timeline
+    tl = subparsers.add_parser("timeline", parents=[auth],
+                               help="Predict a trial's primary-completion timeline")
+    tl.add_argument("nct_id", help="ClinicalTrials.gov id")
+    tl.add_argument("--as-of", default=None, help="anchor date YYYY-MM-DD (default: today)")
+    tl.set_defaults(func=timeline_command, _needs_client=True)
+    # get-key — the one most users want
+    key_parser = subparsers.add_parser(
+        "get-key", help="Get an API key for the Gosset API (recommended)")
+    key_parser.add_argument("--quiet", action="store_true",
+                            help="Only output the key")
+    key_parser.add_argument("--base-url", help="API base URL")
+    key_parser.set_defaults(func=get_key_command, _needs_client=False)
+    # get-token
+    token_parser = subparsers.add_parser("get-token", help="Get a raw OAuth token (MCP clients)")
+    token_parser.add_argument("--base-url", help="Custom API base URL (optional)")
+    token_parser.add_argument("--quiet", action="store_true", help="Only output the token")
+    token_parser.set_defaults(func=get_token_command, _needs_client=False)
+    # version
+    ver = subparsers.add_parser("version", help="Print the Gosset CLI version")
+    ver.set_defaults(func=version_command, _needs_client=False)
+    args = parser.parse_args()
+    if not getattr(args, "command", None):
+        parser.print_help()
+        return 1
+    # Commands that hit the API need an authenticated client.
+    if getattr(args, "_needs_client", False):
+        try:
+            client = GossetClient(api_key=getattr(args, "api_key", None),
+                                  base_url=getattr(args, "base_url", None))
+        except ValueError:
+            print("Error: no API key. Run `gosset get-key` or set GOSSET_API_KEY "
+                  "(or pass --api-key).", file=sys.stderr)
+            return 1
+        try:
+            return args.func(client, args)
+        except GossetAPIError as e:
+            print(json.dumps({"error": str(e)}), file=sys.stderr)
+            return 1
+    return args.func(args)
+if __name__ == "__main__":
+    sys.exit(main())