ticko 1.0.0__tar.gz

ticko-1.0.0/PKG-INFO

@@ -0,0 +1,172 @@
+Metadata-Version: 2.3
+Name: ticko
+Version: 1.0.0
+Summary: Thread-safe stopwatch for measuring elapsed time
+Keywords: stopwatch,timer,performance,profiling,benchmark
+Author: NakuRei
+Author-email: NakuRei <nakurei7901@gmail.com>
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: System :: Benchmark
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Project-URL: Homepage, https://github.com/NakuRei/ticko
+Project-URL: Issues, https://github.com/NakuRei/ticko/issues
+Project-URL: Repository, https://github.com/NakuRei/ticko
+Description-Content-Type: text/markdown
+
+# ticko
+
+[![CI](https://github.com/NakuRei/ticko/actions/workflows/ci.yml/badge.svg)](https://github.com/NakuRei/ticko/actions/workflows/ci.yml)
+[![codecov](https://codecov.io/gh/NakuRei/ticko/branch/main/graph/badge.svg)](https://codecov.io/gh/NakuRei/ticko)
+[![Python 3.10+](https://img.shields.io/badge/python-3.10+-blue.svg)](https://www.python.org/downloads/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+A modern, thread-safe stopwatch library for Python.
+
+## Why ticko?
+
+- **Thread-safe by design** - Use confidently in concurrent applications
+- **Type-safe** - Full type hints for excellent IDE support
+- **Zero dependencies** - Pure Python, no external requirements
+- **Flexible API** - Context managers, decorators, or manual control
+- **Production-ready** - Comprehensive test coverage
+
+## Installation
+
+```bash
+pip install ticko
+```
+
+## Quick Start
+
+```python
+from ticko import StopWatch
+
+# Basic usage
+with StopWatch() as sw:
+    # Your code here
+    pass
+
+print(f"Elapsed: {sw.time_elapsed:.2f}s")
+```
+
+```python
+from ticko import stopwatch
+
+# Decorator for function timing
+@stopwatch
+def process_data():
+    # Your code here
+    pass
+
+process_data()  # Automatically prints execution time
+```
+
+## Core Features
+
+### Manual Control
+
+```python
+sw = StopWatch()
+sw.start()
+# ... your code ...
+elapsed = sw.stop()
+```
+
+### Lap Timing
+
+```python
+sw = StopWatch()
+sw.start()
+
+# Record multiple laps
+lap1 = sw.lap()
+lap2 = sw.lap()
+
+elapsed =sw.stop()
+```
+
+### Custom Callbacks
+
+```python
+def log_time(sw: StopWatch):
+    logger.info(f"Execution took {sw.time_elapsed:.3f}s")
+
+@stopwatch(exit_callback=log_time)
+def my_function():
+    pass
+```
+
+### Thread Safety
+
+```python
+from concurrent.futures import ThreadPoolExecutor
+
+sw = StopWatch()
+sw.start()
+
+# Multiple threads can safely share one StopWatch
+with ThreadPoolExecutor(max_workers=5) as executor:
+    futures = [executor.submit(sw.lap) for _ in range(10)]
+
+elapsed =sw.stop()
+```
+
+For more examples, see the [`examples/`](examples/) directory.
+
+## API Overview
+
+### `StopWatch`
+
+**Properties:**
+- `is_running: bool` - Current state
+- `time_elapsed: float` - Total elapsed time
+- `time_last_lap: float` - Last lap duration
+
+**Methods:**
+- `start()` - Start timing
+- `stop()` - Stop and return elapsed time
+- `lap()` - Record lap time
+- `reset()` - Reset to initial state
+
+### `@stopwatch`
+
+Decorator for automatic function timing with optional custom callbacks.
+
+## Development
+
+```bash
+# Install with dev dependencies
+uv sync --dev
+
+# Run tests
+pytest tests/
+
+# Run tests with coverage report
+pytest tests -v --cov=src --cov-report=term-missing --cov-report=xml:cov.xml
+
+# Type checking
+mypy .
+
+# Lint checking
+ruff check
+
+# Format checking
+ruff format --check --diff
+```
+
+## License
+
+MIT License - Copyright (c) 2025 NakuRei
+
+## Contributing
+
+Contributions welcome! Feel free to open issues or submit pull requests.

ticko-1.0.0/README.md

@@ -0,0 +1,148 @@
+# ticko
+
+[![CI](https://github.com/NakuRei/ticko/actions/workflows/ci.yml/badge.svg)](https://github.com/NakuRei/ticko/actions/workflows/ci.yml)
+[![codecov](https://codecov.io/gh/NakuRei/ticko/branch/main/graph/badge.svg)](https://codecov.io/gh/NakuRei/ticko)
+[![Python 3.10+](https://img.shields.io/badge/python-3.10+-blue.svg)](https://www.python.org/downloads/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+A modern, thread-safe stopwatch library for Python.
+
+## Why ticko?
+
+- **Thread-safe by design** - Use confidently in concurrent applications
+- **Type-safe** - Full type hints for excellent IDE support
+- **Zero dependencies** - Pure Python, no external requirements
+- **Flexible API** - Context managers, decorators, or manual control
+- **Production-ready** - Comprehensive test coverage
+
+## Installation
+
+```bash
+pip install ticko
+```
+
+## Quick Start
+
+```python
+from ticko import StopWatch
+
+# Basic usage
+with StopWatch() as sw:
+    # Your code here
+    pass
+
+print(f"Elapsed: {sw.time_elapsed:.2f}s")
+```
+
+```python
+from ticko import stopwatch
+
+# Decorator for function timing
+@stopwatch
+def process_data():
+    # Your code here
+    pass
+
+process_data()  # Automatically prints execution time
+```
+
+## Core Features
+
+### Manual Control
+
+```python
+sw = StopWatch()
+sw.start()
+# ... your code ...
+elapsed = sw.stop()
+```
+
+### Lap Timing
+
+```python
+sw = StopWatch()
+sw.start()
+
+# Record multiple laps
+lap1 = sw.lap()
+lap2 = sw.lap()
+
+elapsed =sw.stop()
+```
+
+### Custom Callbacks
+
+```python
+def log_time(sw: StopWatch):
+    logger.info(f"Execution took {sw.time_elapsed:.3f}s")
+
+@stopwatch(exit_callback=log_time)
+def my_function():
+    pass
+```
+
+### Thread Safety
+
+```python
+from concurrent.futures import ThreadPoolExecutor
+
+sw = StopWatch()
+sw.start()
+
+# Multiple threads can safely share one StopWatch
+with ThreadPoolExecutor(max_workers=5) as executor:
+    futures = [executor.submit(sw.lap) for _ in range(10)]
+
+elapsed =sw.stop()
+```
+
+For more examples, see the [`examples/`](examples/) directory.
+
+## API Overview
+
+### `StopWatch`
+
+**Properties:**
+- `is_running: bool` - Current state
+- `time_elapsed: float` - Total elapsed time
+- `time_last_lap: float` - Last lap duration
+
+**Methods:**
+- `start()` - Start timing
+- `stop()` - Stop and return elapsed time
+- `lap()` - Record lap time
+- `reset()` - Reset to initial state
+
+### `@stopwatch`
+
+Decorator for automatic function timing with optional custom callbacks.
+
+## Development
+
+```bash
+# Install with dev dependencies
+uv sync --dev
+
+# Run tests
+pytest tests/
+
+# Run tests with coverage report
+pytest tests -v --cov=src --cov-report=term-missing --cov-report=xml:cov.xml
+
+# Type checking
+mypy .
+
+# Lint checking
+ruff check
+
+# Format checking
+ruff format --check --diff
+```
+
+## License
+
+MIT License - Copyright (c) 2025 NakuRei
+
+## Contributing
+
+Contributions welcome! Feel free to open issues or submit pull requests.

ticko-1.0.0/pyproject.toml

@@ -0,0 +1,71 @@
+[project]
+name = "ticko"
+version = "1.0.0"
+description = "Thread-safe stopwatch for measuring elapsed time"
+readme = "README.md"
+authors = [
+    { name = "NakuRei", email = "nakurei7901@gmail.com" }
+]
+requires-python = ">=3.10"
+keywords = ["stopwatch", "timer", "performance", "profiling", "benchmark"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+    "Topic :: System :: Benchmark",
+    "Typing :: Typed",
+]
+dependencies = []
+
+[project.urls]
+Homepage = "https://github.com/NakuRei/ticko"
+Repository = "https://github.com/NakuRei/ticko"
+Issues = "https://github.com/NakuRei/ticko/issues"
+
+[build-system]
+requires = ["uv_build>=0.9.4,<0.10.0"]
+build-backend = "uv_build"
+
+[dependency-groups]
+dev = [
+    "lxml>=6.0.2",
+    "mypy>=1.18.2",
+    "pytest>=8.4.2",
+    "pytest-cov>=7.0.0",
+    "ruff>=0.14.1",
+    "ticko",
+]
+
+[tool.ruff]
+line-length = 80
+indent-width = 4
+target-version = "py310"
+
+[tool.ruff.lint]
+select = ["ALL"]
+ignore = [
+    "S101", # assert
+    "D203", # incorrect-blank-line-before-class
+    "D213", # multi-line-summary-second-line
+    "COM812", # disabled to prevent conflicts with the formatter (trailing comma handling)
+]
+per-file-ignores = { "examples/**" = ["T201", "INP001"], "tests/**" = ["INP001", "PLR2004", "ARG005", "D401", "D404", "TRY003", "EM101", "BLE001", "PERF203"] }
+
+[tool.ruff.format]
+quote-style = "double"
+indent-style = "space"
+line-ending = "lf"
+
+[tool.uv.workspace]
+members = [
+    ".",
+]
+
+[tool.uv.sources]
+ticko = { workspace = true, editable = true }

ticko-1.0.0/src/ticko/__init__.py

@@ -0,0 +1,56 @@
+"""Ticko: A simple and flexible stopwatch library for Python.
+
+This package provides utilities for measuring execution time in Python programs.
+It includes a thread-safe StopWatch class for manual timing control and a
+decorator for automatically measuring function execution times.
+
+Classes
+-------
+StopWatch
+    Thread-safe stopwatch for measuring elapsed time with start, stop, lap,
+    and reset functionality.
+
+Functions
+---------
+stopwatch
+    Decorator that measures and reports the execution time of a function.
+
+Examples
+--------
+Using the decorator:
+
+>>> @stopwatch
+... def compute(n):
+...     return sum(range(n))
+>>> compute(1000)
+Function 'compute' executed in 0.000123 seconds
+499500
+
+Using the StopWatch class directly:
+
+>>> sw = StopWatch()
+>>> sw.start()
+>>> # ... do some work ...
+>>> sw.lap()
+1.234
+>>> # ... do more work ...
+>>> sw.stop()
+2.567
+
+Using StopWatch as a context manager:
+
+>>> with StopWatch() as sw:
+...     # ... do some work ...
+...     pass
+>>> sw.time_elapsed
+1.234
+
+"""
+
+from .decorators import stopwatch
+from .stop_watch import StopWatch
+
+__all__ = [
+    "StopWatch",
+    "stopwatch",
+]

ticko-1.0.0/src/ticko/decorators.py

@@ -0,0 +1,109 @@
+"""Decorator for measuring function execution time."""
+
+import functools
+import logging
+import time
+from collections.abc import Callable
+from typing import ParamSpec, TypeVar, overload
+
+from .stop_watch import StopWatch
+
+logger = logging.getLogger(__name__)
+
+P = ParamSpec("P")
+R = TypeVar("R")
+
+
+# Overload 1: Decorator without arguments (@stopwatch)
+@overload
+def stopwatch(
+    func: Callable[P, R],
+) -> Callable[P, R]: ...
+
+
+# Overload 2: Decorator with arguments (@stopwatch(...))
+@overload
+def stopwatch(
+    func: None = None,
+    *,
+    timer_func: Callable[[], float] = time.perf_counter,
+    exit_callback: Callable[[StopWatch], None] | None = None,
+) -> Callable[[Callable[P, R]], Callable[P, R]]: ...
+
+
+# Implementation
+def stopwatch(
+    func: Callable[P, R] | None = None,
+    *,
+    timer_func: Callable[[], float] = time.perf_counter,
+    exit_callback: Callable[[StopWatch], None] | None = None,
+) -> Callable[P, R] | Callable[[Callable[P, R]], Callable[P, R]]:
+    """Measure the execution time of a function using StopWatch.
+
+    Parameters
+    ----------
+    func : Callable[P, R] | None, optional
+        The function to decorate. If None, returns a decorator function.
+    timer_func : Callable[[], float], optional
+        Function returning the current time (default: time.perf_counter).
+    exit_callback : Callable[[StopWatch], None] | None, optional
+        Optional callback invoked with the StopWatch instance when the
+        decorated function exits. If None, a default callback is used that
+        prints the elapsed time to standard output.
+
+    Returns
+    -------
+    Callable[P, R] or Callable[[Callable[P, R]], Callable[P, R]]
+        The decorated function, or a decorator function when func is None.
+
+    Notes
+    -----
+    The StopWatch is stopped regardless of whether the decorated function
+    returns normally or raises an exception. If an exception occurs it is
+    re-raised after the stopwatch has been stopped; exit_callback is still
+    invoked.
+
+    Examples
+    --------
+    >>> @stopwatch
+    ... def f(x):
+    ...     return x * 2
+
+    """
+
+    def _create_wrapper(f: Callable[P, R]) -> Callable[P, R]:
+        """Create the wrapper function for the given function."""
+
+        @functools.wraps(f)
+        def wrapper(*args: P.args, **kwargs: P.kwargs) -> R:
+            callback = exit_callback
+            if callback is None:
+
+                def _default_callback(sw: StopWatch) -> None:
+                    print(  # noqa: T201
+                        f"Function {f.__name__!r} executed "
+                        f"in {sw.time_elapsed:.6f} seconds",
+                    )
+
+                callback = _default_callback
+
+            sw = StopWatch(timer_func=timer_func, exit_callback=callback)
+            sw.start()
+            try:
+                return f(*args, **kwargs)
+            except Exception:
+                logger.exception(
+                    "Exception in stopwatch-decorated function",
+                )
+                raise
+            finally:
+                sw.stop()
+
+        return wrapper
+
+    if func is None:
+        # Return a decorator function
+        return _create_wrapper
+
+    # Apply decorator directly
+    return _create_wrapper(func)

ticko-1.0.0/src/ticko/stop_watch.py

@@ -0,0 +1,323 @@
+"""Thread-safe stopwatch for measuring elapsed time."""
+
+import logging
+import threading
+import time
+from collections.abc import Callable
+from types import TracebackType
+from typing import Final, final
+
+logger = logging.getLogger(__name__)
+
+
+class StopWatchError(Exception):
+    """Base class for StopWatch exceptions."""
+
+
+class InvalidStateError(StopWatchError):
+    """Raised when an operation is attempted in an invalid state."""
+
+
+class AlreadyRunningError(StopWatchError):
+    """Raised when trying to start an already running stopwatch."""
+
+
+class NotStartedError(StopWatchError):
+    """Raised when stopping or lapping a stopwatch that hasn't been started."""
+
+
+@final
+class StopWatch:
+    """Thread-safe stopwatch for measuring elapsed time.
+
+    This class provides methods to start, stop, lap, and reset a stopwatch. It
+    is designed to be thread-safe, allowing safe usage in multi-threaded
+    environments.
+
+    Parameters
+    ----------
+    timer_func : Callable[[], float], optional
+        Function returning the current time (default: time.perf_counter).
+    exit_callback : Callable[[StopWatch], None] | None, optional
+        Optional callback invoked with the StopWatch instance when the
+        stopwatch is stopped. If None, no callback is invoked.
+
+    Attributes
+    ----------
+    is_running : bool
+        Indicates whether the stopwatch is currently running.
+    time_start : float | None
+        The start time of the stopwatch, or None if not started.
+    time_stop : float | None
+        The stop time of the stopwatch, or None if not stopped.
+    time_last_lap_start : float | None
+        The start time of the last lap, or None if no laps recorded.
+    time_elapsed : float
+        The total elapsed time since the stopwatch was started.
+    time_last_lap : float
+        The elapsed time of the last lap.
+
+    Methods
+    -------
+    start() -> float
+        Start the stopwatch.
+    lap() -> float
+        Record a lap time.
+    stop() -> float
+        Stop the stopwatch.
+    reset() -> None
+        Reset the stopwatch to its initial state.
+
+    Examples
+    --------
+    >>> sw = StopWatch()
+    >>> sw.start()
+    >>> time.sleep(1)
+    >>> sw.lap()
+    1.0
+    >>> time.sleep(2)
+    >>> sw.stop()
+    3.0
+    >>> sw.time_elapsed
+    3.0
+    >>> sw.reset()
+    >>> sw.time_elapsed
+    Traceback (most recent call last):
+        ...
+    NotStartedError: ...
+
+    """
+
+    def __init__(
+        self,
+        timer_func: Callable[[], float] = time.perf_counter,
+        exit_callback: Callable[["StopWatch"], None] | None = None,
+    ) -> None:
+        """Initialize the stopwatch.
+
+        Parameters
+        ----------
+        timer_func : Callable[[], float], optional
+            Function returning the current time (default: time.perf_counter).
+        exit_callback : Callable[[StopWatch], None] | None, optional
+            Optional callback invoked when the stopwatch is stopped.
+
+        """
+        self._timer_func: Final = timer_func
+        self._exit_callback: Final = exit_callback
+
+        self._time_start: float | None = None
+        self._time_last_lap_start: float | None = None
+        self._time_stop: float | None = None
+        self._is_running: bool = False
+
+        self._lock = threading.Lock()  # For thread safety
+
+    @property
+    def is_running(self) -> bool:
+        """Check if the stopwatch is currently running."""
+        with self._lock:
+            return self._is_running
+
+    @property
+    def time_start(self) -> float | None:
+        """Get the start time of the stopwatch."""
+        with self._lock:
+            return self._time_start
+
+    @property
+    def time_stop(self) -> float | None:
+        """Get the stop time of the stopwatch."""
+        with self._lock:
+            return self._time_stop
+
+    @property
+    def time_last_lap_start(self) -> float | None:
+        """Get the start time of the last lap."""
+        with self._lock:
+            return self._time_last_lap_start
+
+    @property
+    def time_elapsed(self) -> float:
+        """Get the total elapsed time."""
+        with self._lock:
+            if self._time_start is None:
+                msg = (
+                    "Stopwatch has not been started. "
+                    "Call start() before getting elapsed time."
+                )
+                raise NotStartedError(msg)
+
+            if self._is_running:
+                return self._timer_func() - self._time_start
+            if self._time_stop is not None:
+                return self._time_stop - self._time_start
+            # This is unreachable
+            msg = (
+                "Stopwatch is in an invalid state. "
+                "Call reset() to reinitialize."
+            )
+            raise InvalidStateError(msg)
+
+    @property
+    def time_last_lap(self) -> float:
+        """Get the elapsed time of the last lap."""
+        with self._lock:
+            if self._time_last_lap_start is None:
+                msg = (
+                    "No laps have been recorded. "
+                    "Call lap() after starting the stopwatch."
+                )
+                raise NotStartedError(msg)
+
+            if self._is_running:
+                return self._timer_func() - self._time_last_lap_start
+            if self._time_stop is not None:
+                return self._time_stop - self._time_last_lap_start
+            # This is unreachable
+            msg = (
+                "Stopwatch is in an invalid state. "
+                "Call reset() to reinitialize."
+            )
+            raise InvalidStateError(msg)
+
+    def reset(self) -> None:
+        """Reset the stopwatch to its initial state."""
+        with self._lock:
+            self._time_start = None
+            self._time_last_lap_start = None
+            self._time_stop = None
+            self._is_running = False
+            logger.debug("Stopwatch has been reset.")
+
+    def start(self) -> float:
+        """Start the stopwatch."""
+        with self._lock:
+            if self._is_running:
+                msg = (
+                    "Stopwatch is already running. "
+                    "Stop or reset it before starting again."
+                )
+                raise AlreadyRunningError(msg)
+            time_current: Final = self._timer_func()
+            self._time_start = time_current
+            self._time_last_lap_start = time_current
+            self._time_stop = None
+            self._is_running = True
+            logger.debug("Stopwatch started at %f.", time_current)
+            return time_current
+
+    def lap(self) -> float:
+        """Record a lap time."""
+        with self._lock:
+            if not self._is_running:
+                msg = (
+                    "Stopwatch is not running. "
+                    "Call start() first before recording a lap."
+                )
+                raise NotStartedError(msg)
+            if self._time_last_lap_start is None:
+                # Invariant check: should not happen if running
+                msg = "Last lap start time should not be None if running."
+                raise InvalidStateError(msg)
+
+            time_current: Final = self._timer_func()
+            lap_duration: Final = time_current - self._time_last_lap_start
+            self._time_last_lap_start = time_current
+            logger.debug(
+                "Lap recorded at %f with duration %f.",
+                time_current,
+                lap_duration,
+            )
+            return lap_duration
+
+    def stop(self) -> float:
+        """Stop the stopwatch."""
+        with self._lock:
+            if not self._is_running:
+                msg = (
+                    "Stopwatch is not running. "
+                    "Call start() first before stopping."
+                )
+                raise NotStartedError(msg)
+            if self._time_start is None:
+                # Invariant check: should not happen if running
+                msg = "Start time should not be None if running."
+                raise InvalidStateError(msg)
+
+            time_current: Final = self._timer_func()
+            self._time_stop = time_current
+            # Directly compute to avoid multiple calls of with self._lock
+            time_elapsed: Final = self._time_stop - self._time_start
+            self._is_running = False
+            logger.debug(
+                "Stopwatch stopped at %f with elapsed time %f.",
+                time_current,
+                time_elapsed,
+            )
+
+        # Call exit_callback outside the lock to avoid deadlock
+        # if callback tries to access stopwatch properties
+        if self._exit_callback is not None:
+            try:
+                self._exit_callback(self)
+            except Exception:
+                logger.exception("Exit callback raised an exception")
+
+        return time_elapsed
+
+    def __repr__(self) -> str:
+        """Return a string representation for recreating the StopWatch.
+
+        Returns a string showing the constructor parameters, following the
+        Python convention that repr() should return a string that could be
+        used to recreate the object.
+        """
+        timer_name = getattr(
+            self._timer_func,
+            "__name__",
+            repr(self._timer_func),
+        )
+        callback_name = (
+            None
+            if self._exit_callback is None
+            else getattr(
+                self._exit_callback,
+                "__name__",
+                repr(self._exit_callback),
+            )
+        )
+        return (
+            f"StopWatch(timer_func={timer_name}, exit_callback={callback_name})"
+        )
+
+    def __str__(self) -> str:
+        """Return a human-readable string representation.
+
+        Returns a string describing the current state of the stopwatch,
+        including whether it's running and the elapsed time if applicable.
+        """
+        with self._lock:
+            if self._time_start is None:
+                return "StopWatch(not started)"
+            if self._is_running:
+                elapsed = self._timer_func() - self._time_start
+                return f"StopWatch(running, elapsed={elapsed:.6f}s)"
+            if self._time_stop is not None:
+                elapsed = self._time_stop - self._time_start
+                return f"StopWatch(stopped, elapsed={elapsed:.6f}s)"
+            return "StopWatch(invalid state)"  # This is unreachable
+
+    def __enter__(self) -> "StopWatch":
+        """Enter the context manager and start the stopwatch."""
+        self.start()
+        return self
+
+    def __exit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_value: BaseException | None,
+        traceback: TracebackType | None,
+    ) -> None:
+        """Exit the context manager and stop the stopwatch."""
+        self.stop()