Add `rebuild()` method for `TypeAdapter` and simplify `defer_build` patterns #10537

sydney-runkle · 2024-10-01T19:55:14Z

This started as a simplification for the defer_build logic, but also touches a few other things in type_adapter.py.

We are removing the experimental_ flag associated with defer_build for TypeAdapter in v2.10, so I think we should also go ahead and simplify this logic now so that we can avoid breaking changes in future releases.

Closes #10632

Main changes:

Remove complexity of frame_depth wrappers
Add rebuild() function to type adapter instances to mimick the model_rebuild() pattern on BaseModels
Revert core_schema, validator, and serializer back to simple attributes rather than properties - this is more consistent with that of BaseModels - said properties silently fail to Mock... structure son schema build if annotations cannot be evaluated.
Add rebuild logic in json schema generation (like that for models)
Make defer_build and model_config properties, not functions

Note, there's a nice little perf boost here :)

cloudflare-workers-and-pages · 2024-10-01T19:56:37Z

Deploying pydantic-docs with Cloudflare Pages

Latest commit:	`b14206b`
Status:	✅ Deploy successful!
Preview URL:	https://b431536a.pydantic-docs.pages.dev
Branch Preview URL:	https://ta-defer-build-simplificatio.pydantic-docs.pages.dev

View logs

codspeed-hq · 2024-10-01T20:01:23Z

CodSpeed Performance Report

Merging #10537 will improve performances by 17.17%

_{Comparing ta-defer-build-simplification (b14206b) with main (9783bc8)}

Summary

⚡ 1 improvements
✅ 43 untouched benchmarks

Benchmarks breakdown

	Benchmark	`main`	`ta-defer-build-simplification`	Change
⚡	`test_efficiency_with_highly_nested_examples`	919.5 µs	784.8 µs	+17.17%

Viicos · 2024-10-02T14:49:58Z

My best guess regarding why the deferred parent namespace fetching was implemented was to support the following:

from pydantic import TypeAdapter

def func():
    ta = TypeAdapter("Forward", config={"defer_build": True})

    Forward = int

    ta.core_schema  # triggers the core schema build, and `frame.f_locals` is only fetched at this point, so it includes `Forward`

Which presumably won't work anymore with this PR. I'll not that this pattern feels "dangerous", as one can do:

def func():
    ta = TypeAdapter("Forward", config={"defer_build": True})

    Forward = int

    return ta

ta = func()
ta.core_schema  # PydanticUndefinedAnnotation: name 'Forward' is not defined, because locals were gc'ed.

# Things could also be worse, if you defined `Forward = str` before calling `ta.core_schema` here

So I think we need to be careful here before making the change. People might be relying on this behavior?

sydney-runkle · 2024-10-02T15:18:08Z

My best guess regarding why the deferred parent namespace fetching was implemented was to support the following:

I'd argue that we shouldnt' support rebuilds on attribute accesses for core_schema, validator, and serializer, as we don't do that for __pydantic_core_schema__, etc.

Indeed, this is an issue, but it's one that we run into with BaseModel as well, which is why we cache the parent namespace 😢, so maybe we should be doing that for consistency?

sydney-runkle · 2024-10-02T15:23:22Z

I'll note, this works:

from pydantic import BaseModel, TypeAdapter, ConfigDict

Int = int

def tester_model() -> None:
    class Model(BaseModel):
        i: Int

        model_config = ConfigDict(defer_build=True)

    print(Model.__pydantic_core_schema__)
    # mock core schema
    Model.model_rebuild()
    print(Model.__pydantic_core_schema__)
    # works, displays a core schema

tester_model()

def tester_adapter() -> None:
    ta = TypeAdapter(Int, config=ConfigDict(defer_build=True))

    print(ta.core_schema)
    # mock core schema
    ta.rebuild()
    print(ta.core_schema)
    # works, displays a core schema
  
tester_adapter()

sydney-runkle · 2024-10-03T16:04:15Z

Admittedly, I don't think this should undergo serious review until we merge #10530

…dantic/pydantic into ta-defer-build-simplification

sydney-runkle · 2024-10-15T15:01:07Z

Closing based on #10632.

Will resume in v2.11

pydantic/_internal/_mock_val_ser.py

pydantic/type_adapter.py

Viicos · 2024-11-11T20:32:15Z

pydantic/_internal/_mock_val_ser.py

+        type_repr: Name of the type used in the adapter, used in error messages
+    """
+    undefined_type_error_message = (
+        f'`TypeAdapter[{type_repr}]` is not fully defined; you should define `{type_repr}` and all referenced types,'


The TypeAdapter[...] form seems a bit weird, especially because type_repr seems to be str(type) when called from TypeAdapter. Probably fine as is, just wanted to note that this may lead to weird string representations (maybe _display.display_as_type could be used, although it is costly to compute).

you could probably rework the APIs a bit to make it possible to defer the cost of computing the error message if it's a concern. Like, make MockCoreSchema accept a callable for the error message rather than just a string

Suggested the same in other comment about making the error message forming lazy. So it only happens on errors

pydantic/type_adapter.py

sydney-runkle · 2024-11-12T13:48:50Z

EDIT: reducing this to closed within a note now that this has been resolved

Details

So I'll note, this works:

from typing import Generic, Optional, TypeVar

from typing_extensions import NamedTuple as TypingExtensionsNamedTuple

from pydantic import TypeAdapter

T = TypeVar('T')


class MyNamedTuple(TypingExtensionsNamedTuple, Generic[T]):
    x: T
    y: Optional['MyNamedTuple[T]']


ta = TypeAdapter(MyNamedTuple[int])
print(ta.validate_python((1, None)))
#> MyNamedTuple(x=1, y=None)

So does this (with the same imports as above)

T = TypeVar('T')

def test_in_function () -> None:
    class MyNamedTuple(TypingExtensionsNamedTuple, Generic[T]):
        x: T
        y: Optional['MyNamedTuple[T]']

    ta = TypeAdapter(MyNamedTuple[int])
    print(ta.validate_python((1, None)))

test_in_function()
#> MyNamedTuple(x=1, y=None)

But alas, this, does not. Debugging now.

def test_in_function () -> None:
    T = TypeVar('T')
    
    class MyNamedTuple(TypingExtensionsNamedTuple, Generic[T]):
        x: T
        y: Optional['MyNamedTuple[T]']

    ta = TypeAdapter(MyNamedTuple[int])
    print(ta.validate_python((1, None)))

test_in_function()

sydney-runkle · 2024-11-12T19:40:57Z

pydantic/type_adapter.py

+            _parent_depth: Depth at which to search the for the parent namespace used for schema building.
+                We also use this as a reference level to find the global namespace (_parent_depth - 1).
+                Defaults to 2 because we expect to reference the frame that called the `TypeAdapter` constructor.


I think it's worth considering - should we default to 1, then add 1 when we call into parent_frame_namespace? That seems more intuitive to me from a user perspective. cc @Viicos.

Though I think this could be a valuable change, it is breaking, as folks are depending on the current behavior. This is _ prefixed though, so we sort of have range to do this.

It could make more sense but would be inconsistent with model_rebuild which suffers from the same issue :/

Alrighty, let's leave as is :(

sydney-runkle · 2024-11-13T14:23:39Z

cc @MarkusSintonen, if you're available, this should be ready for another review :)

pydantic/type_adapter.py

MarkusSintonen · 2024-11-13T15:25:41Z

pydantic/type_adapter.py

+            schema_generator = _generate_schema.GenerateSchema(config_wrapper, ns_resolver=ns_resolver)
+
+            try:
+                core_schema = schema_generator.generate_schema(self._type)
+            except PydanticUndefinedAnnotation:
+                if raise_errors:
+                    raise
+                _mock_val_ser.set_type_adapter_mocks(self, str(self._type))
+                return False
+
+            try:
+                self.core_schema = schema_generator.clean_schema(core_schema)
+            except schema_generator.CollectedInvalid:
+                _mock_val_ser.set_type_adapter_mocks(self, str(self._type))
+                return False


I have seen the same try-catch-if-raise_error-mocking logic repeated in many places. Wondering could it be extracted to some common handling... Maybe later...

Yeah, let's consolidate later

Maybe with 341a778, I can create an issue

sydney-runkle · 2024-11-13T15:29:53Z

Another idea I had, which doesn't fit in scope here. See: 341a778

Details

diff --git a/pydantic/_internal/_mock_val_ser.py b/pydantic/_internal/_mock_val_ser.py
index ddf0a6ac7..9bd8be7d4 100644
--- a/pydantic/_internal/_mock_val_ser.py
+++ b/pydantic/_internal/_mock_val_ser.py
@@ -1,6 +1,7 @@
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Any, Callable, Generic, Iterator, Mapping, TypeVar, Union
+from functools import partial
+from typing import TYPE_CHECKING, Any, Callable, Generic, Iterator, Mapping, TypeAlias, TypeVar, Union
 
 from pydantic_core import CoreSchema, SchemaSerializer, SchemaValidator
 from typing_extensions import Literal
@@ -13,9 +14,8 @@ if TYPE_CHECKING:
     from ..main import BaseModel
     from ..type_adapter import TypeAdapter
 
-
-ValSer = TypeVar('ValSer', bound=Union[SchemaValidator, PluggableSchemaValidator, SchemaSerializer])
-T = TypeVar('T')
+ValidatorOrSerializer: TypeAlias = Union[SchemaValidator, PluggableSchemaValidator, SchemaSerializer]
+ValSer = TypeVar('ValSer', bound=ValidatorOrSerializer)
 
 
 class MockCoreSchema(Mapping[str, Any]):
@@ -109,44 +109,80 @@ class MockValSer(Generic[ValSer]):
         return None
 
 
-def set_type_adapter_mocks(adapter: TypeAdapter, type_repr: str) -> None:
-    """Set `core_schema`, `validator` and `serializer` to mock core types on a type adapter instance.
+MockContainer = TypeVar('MockContainer', bound=type[BaseModel] | TypeAdapter | type[PydanticDataclass])
+RebuildReturnType = TypeVar('RebuildReturnType', bound=CoreSchema | ValidatorOrSerializer)
 
-    Args:
-        adapter: The type adapter instance to set the mocks on
-        type_repr: Name of the type used in the adapter, used in error messages
-    """
-    undefined_type_error_message = (
-        f'`TypeAdapter[{type_repr}]` is not fully defined; you should define `{type_repr}` and all referenced types,'
-        f' then call `.rebuild()` on the instance.'
-    )
 
-    def attempt_rebuild_fn(attr_fn: Callable[[TypeAdapter], T]) -> Callable[[], T | None]:
-        def handler() -> T | None:
-            if adapter.rebuild(_parent_namespace_depth=5) is not False:
-                return attr_fn(adapter)
+class MockFactory(Generic[MockContainer]):
+    """Factory for creating `MockCoreSchema`, `MockValSer` and `MockValSer` instances for a given type."""
+
+    __slots__ = '_obj', '_error_message', '_rebuild'
+
+    def __init__(
+        self,
+        obj: MockContainer,
+        error_message: str,
+        rebuild: Callable[[MockContainer], Callable[..., bool | None]],
+    ) -> None:
+        self._obj = obj
+        self._error_message = error_message
+        self._rebuild = rebuild
+
+    def _attempt_rebuild_fn(
+        self, attr_fn: Callable[[MockContainer], RebuildReturnType | None]
+    ) -> Callable[[], RebuildReturnType | None]:
+        def handler() -> RebuildReturnType | None:
+            if self._rebuild(self._obj)(_parent_namespace_depth=5) is not False:
+                return attr_fn(self._obj)
             else:
                 return None
 
         return handler
 
-    adapter.core_schema = MockCoreSchema(  # pyright: ignore[reportAttributeAccessIssue]
-        undefined_type_error_message,
-        code='class-not-fully-defined',
-        attempt_rebuild=attempt_rebuild_fn(lambda ta: ta.core_schema),
-    )
-    adapter.validator = MockValSer(  # pyright: ignore[reportAttributeAccessIssue]
-        undefined_type_error_message,
-        code='class-not-fully-defined',
-        val_or_ser='validator',
-        attempt_rebuild=attempt_rebuild_fn(lambda ta: ta.validator),
-    )
-    adapter.serializer = MockValSer(  # pyright: ignore[reportAttributeAccessIssue]
-        undefined_type_error_message,
-        code='class-not-fully-defined',
-        val_or_ser='serializer',
-        attempt_rebuild=attempt_rebuild_fn(lambda ta: ta.serializer),
+    def mock_core_schema(self, attr_fn: Callable[[MockContainer], CoreSchema | None]) -> MockCoreSchema:
+        return MockCoreSchema(
+            self._error_message,
+            code='class-not-fully-defined',
+            attempt_rebuild=self._attempt_rebuild_fn(attr_fn),
+        )
+
+    def mock_schema_validator(
+        self, attr_fn: Callable[[MockContainer], SchemaValidator | PluggableSchemaValidator | None]
+    ) -> MockValSer:
+        return MockValSer(
+            self._error_message,
+            code='class-not-fully-defined',
+            val_or_ser='validator',
+            attempt_rebuild=self._attempt_rebuild_fn(attr_fn),
+        )
+
+    def mock_schema_serializer(self, attr_fn: Callable[[MockContainer], SchemaSerializer | None]) -> MockValSer:
+        return MockValSer(
+            self._error_message,
+            code='class-not-fully-defined',
+            val_or_ser='serializer',
+            attempt_rebuild=self._attempt_rebuild_fn(attr_fn),
+        )
+
+
+def set_type_adapter_mocks(adapter: TypeAdapter, type_repr: str) -> None:
+    """Set `core_schema`, `validator` and `serializer` to mock core types on a type adapter instance.
+
+    Args:
+        adapter: The type adapter instance to set the mocks on
+        type_repr: Name of the type used in the adapter, used in error messages
+    """
+    mock_factory = MockFactory[TypeAdapter](
+        obj=adapter,
+        error_message=(
+            f'`TypeAdapter[{type_repr}]` is not fully defined; you should define `{type_repr}` and all referenced types,'
+            f' then call `.rebuild()` on the instance.'
+        ),
+        rebuild=lambda ta: partial(ta.rebuild, raise_errors=False),
     )
+    adapter.core_schema = mock_factory.mock_core_schema(attr_fn=lambda ta: ta.core_schema)  # pyright: ignore[reportAttributeAccessIssue]
+    adapter.validator = mock_factory.mock_schema_validator(attr_fn=lambda ta: ta.validator)  # pyright: ignore[reportAttributeAccessIssue]
+    adapter.serializer = mock_factory.mock_schema_serializer(attr_fn=lambda ta: ta.serializer)  # pyright: ignore[reportAttributeAccessIssue]
 
 
 def set_model_mocks(cls: type[BaseModel], cls_name: str, undefined_name: str = 'all referenced types') -> None:
@@ -157,37 +193,18 @@ def set_model_mocks(cls: type[BaseModel], cls_name: str, undefined_name: str = '
         cls_name: Name of the model class, used in error messages
         undefined_name: Name of the undefined thing, used in error messages
     """
-    undefined_type_error_message = (
-        f'`{cls_name}` is not fully defined; you should define {undefined_name},'
-        f' then call `{cls_name}.model_rebuild()`.'
+    mock_factory = MockFactory[type[BaseModel]](
+        obj=cls,
+        error_message=(
+            f'`{cls_name}` is not fully defined; you should define {undefined_name},'
+            f' then call `{cls_name}.model_rebuild()`.'
+        ),
+        rebuild=lambda c: partial(c.model_rebuild, raise_errors=False),
     )
 
-    def attempt_rebuild_fn(attr_fn: Callable[[type[BaseModel]], T]) -> Callable[[], T | None]:
-        def handler() -> T | None:
-            if cls.model_rebuild(raise_errors=False, _parent_namespace_depth=5) is not False:
-                return attr_fn(cls)
-            else:
-                return None
-
-        return handler
-
-    cls.__pydantic_core_schema__ = MockCoreSchema(  # pyright: ignore[reportAttributeAccessIssue]
-        undefined_type_error_message,
-        code='class-not-fully-defined',
-        attempt_rebuild=attempt_rebuild_fn(lambda c: c.__pydantic_core_schema__),
-    )
-    cls.__pydantic_validator__ = MockValSer(  # pyright: ignore[reportAttributeAccessIssue]
-        undefined_type_error_message,
-        code='class-not-fully-defined',
-        val_or_ser='validator',
-        attempt_rebuild=attempt_rebuild_fn(lambda c: c.__pydantic_validator__),
-    )
-    cls.__pydantic_serializer__ = MockValSer(  # pyright: ignore[reportAttributeAccessIssue]
-        undefined_type_error_message,
-        code='class-not-fully-defined',
-        val_or_ser='serializer',
-        attempt_rebuild=attempt_rebuild_fn(lambda c: c.__pydantic_serializer__),
-    )
+    cls.__pydantic_core_schema__ = mock_factory.mock_core_schema(attr_fn=lambda c: c.__pydantic_core_schema__)  # pyright: ignore[reportAttributeAccessIssue]
+    cls.__pydantic_validator__ = mock_factory.mock_schema_validator(attr_fn=lambda c: c.__pydantic_validator__)  # pyright: ignore[reportAttributeAccessIssue]
+    cls.__pydantic_serializer__ = mock_factory.mock_schema_serializer(attr_fn=lambda c: c.__pydantic_serializer__)  # pyright: ignore[reportAttributeAccessIssue]
 
 
 def set_dataclass_mocks(
@@ -202,34 +219,15 @@ def set_dataclass_mocks(
     """
     from ..dataclasses import rebuild_dataclass
 
-    undefined_type_error_message = (
-        f'`{cls_name}` is not fully defined; you should define {undefined_name},'
-        f' then call `pydantic.dataclasses.rebuild_dataclass({cls_name})`.'
+    mock_factory = MockFactory[type[PydanticDataclass]](
+        obj=cls,
+        error_message=(
+            f'`{cls_name}` is not fully defined; you should define {undefined_name},'
+            f' then call `pydantic.dataclasses.rebuild_dataclass({cls_name})`.'
+        ),
+        rebuild=lambda c: partial(rebuild_dataclass, cls=c, raise_errors=False),
     )
 
-    def attempt_rebuild_fn(attr_fn: Callable[[type[PydanticDataclass]], T]) -> Callable[[], T | None]:
-        def handler() -> T | None:
-            if rebuild_dataclass(cls, raise_errors=False, _parent_namespace_depth=5) is not False:
-                return attr_fn(cls)
-            else:
-                return None
-
-        return handler
-
-    cls.__pydantic_core_schema__ = MockCoreSchema(  # pyright: ignore[reportAttributeAccessIssue]
-        undefined_type_error_message,
-        code='class-not-fully-defined',
-        attempt_rebuild=attempt_rebuild_fn(lambda c: c.__pydantic_core_schema__),
-    )
-    cls.__pydantic_validator__ = MockValSer(  # pyright: ignore[reportAttributeAccessIssue]
-        undefined_type_error_message,
-        code='class-not-fully-defined',
-        val_or_ser='validator',
-        attempt_rebuild=attempt_rebuild_fn(lambda c: c.__pydantic_validator__),
-    )
-    cls.__pydantic_serializer__ = MockValSer(  # pyright: ignore[reportAttributeAccessIssue]
-        undefined_type_error_message,
-        code='class-not-fully-defined',
-        val_or_ser='serializer',
-        attempt_rebuild=attempt_rebuild_fn(lambda c: c.__pydantic_serializer__),
-    )
+    cls.__pydantic_core_schema__ = mock_factory.mock_core_schema(attr_fn=lambda c: c.__pydantic_core_schema__)  # pyright: ignore[reportAttributeAccessIssue]
+    cls.__pydantic_validator__ = mock_factory.mock_schema_validator(attr_fn=lambda c: c.__pydantic_validator__)  # pyright: ignore[reportAttributeAccessIssue]
+    cls.__pydantic_serializer__ = mock_factory.mock_schema_serializer(attr_fn=lambda c: c.__pydantic_serializer__)  # pyright: ignore[reportAttributeAccessIssue]

@Viicos, you might appreciate this, seems better from a type checking perspective perhaps? Or just more consolidated generally.

This reverts commit 341a778.

pydantic/type_adapter.py

pydantic/_internal/_namespace_utils.py

pydantic/type_adapter.py

Viicos

We will still be able to tweak things before the final release if this break existing code with the next beta

sydney-runkle added 2 commits October 1, 2024 15:31

first pass at simplifying namespace management

7051422

more progress

7cc75ac

github-actions bot added the relnotes-fix Used for bugfixes. label Oct 1, 2024

sydney-runkle added relnotes-change Used for changes to existing functionality which don't have a better categorization. and removed relnotes-fix Used for bugfixes. labels Oct 2, 2024

sydney-runkle changed the title ~~WIP: refactor type adapter namespace management~~ Add rebuild() method for TypeAdapter and simplify defer_build patterns Oct 2, 2024

fix some ns fetching

b70682f

sydney-runkle mentioned this pull request Oct 7, 2024

pydantic work plan for Sydney Runkle: October 7th - October 11th, 2024 #10561

Closed

9 tasks

sydney-runkle and others added 4 commits October 11, 2024 10:16

Merge branch 'main' into ta-defer-build-simplification

a6e837e

Merge branch 'ta-defer-build-simplification' of https://github.com/py…

70ef78d

…dantic/pydantic into ta-defer-build-simplification

wip, trying to incorporate new ns logic

9bff182

more ns improvements?

174d9c4

This was referenced Oct 13, 2024

Sydney Runkle's pydantic plan for October 14th-October 18th, 2024 #10615

Closed

Namespace management cleanup for TypeAdapter #10632

Closed

sydney-runkle closed this Oct 15, 2024

sydney-runkle reopened this Nov 10, 2024

sydney-runkle and others added 2 commits November 10, 2024 07:16

Merge branch 'main' into ta-defer-build-simplification

185d45c

formatting

fe4e627

sydney-runkle added the relnotes-performance Used for performance improvements. label Nov 10, 2024

Viicos reviewed Nov 10, 2024

View reviewed changes

pydantic/_internal/_mock_val_ser.py Outdated Show resolved Hide resolved

pydantic/type_adapter.py Outdated Show resolved Hide resolved

Viicos reviewed Nov 11, 2024

View reviewed changes

one fix, adding parentns :)

f9cf65d

sydney-runkle added 5 commits November 12, 2024 14:30

type ignore comments

b3b9987

docs fix

89d5f0e

public pydantic_complete

6d398b0

update init docstring

d73c515

note on parent depth

3bac3d3

sydney-runkle commented Nov 12, 2024

View reviewed changes

sydney-runkle added 2 commits November 13, 2024 09:09

mock on schema build failure, support raise errors

c2130ad

adding rebuild test

0175c04

sydney-runkle requested review from Viicos and MarkusSintonen November 13, 2024 14:25

tiny bug fix

5cf19ed

MarkusSintonen reviewed Nov 13, 2024

View reviewed changes

pydantic/type_adapter.py Outdated Show resolved Hide resolved

optional mock-val-ser refactor

341a778

MarkusSintonen reviewed Nov 13, 2024

View reviewed changes

Revert "optional mock-val-ser refactor"

ec7ed63

This reverts commit 341a778.

sydney-runkle mentioned this pull request Nov 13, 2024

TypeAdapter schema gen optimizations / refactor ideas #10831

Closed

3 tasks

sydney-runkle added 2 commits November 13, 2024 10:34

move namespace docs

60c73b2

oops, on type, not __init__

253119c

Viicos reviewed Nov 13, 2024

View reviewed changes

pydantic/type_adapter.py Outdated Show resolved Hide resolved

remove explicit anns

fa2844c

dmontagu reviewed Nov 13, 2024

View reviewed changes

pydantic/_internal/_namespace_utils.py Outdated Show resolved Hide resolved

Viicos reviewed Nov 13, 2024

View reviewed changes

pydantic/type_adapter.py Outdated Show resolved Hide resolved

Viicos approved these changes Nov 13, 2024

View reviewed changes

update comments

b14206b

sydney-runkle enabled auto-merge (squash) November 13, 2024 17:13

sydney-runkle merged commit c2647ab into main Nov 13, 2024
51 checks passed

sydney-runkle deleted the ta-defer-build-simplification branch November 13, 2024 17:19

sydney-runkle mentioned this pull request Nov 18, 2024

Consolidating shared get / mock core schema logic #10874

Closed

Uh oh!

Add rebuild() method for TypeAdapter and simplify defer_build patterns #10537

Add rebuild() method for TypeAdapter and simplify defer_build patterns #10537

Uh oh!

Conversation

sydney-runkle commented Oct 1, 2024 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

cloudflare-workers-and-pages bot commented Oct 1, 2024 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Deploying pydantic-docs with Cloudflare Pages

Uh oh!

codspeed-hq bot commented Oct 1, 2024 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Merging #10537 will improve performances by 17.17%

Summary

Benchmarks breakdown

Uh oh!

Viicos commented Oct 2, 2024

Uh oh!

sydney-runkle commented Oct 2, 2024

Uh oh!

sydney-runkle commented Oct 2, 2024

Uh oh!

sydney-runkle commented Oct 3, 2024

Uh oh!

sydney-runkle commented Oct 15, 2024

Uh oh!

Uh oh!

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Uh oh!

sydney-runkle commented Nov 12, 2024 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

sydney-runkle commented Nov 13, 2024

Uh oh!

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

sydney-runkle commented Nov 13, 2024 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Viicos left a comment

Choose a reason for hiding this comment

Uh oh!

Uh oh!

Uh oh!

Add `rebuild()` method for `TypeAdapter` and simplify `defer_build` patterns #10537

Add `rebuild()` method for `TypeAdapter` and simplify `defer_build` patterns #10537

sydney-runkle commented Oct 1, 2024 •

edited

Loading

cloudflare-workers-and-pages bot commented Oct 1, 2024 •

edited

Loading

codspeed-hq bot commented Oct 1, 2024 •

edited

Loading

sydney-runkle commented Nov 12, 2024 •

edited

Loading

sydney-runkle commented Nov 13, 2024 •

edited

Loading