msra-codegen 0.1.0__py3-none-any.whl

msra_codegen/templates/abstraction/__init__.py.tpl

@@ -0,0 +1,188 @@
+from human_requests.abstraction import Output as _Output
+
+{% if has_regexes %}
+{% for regex in regexes %}
+from .regexes import {{ regex.class_name }} as _{{ regex.class_name }}
+{% endfor %}
+{% endif %}
+{% if external_modules %}
+from collections.abc import Mapping
+from dataclasses import fields, is_dataclass
+from typing import Any
+
+from pydantic import BaseModel
+
+{% for import_line in external_import_lines %}
+{{ import_line }}
+{% endfor %}
+{% endif %}
+
+Output = _Output
+{% if has_regexes %}
+{% for regex in regexes %}
+{{ regex.class_name }} = _{{ regex.class_name }}
+{% endfor %}
+{% endif %}
+
+__all__ = [
+    "Output",
+{% for regex in regexes %}
+    "{{ regex.class_name }}",
+{% endfor %}
+{% if external_modules %}
+{% for module in external_modules %}
+{% for class_name in module.public_class_names %}
+    "{{ class_name }}",
+{% endfor %}
+{% endfor %}
+{% endif %}
+]
+{% if external_modules %}
+
+SCALAR_TYPES = (str, int, float, bool, bytes, type(None))
+CONTAINER_TYPES = (Mapping, list, tuple, set)
+
+
+def normalize(value: Any) -> Any:
+    if isinstance(value, BaseModel):
+        return value.model_dump()
+    return value
+
+
+def is_leaf(value: Any) -> bool:
+    value = normalize(value)
+    return isinstance(value, SCALAR_TYPES + CONTAINER_TYPES)
+
+
+def public_children_with_names(obj: Any) -> list[tuple[str, Any]]:
+    result: list[tuple[str, Any]] = []
+
+    if isinstance(obj, type):
+        for name, value in vars(obj).items():
+            if name.startswith("_"):
+                continue
+            if isinstance(value, (staticmethod, classmethod)):
+                continue
+            if callable(value) and not isinstance(value, type):
+                continue
+            result.append((name, value))
+        return result
+
+    if isinstance(obj, BaseModel):
+        return []
+
+    if is_dataclass(obj) and not isinstance(obj, type):
+        for field in fields(obj):
+            if field.name.startswith("_"):
+                continue
+            result.append((field.name, getattr(obj, field.name)))
+
+    if hasattr(obj, "__dict__"):
+        for name, value in vars(obj).items():
+            if name.startswith("_"):
+                continue
+            if callable(value):
+                continue
+            result.append((name, value))
+
+    for name, descriptor in vars(type(obj)).items():
+        if name.startswith("_"):
+            continue
+        if isinstance(descriptor, property):
+            result.append((name, getattr(obj, name)))
+
+    return result
+
+
+def registry_display_name(value: Any) -> str:
+    if isinstance(value, type):
+        return value.__qualname__.replace("<locals>.", "")
+    return type(value).__qualname__.replace("<locals>.", "")
+
+
+def collect_allowed_value_paths(parent: Any) -> list[str]:
+    result: list[str] = []
+    seen: set[int] = set()
+
+    def walk(value: Any, path: list[str]) -> None:
+        value = normalize(value)
+        if is_leaf(value):
+            result.append(".".join(path))
+            return
+        value_id = id(value)
+        if value_id in seen:
+            return
+        seen.add(value_id)
+        children = public_children_with_names(value)
+        if not children:
+            result.append(".".join(path))
+            return
+        for child_name, child_value in children:
+            walk(child_value, [*path, child_name])
+
+    walk(parent, [registry_display_name(parent)])
+    return result
+
+
+def collect_allowed_values(parent: Any) -> list[Any]:
+    result: list[Any] = []
+    seen: set[int] = set()
+
+    def walk(value: Any) -> None:
+        value = normalize(value)
+        if is_leaf(value):
+            result.append(value)
+            return
+        value_id = id(value)
+        if value_id in seen:
+            return
+        seen.add(value_id)
+        for _, child_value in public_children_with_names(value):
+            walk(child_value)
+
+    walk(parent)
+    return result
+
+
+def is_allowed_value(value: Any, parent: Any) -> bool:
+    value = normalize(value)
+    return value in collect_allowed_values(parent)
+
+
+def find_registry_path(parent: Any, target: Any) -> str | None:
+    seen: set[int] = set()
+
+    def walk(value: Any, path: list[str]) -> str | None:
+        if value is target:
+            return ".".join(path)
+        value = normalize(value)
+        if is_leaf(value):
+            return None
+        value_id = id(value)
+        if value_id in seen:
+            return None
+        seen.add(value_id)
+        for child_name, child_value in public_children_with_names(value):
+            found = walk(child_value, [*path, child_name])
+            if found is not None:
+                return found
+        return None
+
+    return walk(parent, [registry_display_name(parent)])
+
+
+def validate_allowed_value(value: Any, parent: Any) -> Any:
+    value = normalize(value)
+    allowed = collect_allowed_values(parent)
+    if value in allowed:
+        return value
+    if not is_leaf(value):
+        value_path = find_registry_path(parent, value) or registry_display_name(value)
+        allowed_paths = collect_allowed_value_paths(parent)
+        raise ValueError(
+            f"{value_path} is a value registry, not a value.\n"
+            "Use one of:\n"
+            + "\n".join(f"- {path}" for path in allowed_paths)
+        )
+    raise ValueError(f"Invalid value {value!r}. Allowed values: {allowed!r}")
+{% endif %}

msra_codegen/templates/abstraction/regexes.py.tpl

@@ -0,0 +1,25 @@
+from typing import Any
+import re
+
+
+class RegexBase:
+    REGEX = r""
+    ERROR: str | None = None
+
+    @classmethod
+    def match(cls, value: Any) -> bool:
+        return re.fullmatch(cls.REGEX, str(value)) is not None
+
+
+{% for regex in regexes %}
+class {{ regex.class_name }}(RegexBase):
+{% if regex.description %}
+    """{{ regex.description }}"""
+{% endif %}
+    REGEX = r"{{ regex.pattern }}"
+{% if regex.raise_message is not none %}
+    ERROR = {{ regex.raise_message }}
+{% endif %}
+
+
+{% endfor %}

msra_codegen/templates/docs/requirements.txt.tpl

@@ -0,0 +1,3 @@
+sphinx
+furo
+jsoncrack-for-sphinx

msra_codegen/templates/docs/source/Makefile.tpl

@@ -0,0 +1,20 @@
+# Minimal makefile for Sphinx documentation
+#
+
+# You can set these variables from the command line, and also
+# from the environment for the first two.
+SPHINXOPTS    ?=
+SPHINXBUILD   ?= sphinx-build
+SOURCEDIR     = .
+BUILDDIR      = _build
+
+# Put it first so that "make" without argument is like "make help".
+help:
+	@$(SPHINXBUILD) -M help "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O)
+
+.PHONY: help Makefile
+
+# Catch-all target: route all unknown targets to Sphinx using the new
+# "make mode" option.  $(O) is meant as a shortcut for $(SPHINXOPTS).
+%: Makefile
+	@$(SPHINXBUILD) -M $@ "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O)

msra_codegen/templates/docs/source/api.rst.tpl

@@ -0,0 +1,9 @@
+API Reference
+=============
+
+.. toctree::
+   :maxdepth: 1
+
+{% for docname in api_docnames %}
+   {{ docname }}
+{% endfor %}

msra_codegen/templates/docs/source/conf.py.tpl

@@ -0,0 +1,88 @@
+from __future__ import annotations
+
+import os
+import sys
+from pathlib import Path
+
+HERE = Path(__file__).resolve().parent
+REPO_ROOT = HERE.parents[1]
+sys.path.insert(0, str(REPO_ROOT))
+
+project = "{{ project_name }}"
+author = "Miskler"
+copyright = "{{ current_year }}, Miskler"
+
+
+def _get_version() -> str:
+    for key in ("PROJECT_VERSION", "READTHEDOCS_VERSION", "VERSION"):
+        if os.getenv(key):
+            return os.environ[key]
+    try:
+        from importlib.metadata import version
+
+        return version("{{ package_name }}")
+    except Exception:
+        return "{{ project_version }}"
+
+
+release = _get_version()
+version = ".".join(release.split(".")[:3])
+
+extensions = [
+    "sphinx.ext.autodoc",
+    "sphinx.ext.autosummary",
+    "sphinx.ext.napoleon",
+    "sphinx.ext.intersphinx",
+    "sphinx.ext.viewcode",
+    "sphinx.ext.doctest",
+    "sphinx.ext.duration",
+    "jsoncrack_for_sphinx",
+]
+
+autodoc_mock_imports = [
+    "aiohttp",
+    "aiohttp_retry",
+    "camoufox",
+    "playwright",
+    "playwright.async_api",
+    "PIL",
+]
+
+source_suffix = {
+    ".rst": "restructuredtext",
+}
+
+autosummary_generate = False
+autosummary_imported_members = True
+autosummary_ignore_module_all = False
+
+autodoc_default_options = {}
+autodoc_typehints = "signature"
+autodoc_preserve_defaults = True
+
+add_module_names = False
+python_use_unqualified_type_names = True
+multi_line_parameter_list = True
+python_maximum_signature_line_length = 80
+default_role = "any"
+
+intersphinx_mapping = {
+    "python": ("https://docs.python.org/3", None),
+    "human_requests": ("https://miskler.github.io/human-requests/", None),
+}
+
+json_schema_dir = str(HERE.parents[2] / "tests" / "__snapshots__")
+
+html_theme = "furo"
+html_static_path = ["_static"]
+templates_path = ["_templates"]
+
+html_theme_options = {
+    "sidebar_hide_name": True,
+{% if logo %}
+    "light_logo": "{{ logo.light_name }}",
+    "dark_logo": "{{ logo.dark_name }}",
+{% endif %}
+}
+
+exclude_patterns = ["_build", "Thumbs.db", ".DS_Store"]

msra_codegen/templates/docs/source/index.rst.tpl

@@ -0,0 +1,14 @@
+{{ title }}
+{{ title_underline }}
+
+.. toctree::
+   :maxdepth: 4
+   :caption: Basic use
+
+   quick_start
+
+.. toctree::
+   :maxdepth: 4
+   :caption: References
+
+   api

msra_codegen/templates/docs/source/module.rst.tpl

@@ -0,0 +1,34 @@
+{{ title }}
+{{ title_underline }}
+
+{% if description %}
+{{ description }}
+
+{% endif %}
+.. currentmodule:: {{ import_path }}
+
+.. automodule:: {{ import_path }}
+
+{% if class_names %}
+.. rubric:: Classes
+
+{% for class_name in class_names %}
+.. autoclass:: {{ class_name }}
+   :members:
+   :undoc-members:
+   :show-inheritance:
+
+{% endfor %}
+
+{% endif %}
+{% if child_pages %}
+.. rubric:: Submodules
+
+.. toctree::
+   :maxdepth: 1
+
+{% for child_docname in child_docnames %}
+   {{ child_docname }}
+{% endfor %}
+
+{% endif %}

msra_codegen/templates/docs/source/quick_start.rst.tpl

@@ -0,0 +1,19 @@
+{{ quick_start.title }}
+{{ quick_start.title_underline }}
+
+Install the generated client:
+
+.. code-block:: console
+
+    pip install {{ package_name }}
+{% if quick_start.requires_camoufox %}
+    python -m camoufox fetch
+{% endif %}
+
+Import the client:
+
+.. code-block:: python
+
+{{ pipeline_script_code_rst }}
+
+The public API is documented in :doc:`api`.

msra_codegen/templates/endpoints_init.py.tpl

@@ -0,0 +1,15 @@
+{% if top_groups %}
+{% for group in top_groups %}
+from . import {{ group.package_name }} as _{{ group.package_name }}
+{% endfor %}
+
+{% for group in top_groups %}
+{{ group.class_name }} = _{{ group.package_name }}.{{ group.class_name }}
+{% endfor %}
+{% endif %}
+
+__all__ = [
+{% for group in top_groups %}
+    "{{ group.class_name }}",
+{% endfor %}
+]

msra_codegen/templates/example.py.tpl

@@ -0,0 +1 @@
+{{ pipeline_script_code }}