msra-codegen 0.1.0__tar.gz → 0.1.1__tar.gz

{msra_codegen-0.1.0 → msra_codegen-0.1.1}/MANIFEST.in

@@ -4,4 +4,5 @@ include msra_codegen/README.md
 include msra_codegen/requirements.txt
 include msra_codegen/config.toml
 include msra_codegen/node_export.js
+recursive-include vscode-extension/lsp *.js
 recursive-include msra_codegen/templates *.tpl

{msra_codegen-0.1.0/msra_codegen.egg-info → msra_codegen-0.1.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: msra-codegen
-Version: 0.1.0
+Version: 0.1.1
 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

{msra_codegen-0.1.0 → msra_codegen-0.1.1}/msra_codegen/__init__.py

@@ -3,4 +3,4 @@
 from .package_writer import generate_project
 
 __all__ = ["generate_project"]
-__version__ = "0.1.0"
+__version__ = "0.1.1"

{msra_codegen-0.1.0 → msra_codegen-0.1.1}/msra_codegen/codegen_context.py

@@ -1106,10 +1106,10 @@ def build_function_context(
         "overload_specialization_code": overload_specialization_code,
         "overload_validation_code": overload_validation_code,
         "request": {
-            "referrer_expr": render_request_referrer(headers_spec),
+            "referrer_expr": render_request_referrer(headers_spec, self_ref="self._parent"),
             "cors_mode_expr": render_request_cors_mode(headers_spec, default_if_missing=False),
             "credentials_expr": render_request_credentials(headers_spec, default_if_missing=False),
-            "headers_expr": render_request_headers(headers_spec, default_if_missing=False),
+            "headers_expr": render_request_headers(headers_spec, default_if_missing=False, self_ref="self._parent"),
         },
         "body_expr": render_expr(body.get("from"), self_ref="self._parent") if body else None,
         "body_type": body.get("type") if body else None,
@@ -1206,6 +1206,7 @@ def build_query_param_context(func: dict[str, Any]) -> list[dict[str, Any]]:
             "list_style_indexed": bool(list_style.get("indexed", False)),
             "temp_name": f"_{normalize_name(param_name)}_value",
             "temp_list_name": f"_{normalize_name(param_name)}_values",
+            "temp_list_annotation": None,
         }
         if const_expr is not None:
             item["kind"] = "literal"
@@ -1222,6 +1223,8 @@ def build_query_param_context(func: dict[str, Any]) -> list[dict[str, Any]]:
                 default_entries = [entry for entry in values if entry.get("default")]
                 if selectable_entries:
                     item["has_value_map"] = True
+                    if item["is_list"]:
+                        item["temp_list_annotation"] = "list[str] | None"
                     item["selectable_values_expr"] = render_simple_value([entry["value"] for entry in selectable_entries])
                     item["value_map_expr"] = render_simple_value(
                         {entry["value"]: entry["value_in_url"] for entry in selectable_entries}
@@ -1410,10 +1413,10 @@ def build_manager_context(
             "script_function": warmup_script.get("function") if warmup_script else None,
         },
         "request": {
-            "referrer_expr": render_request_referrer(headers_spec),
+            "referrer_expr": render_request_referrer(headers_spec, self_ref="self"),
             "cors_mode_expr": render_request_cors_mode(headers_spec, default_if_missing=True),
             "credentials_expr": render_request_credentials(headers_spec, default_if_missing=True),
-            "headers_expr": render_request_headers(headers_spec, default_if_missing=True),
+            "headers_expr": render_request_headers(headers_spec, default_if_missing=True, self_ref="self"),
         },
     }
 
@@ -1669,9 +1672,7 @@ def render_input_annotation(input_spec: dict[str, Any]) -> str:
     values = selectable_values_from_plain_values(values)
     if input_spec.get("match") is None and values:
         literal_values = ", ".join(render_simple_value(item) for item in values)
-        if base.startswith("list[") and base.endswith("]"):
-            base = f"list[Literal[{literal_values}]]"
-        else:
+        if not (base.startswith("list[") and base.endswith("]")):
             base = f"Literal[{literal_values}]"
     default_expr = input_spec.get("default")
     has_explicit_default = default_expr is not None and get_plain_value(default_expr) is not None

{msra_codegen-0.1.0 → msra_codegen-0.1.1}/msra_codegen/node_export.js

@@ -18,9 +18,9 @@ const {
   RefSegment,
   SequenceExpr,
   StringExpr,
-} = require(path.resolve(__dirname, "..", "vscode-extension", "lsp", "model"));
-const { analyzeDocument } = require(path.resolve(__dirname, "..", "vscode-extension", "lsp", "analysis"));
-const { loadProject } = require(path.resolve(__dirname, "..", "vscode-extension", "lsp", "project-loader"));
+} = require(path.resolve(__dirname, "vscode-extension", "lsp", "model"));
+const { analyzeDocument } = require(path.resolve(__dirname, "vscode-extension", "lsp", "analysis"));
+const { loadProject } = require(path.resolve(__dirname, "vscode-extension", "lsp", "project-loader"));
 
 function serializePosition(position) {
   if (!position) {

{msra_codegen-0.1.0 → msra_codegen-0.1.1}/msra_codegen/python_render.py

@@ -30,10 +30,10 @@ def escape_regex_literal(text: str) -> str:
     return text.replace("\\", "\\\\").replace('"', '\\"')
 
 
-def render_request_referrer(headers_spec: dict[str, Any] | None) -> str | None:
+def render_request_referrer(headers_spec: dict[str, Any] | None, *, self_ref: str = "self") -> str | None:
     if not headers_spec or headers_spec.get("referrer") is None:
         return None
-    return render_ref_value(headers_spec.get("referrer"), self_ref="self")
+    return render_ref_value(headers_spec.get("referrer"), self_ref=self_ref)
 
 
 def render_request_cors_mode(headers_spec: dict[str, Any] | None, *, default_if_missing: bool) -> str | None:
@@ -48,11 +48,16 @@ def render_request_credentials(headers_spec: dict[str, Any] | None, *, default_i
     return render_simple_value(get_plain_value(headers_spec.get("credentials")))
 
 
-def render_request_headers(headers_spec: dict[str, Any] | None, *, default_if_missing: bool) -> str | None:
+def render_request_headers(
+    headers_spec: dict[str, Any] | None,
+    *,
+    default_if_missing: bool,
+    self_ref: str = "self",
+) -> str | None:
     base = '{"Accept": "application/json, text/plain, */*"}'
     if not headers_spec or headers_spec.get("headers") is None:
         return base if default_if_missing else None
-    return render_headers_expr(headers_spec.get("headers"))
+    return render_headers_expr(headers_spec.get("headers"), self_ref=self_ref)
 
 
 def wait_source_expr(source: Any) -> str:
@@ -175,29 +180,29 @@ def render_text_expr(expr: dict[str, Any] | None, self_ref: str = "self._parent"
     return render_expr(expr, self_ref=self_ref)
 
 
-def render_headers_expr(expr: dict[str, Any] | None) -> str:
+def render_headers_expr(expr: dict[str, Any] | None, *, self_ref: str = "self") -> str:
     if expr is None:
         return "None"
     if not isinstance(expr, dict):
         return render_simple_value(expr)
     kind = expr.get("kind")
     if kind == "merge":
-        return " | ".join(render_headers_expr(part) for part in expr.get("parts", []))
+        return " | ".join(render_headers_expr(part, self_ref=self_ref) for part in expr.get("parts", []))
     if kind == "inline_table":
         return "{" + ", ".join(
-            f"{render_simple_value(item['key'])}: {render_headers_value(item['value'])}"
+            f"{render_simple_value(item['key'])}: {render_headers_value(item['value'], self_ref=self_ref)}"
             for item in expr.get("items", [])
         ) + "}"
     if kind == "ref":
         parts = [part["value"] for part in expr.get("parts", []) if part.get("kind") == "name"]
         if parts and parts[0] == "UNSTANDARD_HEADERS":
             if len(parts) >= 3 and parts[1] == "REQUEST":
-                return f"self.unstandard_headers.get({render_simple_value(parts[2])})"
-            return "self.unstandard_headers"
-    return render_headers_value(expr)
+                return f"{self_ref}.unstandard_headers.get({render_simple_value(parts[2])})"
+            return f"{self_ref}.unstandard_headers"
+    return render_headers_value(expr, self_ref=self_ref)
 
 
-def render_headers_value(expr: dict[str, Any] | None) -> str:
+def render_headers_value(expr: dict[str, Any] | None, *, self_ref: str = "self") -> str:
     if expr is None:
         return "None"
     if not isinstance(expr, dict):
@@ -207,12 +212,12 @@ def render_headers_value(expr: dict[str, Any] | None) -> str:
         parts = [part["value"] for part in expr.get("parts", []) if part.get("kind") == "name"]
         if parts and parts[0] == "UNSTANDARD_HEADERS":
             if len(parts) >= 3 and parts[1] == "REQUEST":
-                return f"str(self.unstandard_headers.get({render_simple_value(parts[2])}))"
-            return "str(self.unstandard_headers)"
-        return render_text_expr(expr, self_ref="self")
+                return f"str({self_ref}.unstandard_headers.get({render_simple_value(parts[2])}))"
+            return f"str({self_ref}.unstandard_headers)"
+        return render_text_expr(expr, self_ref=self_ref)
     if kind in {"string", "number", "bool", "null"}:
-        return render_text_expr(expr, self_ref="self")
-    return render_text_expr(expr, self_ref="self")
+        return render_text_expr(expr, self_ref=self_ref)
+    return render_text_expr(expr, self_ref=self_ref)
 
 
 def get_plain_value(expr: dict[str, Any] | None) -> Any:

{msra_codegen-0.1.0 → msra_codegen-0.1.1}/msra_codegen/templates/function.py.tpl

@@ -172,7 +172,12 @@
 {% for param in query_params %}
 {% if param.kind == "from" and param.has_value_map %}
 {% if param.is_list %}
+{% if param.temp_list_annotation %}
+        {{ param.temp_name }} = {{ param.source_expr }}
+        {{ param.temp_list_name }}: {{ param.temp_list_annotation }} = [str(__item) for __item in {{ param.temp_name }}] if {{ param.temp_name }} is not None else None
+{% else %}
         {{ param.temp_list_name }} = {{ param.source_expr }}
+{% endif %}
         if {{ param.temp_list_name }} in (None, []):
             {{ param.temp_list_name }} = {{ param.default_values_expr if param.default_values_expr is not none else "[]" }}
         elif not isinstance({{ param.temp_list_name }}, list):
@@ -181,7 +186,7 @@
             for __item in {{ param.temp_list_name }}:
                 if __item not in {{ param.selectable_values_expr }}:
                     raise ValueError("`{{ param.source_name }}` must be one of {{ param.selectable_values_expr }}")
-            {{ param.temp_list_name }} = [{{ param.value_map_expr }}[__item] for __item in {{ param.temp_list_name }}]
+            {{ param.temp_list_name }} = [str({{ param.value_map_expr }}[__item]) for __item in {{ param.temp_list_name }}]
             if {{ param.temp_list_name }}:
 {% if param.list_style_style == "repeat" %}
                 query_params.append(({{ param.name_expr }}, {{ param.temp_list_name }}))

{msra_codegen-0.1.0 → msra_codegen-0.1.1}/msra_codegen/templates/group.py.tpl

@@ -30,7 +30,9 @@ from human_requests.abstraction import HttpMethod
 from human_requests.abstraction import MethodPipelineError
 {% endif %}
 
+{% if functions %}
 from {{ root_import_prefix }} import abstraction
+{% endif %}
 {% for child in child_imports %}
 from .{{ child.package_name }} import {{ child.class_name }}
 {% endfor %}

{msra_codegen-0.1.0 → msra_codegen-0.1.1}/msra_codegen/templates/tests/api_test.py.tpl

@@ -7,8 +7,14 @@ from typing import TYPE_CHECKING
 {% if providers %}
 import pytest
 {% endif %}
-{% if hooks or providers %}
-from human_requests import autotest_depends_on, autotest_hook, autotest_params
+{% if hooks %}
+from human_requests import autotest_hook
+{% endif %}
+{% if providers %}
+from human_requests import autotest_params
+{% endif %}
+{% if has_provider_dependencies %}
+from human_requests import autotest_depends_on
 {% endif %}
 {% if data_cases %}
 from human_requests import autotest_data

{msra_codegen-0.1.0 → msra_codegen-0.1.1}/msra_codegen/tests_generator.py

@@ -95,6 +95,7 @@ def build_tests_project_context(project: dict[str, Any], package_name: str) -> d
             "imports": build_test_import_map(autotest_cases),
             "hooks": [case for case in autotest_cases if case["hook_code"]],
             "providers": autotest_cases,
+            "has_provider_dependencies": any(case["dependencies"] for case in autotest_cases),
             "data_cases": data_cases,
             "manual_tests": manual_cases,
         },
@@ -290,6 +291,7 @@ def build_autotest_cases(
                 "class_name": class_name_for_group(group_path_for_function(func)),
                 "hook_code": hook_code,
                 "provider_code": provider_code,
+                "dependencies": dependency_targets,
             }
         )
     return cases

{msra_codegen-0.1.0 → msra_codegen-0.1.1/msra_codegen.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: msra-codegen
-Version: 0.1.0
+Version: 0.1.1
 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

{msra_codegen-0.1.0 → msra_codegen-0.1.1}/msra_codegen.egg-info/SOURCES.txt

@@ -2,6 +2,7 @@ LICENSE
 MANIFEST.in
 README.md
 pyproject.toml
+setup.py
 msra_codegen/README.md
 msra_codegen/__init__.py
 msra_codegen/__main__.py
@@ -69,4 +70,17 @@ msra_codegen/templates/github/workflows/tests.yml.tpl
 msra_codegen/templates/licenses/GPL-3.0-or-later.txt.tpl
 msra_codegen/templates/licenses/MIT.txt.tpl
 msra_codegen/templates/tests/api_test.py.tpl
-msra_codegen/templates/tests/conftest.py.tpl
+msra_codegen/templates/tests/conftest.py.tpl
+vscode-extension/lsp/analysis.js
+vscode-extension/lsp/assignment-relations.js
+vscode-extension/lsp/assignment-schema.js
+vscode-extension/lsp/cli.js
+vscode-extension/lsp/group-relations.js
+vscode-extension/lsp/model.js
+vscode-extension/lsp/parser.js
+vscode-extension/lsp/path-schema.js
+vscode-extension/lsp/project-loader.js
+vscode-extension/lsp/reference-context.js
+vscode-extension/lsp/semantic-tokens.js
+vscode-extension/lsp/server.js
+vscode-extension/lsp/table-relations.js

{msra_codegen-0.1.0 → msra_codegen-0.1.1}/pyproject.toml

@@ -41,6 +41,7 @@ dependencies = { file = ["msra_codegen/requirements.txt"] }
 msra_codegen = [
   "config.toml",
   "node_export.js",
+  "vscode-extension/lsp/*.js",
   "templates/*.tpl",
   "templates/*/*.tpl",
   "templates/*/*/*.tpl",

msra_codegen-0.1.1/setup.py

@@ -0,0 +1,42 @@
+from __future__ import annotations
+
+import shutil
+from pathlib import Path
+
+from setuptools import setup
+from setuptools.command.build_py import build_py as _build_py
+
+
+class build_py(_build_py):
+    def run(self) -> None:
+        self._vscode_lsp_output_files: list[str] = []
+        self._vscode_lsp_output_mapping: dict[str, str] = {}
+        super().run()
+        self._copy_vscode_lsp_assets()
+
+    def get_outputs(self):  # type: ignore[override]
+        outputs = list(super().get_outputs())
+        outputs.extend(getattr(self, "_vscode_lsp_output_files", []))
+        return outputs
+
+    def get_output_mapping(self):  # type: ignore[override]
+        mapping = dict(super().get_output_mapping())
+        mapping.update(getattr(self, "_vscode_lsp_output_mapping", {}))
+        return mapping
+
+    def _copy_vscode_lsp_assets(self) -> None:
+        source_root = Path(__file__).resolve().parent / "vscode-extension" / "lsp"
+        if not source_root.exists():
+            raise FileNotFoundError(source_root)
+
+        target_root = Path(self.build_lib) / "msra_codegen" / "vscode-extension" / "lsp"
+        self.mkpath(str(target_root))
+        for source_file in source_root.glob("*.js"):
+            target_file = target_root / source_file.name
+            shutil.copy2(source_file, target_file)
+            target_output = str(target_file)
+            self._vscode_lsp_output_files.append(target_output)
+            self._vscode_lsp_output_mapping[target_output] = str(source_file)
+
+
+setup(cmdclass={"build_py": build_py})