sphinx-hackerrank 2026.10.30.1__py3-none-any.whl

sphinx_hackerrank/__init__.py

@@ -0,0 +1,31 @@
+"""Sphinx extension for portable HackerRank interviewer mini-maps."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from sphinx_hackerrank.builder import HackerRankBuilder
+from sphinx_hackerrank.sections import MiniMapSection, discard_guide_cache, simplify_mini_map
+
+if TYPE_CHECKING:
+    from sphinx.application import Sphinx
+
+__version__ = "2026.10.30.1"
+
+
+def setup(app: Sphinx) -> dict[str, object]:
+    """Register the builder, directive, and project-independent settings."""
+    app.setup_extension("sphinx_jinja2")
+    app.setup_extension("sphinx_toolbox.collapse")
+    app.add_config_value("hackerrank_manifest_pattern", "**/*-mini-map.yml", "env", types=str)
+    app.add_config_value("hackerrank_languages", {}, "env", types=dict)
+    app.add_config_value("hackerrank_jinja_context", "languages", "env", types=str)
+    app.add_config_value("hackerrank_source_url", None, "html", types=(str, type(None)))
+    app.add_config_value("hackerrank_source_suffix", ".html", "html", types=str)
+    app.add_config_value("hackerrank_source_anchors", True, "html", types=bool)
+    app.add_config_value("hackerrank_exclude_admonitions", True, "html", types=bool)
+    app.add_builder(HackerRankBuilder)
+    app.add_directive("mini-map-section", MiniMapSection)
+    app.connect("doctree-read", discard_guide_cache)
+    app.connect("doctree-resolved", simplify_mini_map)
+    return {"version": __version__, "parallel_read_safe": True, "parallel_write_safe": True}

sphinx_hackerrank/builder.py

@@ -0,0 +1,117 @@
+"""Build HackerRank fragments using Sphinx's standard HTML renderer."""
+
+from __future__ import annotations
+
+from html import escape
+from pathlib import Path
+from typing import TYPE_CHECKING, Any
+
+from sphinx.builders.html import StandaloneHTMLBuilder
+
+from sphinx_hackerrank.html import fragment_path, render_fragment
+from sphinx_hackerrank.targets import load_targets
+
+if TYPE_CHECKING:
+    from collections.abc import Iterator
+
+
+class HackerRankBuilder(StandaloneHTMLBuilder):
+    """Add standalone language fragments to the normal HTML output."""
+
+    name = "hackerrank"
+    format = "html"
+
+    def init(self) -> None:
+        """Validate all question mappings before writing any output."""
+        super().init()
+        self.mini_map_targets = load_targets(
+            source_dir=Path(self.srcdir), pattern=self.config.hackerrank_manifest_pattern
+        )
+
+    def get_outdated_docs(self) -> Iterator[str]:
+        """Rebuild missing fragments and changed mappings or
+        presentation.
+        """
+        self.mini_map_targets = load_targets(
+            source_dir=Path(self.srcdir), pattern=self.config.hackerrank_manifest_pattern
+        )
+        outdated = set(super().get_outdated_docs())
+        if not (Path(self.outdir) / "mini-maps" / "index.html").is_file():
+            outdated.update(self.mini_map_targets)
+        for docname, targets in self.mini_map_targets.items():
+            newest_dependency = max(
+                path.stat().st_mtime_ns
+                for path in (
+                    targets[0].metadata_path,
+                    Path(__file__),
+                    Path(__file__).with_name(name="html.py"),
+                    Path(__file__).parent / "static" / "mini_map.css",
+                )
+            )
+            outputs = (
+                fragment_path(output_dir=Path(self.outdir), docname=docname, language=target.language)
+                for target in targets
+            )
+            if any(not output.is_file() or output.stat().st_mtime_ns < newest_dependency for output in outputs):
+                outdated.add(docname)
+        return iter(sorted(outdated))
+
+    def handle_page(
+        self,
+        pagename: str,
+        addctx: dict[str, Any],
+        templatename: str = "page.html",
+        *,
+        outfilename: Path | None = None,
+        event_arg: object = None,
+    ) -> None:
+        """Export the rendered body before the HTML theme adds chrome."""
+        for target in self.mini_map_targets.get(pagename, []):
+            output_path = fragment_path(output_dir=Path(self.outdir), docname=pagename, language=target.language)
+            output_path.parent.mkdir(parents=True, exist_ok=True)
+            output_path.write_text(
+                data=render_fragment(
+                    html=addctx["body"],
+                    language=target.language,
+                    docname=pagename,
+                    source_url=self.config.hackerrank_source_url,
+                    source_suffix=self.config.hackerrank_source_suffix,
+                    source_anchors=self.config.hackerrank_source_anchors,
+                ),
+                encoding="utf-8",
+            )
+        super().handle_page(
+            pagename=pagename,
+            addctx=addctx,
+            templatename=templatename,
+            outfilename=outfilename,
+            event_arg=event_arg,
+        )
+
+    def finish(self) -> None:
+        """Add a local preview index linking to each standalone mini-
+        map.
+        """
+        super().finish()
+        preview_dir = Path(self.outdir) / "mini-maps"
+        preview_dir.mkdir(parents=True, exist_ok=True)
+        links = "\n".join(
+            f'<li><a href="{escape(s=docname.removesuffix("-mini-map"))}/{target.language}.html">'
+            f"{escape(s=target.name)}</a></li>"
+            for docname, targets in self.mini_map_targets.items()
+            for target in targets
+        )
+        (preview_dir / "index.html").write_text(
+            data=(
+                '<!doctype html>\n<html lang="en"><head><meta charset="utf-8">'
+                '<meta name="viewport" content="width=device-width, initial-scale=1">'
+                "<title>HackerRank mini-maps</title>"
+                "<style>body{font:16px/1.5 Arial,sans-serif;margin:2rem;max-width:60rem}"
+                "li{margin:.5rem 0}</style></head><body><main>"
+                "<h1>HackerRank mini-maps</h1>"
+                "<p>Choose a question and language to preview its interviewer mini-map.</p>"
+                "<p>These previews use the same HTML published to HackerRank interviewer notes.</p>"
+                f"<ul>{links}</ul></main></body></html>\n"
+            ),
+            encoding="utf-8",
+        )

sphinx_hackerrank/html.py

@@ -0,0 +1,54 @@
+"""Render standalone HTML without a theme or external assets."""
+
+from __future__ import annotations
+
+import posixpath
+from importlib.resources import files
+from pathlib import Path
+from urllib.parse import urljoin, urlsplit
+
+from bs4 import BeautifulSoup
+
+
+def fragment_path(*, output_dir: Path, docname: str, language: str) -> Path:
+    """Locate a language fragment in a builder output directory."""
+    return output_dir / "mini-maps" / docname.removesuffix("-mini-map") / f"{language}.html"
+
+
+def render_fragment(
+    *,
+    html: str,
+    language: str,
+    docname: str = "mini-map",
+    source_url: str | None = None,
+    source_suffix: str = ".html",
+    source_anchors: bool = True,
+) -> str:
+    """Extract a language view, retaining exact code and portable links."""
+    soup = BeautifulSoup(html, "html.parser")
+    containers = soup.select(f".mini-map-{language}")
+    if len(containers) != 1:
+        raise ValueError(f"Expected one mini-map for {language}, found {len(containers)}")
+    container = containers[0]
+    for link in container.select("a.headerlink"):
+        link.decompose()
+    output = fragment_path(output_dir=Path(), docname=docname, language=language)
+    for link in container.select("a[href]"):
+        url = urlsplit(str(link["href"]))
+        if not url.scheme and not url.netloc and url.path.endswith(".html"):
+            target = posixpath.normpath(posixpath.join(posixpath.dirname(docname), url.path))
+            if source_url is None:
+                destination = posixpath.relpath(target, output.parent.as_posix())
+            else:
+                destination = urljoin(source_url.rstrip("/") + "/", target.removesuffix(".html") + source_suffix)
+            if source_anchors and url.fragment:
+                destination += "#" + url.fragment
+            link["href"] = destination
+    for pre in container.find_all("pre"):
+        code = soup.new_tag("code")
+        code.string = pre.get_text()
+        pre.clear()
+        pre.append(code)
+    fragment = str(container).encode("ascii", errors="xmlcharrefreplace").decode("ascii")
+    style = files("sphinx_hackerrank").joinpath("static/mini_map.css").read_text(encoding="utf-8")
+    return f'<style type="text/css">{style}</style>\n{fragment}\n'

sphinx_hackerrank/sections.py

@@ -0,0 +1,182 @@
+"""Reuse parsed guide sections in language-specific Sphinx mini-maps."""
+
+from __future__ import annotations
+
+from copy import copy
+from pathlib import Path
+from typing import TYPE_CHECKING, Any, ClassVar
+
+from docutils import nodes
+from docutils.parsers.rst import Parser, directives
+from docutils.transforms.references import (
+    AnonymousHyperlinks,
+    ExternalTargets,
+    IndirectHyperlinks,
+    InternalTargets,
+    PropagateTargets,
+    Substitutions,
+)
+from docutils.utils import new_document
+from sphinx.transforms import DefaultSubstitutions
+from sphinx.util.docutils import SphinxDirective
+from sphinx_toolbox.collapse import CollapseNode, CollapseSummaryNode
+
+if TYPE_CHECKING:
+    from collections.abc import Callable
+
+    from sphinx.application import Sphinx
+
+
+def select_section(*, document: nodes.document, selector: str) -> nodes.section:
+    """Resolve an exact heading path or a standard RST section label."""
+    sections = list(document.findall(condition=nodes.section))
+    if selector.startswith("#"):
+        label = nodes.fully_normalize_name(name=selector[1:])
+        matches = [section for section in sections if label in section["names"] or label in section["ids"]]
+    else:
+        parts = [part.strip() for part in selector.split(sep="/")]
+        matches = [section for section in sections if section[0].astext() == parts[0]]
+        for part in parts[1:]:
+            matches = [
+                child
+                for section in matches
+                for child in section.children
+                if isinstance(child, nodes.section) and child[0].astext() == part
+            ]
+    if len(matches) != 1:
+        msg = f"Expected one guide section for {selector!r}, found {len(matches)}"
+        raise ValueError(msg)
+    return matches[0]
+
+
+def _rubric(title: nodes.Node) -> nodes.rubric:
+    assert isinstance(title, nodes.title)
+    rubric = nodes.rubric(rawsource=title.rawsource)
+    rubric += title.deepcopy().children
+    return rubric
+
+
+def section_content(*, section: nodes.section, guide: str, language: str, include_heading: bool) -> list[nodes.Node]:
+    """Copy selected nodes without importing the guide's anchors or
+    language selectors.
+    """
+    container = nodes.container()
+    if include_heading:
+        container += _rubric(title=section[0])
+    container += [child.deepcopy() for child in section.children[1:]]
+    for subsection in list(container.findall(condition=nodes.section)):
+        subsection.replace_self(new=[_rubric(title=subsection[0]), *subsection.children[1:]])
+    for target in list(container.findall(condition=nodes.target)):
+        assert target.parent is not None
+        target.parent.remove(item=target)
+    for element in container.findall(condition=nodes.Element):
+        element["ids"] = []
+        element["names"] = []
+        if isinstance(element, nodes.reference) and "refid" in element:
+            element["refuri"] = f"{guide}.html#{element['refid']}"
+            del element["refid"]
+    for collapse in list(container.findall(condition=CollapseNode)):
+        if collapse["label"] == language:
+            collapse.replace_self(
+                new=[child for child in collapse.children if not isinstance(child, CollapseSummaryNode)]
+            )
+    return container.children
+
+
+class MiniMapSection(SphinxDirective):
+    """Include one parsed section from a maintained guide in one
+    language.
+    """
+
+    required_arguments = 1
+    option_spec: ClassVar[dict[str, Callable[[str], Any]] | None] = {
+        "section": directives.unchanged_required,
+        "language": directives.unchanged_required,
+        "include-heading": directives.flag,
+    }
+
+    def run(self) -> list[nodes.Node]:
+        """Select a guide section, preserving source files and dependency
+        tracking.
+        """
+        source_root = Path(self.env.srcdir).resolve()
+        _relative, filename = self.env.relfn2path(filename=self.arguments[0])
+        source_path = Path(filename).resolve()
+        if not source_path.is_relative_to(source_root) or source_path.suffix != ".rst":
+            raise self.error(message="Mini-map source must be an RST guide within the source directory")
+        if source_path == Path(self.env.doc2path(docname=self.env.docname)).resolve():
+            raise self.error(message="A mini-map cannot include itself")
+        if "section" not in self.options or "language" not in self.options:
+            raise self.error(message="mini-map-section requires :section: and :language:")
+        language = self.config.hackerrank_languages.get(self.options["language"])
+        if language is None:
+            raise self.error(message=f"Expected one mini-map language config for {self.options['language']!r}")
+        self.env.note_dependency(filename=source_path)
+        cache: dict[tuple[str, str], nodes.document] = self.state.document.attributes.setdefault("_mini_map_guides", {})
+        key = (str(object=source_path), self.options["language"])
+        if key not in cache:
+            settings = copy(x=self.state.document.settings)
+            document = new_document(
+                source_path=str(object=self.env.doc2path(docname=self.env.docname)), settings=settings
+            )
+            contexts = self.config.jinja2_contexts
+            context_name = self.config.hackerrank_jinja_context
+            self.config.jinja2_contexts = {
+                **contexts,
+                context_name: {**contexts.get(context_name, {}), **language.get("context", {})},
+            }
+            try:
+                source = "\n\n".join(
+                    part
+                    for part in (
+                        self.config.rst_prolog or "",
+                        f".. include:: /{source_path.relative_to(source_root).as_posix()}",
+                        self.config.rst_epilog or "",
+                    )
+                    if part
+                )
+                Parser().parse(inputstring=source, document=document)
+                for transform in (
+                    DefaultSubstitutions,
+                    Substitutions,
+                    PropagateTargets,
+                    AnonymousHyperlinks,
+                    IndirectHyperlinks,
+                    ExternalTargets,
+                    InternalTargets,
+                ):
+                    transform(document=document).apply()
+            finally:
+                self.config.jinja2_contexts = contexts
+            cache[key] = document
+        try:
+            section = select_section(document=cache[key], selector=self.options["section"])
+        except ValueError as error:
+            raise self.error(message=str(object=error)) from error
+        content = section_content(
+            section=section,
+            guide=source_path.relative_to(source_root).with_suffix(suffix="").as_posix(),
+            language=language.get("name", self.options["language"]),
+            include_heading="include-heading" in self.options,
+        )
+        for root in content:
+            for node in root.findall():
+                node.document = self.state.document
+        return content
+
+
+def discard_guide_cache(_app: Sphinx, doctree: nodes.document) -> None:
+    """Keep temporary language variants out of Sphinx's persisted doctrees."""
+    doctree.attributes.pop("_mini_map_guides", None)
+
+
+def simplify_mini_map(_app: Sphinx, doctree: nodes.document, docname: str) -> None:
+    """Remove admonitions from mini-map views after includes render."""
+    if not _app.config.hackerrank_exclude_admonitions:
+        return
+    containers = [node for node in doctree.findall(condition=nodes.container) if "hr-mini-map" in node["classes"]]
+    for container in containers:
+        for admonition in list(container.findall(condition=lambda node: isinstance(node, nodes.Admonition))):
+            parent = admonition.parent
+            assert parent is not None
+            parent.remove(item=admonition)

sphinx_hackerrank/static/mini_map.css

@@ -0,0 +1,36 @@
+.hr-mini-map {
+  font-family: Arial, sans-serif;
+  line-height: 1.5;
+  padding: 10px;
+}
+.hr-mini-map details {
+  margin-bottom: 12px;
+}
+.hr-mini-map summary {
+  cursor: pointer;
+  font-size: 16px;
+  font-weight: bold;
+}
+.hr-mini-map .rubric {
+  font-weight: bold;
+  margin-top: 1em;
+}
+.hr-mini-map pre {
+  background: #f5f5f5;
+  border: 1px solid #ddd;
+  color: #222;
+  overflow-x: auto;
+  padding: 10px;
+  white-space: pre;
+}
+.hr-mini-map table {
+  border-collapse: collapse;
+  width: 100%;
+}
+.hr-mini-map th,
+.hr-mini-map td {
+  border: 1px solid #ddd;
+  padding: 8px;
+  text-align: left;
+  vertical-align: top;
+}

sphinx_hackerrank/targets.py

@@ -0,0 +1,49 @@
+"""Read rendering metadata without depending on an API client."""
+
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass
+from pathlib import Path
+
+import yaml
+
+
+@dataclass(frozen=True)
+class Target:
+    """One language and its interviewer-facing title."""
+
+    language: str
+    name: str
+    metadata_path: Path
+
+
+def load_targets(*, source_dir: Path, pattern: str) -> dict[str, list[Target]]:
+    """Read adjacent mapping files; publishing metadata stays with the consumer."""
+    targets: dict[str, list[Target]] = {}
+    for path in sorted(source_dir.glob(pattern)):
+        source = path.with_suffix(".rst")
+        if not source.is_file():
+            raise ValueError(f"Missing RST source beside {path}")
+        metadata = yaml.safe_load(path.read_text(encoding="utf-8"))
+        if not isinstance(metadata, dict) or metadata.get("version") != 1:
+            raise ValueError(f"Expected version: 1 in {path}")
+        questions = metadata.get("questions")
+        if not isinstance(questions, list) or not questions:
+            raise ValueError(f"Expected nonempty questions list in {path}")
+        document: list[Target] = []
+        seen: set[str] = set()
+        for question in questions:
+            if not isinstance(question, dict):
+                raise ValueError(f"Expected a question mapping in {path}")
+            language, name = question.get("language"), question.get("name")
+            if not isinstance(language, str) or re.fullmatch(r"[a-z][a-z0-9]*", language) is None:
+                raise ValueError(f"Invalid language in {path}: {language!r}")
+            if not isinstance(name, str) or not name.strip():
+                raise ValueError(f"Expected a question name in {path}")
+            if language in seen:
+                raise ValueError(f"Duplicate language {language!r} in {path}")
+            seen.add(language)
+            document.append(Target(language, name, path))
+        targets[source.relative_to(source_dir).with_suffix("").as_posix()] = document
+    return targets

sphinx_hackerrank-2026.10.30.1.dist-info/METADATA

@@ -0,0 +1,185 @@
+Metadata-Version: 2.5
+Name: sphinx-hackerrank
+Version: 2026.10.30.1
+Summary: Build portable HackerRank interviewer mini-maps from Sphinx documentation
+Project-URL: Source, https://github.com/adamtheturtle/sphinx-hackerrank
+Project-URL: Issues, https://github.com/adamtheturtle/sphinx-hackerrank/issues
+Author-email: Adam Dangoor <adamdangoor@gmail.com>
+License-Expression: MIT
+License-File: LICENSE
+Classifier: Development Status :: 3 - Alpha
+Classifier: Framework :: Sphinx :: Extension
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Requires-Python: >=3.12
+Requires-Dist: beautifulsoup4>=4.12
+Requires-Dist: pyyaml>=6
+Requires-Dist: sphinx-jinja2>=0.0.1
+Requires-Dist: sphinx-toolbox<5,>=4.3
+Requires-Dist: sphinx<10,>=8.2
+Description-Content-Type: text/x-rst
+
+sphinx-hackerrank
+=================
+
+Build portable interviewer mini-maps from maintained Sphinx guides.
+The ``hackerrank`` builder reuses Sphinx's HTML renderer and exports one
+standalone HTML fragment per question and language, plus a local preview index.
+No HackerRank login or API token is required to build or preview.
+
+Installation
+------------
+
+.. code-block:: console
+
+   pip install sphinx-hackerrank
+
+Built wheels are also published as GitHub release assets:
+
+.. code-block:: console
+
+   pip install https://github.com/adamtheturtle/sphinx-hackerrank/releases/download/2026.10.30.1/sphinx_hackerrank-2026.10.30.1-py3-none-any.whl
+
+Enable the installed extension in ``conf.py``:
+
+.. code-block:: python
+
+   extensions = ["sphinx_hackerrank"]
+
+No ``sys.path`` changes are needed.
+
+Authoring
+---------
+
+Keep the full guide and its mini-map RST beside each other. Include native
+sections by exact heading path or an existing RST section label:
+
+.. code-block:: rst
+
+   .. container:: hr-mini-map mini-map-python
+
+      .. collapse:: Prompt
+
+         .. mini-map-section:: widgets.rst
+            :section: Part 1 / Prompt
+            :language: python
+
+Use ``:section: #widget-prompt`` for a labelled section and
+``:include-heading:`` to retain the selected section's heading.
+Nested headings become rubrics inside disclosures. Missing or ambiguous
+selections are reported as directive errors; build with ``-W`` to reject them.
+The guide does not need extraction markers or duplicated content.
+
+The directive uses native includes, substitutions, and the guide's existing
+Jinja templates. Variants are cached within each mini-map read and discarded
+before Sphinx persists the document tree. Guide and included-file dependencies
+are tracked for incremental builds.
+
+Language contexts
+-----------------
+
+Configure how each language renders the guide's Jinja context:
+
+.. code-block:: python
+
+   hackerrank_jinja_context = "snippets"
+   hackerrank_languages = {
+       "python": {
+           "name": "Python",
+           "context": {"variants": [{"name": "Python", "lexer": "python"}]},
+       },
+   }
+
+``context`` overrides values in the named Jinja context while that variant is
+parsed. The original configuration is restored afterwards.
+``name`` identifies redundant language disclosures to flatten in copied content.
+All other part, category, and test-alternative disclosures remain intact.
+
+By default, admonitions are omitted within ``hr-mini-map`` containers.
+Set ``hackerrank_exclude_admonitions = False`` to retain them.
+The original guide's admonitions remain unchanged.
+
+Question mappings
+-----------------
+
+Create a mapping beside each mini-map, such as ``widgets-mini-map.yml`` beside
+``widgets-mini-map.rst``:
+
+.. code-block:: yaml
+
+   version: 1
+   questions:
+     - language: python
+       name: Widgets - Python
+
+The default ``hackerrank_manifest_pattern`` is ``**/*-mini-map.yml``, relative
+to Sphinx's source directory. Nested directories and custom source layouts are
+supported. Extra fields such as question IDs can be managed by your publishing
+tool; the builder reads only the language and name.
+
+Build and preview
+-----------------
+
+.. code-block:: console
+
+   sphinx-build -W -b hackerrank docs build/hackerrank
+
+Open ``build/hackerrank/mini-maps/index.html`` to select a question and language.
+Each preview uses the same self-contained HTML that can be saved as HackerRank
+interviewer notes. Native disclosure elements work without JavaScript.
+The builder also produces ordinary themed HTML pages. The extension's directives
+work in the standard ``html`` builder too.
+
+Sphinx's native ``only`` directive can select ``builder_hackerrank``,
+``builder_html``, or the shared ``html`` format tag.
+
+Source links
+------------
+
+By default, links to full guide pages point back into the local HTML build.
+To target a hosted documentation or source site, configure:
+
+.. code-block:: python
+
+   hackerrank_source_url = "https://example.org/guides/"
+   hackerrank_source_suffix = ".html"
+   hackerrank_source_anchors = True
+
+A source repository can use a different suffix, such as ``.rst``, and disable
+anchors. External URLs and links within a fragment are retained.
+
+Publishing
+----------
+
+Publishing is separate from rendering. This package does not call the HackerRank
+API or manage credentials, question identities, candidate prompts, or projects.
+Your publishing tool can read the generated fragments and verify saved notes.
+
+Development
+-----------
+
+.. code-block:: console
+
+   uv run pytest --cov --cov-report=term-missing
+   uv run ruff check .
+   uv run ruff format --check .
+   uv build
+   uv run python tests/wheel_smoke.py
+
+The minimal example under ``examples/minimal/manual`` uses a custom Jinja context
+and nested guide files. The wheel smoke test installs the built wheel into a
+fresh environment and builds that example outside the checkout.
+
+To release, update the version in ``pyproject.toml`` and
+``src/sphinx_hackerrank/__init__.py``, then publish a matching GitHub release.
+The release workflow builds and checks distributions before uploading with a
+PyPI trusted publisher configured for ``release.yml`` and environment ``release``.
+Set the repository variable ``PYPI_PUBLISH_ENABLED`` to ``true`` after configuring
+the publisher. The workflow can also be dispatched with a release ``tag``.
+
+License
+-------
+
+MIT. See ``LICENSE``.

sphinx_hackerrank-2026.10.30.1.dist-info/RECORD

@@ -0,0 +1,11 @@
+sphinx_hackerrank/__init__.py,sha256=XsYjow15EjBkJqZLZOwG_aJ8KyKvifbBa8grB_sbHZo,1482
+sphinx_hackerrank/builder.py,sha256=penMdbLG6GUYS6GqVYx4wzkVJs7ybLR2RyO7vGwynDw,4698
+sphinx_hackerrank/html.py,sha256=3tXAL65GkkXsOidB8pWPA4FdVFPDWPY2sgBNnkqMzSc,2246
+sphinx_hackerrank/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sphinx_hackerrank/sections.py,sha256=fhgIY3ZgaIUanBrauXnTONk__-kcimVEKFout48R180,7913
+sphinx_hackerrank/targets.py,sha256=miSc8BtCa4IWt6Tb8Sxh92Iyp1XDXDueTnyH6CLG1mE,2044
+sphinx_hackerrank/static/mini_map.css,sha256=i61odQc_pvKDCtVcHEEVs6UoP9q7I3qbysgx8UzN-ow,616
+sphinx_hackerrank-2026.10.30.1.dist-info/METADATA,sha256=iaa9jzcTpwStOdE20oAB2vlZ-T2R9tLkErcOApLrczk,6296
+sphinx_hackerrank-2026.10.30.1.dist-info/WHEEL,sha256=2iZrJkDIkeDh0k9SikKMqFuRP-ua6mb4Ir1AsER4BEw,87
+sphinx_hackerrank-2026.10.30.1.dist-info/licenses/LICENSE,sha256=hvkADUCIndXpdC1L7yhnIKS99N0Wdtaf9YF06bRgZCo,1065
+sphinx_hackerrank-2026.10.30.1.dist-info/RECORD,,

sphinx_hackerrank-2026.10.30.1.dist-info/WHEEL

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

sphinx_hackerrank-2026.10.30.1.dist-info/licenses/LICENSE

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