msra-codegen 0.1.0__py3-none-any.whl

msra_codegen/typespec.py

@@ -0,0 +1,275 @@
+from __future__ import annotations
+
+import re
+from typing import Any
+
+from .python_render import get_plain_value, regex_class_name, render_expr, render_simple_value
+
+
+def should_render_setter(variable: dict[str, Any]) -> bool:
+    if variable["name"] == "token":
+        return False
+    return not bool(variable.get("read_only", False))
+
+
+def variable_type_names(variable: dict[str, Any]) -> set[str]:
+    types = variable.get("types")
+    if isinstance(types, dict):
+        kind = types.get("kind")
+        if kind == "array":
+            result = set()
+            for item in types.get("items", []):
+                if isinstance(item, dict) and item.get("kind") == "inline_table":
+                    item_dict = inline_table_to_dict(item)
+                    type_name = item_dict.get("type")
+                    if type_name:
+                        result.add(str(type_name))
+            return result
+        if kind == "inline_table":
+            item_dict = inline_table_to_dict(types)
+            type_name = item_dict.get("type")
+            return {str(type_name)} if type_name else set()
+        type_name = types.get("type")
+        return {str(type_name)} if type_name else set()
+    if isinstance(types, list):
+        result = set()
+        for item in types:
+            if isinstance(item, dict):
+                type_name = item.get("type")
+                if type_name:
+                    result.add(str(type_name))
+        return result
+    if isinstance(types, str):
+        return {types}
+    return set()
+
+
+def extract_variable_match(types_expr: dict[str, Any] | None) -> dict[str, Any] | None:
+    if not isinstance(types_expr, dict) or types_expr.get("kind") != "array":
+        return None
+    for item in types_expr.get("items", []):
+        if not isinstance(item, dict) or item.get("kind") != "inline_table":
+            continue
+        for inline_item in item.get("items", []):
+            if inline_item.get("key") == "match":
+                return inline_item.get("value")
+    return None
+
+
+def type_annotation_from_types(type_names: set[str], *, nullable: bool = False) -> str:
+    if not type_names:
+        return "Any | None" if nullable else "Any"
+    non_null = {name for name in type_names if name != "null"}
+    base = {
+        "string": "str",
+        "integer": "int",
+        "boolean": "bool",
+        "number": "float",
+        "array": "list[Any]",
+        "object": "dict[str, Any]",
+    }
+    if not non_null:
+        return "Any | None"
+    annotation = base.get(next(iter(non_null)), "Any")
+    if nullable or "null" in type_names:
+        return f"{annotation} | None"
+    return annotation
+
+
+def type_annotation_from_expr(expr: dict[str, Any] | None) -> str:
+    if is_list_type_expr(expr):
+        item_expr = list_item_type_expr(expr)
+        return f"list[{type_annotation_from_expr(item_expr)}]"
+    if is_abstraction_reference_expr(expr):
+        return "Any"
+    type_names = type_names_from_expr(expr)
+    return type_annotation_from_types(type_names)
+
+
+def primary_type_name(type_names: set[str]) -> str | None:
+    for candidate in ("integer", "number", "boolean", "string", "array", "object", "null"):
+        if candidate in type_names:
+            return candidate
+    return None
+
+
+def inline_array_to_list(expr: dict[str, Any] | None) -> list[dict[str, Any]]:
+    if not expr or expr.get("kind") != "array":
+        return []
+    result: list[dict[str, Any]] = []
+    for item in expr.get("items", []):
+        if item and item.get("kind") == "inline_table":
+            result.append(inline_table_to_dict(item))
+    return result
+
+
+def inline_table_to_dict(expr: dict[str, Any]) -> dict[str, Any]:
+    result: dict[str, Any] = {"kind": expr.get("kind")}
+    for item in expr.get("items", []):
+        result[item["key"]] = get_plain_value(item["value"])
+    return result
+
+
+def escape_docstring(text: str) -> str:
+    return text.replace('"""', '\\"\\"\\"')
+
+
+def variable_match_pattern(variable: dict[str, Any]) -> str | None:
+    match = variable.get("match")
+    return match_to_pattern(match)
+
+
+def match_to_values(expr: dict[str, Any] | None) -> list[Any] | None:
+    if not expr or expr.get("kind") != "array":
+        return None
+    values: list[Any] = []
+    for item in expr.get("items", []):
+        value, ok = scalar_value_from_expr(item)
+        if not ok:
+            return None
+        values.append(value)
+    return values
+
+
+def match_to_pattern(expr: dict[str, Any] | None) -> str | None:
+    if not expr:
+        return None
+    if expr.get("kind") == "string":
+        return render_simple_value(expr.get("value"))
+    if expr.get("kind") == "ref":
+        parts = [part["value"] for part in expr.get("parts", []) if part.get("kind") == "name"]
+        if len(parts) >= 3 and parts[0] == "DOCUMENT" and parts[1] == "REGEXES":
+            return f"abstraction.{regex_class_name(parts[2])}.REGEX"
+    return None
+
+
+def match_to_error(expr: dict[str, Any] | None) -> str | None:
+    if not expr or expr.get("kind") != "ref":
+        return None
+    parts = [part["value"] for part in expr.get("parts", []) if part.get("kind") == "name"]
+    if len(parts) >= 3 and parts[0] == "DOCUMENT" and parts[1] == "REGEXES":
+        return f"abstraction.{regex_class_name(parts[2])}.ERROR"
+    return None
+
+
+def match_to_check_expr(expr: dict[str, Any] | None, value_expr: str) -> str | None:
+    if not expr:
+        return None
+    if expr.get("kind") == "string":
+        pattern = render_simple_value(expr.get("value"))
+        return f"re.fullmatch({pattern}, str({value_expr})) is not None"
+    if expr.get("kind") != "ref":
+        return None
+    parts = [part["value"] for part in expr.get("parts", []) if part.get("kind") == "name"]
+    if len(parts) >= 3 and parts[0] == "DOCUMENT" and parts[1] == "REGEXES":
+        return f"abstraction.{regex_class_name(parts[2])}.match({value_expr})"
+    return None
+
+
+def match_to_range(expr: dict[str, Any] | None) -> tuple[int | float | None, int | float | None] | None:
+    if not expr or expr.get("kind") != "inline_table":
+        return None
+    values = inline_table_to_dict(expr)
+    has_lower = "from" in values
+    has_upper = "to" in values
+    if not has_lower and not has_upper:
+        return None
+    lower = values.get("from")
+    upper = values.get("to")
+    if has_lower and (isinstance(lower, bool) or not isinstance(lower, (int, float))):
+        return None
+    if has_upper and (isinstance(upper, bool) or not isinstance(upper, (int, float))):
+        return None
+    return (lower if has_lower else None, upper if has_upper else None)
+
+
+def scalar_value_from_expr(expr: dict[str, Any] | None) -> tuple[Any, bool]:
+    if not isinstance(expr, dict):
+        return None, False
+    kind = expr.get("kind")
+    if kind == "string":
+        return expr.get("value"), True
+    if kind == "number":
+        return expr.get("value"), True
+    if kind == "bool":
+        return bool(expr.get("value")), True
+    if kind == "null":
+        return None, True
+    return None, False
+
+
+def normalize_name(text: str) -> str:
+    return re.sub(r"[^a-z0-9]+", "", text.lower())
+
+
+def type_names_from_expr(expr: dict[str, Any] | None) -> set[str]:
+    if is_list_type_expr(expr):
+        item_expr = list_item_type_expr(expr)
+        return type_names_from_expr(item_expr)
+    plain = get_plain_value(expr)
+    if isinstance(plain, str):
+        return {plain}
+    if isinstance(plain, list):
+        result = set()
+        for item in plain:
+            if isinstance(item, dict) and item.get("type"):
+                result.add(str(item["type"]))
+        return result
+    if isinstance(plain, dict) and plain.get("type"):
+        return {str(plain["type"])}
+    return set()
+
+
+def is_list_type_expr(expr: dict[str, Any] | None) -> bool:
+    if not isinstance(expr, dict) or expr.get("kind") != "sequence":
+        return False
+    items = expr.get("items", [])
+    if len(items) != 2:
+        return False
+    if get_plain_value(items[0]) != "list":
+        return False
+    return isinstance(items[1], dict) and items[1].get("kind") == "array"
+
+
+def list_item_type_expr(expr: dict[str, Any] | None) -> dict[str, Any] | None:
+    if not is_list_type_expr(expr):
+        return None
+    items = expr.get("items", [])
+    if len(items) != 2:
+        return None
+    inner = items[1]
+    if not isinstance(inner, dict):
+        return None
+    inner_items = inner.get("items", [])
+    if not inner_items:
+        return None
+    first = inner_items[0]
+    return first if isinstance(first, dict) else None
+
+
+def ref_input_name(expr: dict[str, Any] | None) -> str | None:
+    if not isinstance(expr, dict) or expr.get("kind") != "ref":
+        return None
+    parts = [part["value"] for part in expr.get("parts", []) if part.get("kind") == "name"]
+    if len(parts) >= 2 and parts[0] == "INPUT":
+        return parts[1]
+    return None
+
+
+def is_abstraction_reference_expr(expr: dict[str, Any] | None) -> bool:
+    if not isinstance(expr, dict) or expr.get("kind") != "ref":
+        return False
+    parts = [part["value"] for part in expr.get("parts", []) if part.get("kind") == "name"]
+    return len(parts) >= 2 and parts[0] == "ABSTRACTIONS"
+
+
+def selectable_values_from_plain_values(values: Any) -> list[Any]:
+    if not isinstance(values, list):
+        return []
+    if all(not isinstance(item, dict) for item in values):
+        return list(values)
+    return [
+        item["value"]
+        for item in values
+        if isinstance(item, dict) and item.get("value") is not None
+    ]

msra_codegen/validation.py

@@ -0,0 +1,118 @@
+from __future__ import annotations
+
+import subprocess
+import sys
+from pathlib import Path
+from typing import Any
+
+import tomllib
+
+from .generator_config import config_section
+
+
+def validate_generated_project(output_root: Path) -> None:
+    output_root = output_root.resolve()
+    package_name = read_generated_package_name(output_root)
+    validation_config = config_section("validation")
+    checks = validation_config.get("checks", [])
+    if not isinstance(checks, list) or not checks:
+        raise RuntimeError("msra_codegen/config.toml must define validation.checks.")
+
+    context = {
+        "output_root": str(output_root),
+        "package_name": package_name,
+        "python_executable": sys.executable,
+    }
+    for raw_check in checks:
+        check = normalize_check(raw_check)
+        run_validation_check(output_root, check, context)
+
+
+def read_generated_package_name(output_root: Path) -> str:
+    pyproject_path = output_root / "pyproject.toml"
+    if not pyproject_path.exists():
+        raise FileNotFoundError(pyproject_path)
+
+    with pyproject_path.open("rb") as handle:
+        pyproject = tomllib.load(handle)
+    if not isinstance(pyproject, dict):
+        raise RuntimeError(f"Unexpected TOML structure in {pyproject_path}.")
+
+    project = pyproject.get("project")
+    if not isinstance(project, dict):
+        raise RuntimeError(f"Missing [project] table in {pyproject_path}.")
+
+    package_name = str(project.get("name", "")).strip()
+    if not package_name:
+        raise RuntimeError(f"Missing project.name in {pyproject_path}.")
+    return package_name
+
+
+def normalize_check(raw_check: Any) -> dict[str, list[str] | str]:
+    if not isinstance(raw_check, dict):
+        raise RuntimeError("validation.checks entries must be tables.")
+
+    name = str(raw_check.get("name", "")).strip()
+    if not name:
+        raise RuntimeError("validation.checks entries must define a non-empty name.")
+
+    argv = raw_check.get("argv", [])
+    if not isinstance(argv, list) or not argv:
+        raise RuntimeError(f"validation.checks.{name}.argv must be a non-empty list.")
+
+    targets = raw_check.get("targets", [])
+    if not isinstance(targets, list):
+        raise RuntimeError(f"validation.checks.{name}.targets must be a list.")
+
+    return {
+        "name": name,
+        "argv": [str(part) for part in argv],
+        "targets": [str(target) for target in targets],
+    }
+
+
+def run_validation_check(
+    output_root: Path,
+    check: dict[str, list[str] | str],
+    context: dict[str, str],
+) -> None:
+    name = str(check["name"])
+    argv = [expand_placeholder(part, context) for part in check["argv"]]
+    targets = [resolve_validation_target(target, output_root, context) for target in check["targets"]]
+    command = [*argv, *targets]
+    process = subprocess.run(
+        command,
+        cwd=output_root,
+        capture_output=True,
+        text=True,
+        encoding="utf-8",
+        errors="replace",
+        check=False,
+    )
+    if process.returncode == 0:
+        return
+
+    stderr = process.stderr.strip()
+    stdout = process.stdout.strip()
+    details = stderr or stdout or "validation command failed without output"
+    raise RuntimeError(
+        f"Validation check {name!r} failed with exit code {process.returncode}.\n"
+        f"Command: {' '.join(command)}\n"
+        f"{details}"
+    )
+
+
+def resolve_validation_target(target: str, output_root: Path, context: dict[str, str]) -> str:
+    rendered = expand_placeholder(target, context)
+    rendered_path = Path(rendered)
+    if rendered_path.is_absolute():
+        return str(rendered_path)
+    return rendered
+
+
+def expand_placeholder(value: str, context: dict[str, str]) -> str:
+    try:
+        return value.format(**context)
+    except KeyError as exc:
+        missing_key = exc.args[0]
+        raise RuntimeError(f"Unknown validation placeholder {{{missing_key}}} in {value!r}.") from exc

msra_codegen-0.1.0.dist-info/METADATA

@@ -0,0 +1,47 @@
+Metadata-Version: 2.4
+Name: msra-codegen
+Version: 0.1.0
+Summary: MSRA to async Python client generator
+License-Expression: GPL-3.0-or-later
+Project-URL: Homepage, https://github.com/Open-Inflation/engine-reverse-ide
+Project-URL: Repository, https://github.com/Open-Inflation/engine-reverse-ide
+Project-URL: Issues, https://github.com/Open-Inflation/engine-reverse-ide/issues
+Keywords: msra,codegen,generator,python,api
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Code Generators
+Classifier: Topic :: Software Development :: Libraries
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: jinja2>=3.1
+Requires-Dist: packaging>=24.0
+Requires-Dist: Pillow>=10.0
+Requires-Dist: ruff>=0.6
+Requires-Dist: mypy>=1.11
+Dynamic: license-file
+
+# msra-codegen
+
+MSRA to async Python client generator.
+
+## Install
+
+```powershell
+pip install msra-codegen
+```
+
+## Usage
+
+```powershell
+msra-codegen generate .\examples\example\example.msra -o .\generated
+msra-codegen validate .\generated
+```
+
+The module entrypoint stays available as well:
+
+```powershell
+python -m msra_codegen generate .\examples\example\example.msra -o .\generated
+python -m msra_codegen validate .\generated
+```

msra_codegen-0.1.0.dist-info/RECORD

@@ -0,0 +1,68 @@
+msra_codegen/README.md,sha256=QZ7cgcMzZdmVH01Cor_1l_XaSmzMQ-zieLEL3ncuG8I,433
+msra_codegen/__init__.py,sha256=TgrFRwIE1SARuKmA8-zwUPCrRPZRmVs0wDXDUaUl_2M,145
+msra_codegen/__main__.py,sha256=PSQ4rpL0dG6f-qH4N7H-gD9igQkdHzH4yVZDcW8lfZo,80
+msra_codegen/bridge.py,sha256=8tPvo1dFSBk4JvxTxO6jHNXTq7niEbHXOGarNoG7KMA,787
+msra_codegen/cli.py,sha256=L2FbDrlf1n0FlnNN7OoQpCVVeMcyTkKn6sBa6sFO1FY,3414
+msra_codegen/codegen_context.py,sha256=VpwV539GFoP17qxiPPyTxXpiCpCSAbbm9RqRndjdVpU,81135
+msra_codegen/config.toml,sha256=_QifB5o0nUPqAykEQnM3TGyCd-UxaWbwx7WYISAit5k,4416
+msra_codegen/core_naming.py,sha256=r3w4eMhrGibaeRZjXcuqXGdcF3a1S_yeXF4RywhgtMM,4880
+msra_codegen/docs_generator.py,sha256=oA70yOXXjmaDGL6nJEccq_J9BE7te2pcCpsgjtDG4mA,12983
+msra_codegen/file_utils.py,sha256=rOdyQodNfFZgv7wjyO-pxAp5lhHd1A3Tn86VmzTJp9M,211
+msra_codegen/funcresult.py,sha256=cG9YZfja-o4PbT8B5KJTW9bjQgHxfZ6lxUvt8BujYko,5964
+msra_codegen/generator.py,sha256=KOrDZKxG3SBs1_W0wTw-RUpWwFKnYSIMBnJQwQm8Y_4,171
+msra_codegen/generator_config.py,sha256=1e4-VGn9ZlK4Fxd5hkKYRjHGBZ_eDczp27oNTW6pAWI,928
+msra_codegen/github_workflows.py,sha256=PhoBiG8AlAMe9S2Ic4wDNMJDxZi7rYDxQwhUTRXpgL4,6860
+msra_codegen/gitignore.py,sha256=ewGikQoiwHLYQZj-OcNfeASoHode55__YSAPcZhAh6w,1004
+msra_codegen/issue_templates.py,sha256=Mk1lLciCRd6ZqvhnA2_hcrMHEKLNlPSjVu1rYeTbRHg,3458
+msra_codegen/logo_assets.py,sha256=BtU5iuOU2FhdhLFH70QDuBxTwpbUBH1-y6e12sTfyRk,3642
+msra_codegen/msra_serializer.py,sha256=eUSDFE2dw4QCtBqUSQkW0yLqEeZQoXDVn4ps76kFAmQ,7817
+msra_codegen/node_export.js,sha256=WrKjmLU7N9QM-2BAHhnJztvKG66vAZirqyXqPdYMRaE,7519
+msra_codegen/package_metadata.py,sha256=qU2ulFWUxXLJXLmk6uSksfcuCx9_BB3FrRDPMeBzk_s,11353
+msra_codegen/package_writer.py,sha256=2dNfGA4GXLVrhnVOq8cpQVDP0AcaZZzqHBwdkRsaKhk,6950
+msra_codegen/project_model.py,sha256=iJ1VtifcCloseMrr-0-ZprqD8t0ndQt6g6qiiLPiFP0,20088
+msra_codegen/python_formatting.py,sha256=nz8_ek7Psx4Nrmf0pT8bXcsxMiaQhzhWcGqZ0HL9xJ0,2520
+msra_codegen/python_render.py,sha256=QIRDyRidbp6XhpWuC7Yt9S-VyZzYDpmacwhwA7B6qEw,10031
+msra_codegen/readme_pipeline.py,sha256=wstRsOoiiwr2DltlhWpsvDEvlIdy7jl0okaqgKWB3p8,20480
+msra_codegen/requirements.txt,sha256=TGEOcSBPBq31lUJYl5s2mfYXDbUjWzIsZwjmpI3o-y8,62
+msra_codegen/template_engine.py,sha256=E2saVQMAwfrRMGy6jA0u8PoyFLuijbOAJJvAbSGK_NI,749
+msra_codegen/tests_generator.py,sha256=7FPHC_X9JnzNhiYF3R-C4kSAknWXpOBMhtv0n4cvGcE,38026
+msra_codegen/typespec.py,sha256=YPnfNoaaNh9NKDy7G5vInhvEVxiYjbTizcLjKrSr2b0,9531
+msra_codegen/validation.py,sha256=LPHWfpcAO8O7RPSZA69eGWRJHntGkD0SROSmSghU-8I,3897
+msra_codegen/templates/Makefile.tpl,sha256=UaPHmXcX7iIU8gRZQdnZJb4YN42nog_xf42-CHFhsxk,1180
+msra_codegen/templates/README.md.tpl,sha256=vERzjz7H57WRBIG2bz8c_FG9xg5rUlLzXLkmo_BNdJ0,1493
+msra_codegen/templates/endpoints_init.py.tpl,sha256=2V8gqXGRS-HV3yG-Fo5ZGc6dUrLVAx-fkGn2r2u6gIA,349
+msra_codegen/templates/example.py.tpl,sha256=_nfryVxniYskaAnzk8Dc20rzcuTS3D1hvejMyKf2ZE0,27
+msra_codegen/templates/function.py.tpl,sha256=zh9DTbff7Kyg8GBLlWjoS35GC7cFJ7-YJSqkFUI6iD0,17040
+msra_codegen/templates/gitignore.tpl,sha256=tbDU-LuUp6VTfKAZIxBECyw_-fqwLvtfKcldrAf0iXo,58
+msra_codegen/templates/group.py.tpl,sha256=LOesecFGYzBf77STFejJ7Iunn6X1mOw4NexV338izWw,1307
+msra_codegen/templates/group_init.py.tpl,sha256=zv3zYtvFlfWKZrT_X-TRO28QmWrnEJd3-xd343Xi0Ec,456
+msra_codegen/templates/init.py.tpl,sha256=pQYEPc1dTWr0KPzxNX7e4CkTRBqxfrwdQfq-08fvfhs,114
+msra_codegen/templates/manager.py.tpl,sha256=e2tfTqHLkC-zYWV0h7qW-hSBsBBB3VaCrb2XevWMxRE,8427
+msra_codegen/templates/pyproject.toml.tpl,sha256=vntgHtJGycTlC-rVPA07Vhp0UEw1KH24a9tFq7D0KI0,979
+msra_codegen/templates/variable.py.tpl,sha256=G9ZBoUl_9fCRhgaWJ_Vj9f5c6KnK-vHweCutpAxoEPY,2152
+msra_codegen/templates/abstraction/__init__.py.tpl,sha256=2pjmpE5SS6yXTZ8qW90QHj02eLlqNhGmP8fDXC-DQm0,5327
+msra_codegen/templates/abstraction/regexes.py.tpl,sha256=hEq-wdoaN4VbttxcDDlPEGwfO59yOCWBNB7074ssKy4,502
+msra_codegen/templates/docs/requirements.txt.tpl,sha256=LisN4V35t7YXySkjwF3nFxwU9XiW29-mo2epckFASEE,33
+msra_codegen/templates/docs/source/Makefile.tpl,sha256=i2WHuFlgfyAPEW4ssEP8NY4cOibDJrVjvzSEU8_Ggwc,634
+msra_codegen/templates/docs/source/api.rst.tpl,sha256=aq671_12LJfwUdbzMc2VE2KVRKjscMhen6Dfu-XooDM,123
+msra_codegen/templates/docs/source/conf.py.tpl,sha256=mHi4MuOViH-Qi8hQtOhbr3XwnutBbh7Fa0I6eMCGGxo,1992
+msra_codegen/templates/docs/source/index.rst.tpl,sha256=l2QftkvlNdRquxK3g37YQpTtjnP72fTC_C_4xvKT6KQ,165
+msra_codegen/templates/docs/source/module.rst.tpl,sha256=WXn8KvvywJnQl09qU8-mscXxJlccdz898TjqNxHf8Tw,517
+msra_codegen/templates/docs/source/quick_start.rst.tpl,sha256=tJ1-yy7Kroqa2AUKgA08zPRvn023ZkJWhiP71V7RUHk,351
+msra_codegen/templates/github/issue_templates/bug_report.yml.tpl,sha256=0rn2Qt6-VrYUwbyiWk2SE05kH9lumbeqLXxUFIQNcx4,1308
+msra_codegen/templates/github/issue_templates/config.yml.tpl,sha256=kABVkxMluwWauCtF71BUcoF0YJ6xWzgxuUSipUbnYN0,203
+msra_codegen/templates/github/issue_templates/documentation_issue.yml.tpl,sha256=XOqeptXf4sgx6HDCXhBeiPKfWM0Q7TzzSlgKwmDXfdE,766
+msra_codegen/templates/github/issue_templates/feature_request.yml.tpl,sha256=34wXm6kC93T_E36S3V2hWnTX4bL-tz3SW9FMolM7Pfc,988
+msra_codegen/templates/github/workflows/publish.yml.tpl,sha256=4BvhQ_q53xLn1HYEX-1DN5XM0JTyEk6i7SOof4fIoqA,2731
+msra_codegen/templates/github/workflows/source-sync.yml.tpl,sha256=XrgqzfSSesCNU-8ELNMfc9iF2ooWd5FwQ9tOJg-fiv0,6548
+msra_codegen/templates/github/workflows/tests.yml.tpl,sha256=zuJIZmmhY2EgK8e9XzlLg0Atgd6fSS4nu77FSMzpMts,1751
+msra_codegen/templates/licenses/GPL-3.0-or-later.txt.tpl,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+msra_codegen/templates/licenses/MIT.txt.tpl,sha256=2tAP1iRu8_2JMv1tCn3BSV8mdUn7YJVxs1TeXZsLspw,1086
+msra_codegen/templates/tests/api_test.py.tpl,sha256=2tLFajzKtDjRD_orAHRbEoph0mbKt_CpKY9hwIXSMrk,1077
+msra_codegen/templates/tests/conftest.py.tpl,sha256=jsrA4Gl54CCVF9c1wUu5wFlROmM-nJvzsqoZbCVtZhg,451
+msra_codegen-0.1.0.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+msra_codegen-0.1.0.dist-info/METADATA,sha256=r5KTJ1S_Sy0VOSdWYUqvVVktCUFNK3KOtYzxij2S7K0,1364
+msra_codegen-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+msra_codegen-0.1.0.dist-info/entry_points.txt,sha256=qSDNB8315HFeLaYf9imJT-s5kyyoLWF2z1oDcvuz17w,55
+msra_codegen-0.1.0.dist-info/top_level.txt,sha256=z8EcNhplJZTF_sruniZrAogi85X5zNywxKeeNSSW09U,13
+msra_codegen-0.1.0.dist-info/RECORD,,

msra_codegen-0.1.0.dist-info/WHEEL

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

msra_codegen-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+msra-codegen = msra_codegen.cli:main