pytest-codeblock 0.3.1__py3-none-any.whl

pytest_codeblock/__init__.py

@@ -0,0 +1,26 @@
+from pathlib import Path
+
+from .md import MarkdownFile
+from .rst import RSTFile
+
+__title__ = "pytest-codeblock"
+__version__ = "0.3.1"
+__author__ = "Artur Barseghyan <artur.barseghyan@gmail.com>"
+__copyright__ = "2025 Artur Barseghyan"
+__license__ = "MIT"
+__all__ = (
+    "pytest_collect_file",
+)
+
+
+def pytest_collect_file(parent, path):
+    """Collect .md and .rst files for codeblock tests."""
+    # Determine file extension (works for py.path or pathlib.Path)
+    file_name = str(path).lower()
+    if file_name.endswith((".md", ".markdown")):
+        # Use the MarkdownFile collector for Markdown files
+        return MarkdownFile.from_parent(parent=parent, path=Path(path))
+    if file_name.endswith(".rst"):
+        # Use the RSTFile collector for reStructuredText files
+        return RSTFile.from_parent(parent=parent, path=Path(path))
+    return None

pytest_codeblock/collector.py

@@ -0,0 +1,52 @@
+from dataclasses import dataclass, field
+from typing import Optional
+
+__author__ = "Artur Barseghyan <artur.barseghyan@gmail.com>"
+__copyright__ = "2025 Artur Barseghyan"
+__license__ = "MIT"
+__all__ = (
+    "CodeSnippet",
+    "group_snippets",
+)
+
+
+@dataclass
+class CodeSnippet:
+    """Data container for an extracted code snippet."""
+    code: str  # The code content
+    line: int  # Starting line number in the source
+    name: Optional[str] = None  # Identifier for grouping (None if anonymous)
+    marks: list[str] = field(default_factory=list)
+    # Collected pytest marks (e.g. ['django_db']), parsed from doc comments
+    fixtures: list[str] = field(default_factory=list)
+    # Collected pytest fixtures (e.g. ['tmp_path']), parsed from doc comments
+
+
+def group_snippets(snippets: list[CodeSnippet]) -> list[CodeSnippet]:
+    """
+    Merge snippets with the same name into one CodeSnippet,
+    concatenating their code and accumulating marks.
+    Unnamed snippets get unique auto-names.
+    """
+    combined: list[CodeSnippet] = []
+    seen: dict[str, CodeSnippet] = {}
+    anon_count = 0
+
+    for sn in snippets:
+        key = sn.name
+        if not key:
+            anon_count += 1
+            key = f"codeblock{anon_count}"
+
+        if key in seen:
+            seen_sn = seen[key]
+            seen_sn.code += "\n" + sn.code
+            seen_sn.marks.extend(sn.marks)
+            seen_sn.fixtures.extend(sn.fixtures)
+        else:
+            sn.marks = list(sn.marks)  # copy
+            sn.fixtures = list(sn.fixtures)  # copy
+            seen[key] = sn
+            combined.append(sn)
+
+    return combined

pytest_codeblock/constants.py

@@ -0,0 +1,18 @@
+__author__ = "Artur Barseghyan <artur.barseghyan@gmail.com>"
+__copyright__ = "2025 Artur Barseghyan"
+__license__ = "MIT"
+__all__ = (
+    "CODEBLOCK_MARK",
+    "DJANGO_DB_MARKS",
+    "TEST_PREFIX",
+)
+
+DJANGO_DB_MARKS = {
+    "django_db",
+    "db",
+    "transactional_db",
+}
+
+TEST_PREFIX = "test_"
+
+CODEBLOCK_MARK = "codeblock"

pytest_codeblock/md.py

@@ -0,0 +1,213 @@
+import inspect
+import re
+import textwrap
+import traceback
+from typing import Optional
+
+import pytest
+
+from .collector import CodeSnippet, group_snippets
+from .constants import CODEBLOCK_MARK, DJANGO_DB_MARKS, TEST_PREFIX
+
+__author__ = "Artur Barseghyan <artur.barseghyan@gmail.com>"
+__copyright__ = "2025 Artur Barseghyan"
+__license__ = "MIT"
+__all__ = (
+    "MarkdownFile",
+    "parse_markdown",
+)
+
+
+def parse_markdown(text: str) -> list[CodeSnippet]:
+    """
+    Parse Markdown text and extract Python code snippets as CodeSnippet
+    objects.
+
+    Supports:
+      - <!-- pytestmark: <mark> --> comments immediately before a code fence
+      - <!-- codeblock-name: <name> --> comments for naming
+      - Fenced code blocks with ```python (and optional name=<name> in the
+        info string)
+
+    Captures each snippet’s name, code, starting line, and any pytest marks.
+    """
+    snippets: list[CodeSnippet] = []
+    lines = text.splitlines()
+    pending_name: Optional[str] = None
+    pending_marks: list[str] = [CODEBLOCK_MARK]
+    pending_fixtures: list[str] = []
+    in_block = False
+    fence = ""
+    block_indent = 0
+    code_buffer: list[str] = []
+    snippet_name: Optional[str] = None
+    start_line = 0
+
+    for idx, line in enumerate(lines, start=1):
+        stripped = line.strip()
+
+        if not in_block:
+            # Check for pytest mark comment
+            if stripped.startswith("<!--") and "pytestmark:" in stripped:
+                m = re.match(r"<!--\s*pytestmark:\s*(\w+)\s*-->", stripped)
+                if m:
+                    pending_marks.append(m.group(1))
+                continue
+
+            # Check for pytest fixture comment
+            if stripped.startswith("<!--") and "pytestfixture:" in stripped:
+                m = re.match(r"<!--\s*pytestfixture:\s*(\w+)\s*-->", stripped)
+                if m:
+                    pending_fixtures.append(m.group(1))
+                continue
+
+            # Check for name comment
+            if stripped.startswith("<!--") and "codeblock-name:" in stripped:
+                m = re.match(
+                    r"<!--\s*codeblock-name:\s*([^ >]+)\s*-->", stripped
+                )
+                if m:
+                    pending_name = m.group(1)
+                continue
+
+            # Start of fenced code block?
+            if line.lstrip().startswith("```"):
+                indent = len(line) - len(line.lstrip())
+                m = re.match(r"^`{3,}", line.lstrip())
+                if not m:
+                    continue
+                fence = m.group(0)
+                info = line.lstrip()[len(fence):].strip()
+                parts = info.split(None, 1)
+                lang = parts[0].lower() if parts else ""
+                extra = parts[1] if len(parts) > 1 else ""
+                if lang in ("python", "py", "python3"):
+                    in_block = True
+                    block_indent = indent
+                    start_line = idx + 1
+                    code_buffer = []
+                    # determine name from info string or pending comment
+                    snippet_name = None
+                    for token in extra.split():
+                        if (
+                            token.startswith("name=")
+                            or token.startswith("name:")
+                        ):
+                            snippet_name = (
+                                token.split("=", 1)[-1]
+                                if "=" in token
+                                else token.split(":", 1)[-1]
+                            )
+                            break
+                    if snippet_name is None:
+                        snippet_name = pending_name
+                    # reset pending_name; marks stay until block closes
+                    pending_name = None
+                continue
+
+        else:
+            # inside a fenced code block
+            if line.lstrip().startswith(fence):
+                # end of block
+                in_block = False
+                code_text = "\n".join(code_buffer)
+                snippets.append(CodeSnippet(
+                    name=snippet_name,
+                    code=code_text,
+                    line=start_line,
+                    marks=pending_marks.copy(),
+                    fixtures=pending_fixtures.copy(),
+                ))
+                # reset pending marks after collecting
+                pending_marks.clear()
+                snippet_name = None
+            else:
+                # collect code lines (dedent by block_indent)
+                if line.strip() == "":
+                    code_buffer.append("")
+                else:
+                    if len(line) >= block_indent:
+                        code_buffer.append(line[block_indent:])
+                    else:
+                        code_buffer.append(line.lstrip())
+            continue
+
+    return snippets
+
+
+class MarkdownFile(pytest.File):
+    """
+    Collector for Markdown files, extracting only `test_`-prefixed code
+    snippets.
+    """
+    def collect(self):
+        text = self.path.read_text(encoding="utf-8")
+        raw = parse_markdown(text)
+        # keep only snippets named test_*
+        tests = [
+            sn for sn in raw if sn.name and sn.name.startswith(TEST_PREFIX)
+        ]
+        combined = group_snippets(tests)
+
+        for sn in combined:
+            # Bind the values we need so we don't close over `sn` itself
+            _sn_name = sn.name
+            _fpath = str(self.path)
+
+            # Build list of fixture names requested by this snippet
+            _fixture_names: list[str] = list(sn.fixtures)
+
+            # If snippet is marked as needing DB, also request the `db`
+            # fixture, unless user already added it explicitly.
+            if (
+                DJANGO_DB_MARKS.intersection(sn.marks)
+                and "db" not in _fixture_names
+            ):
+                _fixture_names.append("db")
+
+            # Generate a real pytest Function so fixtures work
+            def make_func(
+                code,
+                sn_name=_sn_name,
+                fpath=_fpath,
+                fixture_names=_fixture_names,
+            ):
+                # This inner function *actually* has a **fixtures signature,
+                # but we override __signature__ so pytest passes the right
+                # fixtures and names.
+                def test_block(**fixtures):
+                    compiled = compile(code, fpath, "exec")
+                    try:
+                        # Make fixtures available as top-level names
+                        # inside the executed snippet.
+                        exec(compiled, dict(fixtures))
+                    except Exception as err:
+                        raise Exception(
+                            f"Error in "
+                            f"codeblock `{sn_name}` in {fpath}:\n"
+                            f"\n{textwrap.indent(code, prefix='    ')}\n\n"
+                            f"{traceback.format_exc()}"
+                        ) from err
+
+                # Tell pytest which fixture arguments this test has:
+                test_block.__signature__ = inspect.Signature(
+                    [
+                        inspect.Parameter(
+                            name,
+                            inspect.Parameter.POSITIONAL_OR_KEYWORD,
+                        )
+                        for name in fixture_names
+                    ]
+                )
+                return test_block
+
+            callobj = make_func(sn.code)
+            fn = pytest.Function.from_parent(
+                parent=self,
+                name=sn.name,
+                callobj=callobj,
+            )
+            # apply any marks (e.g. django_db)
+            for m in sn.marks:
+                fn.add_marker(getattr(pytest.mark, m))
+            yield fn

pytest_codeblock/rst.py

@@ -0,0 +1,352 @@
+import inspect
+import re
+import textwrap
+import traceback
+from pathlib import Path
+from typing import Optional, Union
+
+import pytest
+
+from .collector import CodeSnippet, group_snippets
+from .constants import CODEBLOCK_MARK, DJANGO_DB_MARKS, TEST_PREFIX
+
+__author__ = "Artur Barseghyan <artur.barseghyan@gmail.com>"
+__copyright__ = "2025 Artur Barseghyan"
+__license__ = "MIT"
+__all__ = (
+    "RSTFile",
+    "parse_rst",
+    "resolve_literalinclude_path",
+    "get_literalinclude_content",
+)
+
+
+def resolve_literalinclude_path(
+    base_dir: Union[str, Path],
+    include_path: str,
+) -> Optional[str]:
+    """
+    Resolve the full path for a literalinclude directive.
+    Returns None if the file doesn't exist.
+    """
+    _include_path = Path(include_path)
+
+    # If `include_path` is already absolute or relative and exists, done
+    if _include_path.exists():
+        return str(_include_path.resolve())
+
+    # If base_path is a file, switch to its parent directory
+    _base_path = Path(base_dir)
+    if _base_path.is_file():
+        _base_path = _base_path.parent
+
+    try:
+        full_path = _base_path / include_path
+        if full_path.exists():
+            return str(full_path.resolve())
+    except Exception:
+        pass
+    return None
+
+
+def get_literalinclude_content(path):
+    try:
+        with open(path) as f:
+            return f.read()
+    except Exception as e:
+        raise RuntimeError(
+            f"Failed to read literalinclude file {path}: {e}"
+        ) from e
+
+
+def parse_rst(text: str, base_dir: Path) -> list[CodeSnippet]:
+    """
+    Parse an RST document into CodeSnippet objects, capturing:
+      - .. pytestmark: <mark>
+      - .. continue: <name>
+      - .. codeblock-name: <name>
+      - .. code-block:: python
+    """
+    snippets: list[CodeSnippet] = []
+    lines = text.splitlines()
+    n = len(lines)
+
+    pending_name: Optional[str] = None
+    pending_marks: list[str] = [CODEBLOCK_MARK]
+    pending_fixtures: list[str] = []
+    pending_continue: Optional[str] = None
+    i = 0
+
+    while i < n:
+        line = lines[i]
+
+        # --------------------------------------------------------------------
+        # Collect `.. pytestmark: xyz`
+        # --------------------------------------------------------------------
+        m = re.match(r"^\s*\.\.\s*pytestmark:\s*(\w+)\s*$", line)
+        if m:
+            pending_marks.append(m.group(1))
+            i += 1
+            continue
+
+        # --------------------------------------------------------------------
+        # Collect `.. pytestfixture: foo`
+        # --------------------------------------------------------------------
+        m = re.match(r"^\s*\.\.\s*pytestfixture:\s*(\w+)\s*$", line)
+        if m:
+            pending_fixtures.append(m.group(1))
+            i += 1
+            continue
+
+        # --------------------------------------------------------------------
+        # The `.. literalinclude` directive
+        # --------------------------------------------------------------------
+        if line.strip().startswith(".. literalinclude::"):
+            path = line.split(".. literalinclude::", 1)[1].strip()
+            name = None
+
+            # Look ahead for name
+            j = i + 1
+            while j < len(lines) and lines[j].strip():
+                if ":name:" in lines[j]:
+                    name = lines[j].split(":name:", 1)[1].strip()
+                    break
+                j += 1
+
+            if name and name.startswith("test_"):
+                full_path = resolve_literalinclude_path(base_dir, path)
+                if full_path:
+                    snippet = CodeSnippet(
+                        code=get_literalinclude_content(full_path),
+                        line=i + 1,
+                        name=name,
+                        marks=pending_marks.copy(),
+                        fixtures=pending_fixtures.copy(),
+                    )
+                    snippets.append(snippet)
+
+                    # TODO: Is this needed?
+                    # pending_marks.clear()
+                    # pending_fixtures.clear()
+
+            i = j + 1
+            continue
+
+        # --------------------------------------------------------------------
+        # Collect `.. continue: foo`
+        # --------------------------------------------------------------------
+        m = re.match(r"^\s*\.\.\s*continue:\s*(\S+)\s*$", line)
+        if m:
+            pending_continue = m.group(1)
+            i += 1
+            continue
+
+        # --------------------------------------------------------------------
+        # Collect `.. codeblock-name: foo`
+        # --------------------------------------------------------------------
+        m = re.match(r"^\s*\.\.\s*codeblock-name:\s*(\S+)\s*$", line)
+        if m:
+            pending_name = m.group(1)
+            i += 1
+            continue
+
+        # --------------------------------------------------------------------
+        # The `.. code-block` directive
+        # --------------------------------------------------------------------
+        m = re.match(r"^(\s*)\.\. (?:code-block|code)::\s*(\w+)", line)
+        if m:
+            base_indent = len(m.group(1))
+            lang = m.group(2).lower()
+            if lang in ("python", "py", "python3"):
+                # Parse :name: option
+                name_val: Optional[str] = None
+                j = i + 1
+                while j < n:
+                    ln = lines[j]
+                    if not ln.strip():
+                        j += 1
+                        continue
+                    indent = len(ln) - len(ln.lstrip())
+                    if ln.lstrip().startswith(":") and indent > base_indent:
+                        opt = ln.lstrip()
+                        if opt.lower().startswith(":name:"):
+                            name_val = opt.split(":", 2)[2].strip().split()[0]
+                        j += 1
+                        continue
+                    break
+                # The j is first code line
+                if j >= n:
+                    i = j
+                    continue
+                first = lines[j]
+                content_indent = len(first) - len(first.lstrip())
+                if content_indent <= base_indent:
+                    i = j
+                    continue
+                # Collect code
+                buf: list[str] = []
+                k = j
+                while k < n:
+                    ln = lines[k]
+                    if not ln.strip():
+                        buf.append("")
+                        k += 1
+                        continue
+                    ind = len(ln) - len(ln.lstrip())
+                    if ind >= content_indent:
+                        buf.append(ln[content_indent:])
+                        k += 1
+                    else:
+                        break
+                # Decide snippet name: continue overrides name_val/pending_name
+                if pending_continue:
+                    sn_name = pending_continue
+                    pending_continue = None
+                else:
+                    sn_name = name_val or pending_name
+                sn_marks = pending_marks.copy()
+                sn_fixtures = pending_fixtures.copy()
+                pending_name = None
+                pending_marks.clear()
+                pending_fixtures.clear()
+
+                snippets.append(CodeSnippet(
+                    name=sn_name,
+                    code="\n".join(buf),
+                    line=j + 1,
+                    marks=sn_marks,
+                    fixtures=sn_fixtures,
+                ))
+
+                i = k
+                continue
+            else:
+                i += 1
+                continue
+
+        # --------------------------------------------------------------------
+        # The literal-block via "::"
+        # --------------------------------------------------------------------
+        if line.rstrip().endswith("::") and pending_name:
+            # Similar override logic
+            if pending_continue:
+                sn_name = pending_continue
+                pending_continue = None
+            else:
+                sn_name = pending_name
+            sn_marks = pending_marks.copy()
+            sn_fixtures = pending_fixtures.copy()
+            pending_name = None
+            pending_marks.clear()
+            pending_fixtures.clear()
+            j = i + 1
+            if j < n and not lines[j].strip():
+                j += 1
+            if j >= n:
+                i = j
+                continue
+            first = lines[j]
+            content_indent = len(first) - len(first.lstrip())
+            buf: list[str] = []
+            k = j
+            while k < n:
+                ln = lines[k]
+                if not ln.strip():
+                    buf.append("")
+                    k += 1
+                    continue
+                ind = len(ln) - len(ln.lstrip())
+                if ind >= content_indent:
+                    buf.append(ln[content_indent:])
+                    k += 1
+                else:
+                    break
+            snippets.append(CodeSnippet(
+                name=sn_name,
+                code="\n".join(buf),
+                line=j + 1,
+                marks=sn_marks,
+                fixtures=sn_fixtures,
+            ))
+            i = k
+            continue
+
+        i += 1
+
+    return snippets
+
+
+class RSTFile(pytest.File):
+    """Collect RST code-block tests as real test functions."""
+    def collect(self):
+        text = self.path.read_text(encoding="utf-8")
+        raw = parse_rst(text, self.path)
+
+        # Only keep test_* snippets
+        tests = [
+            sn for sn in raw if sn.name and sn.name.startswith(TEST_PREFIX)
+        ]
+        combined = group_snippets(tests)
+
+        for sn in combined:
+            # Bind the values we need so we don't close over `sn` itself
+            _sn_name = sn.name
+            _fpath = str(self.path)
+
+            # Build list of fixture names requested by this snippet
+            _fixture_names: list[str] = list(sn.fixtures)
+
+            # If snippet is marked as needing DB, also request the `db`
+            # fixture, unless user already added it explicitly.
+            if (
+                DJANGO_DB_MARKS.intersection(sn.marks)
+                and "db" not in _fixture_names
+            ):
+                _fixture_names.append("db")
+
+            def make_func(
+                code,
+                sn_name=_sn_name,
+                fpath=_fpath,
+                fixture_names=_fixture_names,
+            ):
+                # This inner function *actually* has a **fixtures signature,
+                # but we override __signature__ so pytest passes the right
+                # fixtures and names.
+                def test_block(**fixtures):
+                    compiled = compile(code, fpath, "exec")
+                    try:
+                        # Make fixtures available as top-level names
+                        # inside the executed snippet.
+                        exec(compiled, dict(fixtures))
+                    except Exception as err:
+                        raise Exception(
+                            f"Error in "
+                            f"codeblock `{sn_name}` in {fpath}:\n"
+                            f"\n{textwrap.indent(code, prefix='    ')}\n\n"
+                            f"{traceback.format_exc()}"
+                        ) from err
+
+                # Tell pytest which fixture arguments this test has:
+                test_block.__signature__ = inspect.Signature(
+                    [
+                        inspect.Parameter(
+                            name,
+                            inspect.Parameter.POSITIONAL_OR_KEYWORD,
+                        )
+                        for name in fixture_names
+                    ]
+                )
+                return test_block
+
+            callobj = make_func(sn.code)
+
+            fn = pytest.Function.from_parent(
+                parent=self,
+                name=sn.name,
+                callobj=callobj
+            )
+            # Re-apply any pytest.mark.<foo> markers
+            for m in sn.marks:
+                fn.add_marker(getattr(pytest.mark, m))
+            yield fn

pytest_codeblock/tests/test_pytest_codeblock.py

@@ -0,0 +1,121 @@
+from pytest_codeblock.collector import CodeSnippet, group_snippets
+from pytest_codeblock.md import parse_markdown
+from pytest_codeblock.rst import (
+    get_literalinclude_content,
+    parse_rst,
+    resolve_literalinclude_path,
+)
+
+__author__ = "Artur Barseghyan <artur.barseghyan@gmail.com>"
+__copyright__ = "2025 Artur Barseghyan"
+__license__ = "MIT"
+__all__ = (
+    "test_group_snippets_different_names",
+    "test_group_snippets_merges_named",
+    "test_parse_markdown_simple",
+    "test_parse_markdown_with_pytestmark",
+    "test_parse_rst_literalinclude",
+    "test_parse_rst_simple",
+    "test_resolve_literalinclude_and_content",
+)
+
+
+def test_group_snippets_merges_named():
+    # Two snippets with the same name should be combined
+    sn1 = CodeSnippet(name="foo", code="a=1", line=1, marks=["codeblock"])
+    sn2 = CodeSnippet(name="foo", code="b=2", line=2, marks=["codeblock", "m"])
+    combined = group_snippets([sn1, sn2])
+    assert len(combined) == 1
+    cs = combined[0]
+    assert cs.name == "foo"
+    # Both code parts should appear
+    assert "a=1" in cs.code
+    assert "b=2" in cs.code
+    # Marks should accumulate
+    assert "m" in cs.marks
+
+
+def test_group_snippets_different_names():
+    # Snippets with different names are not grouped
+    sn1 = CodeSnippet(name="foo", code="x=1", line=1)
+    sn2 = CodeSnippet(name="bar", code="y=2", line=2)
+    combined = group_snippets([sn1, sn2])
+    assert len(combined) == 2
+    assert combined[0].name.startswith("foo")
+    assert combined[1].name.startswith("bar")
+
+
+def test_parse_markdown_simple():
+    text = """
+```python name=test_example
+x=1
+assert x==1
+```"""
+    snippets = parse_markdown(text)
+    assert len(snippets) == 1
+    sn = snippets[0]
+    assert sn.name == "test_example"
+    assert "x=1" in sn.code
+
+
+def test_parse_markdown_with_pytestmark():
+    text = """
+<!-- pytestmark: django_db -->
+```python name=test_db
+from django.db import models
+```"""
+    snippets = parse_markdown(text)
+    assert len(snippets) == 1
+    sn = snippets[0]
+    # Should include both default and django_db marks
+    assert "django_db" in sn.marks
+    assert "codeblock" in sn.marks
+
+
+def test_resolve_literalinclude_and_content(tmp_path):
+    base = tmp_path / "dir"
+    base.mkdir()
+    file = base / "a.py"
+    file.write_text("print('hello')")
+    # Absolute path resolution
+    abs_path = resolve_literalinclude_path(base, str(file))
+    assert abs_path == str(file.resolve())
+    # Relative path resolution
+    rel_path = resolve_literalinclude_path(base, "a.py")
+    assert rel_path == str(file.resolve())
+    # Content read
+    content = get_literalinclude_content(str(file))
+    assert content == "print('hello')"
+
+
+def test_parse_rst_simple(tmp_path):
+    # Basic code-block directive
+    rst = """
+.. code-block:: python
+   :name: test_simple
+
+   a=2
+   assert a==2
+"""
+    snippets = parse_rst(rst, tmp_path)
+    assert len(snippets) == 1
+    sn = snippets[0]
+    assert sn.name == "test_simple"
+    assert "a=2" in sn.code
+
+
+def test_parse_rst_literalinclude(tmp_path):
+    # Create an external file to include
+    include_dir = tmp_path / "inc"
+    include_dir.mkdir()
+    target = include_dir / "foo.py"
+    target.write_text("z=3\nassert z==3")
+    rst = f"""
+.. literalinclude:: {target.name}
+   :name: test_li
+"""
+    snippets = parse_rst(rst, include_dir)
+    assert len(snippets) == 1
+    sn = snippets[0]
+    assert sn.name == "test_li"
+    assert "z=3" in sn.code

pytest_codeblock-0.3.1.dist-info/METADATA

@@ -0,0 +1,301 @@
+Metadata-Version: 2.4
+Name: pytest-codeblock
+Version: 0.3.1
+Summary: Pytest plugin to collect and test code blocks in reStructuredText and Markdown files.
+Author-email: Artur Barseghyan <artur.barseghyan@gmail.com>
+Maintainer-email: Artur Barseghyan <artur.barseghyan@gmail.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/barseghyanartur/pytest-codeblock/
+Project-URL: Repository, https://github.com/barseghyanartur/pytest-codeblock/
+Project-URL: Issues, https://github.com/barseghyanartur/pytest-codeblock/issues
+Project-URL: Documentation, https://pytest-codeblock.readthedocs.io/
+Project-URL: Changelog, https://pytest-codeblock.readthedocs.io/en/latest/changelog.html
+Keywords: pytest,plugin,documentation,code blocks,markdown,rst
+Classifier: Framework :: Pytest
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+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
+Classifier: Topic :: Software Development :: Testing
+Classifier: Topic :: Software Development
+Requires-Python: >=3.9
+Description-Content-Type: text/x-rst
+License-File: LICENSE
+Requires-Dist: pytest
+Provides-Extra: all
+Requires-Dist: pytest-codeblock[build,dev,docs,test]; extra == "all"
+Provides-Extra: dev
+Requires-Dist: detect-secrets; extra == "dev"
+Requires-Dist: doc8; extra == "dev"
+Requires-Dist: ipython; extra == "dev"
+Requires-Dist: mypy; extra == "dev"
+Requires-Dist: pydoclint; extra == "dev"
+Requires-Dist: ruff; extra == "dev"
+Requires-Dist: twine; extra == "dev"
+Requires-Dist: uv; extra == "dev"
+Provides-Extra: test
+Requires-Dist: django; extra == "test"
+Requires-Dist: fake.py; extra == "test"
+Requires-Dist: moto[s3]; extra == "test"
+Requires-Dist: openai; extra == "test"
+Requires-Dist: pytest; extra == "test"
+Requires-Dist: pytest-cov; extra == "test"
+Requires-Dist: pytest-django; extra == "test"
+Provides-Extra: docs
+Requires-Dist: sphinx<6.0; extra == "docs"
+Requires-Dist: sphinx-autobuild; extra == "docs"
+Requires-Dist: sphinx-rtd-theme>=1.3.0; extra == "docs"
+Requires-Dist: sphinx-no-pragma; extra == "docs"
+Requires-Dist: sphinx-llms-txt-link; extra == "docs"
+Provides-Extra: build
+Requires-Dist: build; extra == "build"
+Requires-Dist: twine; extra == "build"
+Requires-Dist: wheel; extra == "build"
+Dynamic: license-file
+
+================
+pytest-codeblock
+================
+
+.. External references
+.. _reStructuredText: https://docutils.sourceforge.io/rst.html
+.. _Markdown: https://daringfireball.net/projects/markdown/
+.. _pytest: https://docs.pytest.org
+.. _Django: https://www.djangoproject.com
+.. _pip: https://pypi.org/project/pip/
+.. _uv: https://pypi.org/project/uv/
+.. _fake.py: https://github.com/barseghyanartur/fake.py
+.. _boto3: https://github.com/boto/boto3
+.. _moto: https://github.com/getmoto/moto
+.. _openai: https://github.com/openai/openai-python
+.. _Ollama: https://github.com/ollama/ollama
+
+.. Internal references
+
+.. _pytest-codeblock: https://github.com/barseghyanartur/pytest-codeblock/
+.. _Read the Docs: http://pytest-codeblock.readthedocs.io/
+.. _Examples: https://github.com/barseghyanartur/pytest-codeblock/tree/main/examples
+.. _Contributor guidelines: https://pytest-codeblock.readthedocs.io/en/latest/contributor_guidelines.html
+.. _reStructuredText docs: https://pytest-codeblock.readthedocs.io/en/latest/restructured_text.html
+.. _Markdown docs: https://pytest-codeblock.readthedocs.io/en/latest/markdown.html
+.. _llms.txt: https://barseghyanartur.github.io/pytest-codeblock/llms.txt
+
+Test your documentation code blocks.
+
+.. image:: https://img.shields.io/pypi/v/pytest-codeblock.svg
+   :target: https://pypi.python.org/pypi/pytest-codeblock
+   :alt: PyPI Version
+
+.. image:: https://img.shields.io/pypi/pyversions/pytest-codeblock.svg
+    :target: https://pypi.python.org/pypi/pytest-codeblock/
+    :alt: Supported Python versions
+
+.. image:: https://github.com/barseghyanartur/pytest-codeblock/actions/workflows/test.yml/badge.svg?branch=main
+   :target: https://github.com/barseghyanartur/pytest-codeblock/actions
+   :alt: Build Status
+
+.. image:: https://readthedocs.org/projects/pytest-codeblock/badge/?version=latest
+    :target: http://pytest-codeblock.readthedocs.io
+    :alt: Documentation Status
+
+.. image:: https://img.shields.io/badge/docs-llms.txt-blue
+    :target: http://pytest-codeblock.readthedocs.io/en/latest/llms.txt
+    :alt: llms.txt - documentation for LLMs
+
+.. image:: https://img.shields.io/badge/license-MIT-blue.svg
+   :target: https://github.com/barseghyanartur/pytest-codeblock/#License
+   :alt: MIT
+
+.. image:: https://coveralls.io/repos/github/barseghyanartur/pytest-codeblock/badge.svg?branch=main&service=github
+    :target: https://coveralls.io/github/barseghyanartur/pytest-codeblock?branch=main
+    :alt: Coverage
+
+`pytest-codeblock`_ is a `Pytest`_ plugin that discovers Python code examples
+in your `reStructuredText`_ and `Markdown`_ documentation files and runs them
+as part of your test suite. This ensures your docs stay correct and up-to-date.
+
+Features
+========
+
+- **reStructuredText and Markdown support**: Automatically find and test code
+  blocks in `reStructuredText`_ (``.rst``) and `Markdown`_ (``.md``) files.
+  The only requirement here is that your code blocks shall
+  have a name starting with ``test_``.
+- **Grouping by name**: Split a single example across multiple code blocks;
+  the plugin concatenates them into one test.
+- **Pytest markers support**: Add existing or custom `pytest`_ markers
+  to the code blocks and hook into the tests life-cycle using ``conftest.py``.
+- **Pytest fixtures support**: Request existing or custom `pytest`_ fixtures
+  for the code blocks.
+
+Prerequisites
+=============
+- Python 3.9+
+- `pytest`_ is the only required dependency
+
+Documentation
+=============
+- Documentation is available on `Read the Docs`_.
+- For `reStructuredText`_, see a dedicated `reStructuredText docs`_.
+- For `Markdown`_, see a dedicated `Markdown docs`_.
+- Both `reStructuredText docs`_ and `Markdown docs`_ have extensive
+  documentation on `pytest`_ markers and corresponding ``conftest.py`` hooks.
+- For guidelines on contributing check the `Contributor guidelines`_.
+
+Installation
+============
+
+Install with `pip`_:
+
+.. code-block:: sh
+
+    pip install pytest-codeblock
+
+Or install with `uv`_:
+
+.. code-block:: sh
+
+    uv pip install pytest-codeblock
+
+.. _configuration:
+
+Configuration
+=============
+No configuration needed. All your `.rst` and `.md` files shall be picked
+automatically.
+
+Usage
+=====
+reStructruredText usage
+-----------------------
+Any code directive, such as ``.. code-block:: python``, ``.. code:: python``,
+or literal blocks with a preceding ``.. codeblock-name: <name>``, will be
+collected and executed automatically by `pytest`_.
+
+``code-block`` directive example
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+.. note:: Note that ``:name:`` value has a ``test_`` prefix.
+
+*Filename: README.rst*
+
+.. code-block:: rst
+
+    .. code-block:: python
+       :name: test_basic_example
+
+       import math
+
+       result = math.pow(3, 2)
+       assert result == 9
+
+
+``literalinclude`` directive example
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+.. note:: Note that ``:name:`` value has a ``test_`` prefix.
+
+*Filename: README.rst*
+
+.. code-block:: rst
+
+    .. literalinclude:: examples/python/basic_example.py
+        :name: test_li_basic_example
+
+See a dedicated `reStructuredText docs`_ for more.
+
+Markdown usage
+--------------
+
+Any fenced code block with a recognized Python language tag (e.g., ``python``,
+``py``) will be collected and executed automatically by `pytest`_.
+
+.. note:: Note that ``name`` value has a ``test_`` prefix.
+
+*Filename: README.md*
+
+.. code-block:: markdown
+
+    ```python name=test_basic_example
+    import math
+
+    result = math.pow(3, 2)
+    assert result == 9
+    ```
+
+See a dedicated `Markdown docs`_ for more.
+
+Tests
+=====
+
+Run the tests with `pytest`_:
+
+.. code-block:: sh
+
+    pytest
+
+Troubleshooting
+===============
+If something doesn't work, try to add this to your pyproject.toml:
+
+*Filename: pyproject.toml*
+
+.. code-block:: text
+
+    [tool.pytest.ini_options]
+    testpaths = [
+        "**/*.rst",
+        "**/*.md",
+    ]
+
+Writing documentation
+=====================
+
+Keep the following hierarchy.
+
+.. code-block:: text
+
+    =====
+    title
+    =====
+
+    header
+    ======
+
+    sub-header
+    ----------
+
+    sub-sub-header
+    ~~~~~~~~~~~~~~
+
+    sub-sub-sub-header
+    ^^^^^^^^^^^^^^^^^^
+
+    sub-sub-sub-sub-header
+    ++++++++++++++++++++++
+
+    sub-sub-sub-sub-sub-header
+    **************************
+
+License
+=======
+
+MIT
+
+Support
+=======
+For security issues contact me at the e-mail given in the `Author`_ section.
+
+For overall issues, go
+to `GitHub <https://github.com/barseghyanartur/pytest-codeblock/issues>`_.
+
+Author
+======
+
+Artur Barseghyan <artur.barseghyan@gmail.com>

pytest_codeblock-0.3.1.dist-info/RECORD

@@ -0,0 +1,13 @@
+pytest_codeblock/__init__.py,sha256=pkjBUtLIFIZ5Nj_xIT36AG1-GdScfD78BBv94MtQ5wo,858
+pytest_codeblock/collector.py,sha256=uepTklmwM-zhH4cKCaOHr63Y7oyg_tjFdoQVsy3oSxg,1618
+pytest_codeblock/constants.py,sha256=Bpr0B0uHAJOaOmoSO9v_xr1FkV_8KJ0-TfP3hEmmdbw,326
+pytest_codeblock/md.py,sha256=8P3fqqzKDjcfW5Zx7-zYmtSRG9BMUOzHSQuBMjr-F9s,7807
+pytest_codeblock/rst.py,sha256=WbnofvWASEhPHq6wO1Qfa4fYFhOh4Hq3zs1tMU7T5rQ,12163
+pytest_codeblock/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pytest_codeblock/tests/test_pytest_codeblock.py,sha256=JmrV6rD4kppzunBSAp3FoweoiA0zOUtneYTFXdwYj90,3451
+pytest_codeblock-0.3.1.dist-info/licenses/LICENSE,sha256=dOWhRtenNzp0haV2LO9YRYb_-GCmPdwVJeTZ4MarauY,1073
+pytest_codeblock-0.3.1.dist-info/METADATA,sha256=tcASyLxRDME3qY9lWkmkaUMEzQh0NzeNDi7bQHRbdTA,9131
+pytest_codeblock-0.3.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+pytest_codeblock-0.3.1.dist-info/entry_points.txt,sha256=jWxHxGWLzT4XZBSUMZ0aUnyDzOaDyjf-KnAIsYgObm0,47
+pytest_codeblock-0.3.1.dist-info/top_level.txt,sha256=H2HyfKDFEj_5vWkbB6qITEjB-YgKfDxCPpIt_983K4g,17
+pytest_codeblock-0.3.1.dist-info/RECORD,,

pytest_codeblock-0.3.1.dist-info/WHEEL

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

pytest_codeblock-0.3.1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[pytest11]
+pytest_codeblock = pytest_codeblock

pytest_codeblock-0.3.1.dist-info/licenses/LICENSE

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

pytest_codeblock-0.3.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+pytest_codeblock