wexample-pseudocode 9.2.0__tar.gz → 9.3.0__tar.gz

{wexample_pseudocode-9.2.0 → wexample_pseudocode-9.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: wexample-pseudocode
-Version: 9.2.0
+Version: 9.3.0
 Summary: Code creation and maintenance tools
 Author-Email: weeger <contact@wexample.com>
 License: MIT
@@ -11,7 +11,7 @@ Project-URL: homepage, https://github.com/wexample/python-pseudocode
 Requires-Python: >=3.10
 Requires-Dist: attrs>=23.1.0
 Requires-Dist: cattrs>=23.1.0
-Requires-Dist: wexample-helpers>=16.2.0
+Requires-Dist: wexample-helpers>=17.0.0
 Provides-Extra: dev
 Requires-Dist: pytest; extra == "dev"
 Requires-Dist: pytest-cov; extra == "dev"
@@ -19,7 +19,7 @@ Description-Content-Type: text/markdown
 
 # pseudocode
 
-Version: 9.2.0
+Version: 9.3.0
 
 Code creation and maintenance tools
 
@@ -101,7 +101,7 @@ Visit the [Wexample Suite documentation](https://docs.wexample.com) for the comp
 
 - attrs: >=23.1.0
 - cattrs: >=23.1.0
-- wexample-helpers: >=16.2.0
+- wexample-helpers: >=17.0.0
 
 ## Versioning & Compatibility Policy
 

{wexample_pseudocode-9.2.0 → wexample_pseudocode-9.3.0}/README.md

@@ -1,6 +1,6 @@
 # pseudocode
 
-Version: 9.2.0
+Version: 9.3.0
 
 Code creation and maintenance tools
 
@@ -82,7 +82,7 @@ Visit the [Wexample Suite documentation](https://docs.wexample.com) for the comp
 
 - attrs: >=23.1.0
 - cattrs: >=23.1.0
-- wexample-helpers: >=16.2.0
+- wexample-helpers: >=17.0.0
 
 ## Versioning & Compatibility Policy
 

{wexample_pseudocode-9.2.0 → wexample_pseudocode-9.3.0}/pyproject.toml

@@ -6,7 +6,7 @@ build-backend = "pdm.backend"
 
 [project]
 name = "wexample-pseudocode"
-version = "9.2.0"
+version = "9.3.0"
 description = "Code creation and maintenance tools"
 authors = [
     { name = "weeger", email = "contact@wexample.com" },
@@ -20,7 +20,7 @@ classifiers = [
 dependencies = [
     "attrs>=23.1.0",
     "cattrs>=23.1.0",
-    "wexample-helpers>=16.2.0",
+    "wexample-helpers>=17.0.0",
 ]
 
 [project.readme]

{wexample_pseudocode-9.2.0 → wexample_pseudocode-9.3.0}/src/wexample_pseudocode/common/docstring.py

@@ -19,10 +19,11 @@ def parse_docstring(doc: str | None) -> dict[str, dict[str, str]]:
     if not doc:
         return result
 
-    lines = [l.rstrip() for l in doc.splitlines()]
+    lines = [l.strip() for l in doc.splitlines()]
 
-    # Pass 1: reST style
-    for line in lines:
+    # Single pass: reST directives + block-header index collection
+    header_map: dict[str, int] = {}
+    for idx, line in enumerate(lines):
         m = PARAM_RE.match(line)
         if m:
             result["params"][m.group("name")] = m.group("desc").strip()
@@ -30,21 +31,24 @@ def parse_docstring(doc: str | None) -> dict[str, dict[str, str]]:
         m = RETURN_RE.match(line)
         if m:
             result["return"]["description"] = m.group("desc").strip()
+            continue
+        low = line.lower()
+        if low.startswith("args:"):
+            header_map.setdefault("args:", idx)
+        elif low.startswith("parameters:"):
+            header_map.setdefault("parameters:", idx)
+        elif low.startswith("returns:"):
+            header_map.setdefault("returns:", idx)
 
-    # Pass 2: Google/NumPy minimal blocks
-    def parse_block(header: str) -> None:
-        try:
-            idx = next(
-                i for i, l in enumerate(lines) if l.strip().lower().startswith(header)
-            )
-        except StopIteration:
+    # Google/NumPy minimal blocks
+    def parse_block(header: str, is_params: bool) -> None:
+        start = header_map.get(header)
+        if start is None:
             return
-        i = idx + 1
+        i = start + 1
         n = len(lines)
-        is_params = header.startswith("args") or header.startswith("parameters")
-        is_returns = header.startswith("returns")
         while i < n:
-            s = lines[i].strip()
+            s = lines[i]  # already stripped
             if not s:
                 i += 1
                 continue
@@ -58,15 +62,14 @@ def parse_docstring(doc: str | None) -> dict[str, dict[str, str]]:
                 if is_params:
                     if name:
                         result["params"][name] = desc
-                elif is_returns:
-                    if desc and "description" not in result["return"]:
-                        result["return"]["description"] = (
-                            f"{name}: {desc}" if name else desc
-                        )
+                elif desc and "description" not in result["return"]:
+                    result["return"]["description"] = (
+                        f"{name}: {desc}" if name else desc
+                    )
             i += 1
 
-    parse_block("args:")
-    parse_block("parameters:")
-    parse_block("returns:")
+    parse_block("args:", True)
+    parse_block("parameters:", True)
+    parse_block("returns:", False)
 
     return result

{wexample_pseudocode-9.2.0 → wexample_pseudocode-9.3.0}/src/wexample_pseudocode/common/type_normalizer.py

@@ -1,5 +1,23 @@
 from __future__ import annotations
 
+_TYPING_PREFIX_LEN: int = 7  # len("typing.")
+_OPTIONAL_PREFIX_LEN: int = 9  # len("Optional[")
+
+_ARRAY_TYPES: frozenset[str] = frozenset(
+    {"list", "List", "Sequence", "MutableSequence", "dict", "Dict", "Mapping"}
+)
+_PRIMITIVE_TYPES: frozenset[str] = frozenset(
+    {"int", "float", "str", "bool", "mixed", "void", "None"}
+)
+
+# Single-lookup table used by to_python_type; "void" maps to None intentionally.
+_TO_PYTHON: dict[str, str | None] = {
+    "array": "list",
+    "callable": "typing.Callable",
+    "mixed": "typing.Any",
+    "void": None,
+}
+
 
 def normalize_type(type_str: str | None) -> str | None:
     if type_str is None:
@@ -8,23 +26,23 @@ def normalize_type(type_str: str | None) -> str | None:
 
     # Strip leading 'typing.' for readability
     if t.startswith("typing."):
-        t = t[len("typing.") :]
+        t = t[_TYPING_PREFIX_LEN:]
 
     # Optional[...] -> inner + marker handled by caller
     if t.startswith("Optional[") and t.endswith("]"):
-        inner = t[len("Optional[") : -1].strip()
+        inner = t[_OPTIONAL_PREFIX_LEN:-1].strip()
         return normalize_type(inner)
 
     # Common aliases across languages
     # Python -> schema (PHP uses 'array')
-    if t in {"list", "List", "Sequence", "MutableSequence", "dict", "Dict", "Mapping"}:
+    if t in _ARRAY_TYPES:
         return "array"
 
     if t == "Callable":
         return "callable"
 
     # Primitives stay as-is
-    if t in {"int", "float", "str", "bool", "mixed", "void", "None"}:
+    if t in _PRIMITIVE_TYPES:
         return t if t != "None" else None
 
     return t
@@ -34,12 +52,6 @@ def to_python_type(type_str: str | None) -> str | None:
     if type_str is None:
         return None
     t = type_str.strip()
-    if t == "array":
-        return "list"
-    if t == "callable":
-        return "typing.Callable"
-    if t == "mixed":
-        return "typing.Any"
-    if t == "void":
-        return None
+    if t in _TO_PYTHON:
+        return _TO_PYTHON[t]
     return t

{wexample_pseudocode-9.2.0 → wexample_pseudocode-9.3.0}/src/wexample_pseudocode/config/class_config.py

@@ -1,23 +1,16 @@
 from __future__ import annotations
 
 from dataclasses import dataclass, field
-from typing import TYPE_CHECKING, Any
-
-from wexample_pseudocode.config.generator_config import GeneratorConfig
+from typing import TYPE_CHECKING
 
 if TYPE_CHECKING:
+    from typing import Any
+
     from wexample_pseudocode.config.class_method_config import ClassMethodConfig
     from wexample_pseudocode.config.class_property_config import ClassPropertyConfig
     from wexample_pseudocode.config.generator_config import GeneratorConfig
 
 
-def _format_value(value: Any) -> str:
-    if isinstance(value, str):
-        escaped = value.replace('"', '\\"')
-        return f'"{escaped}"'
-    return repr(value)
-
-
 @dataclass
 class ClassConfig:
     name: str

{wexample_pseudocode-9.2.0 → wexample_pseudocode-9.3.0}/src/wexample_pseudocode/config/class_method_config.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 from dataclasses import dataclass, field
+from itertools import chain
 from typing import TYPE_CHECKING, Any
 
 if TYPE_CHECKING:
@@ -42,7 +43,7 @@ class ClassMethodConfig:
     def to_code(self, indent: str = "    ") -> str:
         from wexample_pseudocode.common.type_normalizer import to_python_type
 
-        params_src = ", ".join(["self"] + [p.to_code() for p in self.parameters])
+        params_src = ", ".join(chain(("self",), (p.to_code() for p in self.parameters)))
         py_ret = to_python_type(self.return_type)
         ret = f" -> {py_ret}" if py_ret else ""
         header = f"def {self.name}({params_src}){ret}:"
@@ -67,8 +68,7 @@ class ClassMethodConfig:
         if doc_lines:
             first = doc_lines[0]
             rest = doc_lines[1:]
-            inner_block: list[str] = []
-            inner_block.append(first)
+            inner_block: list[str] = [first]
             if rest:
                 inner_block.append("")  # blank line before param/return block
                 # indent param/return lines inside the docstring

{wexample_pseudocode-9.2.0 → wexample_pseudocode-9.3.0}/src/wexample_pseudocode/config/class_property_config.py

@@ -6,6 +6,8 @@ from typing import Any
 
 def _format_value(value: Any) -> str:
     if isinstance(value, str):
+        if '"' not in value:
+            return f'"{value}"'
         escaped = value.replace('"', '\\"')
         return f'"{escaped}"'
     return repr(value)

{wexample_pseudocode-9.2.0 → wexample_pseudocode-9.3.0}/src/wexample_pseudocode/config/constant_config.py

@@ -3,8 +3,6 @@ from __future__ import annotations
 from dataclasses import dataclass
 from typing import TYPE_CHECKING, Any
 
-from wexample_pseudocode.config.generator_config import GeneratorConfig
-
 if TYPE_CHECKING:
     from wexample_pseudocode.config.generator_config import GeneratorConfig
 

{wexample_pseudocode-9.2.0 → wexample_pseudocode-9.3.0}/src/wexample_pseudocode/config/function_config.py

@@ -9,14 +9,6 @@ if TYPE_CHECKING:
     from wexample_pseudocode.config.function_parameter_config import (
         FunctionParameterConfig,
     )
-    from wexample_pseudocode.config.generator_config import GeneratorConfig
-
-
-def _format_value(value: Any) -> str:
-    if isinstance(value, str):
-        escaped = value.replace('"', '\\"')
-        return f'"{escaped}"'
-    return repr(value)
 
 
 @dataclass

{wexample_pseudocode-9.2.0 → wexample_pseudocode-9.3.0}/src/wexample_pseudocode/config/function_parameter_config.py

@@ -3,6 +3,8 @@ from __future__ import annotations
 from dataclasses import dataclass
 from typing import Any
 
+from wexample_pseudocode.common.type_normalizer import to_python_type
+
 
 def _format_value(value: Any) -> str:
     if isinstance(value, str):
@@ -31,24 +33,23 @@ class FunctionParameterConfig:
         )
 
     def to_code(self) -> str:
-        from wexample_pseudocode.common.type_normalizer import to_python_type
-
         py_type = to_python_type(self.type)
-        annotated = self.name
+        name = self.name
+        has_default = self.has_default
+        annotated = name
         if py_type is not None:
             # If default is None (optional), wrap type with typing.Optional[]
             if (
-                self.has_default
+                has_default
                 and self.default is None
                 and not py_type.startswith("typing.Optional[")
             ):
-                annotated = f"{self.name}: typing.Optional[{py_type}]"
+                annotated = f"{name}: typing.Optional[{py_type}]"
             else:
-                annotated = f"{self.name}: {py_type}"
+                annotated = f"{name}: {py_type}"
 
-        left = annotated
-        if self.has_default:
+        if has_default:
             if self.default is None:
-                return f"{left} = None"
-            return f"{left} = {_format_value(self.default)}"
-        return left
+                return f"{annotated} = None"
+            return f"{annotated} = {_format_value(self.default)}"
+        return annotated

{wexample_pseudocode-9.2.0 → wexample_pseudocode-9.3.0}/src/wexample_pseudocode/config/generator_config.py

@@ -4,7 +4,7 @@ from dataclasses import dataclass
 from typing import Any
 
 
-@dataclass
+@dataclass(slots=True)
 class GeneratorConfig:
     """Global generator config (minimal placeholder).
 

{wexample_pseudocode-9.2.0 → wexample_pseudocode-9.3.0}/src/wexample_pseudocode/config/method_parameter_config.py

@@ -11,4 +11,5 @@ class MethodParameterConfig:
     type: str | None = None
 
     def to_code(self) -> str:
-        return f"{self.name}: {self.type}" if self.type is not None else self.name
+        name, param_type = self.name, self.type
+        return f"{name}: {param_type}" if param_type is not None else name

{wexample_pseudocode-9.2.0 → wexample_pseudocode-9.3.0}/src/wexample_pseudocode/generator/abstract_generator.py

@@ -1,10 +1,15 @@
 from __future__ import annotations
 
+import functools
 from typing import Any
 
 import yaml
 from wexample_helpers.classes.abstract_method import abstract_method
 
+# Pre-bind fixed kwargs so dump_pseudocode avoids re-allocating the kwargs
+# dict on every call.
+_yaml_dump = functools.partial(yaml.safe_dump, sort_keys=False, allow_unicode=True)
+
 
 class AbstractGenerator:
     """Base class mirroring the PHP AbstractGenerator responsibilities.
@@ -19,7 +24,7 @@ class AbstractGenerator:
 
         Kept as a static method to mimic the PHP usage ergonomics.
         """
-        return yaml.safe_dump(data, sort_keys=False, allow_unicode=True)
+        return _yaml_dump(data)
 
     @abstract_method
     def generate_config_data(self, source_code: str) -> dict[str, Any]:

{wexample_pseudocode-9.2.0 → wexample_pseudocode-9.3.0}/src/wexample_pseudocode/generator/code_generator.py

@@ -33,7 +33,7 @@ class CodeGenerator(AbstractGenerator):
 
     def generate(self, input_text: str) -> str:
         configs = self._generate_config(input_text)
-        return "".join(cfg.to_code() + "\n" for cfg in configs)
+        return "\n".join(cfg.to_code() for cfg in configs) + "\n" if configs else ""
 
     # Implement abstract method (not used directly in CodeGenerator flow)
     def generate_config_data(self, source_code: str) -> dict[str, Any]:
@@ -57,16 +57,13 @@ class CodeGenerator(AbstractGenerator):
         from wexample_pseudocode.config.generator_config import GeneratorConfig
 
         data = yaml.safe_load(input_text) or {}
-        instances = []
-
-        global_generator_config = None
-        if "generator" in data:
-            global_generator_config = GeneratorConfig.from_config(
-                data["generator"]
-            )  # kept for parity
-
-        for item in data.get("items", []) or []:
-            config_cls = self._find_config_loader(item)
-            if config_cls is not None:
-                instances.append(config_cls.from_config(item, global_generator_config))
-        return instances
+
+        global_generator_config = (
+            GeneratorConfig.from_config(data["generator"]) if "generator" in data else None
+        )
+
+        return [
+            config_cls.from_config(item, global_generator_config)
+            for item in data.get("items", []) or []
+            if (config_cls := self._find_config_loader(item)) is not None
+        ]

{wexample_pseudocode-9.2.0 → wexample_pseudocode-9.3.0}/src/wexample_pseudocode/generator/pseudocode_generator.py

@@ -1,22 +1,23 @@
 from __future__ import annotations
 
+import ast as _ast
 from dataclasses import dataclass
 from typing import Any
 
+from wexample_pseudocode.common.type_normalizer import normalize_type
 from wexample_pseudocode.generator.abstract_generator import AbstractGenerator
+from wexample_pseudocode.parser.class_parser import parse_module_classes
+from wexample_pseudocode.parser.function_parser import parse_module_functions
+from wexample_pseudocode.parser.module_parser import parse_module_constants
 
 
 def _literal_eval_safe(node):
+    if node is None:
+        return None
     try:
-        import ast as _ast
-
-        if node is None:
-            return None
         return _ast.literal_eval(node)
     except Exception:
         try:
-            import ast as _ast
-
             return _ast.unparse(node)  # type: ignore[attr-defined]
         except Exception:
             return None
@@ -32,11 +33,6 @@ class PseudocodeGenerator(AbstractGenerator):
     """
 
     def generate_config_data(self, source_code: str) -> dict[str, Any]:
-        from wexample_pseudocode.common.type_normalizer import normalize_type
-        from wexample_pseudocode.parser.class_parser import parse_module_classes
-        from wexample_pseudocode.parser.function_parser import parse_module_functions
-        from wexample_pseudocode.parser.module_parser import parse_module_constants
-
         items: list[dict[str, Any]] = []
 
         for const in parse_module_constants(source_code):
@@ -123,15 +119,13 @@ class PseudocodeGenerator(AbstractGenerator):
                             pd["default"] = default_val
                     params.append(pd)
                 item["parameters"] = params
-            if (
-                fn.return_type is not None
-                or getattr(fn, "return_description", None) is not None
-            ):
+            fn_return_desc = getattr(fn, "return_description", None)
+            if fn.return_type is not None or fn_return_desc is not None:
                 rd: dict[str, Any] = {}
                 if fn.return_type is not None:
                     rd["type"] = normalize_type(fn.return_type)
-                if getattr(fn, "return_description", None):
-                    rd["description"] = fn.return_description
+                if fn_return_desc:
+                    rd["description"] = fn_return_desc
                 item["return"] = rd
             items.append(item)
 

{wexample_pseudocode-9.2.0 → wexample_pseudocode-9.3.0}/src/wexample_pseudocode/parser/class_parser.py

@@ -58,12 +58,16 @@ def parse_module_classes(source_code: str) -> Iterable[ClassItem]:
                         continue
                     raw_doc = ast.get_docstring(stmt)
                     parsed = parse_docstring(raw_doc)
+                    # hoist dict lookups out of per-arg / per-method loops
+                    return_info = parsed.get("return")
+                    return_desc = return_info.get("description") if return_info else None
                     m = ClassMethod(
                         name=stmt.name,
                         description=_first_line(raw_doc),
                         return_type=_annotation_to_str(stmt.returns),
-                        return_description=parsed.get("return", {}).get("description"),
+                        return_description=return_desc,
                     )
+                    params_dict = parsed.get("params") or {}
                     for arg in stmt.args.args:
                         if arg.arg == "self":
                             continue
@@ -71,7 +75,7 @@ def parse_module_classes(source_code: str) -> Iterable[ClassItem]:
                             MethodParameter(
                                 name=arg.arg,
                                 type=_annotation_to_str(arg.annotation),
-                                description=parsed.get("params", {}).get(arg.arg),
+                                description=params_dict.get(arg.arg),
                             )
                         )
                     cls.methods.append(m)
@@ -92,7 +96,9 @@ def _annotation_to_str(ann: ast.AST | None) -> str | None:
 def _first_line(doc: str | None) -> str | None:
     if not doc:
         return None
-    return doc.strip().splitlines()[0].strip()
+    # partition stops at the first '\n' without building a full list
+    first, _, _ = doc.lstrip().partition('\n')
+    return first.rstrip()
 
 
 def _literal_eval_safe(node: ast.AST | None):

{wexample_pseudocode-9.2.0 → wexample_pseudocode-9.3.0}/src/wexample_pseudocode/parser/function_parser.py

@@ -14,17 +14,6 @@ def parse_module_functions(source_code: str) -> Iterable[FunctionItem]:
 
     tree = ast.parse(source_code)
 
-    def _literal(node: ast.AST | None):
-        if node is None:
-            return None
-        try:
-            return ast.literal_eval(node)
-        except Exception:
-            try:
-                return ast.unparse(node)  # type: ignore[attr-defined]
-            except Exception:
-                return None
-
     for node in tree.body:
         if isinstance(node, ast.FunctionDef):
             raw_doc = ast.get_docstring(node)
@@ -61,7 +50,7 @@ def parse_module_functions(source_code: str) -> Iterable[FunctionItem]:
 def _first_line(doc: str | None) -> str | None:
     if not doc:
         return None
-    return doc.strip().splitlines()[0].strip()
+    return doc.strip().partition('\n')[0].strip()
 
 
 @dataclass

{wexample_pseudocode-9.2.0 → wexample_pseudocode-9.3.0}/src/wexample_pseudocode/parser/module_parser.py

@@ -21,9 +21,10 @@ def parse_module_constants(source_code: str) -> Iterable[ConstantItem]:
     # Python's ast doesn't keep comments; we do a light heuristic by reading the source.
     line_map = {}
     for i, line in enumerate(source_code.splitlines(), start=1):
-        if "#" in line:
-            # take text after the first #, strip spaces
-            comment = line.split("#", 1)[1].strip()
+        # partition does a single scan; avoids the double-pass of `in` + split
+        _, sep, rest = line.partition("#")
+        if sep:
+            comment = rest.strip()
             if comment:
                 line_map[i] = comment
 
@@ -48,7 +49,7 @@ def parse_module_constants(source_code: str) -> Iterable[ConstantItem]:
 def _literal_eval_safe(node: ast.AST):
     try:
         return ast.literal_eval(node)
-    except Exception:
+    except (ValueError, TypeError):
         # Fallback to a simple repr if non-literal
         try:
             return ast.unparse(node)  # type: ignore[attr-defined]