downshift 0.1.0.dev0__py3-none-any.whl

downshift/schema.py

@@ -0,0 +1,356 @@
+"""Data format for LLM call sites (callsites.json).
+
+The ast scanner writes it, the Bob auditor enriches it, and every later
+command reads it. Everything goes through this module so both producers
+are validated the same way.
+"""
+
+from __future__ import annotations
+
+import json
+from collections.abc import Callable
+from dataclasses import asdict, dataclass, field, fields
+from pathlib import Path
+from typing import Any
+
+from downshift import __version__
+
+SCHEMA_VERSION = 1
+
+# How the scanner learned the model name.
+MODEL_SOURCES = frozenset(
+    {
+        "literal",  # model="gpt-4o" at the call
+        "constant",  # a named constant, possibly imported from another module
+        "env_default",  # os.getenv("X", "default"): the default is used
+        "env",  # os.getenv("X") with no default: unknown until runtime
+        "dict_lookup",  # MODELS["key"] on a dict literal
+        "parameter_default",  # def f(model="gpt-4o")
+        "kwargs",  # passed through **params and not resolvable
+        "missing",  # no model argument at all
+        "dynamic",  # anything else computed at runtime
+        "manual",  # set by a human or by Bob
+    }
+)
+OUTPUT_FORMATS = frozenset({"text", "json"})
+DIFFICULTIES = frozenset({"easy", "medium", "hard"})
+GRADINGS = frozenset({"exact", "json_fields", "judge"})
+PRODUCERS = frozenset({"ast", "bob", "manual"})
+
+
+class SchemaError(ValueError):
+    """Raised when callsites data does not match the schema."""
+
+
+@dataclass
+class ModelRef:
+    value: str | None
+    source: str
+    expression: str
+    env_var: str | None = None
+    defined_in: str | None = None
+
+    @property
+    def resolved(self) -> bool:
+        return self.value is not None
+
+
+@dataclass
+class PromptMessage:
+    role: str
+    content: str
+    resolved: bool = True
+
+
+@dataclass
+class CallSite:
+    # Where it is
+    id: str
+    file: str
+    line: int
+    function: str
+    api: str
+    model: ModelRef
+    end_line: int | None = None
+    is_async: bool = False
+    # What it sends
+    messages: list[PromptMessage] | None = None
+    output_format: str = "text"
+    temperature: float | None = None
+    max_tokens: int | None = None
+    # How it is reached
+    via: str | None = None
+    callers: list[str] = field(default_factory=list)
+    notes: list[str] = field(default_factory=list)
+    # Enrichment (Bob or a human); None when produced by the ast scanner
+    purpose: str | None = None
+    output_contract: str | None = None
+    difficulty: str | None = None
+    grading: str | None = None
+    found_by: str = "ast"
+
+    @property
+    def prompt_resolved(self) -> bool:
+        return self.messages is not None and all(m.resolved for m in self.messages)
+
+    def to_dict(self) -> dict[str, Any]:
+        return asdict(self)
+
+    @classmethod
+    def from_dict(cls, data: Any, path: str = "call_site") -> CallSite:
+        if not isinstance(data, dict):
+            raise SchemaError(f"{path}: expected an object, got {type(data).__name__}")
+        _reject_unknown(data, {f.name for f in fields(cls)}, path)
+
+        model_data = _field(data, "model", path, _is_dict, "an object")
+        return cls(
+            id=_field(data, "id", path, _is_nonempty_str, "a non-empty string"),
+            file=_field(data, "file", path, _is_nonempty_str, "a non-empty string"),
+            line=_field(data, "line", path, _is_positive_int, "a line number >= 1"),
+            function=_field(data, "function", path, _is_nonempty_str, "a non-empty string"),
+            api=_field(data, "api", path, _is_nonempty_str, "a non-empty string"),
+            model=_model_from_dict(model_data, f"{path}.model"),
+            end_line=_field(data, "end_line", path, _opt(_is_positive_int), "a line number", None),
+            is_async=_field(data, "is_async", path, _is_bool, "true or false", False),
+            messages=_messages_from_dict(data.get("messages"), f"{path}.messages"),
+            output_format=_field(
+                data,
+                "output_format",
+                path,
+                _one_of(OUTPUT_FORMATS),
+                _choices(OUTPUT_FORMATS),
+                "text",
+            ),
+            temperature=_field(data, "temperature", path, _opt(_is_number), "a number", None),
+            max_tokens=_field(
+                data, "max_tokens", path, _opt(_is_positive_int), "an integer >= 1", None
+            ),
+            via=_field(data, "via", path, _opt(_is_nonempty_str), "a call site id", None),
+            callers=_field(data, "callers", path, _is_str_list, "a list of strings", []),
+            notes=_field(data, "notes", path, _is_str_list, "a list of strings", []),
+            purpose=_field(data, "purpose", path, _opt(_is_str), "a string", None),
+            output_contract=_field(data, "output_contract", path, _opt(_is_str), "a string", None),
+            difficulty=_field(
+                data,
+                "difficulty",
+                path,
+                _opt(_one_of(DIFFICULTIES)),
+                _choices(DIFFICULTIES),
+                None,
+            ),
+            grading=_field(
+                data,
+                "grading",
+                path,
+                _opt(_one_of(GRADINGS)),
+                _choices(GRADINGS),
+                None,
+            ),
+            found_by=_field(
+                data,
+                "found_by",
+                path,
+                _one_of(PRODUCERS),
+                _choices(PRODUCERS),
+                "ast",
+            ),
+        )
+
+
+@dataclass
+class ScanResult:
+    root: str
+    files_scanned: int
+    call_sites: list[CallSite]
+    warnings: list[str] = field(default_factory=list)
+    generated_by: str = "ast"
+    tool_version: str = __version__
+
+    def summary(self) -> dict[str, int]:
+        return {
+            "files_scanned": self.files_scanned,
+            "call_sites": len(self.call_sites),
+            "models_resolved": sum(1 for s in self.call_sites if s.model.resolved),
+            "prompts_resolved": sum(1 for s in self.call_sites if s.prompt_resolved),
+        }
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "schema_version": SCHEMA_VERSION,
+            "tool": "downshift",
+            "tool_version": self.tool_version,
+            "generated_by": self.generated_by,
+            "root": self.root,
+            "summary": self.summary(),
+            "warnings": list(self.warnings),
+            "call_sites": [site.to_dict() for site in self.call_sites],
+        }
+
+    def to_json(self) -> str:
+        return json.dumps(self.to_dict(), indent=2, ensure_ascii=False) + "\n"
+
+    def write(self, path: Path) -> None:
+        path.parent.mkdir(parents=True, exist_ok=True)
+        path.write_text(self.to_json(), encoding="utf-8")
+
+    @classmethod
+    def from_dict(cls, data: Any) -> ScanResult:
+        if not isinstance(data, dict):
+            raise SchemaError("callsites: expected a JSON object at the top level")
+        version = data.get("schema_version")
+        if version != SCHEMA_VERSION:
+            raise SchemaError(
+                f"schema_version: unsupported value {version!r} (expected {SCHEMA_VERSION})"
+            )
+        raw_sites = data.get("call_sites")
+        if not isinstance(raw_sites, list):
+            raise SchemaError("call_sites: expected a list")
+        sites = [CallSite.from_dict(item, f"call_sites[{i}]") for i, item in enumerate(raw_sites)]
+
+        seen: set[str] = set()
+        for site in sites:
+            if site.id in seen:
+                raise SchemaError(f"call_sites: duplicate id {site.id!r}")
+            seen.add(site.id)
+
+        return cls(
+            root=_field(data, "root", "callsites", _is_str, "a string", "."),
+            files_scanned=_summary_files(data),
+            call_sites=sites,
+            warnings=_field(data, "warnings", "callsites", _is_str_list, "a list of strings", []),
+            generated_by=_field(
+                data,
+                "generated_by",
+                "callsites",
+                _one_of(PRODUCERS),
+                _choices(PRODUCERS),
+                "ast",
+            ),
+            tool_version=_field(
+                data, "tool_version", "callsites", _is_str, "a string", __version__
+            ),
+        )
+
+    @classmethod
+    def load(cls, path: Path) -> ScanResult:
+        try:
+            text = path.read_text(encoding="utf-8")
+        except FileNotFoundError:
+            raise SchemaError(f"callsites file not found: {path}") from None
+        try:
+            data = json.loads(text)
+        except json.JSONDecodeError as exc:
+            raise SchemaError(f"{path}: invalid JSON: {exc}") from exc
+        return cls.from_dict(data)
+
+
+# --- helpers ------------------------------------------------------------------
+
+_MISSING: Any = object()
+
+
+def _field(
+    data: dict[str, Any],
+    key: str,
+    path: str,
+    check: Callable[[Any], bool],
+    expected: str,
+    default: Any = _MISSING,
+) -> Any:
+    if key not in data:
+        if default is _MISSING:
+            raise SchemaError(f"{path}.{key}: missing required field")
+        return default
+    value = data[key]
+    if not check(value):
+        raise SchemaError(f"{path}.{key}: expected {expected}, got {value!r}")
+    return value
+
+
+def _reject_unknown(data: dict[str, Any], allowed: set[str], path: str) -> None:
+    unknown = sorted(set(data) - allowed)
+    if unknown:
+        raise SchemaError(f"{path}: unknown field(s) {', '.join(unknown)}")
+
+
+def _model_from_dict(data: dict[str, Any], path: str) -> ModelRef:
+    _reject_unknown(data, {f.name for f in fields(ModelRef)}, path)
+    return ModelRef(
+        value=_field(data, "value", path, _opt(_is_nonempty_str), "a model name or null"),
+        source=_field(data, "source", path, _one_of(MODEL_SOURCES), _choices(MODEL_SOURCES)),
+        expression=_field(data, "expression", path, _is_str, "a string"),
+        env_var=_field(data, "env_var", path, _opt(_is_nonempty_str), "a string", None),
+        defined_in=_field(data, "defined_in", path, _opt(_is_nonempty_str), "a string", None),
+    )
+
+
+def _messages_from_dict(data: Any, path: str) -> list[PromptMessage] | None:
+    if data is None:
+        return None
+    if not isinstance(data, list):
+        raise SchemaError(f"{path}: expected a list or null")
+    messages = []
+    for i, item in enumerate(data):
+        item_path = f"{path}[{i}]"
+        if not isinstance(item, dict):
+            raise SchemaError(f"{item_path}: expected an object")
+        _reject_unknown(item, {f.name for f in fields(PromptMessage)}, item_path)
+        messages.append(
+            PromptMessage(
+                role=_field(item, "role", item_path, _is_nonempty_str, "a non-empty string"),
+                content=_field(item, "content", item_path, _is_str, "a string"),
+                resolved=_field(item, "resolved", item_path, _is_bool, "true or false", True),
+            )
+        )
+    return messages
+
+
+def _summary_files(data: dict[str, Any]) -> int:
+    summary = data.get("summary")
+    if isinstance(summary, dict) and _is_nonneg_int(summary.get("files_scanned")):
+        return int(summary["files_scanned"])
+    return 0
+
+
+def _choices(options: frozenset[str]) -> str:
+    return "one of " + ", ".join(sorted(options))
+
+
+def _is_str(value: Any) -> bool:
+    return isinstance(value, str)
+
+
+def _is_nonempty_str(value: Any) -> bool:
+    return isinstance(value, str) and value.strip() != ""
+
+
+def _is_bool(value: Any) -> bool:
+    return isinstance(value, bool)
+
+
+def _is_dict(value: Any) -> bool:
+    return isinstance(value, dict)
+
+
+def _is_number(value: Any) -> bool:
+    return isinstance(value, (int, float)) and not isinstance(value, bool)
+
+
+def _is_positive_int(value: Any) -> bool:
+    return isinstance(value, int) and not isinstance(value, bool) and value >= 1
+
+
+def _is_nonneg_int(value: Any) -> bool:
+    return isinstance(value, int) and not isinstance(value, bool) and value >= 0
+
+
+def _is_str_list(value: Any) -> bool:
+    return isinstance(value, list) and all(isinstance(v, str) for v in value)
+
+
+def _opt(check: Callable[[Any], bool]) -> Callable[[Any], bool]:
+    return lambda value: value is None or check(value)
+
+
+def _one_of(options: frozenset[str]) -> Callable[[Any], bool]:
+    return lambda value: isinstance(value, str) and value in options

downshift/scorer.py

@@ -0,0 +1,219 @@
+"""Score model outputs against eval expectations.
+
+Three gradings, matching the call site's `grading` field:
+  exact        strict string match after normalizing case, whitespace, fences
+               and outer punctuation
+  json_fields  output parsed as a JSON object, graded fields compared one by one
+  judge        a judge model scores the output 1 to 5 against the case rubric
+
+Every scorer returns a Score with a value in [0, 1] and a pass flag, so the
+decide step can treat all gradings the same way.
+"""
+
+from __future__ import annotations
+
+import json
+import re
+from collections.abc import Mapping, Sequence
+from dataclasses import asdict, dataclass
+from typing import Any
+
+from downshift.llm import ChatMessage, LLMClient
+
+JUDGE_PASS_AT = 4
+
+_OUTER_PUNCT = " \t\r\n.,;:!?\"'`*()[]"
+_FENCE = re.compile(r"^```(?:[\w-]+\n)?\s*(.*?)\s*```$", re.DOTALL)
+_SCORE_LABEL = re.compile(r"\bscore\b\s*(?:is|of|=|:)?\s*\**\s*([1-5])(?!\d|\.\d)", re.IGNORECASE)
+_OUT_OF = re.compile(r"(?<![\d.])([1-5])\s*(?:/|out of)\s*5(?!\d)", re.IGNORECASE)
+_LONE = re.compile(r"\s*([1-5])\s*\.?\s*")
+
+JUDGE_SYSTEM = (
+    "You grade the output of an AI assistant inside a customer support app. "
+    "Read the task the assistant was given, its output, and the rubric. "
+    "Score the output from 1 (fails the rubric) to 5 (fully meets it). "
+    'Reply with JSON only: {"score": <1-5>, "reason": "<one sentence>"}.'
+)
+
+
+@dataclass(frozen=True)
+class Score:
+    """Result of scoring one output. value is in [0, 1]."""
+
+    value: float
+    passed: bool
+    detail: str = ""
+    judge_score: int | None = None
+
+    def to_dict(self) -> dict[str, Any]:
+        return asdict(self)
+
+
+@dataclass(frozen=True)
+class Judge:
+    """The model that grades judge-graded call sites."""
+
+    client: LLMClient
+    model: str
+    pass_at: int = JUDGE_PASS_AT
+    max_tokens: int = 200
+
+
+def _clip(text: str, limit: int = 80) -> str:
+    return text if len(text) <= limit else text[: limit - 3] + "..."
+
+
+def strip_fences(text: str) -> str:
+    """Remove a surrounding ``` or ```lang fence, if any."""
+    stripped = text.strip()
+    match = _FENCE.match(stripped)
+    return match.group(1).strip() if match else stripped
+
+
+def normalize_text(text: str) -> str:
+    """Lowercase, collapse whitespace, drop fences and outer punctuation."""
+    collapsed = " ".join(strip_fences(text).split()).lower()
+    return collapsed.strip(_OUTER_PUNCT)
+
+
+def score_exact(output: str, expected: Any) -> Score:
+    got = normalize_text(output)
+    want = normalize_text(str(expected))
+    if got == want:
+        return Score(1.0, True, "match")
+    return Score(0.0, False, f"expected {want!r}, got {_clip(got)!r}")
+
+
+def parse_json_object(text: str) -> dict[str, Any] | None:
+    """Parse a JSON object from model output (fences and surrounding prose allowed)."""
+    body = strip_fences(text)
+    try:
+        data = json.loads(body)
+    except json.JSONDecodeError:
+        start, end = body.find("{"), body.rfind("}")
+        if start == -1 or end <= start:
+            return None
+        try:
+            data = json.loads(body[start : end + 1])
+        except json.JSONDecodeError:
+            return None
+    return data if isinstance(data, dict) else None
+
+
+def _norm_value(value: Any) -> str:
+    if value is None:
+        return ""
+    if isinstance(value, bool):
+        return "true" if value else "false"
+    if isinstance(value, float) and value.is_integer():
+        value = int(value)
+    if isinstance(value, dict | list):
+        return json.dumps(value, sort_keys=True).lower()
+    text = " ".join(str(value).split()).lower()
+    return "" if text in {"null", "none"} else text
+
+
+def score_json_fields(
+    output: str, expected: Mapping[str, Any], fields: Sequence[str] | None = None
+) -> Score:
+    """Compare graded fields. value = fraction matching; passed only if all match."""
+    names = list(fields) if fields else list(expected)
+    if not names:
+        raise ValueError("json_fields grading needs at least one field")
+    data = parse_json_object(output)
+    if data is None:
+        return Score(0.0, False, "output is not a JSON object")
+    wrong: list[str] = []
+    for name in names:
+        if name not in data:
+            wrong.append(f"{name}: missing")
+        elif _norm_value(data[name]) != _norm_value(expected.get(name)):
+            wrong.append(f"{name}: expected {expected.get(name)!r}, got {data[name]!r}")
+    value = (len(names) - len(wrong)) / len(names)
+    detail = "all fields match" if not wrong else "; ".join(wrong)
+    return Score(value, not wrong, detail)
+
+
+def _as_score(raw: Any) -> int | None:
+    if isinstance(raw, bool):
+        return None
+    try:
+        number = float(raw)
+    except (TypeError, ValueError):
+        return None
+    if not number.is_integer() or not 1 <= number <= 5:
+        return None
+    return int(number)
+
+
+def parse_judge_score(text: str) -> int | None:
+    """Pull a 1 to 5 score out of a judge reply. None if there is no clear score."""
+    data = parse_json_object(text)
+    if data is not None and "score" in data:
+        return _as_score(data["score"])
+    for pattern in (_SCORE_LABEL, _OUT_OF):
+        match = pattern.search(text)
+        if match:
+            return int(match.group(1))
+    lone = _LONE.fullmatch(text)
+    return int(lone.group(1)) if lone else None
+
+
+def build_judge_messages(
+    prompt_messages: Sequence[ChatMessage], output: str, rubric: str
+) -> list[dict[str, str]]:
+    task = "\n\n".join(
+        f"[{m.get('role', 'user')}]\n{m.get('content', '')}" for m in prompt_messages
+    )
+    user = (
+        f"## Task given to the assistant\n{task}\n\n"
+        f"## Assistant output\n{output}\n\n"
+        f"## Rubric\n{rubric}\n\n"
+        "Return the JSON now."
+    )
+    return [{"role": "system", "content": JUDGE_SYSTEM}, {"role": "user", "content": user}]
+
+
+def score_judge(
+    judge: Judge, prompt_messages: Sequence[ChatMessage], output: str, rubric: str
+) -> Score:
+    """Ask the judge model for a 1 to 5 score. LLMError propagates to the caller."""
+    if not output.strip():
+        return Score(0.0, False, "empty output")
+    completion = judge.client.complete(
+        judge.model,
+        build_judge_messages(prompt_messages, output, rubric),
+        temperature=0.0,
+        max_tokens=judge.max_tokens,
+        json_mode=True,
+    )
+    score = parse_judge_score(completion.text)
+    if score is None:
+        return Score(0.0, False, f"judge reply unparseable: {_clip(completion.text)!r}")
+    data = parse_json_object(completion.text)
+    reason = str(data.get("reason", "")).strip() if data else ""
+    detail = f"judge {score}/5" + (f": {_clip(reason, 160)}" if reason else "")
+    return Score((score - 1) / 4, score >= judge.pass_at, detail, judge_score=score)
+
+
+def score_case(
+    grading: str,
+    expected: Any,
+    output: str,
+    *,
+    fields: Sequence[str] | None = None,
+    prompt_messages: Sequence[ChatMessage] = (),
+    judge: Judge | None = None,
+) -> Score:
+    """Score one output with the case's grading."""
+    if grading == "exact":
+        return score_exact(output, expected)
+    if grading == "json_fields":
+        if not isinstance(expected, Mapping):
+            raise ValueError("json_fields expected value must be an object")
+        return score_json_fields(output, expected, fields)
+    if grading == "judge":
+        if judge is None:
+            raise ValueError("judge grading needs a Judge")
+        return score_judge(judge, prompt_messages, output, str(expected))
+    raise ValueError(f"unknown grading {grading!r}")

downshift-0.1.0.dev0.dist-info/METADATA

@@ -0,0 +1,24 @@
+Metadata-Version: 2.5
+Name: downshift
+Version: 0.1.0.dev0
+Summary: Cut LLM costs per PR: find every LLM call, prove which can use cheaper models, and show the cost impact of every change.
+Author: Anagha
+License: MIT
+License-File: LICENSE
+Requires-Python: >=3.10
+Requires-Dist: openai>=1.40
+Requires-Dist: pyyaml>=6.0
+Requires-Dist: rich>=13.0
+Requires-Dist: tiktoken>=0.7
+Requires-Dist: typer>=0.12
+Provides-Extra: dev
+Requires-Dist: build>=1.2; extra == 'dev'
+Requires-Dist: mypy>=1.10; extra == 'dev'
+Requires-Dist: pre-commit>=3.7; extra == 'dev'
+Requires-Dist: pytest-cov>=5.0; extra == 'dev'
+Requires-Dist: pytest>=8.0; extra == 'dev'
+Requires-Dist: ruff>=0.6; extra == 'dev'
+Requires-Dist: types-pyyaml; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# downshift

downshift-0.1.0.dev0.dist-info/RECORD

@@ -0,0 +1,21 @@
+downshift/__init__.py,sha256=yDxO5m74Yt4x2i2ppmLKlJNiayqn_H_UnICVGU1Vam4,67
+downshift/audit.py,sha256=_0KpdjGx-N0JaXX4CoU3mvWkqDwj6zrUwWb9lPvS4To,6749
+downshift/cli.py,sha256=uof5rNFfeBvmv4Fxa4CzhL_iUDrS-5uS5kGV0bw60UI,26863
+downshift/config.py,sha256=SjAV4v2AGEpanDkPeVLc2k-RXW1ToP1CxLKprp376hU,12480
+downshift/cost.py,sha256=xRMOKCALznb8S5cmHpdEr-5Rz-KA6RCDgr5noMiEiN4,6778
+downshift/decide.py,sha256=J_g40peYe7cTvwGBSmk2p1nJn8JAW8ZebFTTxN7KgJ8,7356
+downshift/evalgen.py,sha256=-Rw5kTYQkCaMdwd0nElYqb45AE9DB3wuI8YCqx5jdw4,7891
+downshift/evals.py,sha256=Tk3OLu41EEvMUe8a6xpyTFo0pCh-GVc_iQ4jtXUNMZs,14063
+downshift/llm.py,sha256=TNnCdMlt-7r_GJqiWnv2scGf_WbKRHT_SdZRzK2fvxk,5022
+downshift/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+downshift/report.py,sha256=5IFDLEcuRePW6J_ySortMEJBbJ72Wf5vYFhdyyjKYz0,13395
+downshift/resolve.py,sha256=AarZ2vfBFGnky9514MzV839-ecCDHS0wY6_ZrBzt578,17170
+downshift/runner.py,sha256=UoN78kGOFRr0UXAbodVsCMY9ViSc8vS1r84doFvzjBM,10601
+downshift/scanner.py,sha256=rXCMUYUAyQ9fspJYrKfkT9MrHDO5trxbc74rWh1ud_8,11011
+downshift/schema.py,sha256=LCXCyBD8fRouVI3sLL8SnchpUOTXbxHrOrYaJMZ1lHQ,12270
+downshift/scorer.py,sha256=_tN5Fwz5P6rtQUJxoZdkkqUSkBLr105xXyhrKnazYvo,7566
+downshift-0.1.0.dev0.dist-info/METADATA,sha256=QYJp2ueYTnFqmZ7LY_W1EF7FDexQ_V_ZSQ65pfE2J60,777
+downshift-0.1.0.dev0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+downshift-0.1.0.dev0.dist-info/entry_points.txt,sha256=ycLci7nmvEnA_ieGWyiso5hqd3DzK4SkOBg2YrOtGPg,49
+downshift-0.1.0.dev0.dist-info/licenses/LICENSE,sha256=tYT1Vf4Zel79dY5o7HQuPQ5mIxMXow60cgmh_J3mbIc,1077
+downshift-0.1.0.dev0.dist-info/RECORD,,

downshift-0.1.0.dev0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.32.4
+Root-Is-Purelib: true
+Tag: py3-none-any

downshift-0.1.0.dev0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+downshift = downshift.cli:main

downshift-0.1.0.dev0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Anagha Hambir Langhe
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.