cutoptim 1.0.0__py3-none-any.whl

cutoptim/__init__.py

@@ -0,0 +1,13 @@
+"""cutoptim — the official client for the CutOptim Engine API (https://cutoptim.com/engine/reference).
+
+Standard library only (urllib, hmac). Types are generated from the OpenAPI document (types_gen.py).
+
+    from cutoptim import CutOptim
+    client = CutOptim(api_key="co_test_...")
+    plan = client.optimize_2d({"parts": [{"w": 600, "h": 400, "qty": 4}], "stock": [{"w": 2440, "h": 1220}]})
+"""
+from .client import CutOptim, CutOptimError, is_job_accepted
+from .webhooks import verify_webhook, SIGNATURE_HEADER
+
+__version__ = "1.0.0"
+__all__ = ["CutOptim", "CutOptimError", "is_job_accepted", "verify_webhook", "SIGNATURE_HEADER", "__version__"]

cutoptim/client.py

@@ -0,0 +1,155 @@
+"""The CutOptim Engine API client (standard library only).
+
+* Every optimize call carries an Idempotency-Key (yours, or a generated UUID), so retries are never charged twice and
+  never queue a second max job.
+* 429 / 503 / 409 idempotency_in_progress / network errors are retried (default 2 times), honouring Retry-After.
+* A non-2xx answer raises CutOptimError with the API's stable ``code`` — branch on it, never on the message.
+* engine "max" answers 202 with a jobId: ``client.wait_for_job(job_id)`` — or register a webhook.
+"""
+from __future__ import annotations
+
+import json
+import time
+import urllib.error
+import urllib.parse
+import urllib.request
+import uuid
+from typing import Any, Dict, Optional
+
+from . import types_gen as t
+
+_DEFAULT_BASE = "https://api.cutoptim.com"
+
+
+class CutOptimError(Exception):
+    """A non-2xx answer. ``code`` is the stable error (``invalid_request``, ``quota_exceeded``, ...)."""
+
+    def __init__(self, status: int, code: str, message: str, details: Any = None, retry_after: Optional[int] = None):
+        super().__init__(message)
+        self.status = status
+        self.code = code
+        self.details = details
+        self.retry_after = retry_after
+
+
+def is_job_accepted(result: Any) -> bool:
+    """True when an optimize answer is the async 202 of engine "max"."""
+    return isinstance(result, dict) and isinstance(result.get("jobId"), str) and result.get("status") == "queued"
+
+
+class CutOptim:
+    def __init__(self, api_key: Optional[str] = None, base_url: str = _DEFAULT_BASE, max_retries: int = 2, timeout_s: float = 30.0):
+        from . import __version__
+
+        self.api_key = api_key
+        self.base_url = base_url.rstrip("/")
+        self.max_retries = max_retries
+        self.timeout_s = timeout_s
+        self._ua = "cutoptim-engine-python/" + __version__
+
+    # ── optimize (metered) ──
+    def optimize_2d(self, request: t.Optimize2DRequest, idempotency_key: Optional[str] = None) -> Dict[str, Any]:
+        """2D panels. engine "max" returns the 202 job (see wait_for_job)."""
+        return self._call("POST", "/v1/optimize/2d", request, idempotency_key, idempotent=True)
+
+    def optimize_1d(self, request: t.Optimize1DRequest, idempotency_key: Optional[str] = None) -> t.Optimize1DResponse:
+        return self._call("POST", "/v1/optimize/1d", request, idempotency_key, idempotent=True)
+
+    def optimize_wood(self, request: t.OptimizeWoodRequest, idempotency_key: Optional[str] = None) -> t.OptimizeWoodResponse:
+        return self._call("POST", "/v1/optimize/wood", request, idempotency_key, idempotent=True)
+
+    def optimize_nest(self, request: t.OptimizeNestRequest, idempotency_key: Optional[str] = None) -> Dict[str, Any]:
+        """True-shape nesting. engine "max" returns the 202 job."""
+        return self._call("POST", "/v1/optimize/nest", request, idempotency_key, idempotent=True)
+
+    # ── free / account ──
+    def validate_2d(self, request: t.Optimize2DRequest) -> t.ValidateResponse:
+        return self._call("POST", "/v1/validate/2d", request)
+
+    def validate_1d(self, request: t.Optimize1DRequest) -> t.ValidateResponse:
+        return self._call("POST", "/v1/validate/1d", request)
+
+    def validate_wood(self, request: t.OptimizeWoodRequest) -> t.ValidateResponse:
+        return self._call("POST", "/v1/validate/wood", request)
+
+    def validate_nest(self, request: t.OptimizeNestRequest) -> t.ValidateResponse:
+        return self._call("POST", "/v1/validate/nest", request)
+
+    def import_nest(self, request: t.NestImportRequest) -> t.NestImportResponse:
+        return self._call("POST", "/v1/import/nest", request)
+
+    def get_job(self, job_id: str) -> Dict[str, Any]:
+        return self._call("GET", "/v1/jobs/" + urllib.parse.quote(job_id, safe=""))
+
+    def usage(self) -> t.UsageResponse:
+        return self._call("GET", "/v1/usage")
+
+    def health(self) -> t.HealthResponse:
+        return self._call("GET", "/v1/health")
+
+    def wait_for_job(self, job_id: str, timeout_s: float = 300.0, interval_s: float = 2.0) -> Dict[str, Any]:
+        """Poll GET /v1/jobs/{id} (no quota) until the job succeeded or failed."""
+        deadline = time.monotonic() + timeout_s
+        wait = interval_s
+        while True:
+            job = self.get_job(job_id)
+            if job.get("status") in ("succeeded", "failed"):
+                return job
+            if time.monotonic() + wait > deadline:
+                raise CutOptimError(0, "timeout", "job %s is still %s after the wait timeout" % (job_id, job.get("status")))
+            time.sleep(wait)
+            wait = min(wait * 1.5, 10.0)
+
+    # ── transport ──
+    def _call(self, method: str, path: str, body: Any = None, idempotency_key: Optional[str] = None, idempotent: bool = False) -> Any:
+        headers = {"Accept": "application/json", "User-Agent": self._ua}
+        if self.api_key:
+            headers["Authorization"] = "Bearer " + self.api_key
+        data = None
+        if body is not None:
+            headers["Content-Type"] = "application/json"
+            data = json.dumps(body, separators=(",", ":")).encode("utf-8")
+        if idempotent:
+            # One key for the whole call, retries included.
+            headers["Idempotency-Key"] = idempotency_key or str(uuid.uuid4())
+        attempt = 0
+        while True:
+            req = urllib.request.Request(self.base_url + path, data=data, headers=headers, method=method)
+            try:
+                with urllib.request.urlopen(req, timeout=self.timeout_s) as res:
+                    text = res.read().decode("utf-8")
+                    return json.loads(text) if text else None
+            except urllib.error.HTTPError as e:
+                text = e.read().decode("utf-8", "replace")
+                try:
+                    payload = json.loads(text) if text else None
+                except ValueError:
+                    payload = None
+                retry_after = _int(e.headers.get("Retry-After"))
+                code = payload.get("error") if isinstance(payload, dict) and isinstance(payload.get("error"), str) else "http_%d" % e.code
+                retryable = e.code in (429, 503) or (e.code == 409 and code == "idempotency_in_progress")
+                if retryable and attempt < self.max_retries:
+                    time.sleep(_backoff(attempt, retry_after))
+                    attempt += 1
+                    continue
+                message = payload.get("message") if isinstance(payload, dict) and isinstance(payload.get("message"), str) else "HTTP %d" % e.code
+                details = payload.get("details") if isinstance(payload, dict) else None
+                raise CutOptimError(e.code, code, message, details, retry_after) from None
+            except (urllib.error.URLError, TimeoutError, ConnectionError):
+                if attempt >= self.max_retries:
+                    raise
+                time.sleep(_backoff(attempt, None))
+                attempt += 1
+
+
+def _int(v: Optional[str]) -> Optional[int]:
+    try:
+        return int(v) if v else None
+    except ValueError:
+        return None
+
+
+def _backoff(attempt: int, retry_after: Optional[int]) -> float:
+    if retry_after:
+        return float(min(retry_after, 60))
+    return min(0.5 * (2 ** attempt), 8.0)

cutoptim/types_gen.py

@@ -0,0 +1,814 @@
+# GENERATED by scripts/gen-sdks.ts from the CutOptim Engine API OpenAPI document — DO NOT EDIT.
+# contract 1 · spec sha256 d12a371f3242e7b21df0aa4ecf2df4b2f60f8670bbed7e47bbe3d4cbf08678fb · cutoptim 1.0.0
+from __future__ import annotations
+
+from typing import Any, Dict, List, Literal, TypedDict, Union
+
+class WebhookEvent(TypedDict):
+    """One webhook event. Thin on purpose: the plan is read with GET /v1/jobs/{id}, never pushed."""
+    id: str
+    type: Literal["job.succeeded", "job.failed", "webhook.test"]
+    created: int
+    env: Literal["live", "test"]
+    data: Dict[str, Any]
+
+
+class _ValidateResponseRequired(TypedDict):
+    valid: bool
+    mode: Literal["2d", "1d", "wood", "nest"]
+    contractVersion: str
+    parts: Dict[str, Any]
+    stock: Dict[str, Any]
+    warnings: List[str]
+
+
+class ValidateResponse(_ValidateResponseRequired, total=False):
+    """The request is well-formed. No solve ran and no quota was spent."""
+    engineEnabled: bool
+
+
+class _ErrorRequired(TypedDict):
+    error: Literal["invalid_request", "unauthorized", "quota_exceeded", "key_revoked", "too_large", "busy", "service_unavailable", "solve_timeout", "internal", "idempotency_conflict", "idempotency_in_progress"]
+    message: str
+
+
+class Error(_ErrorRequired, total=False):
+    """The error envelope for every failure the engine itself produces."""
+    details: Dict[str, Any]
+
+
+class NotFoundError(TypedDict):
+    """Routing failure. Uses a code (`not_found`) that is intentionally outside the `Error` enum, because it is produced by the router rather than by the API contract."""
+    error: Literal["not_found"]
+    message: str
+
+
+NestPoint = List[float]
+
+NestRing = List["NestPoint"]
+
+class _NestZoneRequired(TypedDict):
+    polygon: "NestRing"
+
+
+class NestZone(_NestZoneRequired, total=False):
+    """An exclusion / inferior-quality zone ON a sheet: a defect, a clamp footprint, a pre-printed area — something the rectangular API cannot express."""
+    quality: int
+
+
+class _NestSourceRequired(TypedDict):
+    content: str
+
+
+class NestSource(_NestSourceRequired, total=False):
+    """Read this part's outline out of an SVG or DXF FILE instead of listing coordinates. The same parser the CutOptim app uses for its Nesting mode runs server-side, so a part library that already exists as CAD files needs no path/arc flattener of your own. **The file replaces ONLY the geometry.** `qty`, `material`, `allowedRotations`, `minQuality`, `priority` and `meta` behave exactly as they do on a `polygon` part. **Exactly ONE outline per source.** Holes are folded in automatically (a ring contained in another becomes a hole), so a typical single-part drawing — outline plus bolt holes — is one outline. A file describing several separate parts is a 400 that names `POST /v1/import/nest`, which splits it. **Nothing is stored.** The bytes exist only as this request body, are parsed in memory and are gone when the response is written: no disk, no database, no temp file, no log line. There is nothing to delete and nothing retained. **Units are reported, never applied.** A DXF may declare `$INSUNITS`; it comes back in `imported.units` and several disagreeing files produce a warning, but coordinates pass through verbatim — this API converts nothing (see the unit rule on `/v1/optimize/nest`)."""
+    format: Literal["svg", "dxf"]
+    filename: str
+    flattenTolerance: float
+
+
+class _NestImportRequestRequired(TypedDict):
+    content: str
+
+
+class NestImportRequest(_NestImportRequestRequired, total=False):
+    """The same four fields `parts[].source` takes, at the top level. See NestSource for the caps, the sniffing rule and the no-storage guarantee."""
+    format: Literal["svg", "dxf"]
+    filename: str
+    flattenTolerance: float
+
+
+class _NestImportedPartRequired(TypedDict):
+    name: str
+    polygon: "NestRing"
+
+
+class NestImportedPart(_NestImportedPartRequired, total=False):
+    """One outline, in exactly the shape a `parts[]` row wants — paste it in and add your own qty / material / rotations."""
+    holes: List["NestRing"]
+
+
+class _NestImportResponseRequired(TypedDict):
+    format: Literal["svg", "dxf"]
+    parts: List["NestImportedPart"]
+    vertices: int
+    warnings: List[str]
+    engineEnabled: bool
+    contractVersion: str
+
+
+class NestImportResponse(_NestImportResponseRequired, total=False):
+    sourceUnit: Literal["mm", "in"]
+
+
+class NestImportSummary(TypedDict):
+    """What the request's `source` files contributed. ABSENT when every part carried `polygon` coordinates, which is what keeps such a request byte-identical to before the feature existed."""
+    parts: int
+    vertices: int
+    units: List[Literal["mm", "in"]]
+
+
+class NestPart(TypedDict, total=False):
+    """A part. Give its outline as `polygon` coordinates OR as a `source` file — exactly one of the two (both, or neither, is a 400)."""
+    name: str
+    polygon: "NestRing"
+    source: "NestSource"
+    holes: List["NestRing"]
+    qty: int
+    allowedRotations: Union[List[float], Literal["continuous"]]
+    minQuality: int
+    priority: bool
+    material: str
+    meta: Dict[str, Any]
+
+
+class NestStock(TypedDict, total=False):
+    """A stock sheet type: either a rectangle (w & h) OR an arbitrary polygon outline (an off-cut remnant). Exactly one of {w & h} | polygon."""
+    w: float
+    h: float
+    polygon: "NestRing"
+    qty: int
+    price: float
+    cost: int
+    material: str
+    exclusions: List["NestZone"]
+    meta: Dict[str, Any]
+
+
+class NestOptions(TypedDict, total=False):
+    """Solve options. All optional."""
+    minSeparation: float
+    edgeClearance: float
+    timeBudgetMs: int
+    seed: int
+    minimizeCost: bool
+    respectStock: bool
+    simplifyTolerance: float
+    compact: bool
+    compactFor: Literal["box", "horizontal", "vertical"]
+
+
+class _OptimizeNestRequestRequired(TypedDict):
+    parts: List["NestPart"]
+    stock: List["NestStock"]
+
+
+class OptimizeNestRequest(_OptimizeNestRequestRequired, total=False):
+    options: "NestOptions"
+    engine: Literal["lbf", "max", "sparrow"]
+    include: List[Literal["svg", "dxf"]]
+
+
+class _PlacedNestPartRequired(TypedDict):
+    name: str
+    sheet: int
+    x: float
+    y: float
+    rotation: float
+
+
+class PlacedNestPart(_PlacedNestPartRequired, total=False):
+    """A placed copy. Carries the rigid transform (rotation THEN translation), not a re-emitted polygon: rotate the input outline by `rotation` about its origin, then add (x, y)."""
+    material: str
+    meta: Dict[str, Any]
+
+
+class _NestSheetRequired(TypedDict):
+    stock: int
+    price: Union[float, None]
+    density: float
+    cutLength: float
+    pierces: int
+    usedWidth: float
+    usedHeight: float
+    usedArea: float
+    parts: List["PlacedNestPart"]
+
+
+class NestSheet(_NestSheetRequired, total=False):
+    w: float
+    h: float
+    polygon: "NestRing"
+    exclusions: List["NestZone"]
+    material: str
+    meta: Dict[str, Any]
+
+
+class NestMetrics(TypedDict):
+    """Job totals."""
+    sheetCount: int
+    density: float
+    placed: int
+    total: int
+    totalPrice: float
+    cutLength: float
+    pierces: int
+
+
+class _NestStockUsageRequired(TypedDict):
+    stock: int
+    sheetCount: int
+    totalPrice: float
+    density: float
+    usedArea: float
+
+
+class NestStockUsage(_NestStockUsageRequired, total=False):
+    """Sheets used per request stock ROW ("quantity per sheet size"). The unit is the row, not the size: two rows with the same w × h but a different price or meta are two entries."""
+    w: float
+    h: float
+    material: str
+
+
+class UnplacedNest(TypedDict):
+    name: str
+    qty: int
+
+
+class NestMaterialSummary(TypedDict):
+    """One material's totals across the sheets cut from it."""
+    material: str
+    sheetCount: int
+    density: float
+    placed: int
+    total: int
+    totalPrice: float
+
+
+class UnmatchedMaterialNest(TypedDict):
+    material: str
+    parts: List["UnplacedNest"]
+
+
+class _OptimizeNestResponseRequired(TypedDict):
+    engine: Literal["lbf", "max"]
+    engineVersion: str
+    contractVersion: str
+    deterministic: bool
+    sheets: List["NestSheet"]
+    metrics: "NestMetrics"
+    stockUsage: List["NestStockUsage"]
+    unplaced: List["UnplacedNest"]
+    warnings: List[str]
+    timing: Dict[str, Any]
+
+
+class OptimizeNestResponse(_OptimizeNestResponseRequired, total=False):
+    materials: List["NestMaterialSummary"]
+    unmatchedMaterials: List["UnmatchedMaterialNest"]
+    imported: "NestImportSummary"
+    svg: str
+    dxf: str
+
+
+class _Part2DRequired(TypedDict):
+    w: float
+    h: float
+
+
+class Part2D(_Part2DRequired, total=False):
+    name: str
+    qty: int
+    rotatable: bool
+    grain: Literal["w", "h"]
+    grainGroup: str
+    priority: bool
+    edgeBanding: Dict[str, Any]
+    material: str
+    meta: Dict[str, Any]
+    id: Any
+
+
+class _MatchedSetRequired(TypedDict):
+    id: Union[str, int]
+    layout: "MatchedSetLayout"
+
+
+class MatchedSet(_MatchedSetRequired, total=False):
+    """Parts cut out of ONE piece of board, side by side or one above the other, exactly one kerf apart, so the figure of the veneer runs on across them (a drawer front over two doors). The set travels through the optimizer as one rectangle — the block — and comes back as its members. Every refusal is a 400 before the quota is reserved; a size mismatch is a warning (`matchedSets[].warnings`), not an error. At most 24 members per set; a part can be in one set only. Engines `heuristic` and `balanced` (which does not rank `priority`, so under `respectStock` a set can lose its place there); `max` refuses a request with sets (400 `details.unsupported`)."""
+    name: str
+    qty: int
+    grain: Literal["w", "h", null]
+    onMiss: Literal["split", "unplaced"]
+    installGap: float
+
+
+class MatchedSetLayout(TypedDict):
+    """Where each member sits, as lines of `parts[].id` values. `rows`: each line is a row of members side by side, the rows stacked top to bottom (`[["DF"], ["DOOR", "DOOR"]]` = a drawer front over two doors). `cols`: each line is a column of members one above the other, the columns side by side. A part may appear more than once in one set. Positions are numbered in reading order: top to bottom, left to right."""
+    dir: Literal["rows", "cols"]
+    lines: List[List[Union[str, int]]]
+
+
+class _Stock2DRequired(TypedDict):
+    w: float
+    h: float
+
+
+class Stock2D(_Stock2DRequired, total=False):
+    qty: int
+    price: float
+    material: str
+    priority: bool
+    grain: Literal["w", "h"]
+    meta: Dict[str, Any]
+
+
+class Trim2D(TypedDict, total=False):
+    """Per-side edge trim removed before nesting. Asymmetric on purpose: a damaged long edge may need more than the others, and a symmetric trim would then give a wrong plan, not merely a worse one. `left` shifts placements right, `top` shifts them down. The sides are those of each sheet as sent — also on a `grain` row whose grain runs the other way."""
+    left: float
+    right: float
+    top: float
+    bottom: float
+
+
+class Options2D(TypedDict, total=False):
+    kerf: float
+    tolerance: float
+    trim: "Trim2D"
+    firstCut: Literal["auto", "horizontal", "vertical"]
+    minimizeCost: bool
+    respectStock: bool
+    minOffcut: float
+    maxCutStages: Union[int, None]
+    minimizeRotations: bool
+    effort: Literal["fast", "balanced"]
+    setOutlines: bool
+
+
+class _Optimize2DRequestRequired(TypedDict):
+    parts: List["Part2D"]
+    stock: List["Stock2D"]
+
+
+class Optimize2DRequest(_Optimize2DRequestRequired, total=False):
+    options: "Options2D"
+    engine: Literal["heuristic", "balanced", "max"]
+    include: List[Literal["cutPlan", "offcuts", "svg", "csv", "dxf", "labels", "planHash", "pdf", "labelsPdf"]]
+    matchedSets: List["MatchedSet"]
+
+
+class _Part1DRequired(TypedDict):
+    length: float
+
+
+class Part1D(_Part1DRequired, total=False):
+    """A linear part. There is no `rotatable` or `grainGroup` in 1D."""
+    name: str
+    qty: int
+    priority: bool
+    material: str
+    meta: Dict[str, Any]
+
+
+class _Stock1DRequired(TypedDict):
+    length: float
+
+
+class Stock1D(_Stock1DRequired, total=False):
+    qty: int
+    price: float
+    material: str
+    priority: bool
+    meta: Dict[str, Any]
+
+
+class Trim1D(TypedDict, total=False):
+    """A bar has two ends, not four edges. `start` is the leading trim (it shifts the first part along the bar, so the first `pos` equals `start`); `end` is the trailing trim."""
+    start: float
+    end: float
+
+
+class Options1D(TypedDict, total=False):
+    """The 1D option set is deliberately smaller: there is no `firstCut`, `maxCutStages` or `minimizeRotations`, because none of them means anything on a bar."""
+    kerf: float
+    tolerance: float
+    trim: "Trim1D"
+    minimizeCost: bool
+    respectStock: bool
+    minOffcut: float
+
+
+class _Optimize1DRequestRequired(TypedDict):
+    parts: List["Part1D"]
+    stock: List["Stock1D"]
+
+
+class Optimize1DRequest(_Optimize1DRequestRequired, total=False):
+    options: "Options1D"
+    engine: Literal["heuristic", "balanced"]
+    include: List[Literal["cutPlan", "offcuts", "svg", "csv", "dxf", "labels", "planHash", "pdf", "labelsPdf"]]
+
+
+class _PartWoodRequired(TypedDict):
+    sw: float
+    sh: float
+    length: float
+
+
+class PartWood(_PartWoodRequired, total=False):
+    """A timber part. Same as a 1D part plus the CROSS-SECTION, which decides which stock it can come out of at all."""
+    name: str
+    qty: int
+    priority: bool
+    material: str
+    meta: Dict[str, Any]
+
+
+class _StockWoodRequired(TypedDict):
+    sw: float
+    sh: float
+    length: float
+
+
+class StockWood(_StockWoodRequired, total=False):
+    name: str
+    qty: int
+    price: float
+    material: str
+    priority: bool
+    meta: Dict[str, Any]
+
+
+class OptionsWood(TypedDict, total=False):
+    """Identical to `Options1D` — a cross-section changes what fits, not how a bar is cut."""
+    kerf: float
+    tolerance: float
+    trim: "Trim1D"
+    minimizeCost: bool
+    respectStock: bool
+    minOffcut: float
+
+
+class _OptimizeWoodRequestRequired(TypedDict):
+    parts: List["PartWood"]
+    stock: List["StockWood"]
+
+
+class OptimizeWoodRequest(_OptimizeWoodRequestRequired, total=False):
+    options: "OptionsWood"
+    engine: Literal["heuristic", "balanced"]
+    include: List[Literal["cutPlan", "offcuts", "svg", "csv", "dxf", "labels", "planHash", "pdf", "labelsPdf"]]
+
+
+class CutStep(TypedDict):
+    """One blade movement, in physically executable order (parent before children: you cannot crosscut a strip before you have ripped it off)."""
+    sheet: int
+    step: int
+    axis: Literal["h", "v"]
+    pos: float
+    length: float
+    stage: int
+
+
+class _PlacedPart2DRequired(TypedDict):
+    name: str
+    x: float
+    y: float
+    w: float
+    h: float
+    rotated: bool
+
+
+class PlacedPart2D(_PlacedPart2DRequired, total=False):
+    """A part on a board. `x`/`y` is its top-left corner measured from the top-left corner of the sheet, `x` growing right and `y` growing downward."""
+    meta: Dict[str, Any]
+    matchedSet: "PlacedMatchedSet"
+
+
+class _PlacedMatchedSetRequired(TypedDict):
+    id: str
+    instance: int
+    position: int
+
+
+class PlacedMatchedSet(_PlacedMatchedSetRequired, total=False):
+    """Present ONLY on a placed member of a matched set (never in a request without `matchedSets`): which set and instance it belongs to and where in it. `position` counts the members in reading order on the cabinet front — top to bottom, left to right — from 1; with the set's `letter` it is the code the `csv` `Position` column and the `svg` labels print (A1, A2 …)."""
+    hint: Literal["left", "middle", "right", "top", "bottom"]
+
+
+class _MatchedSetSummaryRequired(TypedDict):
+    id: str
+    letter: str
+    requested: int
+    asBlock: int
+    split: int
+    unplaced: int
+    block: Dict[str, Any]
+    warnings: List[str]
+
+
+class MatchedSetSummary(_MatchedSetSummaryRequired, total=False):
+    """One requested matched set: what became of its instances. Present ONLY in a request with sets."""
+    name: str
+
+
+class Rect(TypedDict):
+    """A leftover rectangle, in the same coordinate system as the placements."""
+    x: float
+    y: float
+    w: float
+    h: float
+
+
+class _SheetRequired(TypedDict):
+    w: float
+    h: float
+    price: Union[float, None]
+    parts: List["PlacedPart2D"]
+
+
+class Sheet(_SheetRequired, total=False):
+    offcuts: List["Rect"]
+    material: str
+    grain: Literal["w", "h"]
+    meta: Dict[str, Any]
+
+
+class Metrics2D(TypedDict):
+    """Aggregate numbers for the whole job."""
+    sheetCount: int
+    yieldPct: float
+    placed: int
+    total: int
+    cutLines: int
+    sawPasses: int
+    cutLength: float
+    totalPrice: float
+
+
+class Unplaced2D(TypedDict):
+    """Parts that did not fit, aggregated back by name + dimensions."""
+    name: str
+    w: float
+    h: float
+    qty: int
+
+
+class Timing(TypedDict):
+    solveMs: float
+
+
+class EdgeBandingByType(TypedDict):
+    reference: str
+    meters: float
+
+
+class EdgeBandingByPart(TypedDict):
+    name: str
+    meters: float
+    byType: List["EdgeBandingByType"]
+
+
+class LabelEdge(TypedDict):
+    reference: str
+    length: float
+
+
+class _Label2DRequired(TypedDict):
+    sheet: int
+    name: str
+    partNo: int
+    w: float
+    h: float
+    rotated: bool
+    x: float
+    y: float
+
+
+class Label2D(_Label2DRequired, total=False):
+    """Label data for one placed piece. `w`/`h` are the ENTERED size, `rotated` says the piece was turned 90 degrees on the sheet, `x`/`y` equal the placed position in `sheets[sheet].parts`. `edges` are in the entered orientation and list only banded sides."""
+    material: str
+    grain: Literal["w", "h"]
+    edges: Dict[str, Any]
+    meta: Dict[str, Any]
+
+
+class EdgeBanding(TypedDict):
+    """Linear metres of edge banding the order consumes, grouped by the caller-supplied type reference and reported per part AND as an order total. Present ONLY when at least one part requested banding, so a banding-free response omits the key. Exact geometry, no waste margin — the workshop adds its own. ⚠️ The metres ASSUME MILLIMETRE input: top and bottom edges run the part width, left and right run the height, multiplied by qty, divided by 1000. This is the one response figure named for a unit (edge banding is bought by the metre, and the division only means metres in millimetres); in another unit the raw edge length is w/h × qty and these numbers are that divided by 1000. 2D only."""
+    totalMeters: float
+    byType: List["EdgeBandingByType"]
+    byPart: List["EdgeBandingByPart"]
+
+
+class _Optimize2DResponseRequired(TypedDict):
+    engine: Literal["heuristic", "balanced", "max"]
+    engineVersion: str
+    contractVersion: str
+    deterministic: Literal[true]
+    sheets: List["Sheet"]
+    metrics: "Metrics2D"
+    unplaced: List["Unplaced2D"]
+    warnings: List[str]
+    guillotineValid: bool
+    timing: "Timing"
+
+
+class Optimize2DResponse(_Optimize2DResponseRequired, total=False):
+    cutPlan: Union[List["CutStep"], None]
+    edgeBanding: "EdgeBanding"
+    materials: List["MaterialSummary2D"]
+    unmatchedMaterials: List["UnmatchedMaterial2D"]
+    matchedSets: List["MatchedSetSummary"]
+    svg: str
+    csv: str
+    dxf: str
+    labels: List["Label2D"]
+    planHash: str
+    pdf: str
+    labelsPdf: str
+
+
+class MaterialSummary2D(TypedDict):
+    """One material's totals across the sheets cut from it."""
+    material: str
+    sheetCount: int
+    yieldPct: float
+    placed: int
+    total: int
+    totalPrice: float
+
+
+class UnmatchedMaterial2D(TypedDict):
+    """Demand of a material for which the job supplied ZERO stock of that material."""
+    material: str
+    parts: List["Unplaced2D"]
+
+
+class _PlacedPart1DRequired(TypedDict):
+    name: str
+    pos: float
+    length: float
+
+
+class PlacedPart1D(_PlacedPart1DRequired, total=False):
+    meta: Dict[str, Any]
+
+
+class _RodRequired(TypedDict):
+    length: float
+    price: Union[float, None]
+    remaining: float
+    parts: List["PlacedPart1D"]
+
+
+class Rod(_RodRequired, total=False):
+    offcuts: List[float]
+    material: str
+    meta: Dict[str, Any]
+
+
+class Metrics1D(TypedDict):
+    rodCount: int
+    yieldPct: float
+    placed: int
+    total: int
+    cuts: int
+    totalPrice: float
+    toleranceAcceptedCount: int
+
+
+class Unplaced1D(TypedDict):
+    name: str
+    length: float
+    qty: int
+
+
+class _Optimize1DResponseRequired(TypedDict):
+    engine: Literal["heuristic", "balanced"]
+    engineVersion: str
+    contractVersion: str
+    deterministic: Literal[true]
+    rods: List["Rod"]
+    metrics: "Metrics1D"
+    unplaced: List["Unplaced1D"]
+    warnings: List[str]
+    timing: "Timing"
+
+
+class Optimize1DResponse(_Optimize1DResponseRequired, total=False):
+    cutPlan: Union[List["CutStep"], None]
+    materials: List["MaterialSummary1D"]
+    unmatchedMaterials: List["UnmatchedMaterial1D"]
+    csv: str
+    dxf: str
+
+
+class MaterialSummary1D(TypedDict):
+    """One material's totals across the rods cut from it."""
+    material: str
+    rodCount: int
+    yieldPct: float
+    placed: int
+    total: int
+    totalPrice: float
+
+
+class UnmatchedMaterial1D(TypedDict):
+    """Demand of a material for which the job supplied ZERO stock of that material."""
+    material: str
+    parts: List["Unplaced1D"]
+
+
+class WoodCutStep(TypedDict):
+    """A `CutStep` that also names its cross-section. ⚠️ `sheet` is the rod index WITHIN that section, not a job-wide rod counter — pair `section` + `sheet` to locate the bar."""
+    section: str
+
+
+class MetricsSection(TypedDict):
+    """One cross-section's own totals — no need to re-derive them from `rods`."""
+    rodCount: int
+    yieldPct: float
+    placed: int
+    total: int
+    cuts: int
+    totalPrice: float
+
+
+class _WoodSectionRequired(TypedDict):
+    section: str
+    sw: float
+    sh: float
+    stockName: Union[str, None]
+    rods: List["Rod"]
+    metrics: "MetricsSection"
+    unplaced: List["Unplaced1D"]
+
+
+class WoodSection(_WoodSectionRequired, total=False):
+    material: str
+
+
+class _WoodUnmatchedRequired(TypedDict):
+    section: str
+    sw: float
+    sh: float
+    parts: List["Unplaced1D"]
+    qty: int
+
+
+class WoodUnmatched(_WoodUnmatchedRequired, total=False):
+    """Demand for a cross-section you supplied NO stock for. Deliberately separate from `unplaced`: the fix is to declare or buy the material, not to add length or relax a limit."""
+    material: str
+
+
+class MetricsWood(TypedDict):
+    """Job-wide totals across every section."""
+    sectionCount: int
+    rodCount: int
+    yieldPct: float
+    placed: int
+    total: int
+    cuts: int
+    totalPrice: float
+    toleranceAcceptedCount: int
+
+
+class _OptimizeWoodResponseRequired(TypedDict):
+    engine: Literal["heuristic", "balanced"]
+    engineVersion: str
+    contractVersion: str
+    deterministic: Literal[true]
+    sections: List["WoodSection"]
+    unmatched: List["WoodUnmatched"]
+    metrics: "MetricsWood"
+    unplaced: List["Unplaced1D"]
+    warnings: List[str]
+    timing: "Timing"
+
+
+class OptimizeWoodResponse(_OptimizeWoodResponseRequired, total=False):
+    cutPlan: Union[List["WoodCutStep"], None]
+    csv: str
+    dxf: str
+
+
+class _UsageResponseRequired(TypedDict):
+    plan: str
+    used: int
+    limit: int
+    remaining: int
+    periodEnd: str
+    keyPrefix: str
+    contractVersion: str
+
+
+class UsageResponse(_UsageResponseRequired, total=False):
+    env: Literal["test"]
+    keyClass: Literal["tenant"]
+
+
+class _HealthResponseRequired(TypedDict):
+    status: Literal["healthy"]
+    service: Literal["cutoptim-engine"]
+    contractVersion: str
+    engineVersion: str
+    engines: List[Literal["heuristic", "balanced"]]
+    modes: List[Literal["2d", "1d", "wood", "nest"]]
+    uptimeSec: int
+
+
+class HealthResponse(_HealthResponseRequired, total=False):
+    nestEngines: List[Literal["lbf", "max"]]
+    maxEngines: List[Literal["max"]]
+
+

cutoptim/webhooks.py

@@ -0,0 +1,58 @@
+"""Verify a CutOptim webhook delivery (the CutOptim-Signature header).
+
+    CutOptim-Signature: t=<unix seconds>,v1=<hex HMAC-SHA256(secret, "<t>.<raw body>")>[,v1=...]
+
+Pass the RAW request body (the exact bytes received): a body parsed and serialised again does not match. During a
+secret rotation the header carries two v1 values; either matching your secret is enough.
+"""
+from __future__ import annotations
+
+import hashlib
+import hmac
+import re
+import time
+from typing import Iterable, Optional, Union
+
+SIGNATURE_HEADER = "CutOptim-Signature"
+DEFAULT_TOLERANCE_S = 300
+
+_T = re.compile(r"^\d{1,12}$")
+_V1 = re.compile(r"^[0-9a-f]{64}$")
+
+
+def verify_webhook(
+    raw_body: Union[bytes, str],
+    header: Optional[str],
+    secrets: Union[str, Iterable[str]],
+    tolerance_s: int = DEFAULT_TOLERANCE_S,
+    now_s: Optional[int] = None,
+) -> bool:
+    """True when ``header`` signs ``raw_body`` with one of ``secrets`` inside the time window."""
+    if not isinstance(header, str) or len(header) > 4096:
+        return False
+    t: Optional[int] = None
+    v1 = []
+    for part in header.split(","):
+        k, sep, v = part.partition("=")
+        if not sep or not k.strip():
+            return False
+        k, v = k.strip(), v.strip()
+        if k == "t":
+            if t is not None or not _T.match(v):
+                return False
+            t = int(v)
+        elif k == "v1":
+            if not _V1.match(v):
+                return False
+            v1.append(v)
+    if t is None or not v1:
+        return False
+    now = int(time.time()) if now_s is None else now_s
+    if abs(now - t) > tolerance_s:
+        return False
+    body = raw_body.encode("utf-8") if isinstance(raw_body, str) else raw_body
+    for secret in [secrets] if isinstance(secrets, str) else list(secrets):
+        want = hmac.new(secret.encode("utf-8"), str(t).encode("ascii") + b"." + body, hashlib.sha256).hexdigest()
+        if any(hmac.compare_digest(want, got) for got in v1):
+            return True
+    return False

cutoptim-1.0.0.dist-info/METADATA

@@ -0,0 +1,243 @@
+Metadata-Version: 2.5
+Name: cutoptim
+Version: 1.0.0
+Summary: Official client for the CutOptim Engine API — cutting optimization (2D panels, 1D linear, timber, true-shape nesting) over HTTPS.
+Project-URL: Homepage, https://cutoptim.com/engine/reference
+Project-URL: Source, https://github.com/cutoptim/engine-python
+Project-URL: Issues, https://github.com/cutoptim/engine-python/issues
+Author-email: CutOptim <support@cutoptim.com>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: api client,cut list,cutoptim,cutting optimization,nesting,panel saw
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Typing :: Typed
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+
+<p align="center">
+  <a href="https://cutoptim.com/engine"><img src="https://raw.githubusercontent.com/cutoptim/engine-python/main/.github/logo.png" width="88" height="88" alt="CutOptim"></a>
+</p>
+
+<h1 align="center">CutOptim Engine API — Python SDK</h1>
+
+<p align="center">
+  Cutting optimization over HTTPS: <b>2D panels</b>, <b>1D linear</b>, <b>timber</b> and <b>true-shape nesting</b>.<br>
+  Deterministic plans, saw-ready cut sequences — standard library only.
+</p>
+
+<p align="center">
+  <a href="https://pypi.org/project/cutoptim/"><img alt="PyPI" src="https://img.shields.io/pypi/v/cutoptim?color=f0c040&labelColor=0d0f14&label=pypi"></a>
+  <a href="https://github.com/cutoptim/engine-python/actions/workflows/ci.yml"><img alt="CI" src="https://github.com/cutoptim/engine-python/actions/workflows/ci.yml/badge.svg"></a>
+  <img alt="Python 3.9+" src="https://img.shields.io/badge/python-%E2%89%A53.9-f0c040?labelColor=0d0f14">
+  <img alt="Zero dependencies" src="https://img.shields.io/badge/dependencies-0-f0c040?labelColor=0d0f14">
+  <a href="https://github.com/cutoptim/engine-python/blob/main/LICENSE"><img alt="MIT" src="https://img.shields.io/badge/license-MIT-f0c040?labelColor=0d0f14"></a>
+</p>
+
+<p align="center">
+  <a href="https://cutoptim.com/engine/reference/quickstart">Quickstart</a> ·
+  <a href="https://cutoptim.com/engine/reference">API reference</a> ·
+  <a href="https://cutoptim.com/engine/reference/guides/webhooks">Webhooks</a> ·
+  <a href="https://cutoptim.com/engine/reference/changelog">Changelog</a> ·
+  <a href="https://cutoptim.com/dashboard#api-keys">Get an API key</a>
+</p>
+
+---
+
+## Why this SDK
+
+- **Typed from the contract.** Request and response shapes are `TypedDict`s generated from the [OpenAPI 3.1 document](https://cutoptim.com/engine/openapi.json) — mypy and your editor know every field.
+- **No dependencies.** `urllib`, `json` and `hmac` from the standard library; Python 3.9+.
+- **Retries that never cost twice.** Every optimize call carries an `Idempotency-Key`; a retried call returns the stored answer instead of a second charge.
+- **Async jobs without the boilerplate.** `wait_for_job()` polls the `max` engine for you — or let a webhook tell you.
+- **Webhook verification built in.** `verify_webhook()` checks the signature on the raw body, with the replay window and secret rotation handled.
+
+## Install
+
+```bash
+pip install cutoptim
+```
+
+A free **test key** (`co_test_…`, never billed) is enough to build the whole integration — create one on your [dashboard](https://cutoptim.com/dashboard#api-keys).
+
+## Quickstart
+
+```python
+import os
+from cutoptim import CutOptim, is_job_accepted
+
+client = CutOptim(api_key=os.environ["CUTOPTIM_KEY"])
+
+plan = client.optimize_2d({
+    "parts": [
+        {"name": "Side", "w": 720, "h": 560, "qty": 2},
+        {"name": "Shelf", "w": 764, "h": 540, "qty": 3, "rotatable": False},
+    ],
+    "stock": [{"w": 2800, "h": 2070, "price": 48}],
+    "options": {"kerf": 4},
+})
+
+if not is_job_accepted(plan):
+    print(f"{plan['metrics']['sheetCount']} sheet(s), {plan['metrics']['yieldPct']}% yield")
+    for sheet in plan["sheets"]:
+        for p in sheet["parts"]:
+            print(p["name"], p["x"], p["y"], p["w"], p["h"], "rotated" if p["rotated"] else "")
+```
+
+The same input always returns the same plan — cache it, test against it, quote from it.
+
+## Every mode
+
+```python
+# 1D linear — bars, profiles, tubes
+bars = client.optimize_1d({"parts": [{"name": "Rail", "length": 1200, "qty": 6}], "stock": [{"length": 6000}]})
+print(bars["metrics"]["rodCount"], bars["metrics"]["yieldPct"])
+
+# Timber — lengths cut from beams of a given cross-section (sw × sh)
+timber = client.optimize_wood({
+    "parts": [{"name": "Joist", "sw": 45, "sh": 145, "length": 3600, "qty": 4}],
+    "stock": [{"sw": 45, "sh": 145, "length": 4800}],
+})
+
+# True-shape nesting — polygons (or SVG/DXF sources) on sheets
+nest = client.optimize_nest({
+    "parts": [{"name": "Bracket", "polygon": [[0, 0], [120, 0], [120, 40], [40, 120], [0, 120]], "qty": 10}],
+    "stock": [{"w": 1000, "h": 500}],
+})
+if not is_job_accepted(nest):
+    print(nest["metrics"]["sheetCount"], nest["metrics"]["density"])
+```
+
+Check a request without spending a call — the validate endpoints need no key and give the same verdict:
+
+```python
+CutOptim().validate_2d(request)  # {"valid": True, "warnings": [...]} or CutOptimError(400)
+```
+
+## Async `max` jobs
+
+`"engine": "max"` searches harder (seconds to a minute) and answers `202` with a job id instead of a plan:
+
+```python
+accepted = client.optimize_2d({**request, "engine": "max"})
+if is_job_accepted(accepted):
+    job = client.wait_for_job(accepted["jobId"], timeout_s=300)  # polls GET /v1/jobs/{id}, no quota
+    if job["status"] == "succeeded":
+        print(job["result"])
+```
+
+## Webhooks
+
+Instead of polling, register an endpoint on your [dashboard](https://cutoptim.com/dashboard#api-webhooks) and receive a signed `POST` (`job.succeeded` / `job.failed`) when a `max` job finishes. Verify it on the **raw** body:
+
+```python
+# Flask
+from flask import Flask, request
+from cutoptim import verify_webhook
+
+@app.post("/cutoptim/webhook")
+def cutoptim_webhook():
+    if not verify_webhook(request.get_data(), request.headers.get("CutOptim-Signature"), WEBHOOK_SECRET):
+        return "", 400
+    event = request.get_json()   # deduplicate on event["id"] — delivery is at least once
+    return "", 204               # answer within 10 s, then do the work
+```
+
+```python
+# FastAPI
+from fastapi import FastAPI, Request, Response
+
+@app.post("/cutoptim/webhook")
+async def cutoptim_webhook(request: Request):
+    raw = await request.body()
+    if not verify_webhook(raw, request.headers.get("CutOptim-Signature"), WEBHOOK_SECRET):
+        return Response(status_code=400)
+    return Response(status_code=204)
+```
+
+During a secret rotation both secrets sign for 24 hours — pass both: `verify_webhook(raw, header, [new_secret, old_secret])`.
+
+## Retries and idempotency
+
+| Situation | What the client does |
+|---|---|
+| `429 busy`, `503`, network error | retries (2× by default), waiting `Retry-After` when the API sends it |
+| `409 idempotency_in_progress` | retries — the first request is still running; the retry receives its answer |
+| any optimize call | sends an `Idempotency-Key` (a fresh UUID, or yours) — the **same** key on every retry |
+
+Pass your own key to make retries safe across process restarts too:
+
+```python
+client.optimize_nest(request, idempotency_key=f"order-{order_id}")
+```
+
+Within 24 hours the same key and request return the stored answer — not charged again, and a `max` job is not queued twice.
+
+## Errors
+
+Any non-2xx answer raises `CutOptimError`:
+
+```python
+from cutoptim import CutOptimError
+
+try:
+    client.optimize_2d(request)
+except CutOptimError as e:
+    print(e.status, e.code, e.details, e.retry_after)  # branch on e.code, never on the message
+```
+
+| `code` | Status | Meaning |
+|---|---|---|
+| `invalid_request` | 400 | the request is wrong — `details["path"]` names the field; never charged |
+| `unauthorized` | 401 | missing or unknown API key |
+| `quota_exceeded` | 402 | the account's monthly quota is used up — `retry_after` counts to the reset |
+| `key_revoked` | 403 | the key is revoked, or the API subscription is not active |
+| `idempotency_conflict` | 409 | the key was used for a different request — use a new key |
+| `too_large` | 413 | an input cap was exceeded (parts, rows, body size) |
+| `busy` | 429 | at capacity right now — retried automatically |
+| `service_unavailable` | 503 | an engine is not available on this deployment |
+| `solve_timeout` | 504 | the nesting solve ran out of time |
+| `timeout` | — | `wait_for_job()` gave up waiting (the job keeps running) |
+
+A network failure that outlasts the retries is raised as the underlying `urllib.error.URLError`. The full list is on the [errors page](https://cutoptim.com/engine/reference/errors).
+
+## Configuration
+
+```python
+CutOptim(
+    api_key="co_live_…",                   # not needed for health() and validate_*()
+    base_url="https://api.cutoptim.com",   # default
+    max_retries=2,                         # 429 / 503 / 409 in-progress / network errors
+    timeout_s=30.0,                        # per request
+)
+```
+
+## API coverage
+
+| Method | Endpoint | Quota |
+|---|---|---|
+| `optimize_2d(req, idempotency_key=None)` | `POST /v1/optimize/2d` | 1 call |
+| `optimize_1d(req, idempotency_key=None)` | `POST /v1/optimize/1d` | 1 call |
+| `optimize_wood(req, idempotency_key=None)` | `POST /v1/optimize/wood` | 1 call |
+| `optimize_nest(req, idempotency_key=None)` | `POST /v1/optimize/nest` | 1 call |
+| `validate_2d` · `validate_1d` · `validate_wood` · `validate_nest` | `POST /v1/validate/*` | free, no key |
+| `import_nest(req)` | `POST /v1/import/nest` | free (key required) |
+| `get_job(id)` · `wait_for_job(id)` | `GET /v1/jobs/{id}` | free |
+| `usage()` | `GET /v1/usage` | free |
+| `health()` | `GET /v1/health` | free, no key |
+
+## Versioning
+
+The SDK follows semver. The API is `v1` and only grows within it: a new field, endpoint or option arrives as a **minor** SDK release with the regenerated types; nothing you use today is removed or narrowed. See [versioning and stability](https://cutoptim.com/engine/reference/versioning) and the [API changelog](https://cutoptim.com/engine/reference/changelog) (also as RSS).
+
+## Support
+
+- Questions and bugs: [GitHub issues](https://github.com/cutoptim/engine-python/issues) or [support@cutoptim.com](mailto:support@cutoptim.com)
+- Limits and quotas: [cutoptim.com/engine/reference/limits](https://cutoptim.com/engine/reference/limits)
+
+This repository is published from the CutOptim monorepo; pull requests are welcome and applied upstream.
+
+## License
+
+[MIT](https://github.com/cutoptim/engine-python/blob/main/LICENSE) © CutOptim

cutoptim-1.0.0.dist-info/RECORD

@@ -0,0 +1,9 @@
+cutoptim/__init__.py,sha256=Go4xrpFCK531dlftviEX1xyN2QAYIfKhYuxaVDsThMU,651
+cutoptim/client.py,sha256=z-lCy_QWWllyz_6TXRC7U2uWdpD42q2xIH2a4eXYk34,7270
+cutoptim/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+cutoptim/types_gen.py,sha256=HPQqbBTgp_dRlZIVrAtyZIfKB4h9uDAyX4BlJSvqVBI,23662
+cutoptim/webhooks.py,sha256=60TtN4UMbQ_R4H82D17Z1HHZr9crxbfWb1Ox28JwC_Y,2007
+cutoptim-1.0.0.dist-info/METADATA,sha256=fQqd2NbpRUVChNM67b7lYh0fqP8Hpg-km0mTPlgWIwU,10653
+cutoptim-1.0.0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+cutoptim-1.0.0.dist-info/licenses/LICENSE,sha256=Bpdyt9EoiUa2PCUahOsP2JRDVl3r5EuomA6EyxjSgcE,1065
+cutoptim-1.0.0.dist-info/RECORD,,

cutoptim-1.0.0.dist-info/WHEEL

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

cutoptim-1.0.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 CutOptim
+
+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.