dstrack 0.1.0__tar.gz

dstrack-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Leonardo Ayala
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

dstrack-0.1.0/PKG-INFO

@@ -0,0 +1,123 @@
+Metadata-Version: 2.4
+Name: dstrack
+Version: 0.1.0
+Summary: A Python package for versioning and monitoring dataset changes throughout the machine learning lifecycle.
+Keywords: dataset,versioning,monitoring,machine learning,mlops,data science
+Author: Leonardo Ayala
+License-Expression: MIT
+License-File: LICENSE
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Dist: rich>=15.0.0
+Requires-Dist: typer>=0.26.8
+Requires-Python: >=3.11
+Project-URL: GitHub, https://github.com/leoyala/dstrack
+Description-Content-Type: text/markdown
+
+# dstrack
+
+[![Unit Tests](https://github.com/leoyala/dstrack/actions/workflows/unittests.yaml/badge.svg)](https://github.com/leoyala/dstrack/actions/workflows/unittests.yaml)
+[![codecov](https://codecov.io/github/leoyala/dstrack/graph/badge.svg?token=DEKCE4LR88)](https://codecov.io/github/leoyala/dstrack)
+
+<p align="center">
+  <img src="docs/assets/dstrack-logo.png" width="200" alt="dstrack logo">
+</p>
+
+
+A Python package for versioning and monitoring dataset changes throughout the machine learning lifecycle.
+
+<p align="center">
+  <img src="docs/assets/cli.gif" alt="CLI example">
+</p>
+
+## Overview
+
+`dstrack` helps data scientists and ML engineers track how datasets evolve over time, catching schema drift, distribution shifts, and unexpected mutations before they silently break pipelines or degrade model performance.
+
+## What dstrack is (and isn't)
+
+`dstrack` records *semantics* about a dataset - its schema, a content fingerprint, and per-column statistics - not the dataset itself.
+It is not a data version control system: unlike DVC, LakeFS, or Git LFS, it never copies your files into a store or pushes them to a
+remote, and it cannot check an old version of `data.csv` back out for you. Your data stays wherever it already lives, and `dstrack` keeps a small,
+human-readable audit trail beside your code so you can see how that data changed and when. If you need to store and retrieve the bytes, reach for
+DVC and use `dstrack` alongside it.
+
+## Installation
+
+```bash
+pip install dstrack
+```
+
+Requires Python 3.11 or later.
+
+## Getting started
+
+Initialize a store in your project, then take your first snapshot.
+
+**1. Create a local store** - this adds a `.dstrack/` directory at the current location:
+
+```bash
+dstrack init
+```
+
+```text
+ℹ Generating local store structure at /path/to/.dstrack.
+✔ Finished creating local store: /path/to/.dstrack
+```
+
+**2. Track a dataset** - point `dstrack` at a data file to snapshot it. Given a small
+`data.csv`:
+
+```csv
+id,name,value
+1,alpha,10.5
+2,beta,20.0
+3,gamma,15.25
+```
+
+```bash
+dstrack track data.csv
+```
+
+```text
+ℹ Reading data.csv and computing snapshot...
+✔ Snapshot <snapshot-uuid> written (new dataset, dataset <dataset-uuid>).
+ℹ Stored at /path/to/.dstrack/datasets/<dataset-uuid>/snapshots/<snapshot-uuid>.json
+```
+
+**3. Re-track as the data changes** - running `track` again on the same path extends the
+dataset's lineage instead of starting a new one:
+
+```bash
+dstrack track data.csv
+```
+
+```text
+✔ Snapshot <snapshot-uuid> written (continued lineage, dataset <dataset-uuid>).
+```
+
+Each snapshot captures the file's schema, a content fingerprint, and per-column
+statistics. See the [Getting Started guide](https://leoyala.github.io/dstrack/getting_started/)
+for options such as `--name`, `--reader`, and `--dataset-id`.
+
+## Features
+
+- **Dataset versioning** - snapshot a dataset and track its lineage across pipeline stages
+- **Rich snapshots** - schema hash, content fingerprint, and per-column statistics (ranges, null rates, and more)
+- **CSV out of the box** - pure standard-library reader, no heavy dependencies
+- **Lightweight CLI** - a small, git-like local store you can commit alongside your code
+
+## Roadmap
+
+Change detection and drift monitoring are on the way - comparing snapshots, surfacing
+schema and distribution shifts, and failing CI on drift. See the
+[roadmap](docs/roadmap.md) for what's planned.

dstrack-0.1.0/README.md

@@ -0,0 +1,98 @@
+# dstrack
+
+[![Unit Tests](https://github.com/leoyala/dstrack/actions/workflows/unittests.yaml/badge.svg)](https://github.com/leoyala/dstrack/actions/workflows/unittests.yaml)
+[![codecov](https://codecov.io/github/leoyala/dstrack/graph/badge.svg?token=DEKCE4LR88)](https://codecov.io/github/leoyala/dstrack)
+
+<p align="center">
+  <img src="docs/assets/dstrack-logo.png" width="200" alt="dstrack logo">
+</p>
+
+
+A Python package for versioning and monitoring dataset changes throughout the machine learning lifecycle.
+
+<p align="center">
+  <img src="docs/assets/cli.gif" alt="CLI example">
+</p>
+
+## Overview
+
+`dstrack` helps data scientists and ML engineers track how datasets evolve over time, catching schema drift, distribution shifts, and unexpected mutations before they silently break pipelines or degrade model performance.
+
+## What dstrack is (and isn't)
+
+`dstrack` records *semantics* about a dataset - its schema, a content fingerprint, and per-column statistics - not the dataset itself.
+It is not a data version control system: unlike DVC, LakeFS, or Git LFS, it never copies your files into a store or pushes them to a
+remote, and it cannot check an old version of `data.csv` back out for you. Your data stays wherever it already lives, and `dstrack` keeps a small,
+human-readable audit trail beside your code so you can see how that data changed and when. If you need to store and retrieve the bytes, reach for
+DVC and use `dstrack` alongside it.
+
+## Installation
+
+```bash
+pip install dstrack
+```
+
+Requires Python 3.11 or later.
+
+## Getting started
+
+Initialize a store in your project, then take your first snapshot.
+
+**1. Create a local store** - this adds a `.dstrack/` directory at the current location:
+
+```bash
+dstrack init
+```
+
+```text
+ℹ Generating local store structure at /path/to/.dstrack.
+✔ Finished creating local store: /path/to/.dstrack
+```
+
+**2. Track a dataset** - point `dstrack` at a data file to snapshot it. Given a small
+`data.csv`:
+
+```csv
+id,name,value
+1,alpha,10.5
+2,beta,20.0
+3,gamma,15.25
+```
+
+```bash
+dstrack track data.csv
+```
+
+```text
+ℹ Reading data.csv and computing snapshot...
+✔ Snapshot <snapshot-uuid> written (new dataset, dataset <dataset-uuid>).
+ℹ Stored at /path/to/.dstrack/datasets/<dataset-uuid>/snapshots/<snapshot-uuid>.json
+```
+
+**3. Re-track as the data changes** - running `track` again on the same path extends the
+dataset's lineage instead of starting a new one:
+
+```bash
+dstrack track data.csv
+```
+
+```text
+✔ Snapshot <snapshot-uuid> written (continued lineage, dataset <dataset-uuid>).
+```
+
+Each snapshot captures the file's schema, a content fingerprint, and per-column
+statistics. See the [Getting Started guide](https://leoyala.github.io/dstrack/getting_started/)
+for options such as `--name`, `--reader`, and `--dataset-id`.
+
+## Features
+
+- **Dataset versioning** - snapshot a dataset and track its lineage across pipeline stages
+- **Rich snapshots** - schema hash, content fingerprint, and per-column statistics (ranges, null rates, and more)
+- **CSV out of the box** - pure standard-library reader, no heavy dependencies
+- **Lightweight CLI** - a small, git-like local store you can commit alongside your code
+
+## Roadmap
+
+Change detection and drift monitoring are on the way - comparing snapshots, surfacing
+schema and distribution shifts, and failing CI on drift. See the
+[roadmap](docs/roadmap.md) for what's planned.

dstrack-0.1.0/pyproject.toml

@@ -0,0 +1,114 @@
+[project]
+name = "dstrack"
+version = "0.1.0"
+description = "A Python package for versioning and monitoring dataset changes throughout the machine learning lifecycle."
+readme = "README.md"
+license = "MIT"
+license-files = ["LICENSE"]
+authors = [
+    { name = "Leonardo Ayala" }
+]
+keywords = ["dataset", "versioning", "monitoring", "machine learning", "mlops", "data science"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "Intended Audience :: Science/Research",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
+    "Topic :: Scientific/Engineering :: Artificial Intelligence",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+]
+requires-python = ">=3.11"
+dependencies = [
+    "rich>=15.0.0",
+    "typer>=0.26.8",
+]
+
+[project.urls]
+GitHub = "https://github.com/leoyala/dstrack"
+
+[project.scripts]
+dstrack = "dstrack._cli:app"
+dstrack-benchmark = "dstrack._benchmark:app"
+
+[build-system]
+requires = ["uv_build>=0.11.28,<0.12.0"]
+build-backend = "uv_build"
+
+# -----------------------------------------------------------------------------
+# Ruff: linter + formatter
+# -----------------------------------------------------------------------------
+[tool.ruff]
+line-length = 88
+src = ["src", "tests"]
+
+[tool.ruff.lint]
+# A pragmatic, high-signal rule set.
+select = [
+    "E",    # pycodestyle errors
+    "W",    # pycodestyle warnings
+    "F",    # pyflakes
+    "I",    # isort (import sorting)
+    "B",    # flake8-bugbear (likely bugs)
+    "UP",   # pyupgrade (modernize syntax)
+    "SIM",  # flake8-simplify
+    "C4",   # flake8-comprehensions
+    "PERF", # perflint (performance anti-patterns)
+    "RUF",  # ruff-specific rules
+]
+ignore = [
+    "E501",  # line length is handled by the formatter
+]
+
+[tool.ruff.lint.per-file-ignores]
+# Tests can use assert, magic values, etc.
+"tests/**" = ["B", "S101"]
+
+[tool.ruff.lint.pydocstyle]
+convention = "google"
+
+[tool.ruff.format]
+docstring-code-format = true
+quote-style = "double"
+
+# -----------------------------------------------------------------------------
+# mypy: static type checking
+# -----------------------------------------------------------------------------
+[tool.mypy]
+files = ["src"]
+python_version = "3.11"
+strict = true
+show_error_codes = true
+warn_unreachable = true
+warn_redundant_casts = true
+warn_unused_ignores = true
+enable_error_code = ["ignore-without-code", "redundant-expr", "truthy-bool"]
+
+# Silence missing stubs for third-party libs that don't ship types.
+[[tool.mypy.overrides]]
+module = [
+    "numpy.*",
+    "pandas.*",
+    "sklearn.*",
+]
+ignore_missing_imports = true
+
+# -----------------------------------------------------------------------------
+# codespell: spell-checking for code, docstrings, and docs
+# -----------------------------------------------------------------------------
+[tool.codespell]
+ignore-words-list = "nd,hist,ans"
+skip = "*.lock,*.csv,*.parquet,./data,./datasets"
+
+[dependency-groups]
+dev = [
+    "jsonschema>=4.26.0",
+    "mkdocstrings-python>=2.0.5",
+    "pytest>=9.1.1",
+    "pytest-cov>=7.1.0",
+    "zensical>=0.0.50",
+]

dstrack-0.1.0/src/dstrack/__init__.py

@@ -0,0 +1,8 @@
+from importlib.metadata import PackageNotFoundError, version
+
+from . import _logging as _logging
+
+try:
+    __version__ = version("dstrack")
+except PackageNotFoundError:
+    __version__ = "unknown"

dstrack-0.1.0/src/dstrack/_benchmark/__init__.py

@@ -0,0 +1,54 @@
+"""Benchmark for dstrack's snapshot creation pipeline.
+
+Generates a synthetic CSV in a temporary directory, then times how long it
+takes to build snapshot metadata and statistics for it, alongside a summary of
+the environment the benchmark ran in and a call tree of dstrack's own methods.
+
+Layers
+------
+[dstrack._benchmark._synthetic][]
+    Describes and writes the synthetic dataset.
+
+[dstrack._benchmark._runner][]
+    Runs the snapshot pipeline against it and times each phase.
+
+[dstrack._benchmark._profiling][]
+    Reduces the ``cProfile`` run to a call tree of dstrack's own methods.
+
+[dstrack._benchmark._environment][]
+    Describes the machine the benchmark ran on.
+
+[dstrack._benchmark._report][], [dstrack._benchmark._cli][]
+    Render runs to a console, and wire the whole thing to ``dstrack-benchmark``.
+"""
+
+from ._cli import app
+from ._environment import EnvironmentInfo, collect_environment_info
+from ._profiling import CallGraph, CallNode, CallScope
+from ._report import ConsoleReporter
+from ._runner import (
+    BenchmarkObserver,
+    BenchmarkResult,
+    BenchmarkRun,
+    BenchmarkRunner,
+    SilentObserver,
+)
+from ._synthetic import SyntheticColumn, SyntheticCsvSpec, write_synthetic_csv
+
+__all__ = [
+    "BenchmarkObserver",
+    "BenchmarkResult",
+    "BenchmarkRun",
+    "BenchmarkRunner",
+    "CallGraph",
+    "CallNode",
+    "CallScope",
+    "ConsoleReporter",
+    "EnvironmentInfo",
+    "SilentObserver",
+    "SyntheticColumn",
+    "SyntheticCsvSpec",
+    "app",
+    "collect_environment_info",
+    "write_synthetic_csv",
+]

dstrack-0.1.0/src/dstrack/_benchmark/_cli.py

@@ -0,0 +1,114 @@
+"""Command-line entry point for the snapshot benchmark."""
+
+import shutil
+import tempfile
+from collections.abc import Iterator
+from contextlib import contextmanager
+from pathlib import Path
+from typing import Annotated
+
+import typer
+
+from dstrack._benchmark._report import ConsoleReporter
+from dstrack._benchmark._runner import BenchmarkRunner
+from dstrack._benchmark._synthetic import SyntheticCsvSpec
+
+app = typer.Typer(
+    no_args_is_help=True,
+    pretty_exceptions_show_locals=False,
+    help="Benchmark dstrack's snapshot creation pipeline against a synthetic CSV.",
+)
+
+_DEFAULTS = SyntheticCsvSpec()
+
+
+@app.callback()
+def _main() -> None:
+    """Keep ``run`` a named subcommand so a bare invocation shows help.
+
+    Typer promotes a lone command to the top level, which quietly discards
+    ``no_args_is_help``; an explicit callback keeps the command group intact so
+    running ``dstrack-benchmark`` with no arguments prints help instead of
+    silently kicking off a full-size benchmark.
+    """
+
+
+@contextmanager
+def _workspace(reporter: ConsoleReporter, *, keep_csv: bool) -> Iterator[Path]:
+    """Yield a path for the synthetic CSV, discarding it unless ``keep_csv``."""
+    tmp_dir = Path(tempfile.mkdtemp(prefix="dstrack-benchmark-"))
+    csv_path = tmp_dir / "synthetic_dataset.csv"
+    try:
+        yield csv_path
+    finally:
+        if keep_csv:
+            reporter.csv_kept(csv_path)
+        else:
+            shutil.rmtree(tmp_dir, ignore_errors=True)
+
+
+@app.command(help="Generate a synthetic CSV and benchmark snapshot creation on it.")
+def run(
+    rows: Annotated[
+        int, typer.Option(min=0, help="Number of data rows to generate.")
+    ] = _DEFAULTS.num_rows,
+    numeric_cols: Annotated[
+        int, typer.Option(min=0, help="Number of numeric (float) columns.")
+    ] = _DEFAULTS.num_numeric_cols,
+    string_cols: Annotated[
+        int, typer.Option(min=0, help="Number of string columns.")
+    ] = _DEFAULTS.num_string_cols,
+    datetime_cols: Annotated[
+        int, typer.Option(min=0, help="Number of datetime columns.")
+    ] = _DEFAULTS.num_datetime_cols,
+    bool_cols: Annotated[
+        int, typer.Option(min=0, help="Number of boolean columns.")
+    ] = _DEFAULTS.num_bool_cols,
+    null_rate: Annotated[
+        float,
+        typer.Option(min=0.0, max=1.0, help="Fraction of non-id cells left null."),
+    ] = _DEFAULTS.null_rate,
+    seed: Annotated[
+        int, typer.Option(help="Random seed for reproducible synthetic data.")
+    ] = _DEFAULTS.seed,
+    keep_csv: Annotated[
+        bool,
+        typer.Option(
+            help="Keep the generated CSV instead of deleting it after the run."
+        ),
+    ] = False,
+    profile: Annotated[
+        bool,
+        typer.Option(
+            help="Profile dstrack's own methods while building the snapshot. "
+            "Adds cProfile overhead to the reported metadata/stats timings."
+        ),
+    ] = True,
+    profile_limit: Annotated[
+        int,
+        typer.Option(
+            min=0,
+            help="Max number of child methods shown under each node of the "
+            "profile call tree, ranked by cumulative time.",
+        ),
+    ] = 20,
+) -> None:
+    spec = SyntheticCsvSpec(
+        num_rows=rows,
+        num_numeric_cols=numeric_cols,
+        num_string_cols=string_cols,
+        num_datetime_cols=datetime_cols,
+        num_bool_cols=bool_cols,
+        null_rate=null_rate,
+        seed=seed,
+    )
+    reporter = ConsoleReporter()
+    runner = BenchmarkRunner(spec, observer=reporter, profile=profile)
+
+    with _workspace(reporter, keep_csv=keep_csv) as csv_path:
+        benchmark_run = runner.run(csv_path)
+        reporter.report(benchmark_run, profile_limit=profile_limit)
+
+
+if __name__ == "__main__":
+    app()

dstrack-0.1.0/src/dstrack/_benchmark/_environment.py

@@ -0,0 +1,144 @@
+"""Describes the machine and runtime a benchmark executed under.
+
+Hardware facts have no portable API, so each is read by a per-OS probe.  Every
+probe is best-effort: it returns ``None`` (or raises, which
+[_attempt()][dstrack._benchmark._environment._attempt] swallows) when the
+platform will not give up the answer, and the caller falls back to something
+always available.
+"""
+
+import os
+import platform
+import subprocess
+from collections.abc import Callable
+from dataclasses import dataclass
+from pathlib import Path
+from typing import TypeVar
+
+from dstrack import __version__
+
+T = TypeVar("T")
+
+_PROBE_TIMEOUT_SECONDS = 5
+
+
+@dataclass(frozen=True)
+class EnvironmentInfo:
+    """Snapshot of the machine and runtime a benchmark executed under."""
+
+    os_name: str
+    os_release: str
+    os_version: str
+    machine: str
+    cpu_model: str
+    cpu_count: int | None
+    total_memory_gb: float | None
+    python_implementation: str
+    python_version: str
+    dstrack_version: str
+
+
+def _attempt(probe: Callable[[], T | None]) -> T | None:
+    """Run a probe, returning ``None`` if the platform refuses to answer."""
+    try:
+        return probe()
+    except (OSError, subprocess.SubprocessError, ValueError):
+        return None
+
+
+def _command_output(*args: str) -> str:
+    """Gets the stdout of a command, raising if it fails or times out."""
+    result = subprocess.run(
+        args,
+        capture_output=True,
+        text=True,
+        timeout=_PROBE_TIMEOUT_SECONDS,
+        check=True,
+    )
+    return result.stdout.strip()
+
+
+def _first_matching_line(path: Path, prefix: str) -> str | None:
+    """First line of ``path`` starting with ``prefix`` (case-insensitive)."""
+    if not path.is_file():
+        return None
+    for line in path.read_text().splitlines():
+        if line.lower().startswith(prefix.lower()):
+            return line
+    return None
+
+
+def _linux_cpu_model() -> str | None:
+    line = _first_matching_line(Path("/proc/cpuinfo"), "model name")
+    return line.split(":", 1)[1].strip() if line else None
+
+
+def _darwin_cpu_model() -> str | None:
+    return _command_output("sysctl", "-n", "machdep.cpu.brand_string")
+
+
+def _windows_cpu_model() -> str | None:
+    lines = [
+        line.strip()
+        for line in _command_output("wmic", "cpu", "get", "name").splitlines()
+        if line.strip()
+    ]
+    return lines[1] if len(lines) >= 2 else None
+
+
+def _linux_total_memory() -> int | None:
+    line = _first_matching_line(Path("/proc/meminfo"), "MemTotal:")
+    return int(line.split()[1]) * 1024 if line else None
+
+
+def _darwin_total_memory() -> int | None:
+    return int(_command_output("sysctl", "-n", "hw.memsize"))
+
+
+def _sysconf_total_memory() -> int | None:
+    """Page size times page count, on any POSIX platform exposing sysconf."""
+    if not hasattr(os, "sysconf") or "SC_PAGE_SIZE" not in os.sysconf_names:
+        return None
+    return os.sysconf("SC_PAGE_SIZE") * os.sysconf("SC_PHYS_PAGES")
+
+
+_CPU_MODEL_PROBES: dict[str, Callable[[], str | None]] = {
+    "Linux": _linux_cpu_model,
+    "Darwin": _darwin_cpu_model,
+    "Windows": _windows_cpu_model,
+}
+
+_TOTAL_MEMORY_PROBES: dict[str, Callable[[], int | None]] = {
+    "Linux": _linux_total_memory,
+    "Darwin": _darwin_total_memory,
+}
+
+
+def _cpu_model() -> str:
+    """Best-effort human-readable CPU model string for the current machine."""
+    probe = _CPU_MODEL_PROBES.get(platform.system())
+    model = _attempt(probe) if probe is not None else None
+    return model or platform.processor() or platform.machine() or "unknown"
+
+
+def _total_memory_bytes() -> int | None:
+    """Best-effort total physical memory in bytes, or None if it can't be read."""
+    probe = _TOTAL_MEMORY_PROBES.get(platform.system(), _sysconf_total_memory)
+    return _attempt(probe)
+
+
+def collect_environment_info() -> EnvironmentInfo:
+    """Collect OS, hardware, and runtime details describing the current machine."""
+    total_memory = _total_memory_bytes()
+    return EnvironmentInfo(
+        os_name=platform.system(),
+        os_release=platform.release(),
+        os_version=platform.version(),
+        machine=platform.machine(),
+        cpu_model=_cpu_model(),
+        cpu_count=os.cpu_count(),
+        total_memory_gb=total_memory / (1024**3) if total_memory is not None else None,
+        python_implementation=platform.python_implementation(),
+        python_version=platform.python_version(),
+        dstrack_version=__version__,
+    )