reyk 0.0.1__py3-none-any.whl

reyk/caller_finder.py

@@ -0,0 +1,52 @@
+import logging
+import sys
+from collections.abc import Iterator
+from dataclasses import dataclass
+from pathlib import Path
+
+from reyk.stdlib_finder import is_part_of_stdlib
+
+LOGGER = logging.getLogger(__name__)
+MY_PACKAGE_NAME = __package__
+
+
+class NoCallerOutsideLibFoundError(RuntimeError): ...
+
+
+@dataclass
+class StackFrame:
+    filename: Path
+    module_name: str
+
+
+def get_caller_frame_outside_reyk() -> StackFrame:
+    for frame in _iterate_over_stack():
+        if is_part_of_stdlib(frame.module_name):
+            continue
+
+        if frame.module_name == MY_PACKAGE_NAME or frame.module_name.startswith(f"{MY_PACKAGE_NAME}."):
+            # This function
+            continue
+
+        return frame
+
+    raise NoCallerOutsideLibFoundError("Failed to find caller outside builtin")
+
+
+def _iterate_over_stack() -> Iterator[StackFrame]:
+    current_frame = sys._getframe(1)  # noqa: SLF001
+    while current_frame is not None:
+        yield StackFrame(
+            filename=Path(current_frame.f_code.co_filename),
+            module_name=current_frame.f_globals["__name__"],
+        )
+        current_frame = current_frame.f_back
+
+
+def is_caller_part_of_library(library_name: str) -> bool:
+    try:
+        caller_frame = get_caller_frame_outside_reyk()
+    except NoCallerOutsideLibFoundError:
+        return False
+    caller_module_name = caller_frame.module_name
+    return (caller_module_name == library_name) or (caller_module_name.startswith(f"{library_name}."))

reyk/isolator.py

@@ -0,0 +1,46 @@
+import builtins
+import importlib
+import logging
+from pathlib import Path
+from typing import Optional, cast
+
+from reyk.caller_finder import get_caller_frame_outside_reyk
+from reyk.vendor_importer import BuiltinsImporter, VendorImporter
+
+LOGGER = logging.getLogger(__name__)
+
+
+def isolate_package(package_path: Optional[Path] = None, vendorized_libs_directory_import_path: str = "libs") -> None:
+    vendor_importer = create_vendor_importer(package_path, vendorized_libs_directory_import_path)
+    LOGGER.debug(f"Isolating library: {vendor_importer.package_name} ({vendorized_libs_directory_import_path=})")
+    vendor_importer.install()
+
+
+def create_vendor_importer(
+    package_path: Optional[Path] = None,
+    vendorized_libs_directory_import_path: str = "libs",
+) -> VendorImporter:
+    """
+    Isolates a package dependencies - everything imported from the specified package_path
+    will prefer to import libraries inside the specified vendorized_libs_directory_import_path
+    instead of the default PYTHONPATH/site-packages.
+    The package_path can be unspecified/None to default to the caller's parent package.
+    vendorized_libs_directory_import_path should be the path to import the dependencies
+    from the package.
+    For example if the dependencies are in 'libs' it should be 'libs' as well as we need to perform:
+    `import libs` but if it's a subdirectory like 'my/libs' it should be 'my.libs' for
+    `import my.libs`.
+    """
+    if package_path is None:
+        package_path = get_caller_frame_outside_reyk().filename.parent
+
+    package_name = package_path.name
+    vendorized_libs_path = package_path / vendorized_libs_directory_import_path
+    return VendorImporter(
+        package_name,
+        vendorized_libs_directory_import_path,
+        vendorized_libs_path,
+        # Cast as for some reason the definition of __import__ thinks fromlist is not nullable
+        cast(BuiltinsImporter, builtins.__import__),
+        importlib.import_module,
+    )

reyk/stdlib_finder.py

@@ -0,0 +1,28 @@
+import os
+import sys
+from pathlib import Path
+from functools import cache
+from collections.abc import Iterator
+
+
+@cache
+def list_stdlib_modules() -> list[str]:
+    return list(_list_stdlib_modules_iter())
+
+
+def _list_stdlib_modules_iter() -> Iterator[str]:
+    standard_lib_dir = Path(os.__file__).parent
+    for std_lib_file in standard_lib_dir.iterdir():
+        if _is_package(std_lib_file) or (std_lib_file.suffix == ".py"):
+            yield std_lib_file.stem
+
+    yield from sys.builtin_module_names
+
+
+def _is_package(path: Path) -> bool:
+    return path.is_dir() and (path / "__init__.py").exists()
+
+
+def is_part_of_stdlib(module_name: str) -> bool:
+    library_name, _, _ = module_name.partition(".")
+    return library_name in list_stdlib_modules()

reyk/vendor_importer.py

@@ -0,0 +1,292 @@
+import builtins
+import functools
+import importlib
+import importlib.metadata
+import logging
+import sys
+from collections.abc import Iterable, Mapping, Sequence
+from importlib.metadata import Distribution, DistributionFinder, MetadataPathFinder
+from pathlib import Path
+from types import ModuleType
+from typing import Optional, Protocol
+
+from reyk.caller_finder import is_caller_part_of_library
+from reyk.stdlib_finder import is_part_of_stdlib
+from reyk.vendored_sys_modules import VendoredSysModules
+
+LOGGER = logging.getLogger(__name__)
+
+RELATIVE_IMPORT_PREFIX = "."
+
+
+class BuiltinsImporter(Protocol):
+    def __call__(
+        self,
+        name: str,
+        globals: Optional[Mapping[str, object]] = None,
+        locals: Optional[Mapping[str, object]] = None,
+        fromlist: Optional[Sequence[str]] = (),
+        level: int = 0,
+    ) -> ModuleType: ...
+
+
+class ImportLibImporter(Protocol):
+    def __call__(
+        self,
+        name: str,
+        package: Optional[str] = None,
+    ) -> ModuleType: ...
+
+
+class VendorImporter(DistributionFinder):
+    def __init__(
+        self,
+        package_name: str,
+        vendorized_libs_relative_import_path: str,
+        vendorized_libs_path: Path,
+        original_builtins_import_method: BuiltinsImporter,
+        original_importlib_import_method: ImportLibImporter,
+    ) -> None:
+        self.package_name = package_name
+        self.vendorized_libs_relative_import_path = vendorized_libs_relative_import_path
+        self.vendorized_libs_path = vendorized_libs_path
+        self._original_builtins_import_method = original_builtins_import_method
+        self._original_importlib_import_method = original_importlib_import_method
+        self._sys_modules_wrapper = VendoredSysModules(sys.modules, self.package_name, self.vendor_prefix)
+
+    def builtins_import_override(
+        self,
+        name: str,
+        globals: Optional[Mapping[str, object]] = None,
+        locals: Optional[Mapping[str, object]] = None,
+        fromlist: Optional[Sequence[str]] = (),
+        level: int = 0,
+    ) -> ModuleType:
+        # Note: ALL import calls should be in this function as to not increase the call stack significantly
+        if not self._should_import_vendorized(name):
+            # If importing a module which shouldn't be vendorized
+            # we need to exit the context to ensure we don't retrieve
+            # a vendorized module
+            self._sys_modules_wrapper.remove_vendored_sys_modules()
+            return self._original_builtins_import_method(name, globals, locals, fromlist, level)
+
+        vendorized_import_path = self._vendor_import(name)
+        self._sys_modules_wrapper.install_vendored_sys_modules()
+        imported_vendorized: bool
+        try:
+            LOGGER.debug(f"Importing: {vendorized_import_path}")
+            # Install vendorized modules to save us from importing the same module twice
+            # if it already exists in the sys.modules
+            module = self._original_builtins_import_method(vendorized_import_path, globals, locals, fromlist, level)
+            imported_vendorized = True
+        except ModuleNotFoundError as exc:
+            LOGGER.debug(f"Failed to import vendorized: {name}: {exc!s}")
+            self._sys_modules_wrapper.remove_vendored_sys_modules()
+            module = self._original_builtins_import_method(name, globals, locals, fromlist, level)
+            imported_vendorized = False
+
+        if imported_vendorized:
+            is_absolute_import = fromlist is None or len(fromlist) == 0
+            if is_absolute_import:
+                module = self._retrieve_absolute_import_module(name, module)
+                self._add_imported_sub_modules_to_vendorized(name, module)
+            else:
+                # Add the non-vendored name to sys modules as well (its in the vendored
+                # sys modules so this should go to `package_modules` only)
+                sys.modules[name] = module
+
+            # It's important at the end to return to vendorized sys module if we imported
+            # a vendorized package in case an import was made inside this import which changed the state
+            self._sys_modules_wrapper.install_vendored_sys_modules()
+
+        LOGGER.debug(f"Imported: {module}")
+        return module
+
+    def importlib_import_override(
+        self,
+        name: str,
+        package: Optional[str] = None,
+    ) -> ModuleType:
+        # If package is not None it's a relative import
+        if not self._should_import_vendorized(name) or package is not None:
+            self._sys_modules_wrapper.remove_vendored_sys_modules()
+            return self._original_importlib_import_method(name, package)
+
+        vendorized_import_path = self._vendor_import(name)
+        try:
+            self._sys_modules_wrapper.install_vendored_sys_modules()
+            return self._original_importlib_import_method(vendorized_import_path, None)
+        except ModuleNotFoundError as exc:
+            self._sys_modules_wrapper.remove_vendored_sys_modules()
+            LOGGER.debug(f"Failed to import vendorized: {name}: {exc!s}")
+            return self._original_importlib_import_method(name, None)
+
+    def _retrieve_absolute_import_module(
+        self,
+        module_name: str,
+        module_with_vendor_prefix: ModuleType,
+    ) -> ModuleType:
+        module_without_vendor_prefix = self._try_retrieving_imported_module_by_getattr(
+            module_name=module_name,
+            returned_module=module_with_vendor_prefix,
+        )
+        if module_without_vendor_prefix is None:
+            self._sys_modules_wrapper.install_vendored_sys_modules()
+            module_without_vendor_prefix = self._retrieve_imported_module_from_sys_modules(
+                self._vendor_import(self._extract_returned_module_name(module_name))
+            )
+
+        return module_without_vendor_prefix
+
+    def _add_imported_sub_modules_to_vendorized(
+        self,
+        module_name: str,
+        returned_module: ModuleType,
+    ) -> None:
+        """
+        Adds the imported sub-packages of the returned module to the vendorized modules state.
+        For example if we perform a vendorized: `import example_library.module` then we
+        return `example_library` but in the sys modules there will only be:
+        1. `example_project.libs.example_library`
+        2. `example_project.libs.example_library.module`
+        Meanwhile this function will also add the following:
+        1. `example_library`
+        2. `example_library.module`
+        """
+        packages = module_name.split(".")
+        current_module = returned_module
+        for index, path_component in enumerate(packages):
+            if index > 0:
+                try:
+                    current_module = getattr(current_module, path_component)
+                except AttributeError:
+                    current_module = self._retrieve_imported_module_from_sys_modules(
+                        self._vendor_import(".".join(packages[: index + 1]))
+                    )
+            current_module_name = ".".join(packages[: index + 1])
+            sys.modules[current_module_name] = current_module
+
+    def _retrieve_imported_module_from_sys_modules(
+        self,
+        module_name: str,
+    ) -> ModuleType:
+        module = sys.modules.get(module_name)
+        if module is None:
+            raise ModuleNotFoundError(f"No module named: '{module_name}'")
+
+        return module
+
+    def _try_retrieving_imported_module_by_getattr(
+        self,
+        module_name: str,
+        returned_module: ModuleType,
+    ) -> Optional[ModuleType]:
+        """
+        If we perform the following from example_project:
+        `import example_library.library_module`
+        This will reroute us to:
+        `import example_project.libs.example_library.library_module`
+        therefore instead of accessing the variable by using `example_library.library_module.MY_STRING`
+        we have to use `example_project.libs.example_library.library_module`.
+        To avoid this we have to return the `example_library` module instead of the `example_project` module.
+
+        This may fail sometimes due to circular imports not able to retrieve the object yet.
+        Ie: If you are already inside `example_library.__init__` and importing `example_library.library_module`
+        it might fail because this will try to access an attribute of a partially-initialized module.
+        """
+        packages = self.vendor_prefix.split(".")[1:]
+        returned_module_name = self._extract_returned_module_name(module_name)
+        packages.append(returned_module_name)
+
+        return functools.reduce(
+            lambda module, package: getattr(module, package, None),
+            packages,
+            returned_module,
+        )
+
+    def _vendor_import(self, import_path: str) -> str:
+        return f"{self.vendor_prefix}.{import_path}"
+
+    def _extract_returned_module_name(self, module_name: str) -> str:
+        returned_module_attribute, _, _ = module_name.partition(".")
+        return returned_module_attribute
+
+    def _should_import_vendorized(
+        self,
+        name: str,
+    ) -> bool:
+        if name.startswith(RELATIVE_IMPORT_PREFIX):
+            LOGGER.debug("Relative imports don't require changing the import path for vendorized packages")
+            return False
+
+        if name.startswith(self.vendor_prefix):
+            LOGGER.debug(
+                "The attempted import is already for a vendorized package therefore there's "
+                "no need to change the import path"
+            )
+            return False
+
+        if name == self.package_name:
+            LOGGER.debug(f"Cannot re-import the library: {self.package_name}")
+            return False
+
+        if not is_caller_part_of_library(self.package_name):
+            LOGGER.debug("Cannot import because it's not part of library")
+            return False
+
+        if is_part_of_stdlib(name):
+            LOGGER.debug(f"Skipping vendor import attempt for {name} because the same name exists in stdlib")
+            return False
+
+        return True
+
+    def find_distributions(
+        self,
+        context: Optional[DistributionFinder.Context] = None,
+    ) -> Iterable[Distribution]:
+        if context is None:
+            context = DistributionFinder.Context()
+
+        LOGGER.debug(f"Finding distributions in VendorImporter for context: {context}")
+        if not is_caller_part_of_library(self.package_name):
+            LOGGER.debug("Returning empty list in find_distributions because not part of library")
+            return []
+
+        LOGGER.debug(f"Returning all distributions in vendorized path: {self.vendorized_libs_path}")
+        vars(context).update({"path": [str(self.vendorized_libs_path)]})
+        return MetadataPathFinder.find_distributions(context)
+
+    @property
+    def vendor_prefix(self) -> str:
+        return f"{self.package_name}.{self.vendorized_libs_relative_import_path}"
+
+    def install(self) -> None:
+        builtins.__import__ = self.builtins_import_override
+        importlib.import_module = self.importlib_import_override
+        # Distribution entrypoint loading uses the import_module in `importlib.metadata`
+        # and therefore needs to be overridden as well
+        importlib.metadata.import_module = self.importlib_import_override  # pyright: ignore[reportAttributeAccessIssue]
+
+        if self not in sys.meta_path:
+            # For distribution finder
+            sys.meta_path.append(self)
+
+        sys.modules = self._sys_modules_wrapper
+
+    def uninstall(self) -> None:
+        builtins.__import__ = self._original_builtins_import_method
+        importlib.import_module = self._original_importlib_import_method
+        importlib.metadata.import_module = self._original_importlib_import_method  # pyright: ignore[reportAttributeAccessIssue]
+
+        if self in sys.meta_path:
+            sys.meta_path.remove(self)
+
+        sys.modules = self._sys_modules_wrapper.original_sys_modules
+
+
+def get_installed_vendor_importer() -> Optional[VendorImporter]:
+    import_owner = getattr(builtins.__import__, "__self__", None)
+    if (import_owner is None) or (not isinstance(import_owner, VendorImporter)):
+        return None
+
+    return import_owner

reyk/vendored_sys_modules.py

@@ -0,0 +1,108 @@
+from collections import UserDict
+from collections.abc import MutableMapping
+from dataclasses import dataclass
+from types import ModuleType
+from reyk.caller_finder import is_caller_part_of_library
+from reyk.stdlib_finder import is_part_of_stdlib
+
+
+@dataclass
+class SysModulesSnapshot:
+    original_sys_modules: dict[str, ModuleType]
+    user_modules: dict[str, ModuleType]
+    package_modules: dict[str, ModuleType]
+
+
+class VendoredSysModules(UserDict[str, ModuleType]):
+    """
+    Wrapper for overriding python-direct access to return vendored modules based on
+    stack trace context. This will usually not effect the actual import mechanism as it access
+    the original `sys.modules`.
+
+    Therefore we are doing best-effort here:
+    1. If there's access from C/the original sys modules then we ensure to take the vendored module only if we're in
+       in a vendored context (in the middle of a vendored import), otherwise we'll use the
+       original user imported module/no module with the same name
+    2. If we access from Python to the sys modules wrapper then we'll never access the original
+       sys modules and therefore use the appropriate modules based on the vendor context (user module if outside vendor
+       and vendor module if inside vendor)
+    """
+
+    DICT_INTERNAL_DATA_FIELD_NAME = "data"
+
+    def __init__(self, original_sys_modules: dict[str, ModuleType], package_name: str, vendor_prefix: str) -> None:
+        self._package_name = package_name
+        self._vendor_prefix = vendor_prefix
+        self.original_sys_modules = original_sys_modules
+        self._package_modules: dict[str, ModuleType] = original_sys_modules.copy()
+        self._user_modules: dict[str, ModuleType] = original_sys_modules.copy()
+        self._are_vendored_modules_installed = False
+
+    def install_vendored_sys_modules(self) -> None:
+        if self._are_vendored_modules_installed:
+            return
+
+        self._switch_original_sys_modules_state(self._package_modules, self._user_modules)
+        self._are_vendored_modules_installed = True
+
+    def remove_vendored_sys_modules(self) -> None:
+        if not self._are_vendored_modules_installed:
+            return
+
+        self._switch_original_sys_modules_state(self._user_modules, self._package_modules)
+        self._are_vendored_modules_installed = False
+
+    def _switch_original_sys_modules_state(
+        self,
+        new_sys_modules: dict[str, ModuleType],
+        previous_sys_modules: dict[str, ModuleType],
+    ) -> None:
+        for module_name in previous_sys_modules.keys():
+            self.original_sys_modules.pop(module_name, None)
+
+        self.original_sys_modules.update(new_sys_modules)
+
+    def take_snapshot(self) -> SysModulesSnapshot:
+        return SysModulesSnapshot(
+            original_sys_modules=self.original_sys_modules.copy(),
+            user_modules=self._user_modules.copy(),
+            package_modules=self._package_modules.copy(),
+        )
+
+    def restore_snapshot(self, snapshot: SysModulesSnapshot) -> None:
+        for current_modules, snapshot_modules in (
+            (self.original_sys_modules, snapshot.original_sys_modules),
+            (self._user_modules, snapshot.user_modules),
+            (self._package_modules, snapshot.package_modules),
+        ):
+            current_modules.clear()
+            current_modules.update(snapshot_modules)
+
+    def __setitem__(self, key: str, value: ModuleType) -> None:
+        module_name = value.__name__
+        if is_part_of_stdlib(module_name) or module_name == self._package_name:
+            # Standard libraries should be registered as both package & user modules
+            self.original_sys_modules[key] = value
+            self._package_modules[key] = value
+            self._user_modules[key] = value
+            return
+
+        dicts_to_update: list[MutableMapping[str, ModuleType]] = [super()]
+        if is_caller_part_of_library(self._package_name) == self._are_vendored_modules_installed:
+            dicts_to_update.append(self.original_sys_modules)
+
+        # The setitem will be directed to package modules/user modules
+        for dict_to_update in dicts_to_update:
+            if key.startswith(self._vendor_prefix) and key != self._vendor_prefix:
+                dict_to_update.__setitem__(key.removeprefix(self._vendor_prefix).removeprefix("."), value)
+
+            dict_to_update.__setitem__(key, value)
+
+    def __getattribute__(self, name: str) -> object:
+        if name == VendoredSysModules.DICT_INTERNAL_DATA_FIELD_NAME:
+            if is_caller_part_of_library(self._package_name):
+                return self._package_modules
+
+            return self._user_modules
+
+        return super().__getattribute__(name)

reyk/version.py

@@ -0,0 +1 @@
+VERSION = "0.0.1"

reyk-0.0.1.dist-info/METADATA

@@ -0,0 +1,76 @@
+Metadata-Version: 2.4
+Name: reyk
+Version: 0.0.1
+Summary: Run conflicting Python dependencies in one process — with vendored isolation.
+Project-URL: Homepage, https://reyk.dev
+Project-URL: Source, https://github.com/eyalohn/reyk
+Author-email: Eyal Ohn <eyal.ohn@gmail.com>, Ofek Ashery <ofek.ashery@gmail.com>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: conflicting dependencies,dependency isolation,python import system,vendoring,virtual environment
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+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: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+
+# Reyk
+
+[![Tests](https://github.com/eyalohn/reyk/actions/workflows/test.yml/badge.svg)](https://github.com/eyalohn/reyk/actions/workflows/test.yml)
+[![Coverage](https://coverage-badge.samuelcolvin.workers.dev/eyalohn/reyk.svg)](https://coverage-badge.samuelcolvin.workers.dev/redirect/eyalohn/reyk)
+[![Latest Version](https://img.shields.io/pypi/v/reyk.svg)](https://pypi.python.org/pypi/reyk/)
+[![Python Versions](https://img.shields.io/pypi/pyversions/reyk.svg)](https://pypi.python.org/pypi/reyk/)
+[![llms.txt](https://img.shields.io/badge/llms.txt-green)](https://reyk.dev/llms-full.txt)
+
+Run conflicting Python dependencies in one process — with vendored isolation.
+
+[Reyk](https://reyk.dev) lets you **vendor Python dependencies into your project and isolate them by design**, without changing how you write imports. We leverage Python's import system internals to achieve transparent dependency isolation.
+
+## Features
+
+- **Zero Configuration**: Enable isolation with a single function call
+- **Dependency Isolation**: Avoid conflicts by shipping libraries with your package
+- **Version Flexibility**: Run multiple versions of the same library in one process
+- **Transparent Imports**: Keep your public imports unchanged (`import requests` still works)
+- **Lightweight**: Minimal overhead with a tiny import hook
+
+# Installation
+
+You can install Reyk from PyPI:
+
+```bash
+uv add reyk
+```
+
+Enable isolation from your package's `__init__.py`:
+
+```python
+from reyk.isolator import isolate_package
+
+isolate_package()
+```
+
+Then, vendor your dependencies with Reyk's CLI:
+
+```bash
+uvx reyk-cli add requests==2.25.1
+```
+
+**That's it!** Inside `your_package`, `import requests` resolves to `your_package.libs.requests`. Outside `your_package`, `import requests` continues to resolve to the global installation.
+
+## Documentation
+
+For detailed documentation, examples, and API reference, visit the documentation site at https://reyk.dev.
+
+## Limitations
+
+- Multi-threaded applications are not supported.

reyk-0.0.1.dist-info/RECORD

@@ -0,0 +1,11 @@
+reyk/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+reyk/caller_finder.py,sha256=yxf72ExThw4HsfGm3HUvINmdoxjP3jTiN0KZ3DOFN-A,1472
+reyk/isolator.py,sha256=U1jFAfNgfZmYx8IYCA3rvzL37mZGtTGqWG4eEV0Hmx8,1978
+reyk/stdlib_finder.py,sha256=_zTWjLi8CBfDKChKwwYi82eVZ5ns5gOjCe22e4iUSeg,758
+reyk/vendor_importer.py,sha256=TQL93n9yjNgwsFAyM7XK_37BWH7hJQr3fBn-7gihG5A,12215
+reyk/vendored_sys_modules.py,sha256=A5gUM1V8mLYK7XLxDXo07wi5hhSUwhztX4XgiCWJEZA,4710
+reyk/version.py,sha256=Q8raD6k02z4DoYniAz3iui5d6EdM1el95SMTLXJbeCA,18
+reyk-0.0.1.dist-info/METADATA,sha256=CnuCWSWmRpxIKlUMFs8Fmq8iSK_7ZbbsbJnBKOHCLNA,3134
+reyk-0.0.1.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+reyk-0.0.1.dist-info/licenses/LICENSE,sha256=jS6aMH0eoPNwDHyW2R8su67bEUx4D0FKGQsu6-JPtGM,1071
+reyk-0.0.1.dist-info/RECORD,,

reyk-0.0.1.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.29.0
+Root-Is-Purelib: true
+Tag: py3-none-any

reyk-0.0.1.dist-info/licenses/LICENSE

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