nucore 0.2.0__py3-none-any.whl

nu/__init__.py

@@ -0,0 +1,216 @@
+# ruff: noqa
+"""Nu: the interaction primitive.
+
+Build apps in one primitive that spans your whole stack (databases, UIs,
+AI agents, and services). No glue. 50x less code.
+
+Two ways to import. Grab what you need flat from the root:
+
+    from nu import Int, Sequential, Retry, AttrRef, Nu, run
+
+Or reach a subpackage by dot-access:
+
+    import nu
+    nu.forms.Int    nu.core.Add    nu.flows.Sequential
+    nu.spans.Retry      nu.shape.Shape      nu.tree.map_nodes
+    nu.mem.IntRef       nu.kv.presets.memory_storage
+    nu.ui.Page          nu.std.uuid.UUID
+"""
+
+from __future__ import annotations
+
+from importlib.metadata import PackageNotFoundError, version as _version
+from pkgutil import extend_path as _extend_path
+from typing import TYPE_CHECKING
+
+
+# `nu` is split across two distributions: `nucore` (this file, the kernel)
+# and `nustd` (the fabrics: std, mem, kv, service, llm, cc, http, proxy, mp,
+# cluster, ui). Installed as wheels the two land in the same
+# `site-packages/nu/` and nothing special is needed; installed editable they
+# sit in two separate `src/` trees, so widen `__path__` to pick up both. Only
+# this file exists as `nu/__init__.py` — the kernel owns the package root.
+__path__ = _extend_path(__path__, __name__)
+del _extend_path
+
+try:
+    __version__ = _version("nucore")
+except PackageNotFoundError:
+    __version__ = "0.0.0+dev"
+del _version, PackageNotFoundError
+
+from ._config import bootstrap as _bootstrap
+
+_bootstrap()
+del _bootstrap
+
+# Subpackage namespaces for dot-access.
+# Early group: pure layers with no dependency on the flat root surface.
+from . import context, core, engine, factory, flows, forms, info, lang, prog, spans, tree
+from .domains import shape
+
+# Flat re-exports: the program-authoring surface.
+from .context import *
+from .core import *
+from .flows import *
+from .forms import *
+from .spans import *
+
+# Shape DSL only; fabric atoms (Load, SetCmd, ...) stay at nu.shape.*.
+from .domains.shape import Shape, Slot
+from .domains.service import Method, Service
+
+# The program pipeline (nu.prog fabric). Flat: ``nu.LoadNu`` beside ``nu.Eval``,
+# because ``Eval(LoadNu(src))`` is one authoring idiom, and ``nu.Program``
+# beside them because it is the Form you write that pair with - it sits with
+# the other Forms on the flat surface, not with the machinery. The brace
+# resource and the error types stay at ``nu.prog.*``, the same way
+# ``nu.mp.MpWorker`` does.
+from .prog import Eval, LoadNu, Program
+
+# Language essentials, curated to the building blocks of a Nu program:
+#   - the root kind (``Nu``, ``TypedNu``);
+#   - the kind hierarchy (``Ref``, ``Interaction``, ``Query`` / ``ScalarQuery``
+#     / ``StreamQuery`` / ``Reduction``, ``Command``, ``Action`` /
+#     ``ScalarAction`` / ``StreamAction``, ``Flow`` / ``Strategy`` /
+#     ``Control``, ``Span`` / ``Bracket`` / ``Policy``);
+#   - the argument aliases used in kind signatures (``Arg`` and the typed
+#     ``*Arg`` aliases).
+from .lang import (
+    Action,
+    Arg,
+    BoolArg,
+    Bracket,
+    BytesArg,
+    Command,
+    Context,
+    Control,
+    DictArg,
+    FloatArg,
+    Flow,
+    Form,
+    FrozenSetArg,
+    IntArg,
+    Interaction,
+    ListArg,
+    NoneArg,
+    Nu,
+    Policy,
+    Query,
+    Reduction,
+    Ref,
+    Runtime,
+    ScalarAction,
+    ScalarQuery,
+    SetArg,
+    Span,
+    StrArg,
+    Strategy,
+    StreamAction,
+    StreamQuery,
+    TupleArg,
+    TypedNu,
+)
+
+# Atom builders (nu.factory subpackage): factories + @host.
+from .factory import (
+    InteractionFactory,
+    host,
+)
+
+# Entry points.
+from .lang.helpers import (
+    acollect,
+    aeval,
+    afirst,
+    alast,
+    arun,
+    collect,
+    compile,
+    eval,
+    eval_in_loop,
+    first,
+    run,
+    run_in_loop,
+    validate,
+)
+
+# Late subpackage namespaces: fabric adapters and higher layers that reach into
+# the flat root surface (e.g. ``from nu import Shape``). These are heavy and
+# transitively pull large trees (storage backends, UI runtime, RPC, ...), so
+# they load lazily on first attribute access via ``__getattr__`` below. The
+# ``TYPE_CHECKING`` block gives IDEs and type-checkers the real modules so
+# ``nu.mem.IntRef`` etc. resolve statically with full completion / go-to-def.
+if TYPE_CHECKING:
+    from . import cc, cluster, http, kv, llm, mem, mp, proxy, service, std, ui
+
+# NOTE: several flat re-exports above shadow Python builtins at module scope
+# — coercion atoms (``set``/``frozenset``/``tuple``/``list``/``dict``/``int``/
+# ``float``/``str``/``bool``), IO atoms (``print``/``input``), and language
+# helpers (``compile``/``eval``). They stay reachable as ``nu.set`` etc., but
+# ``from nu import *`` skips them (see ``_SHADOWS_BUILTIN`` below) so callers
+# don't get their builtins silently swapped. Any set/dict-builder logic in
+# THIS file must use literals (``{...}``) — never the shadowed callables.
+#
+# Every name below ships in the `nustd` distribution, not in `nucore`.
+# The two wheels merge into one ``site-packages/nu/`` directory (only the
+# kernel carries ``nu/__init__.py``), so on a kernel-only install these
+# submodules are simply absent — hence the install hint in __getattr__.
+# The value is the extra that pulls the fabric's backend, or None when the
+# fabric is pure stdlib and plain ``nustd`` is enough.
+_LAZY = {
+    "cc": "cc",
+    "cluster": "cluster",
+    "http": "http",
+    "kv": "kv",
+    "llm": "llm",
+    "mem": "mem",
+    "mp": None,
+    "proxy": "proxy",
+    "service": None,
+    "std": None,
+    "ui": "ui",
+}
+
+
+def __getattr__(name):
+    import importlib
+    import importlib.util
+
+    if name not in _LAZY:
+        raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
+    try:
+        mod = importlib.import_module(f".{name}", __name__)
+    except ImportError as exc:
+        # Distinguish "nustd is not installed" from "the fabric is there but
+        # its backend blew up" — the second must surface the real error.
+        if importlib.util.find_spec(f"{__name__}.{name}") is not None:
+            raise
+        extra = _LAZY[name]
+        target = f"nustd[{extra}]" if extra else "nustd"
+        msg = f"nu.{name} requires nustd: pip install {target}"
+        raise AttributeError(msg) from exc
+    globals()[name] = mod
+    return mod
+
+
+def __dir__():
+    return sorted({*globals(), *_LAZY})
+
+
+# __all__ = every name bound above (minus privates, the ``__future__`` shim,
+# the internal ``domains`` layer, and any name shadowing a Python builtin)
+# plus the lazy fabric + alias names, so ``from nu import *`` and IDE
+# discovery see them without forcing import. Builtin-shadowing names stay
+# reachable as ``nu.<name>`` — the module dict is unchanged, only ``__all__``
+# is filtered — so ``import *`` cannot silently rebind ``set``/``print``/etc.
+# in the caller's namespace.
+import builtins as _builtins  # noqa: E402  (placed here to avoid the shadowed scope above)
+
+_HIDDEN = {"annotations", "TYPE_CHECKING", "domains"}
+_SHADOWS_BUILTIN = {n for n in dir(_builtins) if not n.startswith("_")}
+_names = dir()
+__all__ = sorted(
+    ({*_names, *_LAZY} - _HIDDEN - _SHADOWS_BUILTIN) - {n for n in _names if n.startswith("_")}
+)
+del _builtins, _names

nu/_config/__init__.py

@@ -0,0 +1,50 @@
+"""Internal: ``~/.nu`` user config and anonymous usage telemetry.
+
+Layout:
+
+- :mod:`nu._config.constants` -- all paths, defaults, and PostHog
+  wiring. Single source of truth.
+- :mod:`nu._config.config` -- read/write ``~/.nu/config.json``,
+  telemetry opt-out flag, stable ``distinct_id``.
+- :mod:`nu._config.telemetry` -- fire-and-forget PostHog capture.
+
+Hot path: :func:`bootstrap` does one ``exists()`` syscall and returns
+immediately when the first-run marker is already in place; the config
+and telemetry submodules are only imported on first-run bootstrap and
+explicit CLI / nudle calls.
+"""
+
+from .constants import CONFIG_PATH as CONFIG_PATH
+from .constants import FIRST_RUN_MARKER_PATH as FIRST_RUN_MARKER_PATH
+from .constants import HOME as HOME
+
+
+def bootstrap() -> None:
+    """First-touch bootstrap for ``~/.nu``.
+
+    Fast path: one ``exists()`` syscall on the first-run marker; the
+    marker is only written after a successful capture, which itself
+    only runs once the config file exists, so its presence implies
+    both are in place.
+
+    Otherwise: create the config on first ever import, and (re)fire
+    the first-run event on every import until the POST gets a 2xx and
+    drops the marker. That covers short-lived commands
+    (``nu --help``, ``python -c "import nu"``) where a daemon POST
+    would otherwise be killed on process exit. Silent on any failure.
+    """
+    try:
+        if FIRST_RUN_MARKER_PATH.exists():
+            return
+        from .telemetry import capture_first_run
+
+        if not CONFIG_PATH.exists():
+            from .config import create_default
+
+            capture_first_run(create_default())
+        else:
+            from .config import distinct_id
+
+            capture_first_run(distinct_id())
+    except Exception:  # noqa: S110
+        pass

nu/_config/branding/__init__.py

@@ -0,0 +1,28 @@
+"""Nu brand kit: palette + logo + shared header. Consumed by nudle and nucli.
+
+Stdlib only -- it renders straight to ANSI escapes (see :mod:`.ansi`), so it
+sits in the kernel without pulling a terminal library in behind it.
+"""
+
+from __future__ import annotations
+
+from .ansi import RESET, color_enabled, paint
+from .header import DOCS_URL, GITHUB_URL, TAGLINE, header, render_header
+from .logo import logo, logo_lines
+from .palette import BLUE, PURPLE
+
+
+__all__ = [
+    "BLUE",
+    "DOCS_URL",
+    "GITHUB_URL",
+    "PURPLE",
+    "RESET",
+    "TAGLINE",
+    "color_enabled",
+    "header",
+    "logo",
+    "logo_lines",
+    "paint",
+    "render_header",
+]

nu/_config/branding/ansi.py

@@ -0,0 +1,96 @@
+"""Minimal ANSI SGR helpers -- the brand kit's whole rendering layer.
+
+Stdlib only, on purpose: the brand kit lives in the kernel now, and the
+kernel takes no dependency beyond ``typing-extensions`` and ``cloudpickle``.
+Everything here is a plain string transform.
+
+Two rules govern whether escapes are emitted at all:
+
+- ``NO_COLOR`` set to a non-empty value disables them (https://no-color.org).
+- the target stream must be a tty; piping ``nu`` into a file or a pager
+  must never leak escape junk.
+
+Attribute order in the emitted sequence matches what rich produced before
+(bold, dim, underline, then the truecolor foreground) so terminal output is
+byte-identical to the previous rich-rendered brand kit.
+"""
+
+from __future__ import annotations
+
+import os
+import sys
+from typing import TYPE_CHECKING
+
+
+if TYPE_CHECKING:
+    from typing import IO
+
+
+__all__ = ["RESET", "color_enabled", "paint"]
+
+RESET = "\x1b[0m"
+
+
+def color_enabled(stream: IO[str] | None = None) -> bool:
+    """Whether ``stream`` should get ANSI escapes.
+
+    Args:
+        stream: the destination. Defaults to ``sys.stdout``.
+
+    Returns:
+        ``True`` only when ``NO_COLOR`` is unset/empty and the stream is a
+        tty. A stream that raises or has no ``isatty`` counts as not a tty.
+    """
+    if os.environ.get("NO_COLOR"):
+        return False
+    stream = sys.stdout if stream is None else stream
+    try:
+        return bool(stream.isatty())
+    except Exception:
+        return False
+
+
+def _hex_to_rgb(color: str) -> tuple[int, int, int]:
+    """``"#7a4ce0"`` -> ``(122, 76, 224)``."""
+    value = color.lstrip("#")
+    return int(value[0:2], 16), int(value[2:4], 16), int(value[4:6], 16)
+
+
+def paint(
+    text: str,
+    *,
+    fg: str | None = None,
+    bold: bool = False,
+    dim: bool = False,
+    underline: bool = False,
+    enabled: bool = True,
+) -> str:
+    """Wrap ``text`` in one SGR sequence, or return it untouched.
+
+    Args:
+        text: the string to style.
+        fg: foreground as a ``#rrggbb`` hex string, or ``None``.
+        bold: emit SGR 1.
+        dim: emit SGR 2.
+        underline: emit SGR 4.
+        enabled: when ``False``, or when no attribute is requested, ``text``
+            comes back unchanged with no escapes at all.
+
+    Returns:
+        The styled string, always terminated by a reset when styled.
+    """
+    if not enabled or not text:
+        return text
+    codes: list[str] = []
+    if bold:
+        codes.append("1")
+    if dim:
+        codes.append("2")
+    if underline:
+        codes.append("4")
+    if fg is not None:
+        r, g, b = _hex_to_rgb(fg)
+        codes.append(f"38;2;{r};{g};{b}")
+    if not codes:
+        return text
+    return f"\x1b[{';'.join(codes)}m{text}{RESET}"

nu/_config/branding/header.py

@@ -0,0 +1,80 @@
+"""Shared Nu header: logo on the left, tagline + version + urls on the right.
+
+Used by the CLI (`nu` with no args) and the nudle server banner -- one
+shared visual identity across every user-facing entrypoint.
+
+The two columns are laid out by hand (a fixed-width left cell, four spaces
+of gutter, a right cell padded to its widest line, right block vertically
+centred against the mark) so the kernel needs no table renderer.
+"""
+
+from __future__ import annotations
+
+import sys
+from importlib.metadata import PackageNotFoundError, version
+from typing import TYPE_CHECKING
+
+from .ansi import color_enabled, paint
+from .logo import WIDTH as _LOGO_WIDTH
+from .logo import logo_lines
+from .palette import BLUE
+
+
+if TYPE_CHECKING:
+    from typing import IO
+
+
+TAGLINE = "The interaction primitive"
+DOCS_URL = "https://nustack.dev"
+GITHUB_URL = "https://github.com/nustackdev/nu"
+
+# Gutter between the mark and the label block.
+_GUTTER = "    "
+
+
+def _nu_version() -> str:
+    try:
+        return version("nucore")
+    except PackageNotFoundError:
+        return "0.0.0+dev"
+
+
+def _side(color: bool) -> list[tuple[str, str]]:
+    """The right-hand label block as ``(plain, rendered)`` lines."""
+    ver = f"v{_nu_version()}"
+    return [
+        (TAGLINE, TAGLINE),
+        (ver, paint(ver, fg=BLUE, bold=True, enabled=color)),
+        ("", ""),
+        (DOCS_URL, paint(DOCS_URL, fg=BLUE, underline=True, enabled=color)),
+        ("", ""),
+        (GITHUB_URL, paint(GITHUB_URL, fg=BLUE, underline=True, enabled=color)),
+    ]
+
+
+def header(*, color: bool = True) -> str:
+    """The header block as one string, blank line above and below."""
+    # ``logo`` ends on a newline, so the mark occupies one blank row past its
+    # last glyph row -- that row is part of the block and gets padded too.
+    # Every glyph row is exactly ``_LOGO_WIDTH`` cells wide, so the left column
+    # needs no padding of its own; the trailing row is that width in spaces.
+    left = [*logo_lines(color=color), " " * _LOGO_WIDTH]
+
+    side = _side(color)
+    right_width = max(len(plain) for plain, _ in side)
+    # Vertically centre the labels against the mark, rich's ``vertical="middle"``.
+    top = (len(left) - len(side)) // 2
+    blank = ("", "")
+    rows = [blank] * top + side + [blank] * (len(left) - len(side) - top)
+
+    lines = [""]
+    for mark, (plain, rendered) in zip(left, rows, strict=True):
+        lines.append(mark + _GUTTER + rendered + " " * (right_width - len(plain)))
+    lines.append("")
+    return "\n".join(lines)
+
+
+def render_header(file: IO[str] | None = None) -> None:
+    """Print the shared Nu header: logo on the left, labels on the right."""
+    stream = sys.stdout if file is None else file
+    print(header(color=color_enabled(stream)), file=stream, flush=True)

nu/_config/branding/logo.py

@@ -0,0 +1,61 @@
+"""Nu mark rendered as terminal braille glyphs.
+
+Compact 2x4 sub-pixel braille packing of the SVG mark -- two interlocking
+glyphs, purple top-left and blue bottom-right matching the SVG gradient
+stops.
+
+Baked once from the source PNG so this module has zero runtime deps beyond
+the stdlib.
+"""
+
+from __future__ import annotations
+
+from .ansi import paint
+from .palette import BLUE, PURPLE
+
+
+_COLOR = {"P": PURPLE, "B": BLUE}
+
+# 16 cols x 8 rows braille grid; each row is (glyphs, per-cell color tag —
+# 'P' purple, 'B' blue, '.' blank).
+_LOGO: tuple[tuple[str, str], ...] = (
+    ("⠀⢀⣤⣶⣾⣿⣿⣿⣿⣿⣿⡇⠀⢰⣿⣿", ".PPPPPPPPPPP.PPB"),
+    ("⣰⣿⣿⠟⠋⠉⠉⠉⠉⣿⣿⡇⠀⢸⣿⣿", "PPPPPPPPPPPP.BBB"),
+    ("⣿⣿⡇⠀⠀⣀⣀⠀⠀⣿⣿⡇⠀⢸⣿⣿", "PPP..PP..PPB.BBB"),
+    ("⣿⣿⡇⠀⢸⣿⣿⠀⠀⣿⣿⡇⠀⢸⣿⣿", "PPP.PPP..BBB.BBB"),
+    ("⣿⣿⡇⠀⢸⣿⣿⠀⠀⣿⣿⡇⠀⢸⣿⣿", "PPP.PPP..BBB.BBB"),
+    ("⣿⣿⡇⠀⢸⣿⣿⠀⠀⠉⠉⠀⠀⢸⣿⣿", "PPP.PBB..BB..BBB"),
+    ("⣿⣿⡇⠀⢸⣿⣿⣀⣀⣀⣀⣠⣴⣿⣿⠏", "PPP.BBBBBBBBBBBB"),
+    ("⣿⣿⠇⠀⢸⣿⣿⣿⣿⣿⣿⡿⠿⠛⠁⠀", "PBB.BBBBBBBBBBB."),
+)
+
+# Every row is the same width; the header lays the mark out against this.
+WIDTH = len(_LOGO[0][0])
+
+
+def logo_lines(*, color: bool = True) -> list[str]:
+    """The mark, one rendered string per row.
+
+    Args:
+        color: emit ANSI escapes. When ``False`` the glyphs come back bare.
+
+    Returns:
+        Eight strings, each ``WIDTH`` glyphs wide once escapes are stripped.
+    """
+    return [_row(chars, colors, color) for chars, colors in _LOGO]
+
+
+def logo(*, color: bool = True) -> str:
+    """The mark as one block of eight rows, each terminated by a newline."""
+    return "".join(f"{line}\n" for line in logo_lines(color=color))
+
+
+def _row(chars: str, colors: str, color: bool) -> str:
+    """One grid row, collapsed into runs of equal colour tag."""
+    out: list[str] = []
+    start = 0
+    for i in range(1, len(colors) + 1):
+        if i == len(colors) or colors[i] != colors[start]:
+            out.append(paint(chars[start:i], fg=_COLOR.get(colors[start]), enabled=color))
+            start = i
+    return "".join(out)

nu/_config/branding/palette.py

@@ -0,0 +1,11 @@
+"""Nu brand palette -- the SVG gradient stops, canonical for the whole codebase.
+
+Import ``PURPLE``/``BLUE`` from here whenever you need an accent; there is no
+"cyan" or ad-hoc third color in the Nu palette.
+"""
+
+from __future__ import annotations
+
+
+PURPLE = "#7a4ce0"
+BLUE = "#3e72e7"

nu/_config/config.py

@@ -0,0 +1,89 @@
+"""User config at ``~/.nu/config.json``.
+
+One JSON file, machine-managed. Holds the telemetry opt-out flag and a
+stable anonymous ``distinct_id``. Created on first `nu` import or CLI
+run; that first-touch is the signal that a human actually installed
+and used Nu (see :mod:`nu._config.telemetry`).
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import uuid
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+from .constants import CONFIG_DEFAULTS, CONFIG_PATH, HOME
+
+
+if TYPE_CHECKING:
+    from typing import Any
+
+
+def load() -> dict[str, Any]:
+    """Read the config file; return {} if it does not exist or is unreadable."""
+    try:
+        return json.loads(CONFIG_PATH.read_text())
+    except (OSError, json.JSONDecodeError):
+        return {}
+
+
+def save(cfg: dict[str, Any]) -> None:
+    """Write config atomically (temp + rename)."""
+    HOME.mkdir(parents=True, exist_ok=True)
+    tmp = CONFIG_PATH.with_suffix(".json.tmp")
+    tmp.write_text(json.dumps(cfg, indent=2, sort_keys=True) + "\n")
+    tmp.replace(CONFIG_PATH)
+
+
+def create_default() -> str:
+    """Create the config with defaults; return the new distinct_id.
+
+    Caller must have checked that :data:`CONFIG_PATH` does not exist --
+    this always writes.
+    """
+    did = str(uuid.uuid4())
+    save({**CONFIG_DEFAULTS, "distinct_id": did})
+    return did
+
+
+def telemetry_enabled() -> bool:
+    """Effective telemetry state (config flag, defaulting on)."""
+    return bool(load().get("telemetry", True))
+
+
+def set_telemetry(on: bool) -> None:
+    """Flip the telemetry flag, preserving the rest of the config."""
+    cfg = load() or {**CONFIG_DEFAULTS, "distinct_id": str(uuid.uuid4())}
+    cfg["telemetry"] = bool(on)
+    save(cfg)
+
+
+def distinct_id() -> str:
+    """Stable anonymous id. Generated on first :func:`create_default` call."""
+    did = load().get("distinct_id")
+    if isinstance(did, str) and did:
+        return did
+    return "unknown"
+
+
+def is_dev_install() -> bool:
+    """True when Nu is imported from a source checkout (editable install).
+
+    Heuristic: a ``pyproject.toml`` sits within a few levels above
+    ``nu/__init__.py`` (the ``src/nu`` layout used in this repo). Env
+    override ``NU_DEV=1`` forces dev mode; ``NU_DEV=0`` forces prod.
+    """
+    override = os.environ.get("NU_DEV")
+    if override == "1":
+        return True
+    if override == "0":
+        return False
+    here = Path(__file__).resolve()
+    for depth in (3, 4, 5):
+        if depth >= len(here.parents):
+            break
+        if (here.parents[depth] / "pyproject.toml").exists():
+            return True
+    return False

nu/_config/constants.py

@@ -0,0 +1,33 @@
+"""Single source of truth for ``~/.nu`` paths and PostHog wiring.
+
+Everything the ``_config`` subpackage would otherwise hardcode lives
+here: filesystem layout under ``~/.nu``, config defaults, and the
+PostHog capture endpoint. Env vars ``NU_POSTHOG_TOKEN`` /
+``NU_POSTHOG_HOST`` override the baked-in defaults (local testing
+against a different PostHog project).
+"""
+
+from __future__ import annotations
+
+import os
+from pathlib import Path
+
+
+HOME = Path.home() / ".nu"
+CONFIG_PATH = HOME / "config.json"
+DEMOS_DIR = HOME / "demos"
+FIRST_RUN_MARKER_PATH = HOME / "first_run.sent"
+
+CONFIG_DEFAULTS: dict[str, object] = {"telemetry": True}
+
+# PostHog Project API key -- public write-only token, safe to embed
+# (same one baked into the docs site's client bundle).
+POSTHOG_TOKEN = os.environ.get(
+    "NU_POSTHOG_TOKEN", "phc_yRpWfpoMeeRM8sKMPGPEsGy8ygNHJTpsGwrsikfpRfFz"
+)
+POSTHOG_HOST = os.environ.get("NU_POSTHOG_HOST", "https://t.nustack.dev").rstrip("/")
+POSTHOG_CAPTURE_PATH = "/i/v0/e/"
+
+FIRST_RUN_EVENT = "nu_first_run"
+
+HTTP_TIMEOUT_SECONDS = 3