ursa-ai 0.7.0rc2__py3-none-any.whl → 0.7.1__py3-none-any.whl

ursa/observability/pricing.py

@@ -4,7 +4,8 @@ import json
 import os
 from dataclasses import asdict, dataclass
 from decimal import ROUND_HALF_UP, Decimal, getcontext
-from typing import Any, Dict, Optional, Tuple
+from importlib import resources
+from typing import Any, Optional, Tuple
 
 getcontext().prec = 28  # robust money math
 
@@ -24,7 +25,7 @@ class ModelPricing:
         "1"
     )  # e.g., 0.25 if your provider discounts cached prompt tokens
 
-    def price_tokens(self, usage: Dict[str, Any]) -> Dict[str, Decimal]:
+    def price_tokens(self, usage: dict[str, Any]) -> dict[str, Decimal]:
         """Compute cost components from a usage dict with keys like input_tokens, output_tokens, reasoning_tokens, cached_tokens."""
 
         def _to_dec(x) -> Decimal:
@@ -83,7 +84,7 @@ def _dec(x: str | float | int) -> Decimal:
 
 # DEFAULTS: keep $0.00 so you don’t accidentally attribute costs.
 # Fill in values for your org as needed (USD per 1K tokens).
-DEFAULT_REGISTRY: Dict[str, ModelPricing] = {
+DEFAULT_REGISTRY: dict[str, ModelPricing] = {
     # Examples — edit to match your negotiated prices:
     # "openai/gpt-4o": ModelPricing(_dec("5.00"), _dec("15.00")),
     # "openai/o3-mini": ModelPricing(_dec("2.50"), _dec("10.00"), reasoning_per_1k=_dec("5.00")),
@@ -98,7 +99,7 @@ def normalize_model_name(name: str) -> str:
     return (name or "").strip().lower()
 
 
-def resolve_model_name(event: Dict[str, Any]) -> str:
+def resolve_model_name(event: dict[str, Any]) -> str:
     m = (
         ((event.get("metadata") or {}).get("model"))
         or ((event.get("metadata") or {}).get("ls_model_name"))
@@ -108,7 +109,7 @@ def resolve_model_name(event: Dict[str, Any]) -> str:
 
 
 def find_pricing(
-    model: str, registry: Dict[str, ModelPricing]
+    model: str, registry: dict[str, ModelPricing]
 ) -> Optional[ModelPricing]:
     if model in registry:
         return registry[model]
@@ -124,15 +125,16 @@ def find_pricing(
 
 
 def default_registry_path() -> str:
-    """Pricing file shipped with this module (pricing.json next to pricing.py)."""
-    return os.path.join(os.path.dirname(__file__), "pricing.json")
+    """Path to pricing file shipped with this package"""
+    path = resources.files("ursa") / "observability" / "pricing.json"
+    return str(path)
 
 
 def load_registry(
     path: Optional[str] = None,
-    overrides: Optional[Dict[str, Any]] = None,
+    overrides: Optional[dict[str, Any]] = None,
     use_default_if_missing: bool = True,
-) -> Dict[str, ModelPricing]:
+) -> dict[str, ModelPricing]:
     """
     Load pricing registry from:
       1) explicit `path` (if provided), else
@@ -140,7 +142,7 @@ def load_registry(
       3) pricing.json next to pricing.py (if present, and use_default_if_missing)
       4) fall back to DEFAULT_REGISTRY
     """
-    reg: Dict[str, ModelPricing] = dict(DEFAULT_REGISTRY)
+    reg: dict[str, ModelPricing] = dict(DEFAULT_REGISTRY)
 
     # 1) explicit path from caller wins
     candidate = path
@@ -194,7 +196,7 @@ def load_registry(
 # ---------- Core pricing application ----------
 
 
-def _has_provider_cost(roll: Dict[str, Any]) -> bool:
+def _has_provider_cost(roll: dict[str, Any]) -> bool:
     # Treat nonzero provider totals as authoritative
     try:
         return any([
@@ -211,10 +213,10 @@ def _round_money(x: Decimal) -> float:
 
 
 def price_event(
-    event: Dict[str, Any],
-    registry: Dict[str, ModelPricing],
+    event: dict[str, Any],
+    registry: dict[str, ModelPricing],
     overwrite: bool = False,
-) -> Tuple[Dict[str, Any], Optional[Decimal], str]:
+) -> Tuple[dict[str, Any], Optional[Decimal], str]:
     """
     Returns (event, total_cost_decimal_or_None, cost_source)
       cost_source ∈ {"provider", "computed", "no_usage", "no_pricing"}
@@ -255,10 +257,10 @@ def price_event(
 
 
 def price_payload(
-    payload: Dict[str, Any],
-    registry: Optional[Dict[str, ModelPricing]] = None,
+    payload: dict[str, Any],
+    registry: Optional[dict[str, ModelPricing]] = None,
     overwrite: bool = False,
-) -> Dict[str, Any]:
+) -> dict[str, Any]:
     """
     Enriches payload in-place with computed costs where missing.
     Adds a `costs` block with totals and by-model aggregation.
@@ -266,7 +268,7 @@ def price_payload(
     reg = registry or load_registry()
     llm_events = payload.get("llm_events") or []
     total = Decimal("0")
-    by_model: Dict[str, Decimal] = {}
+    by_model: dict[str, Decimal] = {}
     sources = {"provider": 0, "computed": 0, "no_usage": 0, "no_pricing": 0}
 
     for ev in llm_events:

ursa/util/parse.py

@@ -1,5 +1,15 @@
 import json
+import os
 import re
+import shutil
+import unicodedata
+from typing import Any, Optional, Tuple
+from urllib.parse import urljoin, urlparse
+
+import justext
+import requests
+import trafilatura
+from bs4 import BeautifulSoup
 
 
 def extract_json(text: str) -> list[dict]:
@@ -87,3 +97,309 @@ def extract_json(text: str) -> list[dict]:
         return json.loads(json_str)
     except json.JSONDecodeError as e:
         raise ValueError("Extracted content is not valid JSON.") from e
+
+
+PDF_CT_HINTS = (
+    "application/pdf",
+    "binary/octet-stream",
+)  # some servers mislabel
+PDF_EXT_RE = re.compile(r"\.pdf($|\?)", re.IGNORECASE)
+
+
+def _is_pdf_response(resp: requests.Response) -> bool:
+    ct = resp.headers.get("Content-Type", "").lower()
+    if any(hint in ct for hint in PDF_CT_HINTS):
+        return True
+    # Sometimes servers omit CT but set filename
+    cd = resp.headers.get("Content-Disposition", "")
+    if "filename" in cd and ".pdf" in cd.lower():
+        return True
+    # Last resort: URL extension
+    return bool(PDF_EXT_RE.search(resp.url))
+
+
+def _derive_filename_from_cd_or_url(
+    resp: requests.Response, fallback: str
+) -> str:
+    cd = resp.headers.get("Content-Disposition", "")
+    m = re.search(r'filename\*?=(?:UTF-8\'\')?"?([^\";]+)"?', cd, re.IGNORECASE)
+    if m:
+        name = m.group(1)
+        # Some headers include quotes
+        name = name.strip("\"'")
+
+        # RFC 5987 may encode UTF-8 in filename*; we’re treating as plain here.
+        if not name.lower().endswith(".pdf"):
+            name += ".pdf"
+        return name
+
+    # use URL last path segment if looks like PDF
+    parsed = urlparse(resp.url)
+    base = os.path.basename(parsed.path) or fallback
+    if not base.lower().endswith(".pdf"):
+        if PDF_EXT_RE.search(resp.url):
+            base = re.sub(
+                r"(\.pdf)(?:$|\?).*", r"\1", base, flags=re.IGNORECASE
+            )
+            if not base.lower().endswith(".pdf"):
+                base += ".pdf"
+        else:
+            base = (
+                fallback
+                if fallback.lower().endswith(".pdf")
+                else fallback + ".pdf"
+            )
+    return base
+
+
+def _download_stream_to(path: str, resp: requests.Response) -> str:
+    os.makedirs(os.path.dirname(path), exist_ok=True)
+    with open(path, "wb") as f:
+        shutil.copyfileobj(resp.raw, f)
+    return path
+
+
+def _get_soup(
+    url: str, timeout: int = 20, headers: Optional[dict[str, str]] = None
+) -> BeautifulSoup:
+    r = requests.get(url, timeout=timeout, headers=headers or {})
+    r.raise_for_status()
+    return BeautifulSoup(r.text, "html.parser")
+
+
+def _find_pdf_on_landing(soup: BeautifulSoup, base_url: str) -> Optional[str]:
+    # 1) meta citation_pdf_url
+    meta = soup.find("meta", attrs={"name": "citation_pdf_url"})
+    if meta and meta.get("content"):
+        return urljoin(base_url, meta["content"])
+
+    # 2) obvious anchors: text contains 'PDF' or 'Download'
+    for a in soup.find_all("a", href=True):
+        label = (a.get_text(" ", strip=True) or "").lower()
+        href = a["href"]
+        if "pdf" in label or "download" in label or PDF_EXT_RE.search(href):
+            return urljoin(base_url, href)
+
+    # 3) buttons that wrap an anchor
+    for btn in soup.find_all(["button", "a"], href=True):
+        label = (btn.get_text(" ", strip=True) or "").lower()
+        href = btn.get("href")
+        if href and (
+            "pdf" in label or "download" in label or PDF_EXT_RE.search(href)
+        ):
+            return urljoin(base_url, href)
+
+    return None
+
+
+# def _resolve_pdf_via_unpaywall(doi: str, email: str, timeout: int = 15) -> Optional[str]:
+#     # Optional helper: respects publisher OA; returns None if no OA PDF
+#     try:
+#         url = f"https://api.unpaywall.org/v2/{doi}"
+#         r = requests.get(url, params={"email": email}, timeout=timeout)
+#         r.raise_for_status()
+#         data = r.json()
+#         loc = data.get("best_oa_location") or {}
+#         pdf = loc.get("url_for_pdf") or loc.get("url")
+#         if pdf and PDF_EXT_RE.search(pdf):
+#             return pdf
+#         # Sometimes url points to landing; try it anyway.
+#         return pdf
+#     except Exception:
+#         return None
+
+
+def resolve_pdf_from_osti_record(
+    rec: dict[str, Any],
+    *,
+    headers: Optional[dict[str, str]] = None,
+    unpaywall_email: Optional[str] = None,
+    timeout: int = 25,
+) -> Tuple[Optional[str], Optional[str], str]:
+    """
+    Returns (pdf_url, landing_used, note)
+      - pdf_url: direct downloadable PDF URL if found (or a strong candidate)
+      - landing_used: landing page URL we parsed (if any)
+      - note: brief trace of how we found it
+    """
+    headers = headers or {"User-Agent": "Mozilla/5.0"}
+    note_parts: list[str] = []
+
+    links = rec.get("links", []) or []
+    # doi = rec.get("doi")
+
+    # 1) Try 'fulltext' first (OSTI purl)
+    fulltext = None
+    for link in links:
+        if link.get("rel") == "fulltext":
+            fulltext = link.get("href")
+            break
+
+    if fulltext:
+        note_parts.append("Tried links[fulltext] purl")
+        try:
+            # Follow redirects; stream to peek headers without loading whole body
+            r = requests.get(
+                fulltext,
+                headers=headers,
+                timeout=timeout,
+                allow_redirects=True,
+                stream=True,
+            )
+            r.raise_for_status()
+
+            if _is_pdf_response(r):
+                note_parts.append("fulltext resolved directly to PDF")
+                return (r.url, None, " | ".join(note_parts))
+
+            # Not a PDF: parse page HTML for meta or obvious PDF anchors
+            # (If server sent binary but CT lied, _is_pdf_response would have caught via CD or ext)
+            r.close()
+            soup = _get_soup(fulltext, timeout=timeout, headers=headers)
+            candidate = _find_pdf_on_landing(soup, fulltext)
+            if candidate:
+                note_parts.append(
+                    "found PDF via meta/anchor on fulltext landing"
+                )
+                return (candidate, fulltext, " | ".join(note_parts))
+        except Exception as e:
+            note_parts.append(f"fulltext failed: {e}")
+
+    # 2) Try DOE PAGES landing (citation_doe_pages)
+    doe_pages = None
+    for link in links:
+        if link.get("rel") == "citation_doe_pages":
+            doe_pages = link.get("href")
+            break
+
+    if doe_pages:
+        note_parts.append("Tried links[citation_doe_pages] landing")
+        try:
+            soup = _get_soup(doe_pages, timeout=timeout, headers=headers)
+            candidate = _find_pdf_on_landing(soup, doe_pages)
+            if candidate:
+                # Candidate may itself be a landing—check if it serves PDF
+                try:
+                    r2 = requests.get(
+                        candidate,
+                        headers=headers,
+                        timeout=timeout,
+                        allow_redirects=True,
+                        stream=True,
+                    )
+                    r2.raise_for_status()
+                    if _is_pdf_response(r2):
+                        note_parts.append("citation_doe_pages → direct PDF")
+                        return (r2.url, doe_pages, " | ".join(note_parts))
+                    r2.close()
+                except Exception:
+                    pass
+                # If not clearly PDF, still return as a candidate (agent will fetch & parse)
+                note_parts.append(
+                    "citation_doe_pages → PDF-like candidate (not confirmed by headers)"
+                )
+                return (candidate, doe_pages, " | ".join(note_parts))
+        except Exception as e:
+            note_parts.append(f"citation_doe_pages failed: {e}")
+
+    # # 3) Optional: DOI → Unpaywall OA
+    # if doi and unpaywall_email:
+    #     note_parts.append("Tried Unpaywall via DOI")
+    #     pdf_from_ua = _resolve_pdf_via_unpaywall(doi, unpaywall_email)
+    #     if pdf_from_ua:
+    #         # May be direct PDF or landing; the caller will validate headers during download
+    #         note_parts.append("Unpaywall returned candidate")
+    #         return (pdf_from_ua, None, " | ".join(note_parts))
+
+    # 4) Give up
+    note_parts.append("No PDF found")
+    return (None, None, " | ".join(note_parts))
+
+
+def _normalize_ws(text: str) -> str:
+    # Normalize unicode, collapse whitespace, and strip control chars
+    text = unicodedata.normalize("NFKC", text)
+    text = re.sub(r"[ \t\r\f\v]+", " ", text)
+    text = re.sub(r"\s*\n\s*", "\n", text)
+    text = re.sub(r"\n{3,}", "\n\n", text)
+    text = text.strip()
+    return text
+
+
+def _dedupe_lines(text: str, min_len: int = 40) -> str:
+    seen = set()
+    out = []
+    for line in text.splitlines():
+        stripped = line.strip()
+        # Ignore very short or repeated lines (menus, cookie banners, etc.)
+        if len(stripped) < min_len:
+            continue
+        key = stripped.lower()
+        if key in seen:
+            continue
+        seen.add(key)
+        out.append(stripped)
+    return "\n\n".join(out)
+
+
+def extract_main_text_only(html: str, *, max_chars: int = 250_000) -> str:
+    """
+    Returns plain text with navigation/ads/scripts removed.
+    Prefers trafilatura -> jusText -> BS4 paragraphs.
+    """
+    # 1) Trafilatura
+    # You can tune config: with_metadata, include_comments, include_images, favor_recall, etc.
+    cfg = trafilatura.settings.use_config()
+    cfg.set("DEFAULT", "include_comments", "false")
+    cfg.set("DEFAULT", "include_tables", "false")
+    cfg.set("DEFAULT", "favor_recall", "false")  # be stricter; less noise
+    try:
+        # If you fetched HTML already, use extract() on string; otherwise, fetch_url(url)
+        txt = trafilatura.extract(
+            html,
+            config=cfg,
+            include_comments=False,
+            include_tables=False,
+            favor_recall=False,
+        )
+        if txt and txt.strip():
+            txt = _normalize_ws(txt)
+            txt = _dedupe_lines(txt)
+            return txt[:max_chars]
+    except Exception:
+        pass
+
+    # 2) jusText
+    try:
+        paragraphs = justext.justext(html, justext.get_stoplist("English"))
+        body_paras = [p.text for p in paragraphs if not p.is_boilerplate]
+        if body_paras:
+            txt = _normalize_ws("\n\n".join(body_paras))
+            txt = _dedupe_lines(txt)
+            return txt[:max_chars]
+    except Exception:
+        pass
+
+    # 4) last-resort: BS4 paragraphs/headings only
+    from bs4 import BeautifulSoup
+
+    soup = BeautifulSoup(html, "html.parser")
+    for tag in soup([
+        "script",
+        "style",
+        "noscript",
+        "header",
+        "footer",
+        "nav",
+        "form",
+        "aside",
+    ]):
+        tag.decompose()
+    chunks = []
+    for el in soup.find_all(["h1", "h2", "h3", "p", "li", "figcaption"]):
+        t = el.get_text(" ", strip=True)
+        if t:
+            chunks.append(t)
+    txt = _normalize_ws("\n\n".join(chunks))
+    txt = _dedupe_lines(txt)
+    return txt[:max_chars]

{ursa_ai-0.7.0rc2.dist-info → ursa_ai-0.7.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ursa-ai
-Version: 0.7.0rc2
+Version: 0.7.1
 Summary: Agents for science at LANL
 Author-email: Mike Grosskopf <mikegros@lanl.gov>, Nathan Debardeleben <ndebard@lanl.gov>, Rahul Somasundaram <rsomasundaram@lanl.gov>, Isaac Michaud <imichaud@lanl.gov>, Avanish Mishra <avanish@lanl.gov>, Arthur Lui <alui@lanl.gov>, Russell Bent <rbent@lanl.gov>, Earl Lawrence <earl@lanl.gov>
 License-Expression: BSD-3-Clause
@@ -39,6 +39,8 @@ Requires-Dist: langgraph-checkpoint-sqlite<3.0,>=2.0.10
 Requires-Dist: langchain-ollama<0.4,>=0.3.6
 Requires-Dist: ddgs>=9.5.5
 Requires-Dist: typer>=0.16.1
+Requires-Dist: trafilatura<1.7,>=1.6.1
+Requires-Dist: selectolax<0.5,>=0.4.0
 Dynamic: license-file
 
 # URSA - The Universal Research and Scientific Agent
@@ -51,6 +53,8 @@ Dynamic: license-file
 The flexible agentic workflow for accelerating scientific tasks. 
 Composes information flow between agents for planning, code writing and execution, and online research to solve complex problems.
 
+The original arxiv paper is [here](https://arxiv.org/abs/2506.22653).
+
 ## Installation
 You can install `ursa` via `pip` or `uv`.
 

{ursa_ai-0.7.0rc2.dist-info → ursa_ai-0.7.1.dist-info}/RECORD

@@ -1,20 +1,23 @@
 ursa/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-ursa/agents/__init__.py,sha256=u5ClncJ-w4nIJLQJTOC-NBv6Hu4pXxALgZJJxDt3tZw,1202
-ursa/agents/arxiv_agent.py,sha256=naXZuPd3tHuyjqoldsN1gJXWcGB6GJaEdtEzfP1JO1w,14570
-ursa/agents/base.py,sha256=XZ62XhF-GdMykdUyiMuxqQwt41hrryaK9aBhgIFJMMQ,14482
+ursa/agents/__init__.py,sha256=XApBa4fFidXOt0TKrqNZ3UtybKkdGPtyGp9vOgYwP1I,1524
+ursa/agents/acquisition_agents.py,sha256=6TdJvrLdvTKa_mfFNvD6KHZ-Z-2DBHxiMe-yR0tXSu4,28148
+ursa/agents/arxiv_agent.py,sha256=7veUmjnTmlOHm1Y9N65q-IxBxK1ZvlCtHyR7JBZklDw,14576
+ursa/agents/base.py,sha256=rd2b9EQ83gh1ShzGJ2DeEu3CY80vu6OV5tQXHqqK-_E,26373
+ursa/agents/chat_agent.py,sha256=Pw8Tweu7IL7Y5YIWRdbTNr9eC9Gc5bKu9ERBQJxNptk,1726
 ursa/agents/code_review_agent.py,sha256=F3RJmS1jBYOoWPg5Hiy-xirutLTtw_u1_hqiKIsA2eY,11563
-ursa/agents/execution_agent.py,sha256=gMQsiNoj8feG3kalcVs39AV58GXrfvq6jff3m2ecyyw,17923
+ursa/agents/execution_agent.py,sha256=UsCDTA8An4TbwTDrJgpvxKSPrw9GkgfSfXa26f8JJvQ,29369
 ursa/agents/hypothesizer_agent.py,sha256=2jSOHkR8MjNhS5HMeOhZCkhT4wGDLNBs-aLgQhYBHr4,23124
-ursa/agents/lammps_agent.py,sha256=z7RbZwk70aC31CyagXk3LyPhtU4IInUMMa1v8r2qji4,14774
+ursa/agents/lammps_agent.py,sha256=63uDq0zsR06tjT51Gv_cbGvKGzJYvDm_BmZ1h79FWLw,16375
 ursa/agents/mp_agent.py,sha256=HvD4JC9OuGeEicW3mKZBQmQ1yn0HVB03118E1urXwx4,6833
 ursa/agents/optimization_agent.py,sha256=siJKyujfy_oNQDbnIFaCUkE_DLvmxPYsBJBDms6Cgbg,13945
-ursa/agents/planning_agent.py,sha256=9XwwmcEtNHW8xd4osljawp1V0X4y9t3R6ncHrsPo1eo,6489
+ursa/agents/planning_agent.py,sha256=JbP5RIRTKCZX7G-B2ymmS5dbUdJCkL48lNsbtWHqzk0,7320
 ursa/agents/rag_agent.py,sha256=kc7ZYWxgWNh-LbMpREaJY90IVbs2SKPrXdCutxrEdT0,10099
 ursa/agents/recall_agent.py,sha256=MoS0FaQFAb14DeYSCo6sYKNTjvE_u-egTOvuXSTXLpk,1693
-ursa/agents/websearch_agent.py,sha256=7d9EL9r2vqlJHwU1nOeV_moc0p4Jxbfz2awOMrKsf0k,7759
-ursa/cli/__init__.py,sha256=YYh7E1Ce3fcJaYn1XP19U1d9iHG1INfnMQ6gAhtARKM,3879
-ursa/cli/hitl.py,sha256=NIKr72fIdwXE_g6KtRc6c94zSRvft2Ptyi4F0UPSBI8,14695
-ursa/observability/pricing.py,sha256=wNe51EcYjk3KDSuU8rv_vjOPlGZB3We_dQrVBcPXdWA,10551
+ursa/agents/websearch_agent.py,sha256=KV8H_9B3gLNpQx6B_WtMaf6Zahk_caZ1TCOFAiJBc3I,7771
+ursa/cli/__init__.py,sha256=jkP-5aFXo3jn7faevyYlbJUEh04SdDs7at_QJDpFbRI,4042
+ursa/cli/hitl.py,sha256=u2JYGaqi0fjvwHSqbi5A72ER2lsQb7i5gC1VQc6uW9g,15299
+ursa/observability/pricing.json,sha256=c5d334-oBU9CP1xYXAsVf_bUrmT0g0yUE5WZUdmAuvY,6714
+ursa/observability/pricing.py,sha256=Xe397VWXzdVu3wOLDbraHxkMzixu3CUyTyoVpHvTvIA,10575
 ursa/observability/timing.py,sha256=yQX5ZtkxRBH_1V61KjWmEBph02DOeZuP-v0-OtJNffQ,48612
 ursa/prompt_library/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ursa/prompt_library/code_review_prompts.py,sha256=-HuhwW9W_p2LDn44bXLntxLADHCOyl-2KIXxRHto66w,2444
@@ -34,10 +37,10 @@ ursa/util/diff_renderer.py,sha256=1L1q2qWWb8gLhR532-LgJn2TrqXDx0gUpPVOWD_sqeU,40
 ursa/util/helperFunctions.py,sha256=cs-pQEcXyOr4nb5FoH9Ssg3hktycEapW07-MKJcUNOA,4122
 ursa/util/memory_logger.py,sha256=GiKYbQBpxlNRLKyqKFJyrbSbVCkXpRB7Yr5so43tUAw,6097
 ursa/util/optimization_schema.py,sha256=b2wO0BjCIgQb15Q3adDu-ZyG3dfncme9OGQw6FmDGDc,2731
-ursa/util/parse.py,sha256=bTC582fAJDWozXU1XGq4WpY2KR1GnAKVC6kTDFh-kXk,2825
-ursa_ai-0.7.0rc2.dist-info/licenses/LICENSE,sha256=4Vr6_u2zTHIUvYjoOBg9ztDbfpV3hyCFv3mTCS87gYU,1482
-ursa_ai-0.7.0rc2.dist-info/METADATA,sha256=-eEuSNI816nTURuByAJrd5qZxGAazzvHMekFrC6xkEM,9798
-ursa_ai-0.7.0rc2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-ursa_ai-0.7.0rc2.dist-info/entry_points.txt,sha256=B0bbgM-NcAqLujZ1lfmChJZpQMYQDYFJck4moU89Y4E,39
-ursa_ai-0.7.0rc2.dist-info/top_level.txt,sha256=OjA1gRYSUAeiXGnpqPC8iOOGfcjFO1IlP848qMnYSdY,5
-ursa_ai-0.7.0rc2.dist-info/RECORD,,
+ursa/util/parse.py,sha256=QCQM_gEHs89WZ63CzNoaxWVRDUTADNyOrJZyUZmG36E,13657
+ursa_ai-0.7.1.dist-info/licenses/LICENSE,sha256=4Vr6_u2zTHIUvYjoOBg9ztDbfpV3hyCFv3mTCS87gYU,1482
+ursa_ai-0.7.1.dist-info/METADATA,sha256=IytCA3xYHrKn7OU7O2g0qdXI0q7vTc2hF7gFwTNsmO4,9943
+ursa_ai-0.7.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+ursa_ai-0.7.1.dist-info/entry_points.txt,sha256=B0bbgM-NcAqLujZ1lfmChJZpQMYQDYFJck4moU89Y4E,39
+ursa_ai-0.7.1.dist-info/top_level.txt,sha256=OjA1gRYSUAeiXGnpqPC8iOOGfcjFO1IlP848qMnYSdY,5
+ursa_ai-0.7.1.dist-info/RECORD,,