whatamithinking-idlib 1.0.0__py3-none-any.whl

whatamithinking/idlib/__init__.py

@@ -0,0 +1,491 @@
+__version__ = "1.0.0"
+
+import base64
+from functools import total_ordering
+from typing import Any, Optional, TypeVar, Union
+import secrets
+import time
+import datetime
+from contextvars import ContextVar
+import re
+
+from whatamithinking.hostutil import (
+    normalize,
+    is_valid_hostname,
+    get_hostname,
+)
+
+
+T_UOID = TypeVar("T_UOID", bound="UOID")
+T_UOHID = TypeVar("T_UOHID", bound="UOHID")
+T_UOPHID = TypeVar("T_UOPHID", bound="UOPHID")
+
+
+@total_ordering
+class UOID:
+    """Unique ordered ID: time-random_bytes
+
+    Length = 16 bytes (32 chars)
+
+    This unique id format was designed to be sequential, so that all
+    subsequent ID's generated will be greater than the previous ones
+    in lexicographic order.
+
+    Not threadsafe.
+    """
+
+    __slots__ = "_bytes", "_str", "_hash", "__weakref__"
+    _last_id: Optional[bytes] = None
+    _last_time_ns: Optional[int] = None
+    _last_rand_bytes: Optional[bytearray] = None
+    _time_byte_length = 10
+    _rand_byte_length = 6
+    _MIN_BYTE_LENGTH = _time_byte_length + _rand_byte_length
+    _MAX_BYTE_LENGTH = _time_byte_length + _rand_byte_length
+
+    def __init__(
+        self,
+        value: Union[None, bytes, bytearray, str, T_UOID] = None,
+        timeout: float = 0.030,
+        **kwargs,
+    ) -> None:
+        """Init
+
+        Args:
+            value: Optional. id bytes or encoded string or instance of this object.
+                If None, generates a new id. Defaults to None.
+            timeout: Optional. Max number of seconds to spend trying go create a new
+                id before timing out. Defaults to 0.030 seconds.
+        """
+        self._bytes = value
+        if self._bytes is None:
+            self._bytes = self.new(timeout=timeout, **kwargs)
+        elif isinstance(value, str):
+            self._bytes = self._decode(value)
+        elif isinstance(value, type(self)):
+            self._bytes = bytes(value)
+        if len(self._bytes) > self._MAX_BYTE_LENGTH:
+            raise ValueError(
+                f"{type(self).__name__} bytes length, {len(self._bytes)}, "
+                + f"exceeded max, {self._MAX_BYTE_LENGTH}."
+            )
+        if len(self._bytes) < self._MIN_BYTE_LENGTH:
+            raise ValueError(
+                f"{type(self).__name__} bytes length, {len(self._bytes)}, "
+                + f"exceeded min, {self._MIN_BYTE_LENGTH}."
+            )
+        self._str: Optional[str] = None
+        self._hash: Optional[int] = None
+        # test we can parse all fields
+        self.time
+        self.rand
+
+    def _encode(self, value: bytes) -> str:
+        return base64.b32hexencode(value).decode("ascii")
+
+    def _decode(self, value: bytes | str) -> bytes:
+        return base64.b32hexdecode(value)
+
+    @classmethod
+    def new(cls, timeout: float = 0.030) -> bytes:
+        """Generate and return the bytes for a new id.
+
+        Args:
+            timeout: Optional. Max number of seconds to take to generate
+                a new id. This is only required in edge cases where there
+                is clock drift and the clock went backwards from the last
+                id generated in which case this function will sleep for
+                a short duration and then try again.
+        """
+        deadline = time.monotonic() + timeout
+        while True:
+            time_ns = time.time_ns()
+            if cls._last_time_ns is None or time_ns > cls._last_time_ns:
+                rand_bytes = secrets.token_bytes(cls._rand_byte_length)
+            else:
+                # auto-increment the random bytes if inside same timestamp
+                # so ids are still sequential even when generation happening
+                # faster than clock changing
+                rand_int = int.from_bytes(cls._last_rand_bytes, "big") + 1
+                if (
+                    rand_int.bit_length()
+                    > cls._rand_byte_length * cls._time_byte_length
+                ):
+                    raise RuntimeError(
+                        "Random bytes overflow from too many "
+                        + "ids being generated for the same timestamp."
+                    )
+                rand_bytes = rand_int.to_bytes(cls._rand_byte_length, "big")
+            cls._last_time_ns = time_ns
+            cls._last_rand_bytes = rand_bytes
+            time_ns_bytes = time_ns.to_bytes(cls._time_byte_length, "big")
+            id_bytes = b"".join([time_ns_bytes, rand_bytes])
+            if cls._last_id is not None and id_bytes < cls._last_id:
+                if time.monotonic() > deadline:
+                    raise RuntimeError(
+                        "Clock drift prevented an incremental id from "
+                        "being generated within the timeout."
+                    )
+                time.sleep(0.000005)
+                continue
+            cls._last_id = id_bytes
+            return id_bytes
+
+    def __eq__(self, other: Any) -> bool:
+        if other is None:
+            return False
+        if isinstance(other, str):
+            return str(self) == str(other)
+        return bytes(self) == bytes(other)
+
+    def __lt__(self, other: Any) -> bool:
+        if other is None:
+            return False
+        if isinstance(other, str):
+            return str(self) < str(other)
+        return bytes(self) < bytes(other)
+
+    @property
+    def time(self) -> int:
+        """Return nanosecond epoch time encoded in the id."""
+        return int.from_bytes(self._bytes[0 : self._time_byte_length], "big")
+
+    @property
+    def rand(self) -> bytes:
+        """Return the random bytes part of id."""
+        return self._bytes[
+            self._time_byte_length : self._time_byte_length + self._rand_byte_length
+        ]
+
+    def __repr__(self) -> str:
+        dec_time = datetime.datetime.fromtimestamp(self.time / 1_000_000_000).strftime(
+            "%Y-%m-%d %H:%M:%S"
+        )
+        return f"<{type(self).__name__} time={dec_time}.{self.time%1_000_000_000} rand={self._encode(self.rand)}>"
+
+    def __str__(self) -> str:
+        """32-character b16 encoded version of the resource id,
+        which maintains the same sort order as the bytes."""
+        if self._str is None:
+            self._str = self._encode(self._bytes)
+        return self._str
+
+    def __bytes__(self) -> bytes:
+        return self._bytes
+
+    def __hash__(self) -> int:
+        """Return the hash of the string of this id."""
+        if self._hash is None:
+            self._hash = hash(str(self))
+        return self._hash
+
+    def replace(
+        self, time: Optional[int] = None, rand: Optional[bytearray] = None
+    ) -> T_UOID:
+        """Replace parts of the UOID and return a new instance with those
+        replaced parts.
+
+        Args:
+            time: Optional. nanoseconds since epoch integer.
+            rand: Optional. random bytes.
+
+        Returns:
+            A new instance of this class
+        """
+        parts = []
+        if time is None:
+            parts.append(self._bytes[: self._time_byte_length])
+        else:
+            parts.append(time.to_bytes(self._time_byte_length, "big"))
+        if rand is None:
+            parts.append(
+                self._bytes[
+                    self._time_byte_length : self._time_byte_length
+                    + self._rand_byte_length
+                ]
+            )
+        else:
+            parts.append(rand)
+        return type(self)(b"".join(parts))
+
+
+_encoded_localhost = get_hostname().encode("ascii")
+
+
+class UOHID(UOID):
+    """Unique ordered host ID: time-random_bytes-hostname
+
+    Min Length (10 (time) + 6 (random) + 1 (hostname)) = 17 bytes (32 chars)
+    Max Length (10 (time) + 6 (random) + 64 (hostname)) = 80 bytes (128 chars)
+
+    This unique id format was designed to be sequential, so that all
+    subsequent ID's generated will be greater than the previous ones
+    in lexicographic order.
+
+    Additionally, this encodes the hostname of the machine it was generated
+    on. This was done on purpose to simplify sharing resources across services
+    by allowing one service to proxy to another using the hostname encoded
+    in the resource id. When converted to a string, the ID is base32hex encoded
+    to avoid leaking this implementation detail to clients. base32hex maintains
+    the sort order of the data it encodes.
+
+    WARNING: This ID should not be used in cases where security is important,
+    because it leaks the hostnames of the machines hosting the services.
+
+    Not threadsafe.
+    """
+
+    __slots__ = []
+    _min_hostname_byte_length = 1  # based on limits from linux and windows machines
+    _max_hostname_byte_length = 64  # based on limits from linux and windows machines
+    _MIN_BYTE_LENGTH = (
+        UOID._time_byte_length + UOID._rand_byte_length + _min_hostname_byte_length
+    )
+    _MAX_BYTE_LENGTH = (
+        UOID._time_byte_length + UOID._rand_byte_length + _max_hostname_byte_length
+    )
+
+    def __init__(
+        self, value: Union[None, bytes, bytearray, str, T_UOHID] = None, **kwargs
+    ) -> None:
+        """Init
+
+        Args:
+            value: id bytes or encoded string or instance of this object
+            timeout: Optional. Max number of seconds to spend trying go create a new
+                id before timing out. Defaults to 0.030 seconds.
+        """
+        super().__init__(value, **kwargs)
+        if not is_valid_hostname(self.hostname):
+            raise ValueError(f"Invalid hostname format given.")
+
+    def __repr__(self) -> str:
+        dec_time = datetime.datetime.fromtimestamp(self.time / 1_000_000_000).strftime(
+            "%Y-%m-%d %H:%M:%S"
+        )
+        return (
+            f"<{type(self).__name__} time={dec_time}.{self.time%1_000_000_000} rand={self._encode(self.rand)} "
+            f"hostname={self.hostname}>"
+        )
+
+    @classmethod
+    def new(cls, timeout: float = 0.030) -> bytes:
+        """Generate and return the bytes for a new id
+
+        Args:
+            timeout: Optional. Max number of seconds to take to generate
+                a new id. This is only required in edge cases where there
+                is clock drift and the clock went backwards from the last
+                id generated in which case this function will sleep for
+                a short duration and then try again.
+        """
+        global _encoded_localhost
+
+        id_bytes = b"".join(
+            [
+                UOID.new(timeout=timeout),
+                _encoded_localhost,
+            ]
+        )
+        return id_bytes
+
+    def __str__(self) -> str:
+        """32 to 128 character b32hex encoded version of the id,
+        which maintains the same sort order as the bytes."""
+        return super().__str__()
+
+    @property
+    def hostname(self) -> str:
+        """The hostname of a node, usually the computer where the id was generated."""
+        return self._bytes[self._time_byte_length + self._rand_byte_length :].decode(
+            "ascii"
+        )
+
+    def replace(
+        self,
+        time: Optional[int] = None,
+        rand: Optional[bytearray] = None,
+        hostname: Optional[str] = None,
+    ) -> T_UOHID:
+        """Replace parts of the UOHID and return a new instance with those
+        replaced parts.
+
+        Args:
+            time: Optional. nanoseconds since epoch integer.
+            rand: Optional. random bytes.
+            hostname: Optional. Hostname of a computer.
+
+        Returns:
+            UOHID
+        """
+        parts = []
+        if time is None:
+            parts.append(self._bytes[: self._time_byte_length])
+        else:
+            parts.append(time.to_bytes(self._time_byte_length, "big"))
+        if rand is None:
+            parts.append(
+                self._bytes[
+                    self._time_byte_length : self._time_byte_length
+                    + self._rand_byte_length
+                ]
+            )
+        else:
+            parts.append(rand)
+        if hostname is None:
+            parts.append(self._bytes[self._time_byte_length + self._rand_byte_length :])
+        else:
+            parts.append(normalize(hostname).encode("ascii"))
+        return type(self)(b"".join(parts))
+
+
+class UOPHID(UOHID):
+    """Unique ordered port-host ID: time-random_bytes-port-hostname
+
+    Min Length (10 (time) + 6 (random) + 2 (port) + 1 (hostname)) = 19 bytes (32 chars)
+    Max Length (10 (time) + 6 (random) + 2 (port) + 64 (hostname)) = 82 bytes (136 chars)
+
+    Similar to UOHID, but it encodes the port number of the service the resource
+    is hosted on allowing for proxying services to work based on the info encoded in the
+    resource id.
+    """
+
+    __slots__ = []
+    _port_byte_length = 2
+    _MIN_BYTE_LENGTH = (
+        UOID._time_byte_length
+        + UOID._rand_byte_length
+        + _port_byte_length
+        + UOHID._min_hostname_byte_length
+    )
+    _MAX_BYTE_LENGTH = (
+        UOID._time_byte_length
+        + UOID._rand_byte_length
+        + _port_byte_length
+        + UOHID._max_hostname_byte_length
+    )
+
+    def __init__(
+        self,
+        value: Union[None, bytes, bytearray, str, T_UOHID] = None,
+        *,
+        port: int | None = None,
+        **kwargs,
+    ) -> None:
+        """Init
+
+        Args:
+            value: id bytes or encoded string or instance of this object
+            timeout: Optional. Max number of seconds to spend trying go create a new
+                id before timing out. Defaults to 0.030 seconds.
+            port: Optional if value not given. Port number the service is hosted on
+                for where this resource exists.
+        """
+        super().__init__(value, port=port, **kwargs)
+        if self.port < 0 or self.port > 65535:
+            raise ValueError(
+                "The port is outside the acceptable range between 0 and 65535."
+            )
+
+    def __repr__(self) -> str:
+        dec_time = datetime.datetime.fromtimestamp(self.time / 1_000_000_000).strftime(
+            "%Y-%m-%d %H:%M:%S"
+        )
+        return (
+            f"<{type(self).__name__} time={dec_time}.{self.time%1_000_000_000} rand={self._encode(self.rand)} "
+            f"port={self.port} hostname={self.hostname}>"
+        )
+
+    @classmethod
+    def new(cls, port: int, timeout: float = 0.030) -> bytes:
+        """Generate a bytes for a UOHID object, filling in the port based on
+        current_service_info and the hostname from that of the local machine.
+
+        Args:
+            port: Port number of the service this resource exists on.
+            timeout: Optional. Max number of seconds to take to generate
+                a new id. This is only required in edge cases where there
+                is clock drift and the clock went backwards from the last
+                id generated in which case this function will sleep for
+                a short duration and then try again.
+        """
+        global _encoded_localhost
+
+        id_bytes = b"".join(
+            [
+                UOID.new(timeout=timeout),
+                port.to_bytes(2, "big", signed=False),
+                _encoded_localhost,
+            ]
+        )
+        return id_bytes
+
+    def __str__(self) -> str:
+        """32 to 136 character b32hex encoded version of the id,
+        which maintains the same sort order as the bytes."""
+        return super().__str__()
+
+    @property
+    def port(self) -> int:
+        """The port a service is running on for a node."""
+        i = self._time_byte_length + self._rand_byte_length
+        return int.from_bytes(
+            self._bytes[i : i + self._port_byte_length], "big", signed=False
+        )
+
+    @property
+    def hostname(self) -> str:
+        """The hostname of a node, usually the computer where the id was generated."""
+        return self._bytes[
+            self._time_byte_length + self._rand_byte_length + self._port_byte_length :
+        ].decode("ascii")
+
+    def replace(
+        self,
+        time: Optional[int] = None,
+        rand: Optional[bytearray] = None,
+        hostname: Optional[str] = None,
+        port: Optional[int] = None,
+    ) -> T_UOHID:
+        """Replace parts of the UOHID and return a new instance with those
+        replaced parts.
+
+        Args:
+            time: Optional. nanoseconds since epoch integer.
+            rand: Optional. random bytes.
+            hostname: Optional. Hostname of a computer.
+            port: Optional. Port a service is running on.
+
+        Returns:
+            UOHID
+        """
+        parts = []
+        if time is None:
+            parts.append(self._bytes[: self._time_byte_length])
+        else:
+            parts.append(time.to_bytes(self._time_byte_length, "big"))
+        if rand is None:
+            parts.append(
+                self._bytes[
+                    self._time_byte_length : self._time_byte_length
+                    + self._rand_byte_length
+                ]
+            )
+        else:
+            parts.append(rand)
+        if port is None:
+            i = self._time_byte_length + self._rand_byte_length
+            parts.append(self._bytes[i : i + self._port_byte_length])
+        else:
+            parts.append(port.to_bytes(2, "big", signed=False))
+        if hostname is None:
+            parts.append(
+                self._bytes[
+                    self._time_byte_length
+                    + self._rand_byte_length
+                    + self._port_byte_length :
+                ]
+            )
+        else:
+            parts.append(normalize(hostname).encode("ascii"))
+        return type(self)(b"".join(parts))

whatamithinking_idlib-1.0.0.dist-info/METADATA

@@ -0,0 +1,182 @@
+Metadata-Version: 2.4
+Name: whatamithinking-idlib
+Version: 1.0.0
+Summary: Generate unique IDs to identify resources in apps
+Author-email: Connor Sherwood Maynes <connormaynes@gmail.com>
+License: MIT License
+        
+        Copyright (c) 2026 whatamithinking
+        
+        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.
+        
+Project-URL: Homepage, https://github.com/whatamithinking/idlib
+Project-URL: Source, https://github.com/whatamithinking/idlib
+Keywords: id,unique-id,uuid,resource-id
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: whatamithinking-hostutil
+Provides-Extra: dev
+Requires-Dist: black; extra == "dev"
+Dynamic: license-file
+
+# idlib
+
+Time-ordered unique IDs for identifying resources in applications.
+
+`idlib` generates unique IDs that are **sequential**: every ID generated will be lexicographically greater than all previously generated IDs. This makes them ideal as primary keys in databases, since they naturally sort in insertion order without a secondary timestamp column.
+
+IDs are encoded with [base32hex](https://www.rfc-editor.org/rfc/rfc4648#section-7), which preserves the sort order of the underlying bytes while remaining safe to use in URLs and filenames.
+
+## Installation
+
+```
+pip install whatamithinking-idlib
+```
+
+## ID Types
+
+### `UOID` — Unique Ordered ID
+
+**Structure:** `time (10 bytes) + random (6 bytes)` → 16 bytes → **32-character string**
+
+The base type. Encodes a nanosecond-precision timestamp and random bytes.
+
+```python
+from whatamithinking.idlib import UOID
+
+id1 = UOID()
+id2 = UOID()
+
+print(str(id1))   # e.g. "0O0000CGFS0000ABCDEFGH123456"
+print(str(id2))   # always lexicographically greater than id1
+
+assert id1 < id2  # guaranteed ordering
+```
+
+**Properties:**
+
+| Property | Description |
+|----------|-------------|
+| `.time`  | Nanosecond epoch timestamp encoded in the ID (`int`) |
+| `.rand`  | Random bytes component (`bytes`) |
+
+**Reconstruction from string or bytes:**
+
+```python
+id_str = str(id1)
+restored = UOID(id_str)   # from string
+restored = UOID(bytes(id1))  # from bytes
+```
+
+---
+
+### `UOHID` — Unique Ordered Host ID
+
+**Structure:** `time (10 bytes) + random (6 bytes) + hostname (1–64 bytes)` → 17–80 bytes → **32–128-character string**
+
+Extends `UOID` by encoding the hostname of the machine that generated the ID. Useful for systems where resources need to be routed back to the originating service by hostname.
+
+> **Warning:** This ID leaks the hostname of the generating machine. Do not use it when that information is sensitive.
+
+```python
+from whatamithinking.idlib import UOHID
+
+id1 = UOHID()
+
+print(str(id1))       # base32hex-encoded string
+print(id1.hostname)   # e.g. "my-server"
+```
+
+**Properties:**
+
+| Property    | Description |
+|-------------|-------------|
+| `.time`     | Nanosecond epoch timestamp (`int`) |
+| `.rand`     | Random bytes component (`bytes`) |
+| `.hostname` | Hostname of the generating machine (`str`) |
+
+---
+
+### `UOPHID` — Unique Ordered Port-Host ID
+
+**Structure:** `time (10 bytes) + random (6 bytes) + port (2 bytes) + hostname (1–64 bytes)` → 19–82 bytes → **32–136-character string**
+
+Extends `UOHID` by also encoding the port number of the service that created the ID. Useful for systems where resources need to be routed to a specific port on the originating host.
+
+```python
+from whatamithinking.idlib import UOPHID
+
+id1 = UOPHID(port=9100)
+
+print(str(id1))       # base32hex-encoded string
+print(id1.port)       # 9100
+print(id1.hostname)   # e.g. "my-server"
+```
+
+**Properties:**
+
+| Property    | Description |
+|-------------|-------------|
+| `.time`     | Nanosecond epoch timestamp (`int`) |
+| `.rand`     | Random bytes component (`bytes`) |
+| `.port`     | Service port number (`int`, 0–65535) |
+| `.hostname` | Hostname of the generating machine (`str`) |
+
+---
+
+## Common API
+
+All three types share this interface:
+
+```python
+# Create new
+id1 = UOID()
+
+# Restore from string
+id2 = UOID("0O0000CGFS0000ABCDEFGH123456")
+
+# Restore from bytes
+id3 = UOID(bytes(id1))
+
+# String representation (base32hex, sortable)
+s = str(id1)
+
+# Raw bytes
+b = bytes(id1)
+
+# Comparison (all ordering operators supported)
+assert id1 < id2
+assert id1 == id1
+
+# Replace individual fields and get a new instance
+new_id = id1.replace(rand=b"\x00" * 6)
+```
+
+## Ordering Guarantees
+
+IDs are guaranteed to be strictly increasing as long as they are generated on the same thread. If multiple IDs are generated within the same nanosecond, the random component is auto-incremented to maintain order. If clock drift is detected (clock moved backwards), generation will retry for up to `timeout` seconds (default: 30 ms) before raising a `RuntimeError`.
+
+## License
+
+MIT

whatamithinking_idlib-1.0.0.dist-info/RECORD

@@ -0,0 +1,6 @@
+whatamithinking/idlib/__init__.py,sha256=ZvPJhtly3TNWGQPwxBnOfj8eUfGcYM_p51LGfSeDyuM,17880
+whatamithinking_idlib-1.0.0.dist-info/licenses/LICENSE,sha256=s5f4BFsESm1KgGwAQEsNTR4lLEH14kj7-j5SnAkJzn4,1093
+whatamithinking_idlib-1.0.0.dist-info/METADATA,sha256=eG2pmAFjnUsZcS0xnSJi0uwXkbyMFx1SNjaGiVwtL-8,6235
+whatamithinking_idlib-1.0.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+whatamithinking_idlib-1.0.0.dist-info/top_level.txt,sha256=ziC0QeEOyPmt6QrFH6vunXPacrmYzVVGH09o9lxRNbI,21
+whatamithinking_idlib-1.0.0.dist-info/RECORD,,

whatamithinking_idlib-1.0.0.dist-info/WHEEL

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

whatamithinking_idlib-1.0.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 whatamithinking
+
+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.

whatamithinking_idlib-1.0.0.dist-info/top_level.txt

@@ -0,0 +1,2 @@
+dist
+whatamithinking