procfunc 0.31.0__tar.gz → 0.33.0__tar.gz

{procfunc-0.31.0/src/procfunc.egg-info → procfunc-0.33.0}/PKG-INFO

@@ -1,11 +1,11 @@
 Metadata-Version: 2.4
 Name: procfunc
-Version: 0.31.0
+Version: 0.33.0
 Summary: Function-Oriented Abstractions for Procedural 3D Generation in Python
 License-Expression: BSD-3-Clause
 Project-URL: Homepage, https://github.com/princeton-vl/procfunc
 Project-URL: Repository, https://github.com/princeton-vl/procfunc
-Requires-Python: >=3.11
+Requires-Python: <3.12,>=3.11
 Description-Content-Type: text/markdown
 License-File: LICENSE.md
 Requires-Dist: bpy==4.2.0

{procfunc-0.31.0 → procfunc-0.33.0}/pyproject.toml

@@ -4,11 +4,11 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "procfunc"
-version = "0.31.0"
+dynamic = ["version"]
 description = "Function-Oriented Abstractions for Procedural 3D Generation in Python"
 readme = "README.md"
 license = "BSD-3-Clause"
-requires-python = ">=3.11"
+requires-python = ">=3.11,<3.12"
 dependencies = [
     "bpy==4.2.0",
     "numpy<2",
@@ -35,6 +35,9 @@ docs = [
     "sphinx-argparse",
 ]
 
+[tool.setuptools.dynamic]
+version = {attr = "procfunc.__version__"}
+
 [tool.setuptools.packages.find]
 where = ["src"]
 

{procfunc-0.31.0 → procfunc-0.33.0}/src/procfunc/__init__.py

@@ -2,7 +2,7 @@
 # ensure this gets imported first so that mathutils etc is available even if later modules dont import bpy
 import bpy
 
-__version__ = "0.30.2"
+__version__ = "0.33.0"
 
 from numpy.random import Generator as RNG
 

procfunc-0.33.0/src/procfunc/cli/__init__.py

@@ -0,0 +1,3 @@
+from procfunc.cli.main import cli
+
+__all__ = ["cli"]

{procfunc-0.31.0 → procfunc-0.33.0}/src/procfunc/codegen/codegen.py

@@ -5,19 +5,19 @@ import itertools
 import logging
 from collections import OrderedDict, defaultdict
 from pathlib import Path
-from typing import Any, Callable, Generator, Union, get_args, get_origin
+from typing import Any, Callable, Generator
 
 import numpy as np
 
 import procfunc as pf
 from procfunc import compute_graph as cg
 from procfunc.codegen import identifiers
+from procfunc.codegen.repr import repr_type, repr_value
 from procfunc.compute_graph.operators_info import (
     FUNCTIONS_TO_OPERATORS,
     OPERATOR_TEMPLATES,
     OperatorType,
 )
-from procfunc.nodes import types as nt
 from procfunc.util import pytree
 
 logger = logging.getLogger(__name__)
@@ -29,97 +29,6 @@ def indent_lines(lines: list[str], indent: str = INDENT) -> list[str]:
     return [indent + line for line in lines]
 
 
-def _repr_type(x: Any) -> str:
-    # TODO: make the user pass in special resolutions for types, or else we will just do verbose types
-
-    if isinstance(x, str):
-        return x
-
-    if x.__name__ == "NoneType":
-        return "None"
-
-    origin = get_origin(x)
-    args = get_args(x)
-
-    if x.__name__ == "ProcNode":
-        if len(args) == 1:
-            return f"pf.ProcNode[{_repr_type(args[0])}]"
-        elif len(args) == 0:
-            return "pf.ProcNode"
-        else:
-            raise ValueError(f"Unsupported ProcNode type: {x} {args=}")
-
-    if hasattr(pf, x.__name__):
-        if len(args):
-            raise ValueError(f"procfunc type had unhandled annotations: {x} {args=}")
-        return f"pf.{x.__name__}"
-
-    if x.__module__ == "builtins":
-        return x.__name__
-
-    origin = get_origin(x)
-    args = get_args(x)
-
-    if origin is Union:
-        args_0 = get_args(args[0])
-        if get_origin(args[0]) is nt.ProcNode and args_0[0] is args[1]:
-            return f"t.SocketOrVal[{_repr_type(args_0[0])}]"
-        else:
-            return " | ".join([_repr_type(a) for a in args])
-
-    if getattr(x, "__module__", None) == "procfunc.nodes.types":
-        return f"t.{x.__name__}"
-
-    return x.__name__
-
-
-def _repr_value(value: Any) -> str:
-    if hasattr(value, "__wrapped__"):
-        value = value.__wrapped__
-
-    if isinstance(value, cg.Proxy):
-        logger.warning(
-            f"Proxy object {value} should never appear as a raw value in codegen - "
-            f"its underlying node {value.node} was not resolved to a variable"
-        )
-    if isinstance(value, nt.ProcNode):
-        logger.warning(
-            f"Procnode object {value} should never be treated as a raw value in codegen"
-        )
-
-    if isinstance(value, np.random.Generator):
-        return "np.random.default_rng()"
-    elif isinstance(value, type):
-        return _repr_type(value)
-    elif isinstance(value, np.ndarray):
-        nprepr = repr(value).replace("\n", "")
-        return f"np.{nprepr}"
-    elif isinstance(value, np.dtype):
-        return f"np.dtype('{value}')"
-    elif isinstance(value, (pf.Color, pf.Vector, pf.Euler, pf.Quaternion, pf.Matrix)):
-        x = tuple(round(x, 8) for x in value)
-        return f"pf.{value.__class__.__name__}({x})"
-    elif isinstance(value, enum.Enum):
-        return f"{type(value).__name__}.{value.name}"
-    elif isinstance(value, Path):
-        return f"Path({str(value)!r})"
-    elif dataclasses.is_dataclass(value) and not isinstance(value, type):
-        args_str = ", ".join(
-            f"{f.name}={_repr_value(getattr(value, f.name))}"
-            for f in dataclasses.fields(value)
-        )
-        return f"{type(value).__name__}({args_str})"
-    elif isinstance(value, list):
-        return f"[{', '.join([_repr_value(x) for x in value])}]"
-    elif isinstance(value, tuple):
-        inner = ", ".join(_repr_value(x) for x in value)
-        return f"({inner},)" if len(value) == 1 else f"({inner})"
-    elif isinstance(value, float) and not isinstance(value, bool):
-        return repr(round(value, 8))
-    else:
-        return repr(value)
-
-
 def _repr_inp(
     arg: Any,
     scope_expressions: dict[int, str | list[str]],
@@ -132,7 +41,7 @@ def _repr_inp(
             )
         expr = scope_expressions[id(arg)]
     else:
-        expr = _repr_value(arg)
+        expr = repr_value(arg)
 
     if isinstance(expr, list):
         if len(expr) > 1:
@@ -189,7 +98,7 @@ def _repr_args(
 
     argreprs = pytree.PyTree(args).map(lambda x: _repr_inp(x, scope_expressions))
     argreprs = [
-        pytree.repr_tree_to_str(v, type_namer=_repr_type)
+        pytree.repr_tree_to_str(v, type_namer=repr_type)
         for v in argreprs.unflatten_one_level()
     ]
 
@@ -199,7 +108,7 @@ def _repr_args(
         .unflatten_one_level()
     )
     kwargreprs = {
-        k: pytree.repr_tree_to_str(v, type_namer=_repr_type)
+        k: pytree.repr_tree_to_str(v, type_namer=repr_type)
         for k, v in kwargreprs.items()
     }
 
@@ -227,11 +136,12 @@ def _repr_function_call(
     node: cg.FunctionCallNode | cg.MethodCallNode | cg.SubgraphCallNode,
     scope_expressions: dict[int, str | list[str]],
     line_limit: int = 80,
+    func_str: str | None = None,
 ) -> list[str]:
     match node:
         case cg.FunctionCallNode():
             func = node.func
-            func_str = scope_expressions[id(func)]
+            func_str = func_str or scope_expressions[id(func)]
         case cg.MethodCallNode(args=(target, *_), method_name=method_name):
             if not isinstance(target, cg.Node):
                 raise ValueError(f"Method call {node=} has non-node target {target=}")
@@ -266,22 +176,44 @@ def _repr_function_call(
         return [f"{func_str}({', '.join(arg_reprs)})"]
 
 
-def _repr_operator_call(
+def _operator_call_operands(
     node: cg.FunctionCallNode,
+    template: str,
+) -> list | None:
+    """Operand values for rendering `node` in infix/operator form, or None to
+    decline it. The operator template only has slots for the operands, so any
+    extra argument beyond them (e.g. a non-default epsilon on func.equal) would
+    be silently dropped by the infix form - decline unless it merely restates
+    the signature default, in which case it is redundant and dropped."""
+    n_slots = template.count("{}")
+    try:
+        sig = inspect.signature(node.func)
+        bound = sig.bind(*node.args, **node.kwargs)
+    except (TypeError, ValueError):
+        return None
+
+    operand_names = list(sig.parameters)[:n_slots]
+    if any(name not in bound.arguments for name in operand_names):
+        return None
+
+    for name, value in bound.arguments.items():
+        if name in operand_names:
+            continue
+        if not _kwarg_matches_default(sig, name, value):
+            return None
+
+    return [bound.arguments[name] for name in operand_names]
+
+
+def _repr_operator_call(
+    operands: list,
+    template: str,
     scope_expressions: dict[int, str | list[str]],
 ) -> list[str]:
-    assert isinstance(node, cg.FunctionCallNode), node
-
-    # Support both positional args and kwargs for operator templates
-    all_args = [
-        _repr_inp(v, scope_expressions, extra_parens=True) for v in node.args
-    ] + [
-        _repr_inp(v, scope_expressions, extra_parens=True) for v in node.kwargs.values()
+    operand_reprs = [
+        _repr_inp(v, scope_expressions, extra_parens=True) for v in operands
     ]
-
-    operator_template = scope_expressions[id(node.func)]
-    assert isinstance(operator_template, str), operator_template
-    return [operator_template.format(*all_args)]
+    return [template.format(*operand_reprs)]
 
 
 def _codegen_for_node(
@@ -298,7 +230,17 @@ def _codegen_for_node(
             elif funcres == OperatorType.NOOP:
                 return []  # no code needed
             elif "{}" in funcres:
-                return _repr_operator_call(node, scope_expressions)
+                operands = _operator_call_operands(node, funcres)
+                if operands is None:
+                    # args the infix form cannot express: emit a named call.
+                    # scope_expressions holds the operator template, so re-derive
+                    # the callsite name (import already present via
+                    # default_func_resolution_map)
+                    _, callsite = _resolve_func(func)
+                    return _repr_function_call(
+                        node, scope_expressions, func_str=callsite
+                    )
+                return _repr_operator_call(operands, funcres, scope_expressions)
             else:
                 return _repr_function_call(node, scope_expressions)
         case cg.MethodCallNode() if node.method_name == "__getitem__":
@@ -325,7 +267,7 @@ def _codegen_for_node(
                 )
             return [f"{arg_expr}.{attribute_name}"]
         case cg.ConstantNode(value=value):
-            return [_repr_value(value)]
+            return [repr_value(value)]
         case _:
             raise TypeError(f"Unsupported {node=}")
 
@@ -358,17 +300,17 @@ def _codegen_graph_inputs(
 
         known_value_type = node.metadata.get("known_value_type", None)
         line = (
-            f"{name}: {_repr_type(known_value_type)}"
+            f"{name}: {repr_type(known_value_type)}"
             if known_value_type is not None
             else f"{name}"
         )
 
         if (default := node.kwargs.get("default_value")) is not None:
-            line += f" = {_repr_value(default)}"
+            line += f" = {repr_value(default)}"
 
         args_lines.append(line + ",")
 
-    end_statement = "):" if typename is None else f") -> {typename}: "
+    end_statement = "):" if typename is None else f") -> {typename}:"
 
     return [f"def {func_name}("] + indent_lines(args_lines) + [end_statement]
 
@@ -384,7 +326,7 @@ def _codegen_namedtuple_def(outputs: pytree.PyTree):
         if vt is None:
             type_lines.append(f"{name}: Any")
         else:
-            type_lines.append(f"{name}: {_repr_type(vt)}")
+            type_lines.append(f"{name}: {repr_type(vt)}")
 
     return [f"class {tupletype.__name__}(NamedTuple):"] + indent_lines(type_lines)
 
@@ -400,11 +342,11 @@ def _codegen_for_outputs(
     if len(graph.outputs) == 1:
         single_output = next(graph.outputs.values())
         vt = single_output.metadata.get("known_value_type", None)
-        type_name = _repr_type(vt) if vt is not None else None
+        type_name = repr_type(vt) if vt is not None else None
         return type_name, [], [f"return {_repr_inp(single_output, scope_expressions)}"]
 
     graph_output_type = graph.outputs.toplevel_type()
-    type_name = _repr_type(graph_output_type)
+    type_name = repr_type(graph_output_type)
 
     is_pf_type = hasattr(pf, graph_output_type.__name__)
     if is_pf_type:
@@ -423,7 +365,7 @@ def _codegen_for_outputs(
 
     reprs_tree = graph.outputs.map(lambda node: _repr_inp(node, scope_expressions))
     return_lines = [
-        f"return {pytree.repr_tree_to_str(reprs_tree, type_namer=_repr_type)}"
+        f"return {pytree.repr_tree_to_str(reprs_tree, type_namer=repr_type)}"
     ]
 
     return type_name, type_def, return_lines
@@ -579,6 +521,7 @@ def _code_paragraphing_predicate(
 def _codegen_for_assignment(
     assign_varname: str,
     node_code: list[str] | str,
+    node: cg.Node,
     add_line_comments: bool,
 ) -> list[str]:
     assert isinstance(assign_varname, str)
@@ -589,7 +532,7 @@ def _codegen_for_assignment(
     else:
         node_code = [f"{assign_varname} = {node_code}"]
     if add_line_comments:
-        node_code[0] += f" # {node}"  # noqa: F821
+        node_code[-1] += f"  # {str(node).replace(chr(10), ' ')}"
 
     return node_code
 
@@ -669,7 +612,7 @@ def _codegen_for_graph(
             continue
 
         varname = expressions[id(node)]
-        node_code = _codegen_for_assignment(varname, node_code, add_line_comments)
+        node_code = _codegen_for_assignment(varname, node_code, node, add_line_comments)
         code_lines.extend(node_code)
 
         if last_varname.split("_")[0] != varname.split("_")[0]:
@@ -778,43 +721,46 @@ def graphs_to_python_functions(
     np_linewidth = np.get_printoptions()["linewidth"]
     np.set_printoptions(linewidth=100000)
 
-    targets = _topo_sort_subgraphs(graph)
+    try:
+        targets = _topo_sort_subgraphs(graph)
 
-    def _clean_graph_name(name: str) -> str:
-        for suffix in identifiers.NONDESCRIPTIVE_NODE_NAME_PARTS:
-            if name.endswith("_" + suffix):
-                name = name[: -(len(suffix) + 1)]
-        return name
+        def _clean_graph_name(name: str) -> str:
+            for suffix in identifiers.NONDESCRIPTIVE_NODE_NAME_PARTS:
+                if name.endswith("_" + suffix):
+                    name = name[: -(len(suffix) + 1)]
+            return name
 
-    for subgraph in cg.traverse_nested_graphs(graph):
-        subgraph.name = _clean_graph_name(subgraph.name)
+        for subgraph in cg.traverse_nested_graphs(graph):
+            subgraph.name = _clean_graph_name(subgraph.name)
 
-    subgraph_names = {
-        id(subgraph): subgraph.name for subgraph in cg.traverse_nested_graphs(graph)
-    }
-    subgraph_names = identifiers.dedup_names_with_suffix(subgraph_names, separator="_")
-
-    scope_expressions = subgraph_names.copy()
-    for k, v in func_resolution.items():
-        if isinstance(v, OperatorType):
-            scope_expressions[id(k)] = OPERATOR_TEMPLATES[v]
-        else:
-            scope_expressions[id(k)] = v
-
-    lines_for_modules = []
-    for subgraph in targets:
-        func_name = subgraph_names[id(subgraph)]
-        result = _codegen_for_graph(
-            subgraph,
-            scope_expressions=scope_expressions.copy(),
-            as_maincall=(subgraph is graph and toplevel_as_maincall),
-            add_version_comment=add_version_comment,
-            add_line_comments=add_line_comments,
-            func_name=func_name,
+        subgraph_names = {
+            id(subgraph): subgraph.name for subgraph in cg.traverse_nested_graphs(graph)
+        }
+        subgraph_names = identifiers.dedup_names_with_suffix(
+            subgraph_names, separator="_"
         )
-        lines_for_modules.append((subgraph_names[id(subgraph)], result))
 
-    np.set_printoptions(linewidth=np_linewidth)
+        scope_expressions = subgraph_names.copy()
+        for k, v in func_resolution.items():
+            if isinstance(v, OperatorType):
+                scope_expressions[id(k)] = OPERATOR_TEMPLATES[v]
+            else:
+                scope_expressions[id(k)] = v
+
+        lines_for_modules = []
+        for subgraph in targets:
+            func_name = subgraph_names[id(subgraph)]
+            result = _codegen_for_graph(
+                subgraph,
+                scope_expressions=scope_expressions.copy(),
+                as_maincall=(subgraph is graph and toplevel_as_maincall),
+                add_version_comment=add_version_comment,
+                add_line_comments=add_line_comments,
+                func_name=func_name,
+            )
+            lines_for_modules.append((subgraph_names[id(subgraph)], result))
+    finally:
+        np.set_printoptions(linewidth=np_linewidth)
 
     return OrderedDict(lines_for_modules)
 

{procfunc-0.31.0 → procfunc-0.33.0}/src/procfunc/codegen/identifiers.py

@@ -1,3 +1,4 @@
+import keyword
 import logging
 import re
 from collections import Counter, defaultdict
@@ -36,6 +37,10 @@ def bpy_name_to_pythonid(name: str) -> str:
 
     name = name.lower()
 
+    # drop anything that isn't valid in a python identifier (e.g. parentheses
+    # in socket names like "Joint ID (do not set)")
+    name = re.sub(r"[^0-9a-z_]", "_", name)
+
     name = re.sub(r"_+", "_", name).strip("_")
 
     # move number terms to end
@@ -46,6 +51,9 @@ def bpy_name_to_pythonid(name: str) -> str:
 
     name = "_".join(parts)
 
+    if keyword.iskeyword(name):
+        name = name + "_"
+
     return name
 
 
@@ -60,6 +68,8 @@ def is_valid_snake_identifier(name: str) -> bool:
         return False
     if name != name.lower():
         return False  # this is opinionated
+    if not name.isidentifier() or keyword.iskeyword(name):
+        return False
     return True
 
 

procfunc-0.33.0/src/procfunc/codegen/repr.py

@@ -0,0 +1,121 @@
+import dataclasses
+import enum
+import logging
+import math
+from pathlib import Path
+from typing import Any, Union, get_args, get_origin
+
+import numpy as np
+
+import procfunc as pf
+from procfunc import compute_graph as cg
+from procfunc.nodes import types as nt
+
+logger = logging.getLogger(__name__)
+
+
+def repr_type(x: Any) -> str:
+    # TODO: make the user pass in special resolutions for types, or else we will just do verbose types
+
+    if isinstance(x, str):
+        return x
+
+    if x.__name__ == "NoneType":
+        return "None"
+
+    origin = get_origin(x)
+    args = get_args(x)
+
+    if x.__name__ == "ProcNode":
+        if len(args) == 1:
+            return f"pf.ProcNode[{repr_type(args[0])}]"
+        elif len(args) == 0:
+            return "pf.ProcNode"
+        else:
+            raise ValueError(f"Unsupported ProcNode type: {x} {args=}")
+
+    if hasattr(pf, x.__name__):
+        if len(args):
+            raise ValueError(f"procfunc type had unhandled annotations: {x} {args=}")
+        return f"pf.{x.__name__}"
+
+    if x.__module__ == "builtins":
+        return x.__name__
+
+    origin = get_origin(x)
+    args = get_args(x)
+
+    if origin is Union:
+        args_0 = get_args(args[0])
+        if get_origin(args[0]) is nt.ProcNode and args_0[0] is args[1]:
+            return f"t.SocketOrVal[{repr_type(args_0[0])}]"
+        else:
+            return " | ".join([repr_type(a) for a in args])
+
+    if getattr(x, "__module__", None) == "procfunc.nodes.types":
+        return f"t.{x.__name__}"
+
+    return x.__name__
+
+
+def repr_float(value: float) -> str:
+    if not math.isfinite(value):
+        return f'float("{value}")'
+    # float32 socket values: shortest exact round-trip (round(x, 8) would destroy small magnitudes)
+    return str(np.float32(value))
+
+
+def repr_value(value: Any) -> str:
+    if hasattr(value, "__wrapped__"):
+        value = value.__wrapped__
+
+    if isinstance(value, cg.Proxy):
+        logger.warning(
+            f"Proxy object {value} should never appear as a raw value in codegen - "
+            f"its underlying node {value.node} was not resolved to a variable"
+        )
+    if isinstance(value, nt.ProcNode):
+        logger.warning(
+            f"Procnode object {value} should never be treated as a raw value in codegen"
+        )
+
+    if isinstance(value, np.random.Generator):
+        return "np.random.default_rng()"
+    elif isinstance(value, type):
+        return repr_type(value)
+    elif isinstance(value, np.ndarray):
+        # tolist + per-element repr is exact, unlike repr(value) which truncates
+        # to numpy printoptions precision
+        body = (
+            repr_value(value.tolist())
+            if value.dtype == np.float32
+            else repr(value.tolist())
+        )
+        return f"np.array({body}, dtype=np.{value.dtype.name})"
+    elif isinstance(value, np.dtype):
+        return f"np.dtype('{value}')"
+    elif isinstance(value, pf.Matrix):
+        # matrix constants travel as numpy arrays; stray Matrix values delegate
+        return repr_value(np.array(value, dtype=np.float32))
+    elif isinstance(value, (pf.Color, pf.Vector, pf.Euler, pf.Quaternion)):
+        comps = ", ".join(repr_float(c) for c in value)
+        return f"pf.{value.__class__.__name__}(({comps}))"
+    elif isinstance(value, enum.Enum):
+        return f"{type(value).__name__}.{value.name}"
+    elif isinstance(value, Path):
+        return f"Path({str(value)!r})"
+    elif dataclasses.is_dataclass(value) and not isinstance(value, type):
+        args_str = ", ".join(
+            f"{f.name}={repr_value(getattr(value, f.name))}"
+            for f in dataclasses.fields(value)
+        )
+        return f"{type(value).__name__}({args_str})"
+    elif isinstance(value, list):
+        return f"[{', '.join([repr_value(x) for x in value])}]"
+    elif isinstance(value, tuple):
+        inner = ", ".join(repr_value(x) for x in value)
+        return f"({inner},)" if len(value) == 1 else f"({inner})"
+    elif isinstance(value, float) and not isinstance(value, bool):
+        return repr_float(value)
+    else:
+        return repr(value)

{procfunc-0.31.0 → procfunc-0.33.0}/src/procfunc/compute_graph/__init__.py

@@ -26,3 +26,29 @@ from .util import (
     traverse_nested_graphs,
     usages_per_node,
 )
+
+__all__ = [
+    "ComputeGraph",
+    "ConstantNode",
+    "FunctionCallNode",
+    "GetAttributeNode",
+    "InputPlaceholderNode",
+    "MethodCallNode",
+    "MutatedArgumentNode",
+    "Node",
+    "ProceduralNode",
+    "SubgraphCallNode",
+    "normalize_args_to_kwargs",
+    "OperatorType",
+    "AttributeProxy",
+    "Proxy",
+    "LiteralConstant",
+    "graph_nodes_equal",
+    "transform_compute_graph",
+    "transform_nodetree",
+    "traverse_breadth_first",
+    "traverse_depth_first",
+    "traverse_depth_first_node",
+    "traverse_nested_graphs",
+    "usages_per_node",
+]

procfunc-0.33.0/src/procfunc/compute_graph/compute_graph.py

@@ -0,0 +1,32 @@
+import logging
+from dataclasses import dataclass
+from typing import Any
+
+from procfunc.util.pytree import PyTree
+
+from .node import Node
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class ComputeGraph:
+    inputs: PyTree[Any, Node]
+    outputs: PyTree[Any, Node]
+    name: str
+    metadata: dict[str, Any]
+
+    def __repr__(self):
+        return f"{self.__class__.__name__}({self.name!r})"
+
+    def __call__(
+        self,
+        *args,
+        **kwargs,
+    ):
+        """
+        Execute the compute graph. If this graph came from a tracer,
+        this should be exactly equivelant to executing the original python function.
+        """
+
+        raise NotImplementedError("Not implemented")