pelutils 4.3.1__tar.gz → 4.5.0__tar.gz

pelutils-4.5.0/LICENSE.txt

@@ -0,0 +1,19 @@
+Copyright (c) 2022 Asger Laurits Schultz and Søren Winkel Holm
+
+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.

{pelutils-4.3.1 → pelutils-4.5.0}/PKG-INFO

@@ -1,12 +1,11 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: pelutils
-Version: 4.3.1
+Version: 4.5.0
 Summary: The Swiss army knife of Python projects
-Home-page: https://github.com/peleiden/pelutils
-Download-URL: https://pypi.org/project/pelutils/
-Author: Asger Laurits Schultz, Søren Winkel Holm
-Author-email: asger.s@protonmail.com, swholm@protonmail.com
-License: MIT
+Author-email: Asger Laurits Schultz <asger.s@protonmail.com>, Søren Winkel Holm <swholm@protonmail.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/peleiden/pelutils
+Project-URL: Download, https://pypi.org/project/pelutils/
 Keywords: utility,logger,parser,profiling,plotting
 Classifier: Intended Audience :: Developers
 Classifier: Operating System :: OS Independent
@@ -20,9 +19,19 @@ Classifier: Programming Language :: Python :: 3.14
 Classifier: Programming Language :: Python :: 3.15
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown
-Provides-Extra: dev
-Provides-Extra: docs
+License-File: LICENSE.txt
 License-File: pelutils/_c/hashmap/LICENSE
+Requires-Dist: numpy>=2.0
+Requires-Dist: gitpython>=3.1.0
+Requires-Dist: rich>=10.0.0
+Requires-Dist: py-cpuinfo>=8.0.0
+Requires-Dist: psutil>=5.8.0
+Requires-Dist: matplotlib>=3.3
+Requires-Dist: scipy>=1.6
+Requires-Dist: tqdm>=4.55
+Requires-Dist: pydantic>=2
+Requires-Dist: typing_extensions>=4.6
+Dynamic: license-file
 
 # pelutils
 
@@ -314,7 +323,7 @@ def process(features: FloatArray, labels: IntArray, mask: BoolArray): ...
 
 ## Also included
 
-- `pelutils.misc.Table` — build aligned text tables which can also be easily export to LaTeX with `Table.to_latex()`.
+- `pelutils.misc.Table` — build aligned text tables which can be exported to LaTeX with `Table.to_latex()` or Markdown with `Table.to_markdown()`.
 - `pelutils.misc.hardware_info` / `OS` — describe the machine the code runs on.
 - `pelutils.misc.git_repo_info` — the repo and commit the code is executing in.
 - Assorted file and dict helpers (`reverse_line_iterator`, `except_keys`, ...).
@@ -329,25 +338,47 @@ If no wheel matches, `pip` builds from source which requires `<Python.h>` — in
 32-bit systems are not fully supported.
 Most of the library is Python-only and should work but using any C-dependent code (namely `unique` and `SparseGridBlobDetection`) is likely to end in a segfault.
 
-## Updating and releasing
+## Development
 
-`pelutils` uses the `master` branch as a stable development branch.
-The `release` branch contains the latest version on PyPI.
-New features should be made in feature branches from `master` that can be merged into `master` once ready.
-When a new release is ready, update `pelutils/__version__.py` and rebase `master` onto `release`.
-Then push a new tag from `release` named `vX.Y.Z`.
+Use [uv](https://docs.astral.sh/uv/) for dependency management, builds, and running
+development tools. Install uv, then from the repository root sync the development
+environment (a C compiler and Python headers are required to build the native extension):
+
+```sh
+uv sync --python 3.11 --group dev
+```
+
+The `dev` dependency group includes CPU-only PyTorch and documentation tools.
+
+Run checks and tools through `uv run`:
 
-When new code is merged into `master`, a number of checks are run.
-These can be tested locally with the following commands.
 ```sh
 # Linting and formatting
-ruff format pelutils tests
-ruff check pelutils tests
+uv run --python 3.11 ruff format pelutils tests
+uv run --python 3.11 ruff check pelutils tests
 # Type checking
-basedpyright pelutils
+uv run --python 3.11 basedpyright pelutils
 # Unit tests
-python -m pytest tests --cov pelutils
+uv run --python 3.11 pytest tests --cov pelutils
 # Build docs
-# Once build, open docs/build/html/index.html in your browser to see them
-make -C docs html
+uv run --python 3.11 make -C docs html
+# Preview at docs/build/html/index.html
 ```
+
+After changing C sources, rebuild the extension with
+`uv sync --python 3.11 --group dev --reinstall-package pelutils`.
+
+The wheel-build CI tests each built wheel in a cibuildwheel environment provisioned
+from the locked `dev` group with uv; pytest runs against the installed wheel. Read the
+Docs also syncs that group through uv.
+
+## Updating and releasing
+
+`pelutils` uses the `master` branch as a stable development branch.
+The `release` branch contains the latest version on PyPI.
+New features should be made in feature branches from `master` that can be merged into `master` once ready.
+When a new release is ready, update `pyproject.toml` and rebase `master` onto `release`.
+Then push a new tag from `release` named `vX.Y.Z`.
+
+When new code is merged into `master`, the checks listed above are run.
+To build distribution artifacts locally, use `uv build --python 3.11`.

{pelutils-4.3.1 → pelutils-4.5.0}/README.md

@@ -288,7 +288,7 @@ def process(features: FloatArray, labels: IntArray, mask: BoolArray): ...
 
 ## Also included
 
-- `pelutils.misc.Table` — build aligned text tables which can also be easily export to LaTeX with `Table.to_latex()`.
+- `pelutils.misc.Table` — build aligned text tables which can be exported to LaTeX with `Table.to_latex()` or Markdown with `Table.to_markdown()`.
 - `pelutils.misc.hardware_info` / `OS` — describe the machine the code runs on.
 - `pelutils.misc.git_repo_info` — the repo and commit the code is executing in.
 - Assorted file and dict helpers (`reverse_line_iterator`, `except_keys`, ...).
@@ -303,25 +303,47 @@ If no wheel matches, `pip` builds from source which requires `<Python.h>` — in
 32-bit systems are not fully supported.
 Most of the library is Python-only and should work but using any C-dependent code (namely `unique` and `SparseGridBlobDetection`) is likely to end in a segfault.
 
-## Updating and releasing
+## Development
 
-`pelutils` uses the `master` branch as a stable development branch.
-The `release` branch contains the latest version on PyPI.
-New features should be made in feature branches from `master` that can be merged into `master` once ready.
-When a new release is ready, update `pelutils/__version__.py` and rebase `master` onto `release`.
-Then push a new tag from `release` named `vX.Y.Z`.
+Use [uv](https://docs.astral.sh/uv/) for dependency management, builds, and running
+development tools. Install uv, then from the repository root sync the development
+environment (a C compiler and Python headers are required to build the native extension):
+
+```sh
+uv sync --python 3.11 --group dev
+```
+
+The `dev` dependency group includes CPU-only PyTorch and documentation tools.
+
+Run checks and tools through `uv run`:
 
-When new code is merged into `master`, a number of checks are run.
-These can be tested locally with the following commands.
 ```sh
 # Linting and formatting
-ruff format pelutils tests
-ruff check pelutils tests
+uv run --python 3.11 ruff format pelutils tests
+uv run --python 3.11 ruff check pelutils tests
 # Type checking
-basedpyright pelutils
+uv run --python 3.11 basedpyright pelutils
 # Unit tests
-python -m pytest tests --cov pelutils
+uv run --python 3.11 pytest tests --cov pelutils
 # Build docs
-# Once build, open docs/build/html/index.html in your browser to see them
-make -C docs html
+uv run --python 3.11 make -C docs html
+# Preview at docs/build/html/index.html
 ```
+
+After changing C sources, rebuild the extension with
+`uv sync --python 3.11 --group dev --reinstall-package pelutils`.
+
+The wheel-build CI tests each built wheel in a cibuildwheel environment provisioned
+from the locked `dev` group with uv; pytest runs against the installed wheel. Read the
+Docs also syncs that group through uv.
+
+## Updating and releasing
+
+`pelutils` uses the `master` branch as a stable development branch.
+The `release` branch contains the latest version on PyPI.
+New features should be made in feature branches from `master` that can be merged into `master` once ready.
+When a new release is ready, update `pyproject.toml` and rebase `master` onto `release`.
+Then push a new tag from `release` named `vX.Y.Z`.
+
+When new code is merged into `master`, the checks listed above are run.
+To build distribution artifacts locally, use `uv build --python 3.11`.

pelutils-4.5.0/pelutils/__init__.py

@@ -0,0 +1,5 @@
+from importlib.metadata import version as _get_distribution_version
+
+__version__ = _get_distribution_version("pelutils")
+
+__all__ = ("__version__",)

pelutils-4.5.0/pelutils/array/_unique.pyi

@@ -0,0 +1,80 @@
+from __future__ import annotations
+
+from typing import Literal, overload
+
+import numpy.typing as npt
+
+from pelutils.types import AnyArray, IntArray
+
+@overload
+def unique(
+    array: npt.ArrayLike,
+    *,
+    return_index: Literal[False] = False,
+    return_inverse: Literal[False] = False,
+    return_counts: Literal[False] = False,
+    axis: int = 0,
+) -> AnyArray: ...
+@overload
+def unique(
+    array: npt.ArrayLike,
+    *,
+    return_index: Literal[True],
+    return_inverse: Literal[False] = False,
+    return_counts: Literal[False] = False,
+    axis: int = 0,
+) -> tuple[AnyArray, IntArray]: ...
+@overload
+def unique(
+    array: npt.ArrayLike,
+    *,
+    return_index: Literal[False] = False,
+    return_inverse: Literal[True],
+    return_counts: Literal[False] = False,
+    axis: int = 0,
+) -> tuple[AnyArray, IntArray]: ...
+@overload
+def unique(
+    array: npt.ArrayLike,
+    *,
+    return_index: Literal[True],
+    return_inverse: Literal[True],
+    return_counts: Literal[False] = False,
+    axis: int = 0,
+) -> tuple[AnyArray, IntArray, IntArray]: ...
+@overload
+def unique(
+    array: npt.ArrayLike,
+    *,
+    return_index: Literal[False] = False,
+    return_inverse: Literal[False] = False,
+    return_counts: Literal[True],
+    axis: int = 0,
+) -> tuple[AnyArray, IntArray]: ...
+@overload
+def unique(
+    array: npt.ArrayLike,
+    *,
+    return_index: Literal[True],
+    return_inverse: Literal[False] = False,
+    return_counts: Literal[True],
+    axis: int = 0,
+) -> tuple[AnyArray, IntArray, IntArray]: ...
+@overload
+def unique(
+    array: npt.ArrayLike,
+    *,
+    return_index: Literal[False] = False,
+    return_inverse: Literal[True],
+    return_counts: Literal[True],
+    axis: int = 0,
+) -> tuple[AnyArray, IntArray, IntArray]: ...
+@overload
+def unique(
+    array: npt.ArrayLike,
+    *,
+    return_index: Literal[True],
+    return_inverse: Literal[True],
+    return_counts: Literal[True],
+    axis: int = 0,
+) -> tuple[AnyArray, IntArray, IntArray, IntArray]: ...

{pelutils-4.3.1 → pelutils-4.5.0}/pelutils/logging/_rich_string.py

@@ -1,7 +1,5 @@
-import re
-
-from rich.color import ANSI_COLOR_NAMES
 from rich.console import Console
+from rich.markup import escape
 from typing_extensions import override
 
 _stdout_console = Console(highlight=False)
@@ -14,10 +12,6 @@ class RichString:
     This allows for printing and logging without rich syntax causing issues.
     """
 
-    _open_tag_regex = re.compile("(%s)" % "|".join(r"\[" + c + r"\]" for c in ANSI_COLOR_NAMES))  # noqa: UP031
-    _close_tag_regex_1 = re.compile(r"\\(\[\/.*\])")
-    _close_tag_regex_2 = re.compile(r"(\[\/.*\])")
-
     def __init__(self, stderr: bool = False):
         self.strings: list[str] = list()  # Normal strings
         self.riches: list[str] = list()  # Corresponding strings with rich syntax
@@ -26,10 +20,8 @@ class RichString:
     def add_string(self, s: str, rich: str | None = None):
         """Add a new string and optionally a rich string equivalent."""
         if rich is None:
-            # Escape beginning brackets to prevent accidental formatting when printing
-            rich = re.sub(self._open_tag_regex, r"\\\1", s)
-            rich = re.sub(self._close_tag_regex_1, r"\1", rich)
-            rich = re.sub(self._close_tag_regex_2, r"\\\1", rich)
+            # Escape all markup so plain text cannot be mistaken for Rich formatting.
+            rich = escape(s)
         self.strings.append(s)
         self.riches.append(rich)
 

{pelutils-4.3.1 → pelutils-4.5.0}/pelutils/misc/__init__.py

@@ -6,7 +6,7 @@ and rewriting them each time is tedious and error-prone. This module is the grab
 those: each helper is self-contained and useful on its own, so import only what you need.
 
 Main inclusions are :class:`Table` for aligned text tables that also export to LaTeX via
-:meth:`Table.to_latex`; :class:`OS` and :data:`hardware_info` for describing the machine
+:meth:`Table.to_latex` and Markdown via :meth:`Table.to_markdown`; :class:`OS` and :data:`hardware_info` for describing the machine
 the code runs on; :func:`git_repo_info` for the repository and commit currently executing;
 :func:`array_bytes`/:func:`array_ptr` for low-level array introspection; and small file
 and dict helpers such as :func:`reverse_line_iterator` and :func:`except_keys`.

{pelutils-4.3.1 → pelutils-4.5.0}/pelutils/misc/_table.py

@@ -1,16 +1,17 @@
-import re
 from collections.abc import Sequence
 from typing import Any
 
+from rich.cells import cell_len
 from typing_extensions import override
 
 
 class Table:
-    """Build aligned, human-readable text tables that can also be exported to LaTeX.
+    """Build aligned, human-readable text tables that can also be exported to LaTeX and Markdown.
 
     Add an optional header, then rows, and render with ``str(table)``; column widths are
     computed automatically. :meth:`add_hline` inserts a horizontal rule and
-    :meth:`to_latex` produces ``booktabs``-style LaTeX.
+    :meth:`to_latex` produces ``booktabs``-style LaTeX, and :meth:`to_markdown`
+    produces a Markdown pipe table.
 
     Example
     -------
@@ -67,29 +68,58 @@ class Table:
         self._hlines.add(len(self._rows) - 1)
 
     def to_latex(self) -> str:
-        """Produce LaTeX code for the table to included in a tabular environment.
+        """Produce LaTeX code for the table to include in a tabular environment.
 
         It assumes the booktabs package is used.
         """
-        formatted = str(self)
-        lines = formatted.splitlines()
-        lines.insert(0, r"\toprule")
+        assert self._width is not None
+        all_rows = [self._header, *self._rows] if self._header else self._rows
+        widths = [max(cell_len(row[j]) for row in all_rows) for j in range(self._width)]
+
+        lines = [r"\toprule"]
+        if self._header:
+            header = (self._format_element(cell, width, True) for cell, width in zip(self._header, widths, strict=True))
+            lines.append(" & ".join(header) + r" \\")
+            lines.append(r"\midrule")
+
+        for i, (row, left_align) in enumerate(zip(self._rows, self._left_aligns, strict=True)):
+            cells = (self._format_element(cell, width, align) for cell, width, align in zip(row, widths, left_align, strict=True))
+            lines.append(" & ".join(cells) + r" \\")
+            if i in self._hlines:
+                lines.append(r"\midrule")
+
         lines.append(r"\bottomrule")
+        return "\n".join(lines)
 
-        for i, line in enumerate(lines):
-            if re.match(r"^(-+\+)+-+$", line):
-                lines[i] = r"\midrule"
-            elif re.match(r"^(.+\|)+.+$", line):
-                lines[i] = line.replace("|", "&") + r" \\"
+    def to_markdown(self) -> str:
+        """Produce a Markdown pipe table.
 
+        Markdown requires a header row, so a table without an explicit header gets a
+        blank one. Column alignment follows the first data row (or is left-aligned
+        when there are no data rows). Markdown has no syntax for horizontal rules
+        between body rows, so markers added with :meth:`add_hline` are omitted.
+        """
+        assert self._width is not None
+        header = self._header or ("",) * self._width
+        aligns = self._left_aligns[0] if self._left_aligns else (True,) * self._width
+        lines = [
+            "| " + " | ".join(self._escape_markdown_cell(cell) for cell in header) + " |",
+            "| " + " | ".join(":---" if align else "---:" for align in aligns) + " |",
+        ]
+        lines.extend("| " + " | ".join(self._escape_markdown_cell(cell) for cell in row) + " |" for row in self._rows)
         return "\n".join(lines)
 
+    @staticmethod
+    def _escape_markdown_cell(cell: str) -> str:
+        return cell.replace("\\", "\\\\").replace("|", r"\|").replace("\r\n", "\n").replace("\r", "\n").replace("\n", "<br>")
+
     @staticmethod
     def _format_element(element: str, width: int, left_align: bool) -> str:
+        padding = width - cell_len(element)
         if left_align:
-            return element + " " * (width - len(element))
+            return element + " " * padding
         else:
-            return " " * (width - len(element)) + element
+            return " " * padding + element
 
     @override
     def __repr__(self) -> str:
@@ -99,7 +129,7 @@ class Table:
     def __str__(self) -> str:
         assert self._width is not None
         all_rows = [self._header, *self._rows] if self._header else self._rows
-        widths = [max(len(all_rows[i][j]) for i in range(len(all_rows))) for j in range(self._width)]
+        widths = [max(cell_len(all_rows[i][j]) for i in range(len(all_rows))) for j in range(self._width)]
         hline = "+".join("-" * (width + 1 + (0 < i < self._width - 1)) for i, width in enumerate(widths))
         strs = list()
         if self._header:

{pelutils-4.3.1 → pelutils-4.5.0}/pelutils/serialization/_universal_json_model.py

@@ -22,15 +22,24 @@ class UniversalJsonModel(BaseModel):
 
     model_config = ConfigDict(arbitrary_types_allowed=True)
 
-    def to_json_dict(self) -> dict[str, Any]:  # pyright: ignore[reportExplicitAny]
-        """Return a JSON-compatible dictionary, pickle-encoding unsupported values."""
-        return self.model_dump(mode="json", fallback=pickle_encode)
+    def to_json_dict(self, **model_dump_kwargs: Any) -> dict[str, Any]:  # pyright: ignore[reportExplicitAny]
+        """Return a JSON-compatible dictionary, pickle-encoding unsupported values.
+
+        Keyword arguments are forwarded to :meth:`pydantic.BaseModel.model_dump`, except
+        ``mode`` and ``fallback``, which are fixed to preserve this method's JSON format.
+        """
+        if {"mode", "fallback"} & model_dump_kwargs.keys():
+            raise TypeError("'mode' and 'fallback' are fixed by to_json_dict()")
+        return self.model_dump(mode="json", fallback=pickle_encode, **model_dump_kwargs)
 
     @classmethod
-    def from_json_dict(cls: type[Self], json_dict: dict[str, Any]) -> Self:  # pyright: ignore[reportExplicitAny]
-        """Build a model from :meth:`to_json_dict` output. Do not load untrusted data."""
+    def from_json_dict(cls: type[Self], json_dict: dict[str, Any], **model_validate_kwargs: Any) -> Self:  # pyright: ignore[reportExplicitAny]
+        """Build a model from :meth:`to_json_dict` output. Do not load untrusted data.
+
+        Keyword arguments are forwarded to :meth:`pydantic.BaseModel.model_validate`.
+        """
         self_dict = from_safe_json(json_dict)
-        return cls.model_validate(self_dict)
+        return cls.model_validate(self_dict, **model_validate_kwargs)
 
     def save(self, path: str | Path, *, max_line_length: int = 140, indent: int = 2, encoding: str = "utf-8"):
         """Save the model to ``path`` as human-readable JSON, creating parent directories as needed."""

{pelutils-4.3.1 → pelutils-4.5.0}/pelutils/ticktock/__init__.py

@@ -37,6 +37,6 @@ periodic tasks, and ``fuse``/``fuse_multiple`` for combining results across
 processes.
 """
 
-from ._ticktock import TT, Profile, TickTock, TickTockException
+from ._ticktock import TT, Profile, TickTock, TickTockException, get_active_ticktock
 
-__all__ = ("TT", "Profile", "TickTock", "TickTockException")
+__all__ = ("TT", "Profile", "TickTock", "TickTockException", "get_active_ticktock")

{pelutils-4.3.1 → pelutils-4.5.0}/pelutils/ticktock/_ticktock.py

@@ -1,8 +1,9 @@
+import itertools
+import threading
 import warnings
 from collections.abc import Hashable, Iterable, Iterator, Sequence
 from contextlib import contextmanager
 from copy import deepcopy
-from threading import current_thread
 from time import perf_counter
 from typing import TypeAlias, TypeVar, cast
 
@@ -23,6 +24,20 @@ _time_units: tuple[_TimeUnit, ...] = (
 
 T = TypeVar("T")
 
+_lock = threading.RLock()
+_active_ticktocks: "dict[int, TickTock]" = dict()
+_ids = itertools.count()
+_ids_lock = threading.RLock()
+_local_thread = threading.local()
+
+
+def _get_thread_uid() -> int:
+    """Return a stable, program-lifetime-unique ID for the calling thread."""
+    if not hasattr(_local_thread, "__ticktock_uid__"):
+        with _ids_lock:
+            _local_thread.__ticktock_uid__ = next(_ids)
+    return _local_thread.__ticktock_uid__
+
 
 def _get_smallest_suitable_unit(duration_s: float) -> _TimeUnit:
     """Return the smallest unit for which the duration is at least the same size as the unit."""
@@ -160,8 +175,8 @@ class TickTock:
         self._profile_stack: list[Profile] = list()  # LIFO stack of active profiles
         self._root_profiles: list[Profile] = list()  # Top level profiles
 
-        self._thread_name = current_thread().name
-        self._thread_id = id(current_thread())
+        self._thread_name = threading.current_thread().name
+        self._thread_id = _get_thread_uid()
 
     def tick(self, key: Hashable = None):
         """Start a timer identified by an optional hashable key."""
@@ -244,10 +259,10 @@ class TickTock:
             self._end_profile()
 
     def _warn_if_wrong_thread(self, *, stacklevel: int):
-        if self._thread_id != id(current_thread()):
+        if self._thread_id != _get_thread_uid():
             warnings.warn(
                 f"This TickTock instance was created in the {self._thread_name} thread but profiling was started in "
-                + f"{current_thread().name}. Profiling is NOT designed to deal with multiple threads. Instead, create a "
+                + f"{threading.current_thread().name}. Profiling is NOT designed to deal with multiple threads. Instead, create a "
                 + "TickTock instance for each thread requiring profiling.",
                 stacklevel=stacklevel,
             )
@@ -332,13 +347,23 @@ class TickTock:
             profile.parent.children.remove(profile)
 
     def reset(self):
-        """Stop all timing and profiling and clear all profiles and measurements."""
+        """Stop all timing and profiling and clear all profiles and measurements.
+
+        Resetting is allowed while this instance is registered by :meth:`as_active`; the
+        active registration remains until that context exits. Resetting while a profile
+        context is in progress raises :class:`TickTockException` without changing state.
+        """
         if self._profile_stack:
             raise TickTockException("Cannot reset TickTock while profiling is active")
         self.__init__()
 
     def reset_profiles(self):
-        """Similar to ``reset`` but only reset profiles, leaving ``tick``/``tock`` timers intact."""
+        """Reset profiles while leaving ``tick``/``tock`` timers intact.
+
+        The same restrictions as :meth:`reset` apply: this is allowed while registered
+        by :meth:`as_active`, but raises :class:`TickTockException` during a profile
+        context.
+        """
         tick_starts = self._tick_starts
         self.reset()
         self._tick_starts = tick_starts
@@ -393,8 +418,8 @@ class TickTock:
             raise ValueError("Some TickTocks are the same instance, which is not allowed")
         for tt in tts[1:]:
             ticktock.fuse(tt)
-        ticktock._thread_name = current_thread().name
-        ticktock._thread_id = id(current_thread())
+        ticktock._thread_name = threading.current_thread().name
+        ticktock._thread_id = _get_thread_uid()
         return ticktock
 
     @staticmethod
@@ -446,5 +471,38 @@ class TickTock:
         """Return True if any profiling has been performed."""
         return len(self._root_profiles) > 0
 
+    @contextmanager
+    def as_active(self):
+        """Set the ``TickTock`` instance as the active instance in the current thread.
+
+        It can then be retrieved with :func:`get_active_ticktock`.
+        Calling :meth:`reset` or :meth:`reset_profiles` inside this context does not
+        unset the active instance. Those methods still raise if a profile context is
+        currently in progress.
+        """
+        current_thread_id = _get_thread_uid()
+        with _lock:
+            if current_thread_id in _active_ticktocks:
+                raise TickTockException(f"An active TickTock instance has already been set in thread {threading.current_thread().name}")
+            _active_ticktocks[current_thread_id] = self
+        try:
+            yield
+        finally:
+            with _lock:
+                del _active_ticktocks[current_thread_id]
+
+
+def get_active_ticktock() -> TickTock:
+    """Return the active ``TickTock`` instance in the current thread (as set by :meth:`TickTock.as_active`).
+
+    If no active ``TickTock`` is set, a new ``TickTock`` instance is returned.
+    This allows normal profiling usage without having to care if it's actually used or not.
+    """
+    with _lock:
+        ticktock = _active_ticktocks.get(_get_thread_uid())
+    return ticktock if ticktock is not None else TickTock()
+
 
+# Globally accessible default instance
+# It suffices to use this for most cases
 TT = TickTock()

{pelutils-4.3.1 → pelutils-4.5.0}/pelutils.egg-info/PKG-INFO

@@ -1,12 +1,11 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: pelutils
-Version: 4.3.1
+Version: 4.5.0
 Summary: The Swiss army knife of Python projects
-Home-page: https://github.com/peleiden/pelutils
-Download-URL: https://pypi.org/project/pelutils/
-Author: Asger Laurits Schultz, Søren Winkel Holm
-Author-email: asger.s@protonmail.com, swholm@protonmail.com
-License: MIT
+Author-email: Asger Laurits Schultz <asger.s@protonmail.com>, Søren Winkel Holm <swholm@protonmail.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/peleiden/pelutils
+Project-URL: Download, https://pypi.org/project/pelutils/
 Keywords: utility,logger,parser,profiling,plotting
 Classifier: Intended Audience :: Developers
 Classifier: Operating System :: OS Independent
@@ -20,9 +19,19 @@ Classifier: Programming Language :: Python :: 3.14
 Classifier: Programming Language :: Python :: 3.15
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown
-Provides-Extra: dev
-Provides-Extra: docs
+License-File: LICENSE.txt
 License-File: pelutils/_c/hashmap/LICENSE
+Requires-Dist: numpy>=2.0
+Requires-Dist: gitpython>=3.1.0
+Requires-Dist: rich>=10.0.0
+Requires-Dist: py-cpuinfo>=8.0.0
+Requires-Dist: psutil>=5.8.0
+Requires-Dist: matplotlib>=3.3
+Requires-Dist: scipy>=1.6
+Requires-Dist: tqdm>=4.55
+Requires-Dist: pydantic>=2
+Requires-Dist: typing_extensions>=4.6
+Dynamic: license-file
 
 # pelutils
 
@@ -314,7 +323,7 @@ def process(features: FloatArray, labels: IntArray, mask: BoolArray): ...
 
 ## Also included
 
-- `pelutils.misc.Table` — build aligned text tables which can also be easily export to LaTeX with `Table.to_latex()`.
+- `pelutils.misc.Table` — build aligned text tables which can be exported to LaTeX with `Table.to_latex()` or Markdown with `Table.to_markdown()`.
 - `pelutils.misc.hardware_info` / `OS` — describe the machine the code runs on.
 - `pelutils.misc.git_repo_info` — the repo and commit the code is executing in.
 - Assorted file and dict helpers (`reverse_line_iterator`, `except_keys`, ...).
@@ -329,25 +338,47 @@ If no wheel matches, `pip` builds from source which requires `<Python.h>` — in
 32-bit systems are not fully supported.
 Most of the library is Python-only and should work but using any C-dependent code (namely `unique` and `SparseGridBlobDetection`) is likely to end in a segfault.
 
-## Updating and releasing
+## Development
 
-`pelutils` uses the `master` branch as a stable development branch.
-The `release` branch contains the latest version on PyPI.
-New features should be made in feature branches from `master` that can be merged into `master` once ready.
-When a new release is ready, update `pelutils/__version__.py` and rebase `master` onto `release`.
-Then push a new tag from `release` named `vX.Y.Z`.
+Use [uv](https://docs.astral.sh/uv/) for dependency management, builds, and running
+development tools. Install uv, then from the repository root sync the development
+environment (a C compiler and Python headers are required to build the native extension):
+
+```sh
+uv sync --python 3.11 --group dev
+```
+
+The `dev` dependency group includes CPU-only PyTorch and documentation tools.
+
+Run checks and tools through `uv run`:
 
-When new code is merged into `master`, a number of checks are run.
-These can be tested locally with the following commands.
 ```sh
 # Linting and formatting
-ruff format pelutils tests
-ruff check pelutils tests
+uv run --python 3.11 ruff format pelutils tests
+uv run --python 3.11 ruff check pelutils tests
 # Type checking
-basedpyright pelutils
+uv run --python 3.11 basedpyright pelutils
 # Unit tests
-python -m pytest tests --cov pelutils
+uv run --python 3.11 pytest tests --cov pelutils
 # Build docs
-# Once build, open docs/build/html/index.html in your browser to see them
-make -C docs html
+uv run --python 3.11 make -C docs html
+# Preview at docs/build/html/index.html
 ```
+
+After changing C sources, rebuild the extension with
+`uv sync --python 3.11 --group dev --reinstall-package pelutils`.
+
+The wheel-build CI tests each built wheel in a cibuildwheel environment provisioned
+from the locked `dev` group with uv; pytest runs against the installed wheel. Read the
+Docs also syncs that group through uv.
+
+## Updating and releasing
+
+`pelutils` uses the `master` branch as a stable development branch.
+The `release` branch contains the latest version on PyPI.
+New features should be made in feature branches from `master` that can be merged into `master` once ready.
+When a new release is ready, update `pyproject.toml` and rebase `master` onto `release`.
+Then push a new tag from `release` named `vX.Y.Z`.
+
+When new code is merged into `master`, the checks listed above are run.
+To build distribution artifacts locally, use `uv build --python 3.11`.

{pelutils-4.3.1 → pelutils-4.5.0}/pelutils.egg-info/SOURCES.txt

@@ -1,8 +1,9 @@
+LICENSE.txt
 MANIFEST.in
 README.md
+pyproject.toml
 setup.py
 pelutils/__init__.py
-pelutils/__version__.py
 pelutils/py.typed
 pelutils.egg-info/PKG-INFO
 pelutils.egg-info/SOURCES.txt
@@ -27,6 +28,7 @@ pelutils/_entry_points/linecounter.py
 pelutils/array/__init__.py
 pelutils/array/_blob.py
 pelutils/array/_unique.py
+pelutils/array/_unique.pyi
 pelutils/array/_utils.py
 pelutils/job_parser/__init__.py
 pelutils/job_parser/_job_parser.py

pelutils-4.5.0/pelutils.egg-info/requires.txt

@@ -0,0 +1,10 @@
+numpy>=2.0
+gitpython>=3.1.0
+rich>=10.0.0
+py-cpuinfo>=8.0.0
+psutil>=5.8.0
+matplotlib>=3.3
+scipy>=1.6
+tqdm>=4.55
+pydantic>=2
+typing_extensions>=4.6

pelutils-4.5.0/pyproject.toml

@@ -0,0 +1,86 @@
+# uv_build does not support the native C extension; uv uses this PEP 517 backend.
+[build-system]
+requires = ["setuptools>=77", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "pelutils"
+version = "4.5.0"
+description = "The Swiss army knife of Python projects"
+readme = "README.md"
+requires-python = ">=3.11"
+license = "MIT"
+license-files = ["LICENSE.txt", "pelutils/_c/hashmap/LICENSE"]
+authors = [
+    { name = "Asger Laurits Schultz", email = "asger.s@protonmail.com" },
+    { name = "Søren Winkel Holm", email = "swholm@protonmail.com" },
+]
+keywords = ["utility", "logger", "parser", "profiling", "plotting"]
+classifiers = [
+    "Intended Audience :: Developers",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python",
+    "Programming Language :: Python :: 3 :: Only",
+    "Programming Language :: Python :: Free Threading :: 3 - Stable",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
+    "Programming Language :: Python :: 3.15",
+]
+dependencies = [
+    "numpy>=2.0",
+    "gitpython>=3.1.0",
+    "rich>=10.0.0",
+    "py-cpuinfo>=8.0.0",
+    "psutil>=5.8.0",
+    "matplotlib>=3.3",
+    "scipy>=1.6",
+    "tqdm>=4.55",
+    "pydantic>=2",
+    "typing_extensions>=4.6",
+]
+
+[dependency-groups]
+dev = [
+    "torch>=2",
+    "pytest==8.4.2",
+    "pytest-cov==7.0.0",
+    "coveralls>=4.0.0",
+    "coverage==7.10.7",
+    "wheel",
+    "setuptools>=60.0.0",
+    "ruff==0.15.8",
+    "basedpyright==1.39.0",
+    "freezegun>=1.5",
+    "ipdb",
+    "sphinx",
+    "sphinx-autobuild",
+    "furo",
+    "myst-parser",
+]
+
+[project.scripts]
+linecounter = "pelutils._entry_points.linecounter:run"
+
+[project.urls]
+Homepage = "https://github.com/peleiden/pelutils"
+Download = "https://pypi.org/project/pelutils/"
+
+[tool.setuptools]
+include-package-data = true
+
+[tool.setuptools.packages.find]
+exclude = ["tests", "tests.*"]
+namespaces = false
+
+[tool.setuptools.package-data]
+pelutils = ["py.typed"]
+
+[[tool.uv.index]]
+name = "pytorch"
+url = "https://download.pytorch.org/whl/cpu"
+explicit = true
+
+[tool.uv.sources]
+torch = { index = "pytorch" }

pelutils-4.5.0/setup.py

@@ -0,0 +1,17 @@
+import os
+import sys
+
+from setuptools import setup
+from setuptools.extension import Extension
+
+c_files = [os.path.join(root, filename) for root, _, files in os.walk("pelutils/_c") for filename in files if filename.endswith(".c")]
+
+setup(
+    ext_modules=[
+        Extension(
+            name="_pelutils_c",
+            sources=c_files,
+            extra_compile_args=["-DMS_WIN64"] if sys.platform == "win32" else [],
+        )
+    ]
+)

pelutils-4.3.1/pelutils/__init__.py

@@ -1,3 +0,0 @@
-from .__version__ import __version__
-
-__all__ = ("__version__",)

pelutils-4.3.1/pelutils/__version__.py

@@ -1,2 +0,0 @@
-# Do not put anything else in this file
-__version__ = "4.3.1"

pelutils-4.3.1/pelutils.egg-info/requires.txt

@@ -1,33 +0,0 @@
-gitpython>=3.1.0
-matplotlib>=3.3
-numpy>=2.0
-psutil>=5.8.0
-py-cpuinfo>=8.0.0
-pydantic>=2
-rich>=10.0.0
-scipy>=1.6
-tqdm>=4.55
-typing_extensions>=4.6
-
-[dev]
-basedpyright==1.39.0
-coverage==7.10.7
-coveralls>=4.0.0
-freezegun>=1.5
-furo
-ipdb
-myst-parser
-pytest-cov==7.0.0
-pytest==8.4.2
-ruff==0.15.8
-setuptools>=60.0.0
-sphinx
-sphinx-autobuild
-torch>=2
-wheel
-
-[docs]
-furo
-myst-parser
-sphinx
-sphinx-autobuild

pelutils-4.3.1/setup.py

@@ -1,95 +0,0 @@
-import os
-import sys
-from glob import glob as glob  # glob
-
-from setuptools import find_packages, setup
-from setuptools.extension import Extension
-
-sys.path.append("pelutils")
-from __version__ import __version__
-
-requirements = [
-    "numpy>=2.0",
-    "gitpython>=3.1.0",
-    "rich>=10.0.0",
-    "py-cpuinfo>=8.0.0",
-    "psutil>=5.8.0",
-    "matplotlib>=3.3",
-    "scipy>=1.6",
-    "tqdm>=4.55",
-    "pydantic>=2",
-    "typing_extensions>=4.6",
-]
-requirements_dev = [
-    "torch>=2",
-    "pytest==8.4.2",
-    "pytest-cov==7.0.0",
-    "coveralls>=4.0.0",
-    "coverage==7.10.7",
-    "wheel",
-    "setuptools>=60.0.0",
-    "ruff==0.15.8",
-    "basedpyright==1.39.0",
-    "freezegun>=1.5",
-    "ipdb",
-]
-requirements_docs = [
-    "sphinx",
-    "sphinx-autobuild",
-    "furo",
-    "myst-parser",
-]
-
-with open("README.md") as readme_file:
-    README = readme_file.read()
-
-c_files = list()
-for root, __, files in os.walk("pelutils/_c"):
-    c_files += [os.path.join(root, f) for f in files if f.endswith(".c")]
-
-setup_args = dict(
-    name="pelutils",
-    version=__version__,
-    description="The Swiss army knife of Python projects",
-    long_description_content_type="text/markdown",
-    long_description=README,
-    license="MIT",
-    packages=find_packages(exclude=("tests", "tests.*")),
-    package_data={"pelutils": ["py.typed"]},
-    author="Asger Laurits Schultz, Søren Winkel Holm",
-    author_email="asger.s@protonmail.com, swholm@protonmail.com",
-    keywords=["utility", "logger", "parser", "profiling", "plotting"],
-    url="https://github.com/peleiden/pelutils",
-    download_url="https://pypi.org/project/pelutils/",
-    install_requires=requirements,
-    extras_require={"docs": requirements_docs, "dev": requirements_dev + requirements_docs},
-    entry_points={
-        "console_scripts": [
-            "linecounter = pelutils._entry_points.linecounter:run",
-        ]
-    },
-    ext_modules=[
-        Extension(
-            name="_pelutils_c",
-            sources=c_files,
-            extra_compile_args=["-DMS_WIN64"] if sys.platform == "win32" else [],
-        )
-    ],
-    license_files=[os.path.join("pelutils", "_c", "hashmap", "LICENSE")],
-    python_requires=">=3.11",
-    classifiers=[
-        "Intended Audience :: Developers",
-        "Operating System :: OS Independent",
-        "Programming Language :: Python",
-        "Programming Language :: Python :: 3 :: Only",
-        "Programming Language :: Python :: Free Threading :: 3 - Stable",
-        "Programming Language :: Python :: 3.11",
-        "Programming Language :: Python :: 3.12",
-        "Programming Language :: Python :: 3.13",
-        "Programming Language :: Python :: 3.14",
-        "Programming Language :: Python :: 3.15",
-    ],
-)
-
-if __name__ == "__main__":
-    setup(**setup_args)