ipymini 0.1.0__tar.gz

ipymini-0.1.0/.github/workflows/release.yml

@@ -0,0 +1,22 @@
+name: Release
+on:
+  push:
+    tags: ["v*"]
+
+jobs:
+  pypi:
+    runs-on: ubuntu-latest
+    permissions:
+      id-token: write
+      contents: write
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+      - run: pip install hatch
+      - run: hatch build
+      - uses: pypa/gh-action-pypi-publish@release/v1
+      - run: gh release create ${{ github.ref_name }} --generate-notes
+        env:
+          GH_TOKEN: ${{ github.token }}

ipymini-0.1.0/.gitignore

@@ -0,0 +1,157 @@
+EVENTLOOP.md
+meta/
+REVIEW.md
+_docs
+DAP.md
+DEBUG.md
+SUBSHELL.md
+links/
+gateway.py
+style.md
+Untitled*.ipynb
+
+_proc/
+sidebar.yml
+Gemfile.lock
+token
+_docs/
+conda/
+.last_checked
+.gitconfig
+*.bak
+*.log
+*~
+~*
+_tmp*
+tmp*
+tags
+
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+env/
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+.hypothesis/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# pyenv
+.python-version
+
+# celery beat schedule file
+celerybeat-schedule
+
+# SageMath parsed files
+*.sage.py
+
+# dotenv
+.env
+
+# virtualenv
+.venv
+venv/
+ENV/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+
+.vscode
+*.swp
+
+# osx generated files
+.DS_Store
+.DS_Store?
+.Trashes
+ehthumbs.db
+Thumbs.db
+.idea
+
+# pytest
+.pytest_cache
+
+# tools/trust-doc-nbs
+docs_src/.last_checked
+
+# symlinks to fastai
+docs_src/fastai
+tools/fastai
+
+# link checker
+checklink/cookies.txt
+
+# .gitconfig is now autogenerated
+.gitconfig
+

ipymini-0.1.0/.uv-cache/.gitignore

@@ -0,0 +1 @@
+*

ipymini-0.1.0/.uv-cache/CACHEDIR.TAG

@@ -0,0 +1 @@
+Signature: 8a477f597d28d172789f06886806bc55

ipymini-0.1.0/.uv-cache/archive-v0/16ofwWrEnGGP3F17D6qGf/hatchling/__about__.py

@@ -0,0 +1 @@
+__version__ = "1.28.0"

ipymini-0.1.0/.uv-cache/archive-v0/16ofwWrEnGGP3F17D6qGf/hatchling/__main__.py

@@ -0,0 +1,6 @@
+import sys
+
+if __name__ == "__main__":
+    from hatchling.cli import hatchling
+
+    sys.exit(hatchling())

ipymini-0.1.0/.uv-cache/archive-v0/16ofwWrEnGGP3F17D6qGf/hatchling/bridge/app.py

@@ -0,0 +1,111 @@
+from __future__ import annotations
+
+import os
+import sys
+from typing import Any
+
+
+class Application:
+    """
+    The way output is displayed can be [configured](../config/hatch.md#terminal) by users.
+
+    !!! important
+        Never import this directly; Hatch judiciously decides if a type of plugin requires
+        the capabilities herein and will grant access via an attribute.
+    """
+
+    def __init__(self) -> None:
+        self.__verbosity = int(os.environ.get("HATCH_VERBOSE", "0")) - int(os.environ.get("HATCH_QUIET", "0"))
+
+    @property
+    def verbosity(self) -> int:
+        """
+        The verbosity level of the application, with 0 as the default.
+        """
+        return self.__verbosity
+
+    @staticmethod
+    def display(message: str = "", **kwargs: Any) -> None:  # noqa: ARG004
+        # Do not document
+        _display(message, always=True)
+
+    def display_info(self, message: str = "", **kwargs: Any) -> None:  # noqa: ARG002
+        """
+        Meant to be used for messages conveying basic information.
+        """
+        if self.__verbosity >= 0:
+            _display(message)
+
+    def display_waiting(self, message: str = "", **kwargs: Any) -> None:  # noqa: ARG002
+        """
+        Meant to be used for messages shown before potentially time consuming operations.
+        """
+        if self.__verbosity >= 0:
+            _display(message)
+
+    def display_success(self, message: str = "", **kwargs: Any) -> None:  # noqa: ARG002
+        """
+        Meant to be used for messages indicating some positive outcome.
+        """
+        if self.__verbosity >= 0:
+            _display(message)
+
+    def display_warning(self, message: str = "", **kwargs: Any) -> None:  # noqa: ARG002
+        """
+        Meant to be used for messages conveying important information.
+        """
+        if self.__verbosity >= -1:
+            _display(message)
+
+    def display_error(self, message: str = "", **kwargs: Any) -> None:  # noqa: ARG002
+        """
+        Meant to be used for messages indicating some unrecoverable error.
+        """
+        if self.__verbosity >= -2:  # noqa: PLR2004
+            _display(message)
+
+    def display_debug(self, message: str = "", level: int = 1, **kwargs: Any) -> None:  # noqa: ARG002
+        """
+        Meant to be used for messages that are not useful for most user experiences.
+        The `level` option must be between 1 and 3 (inclusive).
+        """
+        if not 1 <= level <= 3:  # noqa: PLR2004
+            error_message = "Debug output can only have verbosity levels between 1 and 3 (inclusive)"
+            raise ValueError(error_message)
+
+        if self.__verbosity >= level:
+            _display(message)
+
+    def display_mini_header(self, message: str = "", **kwargs: Any) -> None:  # noqa: ARG002
+        if self.__verbosity >= 0:
+            _display(f"[{message}]")
+
+    def abort(self, message: str = "", code: int = 1, **kwargs: Any) -> None:  # noqa: ARG002
+        """
+        Terminate the program with the given return code.
+        """
+        if message and self.__verbosity >= -2:  # noqa: PLR2004
+            _display(message)
+
+        sys.exit(code)
+
+    def get_safe_application(self) -> SafeApplication:
+        return SafeApplication(self)
+
+
+class SafeApplication:
+    def __init__(self, app: Application) -> None:
+        self.abort = app.abort
+        self.verbosity = app.verbosity
+        self.display = app.display
+        self.display_info = app.display_info
+        self.display_error = app.display_error
+        self.display_success = app.display_success
+        self.display_waiting = app.display_waiting
+        self.display_warning = app.display_warning
+        self.display_debug = app.display_debug
+        self.display_mini_header = app.display_mini_header
+
+
+def _display(message: str, *, always: bool = False) -> None:
+    print(message, file=None if always else sys.stderr)

ipymini-0.1.0/.uv-cache/archive-v0/16ofwWrEnGGP3F17D6qGf/hatchling/build.py

@@ -0,0 +1,144 @@
+from __future__ import annotations
+
+import os
+from typing import Any
+
+__all__ = [
+    "build_editable",
+    "build_sdist",
+    "build_wheel",
+    "get_requires_for_build_editable",
+    "get_requires_for_build_sdist",
+    "get_requires_for_build_wheel",
+]
+__all__ += ["__all__"]
+
+
+def get_requires_for_build_sdist(config_settings: dict[str, Any] | None = None) -> list[str]:  # noqa: ARG001
+    """
+    https://peps.python.org/pep-0517/#get-requires-for-build-sdist
+    """
+    from hatchling.builders.sdist import SdistBuilder
+
+    builder = SdistBuilder(os.getcwd())
+    return builder.config.dependencies
+
+
+def build_sdist(sdist_directory: str, config_settings: dict[str, Any] | None = None) -> str:  # noqa: ARG001
+    """
+    https://peps.python.org/pep-0517/#build-sdist
+    """
+    from hatchling.builders.sdist import SdistBuilder
+
+    builder = SdistBuilder(os.getcwd())
+    return os.path.basename(next(builder.build(directory=sdist_directory, versions=["standard"])))
+
+
+def get_requires_for_build_wheel(config_settings: dict[str, Any] | None = None) -> list[str]:  # noqa: ARG001
+    """
+    https://peps.python.org/pep-0517/#get-requires-for-build-wheel
+    """
+    from hatchling.builders.wheel import WheelBuilder
+
+    builder = WheelBuilder(os.getcwd())
+    return builder.config.dependencies
+
+
+def build_wheel(
+    wheel_directory: str,
+    config_settings: dict[str, Any] | None = None,  # noqa: ARG001
+    metadata_directory: str | None = None,  # noqa: ARG001
+) -> str:
+    """
+    https://peps.python.org/pep-0517/#build-wheel
+    """
+    from hatchling.builders.wheel import WheelBuilder
+
+    builder = WheelBuilder(os.getcwd())
+    return os.path.basename(next(builder.build(directory=wheel_directory, versions=["standard"])))
+
+
+def get_requires_for_build_editable(config_settings: dict[str, Any] | None = None) -> list[str]:  # noqa: ARG001
+    """
+    https://peps.python.org/pep-0660/#get-requires-for-build-editable
+    """
+    from hatchling.builders.constants import EDITABLES_REQUIREMENT
+    from hatchling.builders.wheel import WheelBuilder
+
+    builder = WheelBuilder(os.getcwd())
+    return [*builder.config.dependencies, EDITABLES_REQUIREMENT]
+
+
+def build_editable(
+    wheel_directory: str,
+    config_settings: dict[str, Any] | None = None,  # noqa: ARG001
+    metadata_directory: str | None = None,  # noqa: ARG001
+) -> str:
+    """
+    https://peps.python.org/pep-0660/#build-editable
+    """
+    from hatchling.builders.wheel import WheelBuilder
+
+    builder = WheelBuilder(os.getcwd())
+    return os.path.basename(next(builder.build(directory=wheel_directory, versions=["editable"])))
+
+
+# Any builder that has build-time hooks like Hatchling and setuptools cannot technically keep PEP 517's identical
+# metadata promise e.g. C extensions would require different tags in the `WHEEL` file. Therefore, we consider the
+# methods as mostly being for non-frontend tools like tox and dependency updaters. So Hatchling only writes the
+# `METADATA` file to the metadata directory and continues to ignore that directory itself.
+#
+# An issue we encounter by supporting this metadata-only access is that for installations with pip the required
+# dependencies of the project are read at this stage. This means that build hooks that add to the `dependencies`
+# build data or modify the built wheel have no effect on what dependencies are or are not installed.
+#
+# There are legitimate use cases in which this is required, so we only define these when no pip build is detected.
+# See: https://github.com/pypa/pip/blob/22.2.2/src/pip/_internal/operations/build/build_tracker.py#L41-L51
+# Example use case: https://github.com/pypa/hatch/issues/532
+if "PIP_BUILD_TRACKER" not in os.environ:
+    __all__ += ["prepare_metadata_for_build_editable", "prepare_metadata_for_build_wheel"]
+
+    def prepare_metadata_for_build_wheel(
+        metadata_directory: str,
+        config_settings: dict[str, Any] | None = None,  # noqa: ARG001
+    ) -> str:
+        """
+        https://peps.python.org/pep-0517/#prepare-metadata-for-build-wheel
+        """
+        from hatchling.builders.wheel import WheelBuilder
+
+        builder = WheelBuilder(os.getcwd())
+
+        directory = os.path.join(metadata_directory, f"{builder.artifact_project_id}.dist-info")
+        if not os.path.isdir(directory):
+            os.mkdir(directory)
+
+        with open(os.path.join(directory, "METADATA"), "w", encoding="utf-8") as f:
+            f.write(builder.config.core_metadata_constructor(builder.metadata))
+
+        return os.path.basename(directory)
+
+    def prepare_metadata_for_build_editable(
+        metadata_directory: str,
+        config_settings: dict[str, Any] | None = None,  # noqa: ARG001
+    ) -> str:
+        """
+        https://peps.python.org/pep-0660/#prepare-metadata-for-build-editable
+        """
+        from hatchling.builders.constants import EDITABLES_REQUIREMENT
+        from hatchling.builders.wheel import WheelBuilder
+
+        builder = WheelBuilder(os.getcwd())
+
+        directory = os.path.join(metadata_directory, f"{builder.artifact_project_id}.dist-info")
+        if not os.path.isdir(directory):
+            os.mkdir(directory)
+
+        extra_dependencies = []
+        if not builder.config.dev_mode_dirs and builder.config.dev_mode_exact:
+            extra_dependencies.append(EDITABLES_REQUIREMENT)
+
+        with open(os.path.join(directory, "METADATA"), "w", encoding="utf-8") as f:
+            f.write(builder.config.core_metadata_constructor(builder.metadata, extra_dependencies=extra_dependencies))
+
+        return os.path.basename(directory)

ipymini-0.1.0/.uv-cache/archive-v0/16ofwWrEnGGP3F17D6qGf/hatchling/builders/app.py

@@ -0,0 +1,20 @@
+from __future__ import annotations
+
+from typing import Any
+
+from hatchling.builders.binary import BinaryBuilder
+
+
+class AppBuilder(BinaryBuilder):
+    PLUGIN_NAME = "app"
+
+    def build_bootstrap(
+        self,
+        directory: str,
+        **build_data: Any,
+    ) -> str:
+        self.app.display_warning(
+            "The `app` build target is deprecated and will be removed in a future release. "
+            "Use the `binary` build target instead."
+        )
+        return super().build_bootstrap(directory, **build_data)

ipymini-0.1.0/.uv-cache/archive-v0/16ofwWrEnGGP3F17D6qGf/hatchling/builders/binary.py

@@ -0,0 +1,202 @@
+from __future__ import annotations
+
+import os
+import sys
+from typing import TYPE_CHECKING, Any
+
+from hatchling.builders.config import BuilderConfig
+from hatchling.builders.plugin.interface import BuilderInterface
+
+if TYPE_CHECKING:
+    from collections.abc import Callable
+
+
+class BinaryBuilderConfig(BuilderConfig):
+    SUPPORTED_VERSIONS = ("3.12", "3.11", "3.10", "3.9", "3.8", "3.7")
+
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
+        super().__init__(*args, **kwargs)
+
+        self.__scripts: list[str] | None = None
+        self.__python_version: str | None = None
+        self.__pyapp_version: str | None = None
+
+    @property
+    def scripts(self) -> list[str]:
+        if self.__scripts is None:
+            known_scripts = self.builder.metadata.core.scripts
+            scripts = self.target_config.get("scripts", [])
+
+            if not isinstance(scripts, list):
+                message = f"Field `tool.hatch.build.targets.{self.plugin_name}.scripts` must be an array"
+                raise TypeError(message)
+
+            for i, script in enumerate(scripts, 1):
+                if not isinstance(script, str):
+                    message = (
+                        f"Script #{i} of field `tool.hatch.build.targets.{self.plugin_name}.scripts` must be a string"
+                    )
+                    raise TypeError(message)
+
+                if script not in known_scripts:
+                    message = f"Unknown script in field `tool.hatch.build.targets.{self.plugin_name}.scripts`: {script}"
+                    raise ValueError(message)
+
+            self.__scripts = sorted(set(scripts)) if scripts else list(known_scripts)
+
+        return self.__scripts
+
+    @property
+    def python_version(self) -> str:
+        if self.__python_version is None:
+            python_version = self.target_config.get("python-version", "")
+
+            if not isinstance(python_version, str):
+                message = f"Field `tool.hatch.build.targets.{self.plugin_name}.python-version` must be a string"
+                raise TypeError(message)
+
+            if not python_version and "PYAPP_DISTRIBUTION_SOURCE" not in os.environ:
+                for supported_version in self.SUPPORTED_VERSIONS:
+                    if self.builder.metadata.core.python_constraint.contains(supported_version):
+                        python_version = supported_version
+                        break
+                else:
+                    message = "Field `project.requires-python` is incompatible with the known distributions"
+                    raise ValueError(message)
+
+            self.__python_version = python_version
+
+        return self.__python_version
+
+    @property
+    def pyapp_version(self) -> str:
+        if self.__pyapp_version is None:
+            pyapp_version = self.target_config.get("pyapp-version", "")
+
+            if not isinstance(pyapp_version, str):
+                message = f"Field `tool.hatch.build.targets.{self.plugin_name}.pyapp-version` must be a string"
+                raise TypeError(message)
+
+            self.__pyapp_version = pyapp_version
+
+        return self.__pyapp_version
+
+
+class BinaryBuilder(BuilderInterface):
+    """
+    Build binaries
+    """
+
+    PLUGIN_NAME = "binary"
+
+    def get_version_api(self) -> dict[str, Callable]:
+        return {"bootstrap": self.build_bootstrap}
+
+    def get_default_versions(self) -> list[str]:  # noqa: PLR6301
+        return ["bootstrap"]
+
+    def clean(
+        self,
+        directory: str,
+        versions: list[str],  # noqa: ARG002
+    ) -> None:
+        import shutil
+
+        app_dir = os.path.join(directory, self.PLUGIN_NAME)
+        if os.path.isdir(app_dir):
+            shutil.rmtree(app_dir)
+
+    def build_bootstrap(
+        self,
+        directory: str,
+        **build_data: Any,  # noqa: ARG002
+    ) -> str:
+        import shutil
+        import tempfile
+
+        cargo_path = os.environ.get("CARGO", "")
+        if not cargo_path:
+            if not shutil.which("cargo"):
+                message = "Executable `cargo` could not be found on PATH"
+                raise OSError(message)
+
+            cargo_path = "cargo"
+
+        app_dir = os.path.join(directory, self.PLUGIN_NAME)
+        if not os.path.isdir(app_dir):
+            os.makedirs(app_dir)
+
+        on_windows = sys.platform == "win32"
+        base_env = dict(os.environ)
+        base_env["PYAPP_PROJECT_NAME"] = self.metadata.name
+        base_env["PYAPP_PROJECT_VERSION"] = self.metadata.version
+
+        if self.config.python_version:
+            base_env["PYAPP_PYTHON_VERSION"] = self.config.python_version
+
+        # https://doc.rust-lang.org/cargo/reference/config.html#buildtarget
+        build_target = os.environ.get("CARGO_BUILD_TARGET", "")
+
+        # This will determine whether we install from crates.io or build locally and is currently required for
+        # cross compilation: https://github.com/cross-rs/cross/issues/1215
+        repo_path = os.environ.get("PYAPP_REPO", "")
+
+        with tempfile.TemporaryDirectory() as temp_dir:
+            exe_name = "pyapp.exe" if on_windows else "pyapp"
+            if repo_path:
+                context_dir = repo_path
+                target_dir = os.path.join(temp_dir, "build")
+                if build_target:
+                    temp_exe_path = os.path.join(target_dir, build_target, "release", exe_name)
+                else:
+                    temp_exe_path = os.path.join(target_dir, "release", exe_name)
+                install_command = [cargo_path, "build", "--release", "--target-dir", target_dir]
+            else:
+                context_dir = temp_dir
+                temp_exe_path = os.path.join(temp_dir, "bin", exe_name)
+                install_command = [cargo_path, "install", "pyapp", "--force", "--root", temp_dir]
+                if self.config.pyapp_version:
+                    install_command.extend(["--version", self.config.pyapp_version])
+
+            if self.config.scripts:
+                for script in self.config.scripts:
+                    env = dict(base_env)
+                    env["PYAPP_EXEC_SPEC"] = self.metadata.core.scripts[script]
+
+                    self.cargo_build(install_command, cwd=context_dir, env=env)
+
+                    exe_stem = (
+                        f"{script}-{self.metadata.version}-{build_target}"
+                        if build_target
+                        else f"{script}-{self.metadata.version}"
+                    )
+                    exe_path = os.path.join(app_dir, f"{exe_stem}.exe" if on_windows else exe_stem)
+                    shutil.move(temp_exe_path, exe_path)
+            else:
+                self.cargo_build(install_command, cwd=context_dir, env=base_env)
+
+                exe_stem = (
+                    f"{self.metadata.name}-{self.metadata.version}-{build_target}"
+                    if build_target
+                    else f"{self.metadata.name}-{self.metadata.version}"
+                )
+                exe_path = os.path.join(app_dir, f"{exe_stem}.exe" if on_windows else exe_stem)
+                shutil.move(temp_exe_path, exe_path)
+
+        return app_dir
+
+    def cargo_build(self, *args: Any, **kwargs: Any) -> None:
+        import subprocess
+
+        if self.app.verbosity < 0:
+            kwargs["stdout"] = subprocess.PIPE
+            kwargs["stderr"] = subprocess.STDOUT
+
+        process = subprocess.run(*args, **kwargs)  # noqa: PLW1510
+        if process.returncode:
+            message = f"Compilation failed (code {process.returncode})"
+            raise OSError(message)
+
+    @classmethod
+    def get_config_class(cls) -> type[BinaryBuilderConfig]:
+        return BinaryBuilderConfig