PyPI - haxaml-ui - Versions diffs - 0.6.7__tar.gz - Mend

haxaml-ui 0.6.7__tar.gz

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (12) hide show

haxaml_ui-0.6.7/PKG-INFO +54 -0
haxaml_ui-0.6.7/README.md +31 -0
haxaml_ui-0.6.7/haxaml_ui/__init__.py +6 -0
haxaml_ui-0.6.7/haxaml_ui/dashboard.py +517 -0
haxaml_ui-0.6.7/haxaml_ui.egg-info/PKG-INFO +54 -0
haxaml_ui-0.6.7/haxaml_ui.egg-info/SOURCES.txt +10 -0
haxaml_ui-0.6.7/haxaml_ui.egg-info/dependency_links.txt +1 -0
haxaml_ui-0.6.7/haxaml_ui.egg-info/entry_points.txt +2 -0
haxaml_ui-0.6.7/haxaml_ui.egg-info/requires.txt +4 -0
haxaml_ui-0.6.7/haxaml_ui.egg-info/top_level.txt +1 -0
haxaml_ui-0.6.7/pyproject.toml +45 -0
haxaml_ui-0.6.7/setup.cfg +4 -0

haxaml_ui-0.6.7/PKG-INFO ADDED Viewed

@@ -0,0 +1,54 @@
+Metadata-Version: 2.4
+Name: haxaml-ui
+Version: 0.6.7
+Summary: Local read-only dashboard package for Haxaml.
+Author: Hax
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/haxsysgit/haxaml
+Project-URL: Repository, https://github.com/haxsysgit/haxaml
+Keywords: haxaml,dashboard,ui,developer-tools
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Web Environment
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Build Tools
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+Requires-Dist: haxaml<0.7.0,>=0.6.7
+Requires-Dist: jinja2>=3.1
+Requires-Dist: starlette>=0.37
+Requires-Dist: uvicorn>=0.30
+# haxaml-ui
+Read-only local dashboard package for Haxaml.
+This package is the dashboard distribution itself.
+The human launcher remains:
+```bash
+haxaml dashboard
+```
+`haxaml[ui]` is only the convenience install selector for the core package.
+Install directly:
+```bash
+pip install haxaml-ui
+```
+Or install through the core extra:
+```bash
+pip install "haxaml[ui]"
+```
+Direct package entrypoint is also available:
+```bash
+haxaml-dashboard
+```

haxaml_ui-0.6.7/README.md ADDED Viewed

@@ -0,0 +1,31 @@
+# haxaml-ui
+Read-only local dashboard package for Haxaml.
+This package is the dashboard distribution itself.
+The human launcher remains:
+```bash
+haxaml dashboard
+```
+`haxaml[ui]` is only the convenience install selector for the core package.
+Install directly:
+```bash
+pip install haxaml-ui
+```
+Or install through the core extra:
+```bash
+pip install "haxaml[ui]"
+```
+Direct package entrypoint is also available:
+```bash
+haxaml-dashboard
+```

haxaml_ui-0.6.7/haxaml_ui/__init__.py ADDED Viewed

@@ -0,0 +1,6 @@
+"""UI package for the Haxaml local dashboard."""
+from haxaml_ui.dashboard import create_dashboard_app, run_dashboard_server
+__all__ = ["create_dashboard_app", "run_dashboard_server"]

haxaml_ui-0.6.7/haxaml_ui/dashboard.py ADDED Viewed

@@ -0,0 +1,517 @@
+"""Read-only local dashboard for FRAME projects."""
+from __future__ import annotations
+from html import escape
+from pathlib import Path
+import webbrowser
+import uvicorn
+import yaml
+from jinja2 import DictLoader, Environment, select_autoescape
+from starlette.applications import Starlette
+from starlette.requests import Request
+from starlette.responses import HTMLResponse, Response
+from starlette.routing import Route
+from haxaml.frame_model import FrameModel
+from haxaml.map_policy import evaluate_map_complexity, format_map_complexity_summary, map_complexity_issues
+from haxaml.mcp.lifecycle_helpers import _expect_sync_state
+from haxaml.paths import detect_project_root, frame_path
+from haxaml.reconcile import reconcile_derivation
+from haxaml.runner import ExecutionRunner
+from haxaml.runtime_cache import runtime_cache
+from haxaml.state_manager import StateManager
+from haxaml.validator import frame_consistency_report, semantic_validate
+DEFAULT_DASHBOARD_HOST = "127.0.0.1"
+DEFAULT_DASHBOARD_PORT = 8421
+FRAME_PAGE_ORDER = ["facts", "rules", "acts", "expect", "map"]
+TEMPLATES = {
+    "base.html": """
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1">
+    <title>{{ title }}</title>
+    <link rel="stylesheet" href="/static/app.css">
+  </head>
+  <body>
+    <header class="site-header">
+      <div>
+        <p class="eyebrow">Haxaml Dashboard</p>
+        <h1>{{ heading }}</h1>
+        <p class="meta">{{ project_dir }}</p>
+      </div>
+      <div class="pill-row">
+        <span class="pill">{{ "Read-only" if read_only else "Mutable" }}</span>
+        {% if project_name %}<span class="pill accent">{{ project_name }}</span>{% endif %}
+      </div>
+    </header>
+    <nav class="nav">
+      <a href="/">Overview</a>
+      {% for item in frame_nav %}
+      <a href="/frame/{{ item }}">{{ item }}</a>
+      {% endfor %}
+      <a href="/archive">archive</a>
+    </nav>
+    <main class="page">
+      {{ body | safe }}
+    </main>
+  </body>
+</html>
+""",
+}
+CSS = """
+:root {
+  --bg: #f4f0e8;
+  --panel: #fffaf2;
+  --ink: #1d1b19;
+  --muted: #6a645c;
+  --line: #d8cfc1;
+  --accent: #0d6b57;
+  --accent-soft: #d9f0ea;
+  --warn: #9b4d19;
+  --warn-soft: #f7e1cf;
+  --mono: "JetBrains Mono", "SFMono-Regular", monospace;
+  --sans: "IBM Plex Sans", "Segoe UI", sans-serif;
+}
+body {
+  margin: 0;
+  background:
+    radial-gradient(circle at top left, rgba(13, 107, 87, 0.12), transparent 34%),
+    linear-gradient(180deg, #efe7da 0%, var(--bg) 36%, #f8f5ef 100%);
+  color: var(--ink);
+  font-family: var(--sans);
+}
+.site-header, .nav, .page {
+  max-width: 1100px;
+  margin: 0 auto;
+  padding-left: 1rem;
+  padding-right: 1rem;
+}
+.site-header {
+  display: flex;
+  justify-content: space-between;
+  gap: 1rem;
+  padding-top: 2rem;
+}
+.eyebrow {
+  margin: 0 0 .35rem;
+  letter-spacing: .08em;
+  text-transform: uppercase;
+  color: var(--muted);
+  font-size: .8rem;
+}
+h1, h2, h3 { margin: 0; }
+.meta, .subtle { color: var(--muted); }
+.pill-row {
+  display: flex;
+  gap: .5rem;
+  align-items: start;
+  flex-wrap: wrap;
+}
+.pill {
+  border: 1px solid var(--line);
+  background: var(--panel);
+  border-radius: 999px;
+  padding: .45rem .8rem;
+  font-size: .9rem;
+}
+.pill.accent {
+  border-color: var(--accent);
+  background: var(--accent-soft);
+}
+.nav {
+  display: flex;
+  gap: .6rem;
+  flex-wrap: wrap;
+  padding-top: 1rem;
+  padding-bottom: 1rem;
+}
+.nav a, .button-link {
+  color: var(--ink);
+  text-decoration: none;
+  border: 1px solid var(--line);
+  background: rgba(255, 255, 255, .68);
+  padding: .55rem .8rem;
+  border-radius: 999px;
+}
+.page {
+  padding-bottom: 2rem;
+}
+.grid {
+  display: grid;
+  grid-template-columns: repeat(auto-fit, minmax(220px, 1fr));
+  gap: 1rem;
+}
+.card, .panel, details {
+  background: rgba(255, 250, 242, .88);
+  border: 1px solid var(--line);
+  border-radius: 18px;
+  padding: 1rem;
+  box-shadow: 0 10px 30px rgba(54, 43, 29, 0.04);
+}
+.card h3, .panel h2 { margin-bottom: .4rem; }
+.plain-list {
+  margin: .6rem 0 0;
+  padding-left: 1rem;
+}
+.plain-list li {
+  margin: .3rem 0;
+}
+.warning {
+  border-color: var(--warn);
+  background: var(--warn-soft);
+}
+pre, code {
+  font-family: var(--mono);
+}
+pre {
+  overflow-x: auto;
+  white-space: pre-wrap;
+  background: #f7f3ec;
+  padding: 1rem;
+  border-radius: 12px;
+  border: 1px solid #e5dccf;
+}
+.stack {
+  display: flex;
+  flex-direction: column;
+  gap: 1rem;
+}
+.toolbar {
+  display: flex;
+  flex-wrap: wrap;
+  gap: .6rem;
+  margin-bottom: 1rem;
+}
+.section-summary {
+  font-weight: 600;
+}
+@media (max-width: 720px) {
+  .site-header {
+    flex-direction: column;
+  }
+}
+"""
+_TEMPLATE_ENV = Environment(
+    loader=DictLoader(TEMPLATES),
+    autoescape=select_autoescape(["html", "xml"]),
+)
+def resolve_dashboard_project_dir(project_dir: str = ".") -> Path:
+    resolved = detect_project_root(project_dir)
+    if resolved is None:
+        raise FileNotFoundError(f"No .haxaml directory found from {Path(project_dir).resolve()}")
+    return resolved
+def dashboard_url(host: str, port: int) -> str:
+    return f"http://{host}:{port}/"
+def run_dashboard_server(
+    *,
+    project_dir: str,
+    host: str = DEFAULT_DASHBOARD_HOST,
+    port: int = DEFAULT_DASHBOARD_PORT,
+    open_browser: bool = True,
+    read_only: bool = True,
+) -> str:
+    app = create_dashboard_app(project_dir=project_dir, read_only=read_only)
+    url = dashboard_url(host, port)
+    if open_browser:
+        webbrowser.open(url)
+    uvicorn.run(app, host=host, port=port, log_level="warning")
+    return url
+def main() -> None:
+    run_dashboard_server(project_dir=".")
+def create_dashboard_app(*, project_dir: str, read_only: bool = True) -> Starlette:
+    root = resolve_dashboard_project_dir(project_dir)
+    app = Starlette(
+        debug=False,
+        routes=[
+            Route("/", _overview_page),
+            Route("/frame/{frame_name}", _frame_page),
+            Route("/archive", _archive_page),
+            Route("/archive/{kind}/{record_id}", _archive_detail_page),
+            Route("/static/app.css", _css_asset),
+        ],
+    )
+    app.state.project_dir = str(root)
+    app.state.read_only = bool(read_only)
+    return app
+def _render_page(
+    request: Request,
+    *,
+    title: str,
+    heading: str,
+    body: str,
+    project_name: str = "",
+) -> HTMLResponse:
+    template = _TEMPLATE_ENV.get_template("base.html")
+    return HTMLResponse(
+        template.render(
+            title=title,
+            heading=heading,
+            body=body,
+            project_dir=request.app.state.project_dir,
+            project_name=project_name,
+            read_only=request.app.state.read_only,
+            frame_nav=FRAME_PAGE_ORDER,
+        )
+    )
+async def _css_asset(_: Request) -> Response:
+    return Response(CSS, media_type="text/css")
+def _render_card(title: str, value: str, detail: str = "", *, warning: bool = False) -> str:
+    detail_html = f"<p class='subtle'>{escape(detail)}</p>" if detail else ""
+    klass = "card warning" if warning else "card"
+    return f"<section class='{klass}'><h3>{escape(title)}</h3><p>{escape(value)}</p>{detail_html}</section>"
+def _overview_body(project_dir: str) -> tuple[str, str]:
+    frame = FrameModel.load(project_dir)
+    project_name = str(((frame.facts or {}).get("identity") or {}).get("name", "")).strip()
+    runner = ExecutionRunner(project_dir)
+    health = runner.get_project_health()
+    stats = StateManager(str(frame_path(project_dir, "acts.yaml"))).get_stats() if frame.has_acts() else {}
+    archive_index = runtime_cache().get_archive_index(project_dir)
+    reconcile = reconcile_derivation(project_dir)
+    semantic = semantic_validate(frame)
+    consistency = frame_consistency_report(frame)
+    map_assessment = evaluate_map_complexity(project_dir)
+    map_errors, map_warnings = map_complexity_issues(map_assessment)
+    sync_state = _expect_sync_state(frame.acts or {})
+    cards = [
+        _render_card("Ready", "yes" if health.get("ready") else "no", "Validation and lifecycle readiness", warning=not health.get("ready")),
+        _render_card("Context Tokens", str(health.get("context_tokens", 0)), "Current full-context size"),
+        _render_card("Archive", f"{len(archive_index.index)} indexed records", "Shallow index loaded from archive"),
+        _render_card("Map Policy", format_map_complexity_summary(map_assessment), "Complexity and map expectation", warning=bool(map_errors)),
+        _render_card("Runs", str(stats.get("total_runs", 0)), "Hot plus archived"),
+        _render_card("Active Task", str(stats.get("active_task", "none")), "Current human-facing state"),
+    ]
+    warnings: list[str] = []
+    warnings.extend(str(item) for item in health.get("errors", []))
+    warnings.extend(str(item) for item in semantic.blocking)
+    warnings.extend(str(item) for item in semantic.warnings)
+    warnings.extend(str(item.get("message", "")) for item in consistency.get("findings", []))
+    warnings.extend(str(item) for item in map_warnings)
+    if sync_state.get("required"):
+        warnings.append(
+            f"expect.yaml sync pending for run {sync_state.get('pending_run_id') or 'unknown'}."
+        )
+    warnings = [item for item in warnings if item]
+    recent_decisions = (frame.acts or {}).get("decisions", []) if isinstance(frame.acts, dict) else []
+    recent_runs = archive_index.index[-5:] if archive_index.index else []
+    body = [
+        "<section class='grid'>",
+        *cards,
+        "</section>",
+        "<section class='panel stack'>",
+        "<div><h2>Signals</h2><p class='subtle'>Overview-first and read-only. Use drilldown pages for full YAML.</p></div>",
+        "<ul class='plain-list'>",
+        f"<li>Project: {escape(project_name or '(unnamed)')}</li>",
+        f"<li>Phase: {escape(str(stats.get('current_phase', 'unknown')))}</li>",
+        f"<li>Archive mode: {escape(str(stats.get('archive_mode', 'manual')))}</li>",
+        f"<li>Reconcile: {escape(str(reconcile.get('human_summary', 'No reconcile summary')))}</li>",
+        "</ul>",
+        "</section>",
+    ]
+    if warnings:
+        body.extend(
+            [
+                "<section class='panel warning'>",
+                "<h2>Lifecycle And Drift Warnings</h2>",
+                "<ul class='plain-list'>",
+                *[f"<li>{escape(item)}</li>" for item in warnings[:12]],
+                "</ul>",
+                "</section>",
+            ]
+        )
+    body.extend(
+        [
+            "<section class='grid'>",
+            "<div class='panel'><h2>Recent Decisions</h2><ul class='plain-list'>",
+            *[
+                f"<li>{escape(str(item.get('decision', '')))}"
+                f"{' — ' + escape(str(item.get('reasoning', ''))) if item.get('reasoning') else ''}</li>"
+                for item in recent_decisions[-5:]
+                if isinstance(item, dict)
+            ],
+            "</ul></div>",
+            "<div class='panel'><h2>Archive Summary</h2><ul class='plain-list'>",
+            *[
+                f"<li><a href='/archive/{escape(str(item.get('kind', '')))}"
+                f"/{escape(str(item.get('id', '')))}'>{escape(str(item.get('id', '')))}</a> "
+                f"{escape(str(item.get('summary', '')))}</li>"
+                for item in recent_runs
+            ],
+            "</ul></div>",
+            "</section>",
+        ]
+    )
+    return "".join(body), project_name
+async def _overview_page(request: Request) -> HTMLResponse:
+    body, project_name = _overview_body(request.app.state.project_dir)
+    return _render_page(
+        request,
+        title="Haxaml Dashboard",
+        heading="Overview",
+        body=body,
+        project_name=project_name,
+    )
+def _frame_body(project_dir: str, frame_name: str, q: str = "", view: str = "human") -> tuple[str, str]:
+    frame = FrameModel.load(project_dir)
+    data = frame.frame_file(frame_name)
+    path = frame_path(project_dir, f"{frame_name}.yaml")
+    project_name = str((((frame.facts or {}).get("identity")) or {}).get("name", "")).strip()
+    filter_text = q.strip().lower()
+    if view == "raw":
+        raw = yaml.dump(data or {}, default_flow_style=False, sort_keys=False)
+        return (
+            "<section class='toolbar'>"
+            f"<a class='button-link' href='/frame/{frame_name}?view=human'>Human view</a>"
+            f"<span class='pill'>{escape(str(path))}</span></section>"
+            f"<pre>{escape(raw)}</pre>",
+            project_name,
+        )
+    blocks: list[str] = [
+        "<section class='toolbar'>"
+        f"<a class='button-link' href='/frame/{frame_name}?view=raw'>Raw YAML</a>"
+        f"<span class='pill'>{escape(str(path))}</span>"
+        "</section>"
+    ]
+    if not isinstance(data, dict):
+        blocks.append(f"<section class='panel warning'><h2>{escape(frame_name)}</h2><p>File is missing.</p></section>")
+        return "".join(blocks), project_name
+    for key, value in data.items():
+        preview = yaml.dump(value, default_flow_style=False, sort_keys=False).strip()
+        haystack = f"{key}\n{preview}".lower()
+        if filter_text and filter_text not in haystack:
+            continue
+        blocks.append(
+            "<details open>"
+            f"<summary class='section-summary'>{escape(str(key))}</summary>"
+            f"<pre>{escape(preview)}</pre>"
+            "</details>"
+        )
+    if len(blocks) == 1:
+        blocks.append("<section class='panel'><p>No sections matched this filter.</p></section>")
+    return "".join(blocks), project_name
+async def _frame_page(request: Request) -> HTMLResponse:
+    frame_name = request.path_params["frame_name"]
+    if frame_name not in FRAME_PAGE_ORDER:
+        return HTMLResponse("Not found", status_code=404)
+    body, project_name = _frame_body(
+        request.app.state.project_dir,
+        frame_name,
+        q=str(request.query_params.get("q", "")),
+        view=str(request.query_params.get("view", "human")),
+    )
+    return _render_page(
+        request,
+        title=f"FRAME: {frame_name}",
+        heading=f"{frame_name}.yaml",
+        body=body,
+        project_name=project_name,
+    )
+def _archive_body(project_dir: str, q: str = "") -> tuple[str, str]:
+    frame = FrameModel.load(project_dir)
+    project_name = str((((frame.facts or {}).get("identity")) or {}).get("name", "")).strip()
+    archive_index = runtime_cache().get_archive_index(project_dir)
+    if not archive_index.exists:
+        return "<section class='panel'><h2>Archive</h2><p>No archive file found.</p></section>", project_name
+    filter_text = q.strip().lower()
+    items = archive_index.index
+    if filter_text:
+        items = [
+            item for item in items
+            if filter_text in yaml.dump(item, default_flow_style=False, sort_keys=False).lower()
+        ]
+    counts = archive_index.metadata.get("counts", {})
+    body = [
+        "<section class='panel'>",
+        "<h2>Archive Overview</h2>",
+        "<ul class='plain-list'>",
+        f"<li>Runs: {int(counts.get('runs', 0) or 0)}</li>",
+        f"<li>Sessions: {int(counts.get('sessions', 0) or 0)}</li>",
+        f"<li>Verifications: {int(counts.get('verifications', 0) or 0)}</li>",
+        "</ul>",
+        "</section>",
+        "<section class='panel'><h2>Indexed Records</h2><ul class='plain-list'>",
+    ]
+    for item in reversed(items[-25:]):
+        kind = str(item.get("kind", "")).strip()
+        record_id = str(item.get("id", "")).strip()
+        body.append(
+            f"<li><a href='/archive/{escape(kind)}/{escape(record_id)}'>{escape(record_id or kind)}</a> "
+            f"{escape(str(item.get('summary', '')))}</li>"
+        )
+    body.append("</ul></section>")
+    return "".join(body), project_name
+async def _archive_page(request: Request) -> HTMLResponse:
+    body, project_name = _archive_body(
+        request.app.state.project_dir,
+        q=str(request.query_params.get("q", "")),
+    )
+    return _render_page(
+        request,
+        title="Archive",
+        heading="Archive",
+        body=body,
+        project_name=project_name,
+    )
+async def _archive_detail_page(request: Request) -> HTMLResponse:
+    kind = str(request.path_params["kind"])
+    record_id = str(request.path_params["record_id"])
+    record = runtime_cache().load_archive_record_details(request.app.state.project_dir, kind, record_id)
+    if record is None:
+        return HTMLResponse("Not found", status_code=404)
+    frame = FrameModel.load(request.app.state.project_dir)
+    project_name = str((((frame.facts or {}).get("identity")) or {}).get("name", "")).strip()
+    body = (
+        f"<section class='toolbar'><a class='button-link' href='/archive'>Back to archive</a></section>"
+        f"<section class='panel'><h2>{escape(kind)}:{escape(record_id)}</h2>"
+        f"<pre>{escape(yaml.dump(record, default_flow_style=False, sort_keys=False))}</pre></section>"
+    )
+    return _render_page(
+        request,
+        title=f"Archive {kind}:{record_id}",
+        heading=f"Archive {kind}:{record_id}",
+        body=body,
+        project_name=project_name,
+    )

haxaml_ui-0.6.7/haxaml_ui.egg-info/PKG-INFO ADDED Viewed

@@ -0,0 +1,54 @@
+Metadata-Version: 2.4
+Name: haxaml-ui
+Version: 0.6.7
+Summary: Local read-only dashboard package for Haxaml.
+Author: Hax
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/haxsysgit/haxaml
+Project-URL: Repository, https://github.com/haxsysgit/haxaml
+Keywords: haxaml,dashboard,ui,developer-tools
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Web Environment
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Build Tools
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+Requires-Dist: haxaml<0.7.0,>=0.6.7
+Requires-Dist: jinja2>=3.1
+Requires-Dist: starlette>=0.37
+Requires-Dist: uvicorn>=0.30
+# haxaml-ui
+Read-only local dashboard package for Haxaml.
+This package is the dashboard distribution itself.
+The human launcher remains:
+```bash
+haxaml dashboard
+```
+`haxaml[ui]` is only the convenience install selector for the core package.
+Install directly:
+```bash
+pip install haxaml-ui
+```
+Or install through the core extra:
+```bash
+pip install "haxaml[ui]"
+```
+Direct package entrypoint is also available:
+```bash
+haxaml-dashboard
+```

haxaml_ui-0.6.7/haxaml_ui.egg-info/SOURCES.txt ADDED Viewed

@@ -0,0 +1,10 @@
+README.md
+pyproject.toml
+haxaml_ui/__init__.py
+haxaml_ui/dashboard.py
+haxaml_ui.egg-info/PKG-INFO
+haxaml_ui.egg-info/SOURCES.txt
+haxaml_ui.egg-info/dependency_links.txt
+haxaml_ui.egg-info/entry_points.txt
+haxaml_ui.egg-info/requires.txt
+haxaml_ui.egg-info/top_level.txt

haxaml_ui-0.6.7/haxaml_ui.egg-info/dependency_links.txt ADDED Viewed

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

haxaml_ui-0.6.7/haxaml_ui.egg-info/entry_points.txt ADDED Viewed

	@@ -0,0 +1,2 @@
1	+ [console_scripts]
2	+ haxaml-dashboard = haxaml_ui.dashboard:main

haxaml_ui-0.6.7/haxaml_ui.egg-info/requires.txt ADDED Viewed

@@ -0,0 +1,4 @@
+haxaml<0.7.0,>=0.6.7
+jinja2>=3.1
+starlette>=0.37
+uvicorn>=0.30

haxaml_ui-0.6.7/haxaml_ui.egg-info/top_level.txt ADDED Viewed

	@@ -0,0 +1 @@
1	+ haxaml_ui

haxaml_ui-0.6.7/pyproject.toml ADDED Viewed

@@ -0,0 +1,45 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+[project]
+name = "haxaml-ui"
+version = "0.6.7"
+description = "Local read-only dashboard package for Haxaml."
+readme = "README.md"
+requires-python = ">=3.11"
+license = "MIT"
+authors = [
+  { name = "Hax" }
+]
+keywords = [
+  "haxaml",
+  "dashboard",
+  "ui",
+  "developer-tools"
+]
+classifiers = [
+  "Development Status :: 4 - Beta",
+  "Environment :: Web Environment",
+  "Intended Audience :: Developers",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Topic :: Software Development :: Build Tools"
+]
+dependencies = [
+  "haxaml>=0.6.7,<0.7.0",
+  "jinja2>=3.1",
+  "starlette>=0.37",
+  "uvicorn>=0.30"
+]
+[project.scripts]
+haxaml-dashboard = "haxaml_ui.dashboard:main"
+[project.urls]
+Homepage = "https://github.com/haxsysgit/haxaml"
+Repository = "https://github.com/haxsysgit/haxaml"
+[tool.setuptools.packages.find]
+include = ["haxaml_ui*"]

haxaml_ui-0.6.7/setup.cfg ADDED Viewed

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build =
+tag_date = 0