designaround-core 0.1.3__py3-none-any.whl

designaround_core/__init__.py

@@ -0,0 +1,4 @@
+"""Shared, dependency-light rules used by the engine, the CLI and the thin server."""
+
+__version__ = "0.1.3"
+SCHEMA_VERSION = 1

designaround_core/catalog.py

@@ -0,0 +1,124 @@
+"""Price catalog (USD). 1 credit = $0.01.
+
+Lean-cost model (decision after v1.2): heavy work runs on the user's machine,
+so the subscription unlocks local features and credits only pay for work that
+costs us money on the server:
+
+* server-side registry screening (ClearComply + image fetch),
+* platform-proxied LLM/VLM tokens (metered: upstream cost x markup),
+* hosted observer scoring when the user runs in host mode,
+* fallback image-to-3D API calls.
+
+BYOK (bring your own model key) and host mode (Claude Code / Codex / Cursor
+supplies the model) consume no LLM credits.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+CREDIT_USD = 0.01
+
+
+@dataclass(frozen=True)
+class Plan:
+    id: str
+    name: str
+    monthly_usd: float
+    annual_usd: float
+    monthly_credits: int
+    seats: int
+    max_active_cases: int | None
+    viewpack_watermark: bool
+    filing_packs: bool
+    batch_limit: int
+    monitors: int
+
+
+PLANS: dict[str, Plan] = {
+    "free": Plan("free", "Free", 0, 0, 300, 1, 1, True, False, 20, 0),
+    "pro": Plan("pro", "Pro", 59, 590, 10_000, 1, 50, False, True, 200, 20),
+    "team": Plan("team", "Team", 189, 1890, 40_000, 5, None, False, True, 1000, 100),
+    "enterprise": Plan("enterprise", "Enterprise", 1000, 12_000, 150_000, 25, None, False, True, 10_000, 1000),
+}
+
+CREDIT_PACKS: dict[str, dict] = {
+    "credits_5k": {"credits": 5_000, "usd": 50},
+    "credits_21k": {"credits": 21_000, "usd": 200},
+    "credits_55k": {"credits": 55_000, "usd": 500},
+    "credits_240k": {"credits": 240_000, "usd": 2_000},
+}
+
+# Fixed-price server actions (credits).
+ACTION_CREDITS: dict[str, int] = {
+    "screen.quick": 50,
+    "screen.deep": 350,
+    "screen.deep.batch": 200,  # per item when >= 100 items
+    "model3d.fallback": 690,  # image-to-mesh API fallback
+    "observe.hosted": 120,  # one hosted observer scoring call (host mode)
+    "concept.image": 25,  # one 2D concept image (GPT Image), charged only when delivered
+    "evidence.anchor": 0,
+    "gate.create": 0,
+}
+
+# Free monthly allowance of quick screens.
+FREE_QUICK_SCREENS_PER_MONTH = 5
+
+# Design-around depth presets (CLI `around --depth`). Credits are what the run is
+# capped at by default; platform runs are metered and usually spend less.
+AROUND_DEPTHS: dict[str, dict] = {
+    "quick": {"rounds": 1, "per_round": 3, "target": 1, "max_credits": 2_900},
+    "standard": {"rounds": 3, "per_round": 3, "target": 2, "max_credits": 5_900},
+    "deep": {"rounds": 6, "per_round": 4, "target": 3, "max_credits": 14_900},
+}
+
+# Result guarantee (FR-ACCT-08): a standard or deep design-around run that ends
+# without any qualified candidate gets this share of its spent credits back,
+# automatically and once per run. View packs are rendered locally and never
+# charged, so re-rendering one an agent returned for format reasons is free.
+GUARANTEE: dict = {
+    "rate": 0.5,
+    "depths": ["standard", "deep"],
+    "min_rounds": 3,
+    "claim_window_days": 7,
+    "max_claims_per_month": 20,
+    "max_credits_per_month": 20_000,
+}
+
+# Platform LLM proxy: credits = ceil(upstream_usd * LLM_MARKUP / CREDIT_USD)
+LLM_MARKUP = 1.25
+
+# Managed packages: platform fee is sold via Creem; practitioner fees are paid
+# by the customer directly to the practitioner (never through the platform).
+MANAGED_PACKAGES: dict[str, dict] = {
+    "managed_cn_around_file": {"platform_usd": 419, "practitioner_usd_est": 140, "offices": ["CN"]},
+    "managed_us_around_file": {"platform_usd": 819, "practitioner_usd_est": 850, "offices": ["US"]},
+    "managed_cn_us_around_file": {"platform_usd": 1099, "practitioner_usd_est": 990, "offices": ["CN", "US"]},
+    "managed_cn_file_only": {"platform_usd": 99, "practitioner_usd_est": 140, "offices": ["CN"]},
+    "managed_us_file_only": {"platform_usd": 249, "practitioner_usd_est": 850, "offices": ["US"]},
+    "managed_risk_opinion": {"platform_usd": 249, "practitioner_usd_est": 420, "offices": []},
+}
+
+
+def credits_for_usd(usd: float) -> int:
+    import math
+
+    return max(0, math.ceil(round(usd / CREDIT_USD, 6)))
+
+
+def plan(plan_id: str) -> Plan:
+    return PLANS.get(plan_id, PLANS["free"])
+
+
+def public_catalog() -> dict:
+    return {
+        "credit_usd": CREDIT_USD,
+        "plans": {k: vars(v) for k, v in PLANS.items()},
+        "credit_packs": CREDIT_PACKS,
+        "actions": ACTION_CREDITS,
+        "llm_markup": LLM_MARKUP,
+        "managed_packages": MANAGED_PACKAGES,
+        "free_quick_screens_per_month": FREE_QUICK_SCREENS_PER_MONTH,
+        "around_depths": AROUND_DEPTHS,
+        "guarantee": GUARANTEE,
+    }

designaround_core/deadlines.py

@@ -0,0 +1,274 @@
+"""Deadline calendar for design filings (FR-FILE-12).
+
+Pure date rules, computed from what the person recorded on the case: filings
+(office, filing date, route), official notices (office action, allowance or grant
+notice, registration) and public disclosures. Every deadline carries its legal
+basis. Official notices state their own time limit; when the person records it
+(``due``), that date wins over the computed one. Non-working days are not moved
+(the Paris Convention and the offices extend a period that ends on a closed day
+to the next working day); practitioners confirm every date.
+
+Rules (2026-10):
+
+* Priority (Paris Convention Art. 4C; 35 U.S.C. 172; CN Patent Law Art. 29;
+  EUDR Art. 41; Hague via Paris): 6 months from the first filing.
+* Own-disclosure grace period: US 1 year (35 U.S.C. 102(b)(1)), EU 12 months
+  (EUDR Art. 7(2)), JP 1 year; CN has no general grace period.
+* US office action: 3-month shortened statutory period, extendable with fees to
+  the 6-month statutory limit (35 U.S.C. 133, 37 CFR 1.134, 1.136(a)).
+  Notice of allowance: issue fee within 3 months, not extendable (35 U.S.C. 151,
+  37 CFR 1.311). Term: 15 years from grant (35 U.S.C. 173); no maintenance fees.
+* CN notice (补正通知书 / 审查意见通知书): 2 months from receipt; a mailed notice
+  is deemed received 15 days after dispatch, an electronic one on dispatch
+  (专利法实施细则第四条). Extension can be requested before expiry (第六条).
+  Grant notice (办理登记手续通知书): 2 months to complete registration and pay
+  the annual fee of the grant year. Patent years run from the filing date; each
+  later year is paid before the previous one ends (the day before the filing
+  anniversary), or within 6 months late with a surcharge. Term: 15 years from filing
+  (专利法第四十二条, applications filed from 2021-06-01).
+* EU (RCD): protection 5 years from filing, renewable to 25. Renewal within the 6
+  months ending on the last day of the month in which protection ends, then 6
+  more months with a surcharge (EUDR Art. 13). Deficiency letters: the period
+  stated in the letter, usually 2 months.
+* Hague (WIPO): standard publication 12 months after the international
+  registration (Common Regulations Rule 17); designated offices may refuse
+  within 6 months of publication (12 months for offices that declared it, such
+  as CN and US); irregularities are remedied within 3 months (Rule 14);
+  renewal every 5 years.
+"""
+
+from __future__ import annotations
+
+import calendar
+import hashlib
+from dataclasses import asdict, dataclass, field
+from datetime import date, datetime, timedelta
+
+PRIORITY_MONTHS = 6
+GRACE_MONTHS = {"US": 12, "EU": 12, "JP": 12}
+REMINDER_DAYS = (30, 14, 7, 1)
+OFFICES = ("US", "CN", "EU", "JP", "HAGUE")
+NOTICE_KINDS = ("office_action", "allowance", "granted")
+HAGUE_LONG_REFUSAL = {"CN", "US", "JP", "KR", "MX", "RU", "SY", "VN", "IL"}
+
+
+def add_months(d: date, months: int) -> date:
+    """Same day number ``months`` later; the month's last day when that day does not exist."""
+
+    total = d.month - 1 + months
+    year, month = d.year + total // 12, total % 12 + 1
+    return date(year, month, min(d.day, calendar.monthrange(year, month)[1]))
+
+
+def end_of_month(d: date) -> date:
+    return date(d.year, d.month, calendar.monthrange(d.year, d.month)[1])
+
+
+@dataclass
+class Deadline:
+    id: str
+    office: str
+    kind: str
+    due: date
+    title_zh: str
+    title_en: str
+    basis: str
+    note_zh: str = ""
+    note_en: str = ""
+    hard: bool = True  # missing it loses a right (vs. an informational milestone)
+    source: dict = field(default_factory=dict)
+
+    def to_dict(self, today: date | None = None) -> dict:
+        out = asdict(self)
+        out["due"] = self.due.isoformat()
+        if today is not None:
+            out["days_left"] = (self.due - today).days
+        return out
+
+
+def _d(value) -> date:
+    return value if isinstance(value, date) else date.fromisoformat(str(value)[:10])
+
+
+def _uid(*parts) -> str:
+    return hashlib.sha1("|".join(str(p) for p in parts).encode("utf-8")).hexdigest()[:16]
+
+
+def compute(*, offices: list[str], filings: list[dict], notices: list[dict], disclosures: list[dict], matters: list[dict] | None = None) -> list[Deadline]:
+    """All deadlines for one case, sorted by date."""
+
+    offices = [o.upper() for o in offices]
+    out: list[Deadline] = []
+
+    # Complaints and lawsuits (FR-DEF-06): a US court answer is due 21 days after service.
+    for m in matters or []:
+        ref = {"matter": m.get("id"), "number": m.get("number")}
+        if m.get("route") == "court_tro" and m.get("served"):
+            served = _d(m["served"])
+            out.append(Deadline(_uid("answer", m.get("id"), served), "US", "court_answer", served + timedelta(days=21), f"诉讼答辩期限（{m.get('number') or '案件'}，送达后 21 天）", f"Answer due ({m.get('number') or 'lawsuit'}, 21 days after service)", "FRCP 12(a)(1)(A)(i)", "放弃送达（waiver）时为发出请求后 60 天；法院命令里的日期优先。请立即联系美国诉讼律师。", "60 days after the waiver request was sent if service was waived; dates in a court order prevail. Contact US litigation counsel now.", source=ref))
+        if m.get("hearing"):
+            out.append(Deadline(_uid("hearing", m.get("id"), m["hearing"]), "US" if m.get("route") == "court_tro" else (m.get("platform") or "").upper() or "US", "hearing", _d(m["hearing"]), f"听证 / 回复期限（{m.get('number') or ''}）", f"Hearing / response date ({m.get('number') or ''})", "court order / notice", "以法院命令或平台通知写明的日期为准。", "The date in the court order or platform notice applies.", source=ref))
+        if m.get("respond_by"):
+            out.append(Deadline(_uid("respond", m.get("id"), m["respond_by"]), (m.get("platform") or "platform").upper(), "complaint_response", _d(m["respond_by"]), f"平台投诉回复期限（{m.get('number') or ''}）", f"Platform complaint response ({m.get('number') or ''})", "platform notice", "以平台通知写明的期限为准。", "The time limit in the platform notice applies.", source=ref))
+    by_office = {}
+    for f in sorted(filings, key=lambda f: _d(f["filed"])):
+        by_office.setdefault(f["office"].upper(), f)
+    filed_offices = set(by_office)
+
+    # Priority: 6 months from the first filing anywhere, for every target office not filed yet.
+    if filings:
+        first = min(filings, key=lambda f: _d(f["filed"]))
+        first_date = _d(first["filed"])
+        missing = [o for o in offices if o not in filed_offices]
+        due = add_months(first_date, PRIORITY_MONTHS)
+        out.append(Deadline(
+            _uid("priority", first_date), first["office"].upper(), "priority", due,
+            f"优先权期限：{'、'.join(missing) if missing else '其他法域'}要求 {first['office'].upper()} 首次申请的优先权",
+            f"Priority deadline: file {', '.join(missing) if missing else 'other offices'} claiming the {first['office'].upper()} first filing",
+            "Paris Convention Art. 4C; 35 U.S.C. 172; CN Patent Law Art. 29; EUDR Art. 41",
+            "6 个月内在其他法域申请才能享有优先权；最后一天遇官方非工作日顺延到下一个工作日。" + ("（目标法域都已申请）" if not missing else ""),
+            "File within 6 months to keep the first filing date; a closed office day moves the end to the next working day." + (" (All target offices are filed.)" if not missing else ""),
+            hard=bool(missing), source={"filing": first.get("number") or first_date.isoformat()},
+        ))
+
+    # Own disclosures: file-by dates inside the grace period.
+    own = [x for x in disclosures if x.get("by_applicant", True)]
+    if own:
+        earliest = min(own, key=lambda x: _d(x["date"]))
+        when = _d(earliest["date"])
+        for office in offices:
+            if office in filed_offices:
+                continue
+            if office in GRACE_MONTHS:
+                out.append(Deadline(
+                    _uid("grace", office, when), office, "grace", add_months(when, GRACE_MONTHS[office]),
+                    f"{office} 宽限期内最晚申请日（自己 {when.isoformat()} 的公开）",
+                    f"{office}: last filing day inside the grace period (own disclosure on {when.isoformat()})",
+                    "35 U.S.C. 102(b)(1)" if office == "US" else "EUDR Art. 7(2)" if office == "EU" else "JP Design Act Art. 4",
+                    "超过这一天，自己的公开会破坏新颖性。", "After this day your own disclosure destroys novelty.",
+                    source={"disclosure": earliest.get("kind"), "date": when.isoformat()},
+                ))
+
+    # Term and renewal milestones from filings.
+    for office, f in by_office.items():
+        filed = _d(f["filed"])
+        if office == "EU":
+            for n in range(1, 5):
+                ends = add_months(filed, 60 * n)
+                last = end_of_month(ends)
+                out.append(Deadline(
+                    _uid("eu-renew", filed, n), "EU", "renewal", last,
+                    f"欧盟外观第 {n} 次续展截止（保护到 {ends.isoformat()}）",
+                    f"EU design renewal {n} (protection ends {ends.isoformat()})",
+                    "EUDR Art. 13",
+                    f"续展窗口 {add_months(date(last.year, last.month, 1), -5)} 起；之后 6 个月内可加滞纳金补办（到 {end_of_month(add_months(last, 6))}）。",
+                    f"Window opens {add_months(date(last.year, last.month, 1), -5)}; 6 more months with a surcharge (to {end_of_month(add_months(last, 6))}).",
+                    source={"filing": f.get("number") or filed.isoformat()},
+                ))
+        if office == "CN":
+            out.append(Deadline(_uid("cn-term", filed), "CN", "term", add_months(filed, 180) - timedelta(days=1), "中国外观专利权期满（申请日起 15 年）", "CN design term ends (15 years from filing)", "CN Patent Law Art. 42", hard=False, source={"filing": f.get("number") or filed.isoformat()}))
+        if office == "HAGUE" or f.get("route") == "hague":
+            reg = filed
+            pub = add_months(reg, 12)
+            out.append(Deadline(_uid("hague-pub", reg), "HAGUE", "publication", pub, "海牙国际注册标准公布日（国际注册日起 12 个月）", "Hague standard publication (12 months after international registration)", "Hague Common Regulations Rule 17", "可以申请立即公布或延迟公布（最长 30 个月）。", "Immediate or deferred publication (up to 30 months) can be requested.", hard=False))
+            designated = [o for o in (f.get("designated") or offices) if o != "HAGUE"]
+            long = [o for o in designated if o in HAGUE_LONG_REFUSAL]
+            short = [o for o in designated if o not in HAGUE_LONG_REFUSAL]
+            if short:
+                out.append(Deadline(_uid("hague-ref6", reg), "HAGUE", "refusal_period", add_months(pub, 6), f"海牙：{'、'.join(short)} 驳回期届满（公布后 6 个月）", f"Hague: refusal period ends for {', '.join(short)} (6 months after publication)", "Hague Agreement (1999) Art. 12; Rule 18", "期满没有收到驳回，视为在该国获得保护。", "No refusal by then: protection in that office.", hard=False))
+            if long:
+                out.append(Deadline(_uid("hague-ref12", reg), "HAGUE", "refusal_period", add_months(pub, 12), f"海牙：{'、'.join(long)} 驳回期届满（公布后 12 个月）", f"Hague: refusal period ends for {', '.join(long)} (12 months after publication)", "Hague Agreement (1999) Art. 12; Rule 18(1)(b)", "这些国家声明了 12 个月的驳回期。", "These offices declared a 12-month refusal period.", hard=False))
+            for n in range(1, 3):
+                out.append(Deadline(_uid("hague-renew", reg, n), "HAGUE", "renewal", add_months(reg, 60 * n), f"海牙国际注册第 {n} 次续展（每 5 年）", f"Hague renewal {n} (every 5 years)", "Hague Agreement (1999) Art. 17", "到期后 6 个月内可加滞纳金续展。", "Up to 6 months late with a surcharge.", source={"registration": f.get("number") or reg.isoformat()}))
+
+    # Official notices.
+    for n in notices:
+        office = n["office"].upper()
+        kind = n["kind"]
+        issued = _d(n["date"])
+        mailed = bool(n.get("mailed"))
+        received = issued + timedelta(days=15) if (office == "CN" and mailed) else issued
+        given = _d(n["due"]) if n.get("due") else None
+        ref = {"notice": n.get("number") or kind, "date": issued.isoformat()}
+        filed = _d(by_office[office]["filed"]) if office in by_office else None
+        if kind == "office_action":
+            if office == "US":
+                out.append(Deadline(_uid("us-oa3", issued), "US", "response", given or add_months(issued, 3), "美国审查意见答复（3 个月，不交延期费）", "US office action reply (3 months, no extension fee)", "37 CFR 1.134, 1.136(a)", "可交延期费延到 6 个月。", "Extendable with fees up to 6 months.", source=ref))
+                out.append(Deadline(_uid("us-oa6", issued), "US", "response_final", add_months(issued, 6), "美国审查意见答复法定最晚期限（6 个月，需延期费）", "US office action statutory limit (6 months, with extension fees)", "35 U.S.C. 133", "过期不答复，申请视为放弃。", "Missing it abandons the application.", source=ref))
+            elif office == "CN":
+                out.append(Deadline(_uid("cn-oa", issued), "CN", "response", given or add_months(received, 2), "中国审查意见 / 补正通知答复", "CN office action / correction reply", "专利法实施细则第四条、第六条", ("邮寄送达按发文日加 15 天推定收到；" if mailed else "电子送达以发文日为收到日；") + "可以在期满前请求延长期限。", ("Mailed: deemed received 15 days after dispatch; " if mailed else "Electronic: received on dispatch; ") + "an extension can be requested before expiry.", source=ref))
+            elif office == "HAGUE":
+                out.append(Deadline(_uid("hg-irr", issued), "HAGUE", "response", given or add_months(issued, 3), "海牙：WIPO 不规范通知答复（3 个月）", "Hague: WIPO irregularity reply (3 months)", "Hague Common Regulations Rule 14", source=ref))
+            else:
+                out.append(Deadline(_uid(office.lower() + "-oa", issued), office, "response", given or add_months(issued, 2), f"{office} 官方通知答复", f"{office} official notice reply", "period stated in the notice", "以通知书写明的期限为准。", "The period stated in the notice applies.", source=ref))
+        elif kind == "allowance":
+            if office == "US":
+                out.append(Deadline(_uid("us-issue", issued), "US", "issue_fee", given or add_months(issued, 3), "美国授权费（Issue fee）缴纳截止", "US issue fee due", "35 U.S.C. 151; 37 CFR 1.311", "3 个月，不能延期；过期申请视为放弃。", "3 months, not extendable; missing it abandons the application.", source=ref))
+            elif office == "CN":
+                out.append(Deadline(_uid("cn-reg", issued), "CN", "registration", given or add_months(received, 2), "中国办理登记手续并缴纳第一年年费", "CN registration formalities and first annual fee", "专利法实施细则（办理登记手续）", "期满未办理视为放弃取得专利权。", "Missing it forfeits the patent.", source=ref))
+            else:
+                out.append(Deadline(_uid(office.lower() + "-allow", issued), office, "registration", given or add_months(issued, 2), f"{office} 授权后续手续", f"{office} post-allowance step", "period stated in the notice", source=ref))
+        elif kind == "granted":
+            if office == "US":
+                out.append(Deadline(_uid("us-term", issued), "US", "term", add_months(issued, 180), "美国外观专利权期满（授权日起 15 年，无维持费）", "US design term ends (15 years from grant; no maintenance fees)", "35 U.S.C. 173", hard=False, source=ref))
+            elif office == "CN" and filed:
+                year = 2
+                anniversary = add_months(filed, 12 * (year - 1))
+                while anniversary <= issued:  # fees for the grant year are paid at registration
+                    year += 1
+                    anniversary = add_months(filed, 12 * (year - 1))
+                for k in range(3):
+                    # Patent years run from the filing date; year N is paid before year N-1 ends.
+                    due = add_months(filed, 12 * (year - 1 + k)) - timedelta(days=1)
+                    if due >= add_months(filed, 180) - timedelta(days=1):
+                        break
+                    out.append(Deadline(_uid("cn-annual", filed, year + k), "CN", "annual_fee", due, f"中国外观第 {year + k} 年年费", f"CN design annual fee, year {year + k}", "专利法实施细则（年费）", f"可在 6 个月内加滞纳金补缴（到 {add_months(due, 6)}）。", f"Payable late within 6 months with a surcharge (to {add_months(due, 6)}).", source=ref))
+    return sorted(out, key=lambda d: (d.due, d.office, d.kind))
+
+
+# ------------------------------------------------------------------- iCalendar
+
+
+def _ics_text(text: str) -> str:
+    return text.replace("\\", "\\\\").replace(";", "\\;").replace(",", "\\,").replace("\r\n", "\\n").replace("\n", "\\n")
+
+
+def _fold(line: str) -> list[str]:
+    """RFC 5545 3.1: lines longer than 75 octets continue on the next line after a space."""
+
+    out, current = [], ""
+    for ch in line:
+        if len((current + ch).encode("utf-8")) > (75 if not out else 74):
+            out.append(current)
+            current = ch
+        else:
+            current += ch
+    out.append(current)
+    return [out[0]] + [" " + part for part in out[1:]]
+
+
+def to_ics(deadlines: list[Deadline], *, calendar_name: str, lang: str = "zh", reminders: tuple[int, ...] = REMINDER_DAYS, now: datetime | None = None) -> str:
+    zh = lang != "en"
+    stamp = (now or datetime.utcnow()).strftime("%Y%m%dT%H%M%SZ")
+    lines = ["BEGIN:VCALENDAR", "VERSION:2.0", "PRODID:-//DesignAround//Deadlines//" + ("ZH" if zh else "EN"), "CALSCALE:GREGORIAN", "METHOD:PUBLISH", f"X-WR-CALNAME:{_ics_text(calendar_name)}"]
+    for d in deadlines:
+        title = d.title_zh if zh else d.title_en
+        note = d.note_zh if zh else d.note_en
+        desc = "\n".join(x for x in [note, ("依据：" if zh else "Basis: ") + d.basis, "请执业代理人确认期限；这不是法律意见。" if zh else "Have a registered practitioner confirm; not legal advice."] if x)
+        lines += [
+            "BEGIN:VEVENT",
+            f"UID:{d.id}@designaround",
+            f"DTSTAMP:{stamp}",
+            f"DTSTART;VALUE=DATE:{d.due.strftime('%Y%m%d')}",
+            f"DTEND;VALUE=DATE:{(d.due + timedelta(days=1)).strftime('%Y%m%d')}",
+            f"SUMMARY:{_ics_text(('[' + d.office + '] ') + title)}",
+            f"DESCRIPTION:{_ics_text(desc)}",
+            "TRANSP:TRANSPARENT",
+            f"CATEGORIES:DesignAround,{d.office},{d.kind}",
+        ]
+        if d.hard:
+            for days in reminders:
+                lines += ["BEGIN:VALARM", "ACTION:DISPLAY", f"DESCRIPTION:{_ics_text(title)}", f"TRIGGER:-P{days}D", "END:VALARM"]
+        lines.append("END:VEVENT")
+    lines.append("END:VCALENDAR")
+    return "\r\n".join(part for line in lines for part in _fold(line)) + "\r\n"

designaround_core/fees.py

@@ -0,0 +1,77 @@
+"""Official design-application fees and terms (versioned data, review quarterly).
+
+Sources (2026): USPTO design fees per UpCounsel/Patsnap summaries of the
+current fee schedule; CNIPA design application fee 500 CNY with up to 85% fee
+reduction. Practitioners must confirm before filing.
+"""
+
+from __future__ import annotations
+
+FEE_TABLE_VERSION = "2026-10"
+CNY_PER_USD = 7.1  # display reference only
+
+US_DESIGN = {
+    # filing + search + examination
+    "application": {"large": 1300, "small": 520, "micro": 260},
+    "issue": {"large": 1300, "small": 520, "micro": 260},
+    "currency": "USD",
+}
+
+CN_DESIGN = {
+    "application": 500,
+    "fee_reduction_rate": 0.85,
+    "currency": "CNY",
+}
+# EUIPO since 1 May 2025 (EUDR as amended): one application fee that replaced
+# registration + publication fees; EUR 125 for each additional design in a
+# multiple application; deferment of publication from EUR 40.
+EU_DESIGN = {"application": 350, "additional_design": 125, "deferment": 40, "currency": "EUR"}
+USD_PER_EUR = 1.08  # display reference only
+
+TERMS = {
+    "US": {"years": 15, "from": "grant"},
+    "CN": {"years": 15, "from": "filing"},
+    "JP": {"years": 25, "from": "filing"},
+    "EU": {"years": 25, "from": "filing", "note": "renewable every 5 years"},
+}
+
+PRIORITY_MONTHS_DESIGN = 6
+
+
+def us_official_fees(entity: str = "small") -> dict:
+    entity = entity if entity in US_DESIGN["application"] else "large"
+    return {
+        "office": "US",
+        "currency": "USD",
+        "entity": entity,
+        "application": US_DESIGN["application"][entity],
+        "issue_on_allowance": US_DESIGN["issue"][entity],
+        "usd_now": US_DESIGN["application"][entity],
+    }
+
+
+def cn_official_fees(fee_reduction: bool = False) -> dict:
+    amount = CN_DESIGN["application"] * (1 - CN_DESIGN["fee_reduction_rate"]) if fee_reduction else CN_DESIGN["application"]
+    return {
+        "office": "CN",
+        "currency": "CNY",
+        "fee_reduction": fee_reduction,
+        "application": round(amount, 2),
+        "usd_now": round(amount / CNY_PER_USD, 2),
+    }
+
+
+def eu_official_fees(additional_designs: int = 0) -> dict:
+    amount = EU_DESIGN["application"] + EU_DESIGN["additional_design"] * max(0, additional_designs)
+    return {"office": "EU", "currency": "EUR", "application": amount, "additional_designs": max(0, additional_designs), "usd_now": round(amount * USD_PER_EUR, 2)}
+
+
+def official_fees(office: str, *, entity: str = "small", fee_reduction: bool = False) -> dict:
+    office = office.upper()
+    if office == "US":
+        return us_official_fees(entity)
+    if office == "CN":
+        return cn_official_fees(fee_reduction)
+    if office == "EU":
+        return eu_official_fees()
+    return {"office": office, "currency": None, "application": None, "usd_now": None, "note": "fee table not available yet"}

designaround_core/observer.py

@@ -0,0 +1,108 @@
+"""The isolated observer's rubric. One source of truth for the hosted observer
+(server), the BYOK observer (embedded Pi Agent) and host mode.
+
+The observer never sees the designer's rationale; it only sees the candidate
+views, the prior-art figures and the claimed-scope notes.
+"""
+
+from __future__ import annotations
+
+import json
+import re
+
+RUBRIC_VERSION = "observer-2026.10-2"
+
+SYSTEM_PROMPT = """You are an independent visual reviewer who imitates the "ordinary observer" used when comparing a product design with a registered design (US design patent / CN design patent / EU registered design).
+
+You receive ONE comparison sheet for ONE prior-art right:
+- top row "CANDIDATE": line drawings of the candidate product (perspective, front, right side, top);
+- bottom row "PRIOR ART": the figures of the registered design (views may be in a different order or orientation).
+You may also receive notes on what the prior art claims (solid lines are claimed; broken lines are not claimed; CN partial designs claim only the indicated portion).
+
+How to judge:
+1. Compare only the claimed portions of the prior art. Ignore broken-line (dashed) environment.
+2. Judge the overall visual impression of the product as a whole, across all views. Match views by content, not by position on the sheet.
+3. Give little weight to features that almost every product of this type has (for a storage box: a rectangular or rounded-rectangular footprint, a lid, flat side walls) and to features dictated by function. Give most weight to the features that make the prior art distinctive: its proportions, the form of its lid, handles, rims, feet, ribs, surface patterns and profile lines.
+4. Small changes to corner radii, chamfers, scale or colour do not change the overall impression.
+5. If the field is crowded with similar registered designs, smaller differences are enough to create a different impression; if the prior art is distinctive, the candidate must differ in the distinctive features.
+6. Never state that a design "does not infringe", is "safe" or is "guaranteed". You produce a risk score for a professional to review.
+
+Score anchors (10 = substantially the same to an ordinary observer):
+- 9-10: same design; differences only visible on close side-by-side study.
+- 7-8: same overall impression with minor differences.
+- 5-6: shares the main design concept, but at least one distinctive feature clearly differs.
+- 3-4: different overall impression; shares the general product concept and some secondary features.
+- 0-2: clearly different designs; shared features are only those common to products of this type.
+
+Return ONLY a JSON object:
+{"score": <0-10 number>,
+ "similar": ["<top shared visual features, max 3>"],
+ "different": ["<top differences, max 3>"],
+ "distinctive_features_of_prior_art": ["<max 3>"],
+ "uncertain": "<what could change the score, e.g. hidden views, scope unclear>"}"""
+
+USER_TEMPLATE = """Product type: {article}
+Prior art: {number} ({office}) — {title}
+Claimed-scope notes: {scope}
+Field: {field_size} other registered designs of this product type were found in screening.
+Candidate version: {version}; sheet: {view}
+Score how similar the overall visual impression of the candidate is to the CLAIMED design of the prior art."""
+
+
+def user_prompt(*, number: str, office: str | None, title: str | None, scope: str | None, version: str, view: str, article: str | None = None, field_size: int | None = None) -> str:
+    return USER_TEMPLATE.format(
+        article=article or "consumer product",
+        number=number,
+        office=office or "?",
+        title=title or "",
+        scope=scope or "none provided; assume solid lines are claimed",
+        field_size=field_size if field_size is not None else "unknown",
+        version=version,
+        view="multi-view comparison sheet" if view == "multi" else f"single view ({view})",
+    )
+
+
+def parse_reply(text: str) -> dict:
+    """Extract the JSON object from a model reply and validate the score."""
+
+    match = re.search(r"\{.*\}", text or "", re.S)
+    if not match:
+        raise ValueError("observer reply has no JSON object")
+    data = json.loads(match.group(0))
+    score = float(data.get("score"))
+    if not 0 <= score <= 10:
+        raise ValueError("observer score out of range")
+    data["score"] = score
+    for key in ("similar", "different", "distinctive_features_of_prior_art"):
+        value = data.get(key) or []
+        data[key] = [str(v) for v in value][:3] if isinstance(value, list) else [str(value)]
+    data["rubric_version"] = RUBRIC_VERSION
+    return data
+
+
+SAMPLES = 3  # independent judgments per comparison; the median is used
+
+
+def combine(samples: list[dict]) -> dict:
+    """Median of independent judgments (single VLM judgments vary by +-2 points).
+
+    The reported lists come from the judgment closest to the median.
+    """
+
+    if not samples:
+        raise ValueError("no observer samples")
+    scores = sorted(float(s["score"]) for s in samples)
+    n = len(scores)
+    median = scores[n // 2] if n % 2 else (scores[n // 2 - 1] + scores[n // 2]) / 2
+    pick = min(samples, key=lambda s: abs(float(s["score"]) - median))
+    return {
+        **pick,
+        "score": round(median, 2),
+        "samples": [float(s["score"]) for s in samples],
+        "spread": round(scores[-1] - scores[0], 2),
+        "rubric_version": RUBRIC_VERSION,
+    }
+
+
+def rubric() -> dict:
+    return {"version": RUBRIC_VERSION, "system": SYSTEM_PROMPT, "user_template": USER_TEMPLATE}

designaround_core/quote.py

@@ -0,0 +1,63 @@
+"""Three-way quotes: official fee + practitioner fee (paid directly) + platform fee."""
+
+from __future__ import annotations
+
+from . import catalog, fees
+
+
+def filing_quote(
+    offices: list[str],
+    *,
+    managed: bool = False,
+    design_around: bool = True,
+    entity: str = "small",
+    fee_reduction: bool = False,
+    similar_designs: int = 0,
+) -> dict:
+    offices = [o.upper() for o in offices]
+    lines = []
+    total_usd = 0.0
+    for office in offices:
+        official = fees.official_fees(office, entity=entity, fee_reduction=fee_reduction)
+        lines.append({"kind": "official_fee", "office": office, "paid_to": "patent office via practitioner", "method": "via_practitioner", **official})
+        total_usd += official.get("usd_now") or 0
+    platform_usd = 0.0
+    practitioner_usd = 0.0
+    package = None
+    if managed:
+        key = "_".join(sorted(o.lower() for o in offices))
+        package_id = {
+            ("cn", True): "managed_cn_around_file",
+            ("us", True): "managed_us_around_file",
+            ("cn_us", True): "managed_cn_us_around_file",
+            ("cn", False): "managed_cn_file_only",
+            ("us", False): "managed_us_file_only",
+        }.get((key, design_around))
+        if package_id:
+            package = {"id": package_id, **catalog.MANAGED_PACKAGES[package_id]}
+            platform_usd = package["platform_usd"]
+            practitioner_usd = package["practitioner_usd_est"]
+    lines.append({"kind": "platform_fee", "usd": platform_usd, "paid_to": "DesignAround via Creem (Merchant of Record)", "method": "creem", "package": package})
+    lines.append({"kind": "practitioner_fee", "usd_estimate": practitioner_usd, "paid_to": "registered practitioner / licensed agency", "method": "direct", "note": "Paid directly by the customer under the practitioner's engagement letter. Never routed through DesignAround."})
+    total_usd += platform_usd + practitioner_usd
+    if "EU" in offices and similar_designs:
+        lines[offices.index("EU")] = {**lines[offices.index("EU")], **fees.eu_official_fees(similar_designs)}
+        total_usd += fees.eu_official_fees(similar_designs)["usd_now"] - fees.eu_official_fees()["usd_now"]
+    timeline = {
+        "CN": "初步审查，通常约 4–8 个月授权（以 CNIPA 实际为准）",
+        "US": "审查周期通常 18 个月以上；外观加急审查已于 2025 年取消",
+        "EU": "EUIPO 只做形式审查，无缺陷时通常数周内注册",
+    }
+    notes = []
+    if "CN" in offices and similar_designs:
+        notes.append(f"CN 合案：主方案 + {similar_designs} 项相似设计（同一件申请，最多 10 项）。")
+    if "CN" in offices and "US" in offices:
+        notes.append(f"先报 CN，再在 {fees.PRIORITY_MONTHS_DESIGN} 个月内要求优先权报 US。")
+    return {
+        "fee_table_version": fees.FEE_TABLE_VERSION,
+        "offices": offices,
+        "lines": lines,
+        "total_usd_estimate": round(total_usd, 2),
+        "timeline": {o: timeline.get(o, "") for o in offices},
+        "notes": notes,
+    }

designaround_core/rules.py

@@ -0,0 +1,129 @@
+"""Versioned legal-process rules: representation, disclosure timeline, titles.
+
+Each rule carries an id and a basis so every decision written into a case can
+be traced to the rule version that produced it. Rule text must be approved by a
+partner practitioner before production use (开发清单 T0-24).
+"""
+
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass, field
+from datetime import date
+
+RULEPACK_VERSION = "2026.10-1"
+
+# --------------------------------------------------------------- representation
+
+US_FOREIGN_COUNSEL_EFFECTIVE = date(2026, 7, 20)
+
+
+@dataclass
+class Finding:
+    rule_id: str
+    severity: str  # block | error | warning | info
+    message: str
+    basis: str
+    data: dict = field(default_factory=dict)
+
+    def to_dict(self) -> dict:
+        return {"rule_id": self.rule_id, "severity": self.severity, "message": self.message, "basis": self.basis, **({"data": self.data} if self.data else {})}
+
+
+def representation_requirements(office: str, applicant: dict, *, on: date | None = None) -> list[Finding]:
+    """Who must represent the applicant. applicant = {domicile: 'CN', type: 'natural'|'juristic'}."""
+
+    on = on or date.today()
+    office = office.upper()
+    domicile = (applicant.get("domicile") or "").upper()
+    kind = applicant.get("type", "juristic")
+    out: list[Finding] = []
+    if office == "US":
+        if domicile and domicile != "US" and on >= US_FOREIGN_COUNSEL_EFFECTIVE:
+            out.append(Finding("REP-US-001", "block", "Applicants domiciled outside the US must be represented by a USPTO registered practitioner.", "37 CFR 1.31(a)(2), effective 2026-07-20"))
+        if kind == "juristic":
+            out.append(Finding("REP-US-002", "block", "A juristic entity applicant must be represented by a registered practitioner.", "37 CFR 1.31"))
+    elif office == "CN":
+        if domicile and domicile != "CN":
+            out.append(Finding("REP-CN-001", "block", "Foreign applicants without a habitual residence or business office in China must appoint a licensed patent agency.", "Patent Law Art. 18"))
+        else:
+            out.append(Finding("REP-CN-002", "info", "Domestic applicants may file themselves; using a licensed agency is recommended.", "Patent Law Art. 18"))
+    elif office == "EU":
+        if domicile and domicile not in EU_EEA:
+            out.append(Finding("REP-EU-001", "block", "Applicants without domicile or establishment in the EEA must be represented before EUIPO.", "EUDR Art. 77(2)"))
+    return out
+
+
+EU_EEA = {
+    "AT", "BE", "BG", "HR", "CY", "CZ", "DK", "EE", "FI", "FR", "DE", "GR", "HU", "IE", "IT", "LV", "LT", "LU", "MT",
+    "NL", "PL", "PT", "RO", "SK", "SI", "ES", "SE", "IS", "LI", "NO",
+}
+
+# --------------------------------------------------------------------- timeline
+
+GRACE_DAYS = {"US": 365, "EU": 365, "CN": 0, "JP": 365}
+
+
+def disclosure_findings(office: str, disclosures: list[dict], filing_date: date | None) -> list[Finding]:
+    """Check public disclosures (listing, fair, crowdfunding, social, sale) against the filing date.
+
+    disclosures: [{"kind": "listing", "date": "2026-11-01", "by_applicant": True, "exception": None}]
+    filing_date: planned or actual filing date; None means "not filed yet" (today is used).
+    """
+
+    office = office.upper()
+    ref = filing_date or date.today()
+    out: list[Finding] = []
+    grace = GRACE_DAYS.get(office, 0)
+    for item in disclosures:
+        when = date.fromisoformat(str(item["date"]))
+        if when >= ref and filing_date is not None:
+            continue
+        days_before = (ref - when).days
+        by_applicant = bool(item.get("by_applicant", True))
+        planned = when > date.today()
+        label = f"{item.get('kind', 'disclosure')} on {when.isoformat()}"
+        if office == "CN":
+            if item.get("exception"):
+                out.append(Finding("TL-CN-002", "warning", f"{label}: claimed statutory exception '{item['exception']}' must be declared and proven when filing.", "Patent Law Art. 24"))
+            elif planned and filing_date is None:
+                out.append(Finding("TL-CN-001", "block", f"{label} is planned before a CN filing exists. File first, then disclose.", "Patent Law Art. 23-24 (no general grace period)"))
+            elif when < ref:
+                out.append(Finding("TL-CN-001", "block", f"{label} precedes the CN filing date; it can destroy novelty of your own design.", "Patent Law Art. 23-24 (no general grace period)"))
+        else:
+            if not by_applicant and when < ref:
+                out.append(Finding(f"TL-{office}-003", "error", f"{label} by a third party precedes filing.", "novelty"))
+            elif days_before > grace:
+                out.append(Finding(f"TL-{office}-001", "block", f"{label} is more than {grace} days before filing; the grace period is exceeded.", "35 U.S.C. 102(b)(1)" if office == "US" else "EUDR Art. 7(2)"))
+            elif days_before > 0:
+                out.append(Finding(f"TL-{office}-002", "warning", f"{label} relies on the {grace}-day grace period; record evidence of the disclosure.", "grace period"))
+    return out
+
+
+# ------------------------------------------------------------------------ titles
+
+MARKETING_WORDS = re.compile(r"\b(best|premium|ultimate|new|improved|amazing|pro|max|deluxe|luxury|super|™|®)\b", re.I)
+
+
+def title_findings(office: str, title: str) -> list[Finding]:
+    out: list[Finding] = []
+    if not title or not title.strip():
+        return [Finding("TTL-001", "error", "Article title is empty.", "MPEP 1503.01 / CN Guidelines Part I Ch.3")]
+    if office.upper() == "US":
+        if MARKETING_WORDS.search(title):
+            out.append(Finding("TTL-US-002", "error", "Title contains marketing language; use the generic article name.", "MPEP 1503.01(I)"))
+        if any(ch.isdigit() for ch in title):
+            out.append(Finding("TTL-US-003", "warning", "Model numbers in the title are discouraged.", "MPEP 1503.01(I)"))
+    if office.upper() == "CN":
+        if re.search(r"(新型|最佳|豪华|升级版|专用)", title):
+            out.append(Finding("TTL-CN-002", "error", "产品名称不应包含宣传性或含糊词语。", "专利审查指南 第一部分第三章"))
+        if re.search(r"[A-Za-z]{3,}\d|\d{3,}", title):
+            out.append(Finding("TTL-CN-003", "warning", "产品名称一般不应包含型号。", "专利审查指南 第一部分第三章"))
+    return out
+
+
+def worst(findings: list[Finding]) -> str:
+    order = {"block": 3, "error": 2, "warning": 1, "info": 0}
+    if not findings:
+        return "ok"
+    return max(findings, key=lambda f: order.get(f.severity, 0)).severity

designaround_core-0.1.3.dist-info/METADATA

@@ -0,0 +1,7 @@
+Metadata-Version: 2.4
+Name: designaround-core
+Version: 0.1.3
+Summary: Pure-Python shared rules for DesignAround: price catalog, official fees, filing/timeline/representation rule packs, quotes.
+License: Apache-2.0
+Requires-Python: >=3.11
+Requires-Dist: pyyaml==6.0.3

designaround_core-0.1.3.dist-info/RECORD

@@ -0,0 +1,10 @@
+designaround_core/__init__.py,sha256=WsrUsTq4vUBFIT19j0kjFsKWJbTv3q8Me6iJBvSQWr4,128
+designaround_core/catalog.py,sha256=tAH-dpPo0JC4VummKR_JEZs1A10RWa68GQTSw3VKiGg,4568
+designaround_core/deadlines.py,sha256=QgCa58N_Xr9gadB-ZU4aWFon3Gmv5160e_ju2GK_jp4,19475
+designaround_core/fees.py,sha256=cO62HQfeWibaSDxRvvuzvVvcXbkeFnD2_iAdnsRig90,2840
+designaround_core/observer.py,sha256=44-d-kTJO_LRcuzgJV_E3CDvRSYWXG0JAdgSOiGdpKs,5483
+designaround_core/quote.py,sha256=eh3w4g_mufX0vbA4JTTuTFDN--rwZn-I5QGPmW0MH-Y,3075
+designaround_core/rules.py,sha256=regzyHSaOOnCM1cCDF8mmk_DDV2_6HYHXE684Xy3-7s,6667
+designaround_core-0.1.3.dist-info/METADATA,sha256=BY9GGZGEh9BnEQJUkQQq5sbycZerO-EQTEWNK9Mi86M,267
+designaround_core-0.1.3.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+designaround_core-0.1.3.dist-info/RECORD,,

designaround_core-0.1.3.dist-info/WHEEL

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