browser-py 0.1.0__py3-none-any.whl

webgpu_bindings.py

@@ -0,0 +1,308 @@
+from ast import (
+   Assign,
+   Attribute,
+   Call,
+   Constant,
+   Dict,
+   Expr,
+   FunctionDef,
+   ImportFrom,
+   List,
+   Load,
+   Module,
+   Name,
+   Return,
+   Subscript,
+   Tuple,
+   arg,
+   arguments,
+   expr,
+   fix_missing_locations,
+   parse,
+   stmt,
+   unparse,
+   walk,
+)
+from pathlib import Path
+
+# wgpu structs define field types; the lowerer validates this subset and emits browser field names.
+DESCRIPTORS = (
+   ("ShaderModuleDescriptor", (("code", "code", "str"),)),
+   (
+      "RenderPipelineDescriptor",
+      (
+         ("layout", "layout", "str"),
+         ("vertex", "vertex", "VertexState"),
+         ("fragment", "fragment", "FragmentState"),
+         ("primitive", "primitive", "PrimitiveState"),
+      ),
+   ),
+   ("VertexState", (("module", "module", "GPUShaderModule"), ("entry_point", "entryPoint", "str"))),
+   (
+      "FragmentState",
+      (
+         ("module", "module", "GPUShaderModule"),
+         ("entry_point", "entryPoint", "str"),
+         ("targets", "targets", "ColorTargetState[]"),
+      ),
+   ),
+   ("PrimitiveState", (("topology", "topology", "str"),)),
+   ("ColorTargetState", (("format", "format", "str"),)),
+   ("RenderPassDescriptor", (("color_attachments", "colorAttachments", "RenderPassColorAttachment[]"),)),
+   (
+      "RenderPassColorAttachment",
+      (
+         ("view", "view", "GPUTextureView"),
+         ("clear_value", "clearValue", "Color"),
+         ("load_op", "loadOp", "str"),
+         ("store_op", "storeOp", "str"),
+      ),
+   ),
+)
+
+
+def method_binding(owner: str, name: str) -> tuple[str, str, str | None, tuple[str, ...]]:
+   if owner == "GPUDevice":
+      if name == "create_shader_module":
+         return "createShaderModule", "GPUShaderModule", "ShaderModuleDescriptor", ()
+      if name == "create_render_pipeline":
+         return "createRenderPipeline", "GPURenderPipeline", "RenderPipelineDescriptor", ()
+      if name == "create_command_encoder":
+         return "createCommandEncoder", "GPUCommandEncoder", None, ()
+   elif owner == "GPUCommandEncoder":
+      if name == "begin_render_pass":
+         return "beginRenderPass", "GPURenderPassEncoder", "RenderPassDescriptor", ()
+      if name == "finish":
+         return "finish", "GPUCommandBuffer", None, ()
+   elif owner == "GPUTexture" and name == "create_view":
+      return "createView", "GPUTextureView", None, ()
+   elif owner == "GPURenderPassEncoder":
+      if name == "set_pipeline":
+         return "setPipeline", "None", None, ("GPURenderPipeline",)
+      if name == "draw":
+         return "draw", "None", None, ("int", "int", "int", "int")
+      if name == "end":
+         return "end", "None", None, ()
+   elif owner == "GPUQueue" and name == "submit":
+      return "submit", "None", None, ("GPUCommandBuffer[]",)
+   raise NotImplementedError(f"Unsupported WebGPU method: {owner}.{name}")
+
+
+def compatible_type(actual: str, expected: str) -> bool:
+   return actual == expected or (actual == "empty_sequence" and expected.endswith("[]"))
+
+
+def descriptor_binding(
+   names: tuple[str | None, ...], types: tuple[str, ...], expected: str | None
+) -> tuple[str, tuple[str, ...]]:
+   for descriptor in DESCRIPTORS:
+      fields = descriptor[1]
+      if (
+         (expected is None or descriptor[0] == expected)
+         and len(names) == len(fields)
+         and set(names) == {field[0] for field in fields}
+      ):
+         browser_names = []
+         for i in range(len(names)):
+            for field in fields:
+               if names[i] == field[0]:
+                  if compatible_type(types[i], field[2]):
+                     browser_names.append(field[1])
+                     break
+                  raise NotImplementedError(
+                     f"Expected {field[2]} for {descriptor[0]}.{field[0]}, got {types[i]}"
+                  )
+         return descriptor[0], tuple(browser_names)
+   subject = expected if expected is not None else "supported wgpu struct"
+   raise NotImplementedError(f"Unsupported WebGPU descriptor fields for {subject}: {names}")
+
+
+def sequence_type(types: tuple[str, ...]) -> str:
+   if len(types) == 0:
+      return "empty_sequence"
+   if (
+      len(types) == 4
+      and types[0] in ("int", "float")
+      and types[1] in ("int", "float")
+      and types[2] in ("int", "float")
+      and types[3] in ("int", "float")
+   ):
+      return "Color"
+   if types[0] in ("GPUCommandBuffer", "ColorTargetState", "RenderPassColorAttachment"):
+      for kind in types:
+         if kind == types[0]:
+            continue
+         raise NotImplementedError("WebGPU sequences require one element type")
+      return types[0] + "[]"
+   raise NotImplementedError("Unsupported WebGPU sequence element types: " + str(types))
+
+
+def lower_expression(value: expr, variables: dict[str, str]) -> tuple[expr, str]:
+   lowered: dict[expr, expr] = {}
+   types: dict[expr, str] = {}
+   nodes = list(walk(value))
+   targets = {node.func for node in nodes if isinstance(node, Call)}
+   for node in reversed(nodes):
+      if not isinstance(node, expr):
+         continue
+      if isinstance(node, Name):
+         if node.id in variables:
+            lowered[node] = Name(id=node.id, ctx=Load())
+            types[node] = variables[node.id]
+         else:
+            raise NotImplementedError("Unknown WebGPU value: " + node.id)
+      elif isinstance(node, Constant):
+         lowered[node] = node
+         types[node] = "None" if node.value is None else type(node.value).__name__
+      elif isinstance(node, (List, Tuple)):
+         lowered[node] = List(elts=[lowered[item] for item in node.elts], ctx=Load())
+         types[node] = sequence_type(tuple(types[item] for item in node.elts))
+      elif isinstance(node, Dict):
+         names = []
+         for key in node.keys:
+            if isinstance(key, Constant) and isinstance(key.value, str):
+               names.append(key.value)
+            else:
+               raise NotImplementedError("WebGPU descriptors require literal field names")
+         descriptor = descriptor_binding(tuple(names), tuple(types[item] for item in node.values), None)
+         keys: list[expr | None] = [Constant(value=name) for name in descriptor[1]]
+         lowered[node] = Dict(keys=keys, values=[lowered[item] for item in node.values])
+         types[node] = descriptor[0]
+      elif isinstance(node, Attribute):
+         owner = types[node.value]
+         if owner == "GPUDevice" and node.attr == "queue":
+            lowered[node] = Attribute(value=lowered[node.value], attr="queue", ctx=Load())
+            types[node] = "GPUQueue"
+         elif node in targets:
+            binding = method_binding(owner, node.attr)
+            # The lowerer emits native method keys; the browser emitter preserves them without runtime bindings.
+            lowered[node] = Subscript(value=lowered[node.value], slice=Constant(value=binding[0]), ctx=Load())
+            types[node] = "method"
+         else:
+            raise NotImplementedError("WebGPU methods must be called directly")
+      elif isinstance(node, Call) and isinstance(node.func, Attribute):
+         owner = types[node.func.value]
+         binding = method_binding(owner, node.func.attr)
+         if binding[2] is not None:
+            if node.args:
+               raise NotImplementedError(f"Expected keyword descriptor fields for {owner}.{node.func.attr}")
+            descriptor = descriptor_binding(
+               tuple(item.arg for item in node.keywords),
+               tuple(types[item.value] for item in node.keywords),
+               binding[2],
+            )
+            keys = [Constant(value=name) for name in descriptor[1]]
+            args: list[expr] = [Dict(keys=keys, values=[lowered[item.value] for item in node.keywords])]
+         elif len(node.args) == len(binding[3]) and not node.keywords:
+            for i in range(len(node.args)):
+               actual = types[node.args[i]]
+               if compatible_type(actual, binding[3][i]):
+                  continue
+               raise NotImplementedError(
+                  f"Expected {binding[3][i]} for {owner}.{node.func.attr} argument {i + 1}, got {actual}"
+               )
+            args = [lowered[item] for item in node.args]
+         else:
+            raise NotImplementedError(
+               f"Expected {len(binding[3])} positional arguments for {owner}.{node.func.attr}"
+            )
+         lowered[node] = Call(func=lowered[node.func], args=args, keywords=[])
+         types[node] = binding[1]
+      else:
+         raise NotImplementedError("Unsupported WebGPU expression: " + type(node).__name__)
+   return lowered[value], types[value]
+
+
+def lower_webgpu(source: Path) -> str:
+   tree = parse(source.read_text())
+   gpu_types = (
+      "GPUDevice",
+      "GPUShaderModule",
+      "GPURenderPipeline",
+      "GPUCommandEncoder",
+      "GPURenderPassEncoder",
+      "GPUTexture",
+      "GPUTextureView",
+      "GPUCommandBuffer",
+      "GPUQueue",
+   )
+   imported = set()
+   functions: list[stmt] = []
+   imports_open = True
+   for node in tree.body:
+      if isinstance(node, ImportFrom) and imports_open:
+         if node.level or node.module != "wgpu.classes":
+            raise NotImplementedError("WebGPU bindings accept only top-level wgpu type imports")
+         for alias in node.names:
+            if alias.asname or alias.name not in gpu_types:
+               raise NotImplementedError("Unsupported WebGPU import: " + alias.name)
+            imported.add(alias.name)
+         continue
+      imports_open = False
+      if not isinstance(node, FunctionDef):
+         raise NotImplementedError("WebGPU modules contain only typed functions")
+      if (
+         node.decorator_list
+         or node.type_params
+         or node.args.defaults
+         or node.args.kw_defaults
+         or node.args.vararg
+         or node.args.kwarg
+         or node.args.kwonlyargs
+         or node.args.posonlyargs
+      ):
+         raise NotImplementedError("WebGPU functions require plain positional parameters")
+      variables: dict[str, str] = {}
+      for parameter in node.args.args:
+         if isinstance(parameter.annotation, Name) and parameter.annotation.id in imported | {"str"}:
+            variables[parameter.arg] = parameter.annotation.id
+         else:
+            raise NotImplementedError("Explicit WebGPU parameter types required")
+      if isinstance(node.returns, Name) and node.returns.id in imported:
+         result_type = node.returns.id
+      elif isinstance(node.returns, Constant) and node.returns.value is None:
+         result_type = "None"
+      else:
+         raise NotImplementedError("Explicit WebGPU return type required")
+      body: list[stmt] = []
+      returned = False
+      for operation in node.body:
+         if returned:
+            raise NotImplementedError("Unreachable WebGPU statement")
+         if (
+            isinstance(operation, Assign)
+            and len(operation.targets) == 1
+            and isinstance(operation.targets[0], Name)
+         ):
+            value = lower_expression(operation.value, variables)
+            variables[operation.targets[0].id] = value[1]
+            body.append(Assign(targets=operation.targets, value=value[0]))
+         elif isinstance(operation, Expr) and isinstance(operation.value, Call):
+            value = lower_expression(operation.value, variables)
+            body.append(Expr(value=value[0]))
+         elif isinstance(operation, Return) and operation.value is not None:
+            value = lower_expression(operation.value, variables)
+            if value[1] != result_type:
+               raise NotImplementedError("WebGPU return type does not match its value")
+            body.append(Return(value=value[0]))
+            returned = True
+         else:
+            raise NotImplementedError("Unsupported WebGPU statement: " + type(operation).__name__)
+      if result_type != "None" and not returned:
+         raise NotImplementedError("WebGPU function must return its declared result")
+      functions.append(
+         FunctionDef(
+            name=node.name,
+            args=arguments(
+               posonlyargs=[],
+               args=[arg(arg=item.arg) for item in node.args.args],
+               kwonlyargs=[],
+               kw_defaults=[],
+               defaults=[],
+            ),
+            body=body,
+            decorator_list=[],
+            type_params=[],
+         )
+      )
+   return unparse(fix_missing_locations(Module(body=functions, type_ignores=[]))) + "\n"