asynkio 0.0.3__py3-none-any.whl

asynkio/__init__.py

@@ -0,0 +1,21 @@
+
+__version__ = '0.0.3'
+
+from .time import (
+    Duration,
+    Instant,
+    Interval,
+    MissedTickBehavior,
+    MissedTickBehaviour,
+)
+
+
+__all__ = [
+    '__version__',
+
+    'Duration',
+    'Instant',
+    'Interval',
+    'MissedTickBehavior',
+    'MissedTickBehaviour',
+]

asynkio/time/__init__.py

@@ -0,0 +1,19 @@
+
+from .interval import (
+    Interval,
+    MissedTickBehavior,
+    MissedTickBehaviour,
+)
+from .types import (
+    Duration,
+    Instant,
+)
+
+
+__all__ = [
+    'Duration',
+    'Instant',
+    'Interval',
+    'MissedTickBehavior',
+    'MissedTickBehaviour',
+]

asynkio/time/interval.py

@@ -0,0 +1,253 @@
+
+from .types import (
+    Duration,
+    Instant,
+)
+
+import asyncio
+import enum
+
+
+class MissedTickBehaviour(enum.IntEnum):
+    """
+    Defines the behaviour of an `Interval` when it misses a tick.
+
+    See
+    ---
+        https://docs.rs/tokio/latest/tokio/time/enum.MissedTickBehavior.html
+    """
+
+    """
+    Ticks as fast as possible until caught up.
+    """
+    BURST = 1
+    """
+    Tick at multiples of period from when tick was called, rather than from
+    start.
+    """
+    DELAY = 2
+    """
+    Skips missed ticks and tick on the next multiple of period from start.
+    """
+    SKIP = 3
+
+
+    def _to_str(self):
+
+        if MissedTickBehaviour.BURST == self:
+
+            return 'BURST'
+
+        if MissedTickBehaviour.DELAY == self:
+
+            return 'DELAY'
+
+        if MissedTickBehaviour.SKIP == self:
+
+            return 'SKIP'
+
+        return NotImplemented
+
+    @staticmethod
+    def try_parse(s : str):
+        """
+        Attempts, in a case-insensitive manner, to interpret a string into
+        a named member of the class, i.e. a recognised enumerator; returns
+        `None` if not recogised.
+        """
+
+        try:
+
+            return MissedTickBehaviour[str(s).upper()]
+        except KeyError:
+
+            return None
+
+    def __repr__(self):
+
+        return f"<{self.__module__}.{self.__class__.__name__}.{self._to_str()}>"
+
+    def __str__(self):
+
+        return enum.Enum.__str__(self)
+
+
+MissedTickBehavior = MissedTickBehaviour
+
+
+class Interval:
+    """
+    Supports wait operations with a certain periodicity and behaviour for
+    late ticking.
+    """
+
+    __slots__ = (
+        # invariant fields
+        '_period_ns',
+        '_missed_tick_behaviour',
+        '_name',
+        '_negative_bias',
+        '_reference_instant',
+        # variant fields
+        '_recent_instant',
+        '_event_count',
+    )
+
+    def __init__(
+        self,
+        period : Duration | int,
+        missed_tick_behaviour : MissedTickBehaviour=MissedTickBehaviour.SKIP,
+        name=None,
+        negative_bias=None,
+    ):
+        """
+        Creates an instance, based on the given parameters.
+        """
+
+        assert isinstance(period, (Duration, int)), "`period` must be instance of `Duration` or `int` (which specifies nanoseconds)"
+
+        assert negative_bias is None or negative_bias < int(period), "invalid `negative_bias` ({negative_bias}) given the `period` ({period)}"
+
+        self._period_ns = int(period)
+        self._missed_tick_behaviour = missed_tick_behaviour
+        self._name = str(name) if name else ''
+        self._negative_bias = negative_bias if isinstance(negative_bias, int) else 400_000 if self._period_ns > 100_000_000 else 0
+        self._reference_instant = Instant.now()
+
+        self._recent_instant = None
+        self._event_count = 0
+
+    def __repr__(self):
+
+        return "" \
+            f"<{self.__module__}.{self.__class__.__name__}: " \
+            f"_period_ns: {self._period_ns:,}; " \
+            f"_missed_tick_behaviour: {self._missed_tick_behaviour:}; " \
+            f"_name: {self._name}; " \
+            f"_negative_bias: {self._negative_bias}; " \
+            f"_reference_instant: {self._reference_instant:}; " \
+            f"_recent_instant: {self._recent_instant:}; " \
+            f"_event_count: {self._event_count:,}; " \
+            ">"
+
+    def __await__(self):
+        """
+        .
+        """
+
+        self._event_count += 1
+
+        now = Instant.now()
+
+
+        if self._missed_tick_behaviour == MissedTickBehaviour.DELAY:
+
+            # simply wait for given duration
+
+            self._recent_instant = now
+
+            return asyncio.sleep((self._period_ns - self._negative_bias) / 1_000_000_000).__await__()
+
+
+        duration : Duration = now - self._reference_instant
+        duration_ns = duration.as_nanos()
+
+        # calculate number of intervals (`q`) and remainder (`r`)
+
+        q, r = divmod(duration_ns, self._period_ns)
+
+
+        if self._missed_tick_behaviour == MissedTickBehavior.BURST:
+
+            # either ...
+
+            if self._event_count <= q:
+
+                # ... respond immediately if more than a full interval, or ...
+
+                self._recent_instant = now
+
+                return asyncio.sleep(0).__await__()
+
+            if self._event_count + 1 == q:
+
+                # ... wait for the last bit of the interval.
+
+                self._recent_instant = now
+
+                return asyncio.sleep(r / 1_000_000_000).__await__()
+
+
+        # `SKIP` behaviour:
+        #
+        # T.B.C.
+
+        # get the time _now_ and then calculate how much time has
+        # elapsed, ...
+
+        # ... and from this calculate how long the next wait should be
+
+        p_ns = self._period_ns - r
+        if p_ns > self._negative_bias:
+
+            p_ns -= self._negative_bias
+
+        self._recent_instant = now
+
+        return asyncio.sleep(p_ns / 1_000_000_000).__await__()
+
+    def event_count(self) -> int:
+        """
+        The number of times that the interval has been awaited.
+        """
+
+        return self._event_count
+
+    def missed_tick_behaviour(self) -> str:
+        """
+        The interval's missed-tick behaviour.
+        """
+
+        return self._missed_tick_behaviour
+
+    def missed_tick_behavior(self) -> str:
+        """
+        The interval's missed-tick behaviour.
+        """
+
+        return self.missed_tick_behaviour()
+
+    def name(self) -> str:
+        """
+        The interval's name.
+        """
+
+        return self._name
+
+    def negative_bias(self) -> Duration:
+        """
+        The interval's negative bias.
+        """
+
+        return Duration.from_nanos(self._negative_bias)
+
+    def period(self) -> Duration:
+        """
+        The interval's period.
+        """
+
+        return Duration.from_nanos(self._period_ns)
+
+    def recent_instant(self) -> Instant:
+        """
+        The instance's most recent await instant.
+        """
+
+        return self._recent_instant
+
+    def reference_instant(self) -> Instant:
+        """
+        The instance's reference instant.
+        """
+
+        return self._reference_instant

asynkio/time/types.py

@@ -0,0 +1,543 @@
+
+from datetime import (
+    datetime,
+    timezone,
+)
+import time
+from typing import Self
+
+
+class Duration:
+    """
+    Represents a span of time.
+    """
+
+    __slots__ = (
+        '_duration',
+    )
+
+    def __init__(
+        self,
+        from_ns,
+        to_ns,
+    ):
+        """
+        Creates a new instance from the number of nanoseconds represented by
+        `to_ns - from_ns`.
+        """
+
+        self._duration = to_ns - from_ns
+
+    @staticmethod
+    def from_nanos(t_ns : int) -> Self:
+        """
+        Creates a new instance from the specified number of nanoseconds.
+        """
+
+        return Duration(0, t_ns)
+
+    @staticmethod
+    def from_micros(t_us : int) -> Self:
+        """
+        Creates a new instance from the specified number of microseconds.
+        """
+
+        return Duration(0, t_us * 1_000)
+
+    @staticmethod
+    def from_millis(t_ms : int) -> Self:
+        """
+        Creates a new instance from the specified number of milliseconds.
+        """
+
+        return Duration(0, t_ms * 1_000_000)
+
+    @staticmethod
+    def from_secs(t_s : int) -> Self:
+        """
+        Creates a new instance from the specified number of seconds.
+        """
+
+        return Duration(0, t_s * 1_000_000_000)
+
+    def as_nanos(self) -> int:
+        """
+        Total number of whole nanoseconds contained by this instance.
+        """
+
+        return self._duration
+
+    def as_micros(self) -> int:
+        """
+        Total number of whole microseconds contained by this instance.
+        """
+
+        return self._duration // 1_000
+
+    def as_millis(self) -> int:
+        """
+        Total number of whole milliseconds contained by this instance.
+        """
+
+        return self._duration // 1_000_000
+
+    def as_secs(self) -> int:
+        """
+        Total number of whole seconds contained by this instance.
+        """
+
+        return self._duration // 1_000_000_000
+
+    def as_secs_f(self) -> float:
+        """
+        The fractional number of seconds contained by this instance.
+        """
+
+        return self._duration / 1_000_000_000.0
+
+    def subsec_nanos(self) -> int:
+        """
+        The fractional part of this instance, in nanoseconds.
+        """
+
+        return self._duration % 1_000_000_000
+
+    def subsec_micros(self) -> int:
+        """
+        The fractional part of this instance, in microseconds.
+        """
+
+        return (self._duration % 1_000_000_000) // 1_000
+
+    def subsec_millis(self) -> int:
+        """
+        The fractional part of this instance, in milliseconds.
+        """
+
+        return (self._duration % 1_000_000_000) // 1_000_000
+
+    @staticmethod
+    def _scale_index(n : int) -> tuple[int, int]:
+
+        _SCALES = [
+            1,
+            10,
+            100,
+            1_000,
+            10_000,
+            100_000,
+            1_000_000,
+            10_000_000,
+            100_000_000,
+            1_000_000_000,
+            10_000_000_000,
+            100_000_000_000,
+        ]
+
+        assert n > 0
+        assert len(_SCALES) == 12
+
+        if n >= 100_000_000_000:
+
+            return (11, _SCALES[11])
+
+        l = 0
+        h = 11
+
+        count = 0
+
+        while l <= h:
+
+            count += 1
+
+            assert count < 5, f"too many loops while trying to scale {n}"
+
+            m = (h + l) // 2
+
+            b = _SCALES[m]
+
+            if n == b:
+
+                return (m, b)
+
+            if n < b:
+
+                h = m
+
+                continue
+            else:
+                assert n > b
+
+                if n < b * 10:
+
+                    return (m, b)
+                else:
+
+                    l = m
+
+        return (11, _SCALES[11])
+
+    @staticmethod
+    def duration_to_string(
+        duration : Self | int,
+        format_spec : str = '',
+    ) -> str:
+
+        v = int(duration)
+
+        if v < 0:
+
+            v = -v
+            sign = '-'
+        else:
+
+            if '+' in format_spec:
+
+                sign = '+'
+            else:
+
+                sign = ''
+
+        if v == 0:
+
+            return "0s"
+
+        oom, divisor = Duration._scale_index(v)
+
+        suffixes = [
+            'ns',
+            'µs',
+            'ms',
+            's',
+        ]
+        suffix = suffixes[oom // 3]
+
+        def fmt(
+            sign,
+            whole,
+            frac,
+            suffix,
+        ):
+
+            if frac == 0:
+
+                return f"{sign}{whole}{suffix}"
+            else:
+
+                if whole > 999:
+
+                    return f"{sign}{whole}{suffix}"
+
+                if whole > 99:
+
+                    return f"{sign}{whole}.{frac}{suffix}"
+
+                if whole > 9:
+
+                    return f"{sign}{whole}.{frac:02d}{suffix}"
+
+                return f"{sign}{whole}.{frac}{suffix}"
+
+        if oom < 3:
+
+            return f"{sign}{v}{suffix}"
+        else:
+
+            divisor_0 = divisor // 1_000
+
+            i = oom % 3
+
+            if i == 0:
+
+                divisor_1 = 1_000
+            elif i == 1:
+
+                divisor_1 = 100
+            else:
+
+                divisor_1 = 10
+
+
+            v //= divisor_0
+
+            whole = v // divisor_1
+            frac = v - (whole * divisor_1)
+
+            return fmt(
+                sign,
+                whole,
+                frac,
+                suffix,
+            )
+
+    def __eq__(self, rhs : Self | float | int) -> bool:
+
+        if isinstance(rhs, Duration):
+
+            return self._duration == rhs._duration
+
+        if isinstance(rhs, (float, int)):
+
+            return self._duration == int(rhs)
+
+        return NotImplemented
+
+    def __format__(self, format_spec) -> str:
+
+        return self.duration_to_string(
+            self._duration,
+            format_spec=format_spec,
+        )
+
+    def __str__(self) -> str:
+
+        return self.duration_to_string(
+            self._duration,
+            format_spec='',
+        )
+
+    def __repr__(self) -> str:
+
+        return f"<{self.__module__}.{self.__class__.__name__}: _duration={self._duration}>"
+
+    def __int__(self) -> int:
+        """
+        Converts an instance into an integer, representing the number of
+        nanoseconds in the duration.
+        """
+
+        return self._duration
+
+    def __add__(self, rhs : Self) -> Self:
+
+        if isinstance(rhs, Duration):
+
+            return Duration.from_nanos(self._duration + rhs._duration)
+
+        return NotImplemented
+
+    def __sub__(self, rhs : Self) -> Self:
+
+        if isinstance(rhs, Duration):
+
+            return Duration.from_nanos(self._duration - rhs._duration)
+
+        return NotImplemented
+
+    def __mul__(self, rhs : float | int) -> Self:
+
+        if isinstance(rhs, float):
+
+            return Duration.from_nanos(int(self._duration * rhs))
+
+        if isinstance(rhs, int):
+
+            return Duration.from_nanos(self._duration * rhs)
+
+        return NotImplemented
+
+    def __truediv__(self, rhs : Self | float | int) -> Self:
+
+        if isinstance(rhs, (Duration, int)):
+
+            return Duration.from_nanos(self._duration / int(rhs))
+
+        if isinstance(rhs, float):
+
+            return Duration.from_nanos(int(self._duration / rhs))
+
+        return NotImplemented
+
+
+class Instant:
+    """
+    Represents a moment in time.
+    """
+
+    __slots__ = (
+        '_t',
+    )
+
+    def __init__(self, t_ns):
+        """
+        Initialises with the given time instant (specified in nanoseconds).
+        """
+
+        self._t = t_ns
+
+    @staticmethod
+    def _t_ns_to_d_utc(t_ns : int) -> datetime:
+        """
+        Convert the number of nanoseconds since epoch into a datetime
+        instance assuming UTC.
+        """
+
+        return datetime.fromtimestamp(t_ns / 1_000_000_000.0, tz=timezone.utc)
+
+    @staticmethod
+    def now() -> Self:
+        """
+        Initialises with the current time instant.
+        """
+
+        t_now_ns = time.time_ns()
+
+        return Instant(t_now_ns)
+
+    @staticmethod
+    def instant_to_string(
+        instant : Self | int,
+        format_spec : str = '',
+    ) -> str:
+
+        typed = None
+
+        def set_type_or_raise(
+            typed,
+            t,
+            c,
+            b,
+        ):
+
+            # local as_type
+
+            if typed is not None:
+
+                raise ValueError(f"cannot specify type `{t}` as type already specified as `{typed[0]}`")
+
+            else:
+
+                return (t, c, b)
+
+        show_plus = False
+        show_base = False
+
+        for c in format_spec:
+
+            if c == 'd':
+
+                typed = set_type_or_raise(typed, int, c, '')
+
+            if c == 'o':
+
+                typed = set_type_or_raise(typed, int, c, '0o')
+
+            if c == 'x':
+
+                typed = set_type_or_raise(typed, int, c, '0x')
+
+            if c == 'X':
+
+                typed = set_type_or_raise(typed, int, c, '0X')
+
+            if c == '+':
+
+                show_plus = True
+
+            if c == '#':
+
+                show_base = True
+
+        if typed:
+
+            if typed[0] == int:
+
+                fmt = ''
+
+                if show_plus:
+
+                    fmt += '+'
+
+                if show_base:
+
+                    fmt += '#'
+
+                fmt += typed[1]
+
+                return format(instant, fmt)
+            else:
+
+                return NotImplemented
+        else:
+
+            d = Instant._t_ns_to_d_utc(instant)
+
+            return d.strftime("%Y-%m-%dT%H:%M:%S.%fZ")
+
+    def __format__(self, format_spec) -> str:
+
+        return Instant.instant_to_string(
+            self._t,
+            format_spec=format_spec,
+        )
+
+    def __str__(self) -> str:
+
+        return Instant.instant_to_string(
+            self._t,
+            format_spec='',
+        )
+
+    def __repr__(self) -> str:
+
+        return f"<{self.__module__}.{self.__class__.__name__}: _t={self._t}>"
+
+    def __int__(self) -> int:
+        """
+        Converts an instance into an integer, representing the number of
+        nanoseconds since the epoch.
+        """
+
+        return self._t
+
+    def __lt__(self, rhs) -> bool:
+        """
+        Determines whether the called instance is less-than the `rhs`
+        instance of `Instant`.
+        """
+
+        if isinstance(rhs, Instant):
+
+            return self._t < rhs._t
+
+        raise NotImplemented
+
+    def __le__(self, rhs) -> bool:
+        """
+        Determines whether the called instance is less-than-or-equal-to the
+        `rhs` instance of `Instant`.
+        """
+
+        if isinstance(rhs, Instant):
+
+            return self._t <= rhs._t
+
+        raise NotImplemented
+
+    def __sub__(self, rhs) -> Duration | Self:
+        """
+        Subtracts the `rhs` - which may be an instance of `Instant` or an
+        instance of `Duration` - from the called instance.
+        """
+
+        if isinstance(rhs, Instant):
+
+            return Duration(rhs._t, self._t)
+
+        if isinstance(rhs, Duration):
+
+            return Instant(self._t - rhs.as_nanos())
+
+        return NotImplemented
+
+    def __add__(self, rhs) -> Self:
+        """
+        Adds the `rhs` instance of `Duration` to the called instance.
+        """
+
+        if isinstance(rhs, Duration):
+
+            return Instant(self._t + rhs.as_nanos())
+
+        return NotImplemented
+

asynkio-0.0.3.dist-info/METADATA

@@ -0,0 +1,184 @@
+Metadata-Version: 2.4
+Name: asynkio
+Version: 0.0.3
+Summary: Tokio-like functionality for Python
+Author-email: Matt Wilson <matthew@synesis.com.au>
+Project-URL: Changelog, https://github.com/synesissoftware/asynkio/releases
+Project-URL: Homepage, https://github.com/synesissoftware/asynkio
+Project-URL: Issues, https://github.com/synesissoftware/asynkio/issues
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Natural Language :: English
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+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
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: dev
+Requires-Dist: aiofiles; extra == "dev"
+Requires-Dist: diagnosticism; extra == "dev"
+Requires-Dist: pyclasp>=0.8.10; extra == "dev"
+Requires-Dist: pytest>=8.4.1; extra == "dev"
+Provides-Extra: test
+Requires-Dist: aiofiles; extra == "test"
+Requires-Dist: diagnosticism; extra == "test"
+Requires-Dist: pyclasp>=0.8.10; extra == "test"
+Requires-Dist: pytest>=8.4.1; extra == "test"
+Dynamic: license-file
+
+# asynkio - README <!-- omit in toc -->
+
+Tokio-like functionality for Python
+
+![Language](https://img.shields.io/badge/Python-3776AB?style=flat&logo=python&logoColor=white)
+[![License](https://img.shields.io/badge/License-BSD_3--Clause-blue.svg)](https://opensource.org/licenses/BSD-3-Clause)
+[![PyPI](https://img.shields.io/pypi/v/asynkio.svg)](https://pypi.org/project/asynkio/)
+[![GitHub release](https://img.shields.io/github/v/release/synesissoftware/asynkio.svg)](https://github.com/synesissoftware/asynkio/releases/latest)
+![Python](https://img.shields.io/badge/Python-3.11+-lightgrey)
+[![CI](https://github.com/synesissoftware/asynkio/actions/workflows/python-package.yml/badge.svg)](https://github.com/synesissoftware/asynkio/actions/workflows/python-package.yml)
+[![PyPI project](https://img.shields.io/badge/documentation-PyPI-lightgrey)](https://pypi.org/project/asynkio/)
+
+
+## Table of contents <!-- omit in toc -->
+
+- [Introduction](#introduction)
+- [Installation \& Usage](#installation--usage)
+- [Components](#components)
+- [Examples](#examples)
+- [Project Information](#project-information)
+	- [Where to get help](#where-to-get-help)
+	- [Contribution guidelines](#contribution-guidelines)
+	- [Dependencies](#dependencies)
+		- [Efferent (fan-out)](#efferent-fan-out)
+			- [Development Dependencies](#development-dependencies)
+		- [Afferent (fan-in)](#afferent-fan-in)
+	- [Related projects](#related-projects)
+	- [License](#license)
+
+
+## Introduction
+
+**asynkio** - a portmanteau of **asyncio** and **Tokio**, pronounced "ay sink ee-oh" - is a small, simple **Python** library that provides some of the features of the **Rust** **Tokio** library's features, such as `Duration`, `Instant`, and `Interval`.
+
+
+## Installation & Usage
+
+Install via **pip** or **pip3**, as in:
+
+```
+$ pip3 install asynkio
+```
+
+Use via **import**:
+
+```python
+from asynkio import (
+    Duration,
+    Instant,
+    Interval,
+    MissedTickBehaviour,
+)
+```
+
+or:
+
+```python
+from asynkio.time import (
+    Duration,
+    Instant,
+    Interval,
+    MissedTickBehaviour,
+)
+```
+
+`MissedTickBehavior` (US spelling) is also exported as an alias for
+`MissedTickBehaviour`.
+
+
+## Components
+
+| Symbol | Description |
+| --- | --- |
+| `Duration` | Elapsed time, in nanoseconds (Tokio-like) |
+| `Instant` | Point in time, as nanoseconds since the epoch |
+| `Interval` | Async periodic timer with missed-tick policy |
+| `MissedTickBehaviour` | Missed-tick policy (`BURST`, `DELAY`, `SKIP`) |
+
+
+## Examples
+
+Examples are provided in the `examples/` directory. See
+[EXAMPLES.md](./EXAMPLES.md) for a summary of each script.
+
+Run a script with, for example:
+
+```
+$ uv sync
+$ uv run python examples/interval_skip.py
+```
+
+
+## Project Information
+
+
+### Where to get help
+
+[GitHub Page](https://github.com/synesissoftware/asynkio "GitHub Page")
+
+
+### Contribution guidelines
+
+Defect reports, feature requests, and pull requests are welcome on https://github.com/synesissoftware/asynkio.
+
+
+### Dependencies
+
+**asynkio** has no runtime dependencies beyond the **Python** standard
+library (`asyncio`).
+
+
+#### Efferent (fan-out)
+
+Libraries upon which **asynkio** depends:
+
+None.
+
+
+##### Development Dependencies
+
+* [**aiofiles**](https://pypi.org/project/aiofiles/) — development and
+  demonstration tooling;
+* [**diagnosticism**](https://pypi.org/project/diagnosticism/) — example
+  scripts under `examples/`;
+* [**pyclasp**](https://pypi.org/project/pyclasp/) — development and
+  demonstration tooling;
+* [**pytest**](https://pypi.org/project/pytest/) — unit-test runner;
+
+
+#### Afferent (fan-in)
+
+Projects that depend on **asynkio**:
+
+None (currently).
+
+
+### Related projects
+
+* [**Tokio**](https://github.com/tokio-rs/tokio) (**Rust**) — the library
+  whose time types **asynkio** emulates;
+* [**Diagnosticism.Python**](https://github.com/synesissoftware/Diagnosticism.Python/)
+  — used in `examples/` scripts;
+
+
+### License
+
+**asynkio** is released under the 3-clause BSD license. See [LICENSE](./LICENSE) for details.
+
+
+<!-- ########################### end of file ########################### -->
+

asynkio-0.0.3.dist-info/RECORD

@@ -0,0 +1,9 @@
+asynkio/__init__.py,sha256=vPNapu_A_-OlUNcCAdUsabjRAXBUbfto80e4n1THlwU,272
+asynkio/time/__init__.py,sha256=P64pof2xFF-nfnjMBVdPzdzsuweJexq-GzPjcvd-RGs,256
+asynkio/time/interval.py,sha256=uHq81-jgr_Sb1CnNnl-bs0Ukrurvcj8VIZqeTWEI_C4,6090
+asynkio/time/types.py,sha256=054tfvyIbrydNjQ4rzl19va1DbTfJR5BioqRFarsxGo,11177
+asynkio-0.0.3.dist-info/licenses/LICENSE,sha256=TWGuvCKcXKdUounnwoRzT57axIWWCEvUfZMYzsAcR7M,1566
+asynkio-0.0.3.dist-info/METADATA,sha256=lc1HIfgRBk7i7s1TE6f4LP7ZidxT3Ix4OQVr99ivzCY,5423
+asynkio-0.0.3.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+asynkio-0.0.3.dist-info/top_level.txt,sha256=MpyOQdFFxdfwkd7nu3LQGQzOzos1nLIzAqFIHsI1pgs,8
+asynkio-0.0.3.dist-info/RECORD,,

asynkio-0.0.3.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

asynkio-0.0.3.dist-info/licenses/LICENSE

@@ -0,0 +1,33 @@
+asynkio - BSD 3-Clause License
+
+Copyright (c) 2025, Matthew Wilson and Synesis Information Systems
+
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+1. Redistributions of source code must retain the above copyright notice,
+   this list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGE.
+

asynkio-0.0.3.dist-info/top_level.txt

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