codeplain 0.3.2__tar.gz → 0.3.4__tar.gz

{codeplain-0.3.2 → codeplain-0.3.4}/PKG-INFO

@@ -1,13 +1,13 @@
 Metadata-Version: 2.4
 Name: codeplain
-Version: 0.3.2
+Version: 0.3.4
 Summary: Transform plain language specifications into working code
 License-File: LICENSE
 Classifier: Environment :: Console
 Classifier: Intended Audience :: Developers
 Classifier: Operating System :: OS Independent
 Classifier: Topic :: Software Development :: Code Generators
-Requires-Python: >=3.11
+Requires-Python: ==3.11
 Requires-Dist: gitpython==3.1.50
 Requires-Dist: mistletoe==1.3.0
 Requires-Dist: networkx==3.6.1
@@ -16,6 +16,7 @@ Requires-Dist: python-liquid2==0.3.0
 Requires-Dist: pyyaml==6.0.3
 Requires-Dist: requests==2.34.0
 Requires-Dist: rich==15.0.0
+Requires-Dist: sentry-sdk==2.62.0
 Requires-Dist: textual>=7.5.0
 Requires-Dist: tiktoken==0.12.0
 Requires-Dist: transitions==0.9.3
@@ -103,6 +104,11 @@ After completing the installation steps above, you can immediately test the syst
   python hello_world.py
   ```
 
+### Crash reporting
+
+If the plain2code client crashes unexpectedly, it sends an anonymous crash report to Codeplain to help improve the tool. To disable crash reporting, set the `CODEPLAIN_NO_TELEMETRY=1` flag.
+
+
 ## Releasing
 
 Releases are built and published with [uv](https://docs.astral.sh/uv/). The version is read from `_version.py`.

{codeplain-0.3.2 → codeplain-0.3.4}/README.md

@@ -74,6 +74,11 @@ After completing the installation steps above, you can immediately test the syst
   python hello_world.py
   ```
 
+### Crash reporting
+
+If the plain2code client crashes unexpectedly, it sends an anonymous crash report to Codeplain to help improve the tool. To disable crash reporting, set the `CODEPLAIN_NO_TELEMETRY=1` flag.
+
+
 ## Releasing
 
 Releases are built and published with [uv](https://docs.astral.sh/uv/). The version is read from `_version.py`.

codeplain-0.3.4/_version.py

@@ -0,0 +1 @@
+__version__ = "0.3.4"

codeplain-0.3.4/change_detection.py

@@ -0,0 +1,190 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Literal
+
+if TYPE_CHECKING:
+    from plain_modules import PlainModule
+
+MODULE_FUNCTIONALITIES_KEY = "functionalities"
+NON_FUNCTIONAL_SOURCE_HASH_KEY = "non_functional_source_hash"
+
+
+@dataclass
+class FunctionalityChange:
+    module: str
+    frid: str
+    change_type: Literal["added", "removed", "edited", "moved"]
+    detail: str | None = None
+
+
+@dataclass
+class PartialRenderStart:
+    module: "PlainModule"
+    frid: str
+
+
+def determine_partial_render_start(plain_module: "PlainModule") -> PartialRenderStart | None:
+    """Determine where to start partial rendering based on spec changes.
+
+    Returns None (only full render is safe) if non-FR sections changed
+    (e.g. definitions, implementation reqs) since previously-rendered FRs
+    were generated without that context, if no changes are found, or if
+    all changes are trailing removals that don't require rendering.
+    """
+    all_modules = plain_module.all_required_modules + [plain_module]
+
+    for module in all_modules:
+        if _non_functional_content_changed(module):
+            return None
+
+        changes = _detect_module_changes(module)
+        if not changes:
+            continue
+
+        current_fr_count = len(module._get_module_functional_requirements())
+        earliest_frid = _get_earliest_affected_frid(changes, current_fr_count)
+        if earliest_frid is None:
+            continue
+        return PartialRenderStart(module=module, frid=earliest_frid)
+
+    return None
+
+
+def _non_functional_content_changed(module: "PlainModule") -> bool:
+    """Check whether anything outside functional specs changed since last render.
+
+    A missing stored hash (older builds) is treated as changed — partial rendering
+    is unsafe without a known baseline.
+    """
+    metadata = module.load_module_metadata()
+    if not metadata:
+        return False
+    stored_hash = metadata.get(NON_FUNCTIONAL_SOURCE_HASH_KEY)
+    if stored_hash is None:
+        return True
+    return stored_hash != module.get_module_non_functional_source_hash()
+
+
+def _get_earliest_affected_frid(changes: list[FunctionalityChange], current_fr_count: int) -> str | None:
+    """Earliest FRID (in current spec numbering) that must be re-rendered.
+
+    Returns the minimum position across all changes:
+    - added / edited: the FRID itself.
+    - removed: the position the removal opened up (now occupied by the next FR).
+    - moved: the FR's old position.
+
+    Correctness does not rely on any single change type's position being individually
+    "the" earliest (in particular, a move's old position is *not* always its earliest
+    touched position once moves mix with adds/removes). The guarantee is structural:
+    the first index at which the new spec diverges from the old is always emitted as
+    some change anchored at that index — a move with that old position, or an
+    edit/removal/addition there — so the minimum over all change FRIDs lands at or
+    before the true first divergence. Rendering runs from this FRID to the end of the
+    module, so an at-or-before start point is always safe (it can re-render unchanged
+    trailing FRs, but never skips a changed one).
+
+    Returns None when every change is a removal beyond the current spec length
+    (only trailing FRs were removed, so nothing needs rendering).
+    """
+    earliest = None
+    for change in changes:
+        frid_int = int(change.frid)
+        if change.change_type == "removed" and frid_int > current_fr_count:
+            continue
+        if earliest is None or frid_int < earliest:
+            earliest = frid_int
+    if earliest is None:
+        return None
+    return str(earliest)
+
+
+def _detect_module_changes(module: "PlainModule") -> list[FunctionalityChange]:
+    metadata = module.load_module_metadata()
+    old_frs: list[str] = metadata.get(MODULE_FUNCTIONALITIES_KEY, []) if metadata else []
+    new_frs: list[str] = module._get_module_functional_requirements()
+
+    if old_frs == new_frs:
+        return []
+
+    moves, edits, removed, added = _classify_changes(old_frs, new_frs)
+
+    changes: list[FunctionalityChange] = []
+    name = module.module_name
+
+    for old_idx, new_idx in moves:
+        old_frid = _frid_from_index(old_idx)
+        new_frid = _frid_from_index(new_idx)
+        changes.append(FunctionalityChange(module=name, frid=old_frid, change_type="moved", detail=new_frid))
+
+    for idx in edits:
+        changes.append(FunctionalityChange(module=name, frid=_frid_from_index(idx), change_type="edited"))
+
+    for idx in removed:
+        changes.append(FunctionalityChange(module=name, frid=_frid_from_index(idx), change_type="removed"))
+
+    for idx in added:
+        changes.append(FunctionalityChange(module=name, frid=_frid_from_index(idx), change_type="added"))
+
+    return changes
+
+
+def _classify_changes(
+    old_frs: list[str], new_frs: list[str]
+) -> tuple[list[tuple[int, int]], list[int], list[int], list[int]]:
+    matched_old: set[int] = set()
+    matched_new: set[int] = set()
+
+    for i in range(min(len(old_frs), len(new_frs))):
+        if old_frs[i] == new_frs[i]:
+            matched_old.add(i)
+            matched_new.add(i)
+
+    content_matches: list[tuple[int, int]] = []
+    for old_idx in range(len(old_frs)):
+        if old_idx in matched_old:
+            continue
+        for new_idx in range(len(new_frs)):
+            if new_idx in matched_new:
+                continue
+            if old_frs[old_idx] == new_frs[new_idx]:
+                content_matches.append((old_idx, new_idx))
+                matched_old.add(old_idx)
+                matched_new.add(new_idx)
+                break
+
+    moves: list[tuple[int, int]] = []
+    if content_matches and _has_relative_order_change(content_matches):
+        moves = content_matches
+
+    edits: list[int] = []
+    for i in range(min(len(old_frs), len(new_frs))):
+        if i not in matched_old and i not in matched_new:
+            edits.append(i)
+            matched_old.add(i)
+            matched_new.add(i)
+
+    removed = [i for i in range(len(old_frs)) if i not in matched_old]
+    added = [i for i in range(len(new_frs)) if i not in matched_new]
+
+    return moves, edits, removed, added
+
+
+def _has_relative_order_change(matches: list[tuple[int, int]]) -> bool:
+    """Check if content matches represent a true reorder (relative order changed).
+
+    If all matches preserve relative order (sorted by old_idx gives same ordering
+    as sorted by new_idx), it's just a positional shift from insertions/removals.
+    """
+    if len(matches) <= 1:
+        return False
+    sorted_by_old = sorted(matches, key=lambda m: m[0])
+    new_indices = [m[1] for m in sorted_by_old]
+    for i in range(len(new_indices) - 1):
+        if new_indices[i] > new_indices[i + 1]:
+            return True
+    return False
+
+
+def _frid_from_index(index: int) -> str:
+    return str(index + 1)

{codeplain-0.3.2 → codeplain-0.3.4}/cli_output/status.py

@@ -50,8 +50,8 @@ def _display_credit_line(plan_credits: dict) -> None:
         console.print(f"    {plan_label:10} {bar}   {remaining:2} of {total} remaining    expires {formatted_date}")
 
 
-def _display_purchased_credit_line(bucket: dict) -> None:
-    """Display a purchased credit line with progress bar."""
+def _display_bucket_credit_line(bucket: dict, label: str) -> None:
+    """Display a credit bucket line (purchased or promo) with progress bar."""
     remaining = bucket["remaining"]
     total = bucket["total"]
     expiry_date = bucket["expiry_date"]
@@ -71,12 +71,12 @@ def _display_purchased_credit_line(bucket: dict) -> None:
     bar = _create_progress_bar(remaining, total, width=30)
 
     if is_expired:
-        console.print(f"    Purchased  {bar}   expired {formatted_date}")
+        console.print(f"    {label:10} {bar}   expired {formatted_date}")
     else:
-        console.print(f"    Purchased  {bar}   {remaining:2} of {total} remaining    expires {formatted_date}")
+        console.print(f"    {label:10} {bar}   {remaining:2} of {total} remaining    expires {formatted_date}")
 
 
-def _display_status_message(plan_credits: Optional[dict], purchased_credits: list) -> None:
+def _display_status_message(plan_credits: Optional[dict], purchased_credits: list, promo_credits: list) -> None:
     """Display appropriate status message based on credit state."""
     has_remaining = False
 
@@ -93,8 +93,8 @@ def _display_status_message(plan_credits: Optional[dict], purchased_credits: lis
         if remaining > 0 and period_end > now:
             has_remaining = True
 
-    # Check if any purchased credits have remaining balance and not expired
-    for bucket in purchased_credits:
+    # Check if any purchased or promo credits have remaining balance and not expired
+    for bucket in [*purchased_credits, *promo_credits]:
         dt_str = bucket["expiry_date"].replace("Z", "+00:00")
         expiry_date = datetime.fromisoformat(dt_str)
         # If naive datetime, assume UTC
@@ -127,6 +127,7 @@ def print_status(api_key: str, api_url: str, client_version: str) -> None:
     org_owner = response.get("organization_owner_email")
     plan_credits = response.get("plan_credits")
     purchased_credits = response.get("purchased_credits", [])
+    promo_credits = response.get("promo_credits", [])
 
     # Display header information
     if client_version_valid:
@@ -153,8 +154,12 @@ def print_status(api_key: str, api_url: str, client_version: str) -> None:
 
     # Display purchased credits
     for bucket in purchased_credits:
-        _display_purchased_credit_line(bucket)
+        _display_bucket_credit_line(bucket, "Purchased")
+
+    # Display promo credits
+    for bucket in promo_credits:
+        _display_bucket_credit_line(bucket, "Promo")
 
     # Display status messages and management link
-    _display_status_message(plan_credits, purchased_credits)
+    _display_status_message(plan_credits, purchased_credits, promo_credits)
     console.print("\nTo manage your plan navigate to https://platform.codeplain.ai/plans")

{codeplain-0.3.2 → codeplain-0.3.4}/examples/example_hello_world_python/hello_world_python.plain

@@ -13,7 +13,7 @@ import:
 - Display "hello, world"
 
   ***acceptance tests***
+    
+  - :App: should exit with status code 0 indicating successful execution.
 
-  - :App: should exit with status code 0 indicating successful execution [adsa](asdsa).
-
-  - :App: should complete execution in under 1 second.
+  - :App: should complete execution in under 1 second.

codeplain-0.3.4/partial_rendering.py

@@ -0,0 +1,297 @@
+from dataclasses import dataclass
+from typing import Literal
+
+import plain_spec
+from change_detection import PartialRenderStart, determine_partial_render_start
+from plain2code_exceptions import ModuleDoesNotExistError
+from plain_modules import PlainModule
+
+
+@dataclass
+class PlainModuleRenderState:
+    last_render_module: PlainModule
+    last_render_frid: str | None
+    change: PlainModule | None = None
+    change_type: Literal["spec_change", "code_change"] | None = None
+
+
+@dataclass
+class RenderChoice:
+    module: PlainModule | None = None
+    render_range: list[str] | None = None
+    wipe_later_modules: bool = False
+    is_destructive: bool = False
+    choice_type: str | None = None
+
+
+def spec_change(plain_module: PlainModule) -> PlainModule | None:
+    all_modules = plain_module.all_required_modules + [plain_module]
+    for _module in all_modules:
+        module_metadata = _module.load_module_metadata()
+        if (
+            module_metadata
+            and "source_hash" in module_metadata
+            and module_metadata["source_hash"] != _module.get_module_source_hash()
+        ):
+            return _module
+
+    return None
+
+
+def code_change(plain_module: PlainModule) -> PlainModule | None:
+    all_modules = plain_module.all_required_modules + [plain_module]
+    for _module in all_modules:
+        if len(_module.required_modules) == 0:
+            continue
+
+        module_metadata = _module.load_module_metadata()
+        previous_module = _module.required_modules[-1]
+        if (
+            module_metadata
+            and "required_modules_code_hash" in module_metadata
+            and module_metadata["required_modules_code_hash"] != previous_module.get_module_code_hash()
+        ):
+            return previous_module
+
+    return None
+
+
+def module_comes_before_or_equal(
+    all_required_modules: list[PlainModule],
+    module1: PlainModule,
+    module2: PlainModule,
+) -> bool:
+    for module in all_required_modules:
+        if module.module_name == module1.module_name:
+            return True
+        if module.module_name == module2.module_name:
+            return False
+
+    raise ValueError(f"Module {module1.module_name} and {module2.module_name} not found in {all_required_modules}")
+
+
+def get_plain_module_render_state(plain_module: PlainModule) -> PlainModuleRenderState | None:
+    sc = spec_change(plain_module)
+    cc = code_change(plain_module)
+    all_required_modules = plain_module.all_required_modules
+    last_rendered_module_name, last_rendered_frid = plain_module.get_module_render_status()
+    if last_rendered_module_name is None and last_rendered_frid is None:
+        return None
+
+    if last_rendered_module_name == plain_module.module_name:
+        module = plain_module
+    else:
+        found_module: PlainModule | None = None
+        for required_module in all_required_modules:
+            if required_module.module_name == last_rendered_module_name:
+                found_module = required_module
+
+        if found_module is None:
+            raise ModuleDoesNotExistError(
+                f"Last rendered module {last_rendered_module_name} not found in {[rmodule.module_name for rmodule in all_required_modules]}"
+            )
+        module = found_module
+
+    pr = PlainModuleRenderState(
+        last_render_module=module,
+        last_render_frid=last_rendered_frid,
+        change=None,
+        change_type=None,
+    )
+
+    if sc is None and cc is None:
+        return pr
+
+    if sc is not None:
+        pr.change = sc
+        pr.change_type = "spec_change"
+
+    if cc is not None and (
+        pr.change is None
+        or (pr.change is not None and module_comes_before_or_equal(all_required_modules, cc, pr.change))
+    ):
+        pr.change = cc
+        pr.change_type = "code_change"
+
+    return pr
+
+
+def get_all_affected_modules_from_change(
+    plain_module: PlainModule,
+    plain_module_render_state: PlainModuleRenderState,
+) -> list[PlainModule]:
+    all_affected_modules = dict[str, PlainModule]()
+
+    if plain_module_render_state.change_type == "spec_change":
+        start_module = plain_module_render_state.change
+    elif plain_module_render_state.change_type == "code_change":
+        if plain_module_render_state.change.is_module_fully_rendered():
+            start_module = plain_module.get_next_module(plain_module_render_state.change.module_name)
+        else:
+            start_module = plain_module_render_state.change
+    else:
+        raise ValueError(f"Unknown change type: {plain_module_render_state.change_type}")
+
+    affected_module = False
+    all_modules = plain_module.all_required_modules + [plain_module]
+    for module in all_modules:
+        if module.module_name == start_module.module_name:
+            affected_module = True
+
+        if affected_module and module.module_name not in all_affected_modules:
+            all_affected_modules[module.module_name] = module
+
+    return list(all_affected_modules.values())
+
+
+def change_is_only_future_work(
+    plain_module: PlainModule,
+    plain_module_render_state: PlainModuleRenderState,
+    partial_start: "PartialRenderStart | None",
+) -> bool:
+    """Return True when a spec change only adds work *after* the last-rendered functionality.
+
+    Appending a new functionality past the render frontier (e.g. a new functionality at the
+    end of the last module) does not affect anything already rendered, so it needs no user
+    decision. The normal "continue" path renders the outstanding functionalities, starting
+    from the first one that was never rendered.
+    """
+    if partial_start is None:
+        return False
+
+    all_modules = plain_module.all_required_modules + [plain_module]
+    order = {module.module_name: index for index, module in enumerate(all_modules)}
+    last_index = order[plain_module_render_state.last_render_module.module_name]
+    start_index = order[partial_start.module.module_name]
+
+    if start_index != last_index:
+        return start_index > last_index
+
+    if plain_module_render_state.last_render_frid is None:
+        return True
+
+    return int(partial_start.frid) > int(plain_module_render_state.last_render_frid)
+
+
+def _resume_render_choice(
+    plain_module: PlainModule,
+    plain_module_render_state: PlainModuleRenderState,
+    force_render: bool,
+) -> RenderChoice:
+    """The natural next step from the last-rendered position when no decision is needed:
+    start an unrendered module, continue a partially-rendered one, or advance to the next.
+    """
+    pr = plain_module_render_state
+
+    if pr.last_render_module.has_no_rendered_functionality():
+        return RenderChoice(
+            module=pr.last_render_module,
+            render_range=None,
+            choice_type="module_start",
+            wipe_later_modules=True,
+            is_destructive=False,
+        )
+
+    if not pr.last_render_module.is_module_fully_rendered():
+        if not pr.last_render_frid:
+            raise ValueError("Last render FRID is not set for a non-initial module")
+
+        next_frid, next_module = plain_module.get_next_frid(pr.last_render_frid, pr.last_render_module.module_name)
+        render_range = plain_spec.get_render_range_from(next_frid, next_module.plain_source)
+        return RenderChoice(
+            module=next_module,
+            render_range=None if force_render else render_range,
+            wipe_later_modules=force_render,
+            choice_type="continue_from_frid",
+        )
+
+    next_module = plain_module.get_next_module(pr.last_render_module.module_name) or pr.last_render_module
+    return RenderChoice(
+        module=next_module,
+        render_range=None,
+        choice_type="module_start",
+        is_destructive=pr.last_render_module.module_name == plain_module.module_name,
+    )
+
+
+def get_render_choices(
+    plain_module: PlainModule,
+    plain_module_render_state: PlainModuleRenderState,
+    force_render: bool = False,
+) -> dict[str, RenderChoice]:
+    render_choices = list[RenderChoice]()
+    module_start_points = list[str]()
+
+    # Decide whether the detected change actually requires a decision. A spec change that only
+    # adds work *after* the last-rendered functionality (e.g. a new functionality appended to
+    # the end of the last module) does not affect anything already rendered, so it is treated
+    # like a normal "continue" rather than a change that requires choosing where to restart.
+    partial_start = None
+    treat_as_continue = plain_module_render_state.change is None
+    if plain_module_render_state.change is not None and plain_module_render_state.change_type == "spec_change":
+        partial_start = determine_partial_render_start(plain_module)
+        if change_is_only_future_work(plain_module, plain_module_render_state, partial_start):
+            treat_as_continue = True
+
+    if treat_as_continue:
+        # Continue / resume from the last-rendered position. The change-driven blocks below decide
+        # the start otherwise — once a change touches already-rendered work, resuming from the old
+        # position would build on stale code.
+        render_choices.append(_resume_render_choice(plain_module, plain_module_render_state, force_render))
+
+    else:
+        # change is set here (otherwise treat_as_continue would be True), so change_type is always
+        # "spec_change" or "code_change" and get_all_affected_modules_from_change is well-defined.
+        all_affected_modules = get_all_affected_modules_from_change(plain_module, plain_module_render_state)
+
+        if plain_module_render_state.change_type == "spec_change" and partial_start is not None:
+            # Optimized partial render: render from the changed functionality, keeping the
+            # module's earlier (unchanged) functionalities.
+            render_range = plain_spec.get_render_range_from(partial_start.frid, partial_start.module.plain_source)
+            render_choices.append(
+                RenderChoice(
+                    module=partial_start.module,
+                    render_range=render_range,
+                    choice_type="render_from_change",
+                    wipe_later_modules=len(all_affected_modules) > 1,
+                    is_destructive=True,
+                )
+            )
+
+        # Full re-render of the affected module(s) from scratch. For a code change this is always
+        # the action; for a spec change with no partial start (non-FR sections changed, or only
+        # trailing FR removals) it is the only safe option, and when a partial start does exist it
+        # is offered alongside it as the "rebuild this module cleanly" alternative. The "re-render
+        # from first module" choice below remains the full-chain reset.
+        if len(all_affected_modules) > 0 and all_affected_modules[0].module_name not in module_start_points:
+            render_choices.append(
+                RenderChoice(
+                    module=all_affected_modules[0],
+                    render_range=None,
+                    choice_type="rerender_affected",
+                    wipe_later_modules=True,
+                    is_destructive=True,
+                )
+            )
+            module_start_points.append(all_affected_modules[0].module_name)
+
+        if len(plain_module.all_required_modules) > 0:
+            first_module = plain_module.all_required_modules[0]
+            if first_module.module_name != plain_module_render_state.last_render_module.module_name and (
+                plain_module_render_state.change is not None
+                and first_module.module_name != plain_module_render_state.change.module_name
+                and first_module.module_name not in module_start_points
+            ):
+                render_choices.append(
+                    RenderChoice(
+                        module=first_module,
+                        render_range=None,
+                        choice_type="rerender_from_first",
+                        wipe_later_modules=True,
+                        is_destructive=True,
+                    )
+                )
+                module_start_points.append(first_module.module_name)
+
+    render_choices.append(RenderChoice(module=None, render_range=None, choice_type="quit"))
+    return {str(idx): choice for idx, choice in enumerate(render_choices, start=1)}