From fa9879d5bff2a5f65467bd78d5e7f69ba8e0ec47 Mon Sep 17 00:00:00 2001 From: Robert-Jan Huijsman <22160949+rjhuijsman@users.noreply.github.com> Date: Tue, 21 Jul 2026 22:57:29 +0000 Subject: [PATCH 1/5] Codegen: namespace constructors under `factory` MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Before this change, constructors lived directly on the state class: a user-defined constructor named `ref` silently collided with the built-in `MyType.ref()`, and the framework could never add a new factory method without risking a clash with an existing user constructor — which a customer could not rename or delete, leaving them permanently unable to upgrade. This commit namespaces every state type's constructor (a.k.a. factory) methods under a `factory` attribute, so `await MyType.create(context)` becomes `await MyType.factory.create(context)`. That frees the top level of the generated state class for framework methods we may want to add later (e.g. a future `MyType.query(...)`), and prevents naming collisions with built-in methods. The way a constructor is declared (`factory=True`, or the `constructor` proto option) is unchanged; only the call surface moved. IMPORTANT REVIEWER HINT: the GitHub diff of the `*.j2` files is big, but very little actually changed: a bunch of methods got indented inside a new `_Factory` class, that's it. For Python that's literally just 4 spaces added to everything, for TS some code had to move to be contiguous but still remains unchanged. Co-Authored-By: Claude Opus 4.8 (1M context) Claude-Session: https://claude.ai/code/session_011xyvD8vLQ9dTwtFMexovJo --- reboot/templates/reboot.py.j2 | 473 +++++++-------- reboot/templates/reboot.ts.j2 | 172 +++--- reboot/templates/reboot_web.ts.j2 | 28 +- tests/reboot/echo_rbt.golden.py | 89 +-- tests/reboot/greeter_rbt.golden.js | 73 +-- tests/reboot/greeter_rbt.golden.py | 385 ++++++------ tests/reboot/greeter_rbt_web.golden.js | 11 +- tests/reboot/ping_api_rbt.golden.py | 796 +++++++++++++------------ 8 files changed, 1033 insertions(+), 994 deletions(-) diff --git a/reboot/templates/reboot.py.j2 b/reboot/templates/reboot.py.j2 index 95df08592..330fc4f3c 100644 --- a/reboot/templates/reboot.py.j2 +++ b/reboot/templates/reboot.py.j2 @@ -3182,7 +3182,7 @@ class {{ state.proto.name }}BaseServicer(IMPORT_reboot_aio_servicers.Servicer): f"urn:dev.reboot:auto-construct:{{ state.proto.name }}:{state_id}", ) try: - await {{ state.proto.name }}.idempotently( + await {{ state.proto.name }}.factory.idempotently( key=idempotency_key, ).{{ AUTO_CONSTRUCT_METHOD }}(context, state_id) except {{ state.proto.name }}.{{ AUTO_CONSTRUCT_PROTO_METHOD }}Aborted as aborted: @@ -7223,268 +7223,271 @@ class {{ client.proto.state_name }}: bearer_token=bearer_token, ) - {% for service in client.services %} - {% for method in service.methods %} - {%- if method.options.proto.kind == 'workflow' %} - {# TODO(benh): support constructor "tasks" and workflows. #} - {%- else %} - {% if method.options.proto.constructor %} - {# If there are no 'input_type_fields', we will have the same function signature, - so no overloads are needed. If there is 'None', 'input_type_fields' will be - already empty.#} - {% if method.input_type_fields | length > 0 %} - @IMPORT_typing.overload - @classmethod - async def {{ method.proto.name }}( - __cls__, - __context__: IMPORT_reboot_aio_contexts.TransactionContext | IMPORT_reboot_aio_contexts.WorkflowContext | IMPORT_reboot_aio_external.ExternalContext, - __state_id_or_request_or_options__: IMPORT_typing.Optional[IMPORT_reboot_aio_types.StateId | {{ client.proto.state_name }}.{{ method.proto.name }}Request] = None, - __request_or_options_or_idempotency__: IMPORT_typing.Optional[{{ client.proto.state_name }}.{{ method.proto.name }}Request | IMPORT_reboot_aio_call.Options] = None, - __options_or_idempotency__: IMPORT_typing.Optional[IMPORT_reboot_aio_call.Options | IMPORT_reboot_aio_idempotency.Idempotency] = None, - __idempotency__: IMPORT_typing.Optional[IMPORT_reboot_aio_idempotency.Idempotency] = None, - ) -> tuple[{{ client.proto.state_name }}.WeakReference, {% if method.has_non_none_response %}{{ client.proto.state_name }}.{{ method.proto.name }}Response{% else %}None{% endif %}]: - ... - - @IMPORT_typing.overload - @classmethod - async def {{ method.proto.name }}( - __cls__, - __context__: IMPORT_reboot_aio_contexts.TransactionContext | IMPORT_reboot_aio_contexts.WorkflowContext | IMPORT_reboot_aio_external.ExternalContext, - __state_id_or_request_or_options__: IMPORT_typing.Optional[IMPORT_reboot_aio_types.StateId | IMPORT_reboot_aio_call.Options] = None, - __request_or_options_or_idempotency__: IMPORT_typing.Optional[IMPORT_reboot_aio_call.Options | IMPORT_reboot_aio_idempotency.Idempotency] = None, - __options_or_idempotency__: IMPORT_typing.Optional[IMPORT_reboot_aio_idempotency.Idempotency] = None, - {% for name, type in method.input_type_fields.items() %} - {% if loop.first %} - *, - {% endif %} - {% if options.proto.pydantic %} - {{ name }}: {{ type }} | Unset = UNSET, - {% else %} - {{ name }}: IMPORT_typing.Optional[{{ type }}] | Unset = UNSET, - {% endif %} - {% endfor %} - ) -> tuple[{{ client.proto.state_name }}.WeakReference, {% if method.has_non_none_response %}{{ client.proto.state_name }}.{{ method.proto.name }}Response{% else %}None{% endif %}]: - ... - {% endif %} + class _Factory: + {% for service in client.services %} + {% for method in service.methods %} + {%- if method.options.proto.kind == 'workflow' %} + {# TODO(benh): support constructor "tasks" and workflows. #} + {%- else %} + {% if method.options.proto.constructor %} + {# If there are no 'input_type_fields', we will have the same function signature, + so no overloads are needed. If there is 'None', 'input_type_fields' will be + already empty.#} + {% if method.input_type_fields | length > 0 %} + @IMPORT_typing.overload + @classmethod + async def {{ method.proto.name }}( + __cls__, + __context__: IMPORT_reboot_aio_contexts.TransactionContext | IMPORT_reboot_aio_contexts.WorkflowContext | IMPORT_reboot_aio_external.ExternalContext, + __state_id_or_request_or_options__: IMPORT_typing.Optional[IMPORT_reboot_aio_types.StateId | {{ client.proto.state_name }}.{{ method.proto.name }}Request] = None, + __request_or_options_or_idempotency__: IMPORT_typing.Optional[{{ client.proto.state_name }}.{{ method.proto.name }}Request | IMPORT_reboot_aio_call.Options] = None, + __options_or_idempotency__: IMPORT_typing.Optional[IMPORT_reboot_aio_call.Options | IMPORT_reboot_aio_idempotency.Idempotency] = None, + __idempotency__: IMPORT_typing.Optional[IMPORT_reboot_aio_idempotency.Idempotency] = None, + ) -> tuple[{{ client.proto.state_name }}.WeakReference, {% if method.has_non_none_response %}{{ client.proto.state_name }}.{{ method.proto.name }}Response{% else %}None{% endif %}]: + ... - @classmethod - async def {{ method.proto.name }}( # type: ignore[misc] - __cls__, - __context__: IMPORT_reboot_aio_contexts.TransactionContext | IMPORT_reboot_aio_contexts.WorkflowContext | IMPORT_reboot_aio_external.ExternalContext, - {% if method.has_non_none_request %} - __state_id_or_request_or_options__: IMPORT_typing.Optional[IMPORT_reboot_aio_types.StateId | {{ client.proto.state_name }}.{{ method.proto.name }}Request | IMPORT_reboot_aio_call.Options] = None, - __request_or_options_or_idempotency__: IMPORT_typing.Optional[{{ client.proto.state_name }}.{{ method.proto.name }}Request | IMPORT_reboot_aio_call.Options | IMPORT_reboot_aio_idempotency.Idempotency] = None, - __options_or_idempotency__: IMPORT_typing.Optional[IMPORT_reboot_aio_call.Options | IMPORT_reboot_aio_idempotency.Idempotency] = None, - __idempotency__: IMPORT_typing.Optional[IMPORT_reboot_aio_idempotency.Idempotency] = None, - {% for name, type in method.input_type_fields.items() %} - {% if loop.first %} - *, - {% endif %} - {% if options.proto.pydantic %} - {{ name }}: {{ type }} | Unset = UNSET, - {% else %} - {{ name }}: IMPORT_typing.Optional[{{ type }}] | Unset = UNSET, - {% endif %} - {% endfor %} - {% else %} - __state_id__: IMPORT_typing.Optional[IMPORT_reboot_aio_types.StateId] = None, - __options__: IMPORT_typing.Optional[IMPORT_reboot_aio_call.Options] = None, - __idempotency__: IMPORT_typing.Optional[IMPORT_reboot_aio_idempotency.Idempotency] = None, + @IMPORT_typing.overload + @classmethod + async def {{ method.proto.name }}( + __cls__, + __context__: IMPORT_reboot_aio_contexts.TransactionContext | IMPORT_reboot_aio_contexts.WorkflowContext | IMPORT_reboot_aio_external.ExternalContext, + __state_id_or_request_or_options__: IMPORT_typing.Optional[IMPORT_reboot_aio_types.StateId | IMPORT_reboot_aio_call.Options] = None, + __request_or_options_or_idempotency__: IMPORT_typing.Optional[IMPORT_reboot_aio_call.Options | IMPORT_reboot_aio_idempotency.Idempotency] = None, + __options_or_idempotency__: IMPORT_typing.Optional[IMPORT_reboot_aio_idempotency.Idempotency] = None, + {% for name, type in method.input_type_fields.items() %} + {% if loop.first %} + *, + {% endif %} + {% if options.proto.pydantic %} + {{ name }}: {{ type }} | Unset = UNSET, + {% else %} + {{ name }}: IMPORT_typing.Optional[{{ type }}] | Unset = UNSET, + {% endif %} + {% endfor %} + ) -> tuple[{{ client.proto.state_name }}.WeakReference, {% if method.has_non_none_response %}{{ client.proto.state_name }}.{{ method.proto.name }}Response{% else %}None{% endif %}]: + ... {% endif %} - ) -> tuple[{{ client.proto.state_name }}.WeakReference, {% if method.has_non_none_response %}{{ client.proto.state_name }}.{{ method.proto.name }}Response{% else %}None{% endif %}]: - # Within a `workflow`, all "bare" calls are - # `per_workflow()` calls, unless we're within a control - # loop, in which case they are syntactic sugar for - # `per_iteration()`. - # - # Unless we are "within until" in which case all "bare" - # calls are `.always()`. - {% if method.has_non_none_request %} - __request__: IMPORT_typing.Optional[{{ client.proto.state_name }}.{{ method.proto.name }}Request] = None - __state_id__: IMPORT_typing.Optional[IMPORT_reboot_aio_types.StateId] = None - __options__: IMPORT_typing.Optional[IMPORT_reboot_aio_call.Options] = None - - if isinstance(__state_id_or_request_or_options__, IMPORT_reboot_aio_types.StateId): - __state_id__ = __state_id_or_request_or_options__ - if isinstance(__request_or_options_or_idempotency__, {{ client.proto.state_name }}.{{ method.proto.name }}Request): - __request__ = __request_or_options_or_idempotency__ - assert __options_or_idempotency__ is None or isinstance(__options_or_idempotency__, IMPORT_reboot_aio_call.Options) - __options__ = __options_or_idempotency__ - assert __idempotency__ is None or isinstance(__idempotency__, IMPORT_reboot_aio_idempotency.Idempotency) + @classmethod + async def {{ method.proto.name }}( # type: ignore[misc] + __cls__, + __context__: IMPORT_reboot_aio_contexts.TransactionContext | IMPORT_reboot_aio_contexts.WorkflowContext | IMPORT_reboot_aio_external.ExternalContext, + {% if method.has_non_none_request %} + __state_id_or_request_or_options__: IMPORT_typing.Optional[IMPORT_reboot_aio_types.StateId | {{ client.proto.state_name }}.{{ method.proto.name }}Request | IMPORT_reboot_aio_call.Options] = None, + __request_or_options_or_idempotency__: IMPORT_typing.Optional[{{ client.proto.state_name }}.{{ method.proto.name }}Request | IMPORT_reboot_aio_call.Options | IMPORT_reboot_aio_idempotency.Idempotency] = None, + __options_or_idempotency__: IMPORT_typing.Optional[IMPORT_reboot_aio_call.Options | IMPORT_reboot_aio_idempotency.Idempotency] = None, + __idempotency__: IMPORT_typing.Optional[IMPORT_reboot_aio_idempotency.Idempotency] = None, + {% for name, type in method.input_type_fields.items() %} + {% if loop.first %} + *, + {% endif %} + {% if options.proto.pydantic %} + {{ name }}: {{ type }} | Unset = UNSET, + {% else %} + {{ name }}: IMPORT_typing.Optional[{{ type }}] | Unset = UNSET, + {% endif %} + {% endfor %} + {% else %} + __state_id__: IMPORT_typing.Optional[IMPORT_reboot_aio_types.StateId] = None, + __options__: IMPORT_typing.Optional[IMPORT_reboot_aio_call.Options] = None, + __idempotency__: IMPORT_typing.Optional[IMPORT_reboot_aio_idempotency.Idempotency] = None, + {% endif %} + ) -> tuple[{{ client.proto.state_name }}.WeakReference, {% if method.has_non_none_response %}{{ client.proto.state_name }}.{{ method.proto.name }}Response{% else %}None{% endif %}]: + # Within a `workflow`, all "bare" calls are + # `per_workflow()` calls, unless we're within a control + # loop, in which case they are syntactic sugar for + # `per_iteration()`. + # + # Unless we are "within until" in which case all "bare" + # calls are `.always()`. - {# When specifying __request__ directly, we need to ensure that all other input fields are 'UNSET'. #} - {% for name in method.input_type_fields %} - assert {{ name }} is UNSET - {% endfor %} - else: + {% if method.has_non_none_request %} + __request__: IMPORT_typing.Optional[{{ client.proto.state_name }}.{{ method.proto.name }}Request] = None + __state_id__: IMPORT_typing.Optional[IMPORT_reboot_aio_types.StateId] = None + __options__: IMPORT_typing.Optional[IMPORT_reboot_aio_call.Options] = None + + if isinstance(__state_id_or_request_or_options__, IMPORT_reboot_aio_types.StateId): + __state_id__ = __state_id_or_request_or_options__ + if isinstance(__request_or_options_or_idempotency__, {{ client.proto.state_name }}.{{ method.proto.name }}Request): + __request__ = __request_or_options_or_idempotency__ + assert __options_or_idempotency__ is None or isinstance(__options_or_idempotency__, IMPORT_reboot_aio_call.Options) + __options__ = __options_or_idempotency__ + assert __idempotency__ is None or isinstance(__idempotency__, IMPORT_reboot_aio_idempotency.Idempotency) + + {# When specifying __request__ directly, we need to ensure that all other input fields are 'UNSET'. #} + {% for name in method.input_type_fields %} + assert {{ name }} is UNSET + {% endfor %} + else: + assert __request_or_options_or_idempotency__ is None or isinstance(__request_or_options_or_idempotency__, IMPORT_reboot_aio_call.Options) + __options__ = __request_or_options_or_idempotency__ + assert __options_or_idempotency__ is None or isinstance(__options_or_idempotency__, IMPORT_reboot_aio_idempotency.Idempotency) + __idempotency__ = __options_or_idempotency__ + + __request__ = {{ client.proto.state_name }}{{ method.proto.name }}RequestFromInputFields( + {% for name in method.input_type_fields %} + {{ name }}={{ name }}, + {% endfor %} + ) + elif isinstance(__state_id_or_request_or_options__, {{ client.proto.state_name }}.{{ method.proto.name }}Request): + __request__ = __state_id_or_request_or_options__ assert __request_or_options_or_idempotency__ is None or isinstance(__request_or_options_or_idempotency__, IMPORT_reboot_aio_call.Options) __options__ = __request_or_options_or_idempotency__ assert __options_or_idempotency__ is None or isinstance(__options_or_idempotency__, IMPORT_reboot_aio_idempotency.Idempotency) __idempotency__ = __options_or_idempotency__ + else: + assert ( + __state_id_or_request_or_options__ is None + or isinstance(__state_id_or_request_or_options__, IMPORT_reboot_aio_call.Options) + ), "Invalid argument type. Did you pass:\n" \ + " - A 'state_id' that is not of type 'reboot.aio.types.StateId'?\n" \ + " - 'options' that are not of type 'reboot.aio.call.Options'?" + __options__ = __state_id_or_request_or_options__ + assert __request_or_options_or_idempotency__ is None or isinstance(__request_or_options_or_idempotency__, IMPORT_reboot_aio_idempotency.Idempotency) + __idempotency__ = __request_or_options_or_idempotency__ __request__ = {{ client.proto.state_name }}{{ method.proto.name }}RequestFromInputFields( {% for name in method.input_type_fields %} {{ name }}={{ name }}, {% endfor %} ) - elif isinstance(__state_id_or_request_or_options__, {{ client.proto.state_name }}.{{ method.proto.name }}Request): - __request__ = __state_id_or_request_or_options__ - assert __request_or_options_or_idempotency__ is None or isinstance(__request_or_options_or_idempotency__, IMPORT_reboot_aio_call.Options) - __options__ = __request_or_options_or_idempotency__ - assert __options_or_idempotency__ is None or isinstance(__options_or_idempotency__, IMPORT_reboot_aio_idempotency.Idempotency) - __idempotency__ = __options_or_idempotency__ - else: - assert ( - __state_id_or_request_or_options__ is None - or isinstance(__state_id_or_request_or_options__, IMPORT_reboot_aio_call.Options) - ), "Invalid argument type. Did you pass:\n" \ - " - A 'state_id' that is not of type 'reboot.aio.types.StateId'?\n" \ - " - 'options' that are not of type 'reboot.aio.call.Options'?" - __options__ = __state_id_or_request_or_options__ - assert __request_or_options_or_idempotency__ is None or isinstance(__request_or_options_or_idempotency__, IMPORT_reboot_aio_idempotency.Idempotency) - __idempotency__ = __request_or_options_or_idempotency__ - - __request__ = {{ client.proto.state_name }}{{ method.proto.name }}RequestFromInputFields( - {% for name in method.input_type_fields %} - {{ name }}={{ name }}, - {% endfor %} - ) - {% else %} - assert __state_id__ is None or isinstance(__state_id__, IMPORT_reboot_aio_types.StateId) - assert __options__ is None or isinstance(__options__, IMPORT_reboot_aio_call.Options) - assert __idempotency__ is None or isinstance(__idempotency__, IMPORT_reboot_aio_idempotency.Idempotency) - {% endif %} + {% else %} + assert __state_id__ is None or isinstance(__state_id__, IMPORT_reboot_aio_types.StateId) + assert __options__ is None or isinstance(__options__, IMPORT_reboot_aio_call.Options) + assert __idempotency__ is None or isinstance(__idempotency__, IMPORT_reboot_aio_idempotency.Idempotency) + {% endif %} - if __idempotency__ is None: - __args__: tuple[IMPORT_typing.Any, ...] = ( - __context__, - ) - if __state_id__ is not None: - # Don't include `state_id` if it is `None`, so that - # we won't break the positional argument deduction. - __args__ += (__state_id__,) - __args__ += ( - {% if method.has_non_none_request %} - __request__, - {% endif %} - __options__, - ) - if isinstance(__context__, IMPORT_reboot_aio_contexts.WorkflowContext): - return await ( - __cls__.always() if __context__.within_until() - else ( - __cls__.per_iteration() if __context__.within_loop() - else __cls__.per_workflow() - ) - ).{{ method.proto.name }}( - *__args__ + if __idempotency__ is None: + __args__: tuple[IMPORT_typing.Any, ...] = ( + __context__, ) - elif isinstance(__context__, IMPORT_reboot_aio_external.InitializeContext): - return await __cls__.idempotently().{{ method.proto.name }}( - *__args__ + if __state_id__ is not None: + # Don't include `state_id` if it is `None`, so that + # we won't break the positional argument deduction. + __args__ += (__state_id__,) + __args__ += ( + {% if method.has_non_none_request %} + __request__, + {% endif %} + __options__, ) + if isinstance(__context__, IMPORT_reboot_aio_contexts.WorkflowContext): + return await ( + __cls__.always() if __context__.within_until() + else ( + __cls__.per_iteration() if __context__.within_loop() + else __cls__.per_workflow() + ) + ).{{ method.proto.name }}( + *__args__ + ) + elif isinstance(__context__, IMPORT_reboot_aio_external.InitializeContext): + return await __cls__.idempotently().{{ method.proto.name }}( + *__args__ + ) + + __metadata__: IMPORT_typing.Optional[IMPORT_reboot_aio_types.GrpcMetadata] = None + __bearer_token__: IMPORT_typing.Optional[str] = None - __metadata__: IMPORT_typing.Optional[IMPORT_reboot_aio_types.GrpcMetadata] = None - __bearer_token__: IMPORT_typing.Optional[str] = None + if __options__ is not None: + IMPORT_reboot_aio_types.assert_type(__options__, [IMPORT_reboot_aio_call.Options]) + if __options__.metadata is not None: + __metadata__ = __options__.metadata + if __options__.bearer_token is not None: + __bearer_token__ = __options__.bearer_token - if __options__ is not None: - IMPORT_reboot_aio_types.assert_type(__options__, [IMPORT_reboot_aio_call.Options]) - if __options__.metadata is not None: - __metadata__ = __options__.metadata - if __options__.bearer_token is not None: - __bearer_token__ = __options__.bearer_token + if __state_id__ is None: + if __idempotency__ is None: + __state_id__ = str(IMPORT_uuid.uuid4()) + else: + __state_id__ = __context__.generate_idempotent_state_id( + state_type_name={{ client.proto.state_name }}.__state_type_name__, + service_name=IMPORT_reboot_aio_types.ServiceName('{{ service.proto.full_name }}'), + method='{{ method.proto.name }}', + idempotency=__idempotency__, + ) - if __state_id__ is None: - if __idempotency__ is None: - __state_id__ = str(IMPORT_uuid.uuid4()) - else: - __state_id__ = __context__.generate_idempotent_state_id( - state_type_name=__cls__.__state_type_name__, - service_name=IMPORT_reboot_aio_types.ServiceName('{{ service.proto.full_name }}'), - method='{{ method.proto.name }}', - idempotency=__idempotency__, - ) + __reference__ = {{ client.proto.state_name }}.ref( + __state_id__, bearer_token=__bearer_token__ + ) + {% if method.options.proto.kind == 'writer' %} + __stub__ = __reference__._writer(__context__) + {% elif method.options.proto.kind == 'transaction' %} + __stub__ = __reference__._workflow(__context__) + {% endif %} + return ( + __reference__, + {{ client.proto.state_name }}{{ method.proto.name }}ResponseFromProto( + await __stub__.{{ method.proto.name }}( + {% if method.has_non_none_request %} + __request__, + {% endif %} + idempotency=__idempotency__, + metadata=__metadata__, + bearer_token=__bearer_token__, + ) + ), + ) - __reference__ = {{ client.proto.state_name }}.ref( - __state_id__, bearer_token=__bearer_token__ - ) - {% if method.options.proto.kind == 'writer' %} - __stub__ = __reference__._writer(__context__) - {% elif method.options.proto.kind == 'transaction' %} - __stub__ = __reference__._workflow(__context__) + # Keep the original functions on the client, so old code will + # continue to work, but use the new 'snake_case' method in + # the new code. + {{ method.proto.name | to_snake }} = {{ method.proto.name }} {% endif %} - return ( - __reference__, - {{ client.proto.state_name }}{{ method.proto.name }}ResponseFromProto( - await __stub__.{{ method.proto.name }}( - {% if method.has_non_none_request %} - __request__, - {% endif %} - idempotency=__idempotency__, - metadata=__metadata__, - bearer_token=__bearer_token__, - ) - ), - ) + {% endif %} + {% endfor %} + {% endfor %} - # Keep the original functions on the client, so old code will - # continue to work, but use the new 'snake_case' method in - # the new code. - {{ method.proto.name | to_snake }} = {{ method.proto.name }} - {% endif %} - {% endif %} - {% endfor %} - {% endfor %} + @IMPORT_typing.overload + @classmethod + def idempotently(cls, alias: IMPORT_typing.Optional[str] = None, *, how: IMPORT_reboot_aio_idempotency.How = IMPORT_reboot_aio_idempotency.PER_WORKFLOW) -> {{ client.proto.state_name }}._ConstructIdempotently: + ... - @IMPORT_typing.overload - @classmethod - def idempotently(cls, alias: IMPORT_typing.Optional[str] = None, *, how: IMPORT_reboot_aio_idempotency.How = IMPORT_reboot_aio_idempotency.PER_WORKFLOW) -> {{ client.proto.state_name }}._ConstructIdempotently: - ... + @IMPORT_typing.overload + @classmethod + def idempotently(cls, *, key: IMPORT_uuid.UUID, how: IMPORT_reboot_aio_idempotency.How = IMPORT_reboot_aio_idempotency.PER_WORKFLOW) -> {{ client.proto.state_name }}._ConstructIdempotently: + ... - @IMPORT_typing.overload - @classmethod - def idempotently(cls, *, key: IMPORT_uuid.UUID, how: IMPORT_reboot_aio_idempotency.How = IMPORT_reboot_aio_idempotency.PER_WORKFLOW) -> {{ client.proto.state_name }}._ConstructIdempotently: - ... + @classmethod + def idempotently( + cls, + alias: IMPORT_typing.Optional[str] = None, + *, + key: IMPORT_typing.Optional[IMPORT_uuid.UUID] = None, + how: IMPORT_typing.Optional[IMPORT_reboot_aio_idempotency.How] = None, + ) -> {{ client.proto.state_name }}._ConstructIdempotently: + return {{ client.proto.state_name }}._ConstructIdempotently( + _idempotency=IMPORT_reboot_aio_contexts.Context.idempotency( + alias=alias, + key=key, + how=how, + ), + ) - @classmethod - def idempotently( - cls, - alias: IMPORT_typing.Optional[str] = None, - *, - key: IMPORT_typing.Optional[IMPORT_uuid.UUID] = None, - how: IMPORT_typing.Optional[IMPORT_reboot_aio_idempotency.How] = None, - ) -> {{ client.proto.state_name }}._ConstructIdempotently: - return {{ client.proto.state_name }}._ConstructIdempotently( - _idempotency=IMPORT_reboot_aio_contexts.Context.idempotency( - alias=alias, - key=key, - how=how, - ), - ) + @classmethod + def per_workflow( + cls, + alias: IMPORT_typing.Optional[str] = None, + ): + return cls.idempotently(alias) - @classmethod - def per_workflow( - cls, - alias: IMPORT_typing.Optional[str] = None, - ): - return cls.idempotently(alias) + @classmethod + def per_iteration( + cls, + alias: IMPORT_typing.Optional[str] = None, + ): + return cls.idempotently( + alias, + how=IMPORT_reboot_aio_idempotency.PER_ITERATION, + ) - @classmethod - def per_iteration( - cls, - alias: IMPORT_typing.Optional[str] = None, - ): - return cls.idempotently( - alias, - how=IMPORT_reboot_aio_idempotency.PER_ITERATION, - ) + @classmethod + def always(cls): + return cls.idempotently( + how=IMPORT_reboot_aio_idempotency.ALWAYS, + ) - @classmethod - def always(cls): - return cls.idempotently( - how=IMPORT_reboot_aio_idempotency.ALWAYS, - ) + factory = _Factory @IMPORT_dataclasses.dataclass(frozen=True) class _ConstructIdempotently: @@ -7629,7 +7632,7 @@ class {{ client.proto.state_name }}: __this__._idempotency, ) - return await {{ client.proto.state_name }}.{{ method.proto.name }}( + return await {{ client.proto.state_name }}.factory.{{ method.proto.name }}( *__args__, ) diff --git a/reboot/templates/reboot.ts.j2 b/reboot/templates/reboot.ts.j2 index 85d98d528..c4fdb85af 100644 --- a/reboot/templates/reboot.ts.j2 +++ b/reboot/templates/reboot.ts.j2 @@ -2212,62 +2212,7 @@ export class {{ client.proto.state_name }}WeakReference { } } -export class {{ client.proto.state_name }} { - - {% if client.state is not none %} - static singleton = { Servicer: {{ client.proto.state_name }}SingletonServicer }; - static Servicer = {{ client.proto.state_name }}Servicer; - static servicer = {{ client.proto.state_name }}BaseServicer.servicer; - static State = {{ client.proto.state_name }}State; - static Authorizer = {{ client.proto.state_name }}Authorizer; - {% endif %} - static WeakReference = {{ client.proto.state_name }}WeakReference; - - {% for service in client.services %} - {% for method in service.methods %} - - static {{ method.proto.name }}Aborted = {{ client.proto.state_name }}{{ method.proto.name }}Aborted; - - static {{ method.proto.name }}Task = {{ client.proto.state_name }}{{ method.proto.name }}Task; - - {% endfor %} - {% endfor %} - - public static ref( - idOrOptions?: string | { bearerToken?: string | null }, - options?: { bearerToken?: string | null } - ) { - if (idOrOptions === undefined || typeof idOrOptions === "object") { - const context = reboot.getContext(); - if (context instanceof WorkflowContext) { - // We support calling `{{ client.proto.state_name }}.ref()` with - // no `id` __only__ inside a workflow to be able to call an - // inline writer, inline reader or other method call, since - // workflow is a `static` and therefor we can't get a - // reference to outselves as `this.ref()`. - const servicer = {{ client.proto.state_name }}BaseServicer.__servicer__.getStore()?.servicer; - - {# We temporary don't assert that servicer is not undefined - because we still support old style workflow methods, when we - complete the migration we should remove this check. #} - if (servicer !== undefined) { - return new {{ client.proto.state_name }}.WeakReference( - context.stateId, - idOrOptions?.bearerToken, - servicer, - ); - } - } - return new {{ client.proto.state_name }}.WeakReference(context.stateId, idOrOptions?.bearerToken); - } - if (typeof idOrOptions !== "string") { - throw new TypeError( - `Expecting first argument to be a 'string' "id", ` + - `got '${typeof idOrOptions}'` - ); - } - return new {{ client.proto.state_name }}.WeakReference(idOrOptions, options?.bearerToken); - } +export class {{ client.proto.state_name }}Factory { {% for service in client.services %} {% for method in service.methods %} @@ -2275,7 +2220,7 @@ export class {{ client.proto.state_name }} { {# TODO(benh): support constructor "tasks" and workflows. #} {%- else %} {% if method.options.proto.constructor %} - public async {{ method.proto.name | to_lower_camel }}( + static async {{ method.proto.name | to_lower_camel }}( context: reboot.TransactionContext | reboot.WorkflowContext | reboot.ExternalContext, partialRequest?: {{ client.proto.state_name }}.Partial{{ method.proto.name }}Request, options?: { bearerToken?: string | null } @@ -2288,7 +2233,7 @@ export class {{ client.proto.state_name }} { {% endif %} ]>; - public async {{ method.proto.name | to_lower_camel }}( + static async {{ method.proto.name | to_lower_camel }}( context: reboot.TransactionContext | reboot.WorkflowContext | reboot.ExternalContext, id: string, partialRequest?: {{ client.proto.state_name }}.Partial{{ method.proto.name }}Request, @@ -2302,7 +2247,7 @@ export class {{ client.proto.state_name }} { {% endif %} ]>; - public static async {{ method.proto.name | to_lower_camel }}( + static async {{ method.proto.name | to_lower_camel }}( context: reboot.TransactionContext | reboot.WorkflowContext | reboot.ExternalContext, idOrPartialRequest?: string | {{ client.proto.state_name }}.Partial{{ method.proto.name }}Request, partialRequestOrOptions?: {{ client.proto.state_name }}.Partial{{ method.proto.name }}Request | { bearerToken?: string | null }, @@ -2328,7 +2273,7 @@ export class {{ client.proto.state_name }} { options = partialRequestOrOptions; if (optionsOrUndefined !== undefined) { throw new Error( - `Invalid arguments passed to '{{ client.proto.state_name }}.{{ method.proto.name | to_lower_camel }}'` + `Invalid arguments passed to '{{ client.proto.state_name }}.factory.{{ method.proto.name | to_lower_camel }}'` ); } } @@ -2337,8 +2282,8 @@ export class {{ client.proto.state_name }} { if (context instanceof WorkflowContext) { return await ( reboot.isWithinLoop() - ? {{ client.proto.state_name }}.perIteration() - : {{ client.proto.state_name }}.perWorkflow() + ? {{ client.proto.state_name }}.factory.perIteration() + : {{ client.proto.state_name }}.factory.perWorkflow() ).{{ method.proto.name | to_lower_camel }}( context, idOrPartialRequest, @@ -2346,7 +2291,7 @@ export class {{ client.proto.state_name }} { optionsOrUndefined ); } else if (context instanceof InitializeContext) { - return await {{ client.proto.state_name }}.idempotently() + return await {{ client.proto.state_name }}.factory.idempotently() .{{ method.proto.name | to_lower_camel }}( context, idOrPartialRequest, @@ -2378,6 +2323,86 @@ export class {{ client.proto.state_name }} { {% endif %} {% endfor %} {% endfor %} + static idempotently(aliasOrOptions: string | reboot_api.IdempotencyOptions = {} as reboot_api.IdempotencyOptions) { + const idempotency = (typeof aliasOrOptions === "string" || aliasOrOptions instanceof String) ? { alias: aliasOrOptions as string } : aliasOrOptions; + return new {{ client.proto.state_name }}._ConstructIdempotently(idempotency); + } + + static perWorkflow(alias?: string) { + return {{ client.proto.state_name }}.factory + .idempotently({ alias }); + } + + static perIteration(alias?: string) { + return {{ client.proto.state_name }}.factory + .idempotently({ alias, perIteration: true }); + } + + static always() { + return {{ client.proto.state_name }}.factory + .idempotently({ always: true }); + } +} + +export class {{ client.proto.state_name }} { + + {% if client.state is not none %} + static singleton = { Servicer: {{ client.proto.state_name }}SingletonServicer }; + static Servicer = {{ client.proto.state_name }}Servicer; + static servicer = {{ client.proto.state_name }}BaseServicer.servicer; + static State = {{ client.proto.state_name }}State; + static Authorizer = {{ client.proto.state_name }}Authorizer; + {% endif %} + static WeakReference = {{ client.proto.state_name }}WeakReference; + + {% for service in client.services %} + {% for method in service.methods %} + + static {{ method.proto.name }}Aborted = {{ client.proto.state_name }}{{ method.proto.name }}Aborted; + + static {{ method.proto.name }}Task = {{ client.proto.state_name }}{{ method.proto.name }}Task; + + {% endfor %} + {% endfor %} + + static factory = {{ client.proto.state_name }}Factory; + + public static ref( + idOrOptions?: string | { bearerToken?: string | null }, + options?: { bearerToken?: string | null } + ) { + if (idOrOptions === undefined || typeof idOrOptions === "object") { + const context = reboot.getContext(); + if (context instanceof WorkflowContext) { + // We support calling `{{ client.proto.state_name }}.ref()` with + // no `id` __only__ inside a workflow to be able to call an + // inline writer, inline reader or other method call, since + // workflow is a `static` and therefor we can't get a + // reference to outselves as `this.ref()`. + const servicer = {{ client.proto.state_name }}BaseServicer.__servicer__.getStore()?.servicer; + + {# We temporary don't assert that servicer is not undefined + because we still support old style workflow methods, when we + complete the migration we should remove this check. #} + if (servicer !== undefined) { + return new {{ client.proto.state_name }}.WeakReference( + context.stateId, + idOrOptions?.bearerToken, + servicer, + ); + } + } + return new {{ client.proto.state_name }}.WeakReference(context.stateId, idOrOptions?.bearerToken); + } + if (typeof idOrOptions !== "string") { + throw new TypeError( + `Expecting first argument to be a 'string' "id", ` + + `got '${typeof idOrOptions}'` + ); + } + return new {{ client.proto.state_name }}.WeakReference(idOrOptions, options?.bearerToken); + } + static _Forall = class { #ids: string[]; @@ -2422,25 +2447,6 @@ export class {{ client.proto.state_name }} { return new {{ client.proto.state_name }}._Forall(ids); } - public static idempotently(aliasOrOptions: string | reboot_api.IdempotencyOptions = {} as reboot_api.IdempotencyOptions) { - const idempotency = (typeof aliasOrOptions === "string" || aliasOrOptions instanceof String) ? { alias: aliasOrOptions as string } : aliasOrOptions; - return new {{ client.proto.state_name }}._ConstructIdempotently(idempotency); - } - - public static perWorkflow(alias?: string) { - return {{ client.proto.state_name }} - .idempotently({ alias }); - } - - public static perIteration(alias?: string) { - return {{ client.proto.state_name }} - .idempotently({ alias, perIteration: true }); - } - - public static always() { - return {{ client.proto.state_name }} - .idempotently({ always: true }); - } static _ConstructIdempotently = class { #idempotency: reboot_api.IdempotencyOptions; @@ -2522,7 +2528,7 @@ export class {{ client.proto.state_name }} { ) as string; } - return await {{ client.proto.state_name }}.{{ method.proto.name | to_lower_camel }}( + return await {{ client.proto.state_name }}.factory.{{ method.proto.name | to_lower_camel }}( context, id, partialRequest, diff --git a/reboot/templates/reboot_web.ts.j2 b/reboot/templates/reboot_web.ts.j2 index fa40f8213..91ef19c55 100644 --- a/reboot/templates/reboot_web.ts.j2 +++ b/reboot/templates/reboot_web.ts.j2 @@ -602,23 +602,14 @@ export class {{ client.proto.state_name }}WeakReference { {% endfor %} } -export class {{ client.proto.state_name }} { - - static WeakReference = {{ client.proto.state_name }}WeakReference; - - public static ref( - id: string, - options?: { bearerToken?: string } - ) { - return new {{ client.proto.state_name }}.WeakReference(id, options?.bearerToken); - } +export class {{ client.proto.state_name }}Factory { {% for service in client.services %} {% for method in service.methods %} {%- if method.options.proto.kind == 'workflow' %} {# TODO(benh): support "tasks" and workflows. #} {% elif method.options.proto.constructor %} - public static async {{ method.proto.name | to_lower_camel }}( + static async {{ method.proto.name | to_lower_camel }}( context: reboot_web.WebContext, idOrPartialRequest?: string | {{ client.proto.state_name }}.Partial{{ method.proto.name }}Request, inputPartialRequest?: {{ client.proto.state_name }}.Partial{{ method.proto.name }}Request, @@ -659,6 +650,21 @@ export class {{ client.proto.state_name }} { {% endif %} {% endfor %} {% endfor %} +} + +export class {{ client.proto.state_name }} { + + static WeakReference = {{ client.proto.state_name }}WeakReference; + + static factory = {{ client.proto.state_name }}Factory; + + public static ref( + id: string, + options?: { bearerToken?: string } + ) { + return new {{ client.proto.state_name }}.WeakReference(id, options?.bearerToken); + } + } diff --git a/tests/reboot/echo_rbt.golden.py b/tests/reboot/echo_rbt.golden.py index 9fbba8531..0b61381e3 100755 --- a/tests/reboot/echo_rbt.golden.py +++ b/tests/reboot/echo_rbt.golden.py @@ -29182,55 +29182,58 @@ def ref( bearer_token=bearer_token, ) + class _Factory: - @IMPORT_typing.overload - @classmethod - def idempotently(cls, alias: IMPORT_typing.Optional[str] = None, *, how: IMPORT_reboot_aio_idempotency.How = IMPORT_reboot_aio_idempotency.PER_WORKFLOW) -> Echo._ConstructIdempotently: - ... + @IMPORT_typing.overload + @classmethod + def idempotently(cls, alias: IMPORT_typing.Optional[str] = None, *, how: IMPORT_reboot_aio_idempotency.How = IMPORT_reboot_aio_idempotency.PER_WORKFLOW) -> Echo._ConstructIdempotently: + ... - @IMPORT_typing.overload - @classmethod - def idempotently(cls, *, key: IMPORT_uuid.UUID, how: IMPORT_reboot_aio_idempotency.How = IMPORT_reboot_aio_idempotency.PER_WORKFLOW) -> Echo._ConstructIdempotently: - ... + @IMPORT_typing.overload + @classmethod + def idempotently(cls, *, key: IMPORT_uuid.UUID, how: IMPORT_reboot_aio_idempotency.How = IMPORT_reboot_aio_idempotency.PER_WORKFLOW) -> Echo._ConstructIdempotently: + ... - @classmethod - def idempotently( - cls, - alias: IMPORT_typing.Optional[str] = None, - *, - key: IMPORT_typing.Optional[IMPORT_uuid.UUID] = None, - how: IMPORT_typing.Optional[IMPORT_reboot_aio_idempotency.How] = None, - ) -> Echo._ConstructIdempotently: - return Echo._ConstructIdempotently( - _idempotency=IMPORT_reboot_aio_contexts.Context.idempotency( - alias=alias, - key=key, - how=how, - ), - ) + @classmethod + def idempotently( + cls, + alias: IMPORT_typing.Optional[str] = None, + *, + key: IMPORT_typing.Optional[IMPORT_uuid.UUID] = None, + how: IMPORT_typing.Optional[IMPORT_reboot_aio_idempotency.How] = None, + ) -> Echo._ConstructIdempotently: + return Echo._ConstructIdempotently( + _idempotency=IMPORT_reboot_aio_contexts.Context.idempotency( + alias=alias, + key=key, + how=how, + ), + ) - @classmethod - def per_workflow( - cls, - alias: IMPORT_typing.Optional[str] = None, - ): - return cls.idempotently(alias) + @classmethod + def per_workflow( + cls, + alias: IMPORT_typing.Optional[str] = None, + ): + return cls.idempotently(alias) - @classmethod - def per_iteration( - cls, - alias: IMPORT_typing.Optional[str] = None, - ): - return cls.idempotently( - alias, - how=IMPORT_reboot_aio_idempotency.PER_ITERATION, - ) + @classmethod + def per_iteration( + cls, + alias: IMPORT_typing.Optional[str] = None, + ): + return cls.idempotently( + alias, + how=IMPORT_reboot_aio_idempotency.PER_ITERATION, + ) - @classmethod - def always(cls): - return cls.idempotently( - how=IMPORT_reboot_aio_idempotency.ALWAYS, - ) + @classmethod + def always(cls): + return cls.idempotently( + how=IMPORT_reboot_aio_idempotency.ALWAYS, + ) + + factory = _Factory @IMPORT_dataclasses.dataclass(frozen=True) class _ConstructIdempotently: diff --git a/tests/reboot/greeter_rbt.golden.js b/tests/reboot/greeter_rbt.golden.js index 391cc3b83..3dec10fbe 100755 --- a/tests/reboot/greeter_rbt.golden.js +++ b/tests/reboot/greeter_rbt.golden.js @@ -5306,29 +5306,7 @@ GreeterWeakReference._Spawn = (_g = class { _weakReference_2 = new WeakMap(), _options_2 = new WeakMap(), _g); -export class Greeter { - static ref(idOrOptions, options) { - if (idOrOptions === undefined || typeof idOrOptions === "object") { - const context = reboot.getContext(); - if (context instanceof WorkflowContext) { - // We support calling `Greeter.ref()` with - // no `id` __only__ inside a workflow to be able to call an - // inline writer, inline reader or other method call, since - // workflow is a `static` and therefor we can't get a - // reference to outselves as `this.ref()`. - const servicer = GreeterBaseServicer.__servicer__.getStore()?.servicer; - if (servicer !== undefined) { - return new Greeter.WeakReference(context.stateId, idOrOptions?.bearerToken, servicer); - } - } - return new Greeter.WeakReference(context.stateId, idOrOptions?.bearerToken); - } - if (typeof idOrOptions !== "string") { - throw new TypeError(`Expecting first argument to be a 'string' "id", ` + - `got '${typeof idOrOptions}'`); - } - return new Greeter.WeakReference(idOrOptions, options?.bearerToken); - } +export class GreeterFactory { static async create(context, idOrPartialRequest, partialRequestOrOptions, optionsOrUndefined) { let id = undefined; let partialRequest = undefined; @@ -5342,17 +5320,17 @@ export class Greeter { partialRequest = idOrPartialRequest; options = partialRequestOrOptions; if (optionsOrUndefined !== undefined) { - throw new Error(`Invalid arguments passed to 'Greeter.create'`); + throw new Error(`Invalid arguments passed to 'Greeter.factory.create'`); } } if (options === undefined || !("idempotency" in options)) { if (context instanceof WorkflowContext) { return await (reboot.isWithinLoop() - ? Greeter.perIteration() - : Greeter.perWorkflow()).create(context, idOrPartialRequest, partialRequestOrOptions, optionsOrUndefined); + ? Greeter.factory.perIteration() + : Greeter.factory.perWorkflow()).create(context, idOrPartialRequest, partialRequestOrOptions, optionsOrUndefined); } else if (context instanceof InitializeContext) { - return await Greeter.idempotently() + return await Greeter.factory.idempotently() .create(context, idOrPartialRequest, partialRequestOrOptions, optionsOrUndefined); } } @@ -5366,26 +5344,50 @@ export class Greeter { response, ]; } - static forall(ids) { - return new Greeter._Forall(ids); - } static idempotently(aliasOrOptions = {}) { const idempotency = (typeof aliasOrOptions === "string" || aliasOrOptions instanceof String) ? { alias: aliasOrOptions } : aliasOrOptions; return new Greeter._ConstructIdempotently(idempotency); } static perWorkflow(alias) { - return Greeter + return Greeter.factory .idempotently({ alias }); } static perIteration(alias) { - return Greeter + return Greeter.factory .idempotently({ alias, perIteration: true }); } static always() { - return Greeter + return Greeter.factory .idempotently({ always: true }); } } +export class Greeter { + static ref(idOrOptions, options) { + if (idOrOptions === undefined || typeof idOrOptions === "object") { + const context = reboot.getContext(); + if (context instanceof WorkflowContext) { + // We support calling `Greeter.ref()` with + // no `id` __only__ inside a workflow to be able to call an + // inline writer, inline reader or other method call, since + // workflow is a `static` and therefor we can't get a + // reference to outselves as `this.ref()`. + const servicer = GreeterBaseServicer.__servicer__.getStore()?.servicer; + if (servicer !== undefined) { + return new Greeter.WeakReference(context.stateId, idOrOptions?.bearerToken, servicer); + } + } + return new Greeter.WeakReference(context.stateId, idOrOptions?.bearerToken); + } + if (typeof idOrOptions !== "string") { + throw new TypeError(`Expecting first argument to be a 'string' "id", ` + + `got '${typeof idOrOptions}'`); + } + return new Greeter.WeakReference(idOrOptions, options?.bearerToken); + } + static forall(ids) { + return new Greeter._Forall(ids); + } +} Greeter.singleton = { Servicer: GreeterSingletonServicer }; Greeter.Servicer = GreeterServicer; Greeter.servicer = GreeterBaseServicer.servicer; @@ -5424,6 +5426,7 @@ Greeter.ReadRecursiveMessageAborted = GreeterReadRecursiveMessageAborted; Greeter.ReadRecursiveMessageTask = GreeterReadRecursiveMessageTask; Greeter.ConstructAndStoreRecursiveMessageAborted = GreeterConstructAndStoreRecursiveMessageAborted; Greeter.ConstructAndStoreRecursiveMessageTask = GreeterConstructAndStoreRecursiveMessageTask; +Greeter.factory = GreeterFactory; Greeter._Forall = (_h = class { constructor(ids) { _ids.set(this, void 0); @@ -5498,7 +5501,7 @@ Greeter._ConstructIdempotently = (_j = class { if (id === undefined) { id = await context.generateIdempotentStateId("tests.reboot.Greeter", "tests.reboot.GreeterMethods", "Create", __classPrivateFieldGet(this, _idempotency_1, "f")); } - return await Greeter.create(context, id, partialRequest, { + return await Greeter.factory.create(context, id, partialRequest, { ...options, idempotency: __classPrivateFieldGet(this, _idempotency_1, "f"), }); @@ -5509,6 +5512,6 @@ Greeter._ConstructIdempotently = (_j = class { export function importPys() { reboot_native.importPy("tests.reboot.greeter_pb2", "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"); reboot_native.importPy("tests.reboot.greeter_pb2_grpc", "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"); - reboot_native.importPy("tests.reboot.greeter_rbt", "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"); + reboot_native.importPy("tests.reboot.greeter_rbt", "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"); } importPys(); diff --git a/tests/reboot/greeter_rbt.golden.py b/tests/reboot/greeter_rbt.golden.py index 49d0dc8e7..6e78248d3 100755 --- a/tests/reboot/greeter_rbt.golden.py +++ b/tests/reboot/greeter_rbt.golden.py @@ -32205,220 +32205,223 @@ def ref( bearer_token=bearer_token, ) - @IMPORT_typing.overload - @classmethod - async def Create( - __cls__, - __context__: IMPORT_reboot_aio_contexts.TransactionContext | IMPORT_reboot_aio_contexts.WorkflowContext | IMPORT_reboot_aio_external.ExternalContext, - __state_id_or_request_or_options__: IMPORT_typing.Optional[IMPORT_reboot_aio_types.StateId | Greeter.CreateRequest] = None, - __request_or_options_or_idempotency__: IMPORT_typing.Optional[Greeter.CreateRequest | IMPORT_reboot_aio_call.Options] = None, - __options_or_idempotency__: IMPORT_typing.Optional[IMPORT_reboot_aio_call.Options | IMPORT_reboot_aio_idempotency.Idempotency] = None, - __idempotency__: IMPORT_typing.Optional[IMPORT_reboot_aio_idempotency.Idempotency] = None, - ) -> tuple[Greeter.WeakReference, Greeter.CreateResponse]: - ... - - @IMPORT_typing.overload - @classmethod - async def Create( - __cls__, - __context__: IMPORT_reboot_aio_contexts.TransactionContext | IMPORT_reboot_aio_contexts.WorkflowContext | IMPORT_reboot_aio_external.ExternalContext, - __state_id_or_request_or_options__: IMPORT_typing.Optional[IMPORT_reboot_aio_types.StateId | IMPORT_reboot_aio_call.Options] = None, - __request_or_options_or_idempotency__: IMPORT_typing.Optional[IMPORT_reboot_aio_call.Options | IMPORT_reboot_aio_idempotency.Idempotency] = None, - __options_or_idempotency__: IMPORT_typing.Optional[IMPORT_reboot_aio_idempotency.Idempotency] = None, - *, - title: IMPORT_typing.Optional[str] | Unset = UNSET, - name: IMPORT_typing.Optional[str] | Unset = UNSET, - adjective: IMPORT_typing.Optional[str] | Unset = UNSET, - ) -> tuple[Greeter.WeakReference, Greeter.CreateResponse]: - ... + class _Factory: + @IMPORT_typing.overload + @classmethod + async def Create( + __cls__, + __context__: IMPORT_reboot_aio_contexts.TransactionContext | IMPORT_reboot_aio_contexts.WorkflowContext | IMPORT_reboot_aio_external.ExternalContext, + __state_id_or_request_or_options__: IMPORT_typing.Optional[IMPORT_reboot_aio_types.StateId | Greeter.CreateRequest] = None, + __request_or_options_or_idempotency__: IMPORT_typing.Optional[Greeter.CreateRequest | IMPORT_reboot_aio_call.Options] = None, + __options_or_idempotency__: IMPORT_typing.Optional[IMPORT_reboot_aio_call.Options | IMPORT_reboot_aio_idempotency.Idempotency] = None, + __idempotency__: IMPORT_typing.Optional[IMPORT_reboot_aio_idempotency.Idempotency] = None, + ) -> tuple[Greeter.WeakReference, Greeter.CreateResponse]: + ... - @classmethod - async def Create( # type: ignore[misc] - __cls__, - __context__: IMPORT_reboot_aio_contexts.TransactionContext | IMPORT_reboot_aio_contexts.WorkflowContext | IMPORT_reboot_aio_external.ExternalContext, - __state_id_or_request_or_options__: IMPORT_typing.Optional[IMPORT_reboot_aio_types.StateId | Greeter.CreateRequest | IMPORT_reboot_aio_call.Options] = None, - __request_or_options_or_idempotency__: IMPORT_typing.Optional[Greeter.CreateRequest | IMPORT_reboot_aio_call.Options | IMPORT_reboot_aio_idempotency.Idempotency] = None, - __options_or_idempotency__: IMPORT_typing.Optional[IMPORT_reboot_aio_call.Options | IMPORT_reboot_aio_idempotency.Idempotency] = None, - __idempotency__: IMPORT_typing.Optional[IMPORT_reboot_aio_idempotency.Idempotency] = None, - *, - title: IMPORT_typing.Optional[str] | Unset = UNSET, - name: IMPORT_typing.Optional[str] | Unset = UNSET, - adjective: IMPORT_typing.Optional[str] | Unset = UNSET, - ) -> tuple[Greeter.WeakReference, Greeter.CreateResponse]: - # Within a `workflow`, all "bare" calls are - # `per_workflow()` calls, unless we're within a control - # loop, in which case they are syntactic sugar for - # `per_iteration()`. - # - # Unless we are "within until" in which case all "bare" - # calls are `.always()`. - - __request__: IMPORT_typing.Optional[Greeter.CreateRequest] = None - __state_id__: IMPORT_typing.Optional[IMPORT_reboot_aio_types.StateId] = None - __options__: IMPORT_typing.Optional[IMPORT_reboot_aio_call.Options] = None - - if isinstance(__state_id_or_request_or_options__, IMPORT_reboot_aio_types.StateId): - __state_id__ = __state_id_or_request_or_options__ - if isinstance(__request_or_options_or_idempotency__, Greeter.CreateRequest): - __request__ = __request_or_options_or_idempotency__ - assert __options_or_idempotency__ is None or isinstance(__options_or_idempotency__, IMPORT_reboot_aio_call.Options) - __options__ = __options_or_idempotency__ - assert __idempotency__ is None or isinstance(__idempotency__, IMPORT_reboot_aio_idempotency.Idempotency) - - assert title is UNSET - assert name is UNSET - assert adjective is UNSET - else: + @IMPORT_typing.overload + @classmethod + async def Create( + __cls__, + __context__: IMPORT_reboot_aio_contexts.TransactionContext | IMPORT_reboot_aio_contexts.WorkflowContext | IMPORT_reboot_aio_external.ExternalContext, + __state_id_or_request_or_options__: IMPORT_typing.Optional[IMPORT_reboot_aio_types.StateId | IMPORT_reboot_aio_call.Options] = None, + __request_or_options_or_idempotency__: IMPORT_typing.Optional[IMPORT_reboot_aio_call.Options | IMPORT_reboot_aio_idempotency.Idempotency] = None, + __options_or_idempotency__: IMPORT_typing.Optional[IMPORT_reboot_aio_idempotency.Idempotency] = None, + *, + title: IMPORT_typing.Optional[str] | Unset = UNSET, + name: IMPORT_typing.Optional[str] | Unset = UNSET, + adjective: IMPORT_typing.Optional[str] | Unset = UNSET, + ) -> tuple[Greeter.WeakReference, Greeter.CreateResponse]: + ... + + @classmethod + async def Create( # type: ignore[misc] + __cls__, + __context__: IMPORT_reboot_aio_contexts.TransactionContext | IMPORT_reboot_aio_contexts.WorkflowContext | IMPORT_reboot_aio_external.ExternalContext, + __state_id_or_request_or_options__: IMPORT_typing.Optional[IMPORT_reboot_aio_types.StateId | Greeter.CreateRequest | IMPORT_reboot_aio_call.Options] = None, + __request_or_options_or_idempotency__: IMPORT_typing.Optional[Greeter.CreateRequest | IMPORT_reboot_aio_call.Options | IMPORT_reboot_aio_idempotency.Idempotency] = None, + __options_or_idempotency__: IMPORT_typing.Optional[IMPORT_reboot_aio_call.Options | IMPORT_reboot_aio_idempotency.Idempotency] = None, + __idempotency__: IMPORT_typing.Optional[IMPORT_reboot_aio_idempotency.Idempotency] = None, + *, + title: IMPORT_typing.Optional[str] | Unset = UNSET, + name: IMPORT_typing.Optional[str] | Unset = UNSET, + adjective: IMPORT_typing.Optional[str] | Unset = UNSET, + ) -> tuple[Greeter.WeakReference, Greeter.CreateResponse]: + # Within a `workflow`, all "bare" calls are + # `per_workflow()` calls, unless we're within a control + # loop, in which case they are syntactic sugar for + # `per_iteration()`. + # + # Unless we are "within until" in which case all "bare" + # calls are `.always()`. + + __request__: IMPORT_typing.Optional[Greeter.CreateRequest] = None + __state_id__: IMPORT_typing.Optional[IMPORT_reboot_aio_types.StateId] = None + __options__: IMPORT_typing.Optional[IMPORT_reboot_aio_call.Options] = None + + if isinstance(__state_id_or_request_or_options__, IMPORT_reboot_aio_types.StateId): + __state_id__ = __state_id_or_request_or_options__ + if isinstance(__request_or_options_or_idempotency__, Greeter.CreateRequest): + __request__ = __request_or_options_or_idempotency__ + assert __options_or_idempotency__ is None or isinstance(__options_or_idempotency__, IMPORT_reboot_aio_call.Options) + __options__ = __options_or_idempotency__ + assert __idempotency__ is None or isinstance(__idempotency__, IMPORT_reboot_aio_idempotency.Idempotency) + + assert title is UNSET + assert name is UNSET + assert adjective is UNSET + else: + assert __request_or_options_or_idempotency__ is None or isinstance(__request_or_options_or_idempotency__, IMPORT_reboot_aio_call.Options) + __options__ = __request_or_options_or_idempotency__ + assert __options_or_idempotency__ is None or isinstance(__options_or_idempotency__, IMPORT_reboot_aio_idempotency.Idempotency) + __idempotency__ = __options_or_idempotency__ + + __request__ = GreeterCreateRequestFromInputFields( + title=title, + name=name, + adjective=adjective, + ) + elif isinstance(__state_id_or_request_or_options__, Greeter.CreateRequest): + __request__ = __state_id_or_request_or_options__ assert __request_or_options_or_idempotency__ is None or isinstance(__request_or_options_or_idempotency__, IMPORT_reboot_aio_call.Options) __options__ = __request_or_options_or_idempotency__ assert __options_or_idempotency__ is None or isinstance(__options_or_idempotency__, IMPORT_reboot_aio_idempotency.Idempotency) __idempotency__ = __options_or_idempotency__ + else: + assert ( + __state_id_or_request_or_options__ is None + or isinstance(__state_id_or_request_or_options__, IMPORT_reboot_aio_call.Options) + ), "Invalid argument type. Did you pass:\n" \ + " - A 'state_id' that is not of type 'reboot.aio.types.StateId'?\n" \ + " - 'options' that are not of type 'reboot.aio.call.Options'?" + __options__ = __state_id_or_request_or_options__ + assert __request_or_options_or_idempotency__ is None or isinstance(__request_or_options_or_idempotency__, IMPORT_reboot_aio_idempotency.Idempotency) + __idempotency__ = __request_or_options_or_idempotency__ __request__ = GreeterCreateRequestFromInputFields( title=title, name=name, adjective=adjective, ) - elif isinstance(__state_id_or_request_or_options__, Greeter.CreateRequest): - __request__ = __state_id_or_request_or_options__ - assert __request_or_options_or_idempotency__ is None or isinstance(__request_or_options_or_idempotency__, IMPORT_reboot_aio_call.Options) - __options__ = __request_or_options_or_idempotency__ - assert __options_or_idempotency__ is None or isinstance(__options_or_idempotency__, IMPORT_reboot_aio_idempotency.Idempotency) - __idempotency__ = __options_or_idempotency__ - else: - assert ( - __state_id_or_request_or_options__ is None - or isinstance(__state_id_or_request_or_options__, IMPORT_reboot_aio_call.Options) - ), "Invalid argument type. Did you pass:\n" \ - " - A 'state_id' that is not of type 'reboot.aio.types.StateId'?\n" \ - " - 'options' that are not of type 'reboot.aio.call.Options'?" - __options__ = __state_id_or_request_or_options__ - assert __request_or_options_or_idempotency__ is None or isinstance(__request_or_options_or_idempotency__, IMPORT_reboot_aio_idempotency.Idempotency) - __idempotency__ = __request_or_options_or_idempotency__ - - __request__ = GreeterCreateRequestFromInputFields( - title=title, - name=name, - adjective=adjective, - ) - - if __idempotency__ is None: - __args__: tuple[IMPORT_typing.Any, ...] = ( - __context__, - ) - if __state_id__ is not None: - # Don't include `state_id` if it is `None`, so that - # we won't break the positional argument deduction. - __args__ += (__state_id__,) - __args__ += ( - __request__, - __options__, - ) - if isinstance(__context__, IMPORT_reboot_aio_contexts.WorkflowContext): - return await ( - __cls__.always() if __context__.within_until() - else ( - __cls__.per_iteration() if __context__.within_loop() - else __cls__.per_workflow() - ) - ).Create( - *__args__ + + if __idempotency__ is None: + __args__: tuple[IMPORT_typing.Any, ...] = ( + __context__, ) - elif isinstance(__context__, IMPORT_reboot_aio_external.InitializeContext): - return await __cls__.idempotently().Create( - *__args__ + if __state_id__ is not None: + # Don't include `state_id` if it is `None`, so that + # we won't break the positional argument deduction. + __args__ += (__state_id__,) + __args__ += ( + __request__, + __options__, ) + if isinstance(__context__, IMPORT_reboot_aio_contexts.WorkflowContext): + return await ( + __cls__.always() if __context__.within_until() + else ( + __cls__.per_iteration() if __context__.within_loop() + else __cls__.per_workflow() + ) + ).Create( + *__args__ + ) + elif isinstance(__context__, IMPORT_reboot_aio_external.InitializeContext): + return await __cls__.idempotently().Create( + *__args__ + ) - __metadata__: IMPORT_typing.Optional[IMPORT_reboot_aio_types.GrpcMetadata] = None - __bearer_token__: IMPORT_typing.Optional[str] = None + __metadata__: IMPORT_typing.Optional[IMPORT_reboot_aio_types.GrpcMetadata] = None + __bearer_token__: IMPORT_typing.Optional[str] = None - if __options__ is not None: - IMPORT_reboot_aio_types.assert_type(__options__, [IMPORT_reboot_aio_call.Options]) - if __options__.metadata is not None: - __metadata__ = __options__.metadata - if __options__.bearer_token is not None: - __bearer_token__ = __options__.bearer_token + if __options__ is not None: + IMPORT_reboot_aio_types.assert_type(__options__, [IMPORT_reboot_aio_call.Options]) + if __options__.metadata is not None: + __metadata__ = __options__.metadata + if __options__.bearer_token is not None: + __bearer_token__ = __options__.bearer_token - if __state_id__ is None: - if __idempotency__ is None: - __state_id__ = str(IMPORT_uuid.uuid4()) - else: - __state_id__ = __context__.generate_idempotent_state_id( - state_type_name=__cls__.__state_type_name__, - service_name=IMPORT_reboot_aio_types.ServiceName('tests.reboot.GreeterMethods'), - method='Create', - idempotency=__idempotency__, - ) + if __state_id__ is None: + if __idempotency__ is None: + __state_id__ = str(IMPORT_uuid.uuid4()) + else: + __state_id__ = __context__.generate_idempotent_state_id( + state_type_name=Greeter.__state_type_name__, + service_name=IMPORT_reboot_aio_types.ServiceName('tests.reboot.GreeterMethods'), + method='Create', + idempotency=__idempotency__, + ) - __reference__ = Greeter.ref( - __state_id__, bearer_token=__bearer_token__ - ) - __stub__ = __reference__._writer(__context__) - return ( - __reference__, - GreeterCreateResponseFromProto( - await __stub__.Create( - __request__, - idempotency=__idempotency__, - metadata=__metadata__, - bearer_token=__bearer_token__, - ) - ), - ) + __reference__ = Greeter.ref( + __state_id__, bearer_token=__bearer_token__ + ) + __stub__ = __reference__._writer(__context__) + return ( + __reference__, + GreeterCreateResponseFromProto( + await __stub__.Create( + __request__, + idempotency=__idempotency__, + metadata=__metadata__, + bearer_token=__bearer_token__, + ) + ), + ) - # Keep the original functions on the client, so old code will - # continue to work, but use the new 'snake_case' method in - # the new code. - create = Create + # Keep the original functions on the client, so old code will + # continue to work, but use the new 'snake_case' method in + # the new code. + create = Create - @IMPORT_typing.overload - @classmethod - def idempotently(cls, alias: IMPORT_typing.Optional[str] = None, *, how: IMPORT_reboot_aio_idempotency.How = IMPORT_reboot_aio_idempotency.PER_WORKFLOW) -> Greeter._ConstructIdempotently: - ... + @IMPORT_typing.overload + @classmethod + def idempotently(cls, alias: IMPORT_typing.Optional[str] = None, *, how: IMPORT_reboot_aio_idempotency.How = IMPORT_reboot_aio_idempotency.PER_WORKFLOW) -> Greeter._ConstructIdempotently: + ... - @IMPORT_typing.overload - @classmethod - def idempotently(cls, *, key: IMPORT_uuid.UUID, how: IMPORT_reboot_aio_idempotency.How = IMPORT_reboot_aio_idempotency.PER_WORKFLOW) -> Greeter._ConstructIdempotently: - ... + @IMPORT_typing.overload + @classmethod + def idempotently(cls, *, key: IMPORT_uuid.UUID, how: IMPORT_reboot_aio_idempotency.How = IMPORT_reboot_aio_idempotency.PER_WORKFLOW) -> Greeter._ConstructIdempotently: + ... - @classmethod - def idempotently( - cls, - alias: IMPORT_typing.Optional[str] = None, - *, - key: IMPORT_typing.Optional[IMPORT_uuid.UUID] = None, - how: IMPORT_typing.Optional[IMPORT_reboot_aio_idempotency.How] = None, - ) -> Greeter._ConstructIdempotently: - return Greeter._ConstructIdempotently( - _idempotency=IMPORT_reboot_aio_contexts.Context.idempotency( - alias=alias, - key=key, - how=how, - ), - ) + @classmethod + def idempotently( + cls, + alias: IMPORT_typing.Optional[str] = None, + *, + key: IMPORT_typing.Optional[IMPORT_uuid.UUID] = None, + how: IMPORT_typing.Optional[IMPORT_reboot_aio_idempotency.How] = None, + ) -> Greeter._ConstructIdempotently: + return Greeter._ConstructIdempotently( + _idempotency=IMPORT_reboot_aio_contexts.Context.idempotency( + alias=alias, + key=key, + how=how, + ), + ) - @classmethod - def per_workflow( - cls, - alias: IMPORT_typing.Optional[str] = None, - ): - return cls.idempotently(alias) + @classmethod + def per_workflow( + cls, + alias: IMPORT_typing.Optional[str] = None, + ): + return cls.idempotently(alias) - @classmethod - def per_iteration( - cls, - alias: IMPORT_typing.Optional[str] = None, - ): - return cls.idempotently( - alias, - how=IMPORT_reboot_aio_idempotency.PER_ITERATION, - ) + @classmethod + def per_iteration( + cls, + alias: IMPORT_typing.Optional[str] = None, + ): + return cls.idempotently( + alias, + how=IMPORT_reboot_aio_idempotency.PER_ITERATION, + ) - @classmethod - def always(cls): - return cls.idempotently( - how=IMPORT_reboot_aio_idempotency.ALWAYS, - ) + @classmethod + def always(cls): + return cls.idempotently( + how=IMPORT_reboot_aio_idempotency.ALWAYS, + ) + + factory = _Factory @IMPORT_dataclasses.dataclass(frozen=True) class _ConstructIdempotently: @@ -32523,7 +32526,7 @@ async def Create( # type: ignore[misc] __this__._idempotency, ) - return await Greeter.Create( + return await Greeter.factory.Create( *__args__, ) diff --git a/tests/reboot/greeter_rbt_web.golden.js b/tests/reboot/greeter_rbt_web.golden.js index 554dc3755..cd57a6967 100755 --- a/tests/reboot/greeter_rbt_web.golden.js +++ b/tests/reboot/greeter_rbt_web.golden.js @@ -2306,10 +2306,7 @@ export class GreeterWeakReference { } } _GreeterWeakReference_id = new WeakMap(), _GreeterWeakReference_options = new WeakMap(); -export class Greeter { - static ref(id, options) { - return new Greeter.WeakReference(id, options === null || options === void 0 ? void 0 : options.bearerToken); - } +export class GreeterFactory { static async create(context, idOrPartialRequest, inputPartialRequest, options) { let id = undefined; let partialRequest = undefined; @@ -2332,4 +2329,10 @@ export class Greeter { return [weakReference, response]; } } +export class Greeter { + static ref(id, options) { + return new Greeter.WeakReference(id, options === null || options === void 0 ? void 0 : options.bearerToken); + } +} Greeter.WeakReference = GreeterWeakReference; +Greeter.factory = GreeterFactory; diff --git a/tests/reboot/ping_api_rbt.golden.py b/tests/reboot/ping_api_rbt.golden.py index 2896c6b2b..3b49c1d94 100755 --- a/tests/reboot/ping_api_rbt.golden.py +++ b/tests/reboot/ping_api_rbt.golden.py @@ -17811,7 +17811,7 @@ async def _authenticated( f"urn:dev.reboot:auto-construct:User:{state_id}", ) try: - await User.idempotently( + await User.factory.idempotently( key=idempotency_key, ).create(context, state_id) except User.CreateAborted as aborted: @@ -23717,55 +23717,58 @@ def ref( bearer_token=bearer_token, ) + class _Factory: - @IMPORT_typing.overload - @classmethod - def idempotently(cls, alias: IMPORT_typing.Optional[str] = None, *, how: IMPORT_reboot_aio_idempotency.How = IMPORT_reboot_aio_idempotency.PER_WORKFLOW) -> Ping._ConstructIdempotently: - ... + @IMPORT_typing.overload + @classmethod + def idempotently(cls, alias: IMPORT_typing.Optional[str] = None, *, how: IMPORT_reboot_aio_idempotency.How = IMPORT_reboot_aio_idempotency.PER_WORKFLOW) -> Ping._ConstructIdempotently: + ... - @IMPORT_typing.overload - @classmethod - def idempotently(cls, *, key: IMPORT_uuid.UUID, how: IMPORT_reboot_aio_idempotency.How = IMPORT_reboot_aio_idempotency.PER_WORKFLOW) -> Ping._ConstructIdempotently: - ... + @IMPORT_typing.overload + @classmethod + def idempotently(cls, *, key: IMPORT_uuid.UUID, how: IMPORT_reboot_aio_idempotency.How = IMPORT_reboot_aio_idempotency.PER_WORKFLOW) -> Ping._ConstructIdempotently: + ... - @classmethod - def idempotently( - cls, - alias: IMPORT_typing.Optional[str] = None, - *, - key: IMPORT_typing.Optional[IMPORT_uuid.UUID] = None, - how: IMPORT_typing.Optional[IMPORT_reboot_aio_idempotency.How] = None, - ) -> Ping._ConstructIdempotently: - return Ping._ConstructIdempotently( - _idempotency=IMPORT_reboot_aio_contexts.Context.idempotency( - alias=alias, - key=key, - how=how, - ), - ) + @classmethod + def idempotently( + cls, + alias: IMPORT_typing.Optional[str] = None, + *, + key: IMPORT_typing.Optional[IMPORT_uuid.UUID] = None, + how: IMPORT_typing.Optional[IMPORT_reboot_aio_idempotency.How] = None, + ) -> Ping._ConstructIdempotently: + return Ping._ConstructIdempotently( + _idempotency=IMPORT_reboot_aio_contexts.Context.idempotency( + alias=alias, + key=key, + how=how, + ), + ) - @classmethod - def per_workflow( - cls, - alias: IMPORT_typing.Optional[str] = None, - ): - return cls.idempotently(alias) + @classmethod + def per_workflow( + cls, + alias: IMPORT_typing.Optional[str] = None, + ): + return cls.idempotently(alias) - @classmethod - def per_iteration( - cls, - alias: IMPORT_typing.Optional[str] = None, - ): - return cls.idempotently( - alias, - how=IMPORT_reboot_aio_idempotency.PER_ITERATION, - ) + @classmethod + def per_iteration( + cls, + alias: IMPORT_typing.Optional[str] = None, + ): + return cls.idempotently( + alias, + how=IMPORT_reboot_aio_idempotency.PER_ITERATION, + ) - @classmethod - def always(cls): - return cls.idempotently( - how=IMPORT_reboot_aio_idempotency.ALWAYS, - ) + @classmethod + def always(cls): + return cls.idempotently( + how=IMPORT_reboot_aio_idempotency.ALWAYS, + ) + + factory = _Factory @IMPORT_dataclasses.dataclass(frozen=True) class _ConstructIdempotently: @@ -25617,55 +25620,58 @@ def ref( bearer_token=bearer_token, ) + class _Factory: - @IMPORT_typing.overload - @classmethod - def idempotently(cls, alias: IMPORT_typing.Optional[str] = None, *, how: IMPORT_reboot_aio_idempotency.How = IMPORT_reboot_aio_idempotency.PER_WORKFLOW) -> Pong._ConstructIdempotently: - ... + @IMPORT_typing.overload + @classmethod + def idempotently(cls, alias: IMPORT_typing.Optional[str] = None, *, how: IMPORT_reboot_aio_idempotency.How = IMPORT_reboot_aio_idempotency.PER_WORKFLOW) -> Pong._ConstructIdempotently: + ... - @IMPORT_typing.overload - @classmethod - def idempotently(cls, *, key: IMPORT_uuid.UUID, how: IMPORT_reboot_aio_idempotency.How = IMPORT_reboot_aio_idempotency.PER_WORKFLOW) -> Pong._ConstructIdempotently: - ... + @IMPORT_typing.overload + @classmethod + def idempotently(cls, *, key: IMPORT_uuid.UUID, how: IMPORT_reboot_aio_idempotency.How = IMPORT_reboot_aio_idempotency.PER_WORKFLOW) -> Pong._ConstructIdempotently: + ... - @classmethod - def idempotently( - cls, - alias: IMPORT_typing.Optional[str] = None, - *, - key: IMPORT_typing.Optional[IMPORT_uuid.UUID] = None, - how: IMPORT_typing.Optional[IMPORT_reboot_aio_idempotency.How] = None, - ) -> Pong._ConstructIdempotently: - return Pong._ConstructIdempotently( - _idempotency=IMPORT_reboot_aio_contexts.Context.idempotency( - alias=alias, - key=key, - how=how, - ), - ) + @classmethod + def idempotently( + cls, + alias: IMPORT_typing.Optional[str] = None, + *, + key: IMPORT_typing.Optional[IMPORT_uuid.UUID] = None, + how: IMPORT_typing.Optional[IMPORT_reboot_aio_idempotency.How] = None, + ) -> Pong._ConstructIdempotently: + return Pong._ConstructIdempotently( + _idempotency=IMPORT_reboot_aio_contexts.Context.idempotency( + alias=alias, + key=key, + how=how, + ), + ) - @classmethod - def per_workflow( - cls, - alias: IMPORT_typing.Optional[str] = None, - ): - return cls.idempotently(alias) + @classmethod + def per_workflow( + cls, + alias: IMPORT_typing.Optional[str] = None, + ): + return cls.idempotently(alias) - @classmethod - def per_iteration( - cls, - alias: IMPORT_typing.Optional[str] = None, - ): - return cls.idempotently( - alias, - how=IMPORT_reboot_aio_idempotency.PER_ITERATION, - ) + @classmethod + def per_iteration( + cls, + alias: IMPORT_typing.Optional[str] = None, + ): + return cls.idempotently( + alias, + how=IMPORT_reboot_aio_idempotency.PER_ITERATION, + ) - @classmethod - def always(cls): - return cls.idempotently( - how=IMPORT_reboot_aio_idempotency.ALWAYS, - ) + @classmethod + def always(cls): + return cls.idempotently( + how=IMPORT_reboot_aio_idempotency.ALWAYS, + ) + + factory = _Factory @IMPORT_dataclasses.dataclass(frozen=True) class _ConstructIdempotently: @@ -29551,142 +29557,145 @@ def ref( bearer_token=bearer_token, ) + class _Factory: - @classmethod - async def Create( # type: ignore[misc] - __cls__, - __context__: IMPORT_reboot_aio_contexts.TransactionContext | IMPORT_reboot_aio_contexts.WorkflowContext | IMPORT_reboot_aio_external.ExternalContext, - __state_id__: IMPORT_typing.Optional[IMPORT_reboot_aio_types.StateId] = None, - __options__: IMPORT_typing.Optional[IMPORT_reboot_aio_call.Options] = None, - __idempotency__: IMPORT_typing.Optional[IMPORT_reboot_aio_idempotency.Idempotency] = None, - ) -> tuple[User.WeakReference, None]: - # Within a `workflow`, all "bare" calls are - # `per_workflow()` calls, unless we're within a control - # loop, in which case they are syntactic sugar for - # `per_iteration()`. - # - # Unless we are "within until" in which case all "bare" - # calls are `.always()`. + @classmethod + async def Create( # type: ignore[misc] + __cls__, + __context__: IMPORT_reboot_aio_contexts.TransactionContext | IMPORT_reboot_aio_contexts.WorkflowContext | IMPORT_reboot_aio_external.ExternalContext, + __state_id__: IMPORT_typing.Optional[IMPORT_reboot_aio_types.StateId] = None, + __options__: IMPORT_typing.Optional[IMPORT_reboot_aio_call.Options] = None, + __idempotency__: IMPORT_typing.Optional[IMPORT_reboot_aio_idempotency.Idempotency] = None, + ) -> tuple[User.WeakReference, None]: + # Within a `workflow`, all "bare" calls are + # `per_workflow()` calls, unless we're within a control + # loop, in which case they are syntactic sugar for + # `per_iteration()`. + # + # Unless we are "within until" in which case all "bare" + # calls are `.always()`. - assert __state_id__ is None or isinstance(__state_id__, IMPORT_reboot_aio_types.StateId) - assert __options__ is None or isinstance(__options__, IMPORT_reboot_aio_call.Options) - assert __idempotency__ is None or isinstance(__idempotency__, IMPORT_reboot_aio_idempotency.Idempotency) + assert __state_id__ is None or isinstance(__state_id__, IMPORT_reboot_aio_types.StateId) + assert __options__ is None or isinstance(__options__, IMPORT_reboot_aio_call.Options) + assert __idempotency__ is None or isinstance(__idempotency__, IMPORT_reboot_aio_idempotency.Idempotency) - if __idempotency__ is None: - __args__: tuple[IMPORT_typing.Any, ...] = ( - __context__, - ) - if __state_id__ is not None: - # Don't include `state_id` if it is `None`, so that - # we won't break the positional argument deduction. - __args__ += (__state_id__,) - __args__ += ( - __options__, - ) - if isinstance(__context__, IMPORT_reboot_aio_contexts.WorkflowContext): - return await ( - __cls__.always() if __context__.within_until() - else ( - __cls__.per_iteration() if __context__.within_loop() - else __cls__.per_workflow() - ) - ).Create( - *__args__ + if __idempotency__ is None: + __args__: tuple[IMPORT_typing.Any, ...] = ( + __context__, ) - elif isinstance(__context__, IMPORT_reboot_aio_external.InitializeContext): - return await __cls__.idempotently().Create( - *__args__ + if __state_id__ is not None: + # Don't include `state_id` if it is `None`, so that + # we won't break the positional argument deduction. + __args__ += (__state_id__,) + __args__ += ( + __options__, ) + if isinstance(__context__, IMPORT_reboot_aio_contexts.WorkflowContext): + return await ( + __cls__.always() if __context__.within_until() + else ( + __cls__.per_iteration() if __context__.within_loop() + else __cls__.per_workflow() + ) + ).Create( + *__args__ + ) + elif isinstance(__context__, IMPORT_reboot_aio_external.InitializeContext): + return await __cls__.idempotently().Create( + *__args__ + ) - __metadata__: IMPORT_typing.Optional[IMPORT_reboot_aio_types.GrpcMetadata] = None - __bearer_token__: IMPORT_typing.Optional[str] = None + __metadata__: IMPORT_typing.Optional[IMPORT_reboot_aio_types.GrpcMetadata] = None + __bearer_token__: IMPORT_typing.Optional[str] = None - if __options__ is not None: - IMPORT_reboot_aio_types.assert_type(__options__, [IMPORT_reboot_aio_call.Options]) - if __options__.metadata is not None: - __metadata__ = __options__.metadata - if __options__.bearer_token is not None: - __bearer_token__ = __options__.bearer_token + if __options__ is not None: + IMPORT_reboot_aio_types.assert_type(__options__, [IMPORT_reboot_aio_call.Options]) + if __options__.metadata is not None: + __metadata__ = __options__.metadata + if __options__.bearer_token is not None: + __bearer_token__ = __options__.bearer_token - if __state_id__ is None: - if __idempotency__ is None: - __state_id__ = str(IMPORT_uuid.uuid4()) - else: - __state_id__ = __context__.generate_idempotent_state_id( - state_type_name=__cls__.__state_type_name__, - service_name=IMPORT_reboot_aio_types.ServiceName('reboot.ping.UserMethods'), - method='Create', - idempotency=__idempotency__, - ) + if __state_id__ is None: + if __idempotency__ is None: + __state_id__ = str(IMPORT_uuid.uuid4()) + else: + __state_id__ = __context__.generate_idempotent_state_id( + state_type_name=User.__state_type_name__, + service_name=IMPORT_reboot_aio_types.ServiceName('reboot.ping.UserMethods'), + method='Create', + idempotency=__idempotency__, + ) - __reference__ = User.ref( - __state_id__, bearer_token=__bearer_token__ - ) - __stub__ = __reference__._workflow(__context__) - return ( - __reference__, - UserCreateResponseFromProto( - await __stub__.Create( - idempotency=__idempotency__, - metadata=__metadata__, - bearer_token=__bearer_token__, - ) - ), - ) + __reference__ = User.ref( + __state_id__, bearer_token=__bearer_token__ + ) + __stub__ = __reference__._workflow(__context__) + return ( + __reference__, + UserCreateResponseFromProto( + await __stub__.Create( + idempotency=__idempotency__, + metadata=__metadata__, + bearer_token=__bearer_token__, + ) + ), + ) - # Keep the original functions on the client, so old code will - # continue to work, but use the new 'snake_case' method in - # the new code. - create = Create + # Keep the original functions on the client, so old code will + # continue to work, but use the new 'snake_case' method in + # the new code. + create = Create - @IMPORT_typing.overload - @classmethod - def idempotently(cls, alias: IMPORT_typing.Optional[str] = None, *, how: IMPORT_reboot_aio_idempotency.How = IMPORT_reboot_aio_idempotency.PER_WORKFLOW) -> User._ConstructIdempotently: - ... + @IMPORT_typing.overload + @classmethod + def idempotently(cls, alias: IMPORT_typing.Optional[str] = None, *, how: IMPORT_reboot_aio_idempotency.How = IMPORT_reboot_aio_idempotency.PER_WORKFLOW) -> User._ConstructIdempotently: + ... - @IMPORT_typing.overload - @classmethod - def idempotently(cls, *, key: IMPORT_uuid.UUID, how: IMPORT_reboot_aio_idempotency.How = IMPORT_reboot_aio_idempotency.PER_WORKFLOW) -> User._ConstructIdempotently: - ... + @IMPORT_typing.overload + @classmethod + def idempotently(cls, *, key: IMPORT_uuid.UUID, how: IMPORT_reboot_aio_idempotency.How = IMPORT_reboot_aio_idempotency.PER_WORKFLOW) -> User._ConstructIdempotently: + ... - @classmethod - def idempotently( - cls, - alias: IMPORT_typing.Optional[str] = None, - *, - key: IMPORT_typing.Optional[IMPORT_uuid.UUID] = None, - how: IMPORT_typing.Optional[IMPORT_reboot_aio_idempotency.How] = None, - ) -> User._ConstructIdempotently: - return User._ConstructIdempotently( - _idempotency=IMPORT_reboot_aio_contexts.Context.idempotency( - alias=alias, - key=key, - how=how, - ), - ) + @classmethod + def idempotently( + cls, + alias: IMPORT_typing.Optional[str] = None, + *, + key: IMPORT_typing.Optional[IMPORT_uuid.UUID] = None, + how: IMPORT_typing.Optional[IMPORT_reboot_aio_idempotency.How] = None, + ) -> User._ConstructIdempotently: + return User._ConstructIdempotently( + _idempotency=IMPORT_reboot_aio_contexts.Context.idempotency( + alias=alias, + key=key, + how=how, + ), + ) - @classmethod - def per_workflow( - cls, - alias: IMPORT_typing.Optional[str] = None, - ): - return cls.idempotently(alias) + @classmethod + def per_workflow( + cls, + alias: IMPORT_typing.Optional[str] = None, + ): + return cls.idempotently(alias) - @classmethod - def per_iteration( - cls, - alias: IMPORT_typing.Optional[str] = None, - ): - return cls.idempotently( - alias, - how=IMPORT_reboot_aio_idempotency.PER_ITERATION, - ) + @classmethod + def per_iteration( + cls, + alias: IMPORT_typing.Optional[str] = None, + ): + return cls.idempotently( + alias, + how=IMPORT_reboot_aio_idempotency.PER_ITERATION, + ) - @classmethod - def always(cls): - return cls.idempotently( - how=IMPORT_reboot_aio_idempotency.ALWAYS, - ) + @classmethod + def always(cls): + return cls.idempotently( + how=IMPORT_reboot_aio_idempotency.ALWAYS, + ) + + factory = _Factory @IMPORT_dataclasses.dataclass(frozen=True) class _ConstructIdempotently: @@ -29720,7 +29729,7 @@ async def Create( # type: ignore[misc] __this__._idempotency, ) - return await User.Create( + return await User.factory.Create( *__args__, ) @@ -32557,215 +32566,218 @@ def ref( bearer_token=bearer_token, ) - @IMPORT_typing.overload - @classmethod - async def Create( - __cls__, - __context__: IMPORT_reboot_aio_contexts.TransactionContext | IMPORT_reboot_aio_contexts.WorkflowContext | IMPORT_reboot_aio_external.ExternalContext, - __state_id_or_request_or_options__: IMPORT_typing.Optional[IMPORT_reboot_aio_types.StateId | Counter.CreateRequest] = None, - __request_or_options_or_idempotency__: IMPORT_typing.Optional[Counter.CreateRequest | IMPORT_reboot_aio_call.Options] = None, - __options_or_idempotency__: IMPORT_typing.Optional[IMPORT_reboot_aio_call.Options | IMPORT_reboot_aio_idempotency.Idempotency] = None, - __idempotency__: IMPORT_typing.Optional[IMPORT_reboot_aio_idempotency.Idempotency] = None, - ) -> tuple[Counter.WeakReference, None]: - ... - - @IMPORT_typing.overload - @classmethod - async def Create( - __cls__, - __context__: IMPORT_reboot_aio_contexts.TransactionContext | IMPORT_reboot_aio_contexts.WorkflowContext | IMPORT_reboot_aio_external.ExternalContext, - __state_id_or_request_or_options__: IMPORT_typing.Optional[IMPORT_reboot_aio_types.StateId | IMPORT_reboot_aio_call.Options] = None, - __request_or_options_or_idempotency__: IMPORT_typing.Optional[IMPORT_reboot_aio_call.Options | IMPORT_reboot_aio_idempotency.Idempotency] = None, - __options_or_idempotency__: IMPORT_typing.Optional[IMPORT_reboot_aio_idempotency.Idempotency] = None, - *, - description: str | Unset = UNSET, - owner_id: str | Unset = UNSET, - ) -> tuple[Counter.WeakReference, None]: - ... + class _Factory: + @IMPORT_typing.overload + @classmethod + async def Create( + __cls__, + __context__: IMPORT_reboot_aio_contexts.TransactionContext | IMPORT_reboot_aio_contexts.WorkflowContext | IMPORT_reboot_aio_external.ExternalContext, + __state_id_or_request_or_options__: IMPORT_typing.Optional[IMPORT_reboot_aio_types.StateId | Counter.CreateRequest] = None, + __request_or_options_or_idempotency__: IMPORT_typing.Optional[Counter.CreateRequest | IMPORT_reboot_aio_call.Options] = None, + __options_or_idempotency__: IMPORT_typing.Optional[IMPORT_reboot_aio_call.Options | IMPORT_reboot_aio_idempotency.Idempotency] = None, + __idempotency__: IMPORT_typing.Optional[IMPORT_reboot_aio_idempotency.Idempotency] = None, + ) -> tuple[Counter.WeakReference, None]: + ... - @classmethod - async def Create( # type: ignore[misc] - __cls__, - __context__: IMPORT_reboot_aio_contexts.TransactionContext | IMPORT_reboot_aio_contexts.WorkflowContext | IMPORT_reboot_aio_external.ExternalContext, - __state_id_or_request_or_options__: IMPORT_typing.Optional[IMPORT_reboot_aio_types.StateId | Counter.CreateRequest | IMPORT_reboot_aio_call.Options] = None, - __request_or_options_or_idempotency__: IMPORT_typing.Optional[Counter.CreateRequest | IMPORT_reboot_aio_call.Options | IMPORT_reboot_aio_idempotency.Idempotency] = None, - __options_or_idempotency__: IMPORT_typing.Optional[IMPORT_reboot_aio_call.Options | IMPORT_reboot_aio_idempotency.Idempotency] = None, - __idempotency__: IMPORT_typing.Optional[IMPORT_reboot_aio_idempotency.Idempotency] = None, - *, - description: str | Unset = UNSET, - owner_id: str | Unset = UNSET, - ) -> tuple[Counter.WeakReference, None]: - # Within a `workflow`, all "bare" calls are - # `per_workflow()` calls, unless we're within a control - # loop, in which case they are syntactic sugar for - # `per_iteration()`. - # - # Unless we are "within until" in which case all "bare" - # calls are `.always()`. + @IMPORT_typing.overload + @classmethod + async def Create( + __cls__, + __context__: IMPORT_reboot_aio_contexts.TransactionContext | IMPORT_reboot_aio_contexts.WorkflowContext | IMPORT_reboot_aio_external.ExternalContext, + __state_id_or_request_or_options__: IMPORT_typing.Optional[IMPORT_reboot_aio_types.StateId | IMPORT_reboot_aio_call.Options] = None, + __request_or_options_or_idempotency__: IMPORT_typing.Optional[IMPORT_reboot_aio_call.Options | IMPORT_reboot_aio_idempotency.Idempotency] = None, + __options_or_idempotency__: IMPORT_typing.Optional[IMPORT_reboot_aio_idempotency.Idempotency] = None, + *, + description: str | Unset = UNSET, + owner_id: str | Unset = UNSET, + ) -> tuple[Counter.WeakReference, None]: + ... - __request__: IMPORT_typing.Optional[Counter.CreateRequest] = None - __state_id__: IMPORT_typing.Optional[IMPORT_reboot_aio_types.StateId] = None - __options__: IMPORT_typing.Optional[IMPORT_reboot_aio_call.Options] = None + @classmethod + async def Create( # type: ignore[misc] + __cls__, + __context__: IMPORT_reboot_aio_contexts.TransactionContext | IMPORT_reboot_aio_contexts.WorkflowContext | IMPORT_reboot_aio_external.ExternalContext, + __state_id_or_request_or_options__: IMPORT_typing.Optional[IMPORT_reboot_aio_types.StateId | Counter.CreateRequest | IMPORT_reboot_aio_call.Options] = None, + __request_or_options_or_idempotency__: IMPORT_typing.Optional[Counter.CreateRequest | IMPORT_reboot_aio_call.Options | IMPORT_reboot_aio_idempotency.Idempotency] = None, + __options_or_idempotency__: IMPORT_typing.Optional[IMPORT_reboot_aio_call.Options | IMPORT_reboot_aio_idempotency.Idempotency] = None, + __idempotency__: IMPORT_typing.Optional[IMPORT_reboot_aio_idempotency.Idempotency] = None, + *, + description: str | Unset = UNSET, + owner_id: str | Unset = UNSET, + ) -> tuple[Counter.WeakReference, None]: + # Within a `workflow`, all "bare" calls are + # `per_workflow()` calls, unless we're within a control + # loop, in which case they are syntactic sugar for + # `per_iteration()`. + # + # Unless we are "within until" in which case all "bare" + # calls are `.always()`. - if isinstance(__state_id_or_request_or_options__, IMPORT_reboot_aio_types.StateId): - __state_id__ = __state_id_or_request_or_options__ - if isinstance(__request_or_options_or_idempotency__, Counter.CreateRequest): - __request__ = __request_or_options_or_idempotency__ - assert __options_or_idempotency__ is None or isinstance(__options_or_idempotency__, IMPORT_reboot_aio_call.Options) - __options__ = __options_or_idempotency__ - assert __idempotency__ is None or isinstance(__idempotency__, IMPORT_reboot_aio_idempotency.Idempotency) + __request__: IMPORT_typing.Optional[Counter.CreateRequest] = None + __state_id__: IMPORT_typing.Optional[IMPORT_reboot_aio_types.StateId] = None + __options__: IMPORT_typing.Optional[IMPORT_reboot_aio_call.Options] = None - assert description is UNSET - assert owner_id is UNSET - else: + if isinstance(__state_id_or_request_or_options__, IMPORT_reboot_aio_types.StateId): + __state_id__ = __state_id_or_request_or_options__ + if isinstance(__request_or_options_or_idempotency__, Counter.CreateRequest): + __request__ = __request_or_options_or_idempotency__ + assert __options_or_idempotency__ is None or isinstance(__options_or_idempotency__, IMPORT_reboot_aio_call.Options) + __options__ = __options_or_idempotency__ + assert __idempotency__ is None or isinstance(__idempotency__, IMPORT_reboot_aio_idempotency.Idempotency) + + assert description is UNSET + assert owner_id is UNSET + else: + assert __request_or_options_or_idempotency__ is None or isinstance(__request_or_options_or_idempotency__, IMPORT_reboot_aio_call.Options) + __options__ = __request_or_options_or_idempotency__ + assert __options_or_idempotency__ is None or isinstance(__options_or_idempotency__, IMPORT_reboot_aio_idempotency.Idempotency) + __idempotency__ = __options_or_idempotency__ + + __request__ = CounterCreateRequestFromInputFields( + description=description, + owner_id=owner_id, + ) + elif isinstance(__state_id_or_request_or_options__, Counter.CreateRequest): + __request__ = __state_id_or_request_or_options__ assert __request_or_options_or_idempotency__ is None or isinstance(__request_or_options_or_idempotency__, IMPORT_reboot_aio_call.Options) __options__ = __request_or_options_or_idempotency__ assert __options_or_idempotency__ is None or isinstance(__options_or_idempotency__, IMPORT_reboot_aio_idempotency.Idempotency) __idempotency__ = __options_or_idempotency__ + else: + assert ( + __state_id_or_request_or_options__ is None + or isinstance(__state_id_or_request_or_options__, IMPORT_reboot_aio_call.Options) + ), "Invalid argument type. Did you pass:\n" \ + " - A 'state_id' that is not of type 'reboot.aio.types.StateId'?\n" \ + " - 'options' that are not of type 'reboot.aio.call.Options'?" + __options__ = __state_id_or_request_or_options__ + assert __request_or_options_or_idempotency__ is None or isinstance(__request_or_options_or_idempotency__, IMPORT_reboot_aio_idempotency.Idempotency) + __idempotency__ = __request_or_options_or_idempotency__ __request__ = CounterCreateRequestFromInputFields( description=description, owner_id=owner_id, ) - elif isinstance(__state_id_or_request_or_options__, Counter.CreateRequest): - __request__ = __state_id_or_request_or_options__ - assert __request_or_options_or_idempotency__ is None or isinstance(__request_or_options_or_idempotency__, IMPORT_reboot_aio_call.Options) - __options__ = __request_or_options_or_idempotency__ - assert __options_or_idempotency__ is None or isinstance(__options_or_idempotency__, IMPORT_reboot_aio_idempotency.Idempotency) - __idempotency__ = __options_or_idempotency__ - else: - assert ( - __state_id_or_request_or_options__ is None - or isinstance(__state_id_or_request_or_options__, IMPORT_reboot_aio_call.Options) - ), "Invalid argument type. Did you pass:\n" \ - " - A 'state_id' that is not of type 'reboot.aio.types.StateId'?\n" \ - " - 'options' that are not of type 'reboot.aio.call.Options'?" - __options__ = __state_id_or_request_or_options__ - assert __request_or_options_or_idempotency__ is None or isinstance(__request_or_options_or_idempotency__, IMPORT_reboot_aio_idempotency.Idempotency) - __idempotency__ = __request_or_options_or_idempotency__ - - __request__ = CounterCreateRequestFromInputFields( - description=description, - owner_id=owner_id, - ) - - if __idempotency__ is None: - __args__: tuple[IMPORT_typing.Any, ...] = ( - __context__, - ) - if __state_id__ is not None: - # Don't include `state_id` if it is `None`, so that - # we won't break the positional argument deduction. - __args__ += (__state_id__,) - __args__ += ( - __request__, - __options__, - ) - if isinstance(__context__, IMPORT_reboot_aio_contexts.WorkflowContext): - return await ( - __cls__.always() if __context__.within_until() - else ( - __cls__.per_iteration() if __context__.within_loop() - else __cls__.per_workflow() - ) - ).Create( - *__args__ + + if __idempotency__ is None: + __args__: tuple[IMPORT_typing.Any, ...] = ( + __context__, ) - elif isinstance(__context__, IMPORT_reboot_aio_external.InitializeContext): - return await __cls__.idempotently().Create( - *__args__ + if __state_id__ is not None: + # Don't include `state_id` if it is `None`, so that + # we won't break the positional argument deduction. + __args__ += (__state_id__,) + __args__ += ( + __request__, + __options__, ) + if isinstance(__context__, IMPORT_reboot_aio_contexts.WorkflowContext): + return await ( + __cls__.always() if __context__.within_until() + else ( + __cls__.per_iteration() if __context__.within_loop() + else __cls__.per_workflow() + ) + ).Create( + *__args__ + ) + elif isinstance(__context__, IMPORT_reboot_aio_external.InitializeContext): + return await __cls__.idempotently().Create( + *__args__ + ) - __metadata__: IMPORT_typing.Optional[IMPORT_reboot_aio_types.GrpcMetadata] = None - __bearer_token__: IMPORT_typing.Optional[str] = None + __metadata__: IMPORT_typing.Optional[IMPORT_reboot_aio_types.GrpcMetadata] = None + __bearer_token__: IMPORT_typing.Optional[str] = None - if __options__ is not None: - IMPORT_reboot_aio_types.assert_type(__options__, [IMPORT_reboot_aio_call.Options]) - if __options__.metadata is not None: - __metadata__ = __options__.metadata - if __options__.bearer_token is not None: - __bearer_token__ = __options__.bearer_token + if __options__ is not None: + IMPORT_reboot_aio_types.assert_type(__options__, [IMPORT_reboot_aio_call.Options]) + if __options__.metadata is not None: + __metadata__ = __options__.metadata + if __options__.bearer_token is not None: + __bearer_token__ = __options__.bearer_token - if __state_id__ is None: - if __idempotency__ is None: - __state_id__ = str(IMPORT_uuid.uuid4()) - else: - __state_id__ = __context__.generate_idempotent_state_id( - state_type_name=__cls__.__state_type_name__, - service_name=IMPORT_reboot_aio_types.ServiceName('reboot.ping.CounterMethods'), - method='Create', - idempotency=__idempotency__, - ) + if __state_id__ is None: + if __idempotency__ is None: + __state_id__ = str(IMPORT_uuid.uuid4()) + else: + __state_id__ = __context__.generate_idempotent_state_id( + state_type_name=Counter.__state_type_name__, + service_name=IMPORT_reboot_aio_types.ServiceName('reboot.ping.CounterMethods'), + method='Create', + idempotency=__idempotency__, + ) - __reference__ = Counter.ref( - __state_id__, bearer_token=__bearer_token__ - ) - __stub__ = __reference__._writer(__context__) - return ( - __reference__, - CounterCreateResponseFromProto( - await __stub__.Create( - __request__, - idempotency=__idempotency__, - metadata=__metadata__, - bearer_token=__bearer_token__, - ) - ), - ) + __reference__ = Counter.ref( + __state_id__, bearer_token=__bearer_token__ + ) + __stub__ = __reference__._writer(__context__) + return ( + __reference__, + CounterCreateResponseFromProto( + await __stub__.Create( + __request__, + idempotency=__idempotency__, + metadata=__metadata__, + bearer_token=__bearer_token__, + ) + ), + ) - # Keep the original functions on the client, so old code will - # continue to work, but use the new 'snake_case' method in - # the new code. - create = Create + # Keep the original functions on the client, so old code will + # continue to work, but use the new 'snake_case' method in + # the new code. + create = Create - @IMPORT_typing.overload - @classmethod - def idempotently(cls, alias: IMPORT_typing.Optional[str] = None, *, how: IMPORT_reboot_aio_idempotency.How = IMPORT_reboot_aio_idempotency.PER_WORKFLOW) -> Counter._ConstructIdempotently: - ... + @IMPORT_typing.overload + @classmethod + def idempotently(cls, alias: IMPORT_typing.Optional[str] = None, *, how: IMPORT_reboot_aio_idempotency.How = IMPORT_reboot_aio_idempotency.PER_WORKFLOW) -> Counter._ConstructIdempotently: + ... - @IMPORT_typing.overload - @classmethod - def idempotently(cls, *, key: IMPORT_uuid.UUID, how: IMPORT_reboot_aio_idempotency.How = IMPORT_reboot_aio_idempotency.PER_WORKFLOW) -> Counter._ConstructIdempotently: - ... + @IMPORT_typing.overload + @classmethod + def idempotently(cls, *, key: IMPORT_uuid.UUID, how: IMPORT_reboot_aio_idempotency.How = IMPORT_reboot_aio_idempotency.PER_WORKFLOW) -> Counter._ConstructIdempotently: + ... - @classmethod - def idempotently( - cls, - alias: IMPORT_typing.Optional[str] = None, - *, - key: IMPORT_typing.Optional[IMPORT_uuid.UUID] = None, - how: IMPORT_typing.Optional[IMPORT_reboot_aio_idempotency.How] = None, - ) -> Counter._ConstructIdempotently: - return Counter._ConstructIdempotently( - _idempotency=IMPORT_reboot_aio_contexts.Context.idempotency( - alias=alias, - key=key, - how=how, - ), - ) + @classmethod + def idempotently( + cls, + alias: IMPORT_typing.Optional[str] = None, + *, + key: IMPORT_typing.Optional[IMPORT_uuid.UUID] = None, + how: IMPORT_typing.Optional[IMPORT_reboot_aio_idempotency.How] = None, + ) -> Counter._ConstructIdempotently: + return Counter._ConstructIdempotently( + _idempotency=IMPORT_reboot_aio_contexts.Context.idempotency( + alias=alias, + key=key, + how=how, + ), + ) - @classmethod - def per_workflow( - cls, - alias: IMPORT_typing.Optional[str] = None, - ): - return cls.idempotently(alias) + @classmethod + def per_workflow( + cls, + alias: IMPORT_typing.Optional[str] = None, + ): + return cls.idempotently(alias) - @classmethod - def per_iteration( - cls, - alias: IMPORT_typing.Optional[str] = None, - ): - return cls.idempotently( - alias, - how=IMPORT_reboot_aio_idempotency.PER_ITERATION, - ) + @classmethod + def per_iteration( + cls, + alias: IMPORT_typing.Optional[str] = None, + ): + return cls.idempotently( + alias, + how=IMPORT_reboot_aio_idempotency.PER_ITERATION, + ) - @classmethod - def always(cls): - return cls.idempotently( - how=IMPORT_reboot_aio_idempotency.ALWAYS, - ) + @classmethod + def always(cls): + return cls.idempotently( + how=IMPORT_reboot_aio_idempotency.ALWAYS, + ) + + factory = _Factory @IMPORT_dataclasses.dataclass(frozen=True) class _ConstructIdempotently: @@ -32865,7 +32877,7 @@ async def Create( # type: ignore[misc] __this__._idempotency, ) - return await Counter.Create( + return await Counter.factory.Create( *__args__, ) From 923b7ff8d06ebc41ec3d345bd0246bf97560d2d9 Mon Sep 17 00:00:00 2001 From: Robert-Jan Huijsman <22160949+rjhuijsman@users.noreply.github.com> Date: Tue, 21 Jul 2026 22:57:43 +0000 Subject: [PATCH 2/5] Migration: note the `factory` namespace move for upgrades The `upgrade` skill rolls fragments from `skills/upgrade/migrations/next/` into each release's migration notes. This adds the fragment for the constructor-namespacing change so an app upgrading past it knows to move its constructor calls: it gives grep-able before/after patterns for `Foo.create(context, ...)` -> `Foo.factory.create(context, ...)`, plus the idempotency-scope and custom-constructor variants. Co-Authored-By: Claude Opus 4.8 (1M context) Claude-Session: https://claude.ai/code/session_011xyvD8vLQ9dTwtFMexovJo --- .../next/factory-namespaced-constructors.md | 40 +++++++++++++++++++ 1 file changed, 40 insertions(+) create mode 100644 reboot/plugin/skills/upgrade/migrations/next/factory-namespaced-constructors.md diff --git a/reboot/plugin/skills/upgrade/migrations/next/factory-namespaced-constructors.md b/reboot/plugin/skills/upgrade/migrations/next/factory-namespaced-constructors.md new file mode 100644 index 000000000..946a3ea50 --- /dev/null +++ b/reboot/plugin/skills/upgrade/migrations/next/factory-namespaced-constructors.md @@ -0,0 +1,40 @@ +## Constructors moved under a `factory` namespace + +Constructor (a.k.a. factory) methods are no longer exposed directly on +a state type. They now live under a `factory` namespace on the type, +so the top-level namespace is free for framework methods like `ref()`. +This only changes how constructors are **called** — the way you +**declare** one (`factory=True` on a writer/transaction, or the +`constructor` proto option) is unchanged. + +For every call that invokes a constructor **directly on a state type** +(i.e. on the class itself, not on a `.ref(...)` handle), insert +`.factory` between the type and the method: + +- `await Foo.create(context, ...)` → `await Foo.factory.create(context, ...)` +- Custom-named constructors too, e.g. `await Account.open(context, ...)` + → `await Account.factory.open(context, ...)`. +- Class-level idempotency-scoped construction moves under `factory` as + well: `Foo.idempotently(...)`, `Foo.per_workflow(...)`, + `Foo.per_iteration(...)`, `Foo.always(...)` (TypeScript: + `Foo.perWorkflow(...)`, `Foo.perIteration(...)`) when invoked on the + **class** to construct → `Foo.factory.idempotently(...)`, etc. So + `await Foo.idempotently("alias").create(context)` becomes + `await Foo.factory.idempotently("alias").create(context)`. + +How to find them: a method invoked directly on a state-type class is +_necessarily_ a constructor — every other method requires a `.ref(...)` +handle. So in `backend/` (Python and TypeScript), search for +`.(` calls where `` is a generated state +type imported from a `*_rbt`/`*_reboot` module and the call is made on +the bare class (the first argument is a `context`). Rewrite each as +`.factory.(`. + +Leave these unchanged: + +- Calls on a `.ref(...)` handle, including the reference-construction + form `Foo.ref(id).create(context)` and inline writers like + `Foo.ref().per_workflow("a").write(context, fn)`. +- `Foo.ref(...)` and `Foo.forall(...)` themselves. +- `factory=True` declarations and the `constructor` proto option. +- Implicit construction on first write (no explicit constructor call). From 4f53ab7a172f6fac2ed3903c3e3eb50d15f49826 Mon Sep 17 00:00:00 2001 From: Robert-Jan Huijsman <22160949+rjhuijsman@users.noreply.github.com> Date: Tue, 21 Jul 2026 23:07:29 +0000 Subject: [PATCH 3/5] Callers: call constructors via `factory` The previous commit changed where constructor/factory methods live; this commit changes all the callers to use the new syntax. Co-Authored-By: Claude Opus 4.8 (1M context) Claude-Session: https://claude.ai/code/session_011xyvD8vLQ9dTwtFMexovJo --- .../docs/call/from_within_your_app.mdx | 5 +- documentation/docs/call/overview.mdx | 24 +++--- documentation/docs/idempotency.mdx | 5 +- documentation/docs/implement/application.mdx | 4 +- documentation/docs/implement/transactions.mdx | 2 +- .../docs/library_services/ciphertext.mdx | 8 +- .../docs/library_services/mailgun.md | 6 +- documentation/docs/users/external_apis.mdx | 2 +- documentation/docs/users/tokens.mdx | 4 +- rbt/thirdparty/mailgun/v1/mailgun.proto | 3 +- reboot/cli/commands/cloud/up.py | 2 +- reboot/demos/fig/backend/src/main.ts | 4 +- reboot/demos/fig/backend/src/user_servicer.ts | 2 +- .../agent-wiki/backend/src/servicers/wiki.py | 6 +- .../bank-nodejs/backend/src/bank_servicer.ts | 10 ++- .../bank-nodejs/backend/tests/test.ts | 2 +- .../backend/src/bank_servicer.py | 2 +- .../backend/src/customer_servicer.py | 2 +- .../bank-pydantic/backend/src/main.py | 2 +- reboot/examples/bank-zod/backend/src/bank.ts | 2 +- .../examples/bank-zod/backend/src/customer.ts | 2 +- reboot/examples/bank-zod/backend/src/main.ts | 2 +- .../examples/bank-zod/backend/tests/test.ts | 6 +- reboot/examples/bank/backend/src/main.py | 6 +- .../boutique/backend/src/checkout/servicer.py | 2 +- reboot/examples/boutique/backend/src/main.py | 6 +- .../chick-potle/backend/src/servicers/food.py | 2 +- reboot/examples/docubot/backend/src/main.ts | 2 +- reboot/examples/kcdc-2025/backend/src/main.py | 4 +- .../backend/src/servicers/channel.py | 2 +- .../backend/src/servicers/chatbot.py | 2 +- .../kcdc-2025/backend/src/servicers/user.py | 4 +- .../backend/src/servicers/counter.py | 2 +- .../backend/src/servicers/counter.py | 2 +- .../bank/backend/src/bank_servicer.py | 2 +- .../hello-constructors/backend/src/main.py | 2 +- .../reboot-swag-store/backend/src/main.py | 2 +- .../backend/src/servicers/store.py | 4 +- reboot/ping/ping.py | 2 +- reboot/plugin/skills/mcp-ui/SKILL.md | 8 +- .../skills/mcp-ui/references/gotchas.md | 2 +- .../mcp-ui/references/servicer-patterns.md | 14 ++-- reboot/plugin/skills/python/SKILL.md | 5 +- .../skills/python/references/_sections.md | 2 +- .../skills/python/references/api-pydantic.md | 4 +- .../references/auth-external-api-calls.md | 4 +- .../references/lifecycle-initialize-hook.md | 17 ++-- .../references/patterns-common-gotchas.md | 12 +-- .../python/references/patterns-idempotency.md | 6 +- .../skills/python/references/rpc-calls.md | 2 +- .../references/rpc-constructor-calls.md | 35 +++++---- .../python/references/servicer-constructor.md | 19 ++--- .../python/references/servicer-transaction.md | 16 ++-- .../references/state-actor-decomposition.md | 4 +- .../python/references/state-collections.md | 2 +- .../python/references/state-scalar-fields.md | 2 +- .../python/references/stdlib-ciphertext.md | 16 ++-- .../python/references/stdlib-presence.md | 2 +- .../python/references/testing-harness.md | 2 +- reboot/plugin/skills/web-app/SKILL.md | 2 +- reboot/std/oauth/v1/oauth.py | 2 +- .../reboot/agents/pydantic_ai/agent_tests.py | 4 +- .../aio/internals/tasks_servicer_tests.py | 4 +- tests/reboot/auth_bank_main.py | 2 +- tests/reboot/auth_tests.py | 6 +- tests/reboot/bank.py | 24 +++--- tests/reboot/bank_main.py | 2 +- tests/reboot/benchmark.py | 2 +- tests/reboot/cancellation_tests.py | 2 +- tests/reboot/context_tests.py | 4 +- .../backend/src/servicers/counter.py | 2 +- tests/reboot/documentation/task.py | 2 +- tests/reboot/documentation/task.ts | 4 +- tests/reboot/documentation/test_http.py | 2 +- tests/reboot/documentation/test_http.ts | 2 +- tests/reboot/documentation/transactions.ts | 6 +- tests/reboot/effect_validation_tests.py | 10 +-- tests/reboot/errors_tests.py | 12 +-- tests/reboot/external_context_tests.py | 2 +- tests/reboot/idempotency_seeds_tests.py | 8 +- tests/reboot/idempotency_tests.py | 32 ++++---- tests/reboot/invalid_header_tests.py | 24 +++--- tests/reboot/nodejs/app_internal_test/test.ts | 6 +- tests/reboot/nodejs/auth_test/test.ts | 6 +- tests/reboot/nodejs/greeter.ts | 2 +- tests/reboot/nodejs/greeter_test/test.ts | 34 ++++---- tests/reboot/nodejs/reboot_down_test/test.ts | 2 +- tests/reboot/nodejs/reboot_test/test.ts | 6 +- tests/reboot/nodejs/reboot_web_test/test.ts | 12 +-- tests/reboot/nodejs/tasks_test/test.ts | 6 +- .../nodejs/yarn_zod_test/backend/src/bank.ts | 2 +- .../nodejs/yarn_zod_test/backend/src/main.ts | 2 +- .../yarn_zod_test/backend/tests/test.ts | 2 +- tests/reboot/ping/ping_test.py | 2 +- tests/reboot/preload_tests.py | 10 +-- tests/reboot/protoc_gen_reboot_tests.py | 3 +- .../pydantic/auto_construct_user/servicer.py | 2 +- .../pydantic/auto_construct_user/test.py | 4 +- .../test.py | 8 +- .../pydantic/discriminated_union/test.py | 12 +-- tests/reboot/pydantic/methods/servicer.py | 4 +- tests/reboot/pydantic/methods/test.py | 24 +++--- .../test_against_local_envoy.py | 2 +- .../test_auth/test_against_local_envoy.py | 2 +- .../react/test_cache/greeter_cache.test.tsx | 4 +- .../test_errors/test_against_local_envoy.py | 2 +- tests/reboot/react/test_http_fallback/test.py | 2 +- .../react/test_idempotent_writer/test.py | 2 +- .../react/test_long_running_fetches/test.py | 2 +- tests/reboot/react/test_mutations/test.py | 2 +- .../test.py | 2 +- .../test_reader/test_against_local_envoy.py | 2 +- .../state_id_change.test.tsx | 4 +- .../test_suspense/test_against_local_envoy.py | 2 +- .../test_against_local_envoy.py | 2 +- .../test_against_local_envoy.py | 2 +- .../test.py | 2 +- tests/reboot/reactivity_test.py | 2 +- tests/reboot/reboot_tests.py | 2 +- tests/reboot/server/local_envoy_test.py | 20 +++-- .../std/ciphertext/v1/ciphertext_tests.py | 2 +- .../std/collections/sorted_map_tests.py | 4 +- tests/reboot/tasks_tests.py | 36 ++++----- tests/reboot/thirdparty/mailgun/tests.py | 4 +- tests/reboot/transaction_tests.py | 78 ++++++++++--------- .../test.ts | 8 +- tests/reboot/zod/methods/test.ts | 2 +- 127 files changed, 433 insertions(+), 395 deletions(-) diff --git a/documentation/docs/call/from_within_your_app.mdx b/documentation/docs/call/from_within_your_app.mdx index 89570443f..2a764ee51 100644 --- a/documentation/docs/call/from_within_your_app.mdx +++ b/documentation/docs/call/from_within_your_app.mdx @@ -49,7 +49,7 @@ async def transfer( +(CODE:src=../../../reboot/examples/bank-nodejs/backend/src/bank_servicer.ts&lines=50-61) --> ```ts @@ -62,6 +62,9 @@ async transfer( await fromAccount.withdraw(context, { amount: request.amount }); await toAccount.deposit(context, { amount: request.amount }); + + return {}; +} ``` diff --git a/documentation/docs/call/overview.mdx b/documentation/docs/call/overview.mdx index 4d97da3e0..803195ed0 100644 --- a/documentation/docs/call/overview.mdx +++ b/documentation/docs/call/overview.mdx @@ -24,7 +24,7 @@ from_account = Account.ref(request.from_account_id) +(CODE:src=../../../reboot/examples/bank-nodejs/backend/src/bank_servicer.ts&lines=54-54) --> ```ts @@ -196,7 +196,7 @@ example: ```python -account, response = await Account.open( +account, response = await Account.factory.open( context, customer_name=request.customer_name, ) @@ -205,7 +205,7 @@ account, response = await Account.open( ```typescript -const [account, response] = await Account.open(context, { +const [account, response] = await Account.factory.open(context, { customerName: request.customerName, }); ``` @@ -235,7 +235,7 @@ an example of constructing an `Account` with an explicit ID using the ```python -account, _ = await Account.open( +account, _ = await Account.factory.open( context, new_account_id, customer_name=request.customer_name, @@ -245,13 +245,17 @@ account, _ = await Account.open( - + ```typescript -const [account, response] = await Account.open(context, newAccountId, { - customerName: request.customerName, -}); +const [account, response] = await Account.factory.open( + context, + newAccountId, + { + customerName: request.customerName, + } +); ``` @@ -269,7 +273,7 @@ application (i.e., using an ```python -account, response = await Account.idempotently().open( +account, response = await Account.factory.idempotently().open( context, customer_name=request.customer_name, ) @@ -278,7 +282,7 @@ account, response = await Account.idempotently().open( ```typescript -const [account, response] = await Account.idempotently().open(context, { +const [account, response] = await Account.factory.idempotently().open(context, { customerName: request.customerName, }); ``` diff --git a/documentation/docs/idempotency.mdx b/documentation/docs/idempotency.mdx index 10dbe0500..0572bde34 100644 --- a/documentation/docs/idempotency.mdx +++ b/documentation/docs/idempotency.mdx @@ -23,10 +23,11 @@ distinguish each call, for example: +(CODE:src=../../tests/reboot/idempotency_tests.py&lines=371-375) --> ```py +# First call: sign up the account idempotently. await bank.idempotently('sign up jonathan').SignUp( context, account_id='jonathan', @@ -41,7 +42,7 @@ await bank.idempotently('sign up jonathan').SignUp( ```ts -await Greeter.idempotently("generated").create(context, { +await Greeter.factory.idempotently("generated").create(context, { title: "Mr", name: "John", adjective: "Dangerous", diff --git a/documentation/docs/implement/application.mdx b/documentation/docs/implement/application.mdx index 1b3749c20..aa62257bf 100644 --- a/documentation/docs/implement/application.mdx +++ b/documentation/docs/implement/application.mdx @@ -237,7 +237,7 @@ async def hello_greeter( context: ExternalContext = InjectExternalContext, ): body = await request.json() - greeter, _ = await Greeter.create( + greeter, _ = await Greeter.factory.create( context, title=body['title'], name=body['name'], @@ -266,7 +266,7 @@ application.http.post("/hello_greeter", async (context, req, res) => { name: string; adjective: string; }; - const [greeter] = await Greeter.create(context, { + const [greeter] = await Greeter.factory.create(context, { title, name, adjective, diff --git a/documentation/docs/implement/transactions.mdx b/documentation/docs/implement/transactions.mdx index ad340d7c5..77bbce5fb 100644 --- a/documentation/docs/implement/transactions.mdx +++ b/documentation/docs/implement/transactions.mdx @@ -73,7 +73,7 @@ transfer: async ( +(CODE:src=../../../reboot/examples/bank-nodejs/backend/src/bank_servicer.ts&lines=50-61) --> ```ts diff --git a/documentation/docs/library_services/ciphertext.mdx b/documentation/docs/library_services/ciphertext.mdx index c229bdfd6..05487fb2e 100644 --- a/documentation/docs/library_services/ciphertext.mdx +++ b/documentation/docs/library_services/ciphertext.mdx @@ -112,7 +112,7 @@ from reboot.std.ciphertext.v1.ciphertext import APP_SHARED_KEY_MANAGER_ID from uuid import uuid4 ciphertext_id = str(uuid4()) -ciphertext, _ = await Ciphertext.encrypt( +ciphertext, _ = await Ciphertext.factory.encrypt( context, ciphertext_id, plaintext=b"123-45-6789", @@ -132,7 +132,7 @@ import { } from "@reboot-dev/reboot-std/ciphertext/v1"; const ciphertextId = crypto.randomUUID(); -const [ciphertext] = await Ciphertext.encrypt(context, ciphertextId, { +const [ciphertext] = await Ciphertext.factory.encrypt(context, ciphertextId, { plaintext: new TextEncoder().encode("123-45-6789"), associatedData: makeAssociatedData({ user_id: "42", purpose: "ssn" }), scope: "user_id:42", @@ -199,7 +199,7 @@ other's ciphertexts (`shred` operates per manager). ```py # Encrypt under a named manager. -await Ciphertext.encrypt( +await Ciphertext.factory.encrypt( context, ciphertext_id, plaintext=b"123-45-6789", @@ -217,7 +217,7 @@ await KeyManager.ref("tenant:acme").shred(context, scope="user_id:42") ```ts // Encrypt under a named manager. -await Ciphertext.encrypt(context, ciphertextId, { +await Ciphertext.factory.encrypt(context, ciphertextId, { plaintext: new TextEncoder().encode("123-45-6789"), associatedData: makeAssociatedData({ user_id: "42", purpose: "ssn" }), scope: "user_id:42", diff --git a/documentation/docs/library_services/mailgun.md b/documentation/docs/library_services/mailgun.md index cdb94a284..fc96cbf06 100644 --- a/documentation/docs/library_services/mailgun.md +++ b/documentation/docs/library_services/mailgun.md @@ -28,12 +28,12 @@ Calls to the integration must also authenticate using that same API key as the bearer token: the integration only accepts calls whose bearer token matches `MAILGUN_API_KEY`, and rejects all other calls as unauthenticated. Pass the key using `Options` when calling -`Message.send`: +`Message.factory.send`: ```python from reboot.aio.call import Options -await Message.send( +await Message.factory.send( context, Options(bearer_token=mailgun_api_key), recipient="alice@example.com", @@ -47,7 +47,7 @@ await Message.send( ## Message {#rbtthirdpartymailgunv1message} A single message sent using the integration. -Created and scheduled using its constructor: `await Message.send(...)`. +Created and scheduled using its constructor: `await Message.factory.send(...)`. ### Send diff --git a/documentation/docs/users/external_apis.mdx b/documentation/docs/users/external_apis.mdx index a954b11a7..193d5efe6 100644 --- a/documentation/docs/users/external_apis.mdx +++ b/documentation/docs/users/external_apis.mdx @@ -170,7 +170,7 @@ returned `Ciphertext` state ID — itself a harmless string — in your state as the reference to the encrypted value: ```py -ciphertext, _ = await Ciphertext.encrypt( +ciphertext, _ = await Ciphertext.factory.encrypt( context, plaintext=request.api_key.encode(), associated_data=make_associated_data( diff --git a/documentation/docs/users/tokens.mdx b/documentation/docs/users/tokens.mdx index e40191946..7d9b4057f 100644 --- a/documentation/docs/users/tokens.mdx +++ b/documentation/docs/users/tokens.mdx @@ -47,7 +47,7 @@ You can also pass it as an option when doing ```py -bank, _ = await Bank.create( +bank, _ = await Bank.factory.create( context, SINGLETON_BANK_ID, Options(bearer_token=VALID_JWT), @@ -59,7 +59,7 @@ bank, _ = await Bank.create( ```ts -const [bank] = await Bank.create( +const [bank] = await Bank.factory.create( context, SINGLETON_BANK_ID, {}, diff --git a/rbt/thirdparty/mailgun/v1/mailgun.proto b/rbt/thirdparty/mailgun/v1/mailgun.proto index c08753e19..4004768a0 100644 --- a/rbt/thirdparty/mailgun/v1/mailgun.proto +++ b/rbt/thirdparty/mailgun/v1/mailgun.proto @@ -19,7 +19,8 @@ import "google/protobuf/timestamp.proto"; /** * A single message sent using the integration. * - * Created and scheduled using its constructor: `await Message.Send(...)`. + * Created and scheduled using its constructor: + * `await Message.factory.Send(...)`. */ service MessageMethods { /** diff --git a/reboot/cli/commands/cloud/up.py b/reboot/cli/commands/cloud/up.py index 0624b4b16..3c3dc8cf8 100644 --- a/reboot/cli/commands/cloud/up.py +++ b/reboot/cli/commands/cloud/up.py @@ -87,7 +87,7 @@ async def _maybe_create_application( bearer_token=api_key, ) try: - await Application.Create(context, qualified_application_name) + await Application.factory.Create(context, qualified_application_name) except Aborted as aborted: match aborted.error: case StateAlreadyConstructed(): # type: ignore[misc] diff --git a/reboot/demos/fig/backend/src/main.ts b/reboot/demos/fig/backend/src/main.ts index 9f4de37a3..33f18b9df 100644 --- a/reboot/demos/fig/backend/src/main.ts +++ b/reboot/demos/fig/backend/src/main.ts @@ -7,9 +7,9 @@ import { FigBoardServicer, FigServicer } from "./fig_servicer.js"; import { UserServicer, UsersServicer } from "./user_servicer.js"; const initialize = async (context) => { - await FigBoard.create(context, FIG_BOARD_ID); + await FigBoard.factory.create(context, FIG_BOARD_ID); - await Users.create(context, USERS_ID); + await Users.factory.create(context, USERS_ID); }; new Application({ diff --git a/reboot/demos/fig/backend/src/user_servicer.ts b/reboot/demos/fig/backend/src/user_servicer.ts index 0ad66355d..cd898af6f 100644 --- a/reboot/demos/fig/backend/src/user_servicer.ts +++ b/reboot/demos/fig/backend/src/user_servicer.ts @@ -52,7 +52,7 @@ export class UsersServicer extends Users.Servicer { this.state.userIds.push(request.userId); - await User.create(context, request.userId); + await User.factory.create(context, request.userId); return {}; } diff --git a/reboot/examples/agent-wiki/backend/src/servicers/wiki.py b/reboot/examples/agent-wiki/backend/src/servicers/wiki.py index 7df45abf4..30e7582f0 100644 --- a/reboot/examples/agent-wiki/backend/src/servicers/wiki.py +++ b/reboot/examples/agent-wiki/backend/src/servicers/wiki.py @@ -264,7 +264,7 @@ async def create_page( content. Returns the new page's state ID, which you should link to from the wiki's markdown as `Page:`.""" - page, _ = await Page.create( + page, _ = await Page.factory.create( context, title=title, content=content, @@ -288,7 +288,7 @@ async def create_wiki( context.auth.user_id if context.auth is not None and context.auth.user_id is not None else "" ) - wiki, _ = await Wiki.create( + wiki, _ = await Wiki.factory.create( context, name=request.name, description=request.description, @@ -363,7 +363,7 @@ async def add_transcript( ) -> WikiAddTranscriptResponse: """Create a new Transcript belonging to this Wiki and record it as pending ingestion on the Wiki.""" - transcript, _ = await Transcript.create( + transcript, _ = await Transcript.factory.create( context, messages=list(request.messages), owner_id=self.state.owner_id, diff --git a/reboot/examples/bank-nodejs/backend/src/bank_servicer.ts b/reboot/examples/bank-nodejs/backend/src/bank_servicer.ts index 32cfefcef..c9fad9a7e 100644 --- a/reboot/examples/bank-nodejs/backend/src/bank_servicer.ts +++ b/reboot/examples/bank-nodejs/backend/src/bank_servicer.ts @@ -36,9 +36,13 @@ export class BankServicer extends Bank.Servicer { this.state.accountIds.push(newAccountId); // Let's go create the account. - const [account, response] = await Account.open(context, newAccountId, { - customerName: request.customerName, - }); + const [account, response] = await Account.factory.open( + context, + newAccountId, + { + customerName: request.customerName, + } + ); return { accountId: newAccountId }; } diff --git a/reboot/examples/bank-nodejs/backend/tests/test.ts b/reboot/examples/bank-nodejs/backend/tests/test.ts index c45ad4763..835117244 100644 --- a/reboot/examples/bank-nodejs/backend/tests/test.ts +++ b/reboot/examples/bank-nodejs/backend/tests/test.ts @@ -14,7 +14,7 @@ function reportErrorToUser(errorMessage: string): void { async function performErroringWithdrawal(context: any): Promise { const accountId = "account-nodejs"; - const [account] = await Account.open(context, accountId, { + const [account] = await Account.factory.open(context, accountId, { customerName: "Tony", }); diff --git a/reboot/examples/bank-pydantic/backend/src/bank_servicer.py b/reboot/examples/bank-pydantic/backend/src/bank_servicer.py index f69baafa5..36c824b52 100644 --- a/reboot/examples/bank-pydantic/backend/src/bank_servicer.py +++ b/reboot/examples/bank-pydantic/backend/src/bank_servicer.py @@ -29,7 +29,7 @@ async def sign_up( context: TransactionContext, request: Bank.SignUpRequest, ) -> None: - await Customer.sign_up(context, request.customer_id) + await Customer.factory.sign_up(context, request.customer_id) await OrderedMap.ref(self.state.customer_ids_map_id).Insert( context, diff --git a/reboot/examples/bank-pydantic/backend/src/customer_servicer.py b/reboot/examples/bank-pydantic/backend/src/customer_servicer.py index 324438124..596bcc87a 100644 --- a/reboot/examples/bank-pydantic/backend/src/customer_servicer.py +++ b/reboot/examples/bank-pydantic/backend/src/customer_servicer.py @@ -29,7 +29,7 @@ async def open_account( account_id = str(uuid.uuid4()) self.state.account_ids.append(account_id) - account, _ = await Account.open( + account, _ = await Account.factory.open( context, account_id, ) diff --git a/reboot/examples/bank-pydantic/backend/src/main.py b/reboot/examples/bank-pydantic/backend/src/main.py index e98c62090..fa42e7a08 100644 --- a/reboot/examples/bank-pydantic/backend/src/main.py +++ b/reboot/examples/bank-pydantic/backend/src/main.py @@ -19,7 +19,7 @@ async def initialize(context: InitializeContext): - await Bank.create(context, SINGLETON_BANK_ID) + await Bank.factory.create(context, SINGLETON_BANK_ID) async def main(): diff --git a/reboot/examples/bank-zod/backend/src/bank.ts b/reboot/examples/bank-zod/backend/src/bank.ts index e87babb3a..5eece5a57 100644 --- a/reboot/examples/bank-zod/backend/src/bank.ts +++ b/reboot/examples/bank-zod/backend/src/bank.ts @@ -51,7 +51,7 @@ export const BankServicer = Bank.servicer({ state: Bank.State, { customerId }: Bank.SignUpRequest ): Promise<[Bank.State]> => { - await Customer.signUp(context, customerId); + await Customer.factory.signUp(context, customerId); // Save the account ID to our _distributed_ map using a UUIDv7 // to get a "timestamp" based ordering. diff --git a/reboot/examples/bank-zod/backend/src/customer.ts b/reboot/examples/bank-zod/backend/src/customer.ts index 7c19bedf8..8aa6b1e3a 100644 --- a/reboot/examples/bank-zod/backend/src/customer.ts +++ b/reboot/examples/bank-zod/backend/src/customer.ts @@ -29,7 +29,7 @@ export const CustomerServicer = Customer.servicer({ const accountId = uuidv4(); state.accountIds.push(accountId); - const [account] = await Account.open(context, accountId, {}); + const [account] = await Account.factory.open(context, accountId, {}); await account.deposit(context, { amount: initialDeposit }); diff --git a/reboot/examples/bank-zod/backend/src/main.ts b/reboot/examples/bank-zod/backend/src/main.ts index 40d615dbd..88a97ce81 100644 --- a/reboot/examples/bank-zod/backend/src/main.ts +++ b/reboot/examples/bank-zod/backend/src/main.ts @@ -7,7 +7,7 @@ import { CustomerServicer } from "./customer.js"; const SINGLETON_BANK_ID = "reboot-bank"; const initialize = async (context) => { - await Bank.create(context, SINGLETON_BANK_ID); + await Bank.factory.create(context, SINGLETON_BANK_ID); }; new Application({ diff --git a/reboot/examples/bank-zod/backend/tests/test.ts b/reboot/examples/bank-zod/backend/tests/test.ts index fb55a836d..76247e420 100644 --- a/reboot/examples/bank-zod/backend/tests/test.ts +++ b/reboot/examples/bank-zod/backend/tests/test.ts @@ -19,7 +19,7 @@ function reportErrorToUser(errorMessage: string): void { async function performErroringWithdrawal(context: any): Promise { const accountId = "account-nodejs"; - const [account] = await Account.open(context, accountId, {}); + const [account] = await Account.factory.open(context, accountId, {}); try { await account.withdraw(context, { amount: 65 }); @@ -66,7 +66,7 @@ test("Calling Bank.SignUp", async (t) => { await t.test("Sign Up", async (t) => { const context = rbt.createExternalContext("test"); - const [bank] = await Bank.create(context, "bank-nodejs"); + const [bank] = await Bank.factory.create(context, "bank-nodejs"); const response = await bank.signUp(context, { customerId: "test@reboot.dev", @@ -152,7 +152,7 @@ test("Transfer with Customer", async (t) => { await t.test("Sign Up", async (t) => { const context = rbt.createExternalContext("test"); - const [bank] = await Bank.create(context, "bank-nodejs"); + const [bank] = await Bank.factory.create(context, "bank-nodejs"); const CUSTOMER_ID_1 = "test@reboot.dev"; const CUSTOMER_ID_2 = "test2@reboot.dev"; diff --git a/reboot/examples/bank/backend/src/main.py b/reboot/examples/bank/backend/src/main.py index e5fca3ac2..8b70111ff 100644 --- a/reboot/examples/bank/backend/src/main.py +++ b/reboot/examples/bank/backend/src/main.py @@ -161,7 +161,7 @@ async def sign_up( account_id = request.account_id if mailgun_api_key := await self._mailgun_api_key(): - await mailgun.Message.send( + await mailgun.Message.factory.send( context, None, Options(bearer_token=mailgun_api_key), @@ -173,7 +173,7 @@ async def sign_up( text=self._text_email, ) - account, _ = await Account.open(context, account_id) + account, _ = await Account.factory.open(context, account_id) await account.deposit(context, amount=request.initial_deposit) @@ -213,7 +213,7 @@ async def _mailgun_api_key(self) -> Optional[str]: async def initialize(context: InitializeContext): - await Bank.create(context, SINGLETON_BANK_ID) + await Bank.factory.create(context, SINGLETON_BANK_ID) async def main(): diff --git a/reboot/examples/boutique/backend/src/checkout/servicer.py b/reboot/examples/boutique/backend/src/checkout/servicer.py index 65145c4dd..e46d73f72 100644 --- a/reboot/examples/boutique/backend/src/checkout/servicer.py +++ b/reboot/examples/boutique/backend/src/checkout/servicer.py @@ -107,7 +107,7 @@ async def place_order( confirmation = template.render(order=order_result) if mailgun_api_key := await self._mailgun_api_key(): - await Message.send( + await Message.factory.send( context, Options(bearer_token=mailgun_api_key), recipient=request.email, diff --git a/reboot/examples/boutique/backend/src/main.py b/reboot/examples/boutique/backend/src/main.py index 68f4ad5f6..4e54ea206 100644 --- a/reboot/examples/boutique/backend/src/main.py +++ b/reboot/examples/boutique/backend/src/main.py @@ -11,9 +11,11 @@ async def initialize(context): - await Checkout.create(context, CHECKOUT_ACTOR_ID) + await Checkout.factory.create(context, CHECKOUT_ACTOR_ID) - await ProductCatalog.load_products(context, PRODUCT_CATALOG_ACTOR_ID) + await ProductCatalog.factory.load_products( + context, PRODUCT_CATALOG_ACTOR_ID + ) async def main(): diff --git a/reboot/examples/chick-potle/backend/src/servicers/food.py b/reboot/examples/chick-potle/backend/src/servicers/food.py index 66ef57763..c7f9d1c36 100644 --- a/reboot/examples/chick-potle/backend/src/servicers/food.py +++ b/reboot/examples/chick-potle/backend/src/servicers/food.py @@ -115,7 +115,7 @@ async def start_order( # authorizer only admits that user (or app-internal callers), so # `context.state_id` is the ordering user's ID — even for # app-internal calls, which carry no `context.auth`. - order, _ = await FoodOrder.create( + order, _ = await FoodOrder.factory.create( context, menu=MENU_ITEMS, user_id=context.state_id, diff --git a/reboot/examples/docubot/backend/src/main.ts b/reboot/examples/docubot/backend/src/main.ts index bfe6cb1f0..5b53ec5de 100644 --- a/reboot/examples/docubot/backend/src/main.ts +++ b/reboot/examples/docubot/backend/src/main.ts @@ -4,7 +4,7 @@ import { DOCUBOT_ASSISTANT_ID } from "../../constants.js"; import docubot from "@reboot-dev/docubot"; const initialize = async (context) => { - await Assistant.create(context, DOCUBOT_ASSISTANT_ID, { + await Assistant.factory.create(context, DOCUBOT_ASSISTANT_ID, { name: DOCUBOT_ASSISTANT_ID, url: "https://docs.reboot.dev", }); diff --git a/reboot/examples/kcdc-2025/backend/src/main.py b/reboot/examples/kcdc-2025/backend/src/main.py index f011d1bdd..884e255a7 100644 --- a/reboot/examples/kcdc-2025/backend/src/main.py +++ b/reboot/examples/kcdc-2025/backend/src/main.py @@ -13,9 +13,9 @@ async def initialize(context): - await Channel.create(context, "channel") + await Channel.factory.create(context, "channel") - await Chatbot.create( + await Chatbot.factory.create( context, name="Fact Checker", channel_id="channel", diff --git a/reboot/examples/kcdc-2025/backend/src/servicers/channel.py b/reboot/examples/kcdc-2025/backend/src/servicers/channel.py index 0290d7666..32aa33770 100644 --- a/reboot/examples/kcdc-2025/backend/src/servicers/channel.py +++ b/reboot/examples/kcdc-2025/backend/src/servicers/channel.py @@ -32,7 +32,7 @@ async def create( context: TransactionContext, request: ChannelCreateRequest, ) -> ChannelCreateResponse: - await Index.create( + await Index.factory.create( context, messages_id(context.state_id), order=100, diff --git a/reboot/examples/kcdc-2025/backend/src/servicers/chatbot.py b/reboot/examples/kcdc-2025/backend/src/servicers/chatbot.py index b656705b6..161f0aaf9 100644 --- a/reboot/examples/kcdc-2025/backend/src/servicers/chatbot.py +++ b/reboot/examples/kcdc-2025/backend/src/servicers/chatbot.py @@ -76,7 +76,7 @@ async def create( # Create our messages reactions index so folks can react to # our messages. - await Index.create( + await Index.factory.create( context, f'{request.name}-messages-reactions', order=100, diff --git a/reboot/examples/kcdc-2025/backend/src/servicers/user.py b/reboot/examples/kcdc-2025/backend/src/servicers/user.py index 93f9fa232..e8862dbcd 100644 --- a/reboot/examples/kcdc-2025/backend/src/servicers/user.py +++ b/reboot/examples/kcdc-2025/backend/src/servicers/user.py @@ -62,7 +62,7 @@ async def create( if context.constructor: users = Users.ref(USERS_SINGLETON) await users.add(context, user=context.state_id) - await Index.create( + await Index.factory.create( context, self._messages_reactions.state_id, order=100, @@ -94,7 +94,7 @@ async def add_chatbot( request: AddChatbotRequest, ) -> AddChatbotResponse: - chatbot, _ = await Chatbot.create( + chatbot, _ = await Chatbot.factory.create( context, name=request.name, channel_id=request.channel_id, diff --git a/reboot/examples/mcp-ui-counter-dashboard/backend/src/servicers/counter.py b/reboot/examples/mcp-ui-counter-dashboard/backend/src/servicers/counter.py index ba9aa4d52..4571a41e0 100644 --- a/reboot/examples/mcp-ui-counter-dashboard/backend/src/servicers/counter.py +++ b/reboot/examples/mcp-ui-counter-dashboard/backend/src/servicers/counter.py @@ -22,7 +22,7 @@ async def create_counter( request: CreateCounterRequest, ) -> CreateCounterResponse: """Create a new Counter and return its ID.""" - counter, _ = await Counter.create( + counter, _ = await Counter.factory.create( context, description=request.description ) self.state.counter_ids.append(counter.state_id) diff --git a/reboot/examples/mcp-ui-counter/backend/src/servicers/counter.py b/reboot/examples/mcp-ui-counter/backend/src/servicers/counter.py index a7db4bae2..1252fa9b1 100644 --- a/reboot/examples/mcp-ui-counter/backend/src/servicers/counter.py +++ b/reboot/examples/mcp-ui-counter/backend/src/servicers/counter.py @@ -42,7 +42,7 @@ async def create_counter( request: CreateCounterRequest, ) -> CreateCounterResponse: """Create a new Counter and return its ID.""" - counter, _ = await Counter.create( + counter, _ = await Counter.factory.create( context, description=request.description, owner_id=context.state_id, diff --git a/reboot/examples/monorepo/bank/backend/src/bank_servicer.py b/reboot/examples/monorepo/bank/backend/src/bank_servicer.py index b14ee6e88..cabaa5b11 100644 --- a/reboot/examples/monorepo/bank/backend/src/bank_servicer.py +++ b/reboot/examples/monorepo/bank/backend/src/bank_servicer.py @@ -31,7 +31,7 @@ async def sign_up( new_account_id = str(uuid.uuid4()) # Let's go create the account. - account, _ = await Account.open( + account, _ = await Account.factory.open( context, new_account_id, customer_name=request.customer_name, diff --git a/reboot/examples/monorepo/hello-constructors/backend/src/main.py b/reboot/examples/monorepo/hello-constructors/backend/src/main.py index 28333944a..da9c4d092 100644 --- a/reboot/examples/monorepo/hello-constructors/backend/src/main.py +++ b/reboot/examples/monorepo/hello-constructors/backend/src/main.py @@ -12,7 +12,7 @@ async def initialize(context: InitializeContext): # Explicitly create the state machine. - hello, _ = await Hello.create( + hello, _ = await Hello.factory.create( context, EXAMPLE_STATE_MACHINE_ID, initial_message="Welcome! This message was sent by a constructor.", diff --git a/reboot/examples/reboot-swag-store/backend/src/main.py b/reboot/examples/reboot-swag-store/backend/src/main.py index e2151886f..cac1bc4e4 100644 --- a/reboot/examples/reboot-swag-store/backend/src/main.py +++ b/reboot/examples/reboot-swag-store/backend/src/main.py @@ -28,7 +28,7 @@ async def initialize(context) -> None: """Ensure the coupon book exists (creates initial codes on first run).""" - await CouponBook.create(context, COUPON_BOOK_ID) + await CouponBook.factory.create(context, COUPON_BOOK_ID) async def main() -> None: diff --git a/reboot/examples/reboot-swag-store/backend/src/servicers/store.py b/reboot/examples/reboot-swag-store/backend/src/servicers/store.py index 9ba80c7d3..6db102827 100644 --- a/reboot/examples/reboot-swag-store/backend/src/servicers/store.py +++ b/reboot/examples/reboot-swag-store/backend/src/servicers/store.py @@ -76,7 +76,7 @@ async def create_cart( this method), and is recorded on the cart so only this session can mutate it.""" owner_id = context.auth.user_id if context.auth else "" - cart, _ = await Cart.create(context, owner_id=owner_id) + cart, _ = await Cart.factory.create(context, owner_id=owner_id) return User.CreateCartResponse( cart_id=cart.state_id, ) @@ -272,7 +272,7 @@ async def checkout( variant_ids = [item.variant_id for item in self.state.items] quantities = [item.quantity for item in self.state.items] - order, _ = await Order.create( + order, _ = await Order.factory.create( context, order_id, Order.CreateRequest( diff --git a/reboot/ping/ping.py b/reboot/ping/ping.py index 53673d131..10005368d 100644 --- a/reboot/ping/ping.py +++ b/reboot/ping/ping.py @@ -167,7 +167,7 @@ async def create_counter( context: TransactionContext, request: CreateCounterRequest, ) -> CreateCounterResponse: - counter, _ = await Counter.create( + counter, _ = await Counter.factory.create( context, description=request.description, owner_id=context.state_id, diff --git a/reboot/plugin/skills/mcp-ui/SKILL.md b/reboot/plugin/skills/mcp-ui/SKILL.md index dcf7e7744..31137b898 100644 --- a/reboot/plugin/skills/mcp-ui/SKILL.md +++ b/reboot/plugin/skills/mcp-ui/SKILL.md @@ -149,7 +149,7 @@ exactly one of them — the step that needs it. `self.state_id`); `self.ref().schedule(...)`. - `python/references/rpc-calls.md` — kwargs, not Request wrappers. - `python/references/rpc-constructor-calls.md` — - `Service.create(context, id)` semantics. + `Service.factory.create(context, id)` semantics. - `python/references/servicer-workflow.md` — only when you declared a `Workflow`, and then top to bottom: the `@classmethod` / `WorkflowContext` declaration shape, the call-classification @@ -158,7 +158,7 @@ exactly one of them — the step that needs it. `until` / `until_changes`, and workflow exit semantics. - [`references/servicer-patterns.md`](references/servicer-patterns.md) — the MCP UI servicer shapes: `UserServicer` calling - `.create(context)`, a Workflow Servicer with `MyType.ref()` + `.factory.create(context)`, a Workflow Servicer with `MyType.ref()` (no-arg) magic, inline writers via `.per_workflow("alias").write(context, fn)` / `.per_iteration("alias").write(...)` / `.always().write(...)`, @@ -406,7 +406,7 @@ Before writing code, analyze the user's request: 3. **User methods**: How does the AI create instances of application types? Each gets a `Transaction` on `User` that calls - `.create(context)`, then registers the new ID in the + `.factory.create(context)`, then registers the new ID in the appropriate container (Shape B or C above). 4. **State shape (per type)**: Fields, types — lists, nested objects, primitives. Each gets `Field(tag=N)`. **Nested `Model` @@ -514,7 +514,7 @@ that warn you are accreting concerns, and the split pattern, are in Full pydantic shape in [`references/api-method-types.md`](references/api-method-types.md); -the `UserServicer` + `.create(context)` pattern in +the `UserServicer` + `.factory.create(context)` pattern in [`references/servicer-patterns.md`](references/servicer-patterns.md). ### Tool Exposure Control diff --git a/reboot/plugin/skills/mcp-ui/references/gotchas.md b/reboot/plugin/skills/mcp-ui/references/gotchas.md index 6d1813bc5..1eacba7b5 100644 --- a/reboot/plugin/skills/mcp-ui/references/gotchas.md +++ b/reboot/plugin/skills/mcp-ui/references/gotchas.md @@ -10,7 +10,7 @@ tags: gotchas, traps, errors, mcp, ui, factory, workflow, ref, schedule, optiona For the rest of the trip-list — `.rbtrc` line-based, no `__init__.py` in `api/`, pydantic Field zero-default rule, `self.ref().state_id` not `self.state_id`, kwargs not Request wrappers, generated import -paths, `Service.create(context, id)` semantics, register-all-Servicers +paths, `Service.factory.create(context, id)` semantics, register-all-Servicers — see `python/references/patterns-common-gotchas.md` and the per-topic references. diff --git a/reboot/plugin/skills/mcp-ui/references/servicer-patterns.md b/reboot/plugin/skills/mcp-ui/references/servicer-patterns.md index 7d163f2fb..bc0aaba4e 100644 --- a/reboot/plugin/skills/mcp-ui/references/servicer-patterns.md +++ b/reboot/plugin/skills/mcp-ui/references/servicer-patterns.md @@ -16,7 +16,10 @@ wrappers, raise typed `Aborted`) are in - One Servicer class per type — `UserServicer` plus one per application type. - The User Servicer's `create_` Transaction calls - `.create(context)` and returns the `state_id` in a response. + `.factory.create(context)` and returns the `state_id` in a + response. Constructors live under the `factory` namespace on the + state class (`.factory.create(...)`), keeping the top-level + state-class namespace free for framework methods like `ref()`. - Workflow Servicers use `MyType.ref()` (no args, picks up `state_id` from `WorkflowContext`) — see Gotcha #11 below; `cls.ref()` and `self.ref()` are both wrong. @@ -44,9 +47,10 @@ class UserServicer(User.Servicer): """Create a new Counter and return its ID.""" # Factory create: pass request fields as keyword args directly # — do NOT wrap in a Request object. - # No-args: Counter.create(context) - # With args: Counter.create(context, title="...", count=0) - counter, _ = await Counter.create(context) + # No-args: Counter.factory.create(context) + # With args: Counter.factory.create( + # context, title="...", count=0) + counter, _ = await Counter.factory.create(context) return User.CreateCounterResponse( counter_id=counter.state_id, ) @@ -188,7 +192,7 @@ class UserServicer(User.Servicer): context: TransactionContext, request: User.CreateGameRequest, ) -> User.CreateGameResponse: - game, _ = await Game.create(context, ...) + game, _ = await Game.factory.create(context, ...) # GOOD — schedule the workflow from the transaction. # Empty request: just pass `context`. await Game.ref(game.state_id).schedule().autoplay(context) diff --git a/reboot/plugin/skills/python/SKILL.md b/reboot/plugin/skills/python/SKILL.md index e10955d8e..a1c669bde 100644 --- a/reboot/plugin/skills/python/SKILL.md +++ b/reboot/plugin/skills/python/SKILL.md @@ -333,8 +333,9 @@ The `Agent` runs only inside a `WorkflowContext`, so also read the trap (`await ref.deposit(context, DepositRequest(amount=10))`) is a recurring miss; passes type-check and fails at runtime - `references/rpc-constructor-calls.md` — **always read** when the - agent invokes a constructor: use `.create(context, id, ...)` or - `.(context, id, ...)`, NEVER `.ref(id).(...)` + agent invokes a constructor: use `.factory.create(context, id, ...)` + or `.factory.(context, id, ...)`, NEVER + `.ref(id).(...)` (the trap that skips creation semantics). The factory-declaration side is `servicer-constructor.md`; the call-site side is here diff --git a/reboot/plugin/skills/python/references/_sections.md b/reboot/plugin/skills/python/references/_sections.md index 73c4b8bfe..445d810d1 100644 --- a/reboot/plugin/skills/python/references/_sections.md +++ b/reboot/plugin/skills/python/references/_sections.md @@ -47,7 +47,7 @@ This file defines the rule categories for Reboot Python best practices. Rules ar ## 9. RPC (rpc) **Impact:** MEDIUM -**Description:** Calling actors via `Service.ref(id)` and `await ref.method(context, ...)`. Constructor calls (`Service.create`), fan-out via `Service.forall(ids).method(context)`, and the kwargs-not-Request convention. +**Description:** Calling actors via `Service.ref(id)` and `await ref.method(context, ...)`. Constructor calls (`Service.factory.create`), fan-out via `Service.forall(ids).method(context)`, and the kwargs-not-Request convention. ## 10. Scheduling (scheduling) diff --git a/reboot/plugin/skills/python/references/api-pydantic.md b/reboot/plugin/skills/python/references/api-pydantic.md index 52d726095..35d7dde90 100644 --- a/reboot/plugin/skills/python/references/api-pydantic.md +++ b/reboot/plugin/skills/python/references/api-pydantic.md @@ -211,8 +211,8 @@ Error while parsing option value for "method": Message type ```python # OK -open=Writer(... factory=True ...), # Account.Open(ctx, id, ...) -place=Transaction(... factory=True ...), # Order.Place(ctx, id, ...) +open=Writer(... factory=True ...), # Account.factory.open(ctx, id, ...) +place=Transaction(... factory=True ...), # Order.factory.place(ctx, id, ...) # REJECTED by `rbt generate` hello=Workflow(... factory=True ...), # codegen error diff --git a/reboot/plugin/skills/python/references/auth-external-api-calls.md b/reboot/plugin/skills/python/references/auth-external-api-calls.md index 2b756da95..5213f0164 100644 --- a/reboot/plugin/skills/python/references/auth-external-api-calls.md +++ b/reboot/plugin/skills/python/references/auth-external-api-calls.md @@ -174,7 +174,7 @@ class UserServicer(User.Servicer): request: User.ConnectAcmeRequest, ) -> User.ConnectAcmeResponse: user_id = self.ref().state_id - ciphertext, _ = await Ciphertext.encrypt( + ciphertext, _ = await Ciphertext.factory.encrypt( context, plaintext=request.api_key.encode(), associated_data=make_associated_data( @@ -316,7 +316,7 @@ await KeyManager.ref(_key_manager_id(GOOGLE)).shred(context, scope=user_id) (any other service): your own authorize + callback routes, callback registered `app_internal=True`, the OAuth `state` HMAC-signed and verified, `OAuthTokenManager.store` called with the app-internal `external_context(request)`. Path C - (the user provides an API key, not OAuth): `Ciphertext.encrypt`, + (the user provides an API key, not OAuth): `Ciphertext.factory.encrypt`, with the returned `state_id` — never the raw key — kept in state. A key the developer holds for the whole app is an application secret (`rbt cloud secret`), not actor state. diff --git a/reboot/plugin/skills/python/references/lifecycle-initialize-hook.md b/reboot/plugin/skills/python/references/lifecycle-initialize-hook.md index c8e2f3b06..b7bf6e3e0 100644 --- a/reboot/plugin/skills/python/references/lifecycle-initialize-hook.md +++ b/reboot/plugin/skills/python/references/lifecycle-initialize-hook.md @@ -10,7 +10,7 @@ tags: initialize, InitializeContext, create, singleton, bootstrap > **Critical:** `initialize` runs on **every** application start, so > its calls get an **auto-generated idempotency key** (one per > `actor` + `method`) and run once. Constructors — -> `Service.create(context, id)` / factory methods — are a no-op on +> `Service.factory.create(context, id)` / factory methods — are a no-op on > existing actors. The catch: to call the **same method on the same > actor more than once** you **must** distinguish the calls with > `.idempotently("alias")` (or an explicit `key=`), or the second one @@ -23,7 +23,7 @@ runs against an `InitializeContext` and is the right place to create singletons or seed data that must exist before the first real request. The callback runs each time the application starts; Reboot's idempotent -`Service.create(context, id)` makes calling it on every boot safe. +`Service.factory.create(context, id)` makes calling it on every boot safe. **Incorrect (creating singletons inside a Servicer's `__init__`):** @@ -33,7 +33,7 @@ class BankServicer(Bank.Servicer): def __init__(self): # This won't run "at startup"; it runs the first time # someone references the Bank actor. - Bank.create(...) # also: no context here + Bank.factory.create(...) # also: no context here ``` **Correct (matches the [`reboot-bank-pydantic`](https://github.com/reboot-dev/reboot-bank-pydantic) example, `backend/src/main.py`):** @@ -47,7 +47,7 @@ SINGLETON_BANK_ID = 'SVB' async def initialize(context: InitializeContext): - await Bank.create(context, SINGLETON_BANK_ID) + await Bank.factory.create(context, SINGLETON_BANK_ID) async def main(): @@ -61,7 +61,7 @@ async def main(): If a `Type` does **not** declare a `factory=True` method, Reboot will implicitly create the actor on the first writer call. A simple chat -room can use this — no explicit `ChatRoom.create(...)` is needed when +room can use this — no explicit `ChatRoom.factory.create(...)` is needed when `send` is a `Writer`: ```python @@ -73,13 +73,14 @@ async def initialize(context: InitializeContext): When the API **does** declare a factory (`Writer(... factory=True ...)` or `Transaction(... factory=True ...)`), call it explicitly via -`Service.create(context, id)` or `Service.(context, id, ...)`. +`Service.factory.create(context, id)` or +`Service.factory.(context, id, ...)`. ## Calling the Same Method More Than Once — `.idempotently("alias")` `initialize` auto-generates an idempotency key per `(actor, method)`, so **one** call to a given method is fine bare — that's why -`Service.create(...)` followed by a single `ref.send(...)` works +`Service.factory.create(...)` followed by a single `ref.send(...)` works without any alias. But calling that **same** method on the **same** actor again in the same `initialize` raises: @@ -94,7 +95,7 @@ Give each call a **distinct** `.idempotently("alias")` (or explicit ```python async def initialize(context: InitializeContext): - hello, _ = await Hello.create( + hello, _ = await Hello.factory.create( context, "reboot-hello", initial_message="Welcome!", ) diff --git a/reboot/plugin/skills/python/references/patterns-common-gotchas.md b/reboot/plugin/skills/python/references/patterns-common-gotchas.md index 878258df3..b4076cad6 100644 --- a/reboot/plugin/skills/python/references/patterns-common-gotchas.md +++ b/reboot/plugin/skills/python/references/patterns-common-gotchas.md @@ -45,16 +45,16 @@ await account.deposit(context, DepositRequest(amount=10)) await account.deposit(context, amount=10) ``` -### 5. Constructor Calls Use `Service.create` / `Service.` +### 5. Constructor Calls Use `Service.factory.create` / `Service.factory.` -Don't call a constructor through `.ref(id).method(...)`. Use the factory -form so creation semantics apply: +Don't call a constructor through `.ref(id).method(...)`. Invoke it +through the `factory` namespace so creation semantics apply: ```python # Wrong: await Account.ref(id).open(context) # Right: -account, _ = await Account.open(context, id) +account, _ = await Account.factory.open(context, id) ``` ### 6. Servicer `authorizer()` Returns an Instance @@ -105,8 +105,8 @@ Workflow, Not a Transaction" in `servicer-transaction.md`. ### 9. `initialize` Runs on Every Restart -It's idempotent only if **you** make it so. Use `Service.create` and -`context.constructor` to gate set-once work. +It's idempotent only if **you** make it so. Use `Service.factory.create` +and `context.constructor` to gate set-once work. ### 10. Don't Hand-Edit `*_rbt.py` diff --git a/reboot/plugin/skills/python/references/patterns-idempotency.md b/reboot/plugin/skills/python/references/patterns-idempotency.md index 6ad748300..f6d6759a4 100644 --- a/reboot/plugin/skills/python/references/patterns-idempotency.md +++ b/reboot/plugin/skills/python/references/patterns-idempotency.md @@ -8,12 +8,12 @@ tags: patterns, idempotency, initialize, constructor, restart ## Make Constructor and `initialize` Calls Idempotent > **Critical:** `initialize` runs on every restart, and Reboot may -> retry transactions internally. `Service.create(context, id)` is the +> retry transactions internally. `Service.factory.create(context, id)` is the > idempotent creation primitive — safe to call repeatedly. Inside a > reusable constructor, gate set-once fields on `context.constructor`. The `initialize` hook runs every time the application starts. Anything it -does must be safe to do repeatedly. Reboot's `Service.create(context, id)` +does must be safe to do repeatedly. Reboot's `Service.factory.create(context, id)` is the canonical idempotent creation primitive: calling it on an existing actor is a no-op. @@ -31,7 +31,7 @@ async def initialize(context: InitializeContext): ```python async def initialize(context: InitializeContext): # Create-once: idempotent on subsequent boots. - await Bank.create(context, SINGLETON_BANK_ID) + await Bank.factory.create(context, SINGLETON_BANK_ID) ``` ## Branch on `context.constructor` for Set-Once Fields diff --git a/reboot/plugin/skills/python/references/rpc-calls.md b/reboot/plugin/skills/python/references/rpc-calls.md index 16a080a96..e8cb7b81d 100644 --- a/reboot/plugin/skills/python/references/rpc-calls.md +++ b/reboot/plugin/skills/python/references/rpc-calls.md @@ -55,7 +55,7 @@ Constructor calls return a `(ref, response)` tuple — the ref to the newly-constructed actor and the response from the method: ```python -account, _ = await Account.open(context, request.account_id) +account, _ = await Account.factory.open(context, request.account_id) await account.deposit(context, amount=request.initial_deposit) ``` diff --git a/reboot/plugin/skills/python/references/rpc-constructor-calls.md b/reboot/plugin/skills/python/references/rpc-constructor-calls.md index 65e38713e..b71679bed 100644 --- a/reboot/plugin/skills/python/references/rpc-constructor-calls.md +++ b/reboot/plugin/skills/python/references/rpc-constructor-calls.md @@ -1,26 +1,29 @@ --- -title: Use `Service.create` and `Service.` for Constructor Calls +title: Use `Service.factory.create` and `Service.factory.` for Constructor Calls impact: MEDIUM impactDescription: Calling a constructor through `.ref(...).method(...)` skips creation semantics tags: rpc, constructor, create, factory --- -## Use `Service.create` and `Service.` for Constructor Calls +## Use `Service.factory.create` and `Service.factory.` for Constructor Calls > **Critical:** never invoke a constructor through `Service.ref(id).method(...)` -> — that skips creation semantics. Use `await Service.create(context, id)` -> for default constructors and `await Service.(context, id, ...)` -> for named ones. Both return a `(ref, response)` tuple. +> — that skips creation semantics. Use +> `await Service.factory.create(context, id)` for default constructors and +> `await Service.factory.(context, id, ...)` for named ones. +> Both return a `(ref, response)` tuple. A method declared with `factory=True` is the actor's creation path. -Invoke it via the generated factory call: +Invoke it through the `factory` namespace on the state type: -- `await Service.create(context, id)` — for the implicit/default - constructor (e.g., `Bank.create(context, SINGLETON_BANK_ID)`). -- `await Service.(context, id, **kwargs)` — for a named - constructor method (e.g., `Account.open(context, account_id)`). +- `await Service.factory.create(context, id)` — for the implicit/default + constructor (e.g., `Bank.factory.create(context, SINGLETON_BANK_ID)`). +- `await Service.factory.(context, id, **kwargs)` — for a named + constructor method (e.g., `Account.factory.open(context, account_id)`). -Both return a `(ref, response)` tuple. +Both return a `(ref, response)` tuple. Routing constructors through the +`factory` namespace keeps the top level of the state type free for +framework methods like `ref()`. **Incorrect (using `.ref(...).method(...)` for a constructor):** @@ -46,18 +49,18 @@ open=Writer( `main.py`: ```python -account, _ = await Account.open(context, account_id) +account, _ = await Account.factory.open(context, account_id) await account.deposit(context, amount=request.initial_deposit) ``` -## `Service.create(context, id)` Is the Idempotent Default +## `Service.factory.create(context, id)` Is the Idempotent Default When the `Type` has no explicit factory (no `factory=True` method), -use `Service.create` from the `initialize` hook: +use `Service.factory.create` from the `initialize` hook: ```python async def initialize(context: InitializeContext): - await Bank.create(context, SINGLETON_BANK_ID) + await Bank.factory.create(context, SINGLETON_BANK_ID) ``` This is safe to call on every application start; existing actors aren't @@ -69,7 +72,7 @@ The first element of the returned tuple is the ref. Prefer using it directly rather than re-constructing one with `Service.ref(...)`: ```python -account, _ = await Account.open(context, account_id) +account, _ = await Account.factory.open(context, account_id) # Use the returned ref: await account.deposit(context, amount=100) diff --git a/reboot/plugin/skills/python/references/servicer-constructor.md b/reboot/plugin/skills/python/references/servicer-constructor.md index 46a53fa26..7dc461790 100644 --- a/reboot/plugin/skills/python/references/servicer-constructor.md +++ b/reboot/plugin/skills/python/references/servicer-constructor.md @@ -7,10 +7,11 @@ tags: servicer, constructor, context.constructor, create, initialization ## Handle Constructor Methods -> **Critical:** invoke a constructor as `await Service.create(context, id)` -> (or `await Service.(context, id, **kwargs)`), **never** -> as `Service.ref(id).method(...)` — the latter skips creation -> semantics. Inside the implementation, branch on +> **Critical:** invoke a constructor as +> `await Service.factory.create(context, id)` (or +> `await Service.factory.(context, id, **kwargs)`), +> **never** as `Service.ref(id).method(...)` — the latter skips +> creation semantics. Inside the implementation, branch on > `context.constructor` for set-once initial state. A method declared with `factory=True` on its `Writer(...)` or @@ -18,7 +19,7 @@ A method declared with `factory=True` on its `Writer(...)` or The Servicer implementation is just an ordinary writer/transaction method — the _constructor-ness_ shows up in two places: -1. **Caller side**: use `await Service.create(context, id)` (not +1. **Caller side**: use `await Service.factory.create(context, id)` (not `Service.ref(id).method(...)`) to invoke it. 2. **Servicer side**: branch on `context.constructor` to set initial state only on the creation pass. @@ -75,10 +76,10 @@ second call. ```python async def initialize(context: InitializeContext): - await Bank.create(context, SINGLETON_BANK_ID) + await Bank.factory.create(context, SINGLETON_BANK_ID) ``` -`Service.create(context, id)` is **idempotent** when called from the +`Service.factory.create(context, id)` is **idempotent** when called from the `initialize` hook, so it's safe to invoke on every application start. ## Calling from a Transaction @@ -89,11 +90,11 @@ A transaction can create and operate on a new actor in one atomic step: async def sign_up( self, context: TransactionContext, request: Bank.SignUpRequest, ) -> None: - account, _ = await Account.open(context, request.account_id) + account, _ = await Account.factory.open(context, request.account_id) await account.deposit(context, amount=request.initial_deposit) ``` -`Account.open(context, id)` here is the constructor (the `open` method +`Account.factory.open(context, id)` here is the constructor (the `open` method declared `factory=True`) and returns the actor reference plus the response (or `None` when `response=None`). diff --git a/reboot/plugin/skills/python/references/servicer-transaction.md b/reboot/plugin/skills/python/references/servicer-transaction.md index 91f5c41d3..796d1025c 100644 --- a/reboot/plugin/skills/python/references/servicer-transaction.md +++ b/reboot/plugin/skills/python/references/servicer-transaction.md @@ -107,7 +107,7 @@ async def sign_up( self, context: TransactionContext, request: SignUpRequest, ) -> SignUpResponse: if mailgun_api_key := await self._mailgun_api_key(): - await mailgun.Message.send( + await mailgun.Message.factory.send( context, None, Options(bearer_token=mailgun_api_key), recipient=request.account_id, sender='team@reboot.dev', @@ -117,16 +117,16 @@ async def sign_up( text=self._text_email, ) - account, _ = await Account.open(context, request.account_id) + account, _ = await Account.factory.open(context, request.account_id) await account.deposit(context, amount=request.initial_deposit) return SignUpResponse() ``` -`mailgun.Message.send` is a `Writer` on an in-system mailgun actor — it -does not hit the network itself; it **schedules a workflow** that makes -the actual HTTP send. So the transaction only ever issues in-system -RPCs, and the un-rollback-able external call lives safely in that -workflow. +`mailgun.Message.factory.send` is a `Writer` on an in-system mailgun +actor — it does not hit the network itself; it **schedules a workflow** +that makes the actual HTTP send. So the transaction only ever issues +in-system RPCs, and the un-rollback-able external call lives safely in +that workflow. When _you_ are the one making the external call — an LLM / model API call, a payment charge, an SMS — put it in a `Workflow` method and @@ -176,7 +176,7 @@ orchestration calls where the caller only needs success/failure - `rpc-forall.md` — `Service.forall(ids).method(context, ...)` for fan-out across many actors. - `servicer-constructor.md` — when a transaction also constructs an - actor (e.g. `Account.open(context, id)`). + actor (e.g. `Account.factory.open(context, id)`). - `api-errors.md` — typed errors that roll back the entire transaction. - `servicer-workflow.md` — when one-shot atomicity isn't enough and you need durable, long-running orchestration. diff --git a/reboot/plugin/skills/python/references/state-actor-decomposition.md b/reboot/plugin/skills/python/references/state-actor-decomposition.md index a3bd7b722..7dab15326 100644 --- a/reboot/plugin/skills/python/references/state-actor-decomposition.md +++ b/reboot/plugin/skills/python/references/state-actor-decomposition.md @@ -111,9 +111,9 @@ class UserServicer(User.Servicer): ) -> None: if context.constructor: self.state.display_name = request.display_name - session, _ = await TelegramSession.create(context) + session, _ = await TelegramSession.factory.create(context) self.state.telegram_session_id = session.state_id - manager, _ = await MonitoringManager.create(context) + manager, _ = await MonitoringManager.factory.create(context) self.state.monitoring_manager_id = manager.state_id ``` diff --git a/reboot/plugin/skills/python/references/state-collections.md b/reboot/plugin/skills/python/references/state-collections.md index 7c92fa357..4e95fa79c 100644 --- a/reboot/plugin/skills/python/references/state-collections.md +++ b/reboot/plugin/skills/python/references/state-collections.md @@ -210,7 +210,7 @@ class UserServicer(User.Servicer): request: User.AddPersonRequest, ) -> User.AddPersonResponse: # `Person` is its own state Type with `factory=True` `create`. - person, _ = await Person.create( + person, _ = await Person.factory.create( context, name=request.name, birthday=request.birthday, diff --git a/reboot/plugin/skills/python/references/state-scalar-fields.md b/reboot/plugin/skills/python/references/state-scalar-fields.md index f8c8e2668..8b0e8213b 100644 --- a/reboot/plugin/skills/python/references/state-scalar-fields.md +++ b/reboot/plugin/skills/python/references/state-scalar-fields.md @@ -125,7 +125,7 @@ class IntegrationState(Model): ``` ```python -ciphertext, _ = await Ciphertext.encrypt( +ciphertext, _ = await Ciphertext.factory.encrypt( context, plaintext=raw_api_key.encode(), associated_data=make_associated_data(tenant_id=tenant_id, purpose="api-key"), diff --git a/reboot/plugin/skills/python/references/stdlib-ciphertext.md b/reboot/plugin/skills/python/references/stdlib-ciphertext.md index 10d37b84b..0a15de060 100644 --- a/reboot/plugin/skills/python/references/stdlib-ciphertext.md +++ b/reboot/plugin/skills/python/references/stdlib-ciphertext.md @@ -61,13 +61,13 @@ async def main(): ### Methods -| Call | Type | Notes | -| ----------------------------------------------------------------------------------------- | ------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | -| `Ciphertext.encrypt(context, [id], *, plaintext, associated_data, scope, key_manager_id)` | transaction (constructor) | `key_manager_id` is **required** (pass `APP_SHARED_KEY_MANAGER_ID`); returns `(ref, EncryptResponse)`; omit `id` to auto-generate one and read it back as `ref.state_id` | -| `Ciphertext.ref(id).decrypt(context, *, associated_data)` | reader | `-> DecryptResponse(plaintext)`. Raises `DecryptAborted` | -| `Ciphertext.ref(id).rescope(context, *, scope)` | transaction | move a ciphertext to a different scope (same manager); only the wrapped DEK changes | -| `KeyManager.ref(APP_SHARED_KEY_MANAGER_ID).shred(context, *, scope)` | transaction | crypto-shred a scope — idempotent | -| `KeyManager.ref(APP_SHARED_KEY_MANAGER_ID).status(context)` | reader | `-> StatusResponse(active_version, rotating)`; poll to confirm a rotation finished (`active_version` reached and `rotating` is false) | +| Call | Type | Notes | +| ------------------------------------------------------------------------------------------------- | ------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | +| `Ciphertext.factory.encrypt(context, [id], *, plaintext, associated_data, scope, key_manager_id)` | transaction (constructor) | `key_manager_id` is **required** (pass `APP_SHARED_KEY_MANAGER_ID`); returns `(ref, EncryptResponse)`; omit `id` to auto-generate one and read it back as `ref.state_id` | +| `Ciphertext.ref(id).decrypt(context, *, associated_data)` | reader | `-> DecryptResponse(plaintext)`. Raises `DecryptAborted` | +| `Ciphertext.ref(id).rescope(context, *, scope)` | transaction | move a ciphertext to a different scope (same manager); only the wrapped DEK changes | +| `KeyManager.ref(APP_SHARED_KEY_MANAGER_ID).shred(context, *, scope)` | transaction | crypto-shred a scope — idempotent | +| `KeyManager.ref(APP_SHARED_KEY_MANAGER_ID).status(context)` | reader | `-> StatusResponse(active_version, rotating)`; poll to confirm a rotation finished (`active_version` reached and `rotating` is false) | Imports: @@ -84,7 +84,7 @@ from reboot.std.ciphertext.v1.ciphertext import ( ### Encrypt ```python -ciphertext, _ = await Ciphertext.encrypt( +ciphertext, _ = await Ciphertext.factory.encrypt( context, plaintext=b"123-45-6789", associated_data=make_associated_data(user_id="42", purpose="ssn"), diff --git a/reboot/plugin/skills/python/references/stdlib-presence.md b/reboot/plugin/skills/python/references/stdlib-presence.md index b946675b1..7058dca7e 100644 --- a/reboot/plugin/skills/python/references/stdlib-presence.md +++ b/reboot/plugin/skills/python/references/stdlib-presence.md @@ -71,7 +71,7 @@ async def main(): The intended dance, per the type's docs: -1. Client `Subscriber.create(context, subscriber_id)` — once. +1. Client `Subscriber.factory.create(context, subscriber_id)` — once. 2. Client opens a long-lived `Subscriber.ref(id).connect(context)` reader RPC; this stays open as long as the client is connected. 3. Client `Subscriber.ref(id).toggle(context)` to mark itself as live; diff --git a/reboot/plugin/skills/python/references/testing-harness.md b/reboot/plugin/skills/python/references/testing-harness.md index adaa0ea10..eb0855280 100644 --- a/reboot/plugin/skills/python/references/testing-harness.md +++ b/reboot/plugin/skills/python/references/testing-harness.md @@ -109,7 +109,7 @@ Things to know: ```python async def _initialize(context) -> None: - await CouponBook.create(context, COUPON_BOOK_ID) + await CouponBook.factory.create(context, COUPON_BOOK_ID) await self.rbt.up( Application( diff --git a/reboot/plugin/skills/web-app/SKILL.md b/reboot/plugin/skills/web-app/SKILL.md index 2458b858d..351d4888a 100644 --- a/reboot/plugin/skills/web-app/SKILL.md +++ b/reboot/plugin/skills/web-app/SKILL.md @@ -249,7 +249,7 @@ exactly one of them — the step that needs it. `self.state_id`); `self.ref().schedule(...)`. - `python/references/rpc-calls.md` — kwargs, not Request wrappers. - `python/references/rpc-constructor-calls.md` — - `Service.create(context, id)` semantics. + `Service.factory.create(context, id)` semantics. - `python/references/servicer-workflow.md` — only when you declared a `Workflow`, and then top to bottom: the `@classmethod` / `WorkflowContext` declaration shape, the call-classification diff --git a/reboot/std/oauth/v1/oauth.py b/reboot/std/oauth/v1/oauth.py index fdfc51d15..b5e9fde14 100644 --- a/reboot/std/oauth/v1/oauth.py +++ b/reboot/std/oauth/v1/oauth.py @@ -117,7 +117,7 @@ async def store( # merge first — we can't read the index here, since this same # transaction writes it (Reboot forbids reading and writing the # same state in one transaction). - ciphertext, _ = await Ciphertext.encrypt( + ciphertext, _ = await Ciphertext.factory.encrypt( context, plaintext=request.tokens.SerializeToString(), associated_data=_associated_data(service, request.user_id), diff --git a/tests/reboot/agents/pydantic_ai/agent_tests.py b/tests/reboot/agents/pydantic_ai/agent_tests.py index ba3e2edcc..771ff0baa 100644 --- a/tests/reboot/agents/pydantic_ai/agent_tests.py +++ b/tests/reboot/agents/pydantic_ai/agent_tests.py @@ -569,7 +569,9 @@ async def asyncSetUp(self) -> None: ) self.context = self.rbt.create_external_context(name=self.id()) - self.general, _ = await General.constructor_writer(self.context) + self.general, _ = await General.factory.constructor_writer( + self.context + ) async def asyncTearDown(self) -> None: await self.rbt.stop() diff --git a/tests/reboot/aio/internals/tasks_servicer_tests.py b/tests/reboot/aio/internals/tasks_servicer_tests.py index 2f51cb584..5747a7fa1 100644 --- a/tests/reboot/aio/internals/tasks_servicer_tests.py +++ b/tests/reboot/aio/internals/tasks_servicer_tests.py @@ -624,7 +624,7 @@ async def workflow( context = self.rbt.create_external_context(name=self.id()) - general, _ = await General.ConstructorWriter( + general, _ = await General.factory.ConstructorWriter( context, "scheduled-loop-test" ) task = await general.spawn().Workflow(context) @@ -715,7 +715,7 @@ async def workflow( context = self.rbt.create_external_context(name=self.id()) - general, _ = await General.ConstructorWriter( + general, _ = await General.factory.ConstructorWriter( context, "test_iteration_count" ) task = await general.spawn().Workflow(context) diff --git a/tests/reboot/auth_bank_main.py b/tests/reboot/auth_bank_main.py index dde7b8ebc..5018df76d 100644 --- a/tests/reboot/auth_bank_main.py +++ b/tests/reboot/auth_bank_main.py @@ -20,7 +20,7 @@ async def initialize(context: InitializeContext): """Create the singleton bank in our application.""" print("🏦🏦🏦 Creating Bank if it hasn't already been created.... 🏦🏦🏦") - await Bank.Create(context, SINGLETON_BANK_ID) + await Bank.factory.Create(context, SINGLETON_BANK_ID) print("💰💰💰 Bank is ready for business! 💰💰💰") diff --git a/tests/reboot/auth_tests.py b/tests/reboot/auth_tests.py index 7759a6f0e..f32969305 100644 --- a/tests/reboot/auth_tests.py +++ b/tests/reboot/auth_tests.py @@ -160,7 +160,7 @@ async def asyncSetUp(self): bearer_token=VALID_JWT, ) - bank, _ = await Bank.create(context, SINGLETON_BANK_ID) + bank, _ = await Bank.factory.create(context, SINGLETON_BANK_ID) await bank.sign_up(context, account_id=ACCOUNT_NAME) async def asyncTearDown(self): @@ -325,7 +325,7 @@ async def asyncSetUp(self): bearer_token=VALID_JWT, ) - bank, _ = await Bank.create(context, SINGLETON_BANK_ID) + bank, _ = await Bank.factory.create(context, SINGLETON_BANK_ID) async def asyncTearDown(self): await self.rbt.stop() @@ -396,7 +396,7 @@ async def test_construct_auth(self): context = self.rbt.create_external_context(name=self.id()) # Test that a bearer token can be used via construct. - bank, _ = await Bank.create( + bank, _ = await Bank.factory.create( context, SINGLETON_BANK_ID, Options(bearer_token=VALID_JWT), diff --git a/tests/reboot/bank.py b/tests/reboot/bank.py index be27efaa5..95e907610 100644 --- a/tests/reboot/bank.py +++ b/tests/reboot/bank.py @@ -202,7 +202,7 @@ async def test_nested_transaction_that_aborts( state.balance += 10 # We abort below so this call should also not take effect. - await Account.open(context, f'{context.state_id}-nested') + await Account.factory.open(context, f'{context.state_id}-nested') raise Account.TestNestedTransactionThatAbortsAborted( bank_rbt.UserError() @@ -290,7 +290,7 @@ async def sign_up( # Since we may manually retry the following call, we must # provide idempotency, which we do via passing the string # alias 'open'. - await Account.idempotently('open').open( + await Account.factory.idempotently('open').open( context, request.account_id, Options(bearer_token=context.caller_bearer_token), @@ -302,7 +302,7 @@ async def sign_up( # For testing purposes, call the 'open' method again - so that it's always # called twice, and idempotency is demonstrated. - account, _ = await Account.idempotently('open').open( + account, _ = await Account.factory.idempotently('open').open( context, request.account_id, Options(bearer_token=context.caller_bearer_token), @@ -636,7 +636,7 @@ async def test_nested_transaction_that_aborts( else: raise RuntimeError('Expecting to abort!') - account, response = await Account.open( + account, response = await Account.factory.open( context, f'{request.account_id}-parent', initial_deposit=42, @@ -651,7 +651,7 @@ async def test_inherited_ownership_abort( ) -> Empty: # We (the root transaction) first join the account by opening # it. - account, _ = await Account.open( + account, _ = await Account.factory.open( context, request.account_id, initial_deposit=10, @@ -777,7 +777,7 @@ async def test_prepare_wait_for_nested_abort_rollback( ) -> Empty: # Open the remote account with a known balance so that the # nested transaction below shares (rather than constructs) it. - await Account.open( + await Account.factory.open( context, request.remote_account_id, initial_deposit=100, @@ -858,13 +858,13 @@ async def test_nested_transactions( request.type == bank_rbt.TestNestedTransactionsRequest.NESTED_TXN_SAME_STATE ): - await Account.open( + await Account.factory.open( context, 'jonathan-same-state', Options(bearer_token=context.caller_bearer_token), initial_deposit=2, ) - await Account.open( + await Account.factory.open( context, 'ben-same-state', Options(bearer_token=context.caller_bearer_token), @@ -884,13 +884,13 @@ async def test_nested_transactions( request.type == bank_rbt.TestNestedTransactionsRequest.NESTED_TXN_PARENT_WRITER ): - jonathan, _ = await Account.open( + jonathan, _ = await Account.factory.open( context, 'jonathan-parent-writer', Options(bearer_token=context.caller_bearer_token), initial_deposit=2, ) - await Account.open( + await Account.factory.open( context, 'ben-parent-writer', Options(bearer_token=context.caller_bearer_token), @@ -910,13 +910,13 @@ async def test_nested_transactions( request.type == bank_rbt.TestNestedTransactionsRequest. NESTED_TXN_SHARED_WRITE_ABORT ): - await Account.open( + await Account.factory.open( context, 'jonathan-shared-write-abort', Options(bearer_token=context.caller_bearer_token), initial_deposit=1, ) - await Account.open( + await Account.factory.open( context, 'ben-shared-write-abort', Options(bearer_token=context.caller_bearer_token), diff --git a/tests/reboot/bank_main.py b/tests/reboot/bank_main.py index 1d5cb32ae..8cfc1c926 100644 --- a/tests/reboot/bank_main.py +++ b/tests/reboot/bank_main.py @@ -17,7 +17,7 @@ async def initialize(context: InitializeContext): """Create the singleton bank in our application.""" print("🏦🏦🏦 Creating Bank if it hasn't already been created.... 🏦🏦🏦") - await Bank.Create(context, SINGLETON_BANK_ID) + await Bank.factory.Create(context, SINGLETON_BANK_ID) print("💰💰💰 Bank is ready for business! 💰💰💰") diff --git a/tests/reboot/benchmark.py b/tests/reboot/benchmark.py index 409b24c82..e02079441 100644 --- a/tests/reboot/benchmark.py +++ b/tests/reboot/benchmark.py @@ -137,7 +137,7 @@ async def benchmark() -> None: state_ids = [str(state_id) for state_id in range(4096)] await asyncio.gather( *( - General.ConstructorWriter(context, state_id) + General.factory.ConstructorWriter(context, state_id) for state_id in state_ids ) ) diff --git a/tests/reboot/cancellation_tests.py b/tests/reboot/cancellation_tests.py index eb990d7fb..0ffe47cf2 100644 --- a/tests/reboot/cancellation_tests.py +++ b/tests/reboot/cancellation_tests.py @@ -88,7 +88,7 @@ async def ClientStreamingReader( context = self.rbt.create_external_context(name=self.id()) # Construct. - g, _ = await General.ConstructorWriter(context) + g, _ = await General.factory.ConstructorWriter(context) # Start task to Reader to test the unary case. reader_task = asyncio.create_task(g.Reader(context)) diff --git a/tests/reboot/context_tests.py b/tests/reboot/context_tests.py index c521129c4..4f6fcd7d7 100644 --- a/tests/reboot/context_tests.py +++ b/tests/reboot/context_tests.py @@ -45,7 +45,7 @@ async def test_context_not_constructible_in_actor(self) -> None: context = self.rbt.create_external_context(name=self.id()) - greeter, response = await Greeter.Create( + greeter, response = await Greeter.factory.Create( context, title='Dr', name='Jonathan', @@ -88,7 +88,7 @@ def fake_to_grpc_metadata(self): fake_to_grpc_metadata ): with self.assertRaises(Greeter.CreateAborted) as aborted: - await Greeter.Create( + await Greeter.factory.Create( context, title='Dr', name='Jonathan', diff --git a/tests/reboot/documentation/backend/src/servicers/counter.py b/tests/reboot/documentation/backend/src/servicers/counter.py index a83303d4a..5211ad34e 100644 --- a/tests/reboot/documentation/backend/src/servicers/counter.py +++ b/tests/reboot/documentation/backend/src/servicers/counter.py @@ -42,7 +42,7 @@ async def create_counter( request: CreateCounterRequest, ) -> CreateCounterResponse: """Create a new Counter and return its ID.""" - counter, _ = await Counter.create( + counter, _ = await Counter.factory.create( context, description=request.description, owner_id=context.state_id, diff --git a/tests/reboot/documentation/task.py b/tests/reboot/documentation/task.py index e9ed2257a..9fe154a10 100644 --- a/tests/reboot/documentation/task.py +++ b/tests/reboot/documentation/task.py @@ -114,7 +114,7 @@ async def value_is_stored(): async def initialize(context: InitializeContext): - await TestTask.create(context, "task") + await TestTask.factory.create(context, "task") # These tests are different from the other tests in this directory in that do not diff --git a/tests/reboot/documentation/task.ts b/tests/reboot/documentation/task.ts index 3232ce701..956c8ce27 100644 --- a/tests/reboot/documentation/task.ts +++ b/tests/reboot/documentation/task.ts @@ -193,7 +193,9 @@ test("task", async (t) => { await t.test("create", async (t) => { const context = rbt.createExternalContext("test"); - const [task] = await TestTask.idempotently().create(context, "task"); + const [task] = await TestTask.factory + .idempotently() + .create(context, "task"); const { task: { taskId }, diff --git a/tests/reboot/documentation/test_http.py b/tests/reboot/documentation/test_http.py index e8476fea0..56d58a8bd 100644 --- a/tests/reboot/documentation/test_http.py +++ b/tests/reboot/documentation/test_http.py @@ -22,7 +22,7 @@ async def hello_greeter( context: ExternalContext = InjectExternalContext, ): body = await request.json() - greeter, _ = await Greeter.create( + greeter, _ = await Greeter.factory.create( context, title=body['title'], name=body['name'], diff --git a/tests/reboot/documentation/test_http.ts b/tests/reboot/documentation/test_http.ts index b40b594c5..ba8e5db8d 100644 --- a/tests/reboot/documentation/test_http.ts +++ b/tests/reboot/documentation/test_http.ts @@ -57,7 +57,7 @@ test("Tests for Reboot HTTP documentation", async (t) => { name: string; adjective: string; }; - const [greeter] = await Greeter.create(context, { + const [greeter] = await Greeter.factory.create(context, { title, name, adjective, diff --git a/tests/reboot/documentation/transactions.ts b/tests/reboot/documentation/transactions.ts index b934fbd35..534225c58 100644 --- a/tests/reboot/documentation/transactions.ts +++ b/tests/reboot/documentation/transactions.ts @@ -97,9 +97,9 @@ test("transactions", async (t) => { await t.test("transfer", async (t) => { const context = rbt.createExternalContext("test"); - const [bank] = await Bank.create(context, "bank"); - const [fromAccount] = await Account.open(context, "alice"); - const [toAccount] = await Account.open(context, "bob"); + const [bank] = await Bank.factory.create(context, "bank"); + const [fromAccount] = await Account.factory.open(context, "alice"); + const [toAccount] = await Account.factory.open(context, "bob"); await fromAccount.deposit(context, { amount: 100 }); diff --git a/tests/reboot/effect_validation_tests.py b/tests/reboot/effect_validation_tests.py index 85ea00572..06013c62d 100644 --- a/tests/reboot/effect_validation_tests.py +++ b/tests/reboot/effect_validation_tests.py @@ -191,7 +191,7 @@ async def create( self, effect_validation: EffectValidation ) -> tuple[General.WeakReference, ExternalContext]: context = await self.up(effect_validation) - general, _ = await General.ConstructorWriter(context) + general, _ = await General.factory.ConstructorWriter(context) return general, context async def test_disabled(self) -> None: @@ -237,7 +237,7 @@ async def test_constructor_writer(self) -> None: async def test_constructor_transaction(self) -> None: context = await self.up(EffectValidation.ENABLED) - general, _ = await General.ConstructorTransaction(context) + general, _ = await General.factory.ConstructorTransaction(context) self.assert_effects( "constructor_transaction", "constructor_transaction" ) @@ -371,7 +371,7 @@ async def test_at_least_once_per_call_effect_validation_disabled( effect_validation=EffectValidation.ENABLED, ) context = self.rbt.create_external_context(name=self.id()) - general, _ = await General.ConstructorWriter(context) + general, _ = await General.factory.ConstructorWriter(context) await (await general.spawn().Workflow(context)) self.assertEqual(1, _DIRECT_CALLS) @@ -394,7 +394,7 @@ async def test_trusted_servicer_skips_reruns_for_app_developer( with mock.patch.dict(os.environ): os.environ.pop('RBT_VALIDATE_TRUSTED_EFFECTS', None) context = await self.up_trusted(EffectValidation.ENABLED) - await TrustedLibrary.ConstructorWriter(context) + await TrustedLibrary.factory.ConstructorWriter(context) self.assert_effects("ConstructorWriter") @@ -408,7 +408,7 @@ async def test_trusted_servicer_reruns_when_validation_requested( os.environ, {'RBT_VALIDATE_TRUSTED_EFFECTS': 'true'} ): context = await self.up_trusted(EffectValidation.ENABLED) - await TrustedLibrary.ConstructorWriter(context) + await TrustedLibrary.factory.ConstructorWriter(context) self.assert_effects("ConstructorWriter", "ConstructorWriter") diff --git a/tests/reboot/errors_tests.py b/tests/reboot/errors_tests.py index ac9a65fc7..d47c9fd6f 100644 --- a/tests/reboot/errors_tests.py +++ b/tests/reboot/errors_tests.py @@ -28,7 +28,7 @@ async def test_declared_error(self) -> None: context = self.rbt.create_external_context(name=self.id()) - account, _ = await Account.Open(context) + account, _ = await Account.factory.Open(context) await account.Deposit(context, amount=100) @@ -50,7 +50,7 @@ async def test_declared_errors_propagate(self) -> None: context = self.rbt.create_external_context(name=self.id()) - bank, _ = await Bank.Create(context, SINGLETON_BANK_ID) + bank, _ = await Bank.factory.Create(context, SINGLETON_BANK_ID) await bank.SignUp(context, account_id='jonathan', initial_deposit=100) await bank.SignUp(context, account_id='morten') @@ -77,7 +77,7 @@ async def test_undeclared_error(self) -> None: context = self.rbt.create_external_context(name=self.id()) - bank, _ = await Bank.Create(context, SINGLETON_BANK_ID) + bank, _ = await Bank.factory.Create(context, SINGLETON_BANK_ID) await bank.SignUp(context, account_id='jonathan') @@ -99,7 +99,7 @@ async def test_undeclared_errors_propagate(self) -> None: context = self.rbt.create_external_context(name=self.id()) - bank, _ = await Bank.Create(context, SINGLETON_BANK_ID) + bank, _ = await Bank.factory.Create(context, SINGLETON_BANK_ID) with self.assertRaises(Bank.SignUpAborted) as aborted: await bank.SignUp( @@ -123,7 +123,7 @@ async def test_unavailable_errors_propagate(self) -> None: context = self.rbt.create_external_context(name=self.id()) - bank, _ = await Bank.Create(context, SINGLETON_BANK_ID) + bank, _ = await Bank.factory.Create(context, SINGLETON_BANK_ID) await bank.SignUp(context, account_id='jonathan') account = Account.ref('jonathan') @@ -198,7 +198,7 @@ async def test_external_context_mixing_error(self) -> None: name=self.id() + "2" ) - account, _ = await Account.Open(context1) + account, _ = await Account.factory.Open(context1) with self.assertRaises(MixedContextsError) as error: await account.Deposit(context2, amount=200) diff --git a/tests/reboot/external_context_tests.py b/tests/reboot/external_context_tests.py index dccc6e40b..dec1d9f0a 100644 --- a/tests/reboot/external_context_tests.py +++ b/tests/reboot/external_context_tests.py @@ -296,7 +296,7 @@ async def _test_keepalive_and_retry( url=proxied_url, name="test_keepalive_and_retry_unary_reader", ) - general, _ = await General.ConstructorWriter(context) + general, _ = await General.factory.ConstructorWriter(context) call_task: asyncio.Task[None] = asyncio.create_task( make_call(context, general) diff --git a/tests/reboot/idempotency_seeds_tests.py b/tests/reboot/idempotency_seeds_tests.py index cc59f3792..7af18f855 100644 --- a/tests/reboot/idempotency_seeds_tests.py +++ b/tests/reboot/idempotency_seeds_tests.py @@ -187,12 +187,12 @@ def test_idempotently_with_alias_under_same_seed_returns_same_uuid( def test_idempotent_state_id_is_seed_scoped(self) -> None: # `generate_idempotent_state_id` derives a state ID from # `(seed, alias)`, used by constructors like - # `Counter.idempotently("create").create(context)` to pick a - # deterministic ID for the new state. It must fold in the + # `Counter.factory.idempotently("create").create(context)` to + # pick a deterministic ID for the new state. It must fold in the # active idempotency seeds for consistency with # `idempotently()`'s seed-aware idempotency key, otherwise the - # state ID collides across seed scopes while the idempotency - # key differs. + # state ID collides across seed scopes while the idempotency key + # differs. manager = IdempotencyManager(seed=self.SEED) with _merge_idempotency_seeds({"variant": "first"}): state_id_1 = manager.generate_idempotent_state_id( diff --git a/tests/reboot/idempotency_tests.py b/tests/reboot/idempotency_tests.py index e72e82922..bbacb5e36 100644 --- a/tests/reboot/idempotency_tests.py +++ b/tests/reboot/idempotency_tests.py @@ -29,7 +29,7 @@ async def test_exactly_one_idempotency_argument(self) -> None: context = self.rbt.create_external_context(name=self.id()) with self.assertRaises(ValueError) as exc: - await Account.idempotently( + await Account.factory.idempotently( key="key", alias="alias", # type: ignore[call-overload] ).Open(context, "one") @@ -53,7 +53,7 @@ async def _test_writers_are_idempotent( context = self.rbt.create_external_context(name=self.id()) - account, _ = await Account.Open(context) + account, _ = await Account.factory.Open(context) await account.Deposit(context, amount=1000) @@ -108,7 +108,7 @@ async def test_expiring_idempotency_key(self) -> None: context = self.rbt.create_external_context(name=self.id()) - account, _ = await Account.Open(context) + account, _ = await Account.factory.Open(context) await account.Deposit(context, amount=1000) @@ -146,7 +146,7 @@ async def _test_transactions_are_idempotent( context = self.rbt.create_external_context(name=self.id()) - bank, _ = await Bank.Create(context, SINGLETON_BANK_ID) + bank, _ = await Bank.factory.Create(context, SINGLETON_BANK_ID) await bank.idempotently(*args, **kwargs).SignUp( context, @@ -205,7 +205,7 @@ async def test_idempotency_request_violation(self) -> None: context = self.rbt.create_external_context(name=self.id()) - account, _ = await Account.idempotently( + account, _ = await Account.factory.idempotently( 'Open', ).Open(context, 'test-1234') @@ -236,7 +236,7 @@ async def test_idempotency_metadata_violation(self) -> None: context = self.rbt.create_external_context(name=self.id()) - account, _ = await Account.idempotently( + account, _ = await Account.factory.idempotently( 'Open', ).Open( context, @@ -247,7 +247,7 @@ async def test_idempotency_metadata_violation(self) -> None: # Using the same idempotency alias but for different metadata # should fail. with self.assertRaises(ValueError) as error: - await Account.idempotently('Open').Open( + await Account.factory.idempotently('Open').Open( context, 'test-1234', Options(metadata=(('x-reboot-some-key', '41'),)), @@ -267,12 +267,14 @@ async def test_idempotency_generate_violation(self) -> None: context = self.rbt.create_external_context(name=self.id()) - account, _ = await Account.idempotently().Open(context, 'test-1234') + account, _ = await Account.factory.idempotently().Open( + context, 'test-1234' + ) # Doing another call should fail, regardless of if it has # different arguments, metadata, etc. with self.assertRaises(ValueError) as error: - await Account.idempotently().Open( + await Account.factory.idempotently().Open( context, 'test-1234', Options(metadata=(('x-reboot-some-key', '41'),)), @@ -288,7 +290,7 @@ async def test_idempotency_generate_violation(self) -> None: async def test_idempotency_failed_mutation_violation(self) -> None: await self.rbt.up(Application(servicers=[AccountServicer])) context = self.rbt.create_external_context(name=self.id()) - account, _ = await Account.Open(context, "foo") + account, _ = await Account.factory.Open(context, "foo") # A failed mutation that we can't be sure is due to an error # that came from the backend will make this idempotency @@ -327,13 +329,13 @@ async def test_constructors_are_idempotent(self) -> None: # First call: construct the account idempotently. state_id = 'idempotent-constructor-test' - account1, _ = await Account.idempotently( + account1, _ = await Account.factory.idempotently( 'open account', ).Open(context, state_id) # Second call: exact same alias, context, and state ID. This # must succeed (not raise `StateAlreadyConstructed`). - account2, _ = await Account.idempotently( + account2, _ = await Account.factory.idempotently( 'open account', ).Open(context, state_id) @@ -344,7 +346,7 @@ async def test_constructors_are_idempotent(self) -> None: # Verify that calling the constructor *without* idempotency on # the same state ID does raise `StateAlreadyConstructed`. with self.assertRaises(Account.OpenAborted) as aborted: - await Account.Open(context, state_id) + await Account.factory.Open(context, state_id) self.assertEqual( type(aborted.exception.error), StateAlreadyConstructed @@ -364,7 +366,7 @@ async def test_non_constructor_transactions_are_idempotent( context = self.rbt.create_external_context(name=self.id()) - bank, _ = await Bank.Create(context, SINGLETON_BANK_ID) + bank, _ = await Bank.factory.Create(context, SINGLETON_BANK_ID) # First call: sign up the account idempotently. await bank.idempotently('sign up jonathan').SignUp( @@ -394,7 +396,7 @@ async def create_or_assert(*, idempotency_seed: Optional[uuid.UUID]): name='create_or_assert', idempotency_seed=idempotency_seed, ) - account, _ = await Account.idempotently().Open( + account, _ = await Account.factory.idempotently().Open( context, ) nonlocal created_id diff --git a/tests/reboot/invalid_header_tests.py b/tests/reboot/invalid_header_tests.py index 8f2910181..1f73bbfac 100644 --- a/tests/reboot/invalid_header_tests.py +++ b/tests/reboot/invalid_header_tests.py @@ -85,7 +85,7 @@ async def test_invalid_state_ref_type(self) -> None: context = ExternalContext(name='test', url='http://test') # Intentionally create a type error, as might happen when the user # doesn't use mypy. - await Greeter.Create( + await Greeter.factory.Create( context, 123 ) # type: ignore[arg-type, call-overload] self.assertEqual( @@ -113,7 +113,7 @@ async def test_invalid_state_ref_value_non_ascii(self) -> None: # Constructor. with self.assertRaises(InvalidStateRefError) as e: context = ExternalContext(name='test', url='http://test') - await Greeter.Create(context, '😾') + await Greeter.factory.Create(context, '😾') self.assertEqual( str(e.exception), "The 'state_id' option must be an ASCII string; the given value " @@ -137,7 +137,7 @@ async def test_invalid_state_ref_value_too_short(self) -> None: # Constructor. with self.assertRaises(InvalidStateRefError) as e: context = ExternalContext(name='test', url='http://test') - await Greeter.Create(context, '') + await Greeter.factory.Create(context, '') self.assertEqual( str(e.exception), "The 'state_id' option must be at least 1 character(s) long; the " @@ -161,7 +161,7 @@ async def test_invalid_state_ref_value_too_long(self) -> None: # Constructor. with self.assertRaises(InvalidStateRefError) as e: context = ExternalContext(name='test', url='http://test') - await Greeter.Create(context, 'x' * 129) + await Greeter.factory.Create(context, 'x' * 129) self.assertEqual( str(e.exception), "The 'state_id' option must be at most 128 characters long; the " @@ -192,7 +192,7 @@ async def test_invalid_state_ref_value_invalid_char(self) -> None: # Constructor. with self.assertRaises(InvalidStateRefError) as e: context = ExternalContext(name='test', url='http://test') - await Greeter.Create(context, 'hello \x00?') + await Greeter.factory.Create(context, 'hello \x00?') self.assertEqual( str(e.exception), "The 'state_id' option contained illegal characters: ['\\x00']. " @@ -205,7 +205,7 @@ async def test_invalid_bearer_token_type(self) -> None: header serialization, so that the user gets a friendlier stack trace. """ with self.assertRaises(TypeError) as e: - await Greeter.Create( + await Greeter.factory.Create( ExternalContext(name='test', url='http://test'), # Intentionally create a type error, as might happen when the user # doesn't use mypy. @@ -222,7 +222,7 @@ async def test_invalid_bearer_token_value(self) -> None: header serialization, so that the user gets a friendlier stack trace. """ with self.assertRaises(InvalidBearerTokenError) as e: - await Greeter.Create( + await Greeter.factory.Create( ExternalContext(name='test', url='http://test'), None, Options(bearer_token='😾'), @@ -234,7 +234,7 @@ async def test_invalid_bearer_token_value(self) -> None: ) with self.assertRaises(InvalidBearerTokenError) as e: - await Greeter.Create( + await Greeter.factory.Create( ExternalContext(name='test', url='http://test'), None, Options(bearer_token='test\n'), @@ -246,7 +246,7 @@ async def test_invalid_bearer_token_value(self) -> None: ) with self.assertRaises(InvalidBearerTokenError) as e: - await Greeter.Create( + await Greeter.factory.Create( ExternalContext(name='test', url='http://test'), None, Options(bearer_token='x' * 4097), @@ -264,7 +264,7 @@ async def test_invalid_idempotency_key_type(self) -> None: trace. """ with self.assertRaises(TypeError) as e: - await Greeter.idempotently( + await Greeter.factory.idempotently( # Intentionally create a type error, as might happen # when the user doesn't use mypy. key=1337, # type: ignore[call-overload] @@ -283,7 +283,7 @@ async def test_invalid_idempotency_key_value(self) -> None: header serialization, so that the user gets a friendlier stack trace. """ with self.assertRaises(InvalidIdempotencyKeyError) as e: - await Greeter.idempotently( + await Greeter.factory.idempotently( # Intentionally create a type error, as might happen # when the user doesn't use mypy. key='😾' # type: ignore[call-overload] @@ -300,7 +300,7 @@ async def test_invalid_idempotency_key_value(self) -> None: with self.assertRaises(InvalidIdempotencyKeyError) as e: # Intentionally create a type error, as might happen # when the user doesn't use mypy. - await Greeter.idempotently( + await Greeter.factory.idempotently( key='x' * 129, ).Create( # type: ignore[call-overload] ExternalContext(name='test', url='http://test'), diff --git a/tests/reboot/nodejs/app_internal_test/test.ts b/tests/reboot/nodejs/app_internal_test/test.ts index 3ec77e48b..7db9933a5 100644 --- a/tests/reboot/nodejs/app_internal_test/test.ts +++ b/tests/reboot/nodejs/app_internal_test/test.ts @@ -59,7 +59,7 @@ test("app internal", async (t) => { const context = rbt.createExternalContext("test", { appInternal: true }); - await Greeter.create(context, {}); + await Greeter.factory.create(context, {}); }); // Test that without a token verifier the authorizer and method both @@ -69,7 +69,7 @@ test("app internal", async (t) => { const context = rbt.createExternalContext("test", { appInternal: true }); - await Greeter.create(context, {}); + await Greeter.factory.create(context, {}); }); // Test that _with_ a token verifier the authorizer and method both @@ -84,6 +84,6 @@ test("app internal", async (t) => { const context = rbt.createExternalContext("test", { appInternal: true }); - await Greeter.create(context, {}); + await Greeter.factory.create(context, {}); }); }); diff --git a/tests/reboot/nodejs/auth_test/test.ts b/tests/reboot/nodejs/auth_test/test.ts index 356290f60..c3cce4e9a 100644 --- a/tests/reboot/nodejs/auth_test/test.ts +++ b/tests/reboot/nodejs/auth_test/test.ts @@ -114,7 +114,7 @@ test("auth", async (t) => { bearerToken: options?.bearerToken, }); try { - await Greeter.create(context, options?.id); + await Greeter.factory.create(context, options?.id); assert(false, `Should not have successfully authed with ${options}`); } catch (e) { assert(e instanceof Greeter.CreateAborted, "not CreateAborted"); @@ -135,7 +135,7 @@ test("auth", async (t) => { const authedContext = rbt.createExternalContext("test", { bearerToken: TOKEN_FOR_TEST, }); - const [greeter] = await Greeter.create(authedContext); + const [greeter] = await Greeter.factory.create(authedContext); // Confirm that our authorizer does not allow access to any other method // by default, since we have not overridden other methods. @@ -157,7 +157,7 @@ test("auth", async (t) => { await t.test("via construct and lookup", async (t) => { // Test that an authenticated construct succeeds. const context = rbt.createExternalContext("test"); - const [greeter] = await Greeter.create( + const [greeter] = await Greeter.factory.create( context, { title: "Dr", diff --git a/tests/reboot/nodejs/greeter.ts b/tests/reboot/nodejs/greeter.ts index 10d98fcb5..1428a530e 100644 --- a/tests/reboot/nodejs/greeter.ts +++ b/tests/reboot/nodejs/greeter.ts @@ -218,7 +218,7 @@ export class GreeterServicer extends Greeter.Servicer { // iteration via `.perIteration()` by default. // // Create the other `Greeter` once per workflow. - const [other] = await Greeter.create(context, { + const [other] = await Greeter.factory.create(context, { title: "Dr", name: "Evil", adjective: "cunning", diff --git a/tests/reboot/nodejs/greeter_test/test.ts b/tests/reboot/nodejs/greeter_test/test.ts index 9ebc70fe4..538d2cf6b 100644 --- a/tests/reboot/nodejs/greeter_test/test.ts +++ b/tests/reboot/nodejs/greeter_test/test.ts @@ -37,7 +37,7 @@ test("constructors and readers", async (t) => { }); // Test creating with ID. - await Greeter.create(context, "other greeter", { + await Greeter.factory.create(context, "other greeter", { title: "Dr", name: "Jonathan", adjective: "Best", @@ -47,7 +47,7 @@ test("constructors and readers", async (t) => { // // Scoping here for snippet purposes. { - const [greeter, response] = await Greeter.create(context, { + const [greeter, response] = await Greeter.factory.create(context, { title: "Dr", name: "Jonathan", adjective: "Best", @@ -55,19 +55,19 @@ test("constructors and readers", async (t) => { } // Test creating with generated ID idempotently. - await Greeter.idempotently().create(context, { + await Greeter.factory.idempotently().create(context, { title: "Mr", name: "John", adjective: "Dangerous", }); - await Greeter.idempotently("generated").create(context, { + await Greeter.factory.idempotently("generated").create(context, { title: "Mr", name: "John", adjective: "Dangerous", }); - await Greeter.idempotently("create").create( + await Greeter.factory.idempotently("create").create( context, "greeter", // Pass a whole object to test that we can take an object as a request. @@ -79,15 +79,13 @@ test("constructors and readers", async (t) => { ); // Call `idempotently()` with explicit alias to test "alias or options". - const [greeter] = await Greeter.idempotently({ alias: "create" }).create( - context, - "greeter", - { + const [greeter] = await Greeter.factory + .idempotently({ alias: "create" }) + .create(context, "greeter", { title: "Mr", name: "John", adjective: "Dangerous", - } - ); + }); // Pass a partial to test that we can take a partial as a request. let response = await greeter.greet(context, { name: "Jake" }); @@ -191,7 +189,7 @@ test("constructors and readers", async (t) => { idempotencySeed: uuid.v4(), }); - const [greeter] = await Greeter.create(context, { + const [greeter] = await Greeter.factory.create(context, { title: "Dr", name: "Jonathan", adjective: "Best", @@ -233,7 +231,7 @@ test("constructors and readers", async (t) => { const context = rbt.createExternalContext("test"); - const [greeter] = await Greeter.create(context, { + const [greeter] = await Greeter.factory.create(context, { title: "Dr", name: "Jonathan", adjective: "Best", @@ -262,7 +260,7 @@ test("constructors and readers", async (t) => { const context = rbt.createExternalContext("test"); - const [greeter] = await Greeter.create(context, { + const [greeter] = await Greeter.factory.create(context, { title: "Dr", name: "Jonathan", adjective: "Best", @@ -280,13 +278,13 @@ test("constructors and readers", async (t) => { const context = rbt.createExternalContext("test"); // Creating some greeters. - await Greeter.create(context, "greeter-1", { + await Greeter.factory.create(context, "greeter-1", { title: "Mr", name: "Heinz", adjective: "Erhardt", }); - await Greeter.create(context, "greeter-2", { + await Greeter.factory.create(context, "greeter-2", { title: "Mrs", name: "Heidi", adjective: "Kabel", @@ -325,13 +323,13 @@ test("constructors and readers", async (t) => { const context = rbt.createExternalContext("test iterables"); - await Greeter.create(context, "greeter-iter-1", { + await Greeter.factory.create(context, "greeter-iter-1", { title: "Mr", name: "Heinz", adjective: "Erhardt", }); - await Greeter.create(context, "greeter-iter-2", { + await Greeter.factory.create(context, "greeter-iter-2", { title: "Mrs", name: "Heidi", adjective: "Kabel", diff --git a/tests/reboot/nodejs/reboot_down_test/test.ts b/tests/reboot/nodejs/reboot_down_test/test.ts index 66a5f96ad..34b334fd5 100644 --- a/tests/reboot/nodejs/reboot_down_test/test.ts +++ b/tests/reboot/nodejs/reboot_down_test/test.ts @@ -25,7 +25,7 @@ test("Reboot down test", async (t) => { idempotencySeed: uuid.v4(), }); - let [greeter, _] = await Greeter.create(context, { + let [greeter, _] = await Greeter.factory.create(context, { title: "Dr", name: "Jonathan", adjective: "Best", diff --git a/tests/reboot/nodejs/reboot_test/test.ts b/tests/reboot/nodejs/reboot_test/test.ts index 3ebc35d94..825fbb43e 100644 --- a/tests/reboot/nodejs/reboot_test/test.ts +++ b/tests/reboot/nodejs/reboot_test/test.ts @@ -52,7 +52,7 @@ test("Reboot", async (t) => { }); application.http.post("/hello_world", async (context, req, res) => { - const [greeter] = await Greeter.create(context, { + const [greeter] = await Greeter.factory.create(context, { title: "Dr", name: "Jonathan", adjective: "Best", @@ -116,7 +116,7 @@ test("Reboot", async (t) => { const context = rbt.createExternalContext("test"); - const [greeter] = await Greeter.create(context, { + const [greeter] = await Greeter.factory.create(context, { title: "Dr", name: "Jonathan", adjective: "Best", @@ -165,7 +165,7 @@ test("Reboot", async (t) => { const context = rbt.createExternalContext("test"); - const [greeter] = await Greeter.create(context, { + const [greeter] = await Greeter.factory.create(context, { title: "Dr", name: "Jonathan", adjective: "Best", diff --git a/tests/reboot/nodejs/reboot_web_test/test.ts b/tests/reboot/nodejs/reboot_web_test/test.ts index 1f31e0502..31c3eb034 100644 --- a/tests/reboot/nodejs/reboot_web_test/test.ts +++ b/tests/reboot/nodejs/reboot_web_test/test.ts @@ -50,7 +50,7 @@ test("Reboot", async (t) => { url: rbt.url(), }); - const [greeter] = await Greeter.create(context, { + const [greeter] = await Greeter.factory.create(context, { title: "Dr", name: "Jonathan", adjective: "Best", @@ -85,7 +85,7 @@ test("Reboot", async (t) => { bearerToken: TOKEN_FOR_TEST, }); - const [greeter] = await Greeter.create(context, { + const [greeter] = await Greeter.factory.create(context, { title: "Dr", name: "Jonathan", adjective: "Best", @@ -124,7 +124,7 @@ test("Reboot", async (t) => { bearerToken: asyncBearerToken, }); - const [greeter] = await Greeter.create(context, { + const [greeter] = await Greeter.factory.create(context, { title: "Dr", name: "Jonathan", adjective: "Best", @@ -160,7 +160,7 @@ test("Reboot", async (t) => { url: rbt.url(), }); - const [greeter] = await Greeter.create(context, { + const [greeter] = await Greeter.factory.create(context, { title: "Dr", name: "Jonathan", adjective: "Best", @@ -215,7 +215,7 @@ test("Reboot", async (t) => { url: rbt.url(), }); - const [greeter] = await Greeter.create(context, "my-greeter", { + const [greeter] = await Greeter.factory.create(context, "my-greeter", { title: "Dr", name: "Jonathan", adjective: "Best", @@ -265,7 +265,7 @@ test("Reboot", async (t) => { url: rbt.url(), }); - const [greeter] = await Greeter.create(context, { + const [greeter] = await Greeter.factory.create(context, { title: "Dr", name: "Jonathan", adjective: "Best", diff --git a/tests/reboot/nodejs/tasks_test/test.ts b/tests/reboot/nodejs/tasks_test/test.ts index e4524ab1e..696b70199 100644 --- a/tests/reboot/nodejs/tasks_test/test.ts +++ b/tests/reboot/nodejs/tasks_test/test.ts @@ -115,7 +115,7 @@ test("tasks", async (t) => { const context = rbt.createExternalContext("test"); - const [task, _] = await Task.constructorTransaction(context); + const [task, _] = await Task.factory.constructorTransaction(context); // Test that we schedule a writer task and run it immediately. await task.transaction(context); @@ -152,7 +152,7 @@ test("tasks", async (t) => { const context = rbt.createExternalContext("test"); - const [task, _] = await Task.constructorTransaction(context); + const [task, _] = await Task.factory.constructorTransaction(context); // Test that we schedule a transaction task and run it immediately. await task.transaction(context); @@ -189,7 +189,7 @@ test("tasks", async (t) => { const context = rbt.createExternalContext("test"); - const [task, _] = await Task.constructorTransaction(context); + const [task, _] = await Task.factory.constructorTransaction(context); // Test that we schedule a workflow task and run it immediately. await task.transaction(context); diff --git a/tests/reboot/nodejs/yarn_zod_test/backend/src/bank.ts b/tests/reboot/nodejs/yarn_zod_test/backend/src/bank.ts index 869b46884..097d7a300 100644 --- a/tests/reboot/nodejs/yarn_zod_test/backend/src/bank.ts +++ b/tests/reboot/nodejs/yarn_zod_test/backend/src/bank.ts @@ -64,7 +64,7 @@ export const BankServicer = Bank.servicer({ state: Bank.State, { accountId, initialDeposit }: Bank.SignUpRequest ): Promise<[Bank.State]> => { - const [account] = await Account.open(context, accountId, {}); + const [account] = await Account.factory.open(context, accountId, {}); await account.deposit(context, { amount: initialDeposit }); diff --git a/tests/reboot/nodejs/yarn_zod_test/backend/src/main.ts b/tests/reboot/nodejs/yarn_zod_test/backend/src/main.ts index f17905752..4f22272fe 100644 --- a/tests/reboot/nodejs/yarn_zod_test/backend/src/main.ts +++ b/tests/reboot/nodejs/yarn_zod_test/backend/src/main.ts @@ -6,7 +6,7 @@ import { BankServicer } from "./bank.js"; const SINGLETON_BANK_ID = "reboot-bank"; const initialize = async (context) => { - await Bank.create(context, SINGLETON_BANK_ID); + await Bank.factory.create(context, SINGLETON_BANK_ID); }; new Application({ diff --git a/tests/reboot/nodejs/yarn_zod_test/backend/tests/test.ts b/tests/reboot/nodejs/yarn_zod_test/backend/tests/test.ts index aa09f198f..7da4708a6 100644 --- a/tests/reboot/nodejs/yarn_zod_test/backend/tests/test.ts +++ b/tests/reboot/nodejs/yarn_zod_test/backend/tests/test.ts @@ -32,7 +32,7 @@ test("Bank test", async (t) => { // Calling a constructor transaction method, which will call a // writer method from inside the transaction. - const [bank] = await Bank.create(context); + const [bank] = await Bank.factory.create(context); // Calling a common transaction method, which will call a writer // method from inside the transaction. diff --git a/tests/reboot/ping/ping_test.py b/tests/reboot/ping/ping_test.py index 3cdac78a5..d93915b01 100644 --- a/tests/reboot/ping/ping_test.py +++ b/tests/reboot/ping/ping_test.py @@ -68,7 +68,7 @@ async def test_counter(self): app_internal=True, ) - counter, _ = await Counter.create( + counter, _ = await Counter.factory.create( context, description="test counter", owner_id="test-owner" ) diff --git a/tests/reboot/preload_tests.py b/tests/reboot/preload_tests.py index 67ffbf862..f6a7b3ecf 100644 --- a/tests/reboot/preload_tests.py +++ b/tests/reboot/preload_tests.py @@ -27,7 +27,7 @@ async def test_preload_eliminates_load_actor_state_rpc(self) -> None: context = self.rbt.create_external_context(name=self.id()) - bank, _ = await Bank.create(context, SINGLETON_BANK_ID) + bank, _ = await Bank.factory.create(context, SINGLETON_BANK_ID) await bank.sign_up( context, @@ -73,7 +73,7 @@ async def test_preload_eliminates_recover_idempotent_mutations_rpc( context = self.rbt.create_external_context(name=self.id()) - bank, _ = await Bank.create(context, SINGLETON_BANK_ID) + bank, _ = await Bank.factory.create(context, SINGLETON_BANK_ID) await bank.sign_up( context, @@ -126,7 +126,7 @@ async def test_preload_failure_falls_back_to_own_rpcs(self) -> None: context = self.rbt.create_external_context(name=self.id()) - bank, _ = await Bank.create(context, SINGLETON_BANK_ID) + bank, _ = await Bank.factory.create(context, SINGLETON_BANK_ID) await bank.sign_up( context, @@ -176,7 +176,7 @@ async def test_preload_is_noop_when_state_is_cached(self) -> None: context = self.rbt.create_external_context(name=self.id()) - bank, _ = await Bank.create(context, SINGLETON_BANK_ID) + bank, _ = await Bank.factory.create(context, SINGLETON_BANK_ID) await bank.sign_up( context, @@ -219,7 +219,7 @@ async def test_preload_is_noop_when_idempotent_mutations_are_cached( context = self.rbt.create_external_context(name=self.id()) - bank, _ = await Bank.create(context, SINGLETON_BANK_ID) + bank, _ = await Bank.factory.create(context, SINGLETON_BANK_ID) await bank.sign_up( context, diff --git a/tests/reboot/protoc_gen_reboot_tests.py b/tests/reboot/protoc_gen_reboot_tests.py index c1a28ca52..66a356fc1 100644 --- a/tests/reboot/protoc_gen_reboot_tests.py +++ b/tests/reboot/protoc_gen_reboot_tests.py @@ -119,7 +119,8 @@ def test_forbid_http_annotations(self) -> None: # Reboot services don't support (custom) HTTP annotations. # # Modify the descriptor set to form the basis for the test. In this - # case, add an HTTP annotation to the `Greeter.Create()` method. + # case, add an HTTP annotation to the `Greeter.factory.Create()` + # method. file = self.descriptor_set.file[-1] self.assertEqual(file.name, 'tests/reboot/greeter.proto') diff --git a/tests/reboot/pydantic/auto_construct_user/servicer.py b/tests/reboot/pydantic/auto_construct_user/servicer.py index 860be676a..f09830f0f 100644 --- a/tests/reboot/pydantic/auto_construct_user/servicer.py +++ b/tests/reboot/pydantic/auto_construct_user/servicer.py @@ -23,7 +23,7 @@ async def create(self, context: TransactionContext) -> None: `Profile` for this user; a `Transaction` can call other state machines during construction.""" profile_id = f"profile-{context.state_id}" - await Profile.create(context, profile_id) + await Profile.factory.create(context, profile_id) self.state.profile_id = profile_id async def set_claims( diff --git a/tests/reboot/pydantic/auto_construct_user/test.py b/tests/reboot/pydantic/auto_construct_user/test.py index 40666fb37..a0cbac0c4 100644 --- a/tests/reboot/pydantic/auto_construct_user/test.py +++ b/tests/reboot/pydantic/auto_construct_user/test.py @@ -167,8 +167,8 @@ async def test_authenticated_tolerates_preexisting_state(self) -> None: # already-constructed — and still deliver claims — rather # than aborting with `StateAlreadyConstructed`. user_id = "preexisting-user" - await User.idempotently("explicit-construction" - ).create(self.internal, user_id) + await User.factory.idempotently("explicit-construction" + ).create(self.internal, user_id) await UserServicer._authenticated( self.internal, diff --git a/tests/reboot/pydantic/concurrent_transactions_same_state/test.py b/tests/reboot/pydantic/concurrent_transactions_same_state/test.py index 93a3d4774..0d6ed3560 100644 --- a/tests/reboot/pydantic/concurrent_transactions_same_state/test.py +++ b/tests/reboot/pydantic/concurrent_transactions_same_state/test.py @@ -36,7 +36,7 @@ async def asyncSetUp(self) -> None: effect_validation=EffectValidation.DISABLED, ) self.context = self.rbt.create_external_context(name=self.id()) - await Counter.create(self.context, COUNTER_ID) + await Counter.factory.create(self.context, COUNTER_ID) async def asyncTearDown(self) -> None: await self.rbt.stop() @@ -54,7 +54,7 @@ async def test_nested_transactions_on_one_state_are_parallel(self) -> None: driver_ids = [f"driver-{index}" for index in range(CONCURRENCY)] await asyncio.gather( *( - Counter.create(self.context, driver_id) + Counter.factory.create(self.context, driver_id) for driver_id in driver_ids ) ) @@ -92,8 +92,8 @@ async def test_finishing_transaction_keeps_anothers_write(self) -> None: set up, step 3 writes into something nothing else reads, and the increment is lost with no error reported anywhere. """ - await Counter.create(self.context, "writing-driver") - await Counter.create(self.context, "touching-driver") + await Counter.factory.create(self.context, "writing-driver") + await Counter.factory.create(self.context, "touching-driver") parked_increment_is_participant.clear() parked_increment_may_write.clear() diff --git a/tests/reboot/pydantic/discriminated_union/test.py b/tests/reboot/pydantic/discriminated_union/test.py index df37e7c0f..9467a528a 100644 --- a/tests/reboot/pydantic/discriminated_union/test.py +++ b/tests/reboot/pydantic/discriminated_union/test.py @@ -42,7 +42,7 @@ async def test_discriminated_union_variant_a(self) -> None: context = self.rbt.create_external_context(name=self.id()) - test, _ = await DiscriminatedUnionTest.initialize( + test, _ = await DiscriminatedUnionTest.factory.initialize( context, _TEST_STATE_ID, ) @@ -82,7 +82,7 @@ async def test_discriminated_union_variant_b(self) -> None: context = self.rbt.create_external_context(name=self.id()) - test, _ = await DiscriminatedUnionTest.initialize( + test, _ = await DiscriminatedUnionTest.factory.initialize( context, _TEST_STATE_ID, ) @@ -114,7 +114,7 @@ async def test_switch_between_variants(self) -> None: context = self.rbt.create_external_context(name=self.id()) - test, _ = await DiscriminatedUnionTest.initialize( + test, _ = await DiscriminatedUnionTest.factory.initialize( context, _TEST_STATE_ID, ) @@ -175,7 +175,7 @@ async def test_nested_discriminated_union_with_inner_x(self) -> None: context = self.rbt.create_external_context(name=self.id()) - test, _ = await NestedDiscriminatedUnionTest.initialize( + test, _ = await NestedDiscriminatedUnionTest.factory.initialize( context, _TEST_STATE_ID, ) @@ -215,7 +215,7 @@ async def test_nested_discriminated_union_with_inner_y(self) -> None: context = self.rbt.create_external_context(name=self.id()) - test, _ = await NestedDiscriminatedUnionTest.initialize( + test, _ = await NestedDiscriminatedUnionTest.factory.initialize( context, _TEST_STATE_ID, ) @@ -248,7 +248,7 @@ async def test_switch_between_nested_and_simple_variants(self) -> None: context = self.rbt.create_external_context(name=self.id()) - test, _ = await NestedDiscriminatedUnionTest.initialize( + test, _ = await NestedDiscriminatedUnionTest.factory.initialize( context, _TEST_STATE_ID, ) diff --git a/tests/reboot/pydantic/methods/servicer.py b/tests/reboot/pydantic/methods/servicer.py index ad092ce6f..e56c2419c 100644 --- a/tests/reboot/pydantic/methods/servicer.py +++ b/tests/reboot/pydantic/methods/servicer.py @@ -284,7 +284,7 @@ async def workflow( STR_VALUE = "initialized from workflow" STR_VALUE_WITH_STATE_ID = "initialized from workflow with state id" MY_STATE_ID = "my-state-id" - test_ref, _ = await Test.initialize_from_workflow( + test_ref, _ = await Test.factory.initialize_from_workflow( context, str_value=STR_VALUE, ) @@ -292,7 +292,7 @@ async def workflow( assert (test_ref_state.snapshot.current_str == STR_VALUE) assert test_ref.state_id != MY_STATE_ID - test_ref_with_state_id, _ = await Test.initialize_from_workflow( + test_ref_with_state_id, _ = await Test.factory.initialize_from_workflow( context, MY_STATE_ID, str_value=STR_VALUE_WITH_STATE_ID, diff --git a/tests/reboot/pydantic/methods/test.py b/tests/reboot/pydantic/methods/test.py index 815bb0e15..0eea5b771 100644 --- a/tests/reboot/pydantic/methods/test.py +++ b/tests/reboot/pydantic/methods/test.py @@ -42,7 +42,7 @@ async def initialize(context: InitializeContext) -> None: STR_VALUE = "initialized from workflow" STR_VALUE_WITH_STATE_ID = "initialized from workflow with state id" - test_ref, _ = await Test.initialize_from_workflow( + test_ref, _ = await Test.factory.initialize_from_workflow( context, str_value=STR_VALUE, ) @@ -56,7 +56,7 @@ async def initialize(context: InitializeContext) -> None: MY_STATE_ID, ) - test_ref_with_state_id, _ = await Test.initialize_from_workflow( + test_ref_with_state_id, _ = await Test.factory.initialize_from_workflow( context, MY_STATE_ID, str_value=STR_VALUE_WITH_STATE_ID, @@ -83,7 +83,7 @@ async def initialize(context: InitializeContext) -> None: context = self.rbt.create_external_context(name=self.id()) - test, response = await Test.initialize( + test, response = await Test.factory.initialize( context, _TEST_STATE_ID, ) @@ -111,7 +111,7 @@ async def test_writer(self) -> None: context = self.rbt.create_external_context(name=self.id()) - test, _ = await Test.initialize( + test, _ = await Test.factory.initialize( context, _TEST_STATE_ID, ) @@ -186,7 +186,7 @@ async def test_reader(self) -> None: context = self.rbt.create_external_context(name=self.id()) - test, _ = await Test.initialize( + test, _ = await Test.factory.initialize( context, _TEST_STATE_ID, ) @@ -253,14 +253,14 @@ async def test_transaction(self) -> None: context = self.rbt.create_external_context(name=self.id()) - test, _ = await Test.initialize( + test, _ = await Test.factory.initialize( context, _TEST_STATE_ID, ) _SECOND_STATE_ID = f"{_TEST_STATE_ID}_other" - second_test, _ = await Test.initialize( + second_test, _ = await Test.factory.initialize( context, _SECOND_STATE_ID, ) @@ -343,7 +343,7 @@ async def test_workflow(self) -> None: context = self.rbt.create_external_context(name=self.id()) - test, _ = await Test.initialize( + test, _ = await Test.factory.initialize( context, _TEST_STATE_ID, ) @@ -376,7 +376,7 @@ async def test_transaction_ongoing_updates(self) -> None: context = self.rbt.create_external_context(name=self.id()) - test, _ = await Test.initialize( + test, _ = await Test.factory.initialize( context, _TEST_STATE_ID, ) @@ -400,7 +400,7 @@ async def test_raise_value_error(self) -> None: context = self.rbt.create_external_context(name=self.id()) - test, _ = await Test.initialize( + test, _ = await Test.factory.initialize( context, _TEST_STATE_ID, ) @@ -423,7 +423,7 @@ async def test_raise_declared_error(self) -> None: context = self.rbt.create_external_context(name=self.id()) - test, _ = await Test.idempotently('initialize').initialize( + test, _ = await Test.factory.idempotently('initialize').initialize( context, _TEST_STATE_ID, ) @@ -499,7 +499,7 @@ async def test_forall_with_iterables(self) -> None: "test-forall-3", ] for state_id in state_ids_list: - await Test.initialize(context, state_id) + await Test.factory.initialize(context, state_id) # Test `forall` with `dict.keys()`. state_ids_dict = {state_id: None for state_id in state_ids_list} diff --git a/tests/reboot/react/test_200_websockets/test_against_local_envoy.py b/tests/reboot/react/test_200_websockets/test_against_local_envoy.py index 530eb00dd..31d6cd17a 100644 --- a/tests/reboot/react/test_200_websockets/test_against_local_envoy.py +++ b/tests/reboot/react/test_200_websockets/test_against_local_envoy.py @@ -10,7 +10,7 @@ async def initialize(context: InitializeContext): """Create the singleton bank for our test.""" - await Bank.Create(context, SINGLETON_BANK_ID) + await Bank.factory.Create(context, SINGLETON_BANK_ID) if __name__ == '__main__': diff --git a/tests/reboot/react/test_auth/test_against_local_envoy.py b/tests/reboot/react/test_auth/test_against_local_envoy.py index 35d29e795..ddf3f1687 100644 --- a/tests/reboot/react/test_auth/test_against_local_envoy.py +++ b/tests/reboot/react/test_auth/test_against_local_envoy.py @@ -17,7 +17,7 @@ async def initialize(context: InitializeContext): """Create the singleton bank for our test.""" - await Bank.Create(context, SINGLETON_BANK_ID) + await Bank.factory.Create(context, SINGLETON_BANK_ID) if __name__ == '__main__': diff --git a/tests/reboot/react/test_cache/greeter_cache.test.tsx b/tests/reboot/react/test_cache/greeter_cache.test.tsx index 7f2924c80..121f1c7aa 100644 --- a/tests/reboot/react/test_cache/greeter_cache.test.tsx +++ b/tests/reboot/react/test_cache/greeter_cache.test.tsx @@ -35,7 +35,7 @@ describe("Disconnected mode - offline cache enabled", () => { it("creates Greeter and changes adjective", async () => { const context = rbt.createExternalContext("test-context-1"); - await Greeter.create(context, "greeter-test-id-1", { + await Greeter.factory.create(context, "greeter-test-id-1", { title: "Dr", name: "Jonathan", adjective: "Best", @@ -157,7 +157,7 @@ describe("Disconnected mode - offline cache disabled", () => { it("creates Greeter and changes adjectiv", async () => { const context = rbt.createExternalContext("test-context-1"); - await Greeter.create(context, "greeter-test-id-1", { + await Greeter.factory.create(context, "greeter-test-id-1", { title: "Dr", name: "Jonathan", adjective: "Best", diff --git a/tests/reboot/react/test_errors/test_against_local_envoy.py b/tests/reboot/react/test_errors/test_against_local_envoy.py index 3da691dca..c7057d423 100644 --- a/tests/reboot/react/test_errors/test_against_local_envoy.py +++ b/tests/reboot/react/test_errors/test_against_local_envoy.py @@ -10,7 +10,7 @@ async def initialize(context: InitializeContext): """Create the singleton bank for our test.""" - await Bank.Create(context, SINGLETON_BANK_ID) + await Bank.factory.Create(context, SINGLETON_BANK_ID) if __name__ == '__main__': diff --git a/tests/reboot/react/test_http_fallback/test.py b/tests/reboot/react/test_http_fallback/test.py index 960f3a1d4..5bc778b99 100644 --- a/tests/reboot/react/test_http_fallback/test.py +++ b/tests/reboot/react/test_http_fallback/test.py @@ -15,7 +15,7 @@ async def test(context: ExternalContext, uri: str): # Call the constructor for this actor so we have state to # receive when `Greet` is called. - await Greeter.idempotently(f"Create '{state_id}'").Create( + await Greeter.factory.idempotently(f"Create '{state_id}'").Create( context, state_id, title='Count', diff --git a/tests/reboot/react/test_idempotent_writer/test.py b/tests/reboot/react/test_idempotent_writer/test.py index 26b1086f5..e9cf36a0e 100644 --- a/tests/reboot/react/test_idempotent_writer/test.py +++ b/tests/reboot/react/test_idempotent_writer/test.py @@ -14,7 +14,7 @@ async def test(context: ExternalContext, uri: str): # Call the constructor for this actor so we have state to receive # when .Greet is called. - await Greeter.idempotently(f"Create '{state_id}'").Create( + await Greeter.factory.idempotently(f"Create '{state_id}'").Create( context, state_id, title='Count', diff --git a/tests/reboot/react/test_long_running_fetches/test.py b/tests/reboot/react/test_long_running_fetches/test.py index 19c198cfa..8b16b0cb1 100644 --- a/tests/reboot/react/test_long_running_fetches/test.py +++ b/tests/reboot/react/test_long_running_fetches/test.py @@ -24,7 +24,7 @@ async def test(context: ExternalContext, uri: str): # long running fetches. return - await Greeter.idempotently(f"Create '{STATE_ID}'").Create( + await Greeter.factory.idempotently(f"Create '{STATE_ID}'").Create( context, STATE_ID, title='Count', diff --git a/tests/reboot/react/test_mutations/test.py b/tests/reboot/react/test_mutations/test.py index 299d95d85..2b5336c7f 100644 --- a/tests/reboot/react/test_mutations/test.py +++ b/tests/reboot/react/test_mutations/test.py @@ -14,7 +14,7 @@ async def test(context: ExternalContext, uri: str): # Call the constructor for this actor so we have state to receive # when .Greet is called. - await Greeter.idempotently(f"Create '{state_id}'").Create( + await Greeter.factory.idempotently(f"Create '{state_id}'").Create( context, state_id, title='Count', diff --git a/tests/reboot/react/test_reactive_reader_slow_consumer/test.py b/tests/reboot/react/test_reactive_reader_slow_consumer/test.py index 233b7dbac..4abe5f165 100644 --- a/tests/reboot/react/test_reactive_reader_slow_consumer/test.py +++ b/tests/reboot/react/test_reactive_reader_slow_consumer/test.py @@ -21,7 +21,7 @@ async def test(context: ExternalContext, uri: str): """ state_id = 'greeter-slow-consumer-test' - await Greeter.idempotently(f"Create '{state_id}'").Create( + await Greeter.factory.idempotently(f"Create '{state_id}'").Create( context, state_id, title='Count', diff --git a/tests/reboot/react/test_reader/test_against_local_envoy.py b/tests/reboot/react/test_reader/test_against_local_envoy.py index 29a7570c0..e597f09e8 100644 --- a/tests/reboot/react/test_reader/test_against_local_envoy.py +++ b/tests/reboot/react/test_reader/test_against_local_envoy.py @@ -10,7 +10,7 @@ async def initialize(context: InitializeContext): """Create the singleton bank for our test.""" - await Bank.Create(context, SINGLETON_BANK_ID) + await Bank.factory.Create(context, SINGLETON_BANK_ID) if __name__ == '__main__': diff --git a/tests/reboot/react/test_state_id_change/state_id_change.test.tsx b/tests/reboot/react/test_state_id_change/state_id_change.test.tsx index 37d4f3bf5..c6a49a1e6 100644 --- a/tests/reboot/react/test_state_id_change/state_id_change.test.tsx +++ b/tests/reboot/react/test_state_id_change/state_id_change.test.tsx @@ -50,13 +50,13 @@ describe("Reader state-ID change", () => { const context = rbt.createExternalContext("test-state-id-change"); // Create two independent Greeter state instances. - await Greeter.create(context, "greeter-alpha", { + await Greeter.factory.create(context, "greeter-alpha", { title: "Dr", name: "Alpha", adjective: "first", }); - await Greeter.create(context, "greeter-beta", { + await Greeter.factory.create(context, "greeter-beta", { title: "Mr", name: "Beta", adjective: "second", diff --git a/tests/reboot/react/test_suspense/test_against_local_envoy.py b/tests/reboot/react/test_suspense/test_against_local_envoy.py index fadac6480..2f9b4d6ea 100644 --- a/tests/reboot/react/test_suspense/test_against_local_envoy.py +++ b/tests/reboot/react/test_suspense/test_against_local_envoy.py @@ -10,7 +10,7 @@ async def initialize(context: InitializeContext): """Create the singleton bank for our test.""" - await Bank.Create(context, SINGLETON_BANK_ID) + await Bank.factory.Create(context, SINGLETON_BANK_ID) if __name__ == '__main__': diff --git a/tests/reboot/react/test_undeclared_errors/test_against_local_envoy.py b/tests/reboot/react/test_undeclared_errors/test_against_local_envoy.py index a97b5efeb..feffd0b72 100644 --- a/tests/reboot/react/test_undeclared_errors/test_against_local_envoy.py +++ b/tests/reboot/react/test_undeclared_errors/test_against_local_envoy.py @@ -10,7 +10,7 @@ async def initialize(context: InitializeContext): """Create the singleton bank for our test.""" - await Bank.Create(context, SINGLETON_BANK_ID) + await Bank.factory.Create(context, SINGLETON_BANK_ID) if __name__ == '__main__': diff --git a/tests/reboot/react/test_websockets_connection/test_against_local_envoy.py b/tests/reboot/react/test_websockets_connection/test_against_local_envoy.py index 1f3bd9f40..dc3c3c81e 100644 --- a/tests/reboot/react/test_websockets_connection/test_against_local_envoy.py +++ b/tests/reboot/react/test_websockets_connection/test_against_local_envoy.py @@ -10,7 +10,7 @@ async def initialize(context: InitializeContext): """Create the singleton bank for our test.""" - await Bank.Create(context, SINGLETON_BANK_ID) + await Bank.factory.Create(context, SINGLETON_BANK_ID) if __name__ == '__main__': diff --git a/tests/reboot/react/test_writer_abort_with_retrying_reactive_reader/test.py b/tests/reboot/react/test_writer_abort_with_retrying_reactive_reader/test.py index b45dd297c..954cc1843 100644 --- a/tests/reboot/react/test_writer_abort_with_retrying_reactive_reader/test.py +++ b/tests/reboot/react/test_writer_abort_with_retrying_reactive_reader/test.py @@ -35,7 +35,7 @@ async def test(context: ExternalContext, uri: str): state_id = 'actor-test-132' - test, _ = await Test.idempotently(f"Create '{state_id}'").Create( + test, _ = await Test.factory.idempotently(f"Create '{state_id}'").Create( context, state_id, ) diff --git a/tests/reboot/reactivity_test.py b/tests/reboot/reactivity_test.py index 488b1cf11..e2798cbc1 100644 --- a/tests/reboot/reactivity_test.py +++ b/tests/reboot/reactivity_test.py @@ -56,7 +56,7 @@ async def test_reactive_get_all_state(self) -> None: """ await self.rbt.up(Application(servicers=[MyGreeterServicer])) context = self.rbt.create_external_context(name=f"test-{self.id()}") - greeter, _ = await Greeter.Create( + greeter, _ = await Greeter.factory.Create( context, "my-greeter", title="Mr.", diff --git a/tests/reboot/reboot_tests.py b/tests/reboot/reboot_tests.py index 5e41e9c59..c6580d906 100644 --- a/tests/reboot/reboot_tests.py +++ b/tests/reboot/reboot_tests.py @@ -436,7 +436,7 @@ async def test_deep_recursive_message(self) -> None: context = self.rbt.create_external_context(name=self.id()) - greeter, _ = await Greeter.Create( + greeter, _ = await Greeter.factory.Create( context, title='Dr', name='Jonathan', diff --git a/tests/reboot/server/local_envoy_test.py b/tests/reboot/server/local_envoy_test.py index 9837d1fa9..68928b5e4 100644 --- a/tests/reboot/server/local_envoy_test.py +++ b/tests/reboot/server/local_envoy_test.py @@ -240,7 +240,7 @@ async def test_server_filter(self): name='test_server_filter', url=f"https://{endpoint}", ) - await General.ConstructorWriter(context, 'foo') + await General.factory.ConstructorWriter(context, 'foo') seen_ids = set() for i in range(30): response = await General.ref('foo').Reader(context) @@ -251,7 +251,9 @@ async def test_server_filter(self): # across all servers. seen_ids = set() for state_id in string.ascii_lowercase: - _, response = await General.ConstructorWriter(context, state_id) + _, response = await General.factory.ConstructorWriter( + context, state_id + ) server_id = response.content[SERVER_ID_HEADER] seen_ids.add((response.content["id"], server_id)) self.assertEqual( @@ -293,7 +295,9 @@ async def test_server_filter(self): # for such states must route to the same server both via gRPC # calls (which send tagged state refs) and via HTTP calls with # human-readable state refs. - _, response = await General.ConstructorWriter(context, "foo:bar/baz") + _, response = await General.factory.ConstructorWriter( + context, "foo:bar/baz" + ) id_server_pair = ( response.content["id"], response.content[SERVER_ID_HEADER], @@ -387,9 +391,11 @@ async def test_mangled_path_filter(self): for i in range(30): state_id = f"foo-{i}" - general, construct_response = await General.ConstructorWriter( - context, - state_id, + general, construct_response = ( + await General.factory.ConstructorWriter( + context, + state_id, + ) ) # If we make an HTTP request to the designated HTTP RPC endpoint using @@ -490,7 +496,7 @@ async def test_remove_json_trailers_filter(self): ) # Create a state to test with. - await General.ConstructorWriter(context, 'test_state') + await General.factory.ConstructorWriter(context, 'test_state') # Use h2 library to make a low-level HTTP/2 request # that can distinguish between headers and trailers. diff --git a/tests/reboot/std/ciphertext/v1/ciphertext_tests.py b/tests/reboot/std/ciphertext/v1/ciphertext_tests.py index e012fd02c..7014ffe7f 100644 --- a/tests/reboot/std/ciphertext/v1/ciphertext_tests.py +++ b/tests/reboot/std/ciphertext/v1/ciphertext_tests.py @@ -55,7 +55,7 @@ async def _encrypt( scope: str, key_manager_id: str, ) -> str: - ciphertext, _ = await Ciphertext.encrypt( + ciphertext, _ = await Ciphertext.factory.encrypt( self.context, plaintext=plaintext, associated_data=associated_data, diff --git a/tests/reboot/std/collections/sorted_map_tests.py b/tests/reboot/std/collections/sorted_map_tests.py index 613c89bd9..1cb2bd683 100644 --- a/tests/reboot/std/collections/sorted_map_tests.py +++ b/tests/reboot/std/collections/sorted_map_tests.py @@ -518,7 +518,7 @@ async def test_transaction_basic(self) -> None: ) sorted_map, context = self.map() - consumer, _ = await General.ConstructorWriter(context) + consumer, _ = await General.factory.ConstructorWriter(context) expected_entries_before = {"2": b""} expected_entries_after = {"1": b"", "2": b"", "3": b""} @@ -584,7 +584,7 @@ async def test_transaction_abort(self) -> None: ) sorted_map, context = self.map() - consumer, _ = await General.ConstructorWriter(context) + consumer, _ = await General.factory.ConstructorWriter(context) expected_entries_before = {"2": b""} diff --git a/tests/reboot/tasks_tests.py b/tests/reboot/tasks_tests.py index 3c6637790..eef22f9ba 100644 --- a/tests/reboot/tasks_tests.py +++ b/tests/reboot/tasks_tests.py @@ -429,7 +429,7 @@ async def test_ref_schedule_in_transaction(self) -> None: context = self.rbt.create_external_context(name=self.id()) - bank, _ = await Bank.Create(context, SINGLETON_BANK_ID) + bank, _ = await Bank.factory.Create(context, SINGLETON_BANK_ID) response = await bank.SignUp(context, account_id='jonathan') @@ -581,7 +581,7 @@ async def test_alpha_servicer_read_write_in_workflow(self) -> None: context = self.rbt.create_external_context(name=self.id()) - greeter, _ = await Greeter.Create( + greeter, _ = await Greeter.factory.Create( context, title='Dr', name='Jonathan', @@ -667,7 +667,7 @@ async def callable() -> General.State: context = self.rbt.create_external_context(name=self.id()) # Construct. - g, _ = await General.ConstructorWriter(context) + g, _ = await General.factory.ConstructorWriter(context) task = await g.spawn().Workflow(context) @@ -751,7 +751,7 @@ async def workflow( context = self.rbt.create_external_context(name=self.id()) # Construct. - g, _ = await General.ConstructorWriter(context) + g, _ = await General.factory.ConstructorWriter(context) task = await g.spawn().Workflow(context) @@ -800,7 +800,7 @@ async def workflow( context = self.rbt.create_external_context(name=self.id()) # Construct. - g, _ = await General.ConstructorWriter(context) + g, _ = await General.factory.ConstructorWriter(context) # Spawn a workflow with an absolute time that includes the timezone. task = await g.spawn(when=datetime.now(tz=get_localzone()) @@ -887,7 +887,7 @@ async def workflow( context = self.rbt.create_external_context(name=self.id()) # Construct. - g, _ = await General.ConstructorWriter(context) + g, _ = await General.factory.ConstructorWriter(context) # Call Writer that will schedule a workflow with an absolute time that does not include the timezone. await g.Writer(context, content={'timezone_attached': ""}) @@ -982,7 +982,7 @@ async def workflow( context = self.rbt.create_external_context(name=self.id()) # Construct. - g, _ = await General.ConstructorTransaction(context, ID) + g, _ = await General.factory.ConstructorTransaction(context, ID) # Call Transaction that will schedule a workflow with an absolute time that does not include the timezone. await g.Transaction(context, content={'timezone_attached': ""}) @@ -1057,7 +1057,7 @@ async def workflow( context = self.rbt.create_external_context(name=self.id()) # Construct. - g, _ = await General.ConstructorWriter(context) + g, _ = await General.factory.ConstructorWriter(context) # Call Transaction that will schedule a workflow with a timedelta. await g.Transaction(context) @@ -1121,7 +1121,7 @@ async def workflow( context = self.rbt.create_external_context(name=self.id()) # Construct. - g, _ = await General.ConstructorTransaction(context, ID) + g, _ = await General.factory.ConstructorTransaction(context, ID) # Call Transaction that will schedule a workflow with a timedelta. await g.Transaction(context) @@ -1192,7 +1192,7 @@ async def workflow( context = self.rbt.create_external_context(name=self.id()) # Construct. - g, _ = await General.constructor_writer(context) + g, _ = await General.factory.constructor_writer(context) # Run the workflow. await g.workflow(context) @@ -1297,7 +1297,7 @@ async def workflow( context = self.rbt.create_external_context(name=self.id()) # Construct. - g, _ = await General.constructor_writer(context) + g, _ = await General.factory.constructor_writer(context) # Spawn the workflow. task = await g.spawn().workflow(context) @@ -1473,7 +1473,7 @@ async def workflow( context = self.rbt.create_external_context(name=self.id()) # Construct. - g, _ = await General.constructor_writer(context) + g, _ = await General.factory.constructor_writer(context) # Spawn the workflow. task = await g.spawn().workflow(context) @@ -1613,7 +1613,7 @@ async def workflow( context = self.rbt.create_external_context(name=self.id()) # Construct. - g, _ = await General.constructor_writer(context) + g, _ = await General.factory.constructor_writer(context) # Spawn the workflow. task = await g.spawn().workflow(context) @@ -1773,7 +1773,7 @@ async def write(state: General.State) -> str: context = self.rbt.create_external_context(name=self.id()) # Construct. - g, _ = await General.constructor_writer(context) + g, _ = await General.factory.constructor_writer(context) # Spawn the workflow. task = await g.spawn().workflow(context) @@ -1877,7 +1877,7 @@ async def async_on_method(*, retrying: bool) -> None: context = self.rbt.create_external_context(name=self.id()) - g, _ = await General.constructor_writer(context) + g, _ = await General.factory.constructor_writer(context) await g.workflow(context) @@ -1960,7 +1960,7 @@ def on_method(*, retrying: bool) -> None: context = self.rbt.create_external_context(name=self.id()) - g, _ = await General.constructor_writer(context) + g, _ = await General.factory.constructor_writer(context) await g.workflow(context) @@ -2043,7 +2043,7 @@ def on_iteration(*, iteration: int) -> None: context = self.rbt.create_external_context(name=self.id()) - g, _ = await General.constructor_writer(context) + g, _ = await General.factory.constructor_writer(context) await g.workflow(context) @@ -2110,7 +2110,7 @@ def on_method(*, retrying: bool) -> None: context = self.rbt.create_external_context(name=self.id()) - g, _ = await General.constructor_writer(context) + g, _ = await General.factory.constructor_writer(context) await g.workflow(context) diff --git a/tests/reboot/thirdparty/mailgun/tests.py b/tests/reboot/thirdparty/mailgun/tests.py index e51d85adb..0721cdea5 100644 --- a/tests/reboot/thirdparty/mailgun/tests.py +++ b/tests/reboot/thirdparty/mailgun/tests.py @@ -36,7 +36,7 @@ async def test_emailer(self) -> None: bearer_token=MAILGUN_API_KEY, ) - _, send_response = await Message.Send( + _, send_response = await Message.factory.Send( context, recipient="team@reboot.dev", sender="hipsterstore@reboot.dev", @@ -54,7 +54,7 @@ async def test_emailer(self) -> None: self.assertEqual(1, len(MockMessageServicer.emails_sent)) MockMessageServicer.emails_sent.clear() - _, send_response = await Message.Send( + _, send_response = await Message.factory.Send( context, recipient="team@reboot.dev", sender="hipsterstore@reboot.dev", diff --git a/tests/reboot/transaction_tests.py b/tests/reboot/transaction_tests.py index 106875551..0a8178bd5 100644 --- a/tests/reboot/transaction_tests.py +++ b/tests/reboot/transaction_tests.py @@ -124,7 +124,7 @@ async def test_transactions_basic(self) -> None: context = self.rbt.create_external_context(name=self.id()) - bank, _ = await Bank.Create(context, SINGLETON_BANK_ID) + bank, _ = await Bank.factory.Create(context, SINGLETON_BANK_ID) await bank.SignUp( context, @@ -937,7 +937,7 @@ async def test_transactions_after_down(self) -> None: context = self.rbt.create_external_context(name=self.id()) - bank, _ = await Bank.Create(context, SINGLETON_BANK_ID) + bank, _ = await Bank.factory.Create(context, SINGLETON_BANK_ID) await bank.SignUp( context, @@ -1004,7 +1004,7 @@ async def mock_commit(state_manager, request, grpc_context): context = self.rbt.create_external_context(name=self.id()) - bank, _ = await Bank.Create(context, SINGLETON_BANK_ID) + bank, _ = await Bank.factory.Create(context, SINGLETON_BANK_ID) await bank.SignUp(context, account_id='jonathan') @@ -1037,7 +1037,7 @@ async def mock_prepare(state_manager, request, grpc_context): context = self.rbt.create_external_context(name=self.id()) - bank, _ = await Bank.Create(context, SINGLETON_BANK_ID) + bank, _ = await Bank.factory.Create(context, SINGLETON_BANK_ID) with self.assertRaises(Bank.SignUpAborted): await bank.SignUp(context, account_id='jonathan') @@ -1080,7 +1080,7 @@ async def mock_prepare(state_manager, request, grpc_context): context = self.rbt.create_external_context(name=self.id()) - bank, _ = await Bank.Create(context, SINGLETON_BANK_ID) + bank, _ = await Bank.factory.Create(context, SINGLETON_BANK_ID) with self.assertRaises(Bank.SignUpAborted): await bank.SignUp(context, account_id='jonathan') @@ -1214,7 +1214,7 @@ def mock_should_retry(unary_retried_call, error): context = self.rbt.create_external_context(name=self.id()) - bank, _ = await Bank.Create(context, SINGLETON_BANK_ID) + bank, _ = await Bank.factory.Create(context, SINGLETON_BANK_ID) # Confirm that the relevant Bank and Account instances are running # in different servers. Note that this isn't necessarily @@ -1352,7 +1352,7 @@ def mock_should_retry(unary_retried_call, error): context = self.rbt.create_external_context(name=self.id()) - bank, _ = await Bank.Create(context, SINGLETON_BANK_ID) + bank, _ = await Bank.factory.Create(context, SINGLETON_BANK_ID) # Confirm that the relevant Bank and Account instances are running # in different servers. Note that this isn't necessarily @@ -1633,7 +1633,7 @@ def mock_should_retry(unary_retried_call, error): context = self.rbt.create_external_context(name=self.id()) - bank, _ = await Bank.Create(context, SINGLETON_BANK_ID) + bank, _ = await Bank.factory.Create(context, SINGLETON_BANK_ID) # Confirm that `Bank` and `Account` are on different # servers so we can restart just the participant. @@ -1692,7 +1692,7 @@ async def mock_transaction_participant_store( context = self.rbt.create_external_context(name=self.id()) - bank, _ = await Bank.Create(context, SINGLETON_BANK_ID) + bank, _ = await Bank.factory.Create(context, SINGLETON_BANK_ID) await bank.SignUp(context, account_id='jonathan') @@ -1743,7 +1743,7 @@ async def mock_transaction_participant_store( context = self.rbt.create_external_context(name=self.id()) - bank, _ = await Bank.Create(context, SINGLETON_BANK_ID) + bank, _ = await Bank.factory.Create(context, SINGLETON_BANK_ID) await bank.SignUp(context, account_id='jonathan') @@ -1803,7 +1803,7 @@ async def mock_commit(state_manager, request, grpc_context): ) context = self.rbt.create_external_context(name=self.id()) - bank, _ = await Bank.Create(context, SINGLETON_BANK_ID) + bank, _ = await Bank.factory.Create(context, SINGLETON_BANK_ID) # Confirm that the relevant Bank and Account instances are running # in different servers. Note that this isn't necessarily @@ -1937,7 +1937,7 @@ async def mock_commit(state_manager, request, grpc_context): ) context = self.rbt.create_external_context(name=self.id()) - bank, _ = await Bank.Create(context, SINGLETON_BANK_ID) + bank, _ = await Bank.factory.Create(context, SINGLETON_BANK_ID) await bank.SignUp( context, account_id=alice_account_ref.id, initial_deposit=100 ) @@ -2084,7 +2084,7 @@ async def mock_commit(state_manager, request, grpc_context): ) context = self.rbt.create_external_context(name=self.id()) - bank, _ = await Bank.Create(context, SINGLETON_BANK_ID) + bank, _ = await Bank.factory.Create(context, SINGLETON_BANK_ID) # Bank and Account on different servers (the existing # recovery tests rely on this and we want the same @@ -2196,7 +2196,7 @@ async def mock_transaction_coordinator_prepared( ) context = self.rbt.create_external_context(name=self.id()) - bank, _ = await Bank.Create(context, SINGLETON_BANK_ID) + bank, _ = await Bank.factory.Create(context, SINGLETON_BANK_ID) # Confirm that `Bank` and `Account` are on different # servers so we exercise cross-server recovery. @@ -2293,7 +2293,7 @@ async def mock_transaction_participant_prepare( ) context = self.rbt.create_external_context(name=self.id()) - bank, _ = await Bank.Create(context, SINGLETON_BANK_ID) + bank, _ = await Bank.factory.Create(context, SINGLETON_BANK_ID) bank_server_id, account_server_id = await self.rbt.unique_servers( bank._state_ref, @@ -2424,7 +2424,7 @@ def mock_transaction_await(*args, **kwargs): # Create the account using the transactional method `SignUp`. context = self.rbt.create_external_context(name=self.id()) - bank, _ = await Bank.Create(context, SINGLETON_BANK_ID) + bank, _ = await Bank.factory.Create(context, SINGLETON_BANK_ID) await bank.SignUp( context, account_id=account_name, initial_deposit=10 @@ -2498,7 +2498,7 @@ async def mock_SignUp( context = self.rbt.create_external_context(name=self.id()) - bank, _ = await Bank.Create(context, SINGLETON_BANK_ID) + bank, _ = await Bank.factory.Create(context, SINGLETON_BANK_ID) with self.assertRaises(Bank.SignUpAborted) as aborted: await bank.SignUp(context, account_id='jonathan') @@ -2681,7 +2681,7 @@ def check_transactionally( context = self.rbt.create_external_context(name=self.id()) - bank, _ = await Bank.Create(context, SINGLETON_BANK_ID) + bank, _ = await Bank.factory.Create(context, SINGLETON_BANK_ID) bank_initialized = True @@ -2766,7 +2766,7 @@ def check_transactionally( context = self.rbt.create_external_context(name=self.id()) - bank, _ = await Bank.Create(context, SINGLETON_BANK_ID) + bank, _ = await Bank.factory.Create(context, SINGLETON_BANK_ID) await bank.SignUp(context, account_id='jonathan') @@ -2845,7 +2845,7 @@ def check_transactionally( context = self.rbt.create_external_context(name=self.id()) - bank, _ = await Bank.Create(context, SINGLETON_BANK_ID) + bank, _ = await Bank.factory.Create(context, SINGLETON_BANK_ID) with self.assertRaises(Bank.SignUpAborted) as aborted: await bank.SignUp(context, account_id='jonathan') @@ -2865,7 +2865,7 @@ async def test_transaction_aborts_when_catching_undeclared_errors(self): context = self.rbt.create_external_context(name=self.id()) - bank, _ = await Bank.Create(context, SINGLETON_BANK_ID) + bank, _ = await Bank.factory.Create(context, SINGLETON_BANK_ID) await bank.SignUp(context, account_id='jonathan') @@ -2890,7 +2890,7 @@ async def test_nested_catch_undeclared_aborts_root(self): context = self.rbt.create_external_context(name=self.id()) - bank, _ = await Bank.Create(context, SINGLETON_BANK_ID) + bank, _ = await Bank.factory.Create(context, SINGLETON_BANK_ID) await bank.SignUp(context, account_id='jonathan') @@ -2920,7 +2920,7 @@ async def test_nested_read_only_doomed_subtree_aborts_root(self): context = self.rbt.create_external_context(name=self.id()) - bank, _ = await Bank.Create(context, SINGLETON_BANK_ID) + bank, _ = await Bank.factory.Create(context, SINGLETON_BANK_ID) await bank.SignUp(context, account_id='catcher') await bank.SignUp(context, account_id='thrower') @@ -2949,7 +2949,7 @@ async def test_calls_within_transactions_raise_after_catching_abort(self): context = self.rbt.create_external_context(name=self.id()) - bank, _ = await Bank.Create(context, SINGLETON_BANK_ID) + bank, _ = await Bank.factory.Create(context, SINGLETON_BANK_ID) await bank.SignUp(context, account_id='jonathan') @@ -2976,7 +2976,7 @@ async def test_transaction_retried_when_catching_unavailable(self): context = self.rbt.create_external_context(name=self.id()) - bank, _ = await Bank.Create(context, SINGLETON_BANK_ID) + bank, _ = await Bank.factory.Create(context, SINGLETON_BANK_ID) await bank.SignUp(context, account_id='jonathan') @@ -2998,7 +2998,7 @@ async def test_transaction_not_aborts_when_catching_declared_errors(self): context = self.rbt.create_external_context(name=self.id()) - bank, _ = await Bank.Create(context, SINGLETON_BANK_ID) + bank, _ = await Bank.factory.Create(context, SINGLETON_BANK_ID) await bank.SignUp(context, account_id='jonathan') @@ -3064,7 +3064,7 @@ async def test_nested_transaction_aborts_even_if_parent_does_not(self): context = self.rbt.create_external_context(name=self.id()) - bank, _ = await Bank.Create(context, SINGLETON_BANK_ID) + bank, _ = await Bank.factory.Create(context, SINGLETON_BANK_ID) await bank.SignUp(context, account_id='jonathan', initial_deposit=7) @@ -3108,7 +3108,7 @@ async def test_inherited_ownership_abort(self): context = self.rbt.create_external_context(name=self.id()) - bank, _ = await Bank.Create(context, SINGLETON_BANK_ID) + bank, _ = await Bank.factory.Create(context, SINGLETON_BANK_ID) # Opens 'inherited' (balance 10), then via a nested transaction # that does NOT touch 'inherited' calls a deeper nested @@ -3176,7 +3176,7 @@ async def mock_acquire_exclusive(lock, *args, **kwargs): context = self.rbt.create_external_context(name=self.id()) - bank, _ = await Bank.Create(context, SINGLETON_BANK_ID) + bank, _ = await Bank.factory.Create(context, SINGLETON_BANK_ID) await bank.SignUp( context, account_id='retainacct', initial_deposit=10 @@ -3284,7 +3284,7 @@ async def mock_wait_ownership(transaction, condition, *args, **kwargs): context = self.rbt.create_external_context(name=self.id()) - bank, _ = await Bank.Create(context, SINGLETON_BANK_ID) + bank, _ = await Bank.factory.Create(context, SINGLETON_BANK_ID) root_task = asyncio.create_task( bank.TestPrepareWaitForNestedAbortRollback( @@ -3390,7 +3390,7 @@ async def test_constructor_after_abort_from_unconstructed(self): type(aborted.exception.error), errors_pb2.StateNotConstructed ) - await Bank.Create(context, SINGLETON_BANK_ID) + await Bank.factory.Create(context, SINGLETON_BANK_ID) async def test_transactional_constructor(self): """Tests that we can call a transactional constructor, and that aborting @@ -3429,7 +3429,9 @@ async def Reader( context = self.rbt.create_external_context(name=self.id()) # Successfully create, and confirm that we can see the state. - item1, _ = await General.ConstructorTransaction(context, "item1") + item1, _ = await General.factory.ConstructorTransaction( + context, "item1" + ) self.assertEqual( {"yep": "it ran"}, dict((await item1.Reader(context)).content) ) @@ -3438,7 +3440,7 @@ async def Reader( with self.assertRaises( General.ConstructorTransactionAborted ) as ct_aborted: - await General.ConstructorTransaction( + await General.factory.ConstructorTransaction( context, "item2", content={"abort": "True"}, @@ -3485,7 +3487,7 @@ async def Reader( ) context = self.rbt.create_external_context(name=self.id()) - item, _ = await General.ConstructorTransaction(context, "item") + item, _ = await General.factory.ConstructorTransaction(context, "item") # The actor must be constructed: reading it must succeed rather # than abort with `StateNotConstructed`. @@ -3501,7 +3503,7 @@ async def test_nested_transactions(self): context = self.rbt.create_external_context(name=self.id()) - bank, _ = await Bank.Create(context, SINGLETON_BANK_ID) + bank, _ = await Bank.factory.Create(context, SINGLETON_BANK_ID) # A nested transaction (`Bank.Transfer`) on the same `Bank` # state as the parent transaction, also modifying accounts @@ -3634,7 +3636,7 @@ async def Transaction( entries={"bar": b"bar"}, ) - general, _ = await General.ConstructorWriter(context) + general, _ = await General.factory.ConstructorWriter(context) # We first call `General.Transaction` for a nonexistent key, which # will cause its `SortedMap.Get` call to fail, and therefore cause the @@ -3680,7 +3682,7 @@ async def test_successful_transaction_no_trailing_metadata(self) -> None: # Create a bank and an account to test with. context = self.rbt.create_external_context(name=self.id()) - bank, _ = await Bank.Create(context, SINGLETON_BANK_ID) + bank, _ = await Bank.factory.Create(context, SINGLETON_BANK_ID) await bank.SignUp(context, account_id='test-account') # Now use raw gRPC to call a transaction method, so we can check @@ -3726,7 +3728,7 @@ async def test_failing_transaction_no_trailing_metadata(self) -> None: # Create a bank to test with. context = self.rbt.create_external_context(name=self.id()) - bank, _ = await Bank.Create(context, SINGLETON_BANK_ID) + bank, _ = await Bank.factory.Create(context, SINGLETON_BANK_ID) # Now use raw gRPC to call a transaction method that will fail, # so we can check the trailing metadata. diff --git a/tests/reboot/zod/concurrent_transactions_same_state/test.ts b/tests/reboot/zod/concurrent_transactions_same_state/test.ts index ee77c988d..95606fee6 100644 --- a/tests/reboot/zod/concurrent_transactions_same_state/test.ts +++ b/tests/reboot/zod/concurrent_transactions_same_state/test.ts @@ -25,7 +25,7 @@ const setUp = async () => { const context = rbt.createExternalContext("test"); - await Counter.create(context, COUNTER_ID, {}); + await Counter.factory.create(context, COUNTER_ID, {}); return { rbt, context }; }; @@ -51,7 +51,7 @@ test("Concurrent transactions on one state", async (t) => { (_, index) => `driver-${index}` ); await Promise.all( - driverIds.map((driverId) => Counter.create(context, driverId, {})) + driverIds.map((driverId) => Counter.factory.create(context, driverId, {})) ); rendezvous.reset(CONCURRENCY); @@ -90,8 +90,8 @@ test("Concurrent transactions on one state", async (t) => { await rbt.stop(); }); - await Counter.create(context, "writing-driver", {}); - await Counter.create(context, "touching-driver", {}); + await Counter.factory.create(context, "writing-driver", {}); + await Counter.factory.create(context, "touching-driver", {}); parkedIncrementIsParticipant.reset(); parkedIncrementMayWrite.reset(); diff --git a/tests/reboot/zod/methods/test.ts b/tests/reboot/zod/methods/test.ts index 3c2bc75b8..f247dc85b 100644 --- a/tests/reboot/zod/methods/test.ts +++ b/tests/reboot/zod/methods/test.ts @@ -17,7 +17,7 @@ test("Test Zod Service", async (t) => { const context = rbt.createExternalContext("test"); - const [test] = await Test.construct(context, {}); + const [test] = await Test.factory.construct(context, {}); await test.writer(context, { data: "initialize", From bf5ac451ab66406afd83ab992545a23ac7e922bd Mon Sep 17 00:00:00 2001 From: Robert-Jan Huijsman <22160949+rjhuijsman@users.noreply.github.com> Date: Tue, 15 Sep 2026 10:49:14 +0000 Subject: [PATCH 4/5] Codegen: make `factory` a function, `MyType.factory().create(...)` Before this change, the `factory` namespace was a class attribute (`factory = _Factory` in Python, `static factory = MyTypeFactory` in TypeScript), so its shape was fixed forever: we could never do more than hand back the class. Making it a function keeps the option open to grow it later (say, by returning an instance that carries per-call state) without another migration of every caller. For now `factory()` still returns the `_Factory` class, so the only change for callers is the parentheses: `MyType.factory.create(...)` becomes `MyType.factory().create(...)`, in Python, TypeScript and the web client alike. - Templates: `reboot.py.j2`, `reboot.ts.j2`, `reboot_web.ts.j2`. - Every caller, the docs and their snippets, the agent skill references, and the migration fragment follow. - Goldens regenerated. Co-Authored-By: Claude Opus 5 (1M context) Claude-Session: https://claude.ai/code/session_01BAd3bRycJhQHPAmoCHBdgJ --- documentation/docs/call/overview.mdx | 12 +-- documentation/docs/idempotency.mdx | 2 +- documentation/docs/implement/application.mdx | 4 +- .../docs/library_services/ciphertext.mdx | 8 +- .../docs/library_services/mailgun.md | 6 +- documentation/docs/users/external_apis.mdx | 2 +- documentation/docs/users/tokens.mdx | 4 +- rbt/thirdparty/mailgun/v1/mailgun.proto | 2 +- reboot/cli/commands/cloud/up.py | 2 +- reboot/demos/fig/backend/src/main.ts | 4 +- reboot/demos/fig/backend/src/user_servicer.ts | 2 +- .../agent-wiki/backend/src/servicers/wiki.py | 6 +- .../bank-nodejs/backend/src/bank_servicer.ts | 2 +- .../bank-nodejs/backend/tests/test.ts | 2 +- .../backend/src/bank_servicer.py | 2 +- .../backend/src/customer_servicer.py | 2 +- .../bank-pydantic/backend/src/main.py | 2 +- reboot/examples/bank-zod/backend/src/bank.ts | 2 +- .../examples/bank-zod/backend/src/customer.ts | 2 +- reboot/examples/bank-zod/backend/src/main.ts | 2 +- .../examples/bank-zod/backend/tests/test.ts | 6 +- reboot/examples/bank/backend/src/main.py | 6 +- .../boutique/backend/src/checkout/servicer.py | 2 +- reboot/examples/boutique/backend/src/main.py | 4 +- .../chick-potle/backend/src/servicers/food.py | 2 +- reboot/examples/docubot/backend/src/main.ts | 2 +- reboot/examples/kcdc-2025/backend/src/main.py | 4 +- .../backend/src/servicers/channel.py | 2 +- .../backend/src/servicers/chatbot.py | 2 +- .../kcdc-2025/backend/src/servicers/user.py | 4 +- .../backend/src/servicers/counter.py | 2 +- .../backend/src/servicers/counter.py | 2 +- .../bank/backend/src/bank_servicer.py | 2 +- .../hello-constructors/backend/src/main.py | 2 +- .../reboot-swag-store/backend/src/main.py | 2 +- .../backend/src/servicers/store.py | 4 +- reboot/ping/ping.py | 2 +- reboot/plugin/skills/mcp-ui/SKILL.md | 8 +- .../skills/mcp-ui/references/gotchas.md | 2 +- .../mcp-ui/references/servicer-patterns.md | 14 ++-- reboot/plugin/skills/python/SKILL.md | 4 +- .../skills/python/references/_sections.md | 2 +- .../skills/python/references/api-pydantic.md | 4 +- .../references/auth-external-api-calls.md | 4 +- .../references/lifecycle-initialize-hook.md | 18 ++--- .../references/patterns-common-gotchas.md | 8 +- .../python/references/patterns-idempotency.md | 6 +- .../skills/python/references/rpc-calls.md | 2 +- .../references/rpc-constructor-calls.md | 30 +++---- .../python/references/servicer-constructor.md | 14 ++-- .../python/references/servicer-transaction.md | 8 +- .../references/state-actor-decomposition.md | 4 +- .../python/references/state-collections.md | 2 +- .../python/references/state-scalar-fields.md | 2 +- .../python/references/stdlib-ciphertext.md | 16 ++-- .../python/references/stdlib-presence.md | 2 +- .../python/references/testing-harness.md | 2 +- .../next/factory-namespaced-constructors.md | 18 ++--- reboot/plugin/skills/web-app/SKILL.md | 2 +- reboot/std/oauth/v1/oauth.py | 2 +- reboot/templates/reboot.py.j2 | 8 +- reboot/templates/reboot.ts.j2 | 20 ++--- reboot/templates/reboot_web.ts.j2 | 4 +- .../reboot/agents/pydantic_ai/agent_tests.py | 2 +- .../aio/internals/tasks_servicer_tests.py | 4 +- tests/reboot/auth_bank_main.py | 2 +- tests/reboot/auth_tests.py | 6 +- tests/reboot/bank.py | 24 +++--- tests/reboot/bank_main.py | 2 +- tests/reboot/benchmark.py | 2 +- tests/reboot/cancellation_tests.py | 2 +- tests/reboot/context_tests.py | 4 +- .../backend/src/servicers/counter.py | 2 +- tests/reboot/documentation/task.py | 2 +- tests/reboot/documentation/task.ts | 2 +- tests/reboot/documentation/test_http.py | 2 +- tests/reboot/documentation/test_http.ts | 2 +- tests/reboot/documentation/transactions.ts | 6 +- tests/reboot/echo_rbt.golden.py | 4 +- tests/reboot/effect_validation_tests.py | 10 +-- tests/reboot/errors_tests.py | 12 +-- tests/reboot/external_context_tests.py | 2 +- tests/reboot/greeter_rbt.golden.js | 22 +++--- tests/reboot/greeter_rbt.golden.py | 6 +- tests/reboot/greeter_rbt_web.golden.js | 4 +- tests/reboot/idempotency_seeds_tests.py | 2 +- tests/reboot/idempotency_tests.py | 30 +++---- tests/reboot/invalid_header_tests.py | 24 +++--- tests/reboot/nodejs/app_internal_test/test.ts | 6 +- tests/reboot/nodejs/auth_test/test.ts | 6 +- tests/reboot/nodejs/greeter.ts | 2 +- tests/reboot/nodejs/greeter_test/test.ts | 46 +++++------ tests/reboot/nodejs/reboot_down_test/test.ts | 2 +- tests/reboot/nodejs/reboot_test/test.ts | 6 +- tests/reboot/nodejs/reboot_web_test/test.ts | 12 +-- tests/reboot/nodejs/tasks_test/test.ts | 6 +- .../nodejs/yarn_zod_test/backend/src/bank.ts | 2 +- .../nodejs/yarn_zod_test/backend/src/main.ts | 2 +- .../yarn_zod_test/backend/tests/test.ts | 2 +- tests/reboot/ping/ping_test.py | 2 +- tests/reboot/ping_api_rbt.golden.py | 22 ++++-- tests/reboot/preload_tests.py | 10 +-- tests/reboot/protoc_gen_reboot_tests.py | 2 +- .../pydantic/auto_construct_user/servicer.py | 2 +- .../pydantic/auto_construct_user/test.py | 4 +- .../test.py | 8 +- .../pydantic/discriminated_union/test.py | 12 +-- tests/reboot/pydantic/methods/servicer.py | 12 +-- tests/reboot/pydantic/methods/test.py | 32 ++++---- .../test_against_local_envoy.py | 2 +- .../test_auth/test_against_local_envoy.py | 2 +- .../react/test_cache/greeter_cache.test.tsx | 4 +- .../test_errors/test_against_local_envoy.py | 2 +- tests/reboot/react/test_http_fallback/test.py | 2 +- .../react/test_idempotent_writer/test.py | 2 +- .../react/test_long_running_fetches/test.py | 2 +- tests/reboot/react/test_mutations/test.py | 2 +- .../test.py | 2 +- .../test_reader/test_against_local_envoy.py | 2 +- .../state_id_change.test.tsx | 4 +- .../test_suspense/test_against_local_envoy.py | 2 +- .../test_against_local_envoy.py | 2 +- .../test_against_local_envoy.py | 2 +- .../test.py | 2 +- tests/reboot/reactivity_test.py | 2 +- tests/reboot/reboot_tests.py | 2 +- tests/reboot/server/local_envoy_test.py | 10 +-- .../std/ciphertext/v1/ciphertext_tests.py | 2 +- .../std/collections/sorted_map_tests.py | 4 +- tests/reboot/tasks_tests.py | 36 ++++----- tests/reboot/thirdparty/mailgun/tests.py | 4 +- tests/reboot/transaction_tests.py | 78 ++++++++++--------- .../test.ts | 10 ++- tests/reboot/zod/methods/test.ts | 2 +- 134 files changed, 460 insertions(+), 428 deletions(-) diff --git a/documentation/docs/call/overview.mdx b/documentation/docs/call/overview.mdx index 803195ed0..078c00216 100644 --- a/documentation/docs/call/overview.mdx +++ b/documentation/docs/call/overview.mdx @@ -196,7 +196,7 @@ example: ```python -account, response = await Account.factory.open( +account, response = await Account.factory().open( context, customer_name=request.customer_name, ) @@ -205,7 +205,7 @@ account, response = await Account.factory.open( ```typescript -const [account, response] = await Account.factory.open(context, { +const [account, response] = await Account.factory().open(context, { customerName: request.customerName, }); ``` @@ -235,7 +235,7 @@ an example of constructing an `Account` with an explicit ID using the ```python -account, _ = await Account.factory.open( +account, _ = await Account.factory().open( context, new_account_id, customer_name=request.customer_name, @@ -249,7 +249,7 @@ account, _ = await Account.factory.open( ```typescript -const [account, response] = await Account.factory.open( +const [account, response] = await Account.factory().open( context, newAccountId, { @@ -273,7 +273,7 @@ application (i.e., using an ```python -account, response = await Account.factory.idempotently().open( +account, response = await Account.factory().idempotently().open( context, customer_name=request.customer_name, ) @@ -282,7 +282,7 @@ account, response = await Account.factory.idempotently().open( ```typescript -const [account, response] = await Account.factory.idempotently().open(context, { +const [account, response] = await Account.factory().idempotently().open(context, { customerName: request.customerName, }); ``` diff --git a/documentation/docs/idempotency.mdx b/documentation/docs/idempotency.mdx index 0572bde34..eb020afa1 100644 --- a/documentation/docs/idempotency.mdx +++ b/documentation/docs/idempotency.mdx @@ -42,7 +42,7 @@ await bank.idempotently('sign up jonathan').SignUp( ```ts -await Greeter.factory.idempotently("generated").create(context, { +await Greeter.factory().idempotently("generated").create(context, { title: "Mr", name: "John", adjective: "Dangerous", diff --git a/documentation/docs/implement/application.mdx b/documentation/docs/implement/application.mdx index aa62257bf..f775adb4a 100644 --- a/documentation/docs/implement/application.mdx +++ b/documentation/docs/implement/application.mdx @@ -237,7 +237,7 @@ async def hello_greeter( context: ExternalContext = InjectExternalContext, ): body = await request.json() - greeter, _ = await Greeter.factory.create( + greeter, _ = await Greeter.factory().create( context, title=body['title'], name=body['name'], @@ -266,7 +266,7 @@ application.http.post("/hello_greeter", async (context, req, res) => { name: string; adjective: string; }; - const [greeter] = await Greeter.factory.create(context, { + const [greeter] = await Greeter.factory().create(context, { title, name, adjective, diff --git a/documentation/docs/library_services/ciphertext.mdx b/documentation/docs/library_services/ciphertext.mdx index 05487fb2e..7c562b1d9 100644 --- a/documentation/docs/library_services/ciphertext.mdx +++ b/documentation/docs/library_services/ciphertext.mdx @@ -112,7 +112,7 @@ from reboot.std.ciphertext.v1.ciphertext import APP_SHARED_KEY_MANAGER_ID from uuid import uuid4 ciphertext_id = str(uuid4()) -ciphertext, _ = await Ciphertext.factory.encrypt( +ciphertext, _ = await Ciphertext.factory().encrypt( context, ciphertext_id, plaintext=b"123-45-6789", @@ -132,7 +132,7 @@ import { } from "@reboot-dev/reboot-std/ciphertext/v1"; const ciphertextId = crypto.randomUUID(); -const [ciphertext] = await Ciphertext.factory.encrypt(context, ciphertextId, { +const [ciphertext] = await Ciphertext.factory().encrypt(context, ciphertextId, { plaintext: new TextEncoder().encode("123-45-6789"), associatedData: makeAssociatedData({ user_id: "42", purpose: "ssn" }), scope: "user_id:42", @@ -199,7 +199,7 @@ other's ciphertexts (`shred` operates per manager). ```py # Encrypt under a named manager. -await Ciphertext.factory.encrypt( +await Ciphertext.factory().encrypt( context, ciphertext_id, plaintext=b"123-45-6789", @@ -217,7 +217,7 @@ await KeyManager.ref("tenant:acme").shred(context, scope="user_id:42") ```ts // Encrypt under a named manager. -await Ciphertext.factory.encrypt(context, ciphertextId, { +await Ciphertext.factory().encrypt(context, ciphertextId, { plaintext: new TextEncoder().encode("123-45-6789"), associatedData: makeAssociatedData({ user_id: "42", purpose: "ssn" }), scope: "user_id:42", diff --git a/documentation/docs/library_services/mailgun.md b/documentation/docs/library_services/mailgun.md index fc96cbf06..26a3fb8c2 100644 --- a/documentation/docs/library_services/mailgun.md +++ b/documentation/docs/library_services/mailgun.md @@ -28,12 +28,12 @@ Calls to the integration must also authenticate using that same API key as the bearer token: the integration only accepts calls whose bearer token matches `MAILGUN_API_KEY`, and rejects all other calls as unauthenticated. Pass the key using `Options` when calling -`Message.factory.send`: +`Message.factory().send`: ```python from reboot.aio.call import Options -await Message.factory.send( +await Message.factory().send( context, Options(bearer_token=mailgun_api_key), recipient="alice@example.com", @@ -47,7 +47,7 @@ await Message.factory.send( ## Message {#rbtthirdpartymailgunv1message} A single message sent using the integration. -Created and scheduled using its constructor: `await Message.factory.send(...)`. +Created and scheduled using its constructor: `await Message.factory().send(...)`. ### Send diff --git a/documentation/docs/users/external_apis.mdx b/documentation/docs/users/external_apis.mdx index 193d5efe6..b6a122e50 100644 --- a/documentation/docs/users/external_apis.mdx +++ b/documentation/docs/users/external_apis.mdx @@ -170,7 +170,7 @@ returned `Ciphertext` state ID — itself a harmless string — in your state as the reference to the encrypted value: ```py -ciphertext, _ = await Ciphertext.factory.encrypt( +ciphertext, _ = await Ciphertext.factory().encrypt( context, plaintext=request.api_key.encode(), associated_data=make_associated_data( diff --git a/documentation/docs/users/tokens.mdx b/documentation/docs/users/tokens.mdx index 7d9b4057f..71c4d4dd8 100644 --- a/documentation/docs/users/tokens.mdx +++ b/documentation/docs/users/tokens.mdx @@ -47,7 +47,7 @@ You can also pass it as an option when doing ```py -bank, _ = await Bank.factory.create( +bank, _ = await Bank.factory().create( context, SINGLETON_BANK_ID, Options(bearer_token=VALID_JWT), @@ -59,7 +59,7 @@ bank, _ = await Bank.factory.create( ```ts -const [bank] = await Bank.factory.create( +const [bank] = await Bank.factory().create( context, SINGLETON_BANK_ID, {}, diff --git a/rbt/thirdparty/mailgun/v1/mailgun.proto b/rbt/thirdparty/mailgun/v1/mailgun.proto index 4004768a0..5b6fd1f88 100644 --- a/rbt/thirdparty/mailgun/v1/mailgun.proto +++ b/rbt/thirdparty/mailgun/v1/mailgun.proto @@ -20,7 +20,7 @@ import "google/protobuf/timestamp.proto"; * A single message sent using the integration. * * Created and scheduled using its constructor: - * `await Message.factory.Send(...)`. + * `await Message.factory().Send(...)`. */ service MessageMethods { /** diff --git a/reboot/cli/commands/cloud/up.py b/reboot/cli/commands/cloud/up.py index 3c3dc8cf8..5adcad171 100644 --- a/reboot/cli/commands/cloud/up.py +++ b/reboot/cli/commands/cloud/up.py @@ -87,7 +87,7 @@ async def _maybe_create_application( bearer_token=api_key, ) try: - await Application.factory.Create(context, qualified_application_name) + await Application.factory().Create(context, qualified_application_name) except Aborted as aborted: match aborted.error: case StateAlreadyConstructed(): # type: ignore[misc] diff --git a/reboot/demos/fig/backend/src/main.ts b/reboot/demos/fig/backend/src/main.ts index 33f18b9df..a11259324 100644 --- a/reboot/demos/fig/backend/src/main.ts +++ b/reboot/demos/fig/backend/src/main.ts @@ -7,9 +7,9 @@ import { FigBoardServicer, FigServicer } from "./fig_servicer.js"; import { UserServicer, UsersServicer } from "./user_servicer.js"; const initialize = async (context) => { - await FigBoard.factory.create(context, FIG_BOARD_ID); + await FigBoard.factory().create(context, FIG_BOARD_ID); - await Users.factory.create(context, USERS_ID); + await Users.factory().create(context, USERS_ID); }; new Application({ diff --git a/reboot/demos/fig/backend/src/user_servicer.ts b/reboot/demos/fig/backend/src/user_servicer.ts index cd898af6f..4c8a0326c 100644 --- a/reboot/demos/fig/backend/src/user_servicer.ts +++ b/reboot/demos/fig/backend/src/user_servicer.ts @@ -52,7 +52,7 @@ export class UsersServicer extends Users.Servicer { this.state.userIds.push(request.userId); - await User.factory.create(context, request.userId); + await User.factory().create(context, request.userId); return {}; } diff --git a/reboot/examples/agent-wiki/backend/src/servicers/wiki.py b/reboot/examples/agent-wiki/backend/src/servicers/wiki.py index 30e7582f0..39ea7fc40 100644 --- a/reboot/examples/agent-wiki/backend/src/servicers/wiki.py +++ b/reboot/examples/agent-wiki/backend/src/servicers/wiki.py @@ -264,7 +264,7 @@ async def create_page( content. Returns the new page's state ID, which you should link to from the wiki's markdown as `Page:`.""" - page, _ = await Page.factory.create( + page, _ = await Page.factory().create( context, title=title, content=content, @@ -288,7 +288,7 @@ async def create_wiki( context.auth.user_id if context.auth is not None and context.auth.user_id is not None else "" ) - wiki, _ = await Wiki.factory.create( + wiki, _ = await Wiki.factory().create( context, name=request.name, description=request.description, @@ -363,7 +363,7 @@ async def add_transcript( ) -> WikiAddTranscriptResponse: """Create a new Transcript belonging to this Wiki and record it as pending ingestion on the Wiki.""" - transcript, _ = await Transcript.factory.create( + transcript, _ = await Transcript.factory().create( context, messages=list(request.messages), owner_id=self.state.owner_id, diff --git a/reboot/examples/bank-nodejs/backend/src/bank_servicer.ts b/reboot/examples/bank-nodejs/backend/src/bank_servicer.ts index c9fad9a7e..9df9b7d7a 100644 --- a/reboot/examples/bank-nodejs/backend/src/bank_servicer.ts +++ b/reboot/examples/bank-nodejs/backend/src/bank_servicer.ts @@ -36,7 +36,7 @@ export class BankServicer extends Bank.Servicer { this.state.accountIds.push(newAccountId); // Let's go create the account. - const [account, response] = await Account.factory.open( + const [account, response] = await Account.factory().open( context, newAccountId, { diff --git a/reboot/examples/bank-nodejs/backend/tests/test.ts b/reboot/examples/bank-nodejs/backend/tests/test.ts index 835117244..062d95098 100644 --- a/reboot/examples/bank-nodejs/backend/tests/test.ts +++ b/reboot/examples/bank-nodejs/backend/tests/test.ts @@ -14,7 +14,7 @@ function reportErrorToUser(errorMessage: string): void { async function performErroringWithdrawal(context: any): Promise { const accountId = "account-nodejs"; - const [account] = await Account.factory.open(context, accountId, { + const [account] = await Account.factory().open(context, accountId, { customerName: "Tony", }); diff --git a/reboot/examples/bank-pydantic/backend/src/bank_servicer.py b/reboot/examples/bank-pydantic/backend/src/bank_servicer.py index 36c824b52..4eb423d0b 100644 --- a/reboot/examples/bank-pydantic/backend/src/bank_servicer.py +++ b/reboot/examples/bank-pydantic/backend/src/bank_servicer.py @@ -29,7 +29,7 @@ async def sign_up( context: TransactionContext, request: Bank.SignUpRequest, ) -> None: - await Customer.factory.sign_up(context, request.customer_id) + await Customer.factory().sign_up(context, request.customer_id) await OrderedMap.ref(self.state.customer_ids_map_id).Insert( context, diff --git a/reboot/examples/bank-pydantic/backend/src/customer_servicer.py b/reboot/examples/bank-pydantic/backend/src/customer_servicer.py index 596bcc87a..313493d46 100644 --- a/reboot/examples/bank-pydantic/backend/src/customer_servicer.py +++ b/reboot/examples/bank-pydantic/backend/src/customer_servicer.py @@ -29,7 +29,7 @@ async def open_account( account_id = str(uuid.uuid4()) self.state.account_ids.append(account_id) - account, _ = await Account.factory.open( + account, _ = await Account.factory().open( context, account_id, ) diff --git a/reboot/examples/bank-pydantic/backend/src/main.py b/reboot/examples/bank-pydantic/backend/src/main.py index fa42e7a08..16a3de065 100644 --- a/reboot/examples/bank-pydantic/backend/src/main.py +++ b/reboot/examples/bank-pydantic/backend/src/main.py @@ -19,7 +19,7 @@ async def initialize(context: InitializeContext): - await Bank.factory.create(context, SINGLETON_BANK_ID) + await Bank.factory().create(context, SINGLETON_BANK_ID) async def main(): diff --git a/reboot/examples/bank-zod/backend/src/bank.ts b/reboot/examples/bank-zod/backend/src/bank.ts index 5eece5a57..54e8a7a0c 100644 --- a/reboot/examples/bank-zod/backend/src/bank.ts +++ b/reboot/examples/bank-zod/backend/src/bank.ts @@ -51,7 +51,7 @@ export const BankServicer = Bank.servicer({ state: Bank.State, { customerId }: Bank.SignUpRequest ): Promise<[Bank.State]> => { - await Customer.factory.signUp(context, customerId); + await Customer.factory().signUp(context, customerId); // Save the account ID to our _distributed_ map using a UUIDv7 // to get a "timestamp" based ordering. diff --git a/reboot/examples/bank-zod/backend/src/customer.ts b/reboot/examples/bank-zod/backend/src/customer.ts index 8aa6b1e3a..8d9999186 100644 --- a/reboot/examples/bank-zod/backend/src/customer.ts +++ b/reboot/examples/bank-zod/backend/src/customer.ts @@ -29,7 +29,7 @@ export const CustomerServicer = Customer.servicer({ const accountId = uuidv4(); state.accountIds.push(accountId); - const [account] = await Account.factory.open(context, accountId, {}); + const [account] = await Account.factory().open(context, accountId, {}); await account.deposit(context, { amount: initialDeposit }); diff --git a/reboot/examples/bank-zod/backend/src/main.ts b/reboot/examples/bank-zod/backend/src/main.ts index 88a97ce81..9886bab9e 100644 --- a/reboot/examples/bank-zod/backend/src/main.ts +++ b/reboot/examples/bank-zod/backend/src/main.ts @@ -7,7 +7,7 @@ import { CustomerServicer } from "./customer.js"; const SINGLETON_BANK_ID = "reboot-bank"; const initialize = async (context) => { - await Bank.factory.create(context, SINGLETON_BANK_ID); + await Bank.factory().create(context, SINGLETON_BANK_ID); }; new Application({ diff --git a/reboot/examples/bank-zod/backend/tests/test.ts b/reboot/examples/bank-zod/backend/tests/test.ts index 76247e420..7fa7fe86c 100644 --- a/reboot/examples/bank-zod/backend/tests/test.ts +++ b/reboot/examples/bank-zod/backend/tests/test.ts @@ -19,7 +19,7 @@ function reportErrorToUser(errorMessage: string): void { async function performErroringWithdrawal(context: any): Promise { const accountId = "account-nodejs"; - const [account] = await Account.factory.open(context, accountId, {}); + const [account] = await Account.factory().open(context, accountId, {}); try { await account.withdraw(context, { amount: 65 }); @@ -66,7 +66,7 @@ test("Calling Bank.SignUp", async (t) => { await t.test("Sign Up", async (t) => { const context = rbt.createExternalContext("test"); - const [bank] = await Bank.factory.create(context, "bank-nodejs"); + const [bank] = await Bank.factory().create(context, "bank-nodejs"); const response = await bank.signUp(context, { customerId: "test@reboot.dev", @@ -152,7 +152,7 @@ test("Transfer with Customer", async (t) => { await t.test("Sign Up", async (t) => { const context = rbt.createExternalContext("test"); - const [bank] = await Bank.factory.create(context, "bank-nodejs"); + const [bank] = await Bank.factory().create(context, "bank-nodejs"); const CUSTOMER_ID_1 = "test@reboot.dev"; const CUSTOMER_ID_2 = "test2@reboot.dev"; diff --git a/reboot/examples/bank/backend/src/main.py b/reboot/examples/bank/backend/src/main.py index 8b70111ff..5dc5d68ea 100644 --- a/reboot/examples/bank/backend/src/main.py +++ b/reboot/examples/bank/backend/src/main.py @@ -161,7 +161,7 @@ async def sign_up( account_id = request.account_id if mailgun_api_key := await self._mailgun_api_key(): - await mailgun.Message.factory.send( + await mailgun.Message.factory().send( context, None, Options(bearer_token=mailgun_api_key), @@ -173,7 +173,7 @@ async def sign_up( text=self._text_email, ) - account, _ = await Account.factory.open(context, account_id) + account, _ = await Account.factory().open(context, account_id) await account.deposit(context, amount=request.initial_deposit) @@ -213,7 +213,7 @@ async def _mailgun_api_key(self) -> Optional[str]: async def initialize(context: InitializeContext): - await Bank.factory.create(context, SINGLETON_BANK_ID) + await Bank.factory().create(context, SINGLETON_BANK_ID) async def main(): diff --git a/reboot/examples/boutique/backend/src/checkout/servicer.py b/reboot/examples/boutique/backend/src/checkout/servicer.py index e46d73f72..be2e3b310 100644 --- a/reboot/examples/boutique/backend/src/checkout/servicer.py +++ b/reboot/examples/boutique/backend/src/checkout/servicer.py @@ -107,7 +107,7 @@ async def place_order( confirmation = template.render(order=order_result) if mailgun_api_key := await self._mailgun_api_key(): - await Message.factory.send( + await Message.factory().send( context, Options(bearer_token=mailgun_api_key), recipient=request.email, diff --git a/reboot/examples/boutique/backend/src/main.py b/reboot/examples/boutique/backend/src/main.py index 4e54ea206..085b4fad1 100644 --- a/reboot/examples/boutique/backend/src/main.py +++ b/reboot/examples/boutique/backend/src/main.py @@ -11,9 +11,9 @@ async def initialize(context): - await Checkout.factory.create(context, CHECKOUT_ACTOR_ID) + await Checkout.factory().create(context, CHECKOUT_ACTOR_ID) - await ProductCatalog.factory.load_products( + await ProductCatalog.factory().load_products( context, PRODUCT_CATALOG_ACTOR_ID ) diff --git a/reboot/examples/chick-potle/backend/src/servicers/food.py b/reboot/examples/chick-potle/backend/src/servicers/food.py index c7f9d1c36..41777cbb5 100644 --- a/reboot/examples/chick-potle/backend/src/servicers/food.py +++ b/reboot/examples/chick-potle/backend/src/servicers/food.py @@ -115,7 +115,7 @@ async def start_order( # authorizer only admits that user (or app-internal callers), so # `context.state_id` is the ordering user's ID — even for # app-internal calls, which carry no `context.auth`. - order, _ = await FoodOrder.factory.create( + order, _ = await FoodOrder.factory().create( context, menu=MENU_ITEMS, user_id=context.state_id, diff --git a/reboot/examples/docubot/backend/src/main.ts b/reboot/examples/docubot/backend/src/main.ts index 5b53ec5de..8f1a33cea 100644 --- a/reboot/examples/docubot/backend/src/main.ts +++ b/reboot/examples/docubot/backend/src/main.ts @@ -4,7 +4,7 @@ import { DOCUBOT_ASSISTANT_ID } from "../../constants.js"; import docubot from "@reboot-dev/docubot"; const initialize = async (context) => { - await Assistant.factory.create(context, DOCUBOT_ASSISTANT_ID, { + await Assistant.factory().create(context, DOCUBOT_ASSISTANT_ID, { name: DOCUBOT_ASSISTANT_ID, url: "https://docs.reboot.dev", }); diff --git a/reboot/examples/kcdc-2025/backend/src/main.py b/reboot/examples/kcdc-2025/backend/src/main.py index 884e255a7..b362cb9ef 100644 --- a/reboot/examples/kcdc-2025/backend/src/main.py +++ b/reboot/examples/kcdc-2025/backend/src/main.py @@ -13,9 +13,9 @@ async def initialize(context): - await Channel.factory.create(context, "channel") + await Channel.factory().create(context, "channel") - await Chatbot.factory.create( + await Chatbot.factory().create( context, name="Fact Checker", channel_id="channel", diff --git a/reboot/examples/kcdc-2025/backend/src/servicers/channel.py b/reboot/examples/kcdc-2025/backend/src/servicers/channel.py index 32aa33770..8a2eb72e2 100644 --- a/reboot/examples/kcdc-2025/backend/src/servicers/channel.py +++ b/reboot/examples/kcdc-2025/backend/src/servicers/channel.py @@ -32,7 +32,7 @@ async def create( context: TransactionContext, request: ChannelCreateRequest, ) -> ChannelCreateResponse: - await Index.factory.create( + await Index.factory().create( context, messages_id(context.state_id), order=100, diff --git a/reboot/examples/kcdc-2025/backend/src/servicers/chatbot.py b/reboot/examples/kcdc-2025/backend/src/servicers/chatbot.py index 161f0aaf9..a6f8dd6f8 100644 --- a/reboot/examples/kcdc-2025/backend/src/servicers/chatbot.py +++ b/reboot/examples/kcdc-2025/backend/src/servicers/chatbot.py @@ -76,7 +76,7 @@ async def create( # Create our messages reactions index so folks can react to # our messages. - await Index.factory.create( + await Index.factory().create( context, f'{request.name}-messages-reactions', order=100, diff --git a/reboot/examples/kcdc-2025/backend/src/servicers/user.py b/reboot/examples/kcdc-2025/backend/src/servicers/user.py index e8862dbcd..cf20a2f24 100644 --- a/reboot/examples/kcdc-2025/backend/src/servicers/user.py +++ b/reboot/examples/kcdc-2025/backend/src/servicers/user.py @@ -62,7 +62,7 @@ async def create( if context.constructor: users = Users.ref(USERS_SINGLETON) await users.add(context, user=context.state_id) - await Index.factory.create( + await Index.factory().create( context, self._messages_reactions.state_id, order=100, @@ -94,7 +94,7 @@ async def add_chatbot( request: AddChatbotRequest, ) -> AddChatbotResponse: - chatbot, _ = await Chatbot.factory.create( + chatbot, _ = await Chatbot.factory().create( context, name=request.name, channel_id=request.channel_id, diff --git a/reboot/examples/mcp-ui-counter-dashboard/backend/src/servicers/counter.py b/reboot/examples/mcp-ui-counter-dashboard/backend/src/servicers/counter.py index 4571a41e0..6dd8fe7c1 100644 --- a/reboot/examples/mcp-ui-counter-dashboard/backend/src/servicers/counter.py +++ b/reboot/examples/mcp-ui-counter-dashboard/backend/src/servicers/counter.py @@ -22,7 +22,7 @@ async def create_counter( request: CreateCounterRequest, ) -> CreateCounterResponse: """Create a new Counter and return its ID.""" - counter, _ = await Counter.factory.create( + counter, _ = await Counter.factory().create( context, description=request.description ) self.state.counter_ids.append(counter.state_id) diff --git a/reboot/examples/mcp-ui-counter/backend/src/servicers/counter.py b/reboot/examples/mcp-ui-counter/backend/src/servicers/counter.py index 1252fa9b1..c7642a3a3 100644 --- a/reboot/examples/mcp-ui-counter/backend/src/servicers/counter.py +++ b/reboot/examples/mcp-ui-counter/backend/src/servicers/counter.py @@ -42,7 +42,7 @@ async def create_counter( request: CreateCounterRequest, ) -> CreateCounterResponse: """Create a new Counter and return its ID.""" - counter, _ = await Counter.factory.create( + counter, _ = await Counter.factory().create( context, description=request.description, owner_id=context.state_id, diff --git a/reboot/examples/monorepo/bank/backend/src/bank_servicer.py b/reboot/examples/monorepo/bank/backend/src/bank_servicer.py index cabaa5b11..0d1a81cea 100644 --- a/reboot/examples/monorepo/bank/backend/src/bank_servicer.py +++ b/reboot/examples/monorepo/bank/backend/src/bank_servicer.py @@ -31,7 +31,7 @@ async def sign_up( new_account_id = str(uuid.uuid4()) # Let's go create the account. - account, _ = await Account.factory.open( + account, _ = await Account.factory().open( context, new_account_id, customer_name=request.customer_name, diff --git a/reboot/examples/monorepo/hello-constructors/backend/src/main.py b/reboot/examples/monorepo/hello-constructors/backend/src/main.py index da9c4d092..12eea3a91 100644 --- a/reboot/examples/monorepo/hello-constructors/backend/src/main.py +++ b/reboot/examples/monorepo/hello-constructors/backend/src/main.py @@ -12,7 +12,7 @@ async def initialize(context: InitializeContext): # Explicitly create the state machine. - hello, _ = await Hello.factory.create( + hello, _ = await Hello.factory().create( context, EXAMPLE_STATE_MACHINE_ID, initial_message="Welcome! This message was sent by a constructor.", diff --git a/reboot/examples/reboot-swag-store/backend/src/main.py b/reboot/examples/reboot-swag-store/backend/src/main.py index cac1bc4e4..36fe67479 100644 --- a/reboot/examples/reboot-swag-store/backend/src/main.py +++ b/reboot/examples/reboot-swag-store/backend/src/main.py @@ -28,7 +28,7 @@ async def initialize(context) -> None: """Ensure the coupon book exists (creates initial codes on first run).""" - await CouponBook.factory.create(context, COUPON_BOOK_ID) + await CouponBook.factory().create(context, COUPON_BOOK_ID) async def main() -> None: diff --git a/reboot/examples/reboot-swag-store/backend/src/servicers/store.py b/reboot/examples/reboot-swag-store/backend/src/servicers/store.py index 6db102827..67680ac4a 100644 --- a/reboot/examples/reboot-swag-store/backend/src/servicers/store.py +++ b/reboot/examples/reboot-swag-store/backend/src/servicers/store.py @@ -76,7 +76,7 @@ async def create_cart( this method), and is recorded on the cart so only this session can mutate it.""" owner_id = context.auth.user_id if context.auth else "" - cart, _ = await Cart.factory.create(context, owner_id=owner_id) + cart, _ = await Cart.factory().create(context, owner_id=owner_id) return User.CreateCartResponse( cart_id=cart.state_id, ) @@ -272,7 +272,7 @@ async def checkout( variant_ids = [item.variant_id for item in self.state.items] quantities = [item.quantity for item in self.state.items] - order, _ = await Order.factory.create( + order, _ = await Order.factory().create( context, order_id, Order.CreateRequest( diff --git a/reboot/ping/ping.py b/reboot/ping/ping.py index 10005368d..bda48b1f1 100644 --- a/reboot/ping/ping.py +++ b/reboot/ping/ping.py @@ -167,7 +167,7 @@ async def create_counter( context: TransactionContext, request: CreateCounterRequest, ) -> CreateCounterResponse: - counter, _ = await Counter.factory.create( + counter, _ = await Counter.factory().create( context, description=request.description, owner_id=context.state_id, diff --git a/reboot/plugin/skills/mcp-ui/SKILL.md b/reboot/plugin/skills/mcp-ui/SKILL.md index 31137b898..0374c1a1a 100644 --- a/reboot/plugin/skills/mcp-ui/SKILL.md +++ b/reboot/plugin/skills/mcp-ui/SKILL.md @@ -149,7 +149,7 @@ exactly one of them — the step that needs it. `self.state_id`); `self.ref().schedule(...)`. - `python/references/rpc-calls.md` — kwargs, not Request wrappers. - `python/references/rpc-constructor-calls.md` — - `Service.factory.create(context, id)` semantics. + `Service.factory().create(context, id)` semantics. - `python/references/servicer-workflow.md` — only when you declared a `Workflow`, and then top to bottom: the `@classmethod` / `WorkflowContext` declaration shape, the call-classification @@ -158,7 +158,7 @@ exactly one of them — the step that needs it. `until` / `until_changes`, and workflow exit semantics. - [`references/servicer-patterns.md`](references/servicer-patterns.md) — the MCP UI servicer shapes: `UserServicer` calling - `.factory.create(context)`, a Workflow Servicer with `MyType.ref()` + `.factory().create(context)`, a Workflow Servicer with `MyType.ref()` (no-arg) magic, inline writers via `.per_workflow("alias").write(context, fn)` / `.per_iteration("alias").write(...)` / `.always().write(...)`, @@ -406,7 +406,7 @@ Before writing code, analyze the user's request: 3. **User methods**: How does the AI create instances of application types? Each gets a `Transaction` on `User` that calls - `.factory.create(context)`, then registers the new ID in the + `.factory().create(context)`, then registers the new ID in the appropriate container (Shape B or C above). 4. **State shape (per type)**: Fields, types — lists, nested objects, primitives. Each gets `Field(tag=N)`. **Nested `Model` @@ -514,7 +514,7 @@ that warn you are accreting concerns, and the split pattern, are in Full pydantic shape in [`references/api-method-types.md`](references/api-method-types.md); -the `UserServicer` + `.factory.create(context)` pattern in +the `UserServicer` + `.factory().create(context)` pattern in [`references/servicer-patterns.md`](references/servicer-patterns.md). ### Tool Exposure Control diff --git a/reboot/plugin/skills/mcp-ui/references/gotchas.md b/reboot/plugin/skills/mcp-ui/references/gotchas.md index 1eacba7b5..46ef99bfb 100644 --- a/reboot/plugin/skills/mcp-ui/references/gotchas.md +++ b/reboot/plugin/skills/mcp-ui/references/gotchas.md @@ -10,7 +10,7 @@ tags: gotchas, traps, errors, mcp, ui, factory, workflow, ref, schedule, optiona For the rest of the trip-list — `.rbtrc` line-based, no `__init__.py` in `api/`, pydantic Field zero-default rule, `self.ref().state_id` not `self.state_id`, kwargs not Request wrappers, generated import -paths, `Service.factory.create(context, id)` semantics, register-all-Servicers +paths, `Service.factory().create(context, id)` semantics, register-all-Servicers — see `python/references/patterns-common-gotchas.md` and the per-topic references. diff --git a/reboot/plugin/skills/mcp-ui/references/servicer-patterns.md b/reboot/plugin/skills/mcp-ui/references/servicer-patterns.md index bc0aaba4e..0d3a91a65 100644 --- a/reboot/plugin/skills/mcp-ui/references/servicer-patterns.md +++ b/reboot/plugin/skills/mcp-ui/references/servicer-patterns.md @@ -16,9 +16,9 @@ wrappers, raise typed `Aborted`) are in - One Servicer class per type — `UserServicer` plus one per application type. - The User Servicer's `create_` Transaction calls - `.factory.create(context)` and returns the `state_id` in a - response. Constructors live under the `factory` namespace on the - state class (`.factory.create(...)`), keeping the top-level + `.factory().create(context)` and returns the `state_id` in a + response. Constructors live under the `factory()` namespace on the + state class (`.factory().create(...)`), keeping the top-level state-class namespace free for framework methods like `ref()`. - Workflow Servicers use `MyType.ref()` (no args, picks up `state_id` from `WorkflowContext`) — see Gotcha #11 below; `cls.ref()` and @@ -47,10 +47,10 @@ class UserServicer(User.Servicer): """Create a new Counter and return its ID.""" # Factory create: pass request fields as keyword args directly # — do NOT wrap in a Request object. - # No-args: Counter.factory.create(context) - # With args: Counter.factory.create( + # No-args: Counter.factory().create(context) + # With args: Counter.factory().create( # context, title="...", count=0) - counter, _ = await Counter.factory.create(context) + counter, _ = await Counter.factory().create(context) return User.CreateCounterResponse( counter_id=counter.state_id, ) @@ -192,7 +192,7 @@ class UserServicer(User.Servicer): context: TransactionContext, request: User.CreateGameRequest, ) -> User.CreateGameResponse: - game, _ = await Game.factory.create(context, ...) + game, _ = await Game.factory().create(context, ...) # GOOD — schedule the workflow from the transaction. # Empty request: just pass `context`. await Game.ref(game.state_id).schedule().autoplay(context) diff --git a/reboot/plugin/skills/python/SKILL.md b/reboot/plugin/skills/python/SKILL.md index a1c669bde..db6aed497 100644 --- a/reboot/plugin/skills/python/SKILL.md +++ b/reboot/plugin/skills/python/SKILL.md @@ -333,8 +333,8 @@ The `Agent` runs only inside a `WorkflowContext`, so also read the trap (`await ref.deposit(context, DepositRequest(amount=10))`) is a recurring miss; passes type-check and fails at runtime - `references/rpc-constructor-calls.md` — **always read** when the - agent invokes a constructor: use `.factory.create(context, id, ...)` - or `.factory.(context, id, ...)`, NEVER + agent invokes a constructor: use `.factory().create(context, id, ...)` + or `.factory().(context, id, ...)`, NEVER `.ref(id).(...)` (the trap that skips creation semantics). The factory-declaration side is `servicer-constructor.md`; the call-site side is here diff --git a/reboot/plugin/skills/python/references/_sections.md b/reboot/plugin/skills/python/references/_sections.md index 445d810d1..9a706d242 100644 --- a/reboot/plugin/skills/python/references/_sections.md +++ b/reboot/plugin/skills/python/references/_sections.md @@ -47,7 +47,7 @@ This file defines the rule categories for Reboot Python best practices. Rules ar ## 9. RPC (rpc) **Impact:** MEDIUM -**Description:** Calling actors via `Service.ref(id)` and `await ref.method(context, ...)`. Constructor calls (`Service.factory.create`), fan-out via `Service.forall(ids).method(context)`, and the kwargs-not-Request convention. +**Description:** Calling actors via `Service.ref(id)` and `await ref.method(context, ...)`. Constructor calls (`Service.factory().create`), fan-out via `Service.forall(ids).method(context)`, and the kwargs-not-Request convention. ## 10. Scheduling (scheduling) diff --git a/reboot/plugin/skills/python/references/api-pydantic.md b/reboot/plugin/skills/python/references/api-pydantic.md index 35d7dde90..6424980e2 100644 --- a/reboot/plugin/skills/python/references/api-pydantic.md +++ b/reboot/plugin/skills/python/references/api-pydantic.md @@ -211,8 +211,8 @@ Error while parsing option value for "method": Message type ```python # OK -open=Writer(... factory=True ...), # Account.factory.open(ctx, id, ...) -place=Transaction(... factory=True ...), # Order.factory.place(ctx, id, ...) +open=Writer(... factory=True ...), # Account.factory().open(ctx, id, ...) +place=Transaction(... factory=True ...), # Order.factory().place(ctx, id, ...) # REJECTED by `rbt generate` hello=Workflow(... factory=True ...), # codegen error diff --git a/reboot/plugin/skills/python/references/auth-external-api-calls.md b/reboot/plugin/skills/python/references/auth-external-api-calls.md index 5213f0164..9b57b625c 100644 --- a/reboot/plugin/skills/python/references/auth-external-api-calls.md +++ b/reboot/plugin/skills/python/references/auth-external-api-calls.md @@ -174,7 +174,7 @@ class UserServicer(User.Servicer): request: User.ConnectAcmeRequest, ) -> User.ConnectAcmeResponse: user_id = self.ref().state_id - ciphertext, _ = await Ciphertext.factory.encrypt( + ciphertext, _ = await Ciphertext.factory().encrypt( context, plaintext=request.api_key.encode(), associated_data=make_associated_data( @@ -316,7 +316,7 @@ await KeyManager.ref(_key_manager_id(GOOGLE)).shred(context, scope=user_id) (any other service): your own authorize + callback routes, callback registered `app_internal=True`, the OAuth `state` HMAC-signed and verified, `OAuthTokenManager.store` called with the app-internal `external_context(request)`. Path C - (the user provides an API key, not OAuth): `Ciphertext.factory.encrypt`, + (the user provides an API key, not OAuth): `Ciphertext.factory().encrypt`, with the returned `state_id` — never the raw key — kept in state. A key the developer holds for the whole app is an application secret (`rbt cloud secret`), not actor state. diff --git a/reboot/plugin/skills/python/references/lifecycle-initialize-hook.md b/reboot/plugin/skills/python/references/lifecycle-initialize-hook.md index b7bf6e3e0..e74eeeae6 100644 --- a/reboot/plugin/skills/python/references/lifecycle-initialize-hook.md +++ b/reboot/plugin/skills/python/references/lifecycle-initialize-hook.md @@ -10,7 +10,7 @@ tags: initialize, InitializeContext, create, singleton, bootstrap > **Critical:** `initialize` runs on **every** application start, so > its calls get an **auto-generated idempotency key** (one per > `actor` + `method`) and run once. Constructors — -> `Service.factory.create(context, id)` / factory methods — are a no-op on +> `Service.factory().create(context, id)` / factory methods — are a no-op on > existing actors. The catch: to call the **same method on the same > actor more than once** you **must** distinguish the calls with > `.idempotently("alias")` (or an explicit `key=`), or the second one @@ -23,7 +23,7 @@ runs against an `InitializeContext` and is the right place to create singletons or seed data that must exist before the first real request. The callback runs each time the application starts; Reboot's idempotent -`Service.factory.create(context, id)` makes calling it on every boot safe. +`Service.factory().create(context, id)` makes calling it on every boot safe. **Incorrect (creating singletons inside a Servicer's `__init__`):** @@ -33,7 +33,7 @@ class BankServicer(Bank.Servicer): def __init__(self): # This won't run "at startup"; it runs the first time # someone references the Bank actor. - Bank.factory.create(...) # also: no context here + Bank.factory().create(...) # also: no context here ``` **Correct (matches the [`reboot-bank-pydantic`](https://github.com/reboot-dev/reboot-bank-pydantic) example, `backend/src/main.py`):** @@ -47,7 +47,7 @@ SINGLETON_BANK_ID = 'SVB' async def initialize(context: InitializeContext): - await Bank.factory.create(context, SINGLETON_BANK_ID) + await Bank.factory().create(context, SINGLETON_BANK_ID) async def main(): @@ -61,7 +61,7 @@ async def main(): If a `Type` does **not** declare a `factory=True` method, Reboot will implicitly create the actor on the first writer call. A simple chat -room can use this — no explicit `ChatRoom.factory.create(...)` is needed when +room can use this — no explicit `ChatRoom.factory().create(...)` is needed when `send` is a `Writer`: ```python @@ -73,14 +73,14 @@ async def initialize(context: InitializeContext): When the API **does** declare a factory (`Writer(... factory=True ...)` or `Transaction(... factory=True ...)`), call it explicitly via -`Service.factory.create(context, id)` or -`Service.factory.(context, id, ...)`. +`Service.factory().create(context, id)` or +`Service.factory().(context, id, ...)`. ## Calling the Same Method More Than Once — `.idempotently("alias")` `initialize` auto-generates an idempotency key per `(actor, method)`, so **one** call to a given method is fine bare — that's why -`Service.factory.create(...)` followed by a single `ref.send(...)` works +`Service.factory().create(...)` followed by a single `ref.send(...)` works without any alias. But calling that **same** method on the **same** actor again in the same `initialize` raises: @@ -95,7 +95,7 @@ Give each call a **distinct** `.idempotently("alias")` (or explicit ```python async def initialize(context: InitializeContext): - hello, _ = await Hello.factory.create( + hello, _ = await Hello.factory().create( context, "reboot-hello", initial_message="Welcome!", ) diff --git a/reboot/plugin/skills/python/references/patterns-common-gotchas.md b/reboot/plugin/skills/python/references/patterns-common-gotchas.md index b4076cad6..10edb426e 100644 --- a/reboot/plugin/skills/python/references/patterns-common-gotchas.md +++ b/reboot/plugin/skills/python/references/patterns-common-gotchas.md @@ -45,16 +45,16 @@ await account.deposit(context, DepositRequest(amount=10)) await account.deposit(context, amount=10) ``` -### 5. Constructor Calls Use `Service.factory.create` / `Service.factory.` +### 5. Constructor Calls Use `Service.factory().create` / `Service.factory().` Don't call a constructor through `.ref(id).method(...)`. Invoke it -through the `factory` namespace so creation semantics apply: +through the `factory()` namespace so creation semantics apply: ```python # Wrong: await Account.ref(id).open(context) # Right: -account, _ = await Account.factory.open(context, id) +account, _ = await Account.factory().open(context, id) ``` ### 6. Servicer `authorizer()` Returns an Instance @@ -105,7 +105,7 @@ Workflow, Not a Transaction" in `servicer-transaction.md`. ### 9. `initialize` Runs on Every Restart -It's idempotent only if **you** make it so. Use `Service.factory.create` +It's idempotent only if **you** make it so. Use `Service.factory().create` and `context.constructor` to gate set-once work. ### 10. Don't Hand-Edit `*_rbt.py` diff --git a/reboot/plugin/skills/python/references/patterns-idempotency.md b/reboot/plugin/skills/python/references/patterns-idempotency.md index f6d6759a4..ba9c20186 100644 --- a/reboot/plugin/skills/python/references/patterns-idempotency.md +++ b/reboot/plugin/skills/python/references/patterns-idempotency.md @@ -8,12 +8,12 @@ tags: patterns, idempotency, initialize, constructor, restart ## Make Constructor and `initialize` Calls Idempotent > **Critical:** `initialize` runs on every restart, and Reboot may -> retry transactions internally. `Service.factory.create(context, id)` is the +> retry transactions internally. `Service.factory().create(context, id)` is the > idempotent creation primitive — safe to call repeatedly. Inside a > reusable constructor, gate set-once fields on `context.constructor`. The `initialize` hook runs every time the application starts. Anything it -does must be safe to do repeatedly. Reboot's `Service.factory.create(context, id)` +does must be safe to do repeatedly. Reboot's `Service.factory().create(context, id)` is the canonical idempotent creation primitive: calling it on an existing actor is a no-op. @@ -31,7 +31,7 @@ async def initialize(context: InitializeContext): ```python async def initialize(context: InitializeContext): # Create-once: idempotent on subsequent boots. - await Bank.factory.create(context, SINGLETON_BANK_ID) + await Bank.factory().create(context, SINGLETON_BANK_ID) ``` ## Branch on `context.constructor` for Set-Once Fields diff --git a/reboot/plugin/skills/python/references/rpc-calls.md b/reboot/plugin/skills/python/references/rpc-calls.md index e8cb7b81d..3bf46a03f 100644 --- a/reboot/plugin/skills/python/references/rpc-calls.md +++ b/reboot/plugin/skills/python/references/rpc-calls.md @@ -55,7 +55,7 @@ Constructor calls return a `(ref, response)` tuple — the ref to the newly-constructed actor and the response from the method: ```python -account, _ = await Account.factory.open(context, request.account_id) +account, _ = await Account.factory().open(context, request.account_id) await account.deposit(context, amount=request.initial_deposit) ``` diff --git a/reboot/plugin/skills/python/references/rpc-constructor-calls.md b/reboot/plugin/skills/python/references/rpc-constructor-calls.md index b71679bed..3e32d773f 100644 --- a/reboot/plugin/skills/python/references/rpc-constructor-calls.md +++ b/reboot/plugin/skills/python/references/rpc-constructor-calls.md @@ -1,28 +1,28 @@ --- -title: Use `Service.factory.create` and `Service.factory.` for Constructor Calls +title: Use `Service.factory().create` and `Service.factory().` for Constructor Calls impact: MEDIUM impactDescription: Calling a constructor through `.ref(...).method(...)` skips creation semantics tags: rpc, constructor, create, factory --- -## Use `Service.factory.create` and `Service.factory.` for Constructor Calls +## Use `Service.factory().create` and `Service.factory().` for Constructor Calls > **Critical:** never invoke a constructor through `Service.ref(id).method(...)` > — that skips creation semantics. Use -> `await Service.factory.create(context, id)` for default constructors and -> `await Service.factory.(context, id, ...)` for named ones. +> `await Service.factory().create(context, id)` for default constructors and +> `await Service.factory().(context, id, ...)` for named ones. > Both return a `(ref, response)` tuple. A method declared with `factory=True` is the actor's creation path. -Invoke it through the `factory` namespace on the state type: +Invoke it through the `factory()` namespace on the state type: -- `await Service.factory.create(context, id)` — for the implicit/default - constructor (e.g., `Bank.factory.create(context, SINGLETON_BANK_ID)`). -- `await Service.factory.(context, id, **kwargs)` — for a named - constructor method (e.g., `Account.factory.open(context, account_id)`). +- `await Service.factory().create(context, id)` — for the implicit/default + constructor (e.g., `Bank.factory().create(context, SINGLETON_BANK_ID)`). +- `await Service.factory().(context, id, **kwargs)` — for a named + constructor method (e.g., `Account.factory().open(context, account_id)`). Both return a `(ref, response)` tuple. Routing constructors through the -`factory` namespace keeps the top level of the state type free for +`factory()` namespace keeps the top level of the state type free for framework methods like `ref()`. **Incorrect (using `.ref(...).method(...)` for a constructor):** @@ -49,18 +49,18 @@ open=Writer( `main.py`: ```python -account, _ = await Account.factory.open(context, account_id) +account, _ = await Account.factory().open(context, account_id) await account.deposit(context, amount=request.initial_deposit) ``` -## `Service.factory.create(context, id)` Is the Idempotent Default +## `Service.factory().create(context, id)` Is the Idempotent Default When the `Type` has no explicit factory (no `factory=True` method), -use `Service.factory.create` from the `initialize` hook: +use `Service.factory().create` from the `initialize` hook: ```python async def initialize(context: InitializeContext): - await Bank.factory.create(context, SINGLETON_BANK_ID) + await Bank.factory().create(context, SINGLETON_BANK_ID) ``` This is safe to call on every application start; existing actors aren't @@ -72,7 +72,7 @@ The first element of the returned tuple is the ref. Prefer using it directly rather than re-constructing one with `Service.ref(...)`: ```python -account, _ = await Account.factory.open(context, account_id) +account, _ = await Account.factory().open(context, account_id) # Use the returned ref: await account.deposit(context, amount=100) diff --git a/reboot/plugin/skills/python/references/servicer-constructor.md b/reboot/plugin/skills/python/references/servicer-constructor.md index 7dc461790..eafc0ff87 100644 --- a/reboot/plugin/skills/python/references/servicer-constructor.md +++ b/reboot/plugin/skills/python/references/servicer-constructor.md @@ -8,8 +8,8 @@ tags: servicer, constructor, context.constructor, create, initialization ## Handle Constructor Methods > **Critical:** invoke a constructor as -> `await Service.factory.create(context, id)` (or -> `await Service.factory.(context, id, **kwargs)`), +> `await Service.factory().create(context, id)` (or +> `await Service.factory().(context, id, **kwargs)`), > **never** as `Service.ref(id).method(...)` — the latter skips > creation semantics. Inside the implementation, branch on > `context.constructor` for set-once initial state. @@ -19,7 +19,7 @@ A method declared with `factory=True` on its `Writer(...)` or The Servicer implementation is just an ordinary writer/transaction method — the _constructor-ness_ shows up in two places: -1. **Caller side**: use `await Service.factory.create(context, id)` (not +1. **Caller side**: use `await Service.factory().create(context, id)` (not `Service.ref(id).method(...)`) to invoke it. 2. **Servicer side**: branch on `context.constructor` to set initial state only on the creation pass. @@ -76,10 +76,10 @@ second call. ```python async def initialize(context: InitializeContext): - await Bank.factory.create(context, SINGLETON_BANK_ID) + await Bank.factory().create(context, SINGLETON_BANK_ID) ``` -`Service.factory.create(context, id)` is **idempotent** when called from the +`Service.factory().create(context, id)` is **idempotent** when called from the `initialize` hook, so it's safe to invoke on every application start. ## Calling from a Transaction @@ -90,11 +90,11 @@ A transaction can create and operate on a new actor in one atomic step: async def sign_up( self, context: TransactionContext, request: Bank.SignUpRequest, ) -> None: - account, _ = await Account.factory.open(context, request.account_id) + account, _ = await Account.factory().open(context, request.account_id) await account.deposit(context, amount=request.initial_deposit) ``` -`Account.factory.open(context, id)` here is the constructor (the `open` method +`Account.factory().open(context, id)` here is the constructor (the `open` method declared `factory=True`) and returns the actor reference plus the response (or `None` when `response=None`). diff --git a/reboot/plugin/skills/python/references/servicer-transaction.md b/reboot/plugin/skills/python/references/servicer-transaction.md index 796d1025c..f92fac07c 100644 --- a/reboot/plugin/skills/python/references/servicer-transaction.md +++ b/reboot/plugin/skills/python/references/servicer-transaction.md @@ -107,7 +107,7 @@ async def sign_up( self, context: TransactionContext, request: SignUpRequest, ) -> SignUpResponse: if mailgun_api_key := await self._mailgun_api_key(): - await mailgun.Message.factory.send( + await mailgun.Message.factory().send( context, None, Options(bearer_token=mailgun_api_key), recipient=request.account_id, sender='team@reboot.dev', @@ -117,12 +117,12 @@ async def sign_up( text=self._text_email, ) - account, _ = await Account.factory.open(context, request.account_id) + account, _ = await Account.factory().open(context, request.account_id) await account.deposit(context, amount=request.initial_deposit) return SignUpResponse() ``` -`mailgun.Message.factory.send` is a `Writer` on an in-system mailgun +`mailgun.Message.factory().send` is a `Writer` on an in-system mailgun actor — it does not hit the network itself; it **schedules a workflow** that makes the actual HTTP send. So the transaction only ever issues in-system RPCs, and the un-rollback-able external call lives safely in @@ -176,7 +176,7 @@ orchestration calls where the caller only needs success/failure - `rpc-forall.md` — `Service.forall(ids).method(context, ...)` for fan-out across many actors. - `servicer-constructor.md` — when a transaction also constructs an - actor (e.g. `Account.factory.open(context, id)`). + actor (e.g. `Account.factory().open(context, id)`). - `api-errors.md` — typed errors that roll back the entire transaction. - `servicer-workflow.md` — when one-shot atomicity isn't enough and you need durable, long-running orchestration. diff --git a/reboot/plugin/skills/python/references/state-actor-decomposition.md b/reboot/plugin/skills/python/references/state-actor-decomposition.md index 7dab15326..5603a84ed 100644 --- a/reboot/plugin/skills/python/references/state-actor-decomposition.md +++ b/reboot/plugin/skills/python/references/state-actor-decomposition.md @@ -111,9 +111,9 @@ class UserServicer(User.Servicer): ) -> None: if context.constructor: self.state.display_name = request.display_name - session, _ = await TelegramSession.factory.create(context) + session, _ = await TelegramSession.factory().create(context) self.state.telegram_session_id = session.state_id - manager, _ = await MonitoringManager.factory.create(context) + manager, _ = await MonitoringManager.factory().create(context) self.state.monitoring_manager_id = manager.state_id ``` diff --git a/reboot/plugin/skills/python/references/state-collections.md b/reboot/plugin/skills/python/references/state-collections.md index 4e95fa79c..5dbf61022 100644 --- a/reboot/plugin/skills/python/references/state-collections.md +++ b/reboot/plugin/skills/python/references/state-collections.md @@ -210,7 +210,7 @@ class UserServicer(User.Servicer): request: User.AddPersonRequest, ) -> User.AddPersonResponse: # `Person` is its own state Type with `factory=True` `create`. - person, _ = await Person.factory.create( + person, _ = await Person.factory().create( context, name=request.name, birthday=request.birthday, diff --git a/reboot/plugin/skills/python/references/state-scalar-fields.md b/reboot/plugin/skills/python/references/state-scalar-fields.md index 8b0e8213b..44894c138 100644 --- a/reboot/plugin/skills/python/references/state-scalar-fields.md +++ b/reboot/plugin/skills/python/references/state-scalar-fields.md @@ -125,7 +125,7 @@ class IntegrationState(Model): ``` ```python -ciphertext, _ = await Ciphertext.factory.encrypt( +ciphertext, _ = await Ciphertext.factory().encrypt( context, plaintext=raw_api_key.encode(), associated_data=make_associated_data(tenant_id=tenant_id, purpose="api-key"), diff --git a/reboot/plugin/skills/python/references/stdlib-ciphertext.md b/reboot/plugin/skills/python/references/stdlib-ciphertext.md index 0a15de060..6e9b6f8ae 100644 --- a/reboot/plugin/skills/python/references/stdlib-ciphertext.md +++ b/reboot/plugin/skills/python/references/stdlib-ciphertext.md @@ -61,13 +61,13 @@ async def main(): ### Methods -| Call | Type | Notes | -| ------------------------------------------------------------------------------------------------- | ------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | -| `Ciphertext.factory.encrypt(context, [id], *, plaintext, associated_data, scope, key_manager_id)` | transaction (constructor) | `key_manager_id` is **required** (pass `APP_SHARED_KEY_MANAGER_ID`); returns `(ref, EncryptResponse)`; omit `id` to auto-generate one and read it back as `ref.state_id` | -| `Ciphertext.ref(id).decrypt(context, *, associated_data)` | reader | `-> DecryptResponse(plaintext)`. Raises `DecryptAborted` | -| `Ciphertext.ref(id).rescope(context, *, scope)` | transaction | move a ciphertext to a different scope (same manager); only the wrapped DEK changes | -| `KeyManager.ref(APP_SHARED_KEY_MANAGER_ID).shred(context, *, scope)` | transaction | crypto-shred a scope — idempotent | -| `KeyManager.ref(APP_SHARED_KEY_MANAGER_ID).status(context)` | reader | `-> StatusResponse(active_version, rotating)`; poll to confirm a rotation finished (`active_version` reached and `rotating` is false) | +| Call | Type | Notes | +| --------------------------------------------------------------------------------------------------- | ------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | +| `Ciphertext.factory().encrypt(context, [id], *, plaintext, associated_data, scope, key_manager_id)` | transaction (constructor) | `key_manager_id` is **required** (pass `APP_SHARED_KEY_MANAGER_ID`); returns `(ref, EncryptResponse)`; omit `id` to auto-generate one and read it back as `ref.state_id` | +| `Ciphertext.ref(id).decrypt(context, *, associated_data)` | reader | `-> DecryptResponse(plaintext)`. Raises `DecryptAborted` | +| `Ciphertext.ref(id).rescope(context, *, scope)` | transaction | move a ciphertext to a different scope (same manager); only the wrapped DEK changes | +| `KeyManager.ref(APP_SHARED_KEY_MANAGER_ID).shred(context, *, scope)` | transaction | crypto-shred a scope — idempotent | +| `KeyManager.ref(APP_SHARED_KEY_MANAGER_ID).status(context)` | reader | `-> StatusResponse(active_version, rotating)`; poll to confirm a rotation finished (`active_version` reached and `rotating` is false) | Imports: @@ -84,7 +84,7 @@ from reboot.std.ciphertext.v1.ciphertext import ( ### Encrypt ```python -ciphertext, _ = await Ciphertext.factory.encrypt( +ciphertext, _ = await Ciphertext.factory().encrypt( context, plaintext=b"123-45-6789", associated_data=make_associated_data(user_id="42", purpose="ssn"), diff --git a/reboot/plugin/skills/python/references/stdlib-presence.md b/reboot/plugin/skills/python/references/stdlib-presence.md index 7058dca7e..fb7c1bff2 100644 --- a/reboot/plugin/skills/python/references/stdlib-presence.md +++ b/reboot/plugin/skills/python/references/stdlib-presence.md @@ -71,7 +71,7 @@ async def main(): The intended dance, per the type's docs: -1. Client `Subscriber.factory.create(context, subscriber_id)` — once. +1. Client `Subscriber.factory().create(context, subscriber_id)` — once. 2. Client opens a long-lived `Subscriber.ref(id).connect(context)` reader RPC; this stays open as long as the client is connected. 3. Client `Subscriber.ref(id).toggle(context)` to mark itself as live; diff --git a/reboot/plugin/skills/python/references/testing-harness.md b/reboot/plugin/skills/python/references/testing-harness.md index eb0855280..dc3b0b460 100644 --- a/reboot/plugin/skills/python/references/testing-harness.md +++ b/reboot/plugin/skills/python/references/testing-harness.md @@ -109,7 +109,7 @@ Things to know: ```python async def _initialize(context) -> None: - await CouponBook.factory.create(context, COUPON_BOOK_ID) + await CouponBook.factory().create(context, COUPON_BOOK_ID) await self.rbt.up( Application( diff --git a/reboot/plugin/skills/upgrade/migrations/next/factory-namespaced-constructors.md b/reboot/plugin/skills/upgrade/migrations/next/factory-namespaced-constructors.md index 946a3ea50..03694a67b 100644 --- a/reboot/plugin/skills/upgrade/migrations/next/factory-namespaced-constructors.md +++ b/reboot/plugin/skills/upgrade/migrations/next/factory-namespaced-constructors.md @@ -1,7 +1,7 @@ ## Constructors moved under a `factory` namespace Constructor (a.k.a. factory) methods are no longer exposed directly on -a state type. They now live under a `factory` namespace on the type, +a state type. They now live under a `factory()` namespace on the type, so the top-level namespace is free for framework methods like `ref()`. This only changes how constructors are **called** — the way you **declare** one (`factory=True` on a writer/transaction, or the @@ -9,18 +9,18 @@ This only changes how constructors are **called** — the way you For every call that invokes a constructor **directly on a state type** (i.e. on the class itself, not on a `.ref(...)` handle), insert -`.factory` between the type and the method: +`.factory()` between the type and the method: -- `await Foo.create(context, ...)` → `await Foo.factory.create(context, ...)` +- `await Foo.create(context, ...)` → `await Foo.factory().create(context, ...)` - Custom-named constructors too, e.g. `await Account.open(context, ...)` - → `await Account.factory.open(context, ...)`. -- Class-level idempotency-scoped construction moves under `factory` as - well: `Foo.idempotently(...)`, `Foo.per_workflow(...)`, + → `await Account.factory().open(context, ...)`. +- Class-level idempotency-scoped construction moves under `factory()` + as well: `Foo.idempotently(...)`, `Foo.per_workflow(...)`, `Foo.per_iteration(...)`, `Foo.always(...)` (TypeScript: `Foo.perWorkflow(...)`, `Foo.perIteration(...)`) when invoked on the - **class** to construct → `Foo.factory.idempotently(...)`, etc. So + **class** to construct → `Foo.factory().idempotently(...)`, etc. So `await Foo.idempotently("alias").create(context)` becomes - `await Foo.factory.idempotently("alias").create(context)`. + `await Foo.factory().idempotently("alias").create(context)`. How to find them: a method invoked directly on a state-type class is _necessarily_ a constructor — every other method requires a `.ref(...)` @@ -28,7 +28,7 @@ handle. So in `backend/` (Python and TypeScript), search for `.(` calls where `` is a generated state type imported from a `*_rbt`/`*_reboot` module and the call is made on the bare class (the first argument is a `context`). Rewrite each as -`.factory.(`. +`.factory().(`. Leave these unchanged: diff --git a/reboot/plugin/skills/web-app/SKILL.md b/reboot/plugin/skills/web-app/SKILL.md index 351d4888a..5d68250a7 100644 --- a/reboot/plugin/skills/web-app/SKILL.md +++ b/reboot/plugin/skills/web-app/SKILL.md @@ -249,7 +249,7 @@ exactly one of them — the step that needs it. `self.state_id`); `self.ref().schedule(...)`. - `python/references/rpc-calls.md` — kwargs, not Request wrappers. - `python/references/rpc-constructor-calls.md` — - `Service.factory.create(context, id)` semantics. + `Service.factory().create(context, id)` semantics. - `python/references/servicer-workflow.md` — only when you declared a `Workflow`, and then top to bottom: the `@classmethod` / `WorkflowContext` declaration shape, the call-classification diff --git a/reboot/std/oauth/v1/oauth.py b/reboot/std/oauth/v1/oauth.py index b5e9fde14..5b61ae3ba 100644 --- a/reboot/std/oauth/v1/oauth.py +++ b/reboot/std/oauth/v1/oauth.py @@ -117,7 +117,7 @@ async def store( # merge first — we can't read the index here, since this same # transaction writes it (Reboot forbids reading and writing the # same state in one transaction). - ciphertext, _ = await Ciphertext.factory.encrypt( + ciphertext, _ = await Ciphertext.factory().encrypt( context, plaintext=request.tokens.SerializeToString(), associated_data=_associated_data(service, request.user_id), diff --git a/reboot/templates/reboot.py.j2 b/reboot/templates/reboot.py.j2 index 330fc4f3c..c5bc57b35 100644 --- a/reboot/templates/reboot.py.j2 +++ b/reboot/templates/reboot.py.j2 @@ -3182,7 +3182,7 @@ class {{ state.proto.name }}BaseServicer(IMPORT_reboot_aio_servicers.Servicer): f"urn:dev.reboot:auto-construct:{{ state.proto.name }}:{state_id}", ) try: - await {{ state.proto.name }}.factory.idempotently( + await {{ state.proto.name }}.factory().idempotently( key=idempotency_key, ).{{ AUTO_CONSTRUCT_METHOD }}(context, state_id) except {{ state.proto.name }}.{{ AUTO_CONSTRUCT_PROTO_METHOD }}Aborted as aborted: @@ -7487,7 +7487,9 @@ class {{ client.proto.state_name }}: how=IMPORT_reboot_aio_idempotency.ALWAYS, ) - factory = _Factory + @classmethod + def factory(cls) -> type[{{ client.proto.state_name }}._Factory]: + return {{ client.proto.state_name }}._Factory @IMPORT_dataclasses.dataclass(frozen=True) class _ConstructIdempotently: @@ -7632,7 +7634,7 @@ class {{ client.proto.state_name }}: __this__._idempotency, ) - return await {{ client.proto.state_name }}.factory.{{ method.proto.name }}( + return await {{ client.proto.state_name }}.factory().{{ method.proto.name }}( *__args__, ) diff --git a/reboot/templates/reboot.ts.j2 b/reboot/templates/reboot.ts.j2 index c4fdb85af..f69ec71da 100644 --- a/reboot/templates/reboot.ts.j2 +++ b/reboot/templates/reboot.ts.j2 @@ -2273,7 +2273,7 @@ export class {{ client.proto.state_name }}Factory { options = partialRequestOrOptions; if (optionsOrUndefined !== undefined) { throw new Error( - `Invalid arguments passed to '{{ client.proto.state_name }}.factory.{{ method.proto.name | to_lower_camel }}'` + `Invalid arguments passed to '{{ client.proto.state_name }}.factory().{{ method.proto.name | to_lower_camel }}'` ); } } @@ -2282,8 +2282,8 @@ export class {{ client.proto.state_name }}Factory { if (context instanceof WorkflowContext) { return await ( reboot.isWithinLoop() - ? {{ client.proto.state_name }}.factory.perIteration() - : {{ client.proto.state_name }}.factory.perWorkflow() + ? {{ client.proto.state_name }}.factory().perIteration() + : {{ client.proto.state_name }}.factory().perWorkflow() ).{{ method.proto.name | to_lower_camel }}( context, idOrPartialRequest, @@ -2291,7 +2291,7 @@ export class {{ client.proto.state_name }}Factory { optionsOrUndefined ); } else if (context instanceof InitializeContext) { - return await {{ client.proto.state_name }}.factory.idempotently() + return await {{ client.proto.state_name }}.factory().idempotently() .{{ method.proto.name | to_lower_camel }}( context, idOrPartialRequest, @@ -2329,17 +2329,17 @@ export class {{ client.proto.state_name }}Factory { } static perWorkflow(alias?: string) { - return {{ client.proto.state_name }}.factory + return {{ client.proto.state_name }}.factory() .idempotently({ alias }); } static perIteration(alias?: string) { - return {{ client.proto.state_name }}.factory + return {{ client.proto.state_name }}.factory() .idempotently({ alias, perIteration: true }); } static always() { - return {{ client.proto.state_name }}.factory + return {{ client.proto.state_name }}.factory() .idempotently({ always: true }); } } @@ -2365,7 +2365,9 @@ export class {{ client.proto.state_name }} { {% endfor %} {% endfor %} - static factory = {{ client.proto.state_name }}Factory; + static factory() { + return {{ client.proto.state_name }}Factory; + } public static ref( idOrOptions?: string | { bearerToken?: string | null }, @@ -2528,7 +2530,7 @@ export class {{ client.proto.state_name }} { ) as string; } - return await {{ client.proto.state_name }}.factory.{{ method.proto.name | to_lower_camel }}( + return await {{ client.proto.state_name }}.factory().{{ method.proto.name | to_lower_camel }}( context, id, partialRequest, diff --git a/reboot/templates/reboot_web.ts.j2 b/reboot/templates/reboot_web.ts.j2 index 91ef19c55..e73f20227 100644 --- a/reboot/templates/reboot_web.ts.j2 +++ b/reboot/templates/reboot_web.ts.j2 @@ -656,7 +656,9 @@ export class {{ client.proto.state_name }} { static WeakReference = {{ client.proto.state_name }}WeakReference; - static factory = {{ client.proto.state_name }}Factory; + static factory() { + return {{ client.proto.state_name }}Factory; + } public static ref( id: string, diff --git a/tests/reboot/agents/pydantic_ai/agent_tests.py b/tests/reboot/agents/pydantic_ai/agent_tests.py index 771ff0baa..92afef517 100644 --- a/tests/reboot/agents/pydantic_ai/agent_tests.py +++ b/tests/reboot/agents/pydantic_ai/agent_tests.py @@ -569,7 +569,7 @@ async def asyncSetUp(self) -> None: ) self.context = self.rbt.create_external_context(name=self.id()) - self.general, _ = await General.factory.constructor_writer( + self.general, _ = await General.factory().constructor_writer( self.context ) diff --git a/tests/reboot/aio/internals/tasks_servicer_tests.py b/tests/reboot/aio/internals/tasks_servicer_tests.py index 5747a7fa1..d0ed993fe 100644 --- a/tests/reboot/aio/internals/tasks_servicer_tests.py +++ b/tests/reboot/aio/internals/tasks_servicer_tests.py @@ -624,7 +624,7 @@ async def workflow( context = self.rbt.create_external_context(name=self.id()) - general, _ = await General.factory.ConstructorWriter( + general, _ = await General.factory().ConstructorWriter( context, "scheduled-loop-test" ) task = await general.spawn().Workflow(context) @@ -715,7 +715,7 @@ async def workflow( context = self.rbt.create_external_context(name=self.id()) - general, _ = await General.factory.ConstructorWriter( + general, _ = await General.factory().ConstructorWriter( context, "test_iteration_count" ) task = await general.spawn().Workflow(context) diff --git a/tests/reboot/auth_bank_main.py b/tests/reboot/auth_bank_main.py index 5018df76d..8e54c667b 100644 --- a/tests/reboot/auth_bank_main.py +++ b/tests/reboot/auth_bank_main.py @@ -20,7 +20,7 @@ async def initialize(context: InitializeContext): """Create the singleton bank in our application.""" print("🏦🏦🏦 Creating Bank if it hasn't already been created.... 🏦🏦🏦") - await Bank.factory.Create(context, SINGLETON_BANK_ID) + await Bank.factory().Create(context, SINGLETON_BANK_ID) print("💰💰💰 Bank is ready for business! 💰💰💰") diff --git a/tests/reboot/auth_tests.py b/tests/reboot/auth_tests.py index f32969305..d8b04485e 100644 --- a/tests/reboot/auth_tests.py +++ b/tests/reboot/auth_tests.py @@ -160,7 +160,7 @@ async def asyncSetUp(self): bearer_token=VALID_JWT, ) - bank, _ = await Bank.factory.create(context, SINGLETON_BANK_ID) + bank, _ = await Bank.factory().create(context, SINGLETON_BANK_ID) await bank.sign_up(context, account_id=ACCOUNT_NAME) async def asyncTearDown(self): @@ -325,7 +325,7 @@ async def asyncSetUp(self): bearer_token=VALID_JWT, ) - bank, _ = await Bank.factory.create(context, SINGLETON_BANK_ID) + bank, _ = await Bank.factory().create(context, SINGLETON_BANK_ID) async def asyncTearDown(self): await self.rbt.stop() @@ -396,7 +396,7 @@ async def test_construct_auth(self): context = self.rbt.create_external_context(name=self.id()) # Test that a bearer token can be used via construct. - bank, _ = await Bank.factory.create( + bank, _ = await Bank.factory().create( context, SINGLETON_BANK_ID, Options(bearer_token=VALID_JWT), diff --git a/tests/reboot/bank.py b/tests/reboot/bank.py index 95e907610..f4e3ab628 100644 --- a/tests/reboot/bank.py +++ b/tests/reboot/bank.py @@ -202,7 +202,7 @@ async def test_nested_transaction_that_aborts( state.balance += 10 # We abort below so this call should also not take effect. - await Account.factory.open(context, f'{context.state_id}-nested') + await Account.factory().open(context, f'{context.state_id}-nested') raise Account.TestNestedTransactionThatAbortsAborted( bank_rbt.UserError() @@ -290,7 +290,7 @@ async def sign_up( # Since we may manually retry the following call, we must # provide idempotency, which we do via passing the string # alias 'open'. - await Account.factory.idempotently('open').open( + await Account.factory().idempotently('open').open( context, request.account_id, Options(bearer_token=context.caller_bearer_token), @@ -302,7 +302,7 @@ async def sign_up( # For testing purposes, call the 'open' method again - so that it's always # called twice, and idempotency is demonstrated. - account, _ = await Account.factory.idempotently('open').open( + account, _ = await Account.factory().idempotently('open').open( context, request.account_id, Options(bearer_token=context.caller_bearer_token), @@ -636,7 +636,7 @@ async def test_nested_transaction_that_aborts( else: raise RuntimeError('Expecting to abort!') - account, response = await Account.factory.open( + account, response = await Account.factory().open( context, f'{request.account_id}-parent', initial_deposit=42, @@ -651,7 +651,7 @@ async def test_inherited_ownership_abort( ) -> Empty: # We (the root transaction) first join the account by opening # it. - account, _ = await Account.factory.open( + account, _ = await Account.factory().open( context, request.account_id, initial_deposit=10, @@ -777,7 +777,7 @@ async def test_prepare_wait_for_nested_abort_rollback( ) -> Empty: # Open the remote account with a known balance so that the # nested transaction below shares (rather than constructs) it. - await Account.factory.open( + await Account.factory().open( context, request.remote_account_id, initial_deposit=100, @@ -858,13 +858,13 @@ async def test_nested_transactions( request.type == bank_rbt.TestNestedTransactionsRequest.NESTED_TXN_SAME_STATE ): - await Account.factory.open( + await Account.factory().open( context, 'jonathan-same-state', Options(bearer_token=context.caller_bearer_token), initial_deposit=2, ) - await Account.factory.open( + await Account.factory().open( context, 'ben-same-state', Options(bearer_token=context.caller_bearer_token), @@ -884,13 +884,13 @@ async def test_nested_transactions( request.type == bank_rbt.TestNestedTransactionsRequest.NESTED_TXN_PARENT_WRITER ): - jonathan, _ = await Account.factory.open( + jonathan, _ = await Account.factory().open( context, 'jonathan-parent-writer', Options(bearer_token=context.caller_bearer_token), initial_deposit=2, ) - await Account.factory.open( + await Account.factory().open( context, 'ben-parent-writer', Options(bearer_token=context.caller_bearer_token), @@ -910,13 +910,13 @@ async def test_nested_transactions( request.type == bank_rbt.TestNestedTransactionsRequest. NESTED_TXN_SHARED_WRITE_ABORT ): - await Account.factory.open( + await Account.factory().open( context, 'jonathan-shared-write-abort', Options(bearer_token=context.caller_bearer_token), initial_deposit=1, ) - await Account.factory.open( + await Account.factory().open( context, 'ben-shared-write-abort', Options(bearer_token=context.caller_bearer_token), diff --git a/tests/reboot/bank_main.py b/tests/reboot/bank_main.py index 8cfc1c926..3414ef93d 100644 --- a/tests/reboot/bank_main.py +++ b/tests/reboot/bank_main.py @@ -17,7 +17,7 @@ async def initialize(context: InitializeContext): """Create the singleton bank in our application.""" print("🏦🏦🏦 Creating Bank if it hasn't already been created.... 🏦🏦🏦") - await Bank.factory.Create(context, SINGLETON_BANK_ID) + await Bank.factory().Create(context, SINGLETON_BANK_ID) print("💰💰💰 Bank is ready for business! 💰💰💰") diff --git a/tests/reboot/benchmark.py b/tests/reboot/benchmark.py index e02079441..a20e1b68a 100644 --- a/tests/reboot/benchmark.py +++ b/tests/reboot/benchmark.py @@ -137,7 +137,7 @@ async def benchmark() -> None: state_ids = [str(state_id) for state_id in range(4096)] await asyncio.gather( *( - General.factory.ConstructorWriter(context, state_id) + General.factory().ConstructorWriter(context, state_id) for state_id in state_ids ) ) diff --git a/tests/reboot/cancellation_tests.py b/tests/reboot/cancellation_tests.py index 0ffe47cf2..dee46b041 100644 --- a/tests/reboot/cancellation_tests.py +++ b/tests/reboot/cancellation_tests.py @@ -88,7 +88,7 @@ async def ClientStreamingReader( context = self.rbt.create_external_context(name=self.id()) # Construct. - g, _ = await General.factory.ConstructorWriter(context) + g, _ = await General.factory().ConstructorWriter(context) # Start task to Reader to test the unary case. reader_task = asyncio.create_task(g.Reader(context)) diff --git a/tests/reboot/context_tests.py b/tests/reboot/context_tests.py index 4f6fcd7d7..4a48084aa 100644 --- a/tests/reboot/context_tests.py +++ b/tests/reboot/context_tests.py @@ -45,7 +45,7 @@ async def test_context_not_constructible_in_actor(self) -> None: context = self.rbt.create_external_context(name=self.id()) - greeter, response = await Greeter.factory.Create( + greeter, response = await Greeter.factory().Create( context, title='Dr', name='Jonathan', @@ -88,7 +88,7 @@ def fake_to_grpc_metadata(self): fake_to_grpc_metadata ): with self.assertRaises(Greeter.CreateAborted) as aborted: - await Greeter.factory.Create( + await Greeter.factory().Create( context, title='Dr', name='Jonathan', diff --git a/tests/reboot/documentation/backend/src/servicers/counter.py b/tests/reboot/documentation/backend/src/servicers/counter.py index 5211ad34e..c3ca36776 100644 --- a/tests/reboot/documentation/backend/src/servicers/counter.py +++ b/tests/reboot/documentation/backend/src/servicers/counter.py @@ -42,7 +42,7 @@ async def create_counter( request: CreateCounterRequest, ) -> CreateCounterResponse: """Create a new Counter and return its ID.""" - counter, _ = await Counter.factory.create( + counter, _ = await Counter.factory().create( context, description=request.description, owner_id=context.state_id, diff --git a/tests/reboot/documentation/task.py b/tests/reboot/documentation/task.py index 9fe154a10..ca9a3fe35 100644 --- a/tests/reboot/documentation/task.py +++ b/tests/reboot/documentation/task.py @@ -114,7 +114,7 @@ async def value_is_stored(): async def initialize(context: InitializeContext): - await TestTask.factory.create(context, "task") + await TestTask.factory().create(context, "task") # These tests are different from the other tests in this directory in that do not diff --git a/tests/reboot/documentation/task.ts b/tests/reboot/documentation/task.ts index 956c8ce27..b62a4ecf6 100644 --- a/tests/reboot/documentation/task.ts +++ b/tests/reboot/documentation/task.ts @@ -193,7 +193,7 @@ test("task", async (t) => { await t.test("create", async (t) => { const context = rbt.createExternalContext("test"); - const [task] = await TestTask.factory + const [task] = await TestTask.factory() .idempotently() .create(context, "task"); diff --git a/tests/reboot/documentation/test_http.py b/tests/reboot/documentation/test_http.py index 56d58a8bd..2bcfeadc9 100644 --- a/tests/reboot/documentation/test_http.py +++ b/tests/reboot/documentation/test_http.py @@ -22,7 +22,7 @@ async def hello_greeter( context: ExternalContext = InjectExternalContext, ): body = await request.json() - greeter, _ = await Greeter.factory.create( + greeter, _ = await Greeter.factory().create( context, title=body['title'], name=body['name'], diff --git a/tests/reboot/documentation/test_http.ts b/tests/reboot/documentation/test_http.ts index ba8e5db8d..43a9a9766 100644 --- a/tests/reboot/documentation/test_http.ts +++ b/tests/reboot/documentation/test_http.ts @@ -57,7 +57,7 @@ test("Tests for Reboot HTTP documentation", async (t) => { name: string; adjective: string; }; - const [greeter] = await Greeter.factory.create(context, { + const [greeter] = await Greeter.factory().create(context, { title, name, adjective, diff --git a/tests/reboot/documentation/transactions.ts b/tests/reboot/documentation/transactions.ts index 534225c58..3f2bc4eef 100644 --- a/tests/reboot/documentation/transactions.ts +++ b/tests/reboot/documentation/transactions.ts @@ -97,9 +97,9 @@ test("transactions", async (t) => { await t.test("transfer", async (t) => { const context = rbt.createExternalContext("test"); - const [bank] = await Bank.factory.create(context, "bank"); - const [fromAccount] = await Account.factory.open(context, "alice"); - const [toAccount] = await Account.factory.open(context, "bob"); + const [bank] = await Bank.factory().create(context, "bank"); + const [fromAccount] = await Account.factory().open(context, "alice"); + const [toAccount] = await Account.factory().open(context, "bob"); await fromAccount.deposit(context, { amount: 100 }); diff --git a/tests/reboot/echo_rbt.golden.py b/tests/reboot/echo_rbt.golden.py index 0b61381e3..421585b68 100755 --- a/tests/reboot/echo_rbt.golden.py +++ b/tests/reboot/echo_rbt.golden.py @@ -29233,7 +29233,9 @@ def always(cls): how=IMPORT_reboot_aio_idempotency.ALWAYS, ) - factory = _Factory + @classmethod + def factory(cls) -> type[Echo._Factory]: + return Echo._Factory @IMPORT_dataclasses.dataclass(frozen=True) class _ConstructIdempotently: diff --git a/tests/reboot/effect_validation_tests.py b/tests/reboot/effect_validation_tests.py index 06013c62d..94f842540 100644 --- a/tests/reboot/effect_validation_tests.py +++ b/tests/reboot/effect_validation_tests.py @@ -191,7 +191,7 @@ async def create( self, effect_validation: EffectValidation ) -> tuple[General.WeakReference, ExternalContext]: context = await self.up(effect_validation) - general, _ = await General.factory.ConstructorWriter(context) + general, _ = await General.factory().ConstructorWriter(context) return general, context async def test_disabled(self) -> None: @@ -237,7 +237,7 @@ async def test_constructor_writer(self) -> None: async def test_constructor_transaction(self) -> None: context = await self.up(EffectValidation.ENABLED) - general, _ = await General.factory.ConstructorTransaction(context) + general, _ = await General.factory().ConstructorTransaction(context) self.assert_effects( "constructor_transaction", "constructor_transaction" ) @@ -371,7 +371,7 @@ async def test_at_least_once_per_call_effect_validation_disabled( effect_validation=EffectValidation.ENABLED, ) context = self.rbt.create_external_context(name=self.id()) - general, _ = await General.factory.ConstructorWriter(context) + general, _ = await General.factory().ConstructorWriter(context) await (await general.spawn().Workflow(context)) self.assertEqual(1, _DIRECT_CALLS) @@ -394,7 +394,7 @@ async def test_trusted_servicer_skips_reruns_for_app_developer( with mock.patch.dict(os.environ): os.environ.pop('RBT_VALIDATE_TRUSTED_EFFECTS', None) context = await self.up_trusted(EffectValidation.ENABLED) - await TrustedLibrary.factory.ConstructorWriter(context) + await TrustedLibrary.factory().ConstructorWriter(context) self.assert_effects("ConstructorWriter") @@ -408,7 +408,7 @@ async def test_trusted_servicer_reruns_when_validation_requested( os.environ, {'RBT_VALIDATE_TRUSTED_EFFECTS': 'true'} ): context = await self.up_trusted(EffectValidation.ENABLED) - await TrustedLibrary.factory.ConstructorWriter(context) + await TrustedLibrary.factory().ConstructorWriter(context) self.assert_effects("ConstructorWriter", "ConstructorWriter") diff --git a/tests/reboot/errors_tests.py b/tests/reboot/errors_tests.py index d47c9fd6f..06b854d25 100644 --- a/tests/reboot/errors_tests.py +++ b/tests/reboot/errors_tests.py @@ -28,7 +28,7 @@ async def test_declared_error(self) -> None: context = self.rbt.create_external_context(name=self.id()) - account, _ = await Account.factory.Open(context) + account, _ = await Account.factory().Open(context) await account.Deposit(context, amount=100) @@ -50,7 +50,7 @@ async def test_declared_errors_propagate(self) -> None: context = self.rbt.create_external_context(name=self.id()) - bank, _ = await Bank.factory.Create(context, SINGLETON_BANK_ID) + bank, _ = await Bank.factory().Create(context, SINGLETON_BANK_ID) await bank.SignUp(context, account_id='jonathan', initial_deposit=100) await bank.SignUp(context, account_id='morten') @@ -77,7 +77,7 @@ async def test_undeclared_error(self) -> None: context = self.rbt.create_external_context(name=self.id()) - bank, _ = await Bank.factory.Create(context, SINGLETON_BANK_ID) + bank, _ = await Bank.factory().Create(context, SINGLETON_BANK_ID) await bank.SignUp(context, account_id='jonathan') @@ -99,7 +99,7 @@ async def test_undeclared_errors_propagate(self) -> None: context = self.rbt.create_external_context(name=self.id()) - bank, _ = await Bank.factory.Create(context, SINGLETON_BANK_ID) + bank, _ = await Bank.factory().Create(context, SINGLETON_BANK_ID) with self.assertRaises(Bank.SignUpAborted) as aborted: await bank.SignUp( @@ -123,7 +123,7 @@ async def test_unavailable_errors_propagate(self) -> None: context = self.rbt.create_external_context(name=self.id()) - bank, _ = await Bank.factory.Create(context, SINGLETON_BANK_ID) + bank, _ = await Bank.factory().Create(context, SINGLETON_BANK_ID) await bank.SignUp(context, account_id='jonathan') account = Account.ref('jonathan') @@ -198,7 +198,7 @@ async def test_external_context_mixing_error(self) -> None: name=self.id() + "2" ) - account, _ = await Account.factory.Open(context1) + account, _ = await Account.factory().Open(context1) with self.assertRaises(MixedContextsError) as error: await account.Deposit(context2, amount=200) diff --git a/tests/reboot/external_context_tests.py b/tests/reboot/external_context_tests.py index dec1d9f0a..707e6f3aa 100644 --- a/tests/reboot/external_context_tests.py +++ b/tests/reboot/external_context_tests.py @@ -296,7 +296,7 @@ async def _test_keepalive_and_retry( url=proxied_url, name="test_keepalive_and_retry_unary_reader", ) - general, _ = await General.factory.ConstructorWriter(context) + general, _ = await General.factory().ConstructorWriter(context) call_task: asyncio.Task[None] = asyncio.create_task( make_call(context, general) diff --git a/tests/reboot/greeter_rbt.golden.js b/tests/reboot/greeter_rbt.golden.js index 3dec10fbe..c2f9d9389 100755 --- a/tests/reboot/greeter_rbt.golden.js +++ b/tests/reboot/greeter_rbt.golden.js @@ -5320,17 +5320,17 @@ export class GreeterFactory { partialRequest = idOrPartialRequest; options = partialRequestOrOptions; if (optionsOrUndefined !== undefined) { - throw new Error(`Invalid arguments passed to 'Greeter.factory.create'`); + throw new Error(`Invalid arguments passed to 'Greeter.factory().create'`); } } if (options === undefined || !("idempotency" in options)) { if (context instanceof WorkflowContext) { return await (reboot.isWithinLoop() - ? Greeter.factory.perIteration() - : Greeter.factory.perWorkflow()).create(context, idOrPartialRequest, partialRequestOrOptions, optionsOrUndefined); + ? Greeter.factory().perIteration() + : Greeter.factory().perWorkflow()).create(context, idOrPartialRequest, partialRequestOrOptions, optionsOrUndefined); } else if (context instanceof InitializeContext) { - return await Greeter.factory.idempotently() + return await Greeter.factory().idempotently() .create(context, idOrPartialRequest, partialRequestOrOptions, optionsOrUndefined); } } @@ -5349,19 +5349,22 @@ export class GreeterFactory { return new Greeter._ConstructIdempotently(idempotency); } static perWorkflow(alias) { - return Greeter.factory + return Greeter.factory() .idempotently({ alias }); } static perIteration(alias) { - return Greeter.factory + return Greeter.factory() .idempotently({ alias, perIteration: true }); } static always() { - return Greeter.factory + return Greeter.factory() .idempotently({ always: true }); } } export class Greeter { + static factory() { + return GreeterFactory; + } static ref(idOrOptions, options) { if (idOrOptions === undefined || typeof idOrOptions === "object") { const context = reboot.getContext(); @@ -5426,7 +5429,6 @@ Greeter.ReadRecursiveMessageAborted = GreeterReadRecursiveMessageAborted; Greeter.ReadRecursiveMessageTask = GreeterReadRecursiveMessageTask; Greeter.ConstructAndStoreRecursiveMessageAborted = GreeterConstructAndStoreRecursiveMessageAborted; Greeter.ConstructAndStoreRecursiveMessageTask = GreeterConstructAndStoreRecursiveMessageTask; -Greeter.factory = GreeterFactory; Greeter._Forall = (_h = class { constructor(ids) { _ids.set(this, void 0); @@ -5501,7 +5503,7 @@ Greeter._ConstructIdempotently = (_j = class { if (id === undefined) { id = await context.generateIdempotentStateId("tests.reboot.Greeter", "tests.reboot.GreeterMethods", "Create", __classPrivateFieldGet(this, _idempotency_1, "f")); } - return await Greeter.factory.create(context, id, partialRequest, { + return await Greeter.factory().create(context, id, partialRequest, { ...options, idempotency: __classPrivateFieldGet(this, _idempotency_1, "f"), }); @@ -5512,6 +5514,6 @@ Greeter._ConstructIdempotently = (_j = class { export function importPys() { reboot_native.importPy("tests.reboot.greeter_pb2", "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"); reboot_native.importPy("tests.reboot.greeter_pb2_grpc", "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"); - reboot_native.importPy("tests.reboot.greeter_rbt", "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"); + reboot_native.importPy("tests.reboot.greeter_rbt", "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"); } importPys(); diff --git a/tests/reboot/greeter_rbt.golden.py b/tests/reboot/greeter_rbt.golden.py index 6e78248d3..f51dfb1b3 100755 --- a/tests/reboot/greeter_rbt.golden.py +++ b/tests/reboot/greeter_rbt.golden.py @@ -32421,7 +32421,9 @@ def always(cls): how=IMPORT_reboot_aio_idempotency.ALWAYS, ) - factory = _Factory + @classmethod + def factory(cls) -> type[Greeter._Factory]: + return Greeter._Factory @IMPORT_dataclasses.dataclass(frozen=True) class _ConstructIdempotently: @@ -32526,7 +32528,7 @@ async def Create( # type: ignore[misc] __this__._idempotency, ) - return await Greeter.factory.Create( + return await Greeter.factory().Create( *__args__, ) diff --git a/tests/reboot/greeter_rbt_web.golden.js b/tests/reboot/greeter_rbt_web.golden.js index cd57a6967..e5306a33f 100755 --- a/tests/reboot/greeter_rbt_web.golden.js +++ b/tests/reboot/greeter_rbt_web.golden.js @@ -2330,9 +2330,11 @@ export class GreeterFactory { } } export class Greeter { + static factory() { + return GreeterFactory; + } static ref(id, options) { return new Greeter.WeakReference(id, options === null || options === void 0 ? void 0 : options.bearerToken); } } Greeter.WeakReference = GreeterWeakReference; -Greeter.factory = GreeterFactory; diff --git a/tests/reboot/idempotency_seeds_tests.py b/tests/reboot/idempotency_seeds_tests.py index 7af18f855..5cdb0b2b4 100644 --- a/tests/reboot/idempotency_seeds_tests.py +++ b/tests/reboot/idempotency_seeds_tests.py @@ -187,7 +187,7 @@ def test_idempotently_with_alias_under_same_seed_returns_same_uuid( def test_idempotent_state_id_is_seed_scoped(self) -> None: # `generate_idempotent_state_id` derives a state ID from # `(seed, alias)`, used by constructors like - # `Counter.factory.idempotently("create").create(context)` to + # `Counter.factory().idempotently("create").create(context)` to # pick a deterministic ID for the new state. It must fold in the # active idempotency seeds for consistency with # `idempotently()`'s seed-aware idempotency key, otherwise the diff --git a/tests/reboot/idempotency_tests.py b/tests/reboot/idempotency_tests.py index bbacb5e36..9adc07712 100644 --- a/tests/reboot/idempotency_tests.py +++ b/tests/reboot/idempotency_tests.py @@ -29,7 +29,7 @@ async def test_exactly_one_idempotency_argument(self) -> None: context = self.rbt.create_external_context(name=self.id()) with self.assertRaises(ValueError) as exc: - await Account.factory.idempotently( + await Account.factory().idempotently( key="key", alias="alias", # type: ignore[call-overload] ).Open(context, "one") @@ -53,7 +53,7 @@ async def _test_writers_are_idempotent( context = self.rbt.create_external_context(name=self.id()) - account, _ = await Account.factory.Open(context) + account, _ = await Account.factory().Open(context) await account.Deposit(context, amount=1000) @@ -108,7 +108,7 @@ async def test_expiring_idempotency_key(self) -> None: context = self.rbt.create_external_context(name=self.id()) - account, _ = await Account.factory.Open(context) + account, _ = await Account.factory().Open(context) await account.Deposit(context, amount=1000) @@ -146,7 +146,7 @@ async def _test_transactions_are_idempotent( context = self.rbt.create_external_context(name=self.id()) - bank, _ = await Bank.factory.Create(context, SINGLETON_BANK_ID) + bank, _ = await Bank.factory().Create(context, SINGLETON_BANK_ID) await bank.idempotently(*args, **kwargs).SignUp( context, @@ -205,7 +205,7 @@ async def test_idempotency_request_violation(self) -> None: context = self.rbt.create_external_context(name=self.id()) - account, _ = await Account.factory.idempotently( + account, _ = await Account.factory().idempotently( 'Open', ).Open(context, 'test-1234') @@ -236,7 +236,7 @@ async def test_idempotency_metadata_violation(self) -> None: context = self.rbt.create_external_context(name=self.id()) - account, _ = await Account.factory.idempotently( + account, _ = await Account.factory().idempotently( 'Open', ).Open( context, @@ -247,7 +247,7 @@ async def test_idempotency_metadata_violation(self) -> None: # Using the same idempotency alias but for different metadata # should fail. with self.assertRaises(ValueError) as error: - await Account.factory.idempotently('Open').Open( + await Account.factory().idempotently('Open').Open( context, 'test-1234', Options(metadata=(('x-reboot-some-key', '41'),)), @@ -267,14 +267,14 @@ async def test_idempotency_generate_violation(self) -> None: context = self.rbt.create_external_context(name=self.id()) - account, _ = await Account.factory.idempotently().Open( + account, _ = await Account.factory().idempotently().Open( context, 'test-1234' ) # Doing another call should fail, regardless of if it has # different arguments, metadata, etc. with self.assertRaises(ValueError) as error: - await Account.factory.idempotently().Open( + await Account.factory().idempotently().Open( context, 'test-1234', Options(metadata=(('x-reboot-some-key', '41'),)), @@ -290,7 +290,7 @@ async def test_idempotency_generate_violation(self) -> None: async def test_idempotency_failed_mutation_violation(self) -> None: await self.rbt.up(Application(servicers=[AccountServicer])) context = self.rbt.create_external_context(name=self.id()) - account, _ = await Account.factory.Open(context, "foo") + account, _ = await Account.factory().Open(context, "foo") # A failed mutation that we can't be sure is due to an error # that came from the backend will make this idempotency @@ -329,13 +329,13 @@ async def test_constructors_are_idempotent(self) -> None: # First call: construct the account idempotently. state_id = 'idempotent-constructor-test' - account1, _ = await Account.factory.idempotently( + account1, _ = await Account.factory().idempotently( 'open account', ).Open(context, state_id) # Second call: exact same alias, context, and state ID. This # must succeed (not raise `StateAlreadyConstructed`). - account2, _ = await Account.factory.idempotently( + account2, _ = await Account.factory().idempotently( 'open account', ).Open(context, state_id) @@ -346,7 +346,7 @@ async def test_constructors_are_idempotent(self) -> None: # Verify that calling the constructor *without* idempotency on # the same state ID does raise `StateAlreadyConstructed`. with self.assertRaises(Account.OpenAborted) as aborted: - await Account.factory.Open(context, state_id) + await Account.factory().Open(context, state_id) self.assertEqual( type(aborted.exception.error), StateAlreadyConstructed @@ -366,7 +366,7 @@ async def test_non_constructor_transactions_are_idempotent( context = self.rbt.create_external_context(name=self.id()) - bank, _ = await Bank.factory.Create(context, SINGLETON_BANK_ID) + bank, _ = await Bank.factory().Create(context, SINGLETON_BANK_ID) # First call: sign up the account idempotently. await bank.idempotently('sign up jonathan').SignUp( @@ -396,7 +396,7 @@ async def create_or_assert(*, idempotency_seed: Optional[uuid.UUID]): name='create_or_assert', idempotency_seed=idempotency_seed, ) - account, _ = await Account.factory.idempotently().Open( + account, _ = await Account.factory().idempotently().Open( context, ) nonlocal created_id diff --git a/tests/reboot/invalid_header_tests.py b/tests/reboot/invalid_header_tests.py index 1f73bbfac..699bdb6b5 100644 --- a/tests/reboot/invalid_header_tests.py +++ b/tests/reboot/invalid_header_tests.py @@ -85,7 +85,7 @@ async def test_invalid_state_ref_type(self) -> None: context = ExternalContext(name='test', url='http://test') # Intentionally create a type error, as might happen when the user # doesn't use mypy. - await Greeter.factory.Create( + await Greeter.factory().Create( context, 123 ) # type: ignore[arg-type, call-overload] self.assertEqual( @@ -113,7 +113,7 @@ async def test_invalid_state_ref_value_non_ascii(self) -> None: # Constructor. with self.assertRaises(InvalidStateRefError) as e: context = ExternalContext(name='test', url='http://test') - await Greeter.factory.Create(context, '😾') + await Greeter.factory().Create(context, '😾') self.assertEqual( str(e.exception), "The 'state_id' option must be an ASCII string; the given value " @@ -137,7 +137,7 @@ async def test_invalid_state_ref_value_too_short(self) -> None: # Constructor. with self.assertRaises(InvalidStateRefError) as e: context = ExternalContext(name='test', url='http://test') - await Greeter.factory.Create(context, '') + await Greeter.factory().Create(context, '') self.assertEqual( str(e.exception), "The 'state_id' option must be at least 1 character(s) long; the " @@ -161,7 +161,7 @@ async def test_invalid_state_ref_value_too_long(self) -> None: # Constructor. with self.assertRaises(InvalidStateRefError) as e: context = ExternalContext(name='test', url='http://test') - await Greeter.factory.Create(context, 'x' * 129) + await Greeter.factory().Create(context, 'x' * 129) self.assertEqual( str(e.exception), "The 'state_id' option must be at most 128 characters long; the " @@ -192,7 +192,7 @@ async def test_invalid_state_ref_value_invalid_char(self) -> None: # Constructor. with self.assertRaises(InvalidStateRefError) as e: context = ExternalContext(name='test', url='http://test') - await Greeter.factory.Create(context, 'hello \x00?') + await Greeter.factory().Create(context, 'hello \x00?') self.assertEqual( str(e.exception), "The 'state_id' option contained illegal characters: ['\\x00']. " @@ -205,7 +205,7 @@ async def test_invalid_bearer_token_type(self) -> None: header serialization, so that the user gets a friendlier stack trace. """ with self.assertRaises(TypeError) as e: - await Greeter.factory.Create( + await Greeter.factory().Create( ExternalContext(name='test', url='http://test'), # Intentionally create a type error, as might happen when the user # doesn't use mypy. @@ -222,7 +222,7 @@ async def test_invalid_bearer_token_value(self) -> None: header serialization, so that the user gets a friendlier stack trace. """ with self.assertRaises(InvalidBearerTokenError) as e: - await Greeter.factory.Create( + await Greeter.factory().Create( ExternalContext(name='test', url='http://test'), None, Options(bearer_token='😾'), @@ -234,7 +234,7 @@ async def test_invalid_bearer_token_value(self) -> None: ) with self.assertRaises(InvalidBearerTokenError) as e: - await Greeter.factory.Create( + await Greeter.factory().Create( ExternalContext(name='test', url='http://test'), None, Options(bearer_token='test\n'), @@ -246,7 +246,7 @@ async def test_invalid_bearer_token_value(self) -> None: ) with self.assertRaises(InvalidBearerTokenError) as e: - await Greeter.factory.Create( + await Greeter.factory().Create( ExternalContext(name='test', url='http://test'), None, Options(bearer_token='x' * 4097), @@ -264,7 +264,7 @@ async def test_invalid_idempotency_key_type(self) -> None: trace. """ with self.assertRaises(TypeError) as e: - await Greeter.factory.idempotently( + await Greeter.factory().idempotently( # Intentionally create a type error, as might happen # when the user doesn't use mypy. key=1337, # type: ignore[call-overload] @@ -283,7 +283,7 @@ async def test_invalid_idempotency_key_value(self) -> None: header serialization, so that the user gets a friendlier stack trace. """ with self.assertRaises(InvalidIdempotencyKeyError) as e: - await Greeter.factory.idempotently( + await Greeter.factory().idempotently( # Intentionally create a type error, as might happen # when the user doesn't use mypy. key='😾' # type: ignore[call-overload] @@ -300,7 +300,7 @@ async def test_invalid_idempotency_key_value(self) -> None: with self.assertRaises(InvalidIdempotencyKeyError) as e: # Intentionally create a type error, as might happen # when the user doesn't use mypy. - await Greeter.factory.idempotently( + await Greeter.factory().idempotently( key='x' * 129, ).Create( # type: ignore[call-overload] ExternalContext(name='test', url='http://test'), diff --git a/tests/reboot/nodejs/app_internal_test/test.ts b/tests/reboot/nodejs/app_internal_test/test.ts index 7db9933a5..271df35c3 100644 --- a/tests/reboot/nodejs/app_internal_test/test.ts +++ b/tests/reboot/nodejs/app_internal_test/test.ts @@ -59,7 +59,7 @@ test("app internal", async (t) => { const context = rbt.createExternalContext("test", { appInternal: true }); - await Greeter.factory.create(context, {}); + await Greeter.factory().create(context, {}); }); // Test that without a token verifier the authorizer and method both @@ -69,7 +69,7 @@ test("app internal", async (t) => { const context = rbt.createExternalContext("test", { appInternal: true }); - await Greeter.factory.create(context, {}); + await Greeter.factory().create(context, {}); }); // Test that _with_ a token verifier the authorizer and method both @@ -84,6 +84,6 @@ test("app internal", async (t) => { const context = rbt.createExternalContext("test", { appInternal: true }); - await Greeter.factory.create(context, {}); + await Greeter.factory().create(context, {}); }); }); diff --git a/tests/reboot/nodejs/auth_test/test.ts b/tests/reboot/nodejs/auth_test/test.ts index c3cce4e9a..31f6f1edf 100644 --- a/tests/reboot/nodejs/auth_test/test.ts +++ b/tests/reboot/nodejs/auth_test/test.ts @@ -114,7 +114,7 @@ test("auth", async (t) => { bearerToken: options?.bearerToken, }); try { - await Greeter.factory.create(context, options?.id); + await Greeter.factory().create(context, options?.id); assert(false, `Should not have successfully authed with ${options}`); } catch (e) { assert(e instanceof Greeter.CreateAborted, "not CreateAborted"); @@ -135,7 +135,7 @@ test("auth", async (t) => { const authedContext = rbt.createExternalContext("test", { bearerToken: TOKEN_FOR_TEST, }); - const [greeter] = await Greeter.factory.create(authedContext); + const [greeter] = await Greeter.factory().create(authedContext); // Confirm that our authorizer does not allow access to any other method // by default, since we have not overridden other methods. @@ -157,7 +157,7 @@ test("auth", async (t) => { await t.test("via construct and lookup", async (t) => { // Test that an authenticated construct succeeds. const context = rbt.createExternalContext("test"); - const [greeter] = await Greeter.factory.create( + const [greeter] = await Greeter.factory().create( context, { title: "Dr", diff --git a/tests/reboot/nodejs/greeter.ts b/tests/reboot/nodejs/greeter.ts index 1428a530e..d1d2e44ea 100644 --- a/tests/reboot/nodejs/greeter.ts +++ b/tests/reboot/nodejs/greeter.ts @@ -218,7 +218,7 @@ export class GreeterServicer extends Greeter.Servicer { // iteration via `.perIteration()` by default. // // Create the other `Greeter` once per workflow. - const [other] = await Greeter.factory.create(context, { + const [other] = await Greeter.factory().create(context, { title: "Dr", name: "Evil", adjective: "cunning", diff --git a/tests/reboot/nodejs/greeter_test/test.ts b/tests/reboot/nodejs/greeter_test/test.ts index 538d2cf6b..9bef79ca6 100644 --- a/tests/reboot/nodejs/greeter_test/test.ts +++ b/tests/reboot/nodejs/greeter_test/test.ts @@ -37,7 +37,7 @@ test("constructors and readers", async (t) => { }); // Test creating with ID. - await Greeter.factory.create(context, "other greeter", { + await Greeter.factory().create(context, "other greeter", { title: "Dr", name: "Jonathan", adjective: "Best", @@ -47,7 +47,7 @@ test("constructors and readers", async (t) => { // // Scoping here for snippet purposes. { - const [greeter, response] = await Greeter.factory.create(context, { + const [greeter, response] = await Greeter.factory().create(context, { title: "Dr", name: "Jonathan", adjective: "Best", @@ -55,31 +55,33 @@ test("constructors and readers", async (t) => { } // Test creating with generated ID idempotently. - await Greeter.factory.idempotently().create(context, { + await Greeter.factory().idempotently().create(context, { title: "Mr", name: "John", adjective: "Dangerous", }); - await Greeter.factory.idempotently("generated").create(context, { + await Greeter.factory().idempotently("generated").create(context, { title: "Mr", name: "John", adjective: "Dangerous", }); - await Greeter.factory.idempotently("create").create( - context, - "greeter", - // Pass a whole object to test that we can take an object as a request. - new CreateRequest({ - title: "Mr", - name: "John", - adjective: "Dangerous", - }) - ); + await Greeter.factory() + .idempotently("create") + .create( + context, + "greeter", + // Pass a whole object to test that we can take an object as a request. + new CreateRequest({ + title: "Mr", + name: "John", + adjective: "Dangerous", + }) + ); // Call `idempotently()` with explicit alias to test "alias or options". - const [greeter] = await Greeter.factory + const [greeter] = await Greeter.factory() .idempotently({ alias: "create" }) .create(context, "greeter", { title: "Mr", @@ -189,7 +191,7 @@ test("constructors and readers", async (t) => { idempotencySeed: uuid.v4(), }); - const [greeter] = await Greeter.factory.create(context, { + const [greeter] = await Greeter.factory().create(context, { title: "Dr", name: "Jonathan", adjective: "Best", @@ -231,7 +233,7 @@ test("constructors and readers", async (t) => { const context = rbt.createExternalContext("test"); - const [greeter] = await Greeter.factory.create(context, { + const [greeter] = await Greeter.factory().create(context, { title: "Dr", name: "Jonathan", adjective: "Best", @@ -260,7 +262,7 @@ test("constructors and readers", async (t) => { const context = rbt.createExternalContext("test"); - const [greeter] = await Greeter.factory.create(context, { + const [greeter] = await Greeter.factory().create(context, { title: "Dr", name: "Jonathan", adjective: "Best", @@ -278,13 +280,13 @@ test("constructors and readers", async (t) => { const context = rbt.createExternalContext("test"); // Creating some greeters. - await Greeter.factory.create(context, "greeter-1", { + await Greeter.factory().create(context, "greeter-1", { title: "Mr", name: "Heinz", adjective: "Erhardt", }); - await Greeter.factory.create(context, "greeter-2", { + await Greeter.factory().create(context, "greeter-2", { title: "Mrs", name: "Heidi", adjective: "Kabel", @@ -323,13 +325,13 @@ test("constructors and readers", async (t) => { const context = rbt.createExternalContext("test iterables"); - await Greeter.factory.create(context, "greeter-iter-1", { + await Greeter.factory().create(context, "greeter-iter-1", { title: "Mr", name: "Heinz", adjective: "Erhardt", }); - await Greeter.factory.create(context, "greeter-iter-2", { + await Greeter.factory().create(context, "greeter-iter-2", { title: "Mrs", name: "Heidi", adjective: "Kabel", diff --git a/tests/reboot/nodejs/reboot_down_test/test.ts b/tests/reboot/nodejs/reboot_down_test/test.ts index 34b334fd5..651382283 100644 --- a/tests/reboot/nodejs/reboot_down_test/test.ts +++ b/tests/reboot/nodejs/reboot_down_test/test.ts @@ -25,7 +25,7 @@ test("Reboot down test", async (t) => { idempotencySeed: uuid.v4(), }); - let [greeter, _] = await Greeter.factory.create(context, { + let [greeter, _] = await Greeter.factory().create(context, { title: "Dr", name: "Jonathan", adjective: "Best", diff --git a/tests/reboot/nodejs/reboot_test/test.ts b/tests/reboot/nodejs/reboot_test/test.ts index 825fbb43e..ad389ab10 100644 --- a/tests/reboot/nodejs/reboot_test/test.ts +++ b/tests/reboot/nodejs/reboot_test/test.ts @@ -52,7 +52,7 @@ test("Reboot", async (t) => { }); application.http.post("/hello_world", async (context, req, res) => { - const [greeter] = await Greeter.factory.create(context, { + const [greeter] = await Greeter.factory().create(context, { title: "Dr", name: "Jonathan", adjective: "Best", @@ -116,7 +116,7 @@ test("Reboot", async (t) => { const context = rbt.createExternalContext("test"); - const [greeter] = await Greeter.factory.create(context, { + const [greeter] = await Greeter.factory().create(context, { title: "Dr", name: "Jonathan", adjective: "Best", @@ -165,7 +165,7 @@ test("Reboot", async (t) => { const context = rbt.createExternalContext("test"); - const [greeter] = await Greeter.factory.create(context, { + const [greeter] = await Greeter.factory().create(context, { title: "Dr", name: "Jonathan", adjective: "Best", diff --git a/tests/reboot/nodejs/reboot_web_test/test.ts b/tests/reboot/nodejs/reboot_web_test/test.ts index 31c3eb034..864895d0a 100644 --- a/tests/reboot/nodejs/reboot_web_test/test.ts +++ b/tests/reboot/nodejs/reboot_web_test/test.ts @@ -50,7 +50,7 @@ test("Reboot", async (t) => { url: rbt.url(), }); - const [greeter] = await Greeter.factory.create(context, { + const [greeter] = await Greeter.factory().create(context, { title: "Dr", name: "Jonathan", adjective: "Best", @@ -85,7 +85,7 @@ test("Reboot", async (t) => { bearerToken: TOKEN_FOR_TEST, }); - const [greeter] = await Greeter.factory.create(context, { + const [greeter] = await Greeter.factory().create(context, { title: "Dr", name: "Jonathan", adjective: "Best", @@ -124,7 +124,7 @@ test("Reboot", async (t) => { bearerToken: asyncBearerToken, }); - const [greeter] = await Greeter.factory.create(context, { + const [greeter] = await Greeter.factory().create(context, { title: "Dr", name: "Jonathan", adjective: "Best", @@ -160,7 +160,7 @@ test("Reboot", async (t) => { url: rbt.url(), }); - const [greeter] = await Greeter.factory.create(context, { + const [greeter] = await Greeter.factory().create(context, { title: "Dr", name: "Jonathan", adjective: "Best", @@ -215,7 +215,7 @@ test("Reboot", async (t) => { url: rbt.url(), }); - const [greeter] = await Greeter.factory.create(context, "my-greeter", { + const [greeter] = await Greeter.factory().create(context, "my-greeter", { title: "Dr", name: "Jonathan", adjective: "Best", @@ -265,7 +265,7 @@ test("Reboot", async (t) => { url: rbt.url(), }); - const [greeter] = await Greeter.factory.create(context, { + const [greeter] = await Greeter.factory().create(context, { title: "Dr", name: "Jonathan", adjective: "Best", diff --git a/tests/reboot/nodejs/tasks_test/test.ts b/tests/reboot/nodejs/tasks_test/test.ts index 696b70199..f26f29de5 100644 --- a/tests/reboot/nodejs/tasks_test/test.ts +++ b/tests/reboot/nodejs/tasks_test/test.ts @@ -115,7 +115,7 @@ test("tasks", async (t) => { const context = rbt.createExternalContext("test"); - const [task, _] = await Task.factory.constructorTransaction(context); + const [task, _] = await Task.factory().constructorTransaction(context); // Test that we schedule a writer task and run it immediately. await task.transaction(context); @@ -152,7 +152,7 @@ test("tasks", async (t) => { const context = rbt.createExternalContext("test"); - const [task, _] = await Task.factory.constructorTransaction(context); + const [task, _] = await Task.factory().constructorTransaction(context); // Test that we schedule a transaction task and run it immediately. await task.transaction(context); @@ -189,7 +189,7 @@ test("tasks", async (t) => { const context = rbt.createExternalContext("test"); - const [task, _] = await Task.factory.constructorTransaction(context); + const [task, _] = await Task.factory().constructorTransaction(context); // Test that we schedule a workflow task and run it immediately. await task.transaction(context); diff --git a/tests/reboot/nodejs/yarn_zod_test/backend/src/bank.ts b/tests/reboot/nodejs/yarn_zod_test/backend/src/bank.ts index 097d7a300..b48470437 100644 --- a/tests/reboot/nodejs/yarn_zod_test/backend/src/bank.ts +++ b/tests/reboot/nodejs/yarn_zod_test/backend/src/bank.ts @@ -64,7 +64,7 @@ export const BankServicer = Bank.servicer({ state: Bank.State, { accountId, initialDeposit }: Bank.SignUpRequest ): Promise<[Bank.State]> => { - const [account] = await Account.factory.open(context, accountId, {}); + const [account] = await Account.factory().open(context, accountId, {}); await account.deposit(context, { amount: initialDeposit }); diff --git a/tests/reboot/nodejs/yarn_zod_test/backend/src/main.ts b/tests/reboot/nodejs/yarn_zod_test/backend/src/main.ts index 4f22272fe..6e5b84279 100644 --- a/tests/reboot/nodejs/yarn_zod_test/backend/src/main.ts +++ b/tests/reboot/nodejs/yarn_zod_test/backend/src/main.ts @@ -6,7 +6,7 @@ import { BankServicer } from "./bank.js"; const SINGLETON_BANK_ID = "reboot-bank"; const initialize = async (context) => { - await Bank.factory.create(context, SINGLETON_BANK_ID); + await Bank.factory().create(context, SINGLETON_BANK_ID); }; new Application({ diff --git a/tests/reboot/nodejs/yarn_zod_test/backend/tests/test.ts b/tests/reboot/nodejs/yarn_zod_test/backend/tests/test.ts index 7da4708a6..f1aadbe4f 100644 --- a/tests/reboot/nodejs/yarn_zod_test/backend/tests/test.ts +++ b/tests/reboot/nodejs/yarn_zod_test/backend/tests/test.ts @@ -32,7 +32,7 @@ test("Bank test", async (t) => { // Calling a constructor transaction method, which will call a // writer method from inside the transaction. - const [bank] = await Bank.factory.create(context); + const [bank] = await Bank.factory().create(context); // Calling a common transaction method, which will call a writer // method from inside the transaction. diff --git a/tests/reboot/ping/ping_test.py b/tests/reboot/ping/ping_test.py index d93915b01..2c8eba38f 100644 --- a/tests/reboot/ping/ping_test.py +++ b/tests/reboot/ping/ping_test.py @@ -68,7 +68,7 @@ async def test_counter(self): app_internal=True, ) - counter, _ = await Counter.factory.create( + counter, _ = await Counter.factory().create( context, description="test counter", owner_id="test-owner" ) diff --git a/tests/reboot/ping_api_rbt.golden.py b/tests/reboot/ping_api_rbt.golden.py index 3b49c1d94..8f3c4d06e 100755 --- a/tests/reboot/ping_api_rbt.golden.py +++ b/tests/reboot/ping_api_rbt.golden.py @@ -17811,7 +17811,7 @@ async def _authenticated( f"urn:dev.reboot:auto-construct:User:{state_id}", ) try: - await User.factory.idempotently( + await User.factory().idempotently( key=idempotency_key, ).create(context, state_id) except User.CreateAborted as aborted: @@ -23768,7 +23768,9 @@ def always(cls): how=IMPORT_reboot_aio_idempotency.ALWAYS, ) - factory = _Factory + @classmethod + def factory(cls) -> type[Ping._Factory]: + return Ping._Factory @IMPORT_dataclasses.dataclass(frozen=True) class _ConstructIdempotently: @@ -25671,7 +25673,9 @@ def always(cls): how=IMPORT_reboot_aio_idempotency.ALWAYS, ) - factory = _Factory + @classmethod + def factory(cls) -> type[Pong._Factory]: + return Pong._Factory @IMPORT_dataclasses.dataclass(frozen=True) class _ConstructIdempotently: @@ -29695,7 +29699,9 @@ def always(cls): how=IMPORT_reboot_aio_idempotency.ALWAYS, ) - factory = _Factory + @classmethod + def factory(cls) -> type[User._Factory]: + return User._Factory @IMPORT_dataclasses.dataclass(frozen=True) class _ConstructIdempotently: @@ -29729,7 +29735,7 @@ async def Create( # type: ignore[misc] __this__._idempotency, ) - return await User.factory.Create( + return await User.factory().Create( *__args__, ) @@ -32777,7 +32783,9 @@ def always(cls): how=IMPORT_reboot_aio_idempotency.ALWAYS, ) - factory = _Factory + @classmethod + def factory(cls) -> type[Counter._Factory]: + return Counter._Factory @IMPORT_dataclasses.dataclass(frozen=True) class _ConstructIdempotently: @@ -32877,7 +32885,7 @@ async def Create( # type: ignore[misc] __this__._idempotency, ) - return await Counter.factory.Create( + return await Counter.factory().Create( *__args__, ) diff --git a/tests/reboot/preload_tests.py b/tests/reboot/preload_tests.py index f6a7b3ecf..bb0c96757 100644 --- a/tests/reboot/preload_tests.py +++ b/tests/reboot/preload_tests.py @@ -27,7 +27,7 @@ async def test_preload_eliminates_load_actor_state_rpc(self) -> None: context = self.rbt.create_external_context(name=self.id()) - bank, _ = await Bank.factory.create(context, SINGLETON_BANK_ID) + bank, _ = await Bank.factory().create(context, SINGLETON_BANK_ID) await bank.sign_up( context, @@ -73,7 +73,7 @@ async def test_preload_eliminates_recover_idempotent_mutations_rpc( context = self.rbt.create_external_context(name=self.id()) - bank, _ = await Bank.factory.create(context, SINGLETON_BANK_ID) + bank, _ = await Bank.factory().create(context, SINGLETON_BANK_ID) await bank.sign_up( context, @@ -126,7 +126,7 @@ async def test_preload_failure_falls_back_to_own_rpcs(self) -> None: context = self.rbt.create_external_context(name=self.id()) - bank, _ = await Bank.factory.create(context, SINGLETON_BANK_ID) + bank, _ = await Bank.factory().create(context, SINGLETON_BANK_ID) await bank.sign_up( context, @@ -176,7 +176,7 @@ async def test_preload_is_noop_when_state_is_cached(self) -> None: context = self.rbt.create_external_context(name=self.id()) - bank, _ = await Bank.factory.create(context, SINGLETON_BANK_ID) + bank, _ = await Bank.factory().create(context, SINGLETON_BANK_ID) await bank.sign_up( context, @@ -219,7 +219,7 @@ async def test_preload_is_noop_when_idempotent_mutations_are_cached( context = self.rbt.create_external_context(name=self.id()) - bank, _ = await Bank.factory.create(context, SINGLETON_BANK_ID) + bank, _ = await Bank.factory().create(context, SINGLETON_BANK_ID) await bank.sign_up( context, diff --git a/tests/reboot/protoc_gen_reboot_tests.py b/tests/reboot/protoc_gen_reboot_tests.py index 66a356fc1..d4b46b425 100644 --- a/tests/reboot/protoc_gen_reboot_tests.py +++ b/tests/reboot/protoc_gen_reboot_tests.py @@ -119,7 +119,7 @@ def test_forbid_http_annotations(self) -> None: # Reboot services don't support (custom) HTTP annotations. # # Modify the descriptor set to form the basis for the test. In this - # case, add an HTTP annotation to the `Greeter.factory.Create()` + # case, add an HTTP annotation to the `Greeter.factory().Create()` # method. file = self.descriptor_set.file[-1] self.assertEqual(file.name, 'tests/reboot/greeter.proto') diff --git a/tests/reboot/pydantic/auto_construct_user/servicer.py b/tests/reboot/pydantic/auto_construct_user/servicer.py index f09830f0f..aa99fea76 100644 --- a/tests/reboot/pydantic/auto_construct_user/servicer.py +++ b/tests/reboot/pydantic/auto_construct_user/servicer.py @@ -23,7 +23,7 @@ async def create(self, context: TransactionContext) -> None: `Profile` for this user; a `Transaction` can call other state machines during construction.""" profile_id = f"profile-{context.state_id}" - await Profile.factory.create(context, profile_id) + await Profile.factory().create(context, profile_id) self.state.profile_id = profile_id async def set_claims( diff --git a/tests/reboot/pydantic/auto_construct_user/test.py b/tests/reboot/pydantic/auto_construct_user/test.py index a0cbac0c4..b6e4f4e77 100644 --- a/tests/reboot/pydantic/auto_construct_user/test.py +++ b/tests/reboot/pydantic/auto_construct_user/test.py @@ -167,8 +167,8 @@ async def test_authenticated_tolerates_preexisting_state(self) -> None: # already-constructed — and still deliver claims — rather # than aborting with `StateAlreadyConstructed`. user_id = "preexisting-user" - await User.factory.idempotently("explicit-construction" - ).create(self.internal, user_id) + await User.factory().idempotently("explicit-construction" + ).create(self.internal, user_id) await UserServicer._authenticated( self.internal, diff --git a/tests/reboot/pydantic/concurrent_transactions_same_state/test.py b/tests/reboot/pydantic/concurrent_transactions_same_state/test.py index 0d6ed3560..00c512b98 100644 --- a/tests/reboot/pydantic/concurrent_transactions_same_state/test.py +++ b/tests/reboot/pydantic/concurrent_transactions_same_state/test.py @@ -36,7 +36,7 @@ async def asyncSetUp(self) -> None: effect_validation=EffectValidation.DISABLED, ) self.context = self.rbt.create_external_context(name=self.id()) - await Counter.factory.create(self.context, COUNTER_ID) + await Counter.factory().create(self.context, COUNTER_ID) async def asyncTearDown(self) -> None: await self.rbt.stop() @@ -54,7 +54,7 @@ async def test_nested_transactions_on_one_state_are_parallel(self) -> None: driver_ids = [f"driver-{index}" for index in range(CONCURRENCY)] await asyncio.gather( *( - Counter.factory.create(self.context, driver_id) + Counter.factory().create(self.context, driver_id) for driver_id in driver_ids ) ) @@ -92,8 +92,8 @@ async def test_finishing_transaction_keeps_anothers_write(self) -> None: set up, step 3 writes into something nothing else reads, and the increment is lost with no error reported anywhere. """ - await Counter.factory.create(self.context, "writing-driver") - await Counter.factory.create(self.context, "touching-driver") + await Counter.factory().create(self.context, "writing-driver") + await Counter.factory().create(self.context, "touching-driver") parked_increment_is_participant.clear() parked_increment_may_write.clear() diff --git a/tests/reboot/pydantic/discriminated_union/test.py b/tests/reboot/pydantic/discriminated_union/test.py index 9467a528a..76a011007 100644 --- a/tests/reboot/pydantic/discriminated_union/test.py +++ b/tests/reboot/pydantic/discriminated_union/test.py @@ -42,7 +42,7 @@ async def test_discriminated_union_variant_a(self) -> None: context = self.rbt.create_external_context(name=self.id()) - test, _ = await DiscriminatedUnionTest.factory.initialize( + test, _ = await DiscriminatedUnionTest.factory().initialize( context, _TEST_STATE_ID, ) @@ -82,7 +82,7 @@ async def test_discriminated_union_variant_b(self) -> None: context = self.rbt.create_external_context(name=self.id()) - test, _ = await DiscriminatedUnionTest.factory.initialize( + test, _ = await DiscriminatedUnionTest.factory().initialize( context, _TEST_STATE_ID, ) @@ -114,7 +114,7 @@ async def test_switch_between_variants(self) -> None: context = self.rbt.create_external_context(name=self.id()) - test, _ = await DiscriminatedUnionTest.factory.initialize( + test, _ = await DiscriminatedUnionTest.factory().initialize( context, _TEST_STATE_ID, ) @@ -175,7 +175,7 @@ async def test_nested_discriminated_union_with_inner_x(self) -> None: context = self.rbt.create_external_context(name=self.id()) - test, _ = await NestedDiscriminatedUnionTest.factory.initialize( + test, _ = await NestedDiscriminatedUnionTest.factory().initialize( context, _TEST_STATE_ID, ) @@ -215,7 +215,7 @@ async def test_nested_discriminated_union_with_inner_y(self) -> None: context = self.rbt.create_external_context(name=self.id()) - test, _ = await NestedDiscriminatedUnionTest.factory.initialize( + test, _ = await NestedDiscriminatedUnionTest.factory().initialize( context, _TEST_STATE_ID, ) @@ -248,7 +248,7 @@ async def test_switch_between_nested_and_simple_variants(self) -> None: context = self.rbt.create_external_context(name=self.id()) - test, _ = await NestedDiscriminatedUnionTest.factory.initialize( + test, _ = await NestedDiscriminatedUnionTest.factory().initialize( context, _TEST_STATE_ID, ) diff --git a/tests/reboot/pydantic/methods/servicer.py b/tests/reboot/pydantic/methods/servicer.py index e56c2419c..77a4e5fad 100644 --- a/tests/reboot/pydantic/methods/servicer.py +++ b/tests/reboot/pydantic/methods/servicer.py @@ -284,7 +284,7 @@ async def workflow( STR_VALUE = "initialized from workflow" STR_VALUE_WITH_STATE_ID = "initialized from workflow with state id" MY_STATE_ID = "my-state-id" - test_ref, _ = await Test.factory.initialize_from_workflow( + test_ref, _ = await Test.factory().initialize_from_workflow( context, str_value=STR_VALUE, ) @@ -292,10 +292,12 @@ async def workflow( assert (test_ref_state.snapshot.current_str == STR_VALUE) assert test_ref.state_id != MY_STATE_ID - test_ref_with_state_id, _ = await Test.factory.initialize_from_workflow( - context, - MY_STATE_ID, - str_value=STR_VALUE_WITH_STATE_ID, + test_ref_with_state_id, _ = ( + await Test.factory().initialize_from_workflow( + context, + MY_STATE_ID, + str_value=STR_VALUE_WITH_STATE_ID, + ) ) test_ref_with_state_id_state = await test_ref_with_state_id.get_snapshot( context diff --git a/tests/reboot/pydantic/methods/test.py b/tests/reboot/pydantic/methods/test.py index 0eea5b771..2d63dcf5c 100644 --- a/tests/reboot/pydantic/methods/test.py +++ b/tests/reboot/pydantic/methods/test.py @@ -42,7 +42,7 @@ async def initialize(context: InitializeContext) -> None: STR_VALUE = "initialized from workflow" STR_VALUE_WITH_STATE_ID = "initialized from workflow with state id" - test_ref, _ = await Test.factory.initialize_from_workflow( + test_ref, _ = await Test.factory().initialize_from_workflow( context, str_value=STR_VALUE, ) @@ -56,10 +56,12 @@ async def initialize(context: InitializeContext) -> None: MY_STATE_ID, ) - test_ref_with_state_id, _ = await Test.factory.initialize_from_workflow( - context, - MY_STATE_ID, - str_value=STR_VALUE_WITH_STATE_ID, + test_ref_with_state_id, _ = ( + await Test.factory().initialize_from_workflow( + context, + MY_STATE_ID, + str_value=STR_VALUE_WITH_STATE_ID, + ) ) test_ref_with_state_id_state = await test_ref_with_state_id.get_snapshot( context @@ -83,7 +85,7 @@ async def initialize(context: InitializeContext) -> None: context = self.rbt.create_external_context(name=self.id()) - test, response = await Test.factory.initialize( + test, response = await Test.factory().initialize( context, _TEST_STATE_ID, ) @@ -111,7 +113,7 @@ async def test_writer(self) -> None: context = self.rbt.create_external_context(name=self.id()) - test, _ = await Test.factory.initialize( + test, _ = await Test.factory().initialize( context, _TEST_STATE_ID, ) @@ -186,7 +188,7 @@ async def test_reader(self) -> None: context = self.rbt.create_external_context(name=self.id()) - test, _ = await Test.factory.initialize( + test, _ = await Test.factory().initialize( context, _TEST_STATE_ID, ) @@ -253,14 +255,14 @@ async def test_transaction(self) -> None: context = self.rbt.create_external_context(name=self.id()) - test, _ = await Test.factory.initialize( + test, _ = await Test.factory().initialize( context, _TEST_STATE_ID, ) _SECOND_STATE_ID = f"{_TEST_STATE_ID}_other" - second_test, _ = await Test.factory.initialize( + second_test, _ = await Test.factory().initialize( context, _SECOND_STATE_ID, ) @@ -343,7 +345,7 @@ async def test_workflow(self) -> None: context = self.rbt.create_external_context(name=self.id()) - test, _ = await Test.factory.initialize( + test, _ = await Test.factory().initialize( context, _TEST_STATE_ID, ) @@ -376,7 +378,7 @@ async def test_transaction_ongoing_updates(self) -> None: context = self.rbt.create_external_context(name=self.id()) - test, _ = await Test.factory.initialize( + test, _ = await Test.factory().initialize( context, _TEST_STATE_ID, ) @@ -400,7 +402,7 @@ async def test_raise_value_error(self) -> None: context = self.rbt.create_external_context(name=self.id()) - test, _ = await Test.factory.initialize( + test, _ = await Test.factory().initialize( context, _TEST_STATE_ID, ) @@ -423,7 +425,7 @@ async def test_raise_declared_error(self) -> None: context = self.rbt.create_external_context(name=self.id()) - test, _ = await Test.factory.idempotently('initialize').initialize( + test, _ = await Test.factory().idempotently('initialize').initialize( context, _TEST_STATE_ID, ) @@ -499,7 +501,7 @@ async def test_forall_with_iterables(self) -> None: "test-forall-3", ] for state_id in state_ids_list: - await Test.factory.initialize(context, state_id) + await Test.factory().initialize(context, state_id) # Test `forall` with `dict.keys()`. state_ids_dict = {state_id: None for state_id in state_ids_list} diff --git a/tests/reboot/react/test_200_websockets/test_against_local_envoy.py b/tests/reboot/react/test_200_websockets/test_against_local_envoy.py index 31d6cd17a..1133b5117 100644 --- a/tests/reboot/react/test_200_websockets/test_against_local_envoy.py +++ b/tests/reboot/react/test_200_websockets/test_against_local_envoy.py @@ -10,7 +10,7 @@ async def initialize(context: InitializeContext): """Create the singleton bank for our test.""" - await Bank.factory.Create(context, SINGLETON_BANK_ID) + await Bank.factory().Create(context, SINGLETON_BANK_ID) if __name__ == '__main__': diff --git a/tests/reboot/react/test_auth/test_against_local_envoy.py b/tests/reboot/react/test_auth/test_against_local_envoy.py index ddf3f1687..691fee2e9 100644 --- a/tests/reboot/react/test_auth/test_against_local_envoy.py +++ b/tests/reboot/react/test_auth/test_against_local_envoy.py @@ -17,7 +17,7 @@ async def initialize(context: InitializeContext): """Create the singleton bank for our test.""" - await Bank.factory.Create(context, SINGLETON_BANK_ID) + await Bank.factory().Create(context, SINGLETON_BANK_ID) if __name__ == '__main__': diff --git a/tests/reboot/react/test_cache/greeter_cache.test.tsx b/tests/reboot/react/test_cache/greeter_cache.test.tsx index 121f1c7aa..cf38b8e85 100644 --- a/tests/reboot/react/test_cache/greeter_cache.test.tsx +++ b/tests/reboot/react/test_cache/greeter_cache.test.tsx @@ -35,7 +35,7 @@ describe("Disconnected mode - offline cache enabled", () => { it("creates Greeter and changes adjective", async () => { const context = rbt.createExternalContext("test-context-1"); - await Greeter.factory.create(context, "greeter-test-id-1", { + await Greeter.factory().create(context, "greeter-test-id-1", { title: "Dr", name: "Jonathan", adjective: "Best", @@ -157,7 +157,7 @@ describe("Disconnected mode - offline cache disabled", () => { it("creates Greeter and changes adjectiv", async () => { const context = rbt.createExternalContext("test-context-1"); - await Greeter.factory.create(context, "greeter-test-id-1", { + await Greeter.factory().create(context, "greeter-test-id-1", { title: "Dr", name: "Jonathan", adjective: "Best", diff --git a/tests/reboot/react/test_errors/test_against_local_envoy.py b/tests/reboot/react/test_errors/test_against_local_envoy.py index c7057d423..487119794 100644 --- a/tests/reboot/react/test_errors/test_against_local_envoy.py +++ b/tests/reboot/react/test_errors/test_against_local_envoy.py @@ -10,7 +10,7 @@ async def initialize(context: InitializeContext): """Create the singleton bank for our test.""" - await Bank.factory.Create(context, SINGLETON_BANK_ID) + await Bank.factory().Create(context, SINGLETON_BANK_ID) if __name__ == '__main__': diff --git a/tests/reboot/react/test_http_fallback/test.py b/tests/reboot/react/test_http_fallback/test.py index 5bc778b99..b0e002759 100644 --- a/tests/reboot/react/test_http_fallback/test.py +++ b/tests/reboot/react/test_http_fallback/test.py @@ -15,7 +15,7 @@ async def test(context: ExternalContext, uri: str): # Call the constructor for this actor so we have state to # receive when `Greet` is called. - await Greeter.factory.idempotently(f"Create '{state_id}'").Create( + await Greeter.factory().idempotently(f"Create '{state_id}'").Create( context, state_id, title='Count', diff --git a/tests/reboot/react/test_idempotent_writer/test.py b/tests/reboot/react/test_idempotent_writer/test.py index e9cf36a0e..8b355a7ae 100644 --- a/tests/reboot/react/test_idempotent_writer/test.py +++ b/tests/reboot/react/test_idempotent_writer/test.py @@ -14,7 +14,7 @@ async def test(context: ExternalContext, uri: str): # Call the constructor for this actor so we have state to receive # when .Greet is called. - await Greeter.factory.idempotently(f"Create '{state_id}'").Create( + await Greeter.factory().idempotently(f"Create '{state_id}'").Create( context, state_id, title='Count', diff --git a/tests/reboot/react/test_long_running_fetches/test.py b/tests/reboot/react/test_long_running_fetches/test.py index 8b16b0cb1..8dae1befd 100644 --- a/tests/reboot/react/test_long_running_fetches/test.py +++ b/tests/reboot/react/test_long_running_fetches/test.py @@ -24,7 +24,7 @@ async def test(context: ExternalContext, uri: str): # long running fetches. return - await Greeter.factory.idempotently(f"Create '{STATE_ID}'").Create( + await Greeter.factory().idempotently(f"Create '{STATE_ID}'").Create( context, STATE_ID, title='Count', diff --git a/tests/reboot/react/test_mutations/test.py b/tests/reboot/react/test_mutations/test.py index 2b5336c7f..79c8a2237 100644 --- a/tests/reboot/react/test_mutations/test.py +++ b/tests/reboot/react/test_mutations/test.py @@ -14,7 +14,7 @@ async def test(context: ExternalContext, uri: str): # Call the constructor for this actor so we have state to receive # when .Greet is called. - await Greeter.factory.idempotently(f"Create '{state_id}'").Create( + await Greeter.factory().idempotently(f"Create '{state_id}'").Create( context, state_id, title='Count', diff --git a/tests/reboot/react/test_reactive_reader_slow_consumer/test.py b/tests/reboot/react/test_reactive_reader_slow_consumer/test.py index 4abe5f165..596934d2f 100644 --- a/tests/reboot/react/test_reactive_reader_slow_consumer/test.py +++ b/tests/reboot/react/test_reactive_reader_slow_consumer/test.py @@ -21,7 +21,7 @@ async def test(context: ExternalContext, uri: str): """ state_id = 'greeter-slow-consumer-test' - await Greeter.factory.idempotently(f"Create '{state_id}'").Create( + await Greeter.factory().idempotently(f"Create '{state_id}'").Create( context, state_id, title='Count', diff --git a/tests/reboot/react/test_reader/test_against_local_envoy.py b/tests/reboot/react/test_reader/test_against_local_envoy.py index e597f09e8..52398cacf 100644 --- a/tests/reboot/react/test_reader/test_against_local_envoy.py +++ b/tests/reboot/react/test_reader/test_against_local_envoy.py @@ -10,7 +10,7 @@ async def initialize(context: InitializeContext): """Create the singleton bank for our test.""" - await Bank.factory.Create(context, SINGLETON_BANK_ID) + await Bank.factory().Create(context, SINGLETON_BANK_ID) if __name__ == '__main__': diff --git a/tests/reboot/react/test_state_id_change/state_id_change.test.tsx b/tests/reboot/react/test_state_id_change/state_id_change.test.tsx index c6a49a1e6..7820f4753 100644 --- a/tests/reboot/react/test_state_id_change/state_id_change.test.tsx +++ b/tests/reboot/react/test_state_id_change/state_id_change.test.tsx @@ -50,13 +50,13 @@ describe("Reader state-ID change", () => { const context = rbt.createExternalContext("test-state-id-change"); // Create two independent Greeter state instances. - await Greeter.factory.create(context, "greeter-alpha", { + await Greeter.factory().create(context, "greeter-alpha", { title: "Dr", name: "Alpha", adjective: "first", }); - await Greeter.factory.create(context, "greeter-beta", { + await Greeter.factory().create(context, "greeter-beta", { title: "Mr", name: "Beta", adjective: "second", diff --git a/tests/reboot/react/test_suspense/test_against_local_envoy.py b/tests/reboot/react/test_suspense/test_against_local_envoy.py index 2f9b4d6ea..bd228ba4c 100644 --- a/tests/reboot/react/test_suspense/test_against_local_envoy.py +++ b/tests/reboot/react/test_suspense/test_against_local_envoy.py @@ -10,7 +10,7 @@ async def initialize(context: InitializeContext): """Create the singleton bank for our test.""" - await Bank.factory.Create(context, SINGLETON_BANK_ID) + await Bank.factory().Create(context, SINGLETON_BANK_ID) if __name__ == '__main__': diff --git a/tests/reboot/react/test_undeclared_errors/test_against_local_envoy.py b/tests/reboot/react/test_undeclared_errors/test_against_local_envoy.py index feffd0b72..77935984b 100644 --- a/tests/reboot/react/test_undeclared_errors/test_against_local_envoy.py +++ b/tests/reboot/react/test_undeclared_errors/test_against_local_envoy.py @@ -10,7 +10,7 @@ async def initialize(context: InitializeContext): """Create the singleton bank for our test.""" - await Bank.factory.Create(context, SINGLETON_BANK_ID) + await Bank.factory().Create(context, SINGLETON_BANK_ID) if __name__ == '__main__': diff --git a/tests/reboot/react/test_websockets_connection/test_against_local_envoy.py b/tests/reboot/react/test_websockets_connection/test_against_local_envoy.py index dc3c3c81e..8d51cb5f2 100644 --- a/tests/reboot/react/test_websockets_connection/test_against_local_envoy.py +++ b/tests/reboot/react/test_websockets_connection/test_against_local_envoy.py @@ -10,7 +10,7 @@ async def initialize(context: InitializeContext): """Create the singleton bank for our test.""" - await Bank.factory.Create(context, SINGLETON_BANK_ID) + await Bank.factory().Create(context, SINGLETON_BANK_ID) if __name__ == '__main__': diff --git a/tests/reboot/react/test_writer_abort_with_retrying_reactive_reader/test.py b/tests/reboot/react/test_writer_abort_with_retrying_reactive_reader/test.py index 954cc1843..574855f67 100644 --- a/tests/reboot/react/test_writer_abort_with_retrying_reactive_reader/test.py +++ b/tests/reboot/react/test_writer_abort_with_retrying_reactive_reader/test.py @@ -35,7 +35,7 @@ async def test(context: ExternalContext, uri: str): state_id = 'actor-test-132' - test, _ = await Test.factory.idempotently(f"Create '{state_id}'").Create( + test, _ = await Test.factory().idempotently(f"Create '{state_id}'").Create( context, state_id, ) diff --git a/tests/reboot/reactivity_test.py b/tests/reboot/reactivity_test.py index e2798cbc1..a4921f0fb 100644 --- a/tests/reboot/reactivity_test.py +++ b/tests/reboot/reactivity_test.py @@ -56,7 +56,7 @@ async def test_reactive_get_all_state(self) -> None: """ await self.rbt.up(Application(servicers=[MyGreeterServicer])) context = self.rbt.create_external_context(name=f"test-{self.id()}") - greeter, _ = await Greeter.factory.Create( + greeter, _ = await Greeter.factory().Create( context, "my-greeter", title="Mr.", diff --git a/tests/reboot/reboot_tests.py b/tests/reboot/reboot_tests.py index c6580d906..0f9ba6dbd 100644 --- a/tests/reboot/reboot_tests.py +++ b/tests/reboot/reboot_tests.py @@ -436,7 +436,7 @@ async def test_deep_recursive_message(self) -> None: context = self.rbt.create_external_context(name=self.id()) - greeter, _ = await Greeter.factory.Create( + greeter, _ = await Greeter.factory().Create( context, title='Dr', name='Jonathan', diff --git a/tests/reboot/server/local_envoy_test.py b/tests/reboot/server/local_envoy_test.py index 68928b5e4..b9654b253 100644 --- a/tests/reboot/server/local_envoy_test.py +++ b/tests/reboot/server/local_envoy_test.py @@ -240,7 +240,7 @@ async def test_server_filter(self): name='test_server_filter', url=f"https://{endpoint}", ) - await General.factory.ConstructorWriter(context, 'foo') + await General.factory().ConstructorWriter(context, 'foo') seen_ids = set() for i in range(30): response = await General.ref('foo').Reader(context) @@ -251,7 +251,7 @@ async def test_server_filter(self): # across all servers. seen_ids = set() for state_id in string.ascii_lowercase: - _, response = await General.factory.ConstructorWriter( + _, response = await General.factory().ConstructorWriter( context, state_id ) server_id = response.content[SERVER_ID_HEADER] @@ -295,7 +295,7 @@ async def test_server_filter(self): # for such states must route to the same server both via gRPC # calls (which send tagged state refs) and via HTTP calls with # human-readable state refs. - _, response = await General.factory.ConstructorWriter( + _, response = await General.factory().ConstructorWriter( context, "foo:bar/baz" ) id_server_pair = ( @@ -392,7 +392,7 @@ async def test_mangled_path_filter(self): state_id = f"foo-{i}" general, construct_response = ( - await General.factory.ConstructorWriter( + await General.factory().ConstructorWriter( context, state_id, ) @@ -496,7 +496,7 @@ async def test_remove_json_trailers_filter(self): ) # Create a state to test with. - await General.factory.ConstructorWriter(context, 'test_state') + await General.factory().ConstructorWriter(context, 'test_state') # Use h2 library to make a low-level HTTP/2 request # that can distinguish between headers and trailers. diff --git a/tests/reboot/std/ciphertext/v1/ciphertext_tests.py b/tests/reboot/std/ciphertext/v1/ciphertext_tests.py index 7014ffe7f..1168f083a 100644 --- a/tests/reboot/std/ciphertext/v1/ciphertext_tests.py +++ b/tests/reboot/std/ciphertext/v1/ciphertext_tests.py @@ -55,7 +55,7 @@ async def _encrypt( scope: str, key_manager_id: str, ) -> str: - ciphertext, _ = await Ciphertext.factory.encrypt( + ciphertext, _ = await Ciphertext.factory().encrypt( self.context, plaintext=plaintext, associated_data=associated_data, diff --git a/tests/reboot/std/collections/sorted_map_tests.py b/tests/reboot/std/collections/sorted_map_tests.py index 1cb2bd683..f263ae785 100644 --- a/tests/reboot/std/collections/sorted_map_tests.py +++ b/tests/reboot/std/collections/sorted_map_tests.py @@ -518,7 +518,7 @@ async def test_transaction_basic(self) -> None: ) sorted_map, context = self.map() - consumer, _ = await General.factory.ConstructorWriter(context) + consumer, _ = await General.factory().ConstructorWriter(context) expected_entries_before = {"2": b""} expected_entries_after = {"1": b"", "2": b"", "3": b""} @@ -584,7 +584,7 @@ async def test_transaction_abort(self) -> None: ) sorted_map, context = self.map() - consumer, _ = await General.factory.ConstructorWriter(context) + consumer, _ = await General.factory().ConstructorWriter(context) expected_entries_before = {"2": b""} diff --git a/tests/reboot/tasks_tests.py b/tests/reboot/tasks_tests.py index eef22f9ba..c9a3bfa2a 100644 --- a/tests/reboot/tasks_tests.py +++ b/tests/reboot/tasks_tests.py @@ -429,7 +429,7 @@ async def test_ref_schedule_in_transaction(self) -> None: context = self.rbt.create_external_context(name=self.id()) - bank, _ = await Bank.factory.Create(context, SINGLETON_BANK_ID) + bank, _ = await Bank.factory().Create(context, SINGLETON_BANK_ID) response = await bank.SignUp(context, account_id='jonathan') @@ -581,7 +581,7 @@ async def test_alpha_servicer_read_write_in_workflow(self) -> None: context = self.rbt.create_external_context(name=self.id()) - greeter, _ = await Greeter.factory.Create( + greeter, _ = await Greeter.factory().Create( context, title='Dr', name='Jonathan', @@ -667,7 +667,7 @@ async def callable() -> General.State: context = self.rbt.create_external_context(name=self.id()) # Construct. - g, _ = await General.factory.ConstructorWriter(context) + g, _ = await General.factory().ConstructorWriter(context) task = await g.spawn().Workflow(context) @@ -751,7 +751,7 @@ async def workflow( context = self.rbt.create_external_context(name=self.id()) # Construct. - g, _ = await General.factory.ConstructorWriter(context) + g, _ = await General.factory().ConstructorWriter(context) task = await g.spawn().Workflow(context) @@ -800,7 +800,7 @@ async def workflow( context = self.rbt.create_external_context(name=self.id()) # Construct. - g, _ = await General.factory.ConstructorWriter(context) + g, _ = await General.factory().ConstructorWriter(context) # Spawn a workflow with an absolute time that includes the timezone. task = await g.spawn(when=datetime.now(tz=get_localzone()) @@ -887,7 +887,7 @@ async def workflow( context = self.rbt.create_external_context(name=self.id()) # Construct. - g, _ = await General.factory.ConstructorWriter(context) + g, _ = await General.factory().ConstructorWriter(context) # Call Writer that will schedule a workflow with an absolute time that does not include the timezone. await g.Writer(context, content={'timezone_attached': ""}) @@ -982,7 +982,7 @@ async def workflow( context = self.rbt.create_external_context(name=self.id()) # Construct. - g, _ = await General.factory.ConstructorTransaction(context, ID) + g, _ = await General.factory().ConstructorTransaction(context, ID) # Call Transaction that will schedule a workflow with an absolute time that does not include the timezone. await g.Transaction(context, content={'timezone_attached': ""}) @@ -1057,7 +1057,7 @@ async def workflow( context = self.rbt.create_external_context(name=self.id()) # Construct. - g, _ = await General.factory.ConstructorWriter(context) + g, _ = await General.factory().ConstructorWriter(context) # Call Transaction that will schedule a workflow with a timedelta. await g.Transaction(context) @@ -1121,7 +1121,7 @@ async def workflow( context = self.rbt.create_external_context(name=self.id()) # Construct. - g, _ = await General.factory.ConstructorTransaction(context, ID) + g, _ = await General.factory().ConstructorTransaction(context, ID) # Call Transaction that will schedule a workflow with a timedelta. await g.Transaction(context) @@ -1192,7 +1192,7 @@ async def workflow( context = self.rbt.create_external_context(name=self.id()) # Construct. - g, _ = await General.factory.constructor_writer(context) + g, _ = await General.factory().constructor_writer(context) # Run the workflow. await g.workflow(context) @@ -1297,7 +1297,7 @@ async def workflow( context = self.rbt.create_external_context(name=self.id()) # Construct. - g, _ = await General.factory.constructor_writer(context) + g, _ = await General.factory().constructor_writer(context) # Spawn the workflow. task = await g.spawn().workflow(context) @@ -1473,7 +1473,7 @@ async def workflow( context = self.rbt.create_external_context(name=self.id()) # Construct. - g, _ = await General.factory.constructor_writer(context) + g, _ = await General.factory().constructor_writer(context) # Spawn the workflow. task = await g.spawn().workflow(context) @@ -1613,7 +1613,7 @@ async def workflow( context = self.rbt.create_external_context(name=self.id()) # Construct. - g, _ = await General.factory.constructor_writer(context) + g, _ = await General.factory().constructor_writer(context) # Spawn the workflow. task = await g.spawn().workflow(context) @@ -1773,7 +1773,7 @@ async def write(state: General.State) -> str: context = self.rbt.create_external_context(name=self.id()) # Construct. - g, _ = await General.factory.constructor_writer(context) + g, _ = await General.factory().constructor_writer(context) # Spawn the workflow. task = await g.spawn().workflow(context) @@ -1877,7 +1877,7 @@ async def async_on_method(*, retrying: bool) -> None: context = self.rbt.create_external_context(name=self.id()) - g, _ = await General.factory.constructor_writer(context) + g, _ = await General.factory().constructor_writer(context) await g.workflow(context) @@ -1960,7 +1960,7 @@ def on_method(*, retrying: bool) -> None: context = self.rbt.create_external_context(name=self.id()) - g, _ = await General.factory.constructor_writer(context) + g, _ = await General.factory().constructor_writer(context) await g.workflow(context) @@ -2043,7 +2043,7 @@ def on_iteration(*, iteration: int) -> None: context = self.rbt.create_external_context(name=self.id()) - g, _ = await General.factory.constructor_writer(context) + g, _ = await General.factory().constructor_writer(context) await g.workflow(context) @@ -2110,7 +2110,7 @@ def on_method(*, retrying: bool) -> None: context = self.rbt.create_external_context(name=self.id()) - g, _ = await General.factory.constructor_writer(context) + g, _ = await General.factory().constructor_writer(context) await g.workflow(context) diff --git a/tests/reboot/thirdparty/mailgun/tests.py b/tests/reboot/thirdparty/mailgun/tests.py index 0721cdea5..feef89d78 100644 --- a/tests/reboot/thirdparty/mailgun/tests.py +++ b/tests/reboot/thirdparty/mailgun/tests.py @@ -36,7 +36,7 @@ async def test_emailer(self) -> None: bearer_token=MAILGUN_API_KEY, ) - _, send_response = await Message.factory.Send( + _, send_response = await Message.factory().Send( context, recipient="team@reboot.dev", sender="hipsterstore@reboot.dev", @@ -54,7 +54,7 @@ async def test_emailer(self) -> None: self.assertEqual(1, len(MockMessageServicer.emails_sent)) MockMessageServicer.emails_sent.clear() - _, send_response = await Message.factory.Send( + _, send_response = await Message.factory().Send( context, recipient="team@reboot.dev", sender="hipsterstore@reboot.dev", diff --git a/tests/reboot/transaction_tests.py b/tests/reboot/transaction_tests.py index 0a8178bd5..16f6b0c01 100644 --- a/tests/reboot/transaction_tests.py +++ b/tests/reboot/transaction_tests.py @@ -124,7 +124,7 @@ async def test_transactions_basic(self) -> None: context = self.rbt.create_external_context(name=self.id()) - bank, _ = await Bank.factory.Create(context, SINGLETON_BANK_ID) + bank, _ = await Bank.factory().Create(context, SINGLETON_BANK_ID) await bank.SignUp( context, @@ -937,7 +937,7 @@ async def test_transactions_after_down(self) -> None: context = self.rbt.create_external_context(name=self.id()) - bank, _ = await Bank.factory.Create(context, SINGLETON_BANK_ID) + bank, _ = await Bank.factory().Create(context, SINGLETON_BANK_ID) await bank.SignUp( context, @@ -1004,7 +1004,7 @@ async def mock_commit(state_manager, request, grpc_context): context = self.rbt.create_external_context(name=self.id()) - bank, _ = await Bank.factory.Create(context, SINGLETON_BANK_ID) + bank, _ = await Bank.factory().Create(context, SINGLETON_BANK_ID) await bank.SignUp(context, account_id='jonathan') @@ -1037,7 +1037,7 @@ async def mock_prepare(state_manager, request, grpc_context): context = self.rbt.create_external_context(name=self.id()) - bank, _ = await Bank.factory.Create(context, SINGLETON_BANK_ID) + bank, _ = await Bank.factory().Create(context, SINGLETON_BANK_ID) with self.assertRaises(Bank.SignUpAborted): await bank.SignUp(context, account_id='jonathan') @@ -1080,7 +1080,7 @@ async def mock_prepare(state_manager, request, grpc_context): context = self.rbt.create_external_context(name=self.id()) - bank, _ = await Bank.factory.Create(context, SINGLETON_BANK_ID) + bank, _ = await Bank.factory().Create(context, SINGLETON_BANK_ID) with self.assertRaises(Bank.SignUpAborted): await bank.SignUp(context, account_id='jonathan') @@ -1214,7 +1214,7 @@ def mock_should_retry(unary_retried_call, error): context = self.rbt.create_external_context(name=self.id()) - bank, _ = await Bank.factory.Create(context, SINGLETON_BANK_ID) + bank, _ = await Bank.factory().Create(context, SINGLETON_BANK_ID) # Confirm that the relevant Bank and Account instances are running # in different servers. Note that this isn't necessarily @@ -1352,7 +1352,7 @@ def mock_should_retry(unary_retried_call, error): context = self.rbt.create_external_context(name=self.id()) - bank, _ = await Bank.factory.Create(context, SINGLETON_BANK_ID) + bank, _ = await Bank.factory().Create(context, SINGLETON_BANK_ID) # Confirm that the relevant Bank and Account instances are running # in different servers. Note that this isn't necessarily @@ -1633,7 +1633,7 @@ def mock_should_retry(unary_retried_call, error): context = self.rbt.create_external_context(name=self.id()) - bank, _ = await Bank.factory.Create(context, SINGLETON_BANK_ID) + bank, _ = await Bank.factory().Create(context, SINGLETON_BANK_ID) # Confirm that `Bank` and `Account` are on different # servers so we can restart just the participant. @@ -1692,7 +1692,7 @@ async def mock_transaction_participant_store( context = self.rbt.create_external_context(name=self.id()) - bank, _ = await Bank.factory.Create(context, SINGLETON_BANK_ID) + bank, _ = await Bank.factory().Create(context, SINGLETON_BANK_ID) await bank.SignUp(context, account_id='jonathan') @@ -1743,7 +1743,7 @@ async def mock_transaction_participant_store( context = self.rbt.create_external_context(name=self.id()) - bank, _ = await Bank.factory.Create(context, SINGLETON_BANK_ID) + bank, _ = await Bank.factory().Create(context, SINGLETON_BANK_ID) await bank.SignUp(context, account_id='jonathan') @@ -1803,7 +1803,7 @@ async def mock_commit(state_manager, request, grpc_context): ) context = self.rbt.create_external_context(name=self.id()) - bank, _ = await Bank.factory.Create(context, SINGLETON_BANK_ID) + bank, _ = await Bank.factory().Create(context, SINGLETON_BANK_ID) # Confirm that the relevant Bank and Account instances are running # in different servers. Note that this isn't necessarily @@ -1937,7 +1937,7 @@ async def mock_commit(state_manager, request, grpc_context): ) context = self.rbt.create_external_context(name=self.id()) - bank, _ = await Bank.factory.Create(context, SINGLETON_BANK_ID) + bank, _ = await Bank.factory().Create(context, SINGLETON_BANK_ID) await bank.SignUp( context, account_id=alice_account_ref.id, initial_deposit=100 ) @@ -2084,7 +2084,7 @@ async def mock_commit(state_manager, request, grpc_context): ) context = self.rbt.create_external_context(name=self.id()) - bank, _ = await Bank.factory.Create(context, SINGLETON_BANK_ID) + bank, _ = await Bank.factory().Create(context, SINGLETON_BANK_ID) # Bank and Account on different servers (the existing # recovery tests rely on this and we want the same @@ -2196,7 +2196,7 @@ async def mock_transaction_coordinator_prepared( ) context = self.rbt.create_external_context(name=self.id()) - bank, _ = await Bank.factory.Create(context, SINGLETON_BANK_ID) + bank, _ = await Bank.factory().Create(context, SINGLETON_BANK_ID) # Confirm that `Bank` and `Account` are on different # servers so we exercise cross-server recovery. @@ -2293,7 +2293,7 @@ async def mock_transaction_participant_prepare( ) context = self.rbt.create_external_context(name=self.id()) - bank, _ = await Bank.factory.Create(context, SINGLETON_BANK_ID) + bank, _ = await Bank.factory().Create(context, SINGLETON_BANK_ID) bank_server_id, account_server_id = await self.rbt.unique_servers( bank._state_ref, @@ -2424,7 +2424,7 @@ def mock_transaction_await(*args, **kwargs): # Create the account using the transactional method `SignUp`. context = self.rbt.create_external_context(name=self.id()) - bank, _ = await Bank.factory.Create(context, SINGLETON_BANK_ID) + bank, _ = await Bank.factory().Create(context, SINGLETON_BANK_ID) await bank.SignUp( context, account_id=account_name, initial_deposit=10 @@ -2498,7 +2498,7 @@ async def mock_SignUp( context = self.rbt.create_external_context(name=self.id()) - bank, _ = await Bank.factory.Create(context, SINGLETON_BANK_ID) + bank, _ = await Bank.factory().Create(context, SINGLETON_BANK_ID) with self.assertRaises(Bank.SignUpAborted) as aborted: await bank.SignUp(context, account_id='jonathan') @@ -2681,7 +2681,7 @@ def check_transactionally( context = self.rbt.create_external_context(name=self.id()) - bank, _ = await Bank.factory.Create(context, SINGLETON_BANK_ID) + bank, _ = await Bank.factory().Create(context, SINGLETON_BANK_ID) bank_initialized = True @@ -2766,7 +2766,7 @@ def check_transactionally( context = self.rbt.create_external_context(name=self.id()) - bank, _ = await Bank.factory.Create(context, SINGLETON_BANK_ID) + bank, _ = await Bank.factory().Create(context, SINGLETON_BANK_ID) await bank.SignUp(context, account_id='jonathan') @@ -2845,7 +2845,7 @@ def check_transactionally( context = self.rbt.create_external_context(name=self.id()) - bank, _ = await Bank.factory.Create(context, SINGLETON_BANK_ID) + bank, _ = await Bank.factory().Create(context, SINGLETON_BANK_ID) with self.assertRaises(Bank.SignUpAborted) as aborted: await bank.SignUp(context, account_id='jonathan') @@ -2865,7 +2865,7 @@ async def test_transaction_aborts_when_catching_undeclared_errors(self): context = self.rbt.create_external_context(name=self.id()) - bank, _ = await Bank.factory.Create(context, SINGLETON_BANK_ID) + bank, _ = await Bank.factory().Create(context, SINGLETON_BANK_ID) await bank.SignUp(context, account_id='jonathan') @@ -2890,7 +2890,7 @@ async def test_nested_catch_undeclared_aborts_root(self): context = self.rbt.create_external_context(name=self.id()) - bank, _ = await Bank.factory.Create(context, SINGLETON_BANK_ID) + bank, _ = await Bank.factory().Create(context, SINGLETON_BANK_ID) await bank.SignUp(context, account_id='jonathan') @@ -2920,7 +2920,7 @@ async def test_nested_read_only_doomed_subtree_aborts_root(self): context = self.rbt.create_external_context(name=self.id()) - bank, _ = await Bank.factory.Create(context, SINGLETON_BANK_ID) + bank, _ = await Bank.factory().Create(context, SINGLETON_BANK_ID) await bank.SignUp(context, account_id='catcher') await bank.SignUp(context, account_id='thrower') @@ -2949,7 +2949,7 @@ async def test_calls_within_transactions_raise_after_catching_abort(self): context = self.rbt.create_external_context(name=self.id()) - bank, _ = await Bank.factory.Create(context, SINGLETON_BANK_ID) + bank, _ = await Bank.factory().Create(context, SINGLETON_BANK_ID) await bank.SignUp(context, account_id='jonathan') @@ -2976,7 +2976,7 @@ async def test_transaction_retried_when_catching_unavailable(self): context = self.rbt.create_external_context(name=self.id()) - bank, _ = await Bank.factory.Create(context, SINGLETON_BANK_ID) + bank, _ = await Bank.factory().Create(context, SINGLETON_BANK_ID) await bank.SignUp(context, account_id='jonathan') @@ -2998,7 +2998,7 @@ async def test_transaction_not_aborts_when_catching_declared_errors(self): context = self.rbt.create_external_context(name=self.id()) - bank, _ = await Bank.factory.Create(context, SINGLETON_BANK_ID) + bank, _ = await Bank.factory().Create(context, SINGLETON_BANK_ID) await bank.SignUp(context, account_id='jonathan') @@ -3064,7 +3064,7 @@ async def test_nested_transaction_aborts_even_if_parent_does_not(self): context = self.rbt.create_external_context(name=self.id()) - bank, _ = await Bank.factory.Create(context, SINGLETON_BANK_ID) + bank, _ = await Bank.factory().Create(context, SINGLETON_BANK_ID) await bank.SignUp(context, account_id='jonathan', initial_deposit=7) @@ -3108,7 +3108,7 @@ async def test_inherited_ownership_abort(self): context = self.rbt.create_external_context(name=self.id()) - bank, _ = await Bank.factory.Create(context, SINGLETON_BANK_ID) + bank, _ = await Bank.factory().Create(context, SINGLETON_BANK_ID) # Opens 'inherited' (balance 10), then via a nested transaction # that does NOT touch 'inherited' calls a deeper nested @@ -3176,7 +3176,7 @@ async def mock_acquire_exclusive(lock, *args, **kwargs): context = self.rbt.create_external_context(name=self.id()) - bank, _ = await Bank.factory.Create(context, SINGLETON_BANK_ID) + bank, _ = await Bank.factory().Create(context, SINGLETON_BANK_ID) await bank.SignUp( context, account_id='retainacct', initial_deposit=10 @@ -3284,7 +3284,7 @@ async def mock_wait_ownership(transaction, condition, *args, **kwargs): context = self.rbt.create_external_context(name=self.id()) - bank, _ = await Bank.factory.Create(context, SINGLETON_BANK_ID) + bank, _ = await Bank.factory().Create(context, SINGLETON_BANK_ID) root_task = asyncio.create_task( bank.TestPrepareWaitForNestedAbortRollback( @@ -3390,7 +3390,7 @@ async def test_constructor_after_abort_from_unconstructed(self): type(aborted.exception.error), errors_pb2.StateNotConstructed ) - await Bank.factory.Create(context, SINGLETON_BANK_ID) + await Bank.factory().Create(context, SINGLETON_BANK_ID) async def test_transactional_constructor(self): """Tests that we can call a transactional constructor, and that aborting @@ -3429,7 +3429,7 @@ async def Reader( context = self.rbt.create_external_context(name=self.id()) # Successfully create, and confirm that we can see the state. - item1, _ = await General.factory.ConstructorTransaction( + item1, _ = await General.factory().ConstructorTransaction( context, "item1" ) self.assertEqual( @@ -3440,7 +3440,7 @@ async def Reader( with self.assertRaises( General.ConstructorTransactionAborted ) as ct_aborted: - await General.factory.ConstructorTransaction( + await General.factory().ConstructorTransaction( context, "item2", content={"abort": "True"}, @@ -3487,7 +3487,9 @@ async def Reader( ) context = self.rbt.create_external_context(name=self.id()) - item, _ = await General.factory.ConstructorTransaction(context, "item") + item, _ = await General.factory().ConstructorTransaction( + context, "item" + ) # The actor must be constructed: reading it must succeed rather # than abort with `StateNotConstructed`. @@ -3503,7 +3505,7 @@ async def test_nested_transactions(self): context = self.rbt.create_external_context(name=self.id()) - bank, _ = await Bank.factory.Create(context, SINGLETON_BANK_ID) + bank, _ = await Bank.factory().Create(context, SINGLETON_BANK_ID) # A nested transaction (`Bank.Transfer`) on the same `Bank` # state as the parent transaction, also modifying accounts @@ -3636,7 +3638,7 @@ async def Transaction( entries={"bar": b"bar"}, ) - general, _ = await General.factory.ConstructorWriter(context) + general, _ = await General.factory().ConstructorWriter(context) # We first call `General.Transaction` for a nonexistent key, which # will cause its `SortedMap.Get` call to fail, and therefore cause the @@ -3682,7 +3684,7 @@ async def test_successful_transaction_no_trailing_metadata(self) -> None: # Create a bank and an account to test with. context = self.rbt.create_external_context(name=self.id()) - bank, _ = await Bank.factory.Create(context, SINGLETON_BANK_ID) + bank, _ = await Bank.factory().Create(context, SINGLETON_BANK_ID) await bank.SignUp(context, account_id='test-account') # Now use raw gRPC to call a transaction method, so we can check @@ -3728,7 +3730,7 @@ async def test_failing_transaction_no_trailing_metadata(self) -> None: # Create a bank to test with. context = self.rbt.create_external_context(name=self.id()) - bank, _ = await Bank.factory.Create(context, SINGLETON_BANK_ID) + bank, _ = await Bank.factory().Create(context, SINGLETON_BANK_ID) # Now use raw gRPC to call a transaction method that will fail, # so we can check the trailing metadata. diff --git a/tests/reboot/zod/concurrent_transactions_same_state/test.ts b/tests/reboot/zod/concurrent_transactions_same_state/test.ts index 95606fee6..c9922f5c9 100644 --- a/tests/reboot/zod/concurrent_transactions_same_state/test.ts +++ b/tests/reboot/zod/concurrent_transactions_same_state/test.ts @@ -25,7 +25,7 @@ const setUp = async () => { const context = rbt.createExternalContext("test"); - await Counter.factory.create(context, COUNTER_ID, {}); + await Counter.factory().create(context, COUNTER_ID, {}); return { rbt, context }; }; @@ -51,7 +51,9 @@ test("Concurrent transactions on one state", async (t) => { (_, index) => `driver-${index}` ); await Promise.all( - driverIds.map((driverId) => Counter.factory.create(context, driverId, {})) + driverIds.map((driverId) => + Counter.factory().create(context, driverId, {}) + ) ); rendezvous.reset(CONCURRENCY); @@ -90,8 +92,8 @@ test("Concurrent transactions on one state", async (t) => { await rbt.stop(); }); - await Counter.factory.create(context, "writing-driver", {}); - await Counter.factory.create(context, "touching-driver", {}); + await Counter.factory().create(context, "writing-driver", {}); + await Counter.factory().create(context, "touching-driver", {}); parkedIncrementIsParticipant.reset(); parkedIncrementMayWrite.reset(); diff --git a/tests/reboot/zod/methods/test.ts b/tests/reboot/zod/methods/test.ts index f247dc85b..32655589a 100644 --- a/tests/reboot/zod/methods/test.ts +++ b/tests/reboot/zod/methods/test.ts @@ -17,7 +17,7 @@ test("Test Zod Service", async (t) => { const context = rbt.createExternalContext("test"); - const [test] = await Test.factory.construct(context, {}); + const [test] = await Test.factory().construct(context, {}); await test.writer(context, { data: "initialize", From 347a72ab4a9754afaef5e15789171b5c4bfd8695 Mon Sep 17 00:00:00 2001 From: Robert-Jan Huijsman <22160949+rjhuijsman@users.noreply.github.com> Date: Tue, 15 Sep 2026 10:50:22 +0000 Subject: [PATCH 5/5] Callers: follow the `factory()` move in what `main` added since Before this change, everything that landed on `main` after this branch was cut still relied on constructors living directly on the state type's class, so it would have broken the moment the branch merged. This audits those commits and moves each dependency over: - The dashboard's code watcher registered constructor stubs it found directly in the state type's class body; they now sit in the nested `_Factory`, so it is added to `HOWS_BY_CLASS_NAME` and the body scan goes. Its test fixture mirrors the new shape, and the test sources it analyzes call `factory()`. - The BDD fixtures looked constructors up with `getattr` on the state type's client class; they now look in `factory()`. - Callers `main` added: the shared-error pydantic test, the new concurrent-transaction and root-abort cases in the transaction tests, the local Envoy test, the swag store's relocated test, the documentation app's `todos.py` and the `concepts` / users docs built on it, plus one pre-existing miss in the workflow skill reference. Co-Authored-By: Claude Opus 5 (1M context) Claude-Session: https://claude.ai/code/session_01BAd3bRycJhQHPAmoCHBdgJ --- documentation/docs/concepts.mdx | 2 +- documentation/docs/users/overview.mdx | 6 +-- reboot/bdd/fixtures.py | 6 +-- reboot/dashboard/backend/code_watcher.py | 50 +++++++++---------- .../tests/store_servicer_test.py | 2 +- .../python/references/servicer-workflow.md | 2 +- tests/reboot/dashboard/code_watcher_tests.py | 50 +++++++++++-------- .../backend/src/servicers/todos.py | 4 +- tests/reboot/pydantic/shared_error/test.py | 16 +++--- tests/reboot/server/local_envoy_test.py | 2 +- tests/reboot/transaction_tests.py | 28 +++++------ 11 files changed, 89 insertions(+), 79 deletions(-) diff --git a/documentation/docs/concepts.mdx b/documentation/docs/concepts.mdx index 9032064f6..e81b782a2 100644 --- a/documentation/docs/concepts.mdx +++ b/documentation/docs/concepts.mdx @@ -53,7 +53,7 @@ constructor — a method declared with `factory=True` — and call it without an ID; Reboot mints a fresh, unique one for you: ```python -account, _ = await Account.open(context, customer_name="Ada") +account, _ = await Account.factory().open(context, customer_name="Ada") account.state_id # The generated ID — hold on to this. ``` diff --git a/documentation/docs/users/overview.mdx b/documentation/docs/users/overview.mdx index e64c6ee9a..3a013a6ac 100644 --- a/documentation/docs/users/overview.mdx +++ b/documentation/docs/users/overview.mdx @@ -159,7 +159,7 @@ Three things follow from that name: 1. **Auto-construction.** A `User` instance is created the first time a person signs in, and found again on every sign-in after that. - You never call `User.create(...)` yourself. + You never call `User.factory().create(...)` yourself. 2. **The state ID *is* the identity.** The instance's state ID is the stable user ID your [OAuth provider](/users/providers) issues. Inside a `User` servicer method, @@ -246,7 +246,7 @@ async def create( ) -> None: """Runs once, when a person signs in for the first time: give them a list to start with.""" - todo_list, _ = await TodoList.create( + todo_list, _ = await TodoList.factory().create( context, title="Getting started", owner_id=context.state_id, @@ -286,7 +286,7 @@ async def create_todo_list( ) -> CreateTodoListResponse: """Create a list owned by the signed-in person and remember it on their `User`.""" - todo_list, _ = await TodoList.create( + todo_list, _ = await TodoList.factory().create( context, title=request.title, owner_id=context.state_id, diff --git a/reboot/bdd/fixtures.py b/reboot/bdd/fixtures.py index 532389ff9..30e13dfd0 100644 --- a/reboot/bdd/fixtures.py +++ b/reboot/bdd/fixtures.py @@ -288,9 +288,9 @@ def factory( state_type: str, method: str, ) -> Callable[..., Any]: - """The named factory on the state type's generated client - class; raises if there is none.""" - factory = getattr(self.client_type(state_type), method, None) + """The named factory in the `factory()` namespace of the state + type's generated client class; raises if there is none.""" + factory = getattr(self.client_type(state_type).factory(), method, None) if not callable(factory): raise ValueError(f"`{state_type}` has no factory `{method}`") return factory diff --git a/reboot/dashboard/backend/code_watcher.py b/reboot/dashboard/backend/code_watcher.py index 292865c47..af1f6f235 100644 --- a/reboot/dashboard/backend/code_watcher.py +++ b/reboot/dashboard/backend/code_watcher.py @@ -277,9 +277,9 @@ class ServicerDefinition: class MethodDefinition: """A line defining a method stub of a state type: on its `WeakReference`, the class of a reference to it, or on the - state type's own class, where the generator writes the - constructors. What a call made through any reference, or a - construction, is defined by.""" + `_Factory` inside the state type's own class, where the + generator writes the constructors. What a call made through any + reference, or a construction, is defined by.""" # The state type, spelled as `__state_type_name__` spells it, # e.g. `shop.v1.Shop`. @@ -302,11 +302,12 @@ class MethodDefinition: # How a call whose stub is defined in each class the generator # nests inside a `WeakReference` or the state type's class is -# reached: through `.schedule(when=...)`, `.spawn(when=...)`, or -# `.forall(ids)`; for `.idempotently(...)`, a plain call or a -# construction made idempotent. +# reached: through `.factory()`, `.schedule(when=...)`, +# `.spawn(when=...)`, or `.forall(ids)`; for `.idempotently(...)`, a +# plain call or a construction made idempotent. HOWS_BY_CLASS_NAME = { '_ConstructIdempotently': Servicer.Method.Call.How.CONSTRUCT, + '_Factory': Servicer.Method.Call.How.CONSTRUCT, '_Forall': Servicer.Method.Call.How.FORALL, '_Idempotently': Servicer.Method.Call.How.CALL, '_Schedule': Servicer.Method.Call.How.SCHEDULE, @@ -417,29 +418,24 @@ def _generated_definitions( state_type=state_type, ) - # The state type's class defines the constructor + # The `_Factory` inside the state type's class, + # reached as `.factory()`, defines the constructor # stubs, e.g. # `async def Create(__cls__, __context__, ...)`; - # its `WeakReference`, the class of a reference to - # it, defines the method stubs a reference is - # called with, one def per overload; and the - # classes inside the `WeakReference` named in - # `HOWS_BY_CLASS_NAME` define the same stubs as - # reached each way, `_ConstructIdempotently` the - # constructors made idempotent. Every stub - # is told apart from the machinery around it, such - # as `ref` and `schedule` themselves, by the - # `__context__` parameter only the generator's - # stubs take second. An alias written after a stub, - # `add_to_cart = AddToCart`, defines the same method - # under the name the developer calls. - definitions.update( - _method_definitions_in( - statement.body, - state_type=state_type, - how=Servicer.Method.Call.How.CONSTRUCT, - ) - ) + # the `WeakReference`, the class of a reference to + # the state type, defines the method stubs a + # reference is called with, one def per overload; + # and the other classes named in + # `HOWS_BY_CLASS_NAME`, inside either, define the + # same stubs as reached each way, + # `_ConstructIdempotently` the constructors made + # idempotent. Every stub is told apart from the + # machinery around it, such as `ref` and `schedule` + # themselves, by the `__context__` parameter only + # the generator's stubs take second. An alias + # written after a stub, `add_to_cart = AddToCart`, + # defines the same method under the name the + # developer calls. for inner in statement.body: match inner: case ast.ClassDef( diff --git a/reboot/examples/reboot-swag-store/tests/store_servicer_test.py b/reboot/examples/reboot-swag-store/tests/store_servicer_test.py index 14562801b..128d8293a 100644 --- a/reboot/examples/reboot-swag-store/tests/store_servicer_test.py +++ b/reboot/examples/reboot-swag-store/tests/store_servicer_test.py @@ -63,7 +63,7 @@ async def fulfill( async def _initialize(context) -> None: - await CouponBook.create(context, COUPON_BOOK_ID) + await CouponBook.factory().create(context, COUPON_BOOK_ID) # The admin authorizer reads its key from the environment; give it diff --git a/reboot/plugin/skills/python/references/servicer-workflow.md b/reboot/plugin/skills/python/references/servicer-workflow.md index 1fc830b2c..523c94322 100644 --- a/reboot/plugin/skills/python/references/servicer-workflow.md +++ b/reboot/plugin/skills/python/references/servicer-workflow.md @@ -162,7 +162,7 @@ class GreeterServicer(Greeter.Servicer): await Greeter.ref().write(context, set_greeting) ``` -Caller-side: `await Greeter.Hello(ctx, "alice", name="alice")` both +Caller-side: `await Greeter.factory().Hello(ctx, "alice", name="alice")` both creates the actor and (by virtue of the schedule call) kicks off `run_hello`. diff --git a/tests/reboot/dashboard/code_watcher_tests.py b/tests/reboot/dashboard/code_watcher_tests.py index 7787c2a37..456b5846b 100644 --- a/tests/reboot/dashboard/code_watcher_tests.py +++ b/tests/reboot/dashboard/code_watcher_tests.py @@ -105,8 +105,9 @@ async def stock(self, context, request): # The shape of a generated module, as far as the analysis needs: # the state type's class and its servicer bases carrying the state # type's name as `__state_type_name__`, the `Servicer` aliases a -# servicer's base leads through, and the `WeakReference` defining -# the methods a reference is called with. +# servicer's base leads through, the `WeakReference` defining the +# methods a reference is called with, and the `_Factory` defining +# the constructors. GENERATED = ''' from typing import TypeAlias @@ -204,15 +205,28 @@ def until(self, alias) -> '{state}.WeakReference._Until': def ref(cls, state_id) -> '{state}.WeakReference': return {state}.WeakReference() - @classmethod - async def make( - __cls__, - __context__, - state_id=None, - ): - pass + class _Factory: + + @classmethod + async def make( + __cls__, + __context__, + state_id=None, + ): + pass - build = make + build = make + + @classmethod + def idempotently( + cls, + alias=None, + ) -> '{state}._ConstructIdempotently': + return {state}._ConstructIdempotently() + + @classmethod + def factory(cls) -> 'type[{state}._Factory]': + return {state}._Factory class _ConstructIdempotently: @@ -223,10 +237,6 @@ async def make( ): pass - @classmethod - def idempotently(cls, alias=None) -> '{state}._ConstructIdempotently': - return {state}._ConstructIdempotently() - class _Forall: async def look( @@ -1017,11 +1027,11 @@ async def test_a_method_records_the_calls_it_makes(self) -> None: " depot = Depot.ref('d')\n" ' await depot.look(context)\n' " await Shop.ref('s').look(context)\n" - " await Depot.make(context, 'd')\n" + " await Depot.factory().make(context, 'd')\n" ' await depot.schedule().look(context)\n' ' await depot.spawn().look(context)\n' " await depot.idempotently('i').look(context)\n" - " await Depot.idempotently('i').make(context)\n" + " await Depot.factory().idempotently('i').make(context)\n" " await Depot.forall(['a']).look(context)\n" " await depot.until('u').look(context)\n" ' helper(context)\n' @@ -1232,7 +1242,7 @@ async def test_a_call_through_an_alias_of_a_stub(self) -> None: '\n' ' async def look(self, context, request):\n' " await Depot.ref('d').peek(context)\n" - " await Depot.build(context, 'd')\n" + " await Depot.factory().build(context, 'd')\n" ), ) application = self._write('main.py', source=APPLICATION) @@ -2784,14 +2794,14 @@ async def create(self, context, request): await Greeter.ref('g').SetAdjective(context) await me.SetAdjective(context) await self.ref().Greet(context) - await Greeter.Create(context) + await Greeter.factory().Create(context) await greeter.schedule().SetAdjective(context) await me.schedule().Greet(context) await me.spawn().SetAdjective(context) await me.idempotently('i').Greet(context) - await Greeter.idempotently('i').Create(context) + await Greeter.factory().idempotently('i').Create(context) await me.per_workflow().Greet(context) - await Greeter.per_workflow().Create(context) + await Greeter.factory().per_workflow().Create(context) await Greeter.forall(['g']).SetAdjective(context) await me.until('u').Greet(context) ''' diff --git a/tests/reboot/documentation/backend/src/servicers/todos.py b/tests/reboot/documentation/backend/src/servicers/todos.py index 1665ca5d6..eabffcd6f 100644 --- a/tests/reboot/documentation/backend/src/servicers/todos.py +++ b/tests/reboot/documentation/backend/src/servicers/todos.py @@ -46,7 +46,7 @@ async def create( ) -> None: """Runs once, when a person signs in for the first time: give them a list to start with.""" - todo_list, _ = await TodoList.create( + todo_list, _ = await TodoList.factory().create( context, title="Getting started", owner_id=context.state_id, @@ -78,7 +78,7 @@ async def create_todo_list( ) -> CreateTodoListResponse: """Create a list owned by the signed-in person and remember it on their `User`.""" - todo_list, _ = await TodoList.create( + todo_list, _ = await TodoList.factory().create( context, title=request.title, owner_id=context.state_id, diff --git a/tests/reboot/pydantic/shared_error/test.py b/tests/reboot/pydantic/shared_error/test.py index ee6ba6188..a1b3b2994 100644 --- a/tests/reboot/pydantic/shared_error/test.py +++ b/tests/reboot/pydantic/shared_error/test.py @@ -28,9 +28,11 @@ async def asyncTearDown(self) -> None: async def test_transfer_aborts_with_the_accounts_error(self) -> None: context = self.rbt.create_external_context(name=self.id()) - payer, _ = await Account.open(context, 'payer', balance=100.0) - payee, _ = await Account.open(context, 'payee', balance=0.0) - bank, _ = await Bank.create(context, 'bank') + payer, _ = await Account.factory().open( + context, 'payer', balance=100.0 + ) + payee, _ = await Account.factory().open(context, 'payee', balance=0.0) + bank, _ = await Bank.factory().create(context, 'bank') with self.assertRaises(Bank.TransferAborted) as aborted: await bank.transfer( @@ -50,9 +52,11 @@ async def test_transfer_aborts_with_the_accounts_error(self) -> None: async def test_transfer_within_the_balance_moves_it(self) -> None: context = self.rbt.create_external_context(name=self.id()) - payer, _ = await Account.open(context, 'payer', balance=100.0) - payee, _ = await Account.open(context, 'payee', balance=0.0) - bank, _ = await Bank.create(context, 'bank') + payer, _ = await Account.factory().open( + context, 'payer', balance=100.0 + ) + payee, _ = await Account.factory().open(context, 'payee', balance=0.0) + bank, _ = await Bank.factory().create(context, 'bank') await bank.transfer( context, diff --git a/tests/reboot/server/local_envoy_test.py b/tests/reboot/server/local_envoy_test.py index b9654b253..875cdf8b2 100644 --- a/tests/reboot/server/local_envoy_test.py +++ b/tests/reboot/server/local_envoy_test.py @@ -447,7 +447,7 @@ async def test_mangled_path_filter(self): f"a{chr(code)}b" for code in range(0x20, 0x7f) if chr(code) != '\\' ] for state_id in special_state_ids: - await General.ConstructorWriter(context, state_id) + await General.factory().ConstructorWriter(context, state_id) status, body = await _post_exact_path( url, diff --git a/tests/reboot/transaction_tests.py b/tests/reboot/transaction_tests.py index 16f6b0c01..22f9dd1f1 100644 --- a/tests/reboot/transaction_tests.py +++ b/tests/reboot/transaction_tests.py @@ -235,8 +235,8 @@ async def mock_transaction_should_retry(unary_retried_call): context = self.rbt.create_external_context(name=self.id()) - bank, _ = await Bank.Create(context, SINGLETON_BANK_ID) - other_bank, _ = await Bank.Create(context, 'other-bank') + bank, _ = await Bank.factory().Create(context, SINGLETON_BANK_ID) + other_bank, _ = await Bank.factory().Create(context, 'other-bank') await bank.SignUp(context, account_id='ben', initial_deposit=100) await bank.SignUp( @@ -392,8 +392,8 @@ async def mock_transaction_should_retry(unary_retried_call): context = self.rbt.create_external_context(name=self.id()) - bank, _ = await Bank.Create(context, SINGLETON_BANK_ID) - other_bank, _ = await Bank.Create(context, 'other-bank') + bank, _ = await Bank.factory().Create(context, SINGLETON_BANK_ID) + other_bank, _ = await Bank.factory().Create(context, 'other-bank') await bank.SignUp(context, account_id='ben', initial_deposit=100) await bank.SignUp( @@ -606,12 +606,12 @@ async def mock_nested_transaction_should_retry(retried_call): context = self.rbt.create_external_context(name=self.id()) - await General.ConstructorWriter( + await General.factory().ConstructorWriter( context, 'ben', content={"balance": "100"}, ) - await General.ConstructorWriter( + await General.factory().ConstructorWriter( context, 'jonathan', content={"balance": "100"}, @@ -619,7 +619,7 @@ async def mock_nested_transaction_should_retry(retried_call): started = time.monotonic() - await General.ConstructorTransaction( + await General.factory().ConstructorTransaction( context, 'transfers', content={ @@ -725,15 +725,15 @@ async def Transaction( ) context = self.rbt.create_external_context(name=self.id()) - await General.ConstructorWriter(context, 'target') + await General.factory().ConstructorWriter(context, 'target') await asyncio.gather( - General.ConstructorTransaction( + General.factory().ConstructorTransaction( context, 'root-1', content={"target": "target"}, ), - General.ConstructorTransaction( + General.factory().ConstructorTransaction( context, 'root-2', content={"target": "target"}, @@ -800,15 +800,15 @@ async def SharedTransaction( ) context = self.rbt.create_external_context(name=self.id()) - await General.ConstructorWriter(context, 'target') + await General.factory().ConstructorWriter(context, 'target') await asyncio.gather( - General.ConstructorTransaction( + General.factory().ConstructorTransaction( context, 'root-1', content={"target": "target"}, ), - General.ConstructorTransaction( + General.factory().ConstructorTransaction( context, 'root-2', content={"target": "target"}, @@ -1502,7 +1502,7 @@ async def mock_commit(state_manager, request, grpc_context): context = self.rbt.create_external_context(name=self.id()) - bank, _ = await Bank.Create(context, SINGLETON_BANK_ID) + bank, _ = await Bank.factory().Create(context, SINGLETON_BANK_ID) bank_server_id, account_server_id = await self.rbt.unique_servers( bank._state_ref,