drift-ml 0.1.1__py3-none-any.whl

drift/__init__.py

@@ -0,0 +1,5 @@
+"""
+drift — terminal-first, chat-based CLI for the same AutoML planner + executor as the web app.
+"""
+
+__version__ = "0.1.0"

drift/__main__.py

@@ -0,0 +1,14 @@
+"""
+Entry point for `python -m drift` or `drift` command.
+Runs the chat-based REPL.
+"""
+
+from drift.cli.repl import run_repl
+
+
+def main() -> None:
+    run_repl()
+
+
+if __name__ == "__main__":
+    main()

drift/cli/__init__.py

@@ -0,0 +1,6 @@
+"""drift CLI: chat-based REPL and session state."""
+
+from drift.cli.session import SessionState
+from drift.cli.repl import run_repl
+
+__all__ = ["SessionState", "run_repl"]

drift/cli/client.py

@@ -0,0 +1,125 @@
+"""
+HTTP client for the existing backend API.
+Uses the same endpoints as the web app: upload, chat, session, runs, train.
+"""
+
+import os
+from pathlib import Path
+from typing import Any, Dict, Optional
+
+try:
+    import requests
+except ImportError:
+    requests = None  # type: ignore
+
+DEFAULT_BASE_URL = os.environ.get("DRIFT_BACKEND_URL", "http://localhost:8000")
+
+
+class BackendError(Exception):
+    """Raised when the backend returns an error or is unreachable."""
+
+    def __init__(self, message: str, status_code: Optional[int] = None, body: Any = None):
+        self.message = message
+        self.status_code = status_code
+        self.body = body
+        super().__init__(message)
+
+
+class BackendClient:
+    """Client for backend upload, chat, session, runs, and train endpoints."""
+
+    def __init__(self, base_url: str = DEFAULT_BASE_URL, timeout: int = 300):
+        self.base_url = base_url.rstrip("/")
+        self.timeout = timeout
+        if requests is None:
+            raise BackendError(
+                "The 'requests' library is required for the drift CLI. Install it with: pip install requests"
+            )
+
+    def _url(self, path: str) -> str:
+        return f"{self.base_url}{path}"
+
+    def health(self) -> Dict[str, Any]:
+        """GET /health — check backend is up and LLM status."""
+        r = requests.get(self._url("/health"), timeout=10)
+        r.raise_for_status()
+        return r.json()
+
+    def upload_csv(self, file_path: str) -> Dict[str, Any]:
+        """
+        POST /upload — upload a local CSV and create a session.
+        Returns session_id, dataset_id, profile, initial_message.
+        """
+        path = Path(file_path).resolve()
+        if not path.exists():
+            raise BackendError(f"File not found: {path}")
+        with open(path, "rb") as f:
+            name = path.name
+            files = {"file": (name, f, "text/csv")}
+            r = requests.post(self._url("/upload"), files=files, timeout=60)
+        if r.status_code >= 400:
+            try:
+                body = r.json()
+                detail = body.get("detail", str(r.text))
+            except Exception:
+                detail = r.text or str(r.status_code)
+            raise BackendError(f"Upload failed: {detail}", status_code=r.status_code, body=r.text)
+        return r.json()
+
+    def chat(self, session_id: str, message: str) -> Dict[str, Any]:
+        """
+        POST /session/{session_id}/chat — send a user message, get agent reply.
+        Returns chat_history, trigger_training.
+        """
+        r = requests.post(
+            self._url(f"/session/{session_id}/chat"),
+            json={"message": message},
+            timeout=120,
+        )
+        if r.status_code >= 400:
+            try:
+                body = r.json()
+                detail = body.get("detail", str(r.text))
+            except Exception:
+                detail = r.text or str(r.status_code)
+            raise BackendError(f"Chat failed: {detail}", status_code=r.status_code, body=r.text)
+        return r.json()
+
+    def get_session(self, session_id: str) -> Dict[str, Any]:
+        """GET /session/{session_id} — full session state (chat, model_state, current_run_id, etc.)."""
+        r = requests.get(self._url(f"/session/{session_id}"), timeout=30)
+        if r.status_code >= 400:
+            try:
+                body = r.json()
+                detail = body.get("detail", str(r.text))
+            except Exception:
+                detail = r.text or str(r.status_code)
+            raise BackendError(f"Get session failed: {detail}", status_code=r.status_code, body=r.text)
+        return r.json()
+
+    def get_run_state(self, run_id: str) -> Dict[str, Any]:
+        """GET /runs/{run_id} — run state: status, current_step, progress, events[]."""
+        r = requests.get(self._url(f"/runs/{run_id}"), timeout=30)
+        if r.status_code >= 400:
+            try:
+                body = r.json()
+                detail = body.get("detail", str(r.text))
+            except Exception:
+                detail = r.text or str(r.status_code)
+            raise BackendError(f"Get run failed: {detail}", status_code=r.status_code, body=r.text)
+        return r.json()
+
+    def train(self, session_id: str) -> Dict[str, Any]:
+        """
+        POST /session/{session_id}/train — run one training attempt (blocking).
+        Returns run_id, session_id, metrics, refused, refusal_reason, agent_message.
+        """
+        r = requests.post(self._url(f"/session/{session_id}/train"), timeout=self.timeout)
+        if r.status_code >= 400:
+            try:
+                body = r.json()
+                detail = body.get("detail", str(r.text))
+            except Exception:
+                detail = r.text or str(r.status_code)
+            raise BackendError(f"Train failed: {detail}", status_code=r.status_code, body=r.text)
+        return r.json()

drift/cli/repl.py

@@ -0,0 +1,220 @@
+"""
+Chat-based CLI loop for drift.
+Natural language input; maintains session state; reuses backend planner + executor.
+"""
+
+import re
+import sys
+import threading
+import time
+from typing import Any, Dict, Optional
+
+from drift.cli.client import BackendClient, BackendError, DEFAULT_BASE_URL
+from drift.cli.session import SessionState
+
+
+PROMPT = "drift › "
+LOAD_PATTERN = re.compile(r"^\s*load\s+(.+)$", re.IGNORECASE)
+
+
+def run_repl(base_url: Optional[str] = None) -> None:
+    """Run the chat-based REPL. Uses backend at base_url (default from DRIFT_BACKEND_URL or localhost:8000)."""
+    try:
+        client = BackendClient(base_url=base_url or DEFAULT_BASE_URL)
+    except BackendError as e:
+        print(f"drift: {e.message}", file=sys.stderr)
+        sys.exit(1)
+    session = SessionState()
+    _print_banner(client)
+    while True:
+        try:
+            line = input(PROMPT).strip()
+        except EOFError:
+            print()
+            break
+        if not line:
+            continue
+        if line.lower() in ("quit", "exit", "q"):
+            break
+        try:
+            _handle_input(line, client, session)
+        except BackendError as e:
+            print(f"Error: {e.message}", file=sys.stderr)
+        except KeyboardInterrupt:
+            print("\nInterrupted. Type 'quit' to exit.")
+            continue
+
+
+def _print_banner(client: BackendClient) -> None:
+    _print_welcome()
+    engine_ok = False
+    llm_name = ""
+    try:
+        health = client.health()
+        engine_ok = (health.get("status") or "").lower() == "healthy"
+        llm_name = health.get("llm_provider") or health.get("current_model") or ""
+    except Exception:
+        pass
+    _print_status(engine_ok=engine_ok, llm_name=llm_name)
+    _print_examples()
+    print()
+
+
+def _print_welcome() -> None:
+    """drift by Lakshit Sachdeva. Local-first ML engineer."""
+    print()
+    print("  ----------------------------------------")
+    print("  drift by Lakshit Sachdeva")
+    print("  Local-first ML engineer.")
+    print("  Same engine as the web app.")
+    print("  No commands to memorize.")
+    print("  ----------------------------------------")
+    print()
+
+
+def _print_status(engine_ok: bool, llm_name: str) -> None:
+    """Engine running, LLM detected, Ready."""
+    if engine_ok:
+        print("  \u2713  Engine running")
+        if llm_name:
+            print(f"  \u2713  LLM detected ({llm_name})")
+        else:
+            print("  \u2713  LLM detected (Gemini CLI / Ollama / local)")
+        print("  \u2713  Ready")
+    else:
+        print("  \u2717  Engine not running")
+        print("      Start the engine or set DRIFT_BACKEND_URL to a running engine URL.")
+    print()
+
+
+def _print_examples() -> None:
+    """Examples: load, predict, try something stronger, quit."""
+    print("  Examples:")
+    print("    load data.csv")
+    print("    predict price")
+    print("    try something stronger")
+    print("    why is accuracy capped")
+    print("    quit")
+    print()
+
+
+def _handle_input(line: str, client: BackendClient, session: SessionState) -> None:
+    load_match = LOAD_PATTERN.match(line)
+    if load_match:
+        path = load_match.group(1).strip().strip('"\'')
+        _do_load(path, client, session)
+        return
+    if not session.has_session():
+        print("Load a dataset first: load path/to/file.csv")
+        return
+    _do_chat(line, client, session)
+
+
+def _do_load(path: str, client: BackendClient, session: SessionState) -> None:
+    out = client.upload_csv(path)
+    session.dataset_path = path
+    session.update_from_upload(
+        session_id=out["session_id"],
+        dataset_id=out["dataset_id"],
+        initial_message=out.get("initial_message"),
+    )
+    print("Dataset loaded.")
+    if out.get("initial_message"):
+        content = out["initial_message"].get("content") or ""
+        if content:
+            _print_message(content)
+    print()
+
+
+def _do_chat(message: str, client: BackendClient, session: SessionState) -> None:
+    sid = session.session_id
+    out = client.chat(sid, message)
+    chat_history = out.get("chat_history") or []
+    session.update_from_chat(chat_history)
+    # Show latest agent reply
+    for m in reversed(chat_history):
+        if m.get("role") == "agent" and m.get("content"):
+            _print_message(m["content"])
+            break
+    trigger = out.get("trigger_training") is True
+    if trigger:
+        _run_training_and_show(client, session)
+    print()
+
+
+def _run_training_and_show(client: BackendClient, session: SessionState) -> None:
+    sid = session.session_id
+    if not sid:
+        return
+    train_result: Optional[Dict[str, Any]] = None
+    train_error: Optional[Exception] = None
+
+    def do_train() -> None:
+        nonlocal train_result, train_error
+        try:
+            train_result = client.train(sid)
+        except Exception as e:
+            train_error = e
+
+    thread = threading.Thread(target=do_train, daemon=True)
+    thread.start()
+    print("Training started…")
+    run_id: Optional[str] = None
+    last_event_count = 0
+    poll_interval = 0.8
+    timeout_sec = 300
+    start = time.time()
+    while thread.is_alive() and (time.time() - start) < timeout_sec:
+        time.sleep(poll_interval)
+        try:
+            sess = client.get_session(sid)
+            run_id = sess.get("current_run_id")
+            if run_id:
+                break
+        except Exception:
+            pass
+    if run_id:
+        while thread.is_alive() and (time.time() - start) < timeout_sec:
+            time.sleep(poll_interval)
+            try:
+                run_state = client.get_run_state(run_id)
+                events = run_state.get("events") or []
+                for ev in events[last_event_count:]:
+                    msg = ev.get("message") or ev.get("step_name") or ""
+                    if msg:
+                        print(f"  {msg}")
+                last_event_count = len(events)
+                status = run_state.get("status")
+                if status in ("success", "failed", "refused"):
+                    break
+            except Exception:
+                pass
+    thread.join(timeout=1.0)
+    if train_error:
+        print(f"Training error: {train_error}", file=sys.stderr)
+        return
+    if train_result:
+        session.update_after_train(
+            run_id=train_result.get("run_id", ""),
+            metrics=train_result.get("metrics") or {},
+            agent_message=train_result.get("agent_message"),
+        )
+        agent_message = train_result.get("agent_message")
+        if agent_message:
+            _print_message(agent_message)
+        metrics = train_result.get("metrics") or {}
+        if metrics:
+            primary = metrics.get("primary_metric_value") or metrics.get("accuracy") or metrics.get("r2")
+            if primary is not None:
+                print(f"  Primary metric: {primary}")
+
+
+def _print_message(content: str) -> None:
+    """Print agent message; strip markdown bold for terminal if desired, keep newlines."""
+    text = content.strip()
+    if not text:
+        return
+    # Optional: replace **x** with x for readability in terminal
+    text = re.sub(r"\*\*([^*]+)\*\*", r"\1", text)
+    for line in text.split("\n"):
+        print(line)

drift/cli/session.py

@@ -0,0 +1,70 @@
+"""
+Session state for the drift CLI.
+Holds dataset ref, plan summary, last metrics, run_id, and chat history
+so the REPL can maintain context and the backend can be queried correctly.
+"""
+
+from dataclasses import dataclass, field
+from typing import Any, Dict, List, Optional
+
+
+@dataclass
+class SessionState:
+    """In-memory CLI session: dataset, plan, run, metrics, chat."""
+
+    dataset_path: Optional[str] = None
+    dataset_id: Optional[str] = None
+    session_id: Optional[str] = None
+    run_id: Optional[str] = None
+    plan_summary: Optional[str] = None
+    last_metrics: Dict[str, Any] = field(default_factory=dict)
+    chat_history: List[Dict[str, Any]] = field(default_factory=list)
+
+    def has_session(self) -> bool:
+        return bool(self.session_id)
+
+    def has_dataset(self) -> bool:
+        return bool(self.dataset_id and self.session_id)
+
+    def clear_run(self) -> None:
+        self.run_id = None
+        self.last_metrics = {}
+
+    def update_from_upload(self, session_id: str, dataset_id: str, initial_message: Optional[Dict] = None) -> None:
+        self.session_id = session_id
+        self.dataset_id = dataset_id
+        self.run_id = None
+        self.last_metrics = {}
+        if initial_message:
+            self.chat_history = [initial_message]
+
+    def update_from_chat(self, chat_history: List[Dict[str, Any]], run_id: Optional[str] = None) -> None:
+        self.chat_history = chat_history or self.chat_history
+        if run_id is not None:
+            self.run_id = run_id
+
+    def update_from_session(self, session: Dict[str, Any]) -> None:
+        self.session_id = session.get("session_id") or self.session_id
+        self.dataset_id = session.get("dataset_id") or self.dataset_id
+        self.run_id = session.get("current_run_id") or self.run_id
+        self.chat_history = session.get("chat_history") or self.chat_history
+        ms = session.get("model_state") or {}
+        self.last_metrics = ms.get("metrics") or self.last_metrics
+        self.plan_summary = None
+        if session.get("structural_plan"):
+            self.plan_summary = _summarize_plan(session["structural_plan"])
+
+    def update_after_train(self, run_id: str, metrics: Dict[str, Any], agent_message: Optional[str] = None) -> None:
+        self.run_id = run_id
+        self.last_metrics = metrics or self.last_metrics
+        if agent_message and self.chat_history:
+            self.chat_history[-1]["content"] = agent_message
+
+
+def _summarize_plan(structural_plan: Dict[str, Any]) -> str:
+    """One-line summary of structural plan for display (StructuralPlan has inferred_target, task_type; no models)."""
+    if not structural_plan:
+        return ""
+    target = structural_plan.get("inferred_target") or structural_plan.get("target") or "?"
+    task = structural_plan.get("task_type") or "?"
+    return f"Target: {target}, task: {task}"

drift/llm_adapters/__init__.py

@@ -0,0 +1,9 @@
+"""
+Pluggable LLM adapters for drift CLI.
+Primary planning/execution uses the backend; these adapters support
+optional local processing (e.g. help, summaries) or future offline use.
+"""
+
+from drift.llm_adapters.base import BaseLLMAdapter, LLMResponse
+
+__all__ = ["BaseLLMAdapter", "LLMResponse"]

drift/llm_adapters/base.py

@@ -0,0 +1,41 @@
+"""
+Base contract for drift LLM adapters.
+The CLI uses the backend as the planner/executor; adapters return
+structured ML intent, plan updates, and explanations when used locally.
+"""
+
+from abc import ABC, abstractmethod
+from dataclasses import dataclass
+from typing import Any, Dict, List, Optional
+
+
+@dataclass
+class LLMResponse:
+    """Structured response from an LLM adapter: intent, plan updates, explanation."""
+
+    raw: str
+    intent: Optional[Dict[str, Any]] = None  # target, drop_columns, performance_mode, start_training
+    plan_summary: Optional[str] = None
+    explanation: Optional[str] = None
+
+
+class BaseLLMAdapter(ABC):
+    """
+    LLM adapter contract.
+    The LLM is the PLANNER, not the executor; it updates plans and explains outcomes.
+    Execution is assumed to happen automatically (backend).
+    """
+
+    @abstractmethod
+    def generate(self, user_message: str, system_prompt: Optional[str] = None, context: Optional[Dict[str, Any]] = None) -> LLMResponse:
+        """
+        Turn user message + optional context into a structured response.
+        Returns intent, plan summary, and explanation — never claims to edit files or execute.
+        """
+        pass
+
+    @property
+    @abstractmethod
+    def name(self) -> str:
+        """Adapter identifier (e.g. gemini_cli, local_llm)."""
+        pass

drift/llm_adapters/gemini_cli.py

@@ -0,0 +1,65 @@
+"""
+Gemini CLI adapter — uses gemini CLI (default if available) for local LLM calls.
+Used when drift CLI runs in a mode that calls a local LLM instead of the backend.
+"""
+
+import os
+import re
+import subprocess
+from typing import Any, Dict, Optional
+
+from drift.llm_adapters.base import BaseLLMAdapter, LLMResponse
+
+
+class GeminiCLIAdapter(BaseLLMAdapter):
+    """Adapter that shells out to gemini CLI (e.g. `gemini` or GEMINI_CLI_CMD)."""
+
+    def __init__(self, cmd: Optional[str] = None):
+        self.cmd = (cmd or os.environ.get("GEMINI_CLI_CMD", "gemini")).strip()
+
+    @property
+    def name(self) -> str:
+        return "gemini_cli"
+
+    def generate(
+        self,
+        user_message: str,
+        system_prompt: Optional[str] = None,
+        context: Optional[Dict[str, Any]] = None,
+    ) -> LLMResponse:
+        prompt = user_message
+        if system_prompt:
+            prompt = f"{system_prompt}\n\n---\n\n{prompt}"
+        if context:
+            prompt = f"Context: {context}\n\n{prompt}"
+        raw = self._call_cli(prompt)
+        intent = self._parse_intent(raw)
+        return LLMResponse(raw=raw, intent=intent, explanation=raw)
+
+    def _call_cli(self, prompt: str) -> str:
+        try:
+            proc = subprocess.run(
+                [self.cmd, "run", "-"],
+                input=prompt,
+                capture_output=True,
+                text=True,
+                timeout=120,
+            )
+            if proc.returncode != 0:
+                return f"[gemini CLI error: {proc.stderr or proc.stdout or 'unknown'}]"
+            return (proc.stdout or "").strip()
+        except FileNotFoundError:
+            return f"[gemini CLI not found: {self.cmd}]"
+        except subprocess.TimeoutExpired:
+            return "[gemini CLI timeout]"
+
+    def _parse_intent(self, raw: str) -> Optional[Dict[str, Any]]:
+        """Extract INTENT_JSON from response if present."""
+        match = re.search(r"INTENT_JSON:\s*(\{.*?\})\s*$", raw, re.DOTALL)
+        if not match:
+            return None
+        try:
+            import json
+            return json.loads(match.group(1).strip())
+        except Exception:
+            return None

drift/llm_adapters/local_llm.py

@@ -0,0 +1,65 @@
+"""
+Local LLM adapter — ollama / llama.cpp style.
+Used when drift CLI is configured to use a local model instead of the backend.
+"""
+
+import os
+import re
+from typing import Any, Dict, Optional
+
+from drift.llm_adapters.base import BaseLLMAdapter, LLMResponse
+
+
+class LocalLLMAdapter(BaseLLMAdapter):
+    """
+    Adapter for local LLM (e.g. Ollama, llama.cpp server).
+    Expects OLLAMA_BASE_URL or LOCAL_LLM_URL; model from OLLAMA_MODEL or LOCAL_LLM_MODEL.
+    """
+
+    def __init__(self, base_url: Optional[str] = None, model: Optional[str] = None):
+        self.base_url = (base_url or os.environ.get("OLLAMA_BASE_URL") or os.environ.get("LOCAL_LLM_URL", "http://localhost:11434")).rstrip("/")
+        self.model = model or os.environ.get("OLLAMA_MODEL") or os.environ.get("LOCAL_LLM_MODEL", "llama2")
+
+    @property
+    def name(self) -> str:
+        return "local_llm"
+
+    def generate(
+        self,
+        user_message: str,
+        system_prompt: Optional[str] = None,
+        context: Optional[Dict[str, Any]] = None,
+    ) -> LLMResponse:
+        prompt = user_message
+        if system_prompt:
+            prompt = f"{system_prompt}\n\n---\n\n{prompt}"
+        if context:
+            prompt = f"Context: {context}\n\n{prompt}"
+        raw = self._call_api(prompt)
+        intent = self._parse_intent(raw)
+        return LLMResponse(raw=raw, intent=intent, explanation=raw)
+
+    def _call_api(self, prompt: str) -> str:
+        try:
+            import requests
+            r = requests.post(
+                f"{self.base_url}/api/generate",
+                json={"model": self.model, "prompt": prompt, "stream": False},
+                timeout=120,
+            )
+            if r.status_code >= 400:
+                return f"[Local LLM error: {r.status_code} {r.text[:200]}]"
+            data = r.json()
+            return (data.get("response") or "").strip()
+        except Exception as e:
+            return f"[Local LLM error: {e}]"
+
+    def _parse_intent(self, raw: str) -> Optional[Dict[str, Any]]:
+        match = re.search(r"INTENT_JSON:\s*(\{.*?\})\s*$", raw, re.DOTALL)
+        if not match:
+            return None
+        try:
+            import json
+            return json.loads(match.group(1).strip())
+        except Exception:
+            return None

drift_ml-0.1.1.dist-info/METADATA

@@ -0,0 +1,6 @@
+Metadata-Version: 2.4
+Name: drift-ml
+Version: 0.1.1
+Summary: Terminal-first AutoML CLI - chat-based ML engineer
+Requires-Python: >=3.10
+Requires-Dist: requests>=2.28.0

drift_ml-0.1.1.dist-info/RECORD

@@ -0,0 +1,15 @@
+drift/__init__.py,sha256=X0NUP5ZAZSz-rBFfjvmmS4IYWP2_CZtu187mqwpWwqk,127
+drift/__main__.py,sha256=MMUjNUbctbLHVe37ZCOW-66h8OZ8WIYiISxHJHRNxes,202
+drift/cli/__init__.py,sha256=OQt7M06e98e_L_60Qz-HsmSqGXKWdH53SvgETJ_BZZ0,172
+drift/cli/client.py,sha256=AiV5hNCWgQbH9biznPUD7jctsSpDaXdy1WcgAIoBqtM,4880
+drift/cli/repl.py,sha256=ifZH2xoWFwCfdsGSh7HEkdO378t1c4_h07iNZGiUrMs,7220
+drift/cli/session.py,sha256=fMBI_pgiOmm-hcf7GDcjDeMIKESy6mGeEWhWyzdBirM,2860
+drift/llm_adapters/__init__.py,sha256=y1UhZWlC8Ik_OKfLcOp0JZP-FKR3MBBCemWwsL6TnkY,296
+drift/llm_adapters/base.py,sha256=KlZUPYpvCI8pafklBWel0GHHLNtVKVwSHA92MZt3VsI,1331
+drift/llm_adapters/gemini_cli.py,sha256=Z61wY3yFiZqPrQrpJAQrBtMbBkr2qLWBkni-A4p9lZo,2163
+drift/llm_adapters/local_llm.py,sha256=Z6j6z1CXk2LMeQ5ZnY4o38PiYkHYmcIkgJGkHdU50M8,2279
+drift_ml-0.1.1.dist-info/METADATA,sha256=EGmvqr1xDEnVM42RZFtYS4htDu7KfDimXC2aD9qPu6o,168
+drift_ml-0.1.1.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+drift_ml-0.1.1.dist-info/entry_points.txt,sha256=aCY7U9M8nhYj_tIfTXJmYkVmXY3ZoxF0tebDZzYswv8,46
+drift_ml-0.1.1.dist-info/top_level.txt,sha256=3u2KGqsciGZQ2uCoBivm55t3e8er8S4xnqkgdQ_8oeM,6
+drift_ml-0.1.1.dist-info/RECORD,,

drift_ml-0.1.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.10.2)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

drift_ml-0.1.1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+drift = drift.__main__:main

drift_ml-0.1.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+drift