hn-query 0.2.0__tar.gz

hn_query-0.2.0/.gitignore

@@ -0,0 +1,37 @@
+# Python-generated files
+__pycache__/
+*.py[oc]
+build/
+dist/
+wheels/
+*.egg-info
+
+# Virtual environments
+.venv
+
+# Testing
+.coverage
+.pytest_cache/
+htmlcov/
+
+# Ruff
+.ruff_cache/
+
+# Environment variables
+.env
+.env.*
+
+# IDE
+.idea/
+.vscode/
+*.swp
+*.swo
+*~
+
+# OS
+.DS_Store
+Thumbs.db
+
+# uv
+uv.lock
+.transcripts/

hn_query-0.2.0/.pre-commit-config.yaml

@@ -0,0 +1,15 @@
+repos:
+  - repo: https://github.com/pre-commit/pre-commit-hooks
+    rev: v5.0.0
+    hooks:
+      - id: trailing-whitespace
+      - id: end-of-file-fixer
+      - id: check-yaml
+      - id: check-added-large-files
+
+  - repo: https://github.com/astral-sh/ruff-pre-commit
+    rev: v0.11.6
+    hooks:
+      - id: ruff
+        args: [--fix]
+      - id: ruff-format

hn_query-0.2.0/.python-version

@@ -0,0 +1 @@
+3.12

hn_query-0.2.0/.uv-cache/.gitignore

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

hn_query-0.2.0/.uv-cache/CACHEDIR.TAG

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

hn_query-0.2.0/.uv-cache/archive-v0/1VCaYK1ptRSIoJNzb1tXb/editables/__init__.py

@@ -0,0 +1,102 @@
+import os
+import re
+from pathlib import Path
+from typing import Dict, Iterable, List, Tuple, Union
+
+__all__ = (
+    "EditableProject",
+    "__version__",
+)
+
+__version__ = "0.5"
+
+
+# Check if a project name is valid, based on PEP 426:
+# https://peps.python.org/pep-0426/#name
+def is_valid(name: str) -> bool:
+    return (
+        re.match(r"^([A-Z0-9]|[A-Z0-9][A-Z0-9._-]*[A-Z0-9])$", name, re.IGNORECASE)
+        is not None
+    )
+
+
+# Slightly modified version of the normalisation from PEP 503:
+# https://peps.python.org/pep-0503/#normalized-names
+# This version uses underscore, so that the result is more
+# likely to be a valid import name
+def normalize(name: str) -> str:
+    return re.sub(r"[-_.]+", "_", name).lower()
+
+
+class EditableException(Exception):
+    pass
+
+
+class EditableProject:
+    def __init__(self, project_name: str, project_dir: Union[str, os.PathLike]) -> None:
+        if not is_valid(project_name):
+            raise ValueError(f"Project name {project_name} is not valid")
+        self.project_name = normalize(project_name)
+        self.bootstrap = f"_editable_impl_{self.project_name}"
+        self.project_dir = Path(project_dir)
+        self.redirections: Dict[str, str] = {}
+        self.path_entries: List[Path] = []
+        self.subpackages: Dict[str, Path] = {}
+
+    def make_absolute(self, path: Union[str, os.PathLike]) -> Path:
+        return (self.project_dir / path).resolve()
+
+    def map(self, name: str, target: Union[str, os.PathLike]) -> None:
+        if "." in name:
+            raise EditableException(
+                f"Cannot map {name} as it is not a top-level package"
+            )
+        abs_target = self.make_absolute(target)
+        if abs_target.is_dir():
+            abs_target = abs_target / "__init__.py"
+        if abs_target.is_file():
+            self.redirections[name] = str(abs_target)
+        else:
+            raise EditableException(f"{target} is not a valid Python package or module")
+
+    def add_to_path(self, dirname: Union[str, os.PathLike]) -> None:
+        self.path_entries.append(self.make_absolute(dirname))
+
+    def add_to_subpackage(self, package: str, dirname: Union[str, os.PathLike]) -> None:
+        self.subpackages[package] = self.make_absolute(dirname)
+
+    def files(self) -> Iterable[Tuple[str, str]]:
+        yield f"{self.project_name}.pth", self.pth_file()
+        if self.subpackages:
+            for package, location in self.subpackages.items():
+                yield self.package_redirection(package, location)
+        if self.redirections:
+            yield f"{self.bootstrap}.py", self.bootstrap_file()
+
+    def dependencies(self) -> List[str]:
+        deps = []
+        if self.redirections:
+            deps.append("editables")
+        return deps
+
+    def pth_file(self) -> str:
+        lines = []
+        if self.redirections:
+            lines.append(f"import {self.bootstrap}")
+        for entry in self.path_entries:
+            lines.append(str(entry))
+        return "\n".join(lines)
+
+    def package_redirection(self, package: str, location: Path) -> Tuple[str, str]:
+        init_py = package.replace(".", "/") + "/__init__.py"
+        content = f"__path__ = [{str(location)!r}]"
+        return init_py, content
+
+    def bootstrap_file(self) -> str:
+        bootstrap = [
+            "from editables.redirector import RedirectingFinder as F",
+            "F.install()",
+        ]
+        for name, path in self.redirections.items():
+            bootstrap.append(f"F.map_module({name!r}, {path!r})")
+        return "\n".join(bootstrap)

hn_query-0.2.0/.uv-cache/archive-v0/1VCaYK1ptRSIoJNzb1tXb/editables/redirector.py

@@ -0,0 +1,47 @@
+import importlib.abc
+import importlib.machinery
+import importlib.util
+import sys
+from types import ModuleType
+from typing import Dict, Optional, Sequence, Union
+
+ModulePath = Optional[Sequence[Union[bytes, str]]]
+
+
+class RedirectingFinder(importlib.abc.MetaPathFinder):
+    _redirections: Dict[str, str] = {}
+
+    @classmethod
+    def map_module(cls, name: str, path: str) -> None:
+        cls._redirections[name] = path
+
+    @classmethod
+    def find_spec(
+        cls, fullname: str, path: ModulePath = None, target: Optional[ModuleType] = None
+    ) -> Optional[importlib.machinery.ModuleSpec]:
+        if "." in fullname:
+            return None
+        if path is not None:
+            return None
+        try:
+            redir = cls._redirections[fullname]
+        except KeyError:
+            return None
+        spec = importlib.util.spec_from_file_location(fullname, redir)
+        return spec
+
+    @classmethod
+    def install(cls) -> None:
+        for f in sys.meta_path:
+            if f == cls:
+                break
+        else:
+            sys.meta_path.append(cls)
+
+    @classmethod
+    def invalidate_caches(cls) -> None:
+        # importlib.invalidate_caches calls finders' invalidate_caches methods,
+        # and since we install this meta path finder as a class rather than an instance,
+        # we have to override the inherited invalidate_caches method (using self)
+        # as a classmethod instead
+        pass

hn_query-0.2.0/.uv-cache/archive-v0/1VCaYK1ptRSIoJNzb1tXb/editables-0.5.dist-info/LICENSE.txt

@@ -0,0 +1,18 @@
+Copyright (c) 2020 Paul Moore
+
+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.

hn_query-0.2.0/.uv-cache/archive-v0/1VCaYK1ptRSIoJNzb1tXb/editables-0.5.dist-info/METADATA

@@ -0,0 +1,91 @@
+Metadata-Version: 2.1
+Name: editables
+Version: 0.5
+Summary: Editable installations
+Author-email: Paul Moore <p.f.moore@gmail.com>
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Topic :: Utilities
+Classifier: Typing :: Typed
+Project-URL: Documentation, https://editables.readthedocs.io
+Project-URL: Source, https://github.com/pfmoore/editables
+Project-URL: Tracker, https://github.com/pfmoore/editables/issues
+
+# A Python library for creating "editable wheels"
+
+This library supports the building of wheels which, when installed, will
+expose packages in a local directory on `sys.path` in "editable mode". In
+other words, changes to the package source will be  reflected in the package
+visible to Python, without needing a reinstall.
+
+## Usage
+
+Suppose you want to build a wheel for your project `foo`. Your project is
+located in the directory `/path/to/foo`. Under that directory, you have a
+`src` directory containing your project, which is a package called `foo`
+and a Python module called `bar.py`. So your directory structure looks like
+this:
+
+```
+/path/to/foo
+|
++-- src
+|   +-- foo
+|   |   +-- __init__.py
+|   +-- bar.py
+|
++-- setup.py
++-- other files
+```
+
+Build your wheel as follows:
+
+```python
+from editables import EditableProject
+
+my_project = EditableProject("foo", "/path/to/foo")
+my_project.add_to_path("src")
+
+# Build a wheel however you prefer...
+wheel = BuildAWheel()
+
+# Add files to the wheel
+for name, content in my_project.files():
+    wheel.add_file(name, content)
+
+# Record any runtime dependencies
+for dep in my_project.dependencies():
+    wheel.metadata.dependencies.add(dep)
+```
+
+The resulting wheel will, when installed, put the project `src` directory on
+`sys.path` so that editing the original source will take effect without needing
+a reinstall (i.e., as "editable" packages). The project is exposed on `sys.path`
+by adding a single `.pth` file, named after the project, into the wheel.
+
+For more details, including how to control what gets exposed more precisely, see
+[the documentation](https://editables.readthedocs.io/en/latest/).
+
+Note that this project doesn't build wheels directly. That's the responsibility
+of the calling code.
+
+## Python Compatibility
+
+This project supports the same versions of Python as pip does. Currently
+that is Python 3.7 and later, and PyPy3 (although we don't test against
+PyPy).
+

hn_query-0.2.0/.uv-cache/archive-v0/1VCaYK1ptRSIoJNzb1tXb/editables-0.5.dist-info/RECORD

@@ -0,0 +1,7 @@
+editables/__init__.py,sha256=QjOAsD1QjiUidBlER6TEZu6UDgdHb-keuwWd2WIX8IU,3645
+editables/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+editables/redirector.py,sha256=V1UdndKEHqIx1qWkMxktY02drcPGJHEdvoXubcD2oh4,1487
+editables-0.5.dist-info/LICENSE.txt,sha256=xz4IoE4VV_20lSX7elefc7yrhKJUkQuTUO5W2vFDky0,1072
+editables-0.5.dist-info/WHEEL,sha256=EZbGkh7Ie4PoZfRQ8I0ZuP9VklN_TvcZ6DSE5Uar4z4,81
+editables-0.5.dist-info/METADATA,sha256=1x4z8dvd6mWE9RPpoN9vGlo2BfDm84cLsYHRTB2lS0w,3118
+editables-0.5.dist-info/RECORD,,

hn_query-0.2.0/.uv-cache/archive-v0/1VCaYK1ptRSIoJNzb1tXb/editables-0.5.dist-info/WHEEL

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

hn_query-0.2.0/.uv-cache/archive-v0/2hh5AgoJ5lWeQ6nNt0NHZ/typer/__init__.py

@@ -0,0 +1,39 @@
+"""Typer, build great CLIs. Easy to code. Based on Python type hints."""
+
+__version__ = "0.24.1"
+
+from shutil import get_terminal_size as get_terminal_size
+
+from click.exceptions import Abort as Abort
+from click.exceptions import BadParameter as BadParameter
+from click.exceptions import Exit as Exit
+from click.termui import clear as clear
+from click.termui import confirm as confirm
+from click.termui import echo_via_pager as echo_via_pager
+from click.termui import edit as edit
+from click.termui import getchar as getchar
+from click.termui import pause as pause
+from click.termui import progressbar as progressbar
+from click.termui import prompt as prompt
+from click.termui import secho as secho
+from click.termui import style as style
+from click.termui import unstyle as unstyle
+from click.utils import echo as echo
+from click.utils import format_filename as format_filename
+from click.utils import get_app_dir as get_app_dir
+from click.utils import get_binary_stream as get_binary_stream
+from click.utils import get_text_stream as get_text_stream
+from click.utils import open_file as open_file
+
+from . import colors as colors
+from .main import Typer as Typer
+from .main import launch as launch
+from .main import run as run
+from .models import CallbackParam as CallbackParam
+from .models import Context as Context
+from .models import FileBinaryRead as FileBinaryRead
+from .models import FileBinaryWrite as FileBinaryWrite
+from .models import FileText as FileText
+from .models import FileTextWrite as FileTextWrite
+from .params import Argument as Argument
+from .params import Option as Option

hn_query-0.2.0/.uv-cache/archive-v0/2hh5AgoJ5lWeQ6nNt0NHZ/typer/__main__.py

@@ -0,0 +1,3 @@
+from .cli import main
+
+main()

hn_query-0.2.0/.uv-cache/archive-v0/2hh5AgoJ5lWeQ6nNt0NHZ/typer/_completion_classes.py

@@ -0,0 +1,199 @@
+import importlib.util
+import os
+import re
+import sys
+from typing import Any
+
+import click
+import click.parser
+import click.shell_completion
+from click.shell_completion import split_arg_string as click_split_arg_string
+
+from ._completion_shared import (
+    COMPLETION_SCRIPT_BASH,
+    COMPLETION_SCRIPT_FISH,
+    COMPLETION_SCRIPT_POWER_SHELL,
+    COMPLETION_SCRIPT_ZSH,
+    Shells,
+)
+
+
+def _sanitize_help_text(text: str) -> str:
+    """Sanitizes the help text by removing rich tags"""
+    if not importlib.util.find_spec("rich"):
+        return text
+    from . import rich_utils
+
+    return rich_utils.rich_render_text(text)
+
+
+class BashComplete(click.shell_completion.BashComplete):
+    name = Shells.bash.value
+    source_template = COMPLETION_SCRIPT_BASH
+
+    def source_vars(self) -> dict[str, Any]:
+        return {
+            "complete_func": self.func_name,
+            "autocomplete_var": self.complete_var,
+            "prog_name": self.prog_name,
+        }
+
+    def get_completion_args(self) -> tuple[list[str], str]:
+        cwords = click_split_arg_string(os.environ["COMP_WORDS"])
+        cword = int(os.environ["COMP_CWORD"])
+        args = cwords[1:cword]
+
+        try:
+            incomplete = cwords[cword]
+        except IndexError:
+            incomplete = ""
+
+        return args, incomplete
+
+    def format_completion(self, item: click.shell_completion.CompletionItem) -> str:
+        # TODO: Explore replicating the new behavior from Click, with item types and
+        # triggering completion for files and directories
+        # return f"{item.type},{item.value}"
+        return f"{item.value}"
+
+    def complete(self) -> str:
+        args, incomplete = self.get_completion_args()
+        completions = self.get_completions(args, incomplete)
+        out = [self.format_completion(item) for item in completions]
+        return "\n".join(out)
+
+
+class ZshComplete(click.shell_completion.ZshComplete):
+    name = Shells.zsh.value
+    source_template = COMPLETION_SCRIPT_ZSH
+
+    def source_vars(self) -> dict[str, Any]:
+        return {
+            "complete_func": self.func_name,
+            "autocomplete_var": self.complete_var,
+            "prog_name": self.prog_name,
+        }
+
+    def get_completion_args(self) -> tuple[list[str], str]:
+        completion_args = os.getenv("_TYPER_COMPLETE_ARGS", "")
+        cwords = click_split_arg_string(completion_args)
+        args = cwords[1:]
+        if args and not completion_args.endswith(" "):
+            incomplete = args[-1]
+            args = args[:-1]
+        else:
+            incomplete = ""
+        return args, incomplete
+
+    def format_completion(self, item: click.shell_completion.CompletionItem) -> str:
+        def escape(s: str) -> str:
+            return (
+                s.replace('"', '""')
+                .replace("'", "''")
+                .replace("$", "\\$")
+                .replace("`", "\\`")
+                .replace(":", r"\\:")
+            )
+
+        # TODO: Explore replicating the new behavior from Click, pay attention to
+        # the difference with and without escape
+        # return f"{item.type}\n{item.value}\n{item.help if item.help else '_'}"
+        if item.help:
+            return f'"{escape(item.value)}":"{_sanitize_help_text(escape(item.help))}"'
+        else:
+            return f'"{escape(item.value)}"'
+
+    def complete(self) -> str:
+        args, incomplete = self.get_completion_args()
+        completions = self.get_completions(args, incomplete)
+        res = [self.format_completion(item) for item in completions]
+        if res:
+            args_str = "\n".join(res)
+            return f"_arguments '*: :(({args_str}))'"
+        else:
+            return "_files"
+
+
+class FishComplete(click.shell_completion.FishComplete):
+    name = Shells.fish.value
+    source_template = COMPLETION_SCRIPT_FISH
+
+    def source_vars(self) -> dict[str, Any]:
+        return {
+            "complete_func": self.func_name,
+            "autocomplete_var": self.complete_var,
+            "prog_name": self.prog_name,
+        }
+
+    def get_completion_args(self) -> tuple[list[str], str]:
+        completion_args = os.getenv("_TYPER_COMPLETE_ARGS", "")
+        cwords = click_split_arg_string(completion_args)
+        args = cwords[1:]
+        if args and not completion_args.endswith(" "):
+            incomplete = args[-1]
+            args = args[:-1]
+        else:
+            incomplete = ""
+        return args, incomplete
+
+    def format_completion(self, item: click.shell_completion.CompletionItem) -> str:
+        # TODO: Explore replicating the new behavior from Click, pay attention to
+        # the difference with and without formatted help
+        # if item.help:
+        #     return f"{item.type},{item.value}\t{item.help}"
+
+        # return f"{item.type},{item.value}
+        if item.help:
+            formatted_help = re.sub(r"\s", " ", item.help)
+            return f"{item.value}\t{_sanitize_help_text(formatted_help)}"
+        else:
+            return f"{item.value}"
+
+    def complete(self) -> str:
+        complete_action = os.getenv("_TYPER_COMPLETE_FISH_ACTION", "")
+        args, incomplete = self.get_completion_args()
+        completions = self.get_completions(args, incomplete)
+        show_args = [self.format_completion(item) for item in completions]
+        if complete_action == "get-args":
+            if show_args:
+                return "\n".join(show_args)
+        elif complete_action == "is-args":
+            if show_args:
+                # Activate complete args (no files)
+                sys.exit(0)
+            else:
+                # Deactivate complete args (allow files)
+                sys.exit(1)
+        return ""  # pragma: no cover
+
+
+class PowerShellComplete(click.shell_completion.ShellComplete):
+    name = Shells.powershell.value
+    source_template = COMPLETION_SCRIPT_POWER_SHELL
+
+    def source_vars(self) -> dict[str, Any]:
+        return {
+            "complete_func": self.func_name,
+            "autocomplete_var": self.complete_var,
+            "prog_name": self.prog_name,
+        }
+
+    def get_completion_args(self) -> tuple[list[str], str]:
+        completion_args = os.getenv("_TYPER_COMPLETE_ARGS", "")
+        incomplete = os.getenv("_TYPER_COMPLETE_WORD_TO_COMPLETE", "")
+        cwords = click_split_arg_string(completion_args)
+        args = cwords[1:-1] if incomplete else cwords[1:]
+        return args, incomplete
+
+    def format_completion(self, item: click.shell_completion.CompletionItem) -> str:
+        return f"{item.value}:::{_sanitize_help_text(item.help) if item.help else ' '}"
+
+
+def completion_init() -> None:
+    click.shell_completion.add_completion_class(BashComplete, Shells.bash.value)
+    click.shell_completion.add_completion_class(ZshComplete, Shells.zsh.value)
+    click.shell_completion.add_completion_class(FishComplete, Shells.fish.value)
+    click.shell_completion.add_completion_class(
+        PowerShellComplete, Shells.powershell.value
+    )
+    click.shell_completion.add_completion_class(PowerShellComplete, Shells.pwsh.value)