reflex 0.7.14a6__py3-none-any.whl → 0.8.0__py3-none-any.whl

reflex/utils/prerequisites.py

@@ -39,9 +39,8 @@ from reflex.compiler import templates
 from reflex.config import Config, get_config
 from reflex.environment import environment
 from reflex.utils import console, net, path_ops, processes, redir
-from reflex.utils.decorator import once
 from reflex.utils.exceptions import SystemPackageMissingError
-from reflex.utils.format import format_library_name
+from reflex.utils.misc import get_module_path
 from reflex.utils.registry import get_npm_registry
 
 if typing.TYPE_CHECKING:
@@ -74,7 +73,7 @@ class CpuInfo:
 
 
 def get_web_dir() -> Path:
-    """Get the working directory for the next.js commands.
+    """Get the working directory for the frontend.
 
     Can be overridden with REFLEX_WEB_WORKDIR.
 
@@ -117,7 +116,7 @@ def check_latest_package_version(package_name: str):
         # Get the latest version from PyPI
         current_version = importlib.metadata.version(package_name)
         url = f"https://pypi.org/pypi/{package_name}/json"
-        response = net.get(url)
+        response = net.get(url, timeout=2)
         latest_version = response.json()["info"]["version"]
         console.debug(f"Latest version of {package_name}: {latest_version}")
         if get_or_set_last_reflex_version_check_datetime():
@@ -334,13 +333,14 @@ def npm_escape_hatch() -> bool:
 
 
 def _check_app_name(config: Config):
-    """Check if the app name is set in the config.
+    """Check if the app name is valid and matches the folder structure.
 
     Args:
         config: The config object.
 
     Raises:
-        RuntimeError: If the app name is not set in the config.
+        RuntimeError: If the app name is not set, folder doesn't exist, or doesn't match config.
+        ModuleNotFoundError: If the app_name is not importable (i.e., not a valid Python package, folder structure being wrong).
     """
     if not config.app_name:
         msg = (
@@ -349,6 +349,18 @@ def _check_app_name(config: Config):
         )
         raise RuntimeError(msg)
 
+    from reflex.utils.misc import get_module_path, with_cwd_in_syspath
+
+    with with_cwd_in_syspath():
+        module_path = get_module_path(config.module)
+        if module_path is None:
+            msg = f"Module {config.module} not found. "
+            if config.app_module_import is not None:
+                msg += f"Ensure app_module_import='{config.app_module_import}' in rxconfig.py matches your folder structure."
+            else:
+                msg += f"Ensure app_name='{config.app_name}' in rxconfig.py matches your folder structure."
+            raise ModuleNotFoundError(msg)
+
 
 def get_app(reload: bool = False) -> ModuleType:
     """Get the app module based on the default config.
@@ -439,7 +451,7 @@ def validate_app(
 
 def get_compiled_app(
     reload: bool = False,
-    export: bool = False,
+    prerender_routes: bool = False,
     dry_run: bool = False,
     check_if_schema_up_to_date: bool = False,
 ) -> ModuleType:
@@ -447,7 +459,7 @@ def get_compiled_app(
 
     Args:
         reload: Re-import the app module from disk
-        export: Compile the app for export
+        prerender_routes: Whether to prerender routes.
         dry_run: If True, do not write the compiled app to disk.
         check_if_schema_up_to_date: If True, check if the schema is up to date.
 
@@ -460,13 +472,13 @@ def get_compiled_app(
     # For py3.9 compatibility when redis is used, we MUST add any decorator pages
     # before compiling the app in a thread to avoid event loop error (REF-2172).
     app._apply_decorated_pages()
-    app._compile(export=export, dry_run=dry_run)
+    app._compile(prerender_routes=prerender_routes, dry_run=dry_run)
     return app_module
 
 
 def compile_app(
     reload: bool = False,
-    export: bool = False,
+    prerender_routes: bool = False,
     dry_run: bool = False,
     check_if_schema_up_to_date: bool = False,
 ) -> None:
@@ -474,13 +486,13 @@ def compile_app(
 
     Args:
         reload: Re-import the app module from disk
-        export: Compile the app for export
+        prerender_routes: Whether to prerender routes.
         dry_run: If True, do not write the compiled app to disk.
         check_if_schema_up_to_date: If True, check if the schema is up to date.
     """
     get_compiled_app(
         reload=reload,
-        export=export,
+        prerender_routes=prerender_routes,
         dry_run=dry_run,
         check_if_schema_up_to_date=check_if_schema_up_to_date,
     )
@@ -529,20 +541,26 @@ def _can_colorize() -> bool:
 
 
 def compile_or_validate_app(
-    compile: bool = False, check_if_schema_up_to_date: bool = False
+    compile: bool = False,
+    check_if_schema_up_to_date: bool = False,
+    prerender_routes: bool = False,
 ) -> bool:
     """Compile or validate the app module based on the default config.
 
     Args:
         compile: Whether to compile the app.
         check_if_schema_up_to_date: If True, check if the schema is up to date.
+        prerender_routes: Whether to prerender routes.
 
     Returns:
         If the app is compiled successfully.
     """
     try:
         if compile:
-            compile_app(check_if_schema_up_to_date=check_if_schema_up_to_date)
+            compile_app(
+                check_if_schema_up_to_date=check_if_schema_up_to_date,
+                prerender_routes=prerender_routes,
+            )
         else:
             validate_app(check_if_schema_up_to_date=check_if_schema_up_to_date)
     except Exception as e:
@@ -591,19 +609,19 @@ def get_redis_sync() -> RedisSync | None:
 
 
 def parse_redis_url() -> str | None:
-    """Parse the REDIS_URL in config if applicable.
+    """Parse the REFLEX_REDIS_URL in config if applicable.
 
     Returns:
         If url is non-empty, return the URL as it is.
 
     Raises:
-        ValueError: If the REDIS_URL is not a supported scheme.
+        ValueError: If the REFLEX_REDIS_URL is not a supported scheme.
     """
     config = get_config()
     if not config.redis_url:
         return None
     if not config.redis_url.startswith(("redis://", "rediss://", "unix://")):
-        msg = "REDIS_URL must start with 'redis://', 'rediss://', or 'unix://'."
+        msg = "REFLEX_REDIS_URL must start with 'redis://', 'rediss://', or 'unix://'."
         raise ValueError(msg)
     return config.redis_url
 
@@ -720,14 +738,11 @@ def rename_app(new_app_name: str, loglevel: constants.LogLevel):
     sys.path.insert(0, str(Path.cwd()))
 
     config = get_config()
-    module_path = importlib.util.find_spec(config.module)
+    module_path = get_module_path(config.module)
     if module_path is None:
         console.error(f"Could not find module {config.module}.")
         raise click.exceptions.Exit(1)
 
-    if not module_path.origin:
-        console.error(f"Could not find origin for module {config.module}.")
-        raise click.exceptions.Exit(1)
     console.info(f"Renaming app directory to {new_app_name}.")
     process_directory(
         Path.cwd(),
@@ -736,7 +751,7 @@ def rename_app(new_app_name: str, loglevel: constants.LogLevel):
         exclude_dirs=[constants.Dirs.WEB, constants.Dirs.APP_ASSETS],
     )
 
-    rename_path_up_tree(Path(module_path.origin), config.app_name, new_app_name)
+    rename_path_up_tree(module_path, config.app_name, new_app_name)
 
     console.success(f"App directory renamed to [bold]{new_app_name}[/bold].")
 
@@ -1017,29 +1032,19 @@ def initialize_web_directory():
     console.debug("Initializing the public directory.")
     path_ops.mkdir(get_web_dir() / constants.Dirs.PUBLIC)
 
-    console.debug("Initializing the next.config.js file.")
-    update_next_config()
+    console.debug("Initializing the react-router.config.js file.")
+    update_react_router_config()
 
     console.debug("Initializing the reflex.json file.")
     # Initialize the reflex json file.
     init_reflex_json(project_hash=project_hash)
 
 
-@once
-def _turbopack_flag() -> str:
-    return " --turbopack" if environment.REFLEX_USE_TURBOPACK.get() else ""
-
-
 def _compile_package_json():
     return templates.PACKAGE_JSON.render(
         scripts={
-            "dev": constants.PackageJson.Commands.DEV.format(flags=_turbopack_flag()),
-            "export": constants.PackageJson.Commands.EXPORT.format(
-                flags=_turbopack_flag()
-            ),
-            "export_sitemap": constants.PackageJson.Commands.EXPORT_SITEMAP.format(
-                flags=_turbopack_flag()
-            ),
+            "dev": constants.PackageJson.Commands.DEV,
+            "export": constants.PackageJson.Commands.EXPORT,
             "prod": constants.PackageJson.Commands.PROD,
         },
         dependencies=constants.PackageJson.DEPENDENCIES,
@@ -1107,50 +1112,43 @@ def init_reflex_json(project_hash: int | None):
     path_ops.update_json_file(get_web_dir() / constants.Reflex.JSON, reflex_json)
 
 
-def update_next_config(
-    export: bool = False, transpile_packages: list[str] | None = None
-):
-    """Update Next.js config from Reflex config.
+def update_react_router_config(prerender_routes: bool = False):
+    """Update react-router.config.js config from Reflex config.
 
     Args:
-        export: if the method run during reflex export.
-        transpile_packages: list of packages to transpile via next.config.js.
+        prerender_routes: Whether to enable prerendering of routes.
     """
-    next_config_file = get_web_dir() / constants.Next.CONFIG_FILE
+    react_router_config_file_path = get_web_dir() / constants.ReactRouter.CONFIG_FILE
 
-    next_config = _update_next_config(
-        get_config(), export=export, transpile_packages=transpile_packages
+    new_react_router_config = _update_react_router_config(
+        get_config(), prerender_routes=prerender_routes
     )
 
-    # Overwriting the next.config.js triggers a full server reload, so make sure
+    # Overwriting the config file triggers a full server reload, so make sure
     # there is actually a diff.
-    orig_next_config = next_config_file.read_text() if next_config_file.exists() else ""
-    if orig_next_config != next_config:
-        next_config_file.write_text(next_config)
+    old_react_router_config = (
+        react_router_config_file_path.read_text()
+        if react_router_config_file_path.exists()
+        else ""
+    )
+    if old_react_router_config != new_react_router_config:
+        react_router_config_file_path.write_text(new_react_router_config)
 
 
-def _update_next_config(
-    config: Config, export: bool = False, transpile_packages: list[str] | None = None
-):
-    next_config = {
-        "basePath": config.frontend_path or "",
-        "compress": config.next_compression,
-        "trailingSlash": True,
-        "staticPageGenerationTimeout": config.static_page_generation_timeout,
+def _update_react_router_config(config: Config, prerender_routes: bool = False):
+    react_router_config = {
+        "basename": "/" + (config.frontend_path or "").removeprefix("/"),
+        "future": {
+            "unstable_optimizeDeps": True,
+        },
+        "ssr": False,
     }
-    if not config.next_dev_indicators:
-        next_config["devIndicators"] = False
 
-    if transpile_packages:
-        next_config["transpilePackages"] = list(
-            dict.fromkeys([format_library_name(p) for p in transpile_packages])
-        )
-    if export:
-        next_config["output"] = "export"
-        next_config["distDir"] = constants.Dirs.STATIC
+    if prerender_routes:
+        react_router_config["prerender"] = True
+        react_router_config["build"] = constants.Dirs.BUILD_DIR
 
-    next_config_json = re.sub(r'"([^"]+)"(?=:)', r"\1", json.dumps(next_config))
-    return f"module.exports = {next_config_json};"
+    return f"export default {json.dumps(react_router_config)};"
 
 
 def remove_existing_bun_installation():

reflex/utils/processes.py

@@ -4,17 +4,18 @@ from __future__ import annotations
 
 import collections
 import contextlib
-import importlib.metadata
 import os
 import signal
+import socket
 import subprocess
 from collections.abc import Callable, Generator, Sequence
 from concurrent import futures
+from contextlib import closing
 from pathlib import Path
 from typing import Any, Literal, overload
 
 import click
-import psutil
+import rich.markup
 from redis.exceptions import RedisError
 from rich.progress import Progress
 
@@ -52,29 +53,6 @@ def get_num_workers() -> int:
     return (os.cpu_count() or 1) * 2 + 1
 
 
-def get_process_on_port(port: int) -> psutil.Process | None:
-    """Get the process on the given port.
-
-    Args:
-        port: The port.
-
-    Returns:
-        The process on the given port.
-    """
-    for proc in psutil.process_iter(["pid", "name", "cmdline"]):
-        with contextlib.suppress(
-            psutil.NoSuchProcess, psutil.AccessDenied, psutil.ZombieProcess
-        ):
-            if importlib.metadata.version("psutil") >= "6.0.0":
-                conns = proc.net_connections(kind="inet")
-            else:
-                conns = proc.connections(kind="inet")
-            for conn in conns:
-                if conn.laddr.port == int(port):
-                    return proc
-    return None
-
-
 def is_process_on_port(port: int) -> bool:
     """Check if a process is running on the given port.
 
@@ -84,18 +62,16 @@ def is_process_on_port(port: int) -> bool:
     Returns:
         Whether a process is running on the given port.
     """
-    return get_process_on_port(port) is not None
+    # Test IPv4 localhost (127.0.0.1)
+    with closing(socket.socket(socket.AF_INET, socket.SOCK_STREAM)) as sock:
+        ipv4_result = sock.connect_ex(("127.0.0.1", port)) == 0
 
+    # Test IPv6 localhost (::1)
+    with closing(socket.socket(socket.AF_INET6, socket.SOCK_STREAM)) as sock:
+        ipv6_result = sock.connect_ex(("::1", port)) == 0
 
-def kill_process_on_port(port: int):
-    """Kill the process on the given port.
-
-    Args:
-        port: The port.
-    """
-    if get_process_on_port(port) is not None:
-        with contextlib.suppress(psutil.AccessDenied):
-            get_process_on_port(port).kill()  # pyright: ignore [reportOptionalMemberAccess]
+    # Port is in use if either IPv4 or IPv6 is listening
+    return ipv4_result or ipv6_result
 
 
 def change_port(port: int, _type: str) -> int:
@@ -133,13 +109,13 @@ def handle_port(service_name: str, port: int, auto_increment: bool) -> int:
     Raises:
         Exit:when the port is in use.
     """
-    if (process := get_process_on_port(port)) is None:
+    console.debug(f"Checking if {service_name.capitalize()} port: {port} is in use.")
+    if not is_process_on_port(port):
+        console.debug(f"{service_name.capitalize()} port: {port} is not in use.")
         return port
     if auto_increment:
         return change_port(port, service_name)
-    console.error(
-        f"{service_name.capitalize()} port: {port} is already in use by PID: {process.pid}."
-    )
+    console.error(f"{service_name.capitalize()} port: {port} is already in use.")
     raise click.exceptions.Exit
 
 
@@ -306,7 +282,7 @@ def stream_logs(
             return
         try:
             for line in process.stdout:
-                console.debug(line, end="", progress=progress)
+                console.debug(rich.markup.escape(line), end="", progress=progress)
                 logs.append(line)
                 yield line
         except ValueError:
@@ -320,7 +296,8 @@ def stream_logs(
 
     # Windows uvicorn bug
     # https://github.com/reflex-dev/reflex/issues/2335
-    accepted_return_codes = [0, -2, 15] if constants.IS_WINDOWS else [0, -2]
+    # 130 is the exit code that react router returns when it is interrupted by a signal.
+    accepted_return_codes = [0, -2, 15, 130] if constants.IS_WINDOWS else [0, -2, 130]
     if process.returncode not in accepted_return_codes and not suppress_errors:
         console.error(f"{message} failed with exit code {process.returncode}")
         if "".join(logs).count("CERT_HAS_EXPIRED") > 0:
@@ -412,12 +389,12 @@ def show_progress(message: str, process: subprocess.Popen, checkpoints: list[str
         task = progress.add_task(f"{message}: ", total=len(checkpoints))
         for line in stream_logs(message, process, progress=progress):
             # Check for special strings and update the progress bar.
-            for special_string in checkpoints:
-                if special_string in line:
-                    progress.update(task, advance=1)
-                    if special_string == checkpoints[-1]:
-                        progress.update(task, completed=len(checkpoints))
-                    break
+            special_string = checkpoints[0]
+            if special_string in line:
+                progress.update(task, advance=1)
+                checkpoints.pop(0)
+            if not checkpoints:
+                break
 
 
 def atexit_handler():

reflex/utils/pyi_generator.py

@@ -13,7 +13,6 @@ import subprocess
 import sys
 import typing
 from collections.abc import Callable, Iterable, Sequence
-from fileinput import FileInput
 from hashlib import md5
 from inspect import getfullargspec
 from itertools import chain
@@ -67,7 +66,6 @@ OVERWRITE_TYPES = {
 }
 
 DEFAULT_TYPING_IMPORTS = {
-    "overload",
     "Any",
     "Callable",
     "Dict",
@@ -90,6 +88,7 @@ DEFAULT_IMPORTS = {
         "EventSpec",
         "EventType",
         "KeyInputInfo",
+        "PointerEventInfo",
     ],
     "reflex.style": ["Style"],
     "reflex.vars.base": ["Var"],
@@ -366,7 +365,7 @@ def _extract_class_props_as_ast_nodes(
     all_props = []
     kwargs = []
     for target_class in clzs:
-        event_triggers = target_class._create([]).get_event_triggers()
+        event_triggers = target_class.get_event_triggers()
         # Import from the target class to ensure type hints are resolvable.
         exec(f"from {target_class.__module__} import *", type_hint_globals)
         for name, value in target_class.__annotations__.items():
@@ -409,7 +408,7 @@ def _extract_class_props_as_ast_nodes(
                             )
                         ),
                     ),
-                    ast.Constant(value=default),
+                    ast.Constant(value=default),  # pyright: ignore [reportArgumentType]
                 )
             )
     return kwargs
@@ -444,7 +443,11 @@ def type_to_ast(typ: Any, cls: type) -> ast.expr:
 
                 if all(a == b for a, b in zipped) and len(typ_parts) == len(cls_parts):
                     return ast.Name(id=typ.__name__)
-
+                if (
+                    typ.__module__ in DEFAULT_IMPORTS
+                    and typ.__name__ in DEFAULT_IMPORTS[typ.__module__]
+                ):
+                    return ast.Name(id=typ.__name__)
                 return ast.Name(id=typ.__module__ + "." + typ.__name__)
             return ast.Name(id=typ.__name__)
         if hasattr(typ, "_name"):
@@ -607,7 +610,7 @@ def _generate_component_create_functiondef(
             return ast.Name(id=f"{' | '.join(map(ast.unparse, all_count_args_type))}")
         return ast.Name(id="EventType[Any]")
 
-    event_triggers = clz._create([]).get_event_triggers()
+    event_triggers = clz.get_event_triggers()
 
     # event handler kwargs
     kwargs.extend(
@@ -672,10 +675,7 @@ def _generate_component_create_functiondef(
                 value=ast.Constant(value=Ellipsis),
             ),
         ],
-        decorator_list=[
-            ast.Name(id="overload"),
-            *decorator_list,
-        ],
+        decorator_list=list(decorator_list),
         lineno=lineno,
         returns=ast.Constant(value=clz.__name__),
     )
@@ -891,7 +891,7 @@ class StubGenerator(ast.NodeTransformer):
             The modified ImportFrom node.
         """
         if node.module == "__future__":
-            return None  # ignore __future__ imports
+            return None  # ignore __future__ imports: https://docs.astral.sh/ruff/rules/future-annotations-in-stub/
         return self.visit_Import(node)
 
     def visit_ClassDef(self, node: ast.ClassDef) -> ast.ClassDef:
@@ -1104,9 +1104,10 @@ class PyiGenerator:
 
     def _get_init_lazy_imports(self, mod: tuple | ModuleType, new_tree: ast.AST):
         # retrieve the _SUBMODULES and _SUBMOD_ATTRS from an init file if present.
-        sub_mods = getattr(mod, "_SUBMODULES", None)
-        sub_mod_attrs = getattr(mod, "_SUBMOD_ATTRS", None)
-        pyright_ignore_imports = getattr(mod, "_PYRIGHT_IGNORE_IMPORTS", [])
+        sub_mods: set[str] | None = getattr(mod, "_SUBMODULES", None)
+        sub_mod_attrs: dict[str, list[str | tuple[str, str]]] | None = getattr(
+            mod, "_SUBMOD_ATTRS", None
+        )
 
         if not sub_mods and not sub_mod_attrs:
             return None
@@ -1114,31 +1115,34 @@ class PyiGenerator:
         sub_mod_attrs_imports = []
 
         if sub_mods:
-            sub_mods_imports = [
-                f"from . import {mod} as {mod}" for mod in sorted(sub_mods)
-            ]
+            sub_mods_imports = [f"from . import {mod}" for mod in sorted(sub_mods)]
             sub_mods_imports.append("")
 
         if sub_mod_attrs:
-            sub_mod_attrs = {
-                attr: mod for mod, attrs in sub_mod_attrs.items() for attr in attrs
+            flattened_sub_mod_attrs = {
+                imported: module
+                for module, attrs in sub_mod_attrs.items()
+                for imported in attrs
             }
             # construct the import statement and handle special cases for aliases
             sub_mod_attrs_imports = [
-                f"from .{path} import {mod if not isinstance(mod, tuple) else mod[0]} as {mod if not isinstance(mod, tuple) else mod[1]}"
+                f"from .{module} import "
                 + (
-                    "  # type: ignore"
-                    if mod in pyright_ignore_imports
-                    else "  # noqa: F401"  # ignore ruff formatting here for cases like rx.list.
-                    if isinstance(mod, tuple)
-                    else ""
+                    (
+                        (imported[0] + " as " + imported[1])
+                        if imported[0] != imported[1]
+                        else imported[0]
+                    )
+                    if isinstance(imported, tuple)
+                    else imported
                 )
-                for mod, path in sub_mod_attrs.items()
+                for imported, module in flattened_sub_mod_attrs.items()
             ]
             sub_mod_attrs_imports.append("")
 
         text = "\n" + "\n".join([*sub_mods_imports, *sub_mod_attrs_imports])
-        text += ast.unparse(new_tree) + "\n"
+        text += ast.unparse(new_tree) + "\n\n"
+        text += f"__all__ = {getattr(mod, '__all__', [])!r}\n"
         return text
 
     def _scan_file(self, module_path: Path) -> tuple[str, str] | None:
@@ -1253,10 +1257,7 @@ class PyiGenerator:
         if file_paths:
             subprocess.run(["ruff", "format", *file_paths])
             subprocess.run(["ruff", "check", "--fix", *file_paths])
-
-        # For some reason, we need to format the __init__.pyi files again after fixing...
-        init_files = [f for f in file_paths if "/__init__.pyi" in f]
-        subprocess.run(["ruff", "format", *init_files])
+            subprocess.run(["ruff", "format", *file_paths])
 
         if use_json:
             if file_paths and changed_files is None:
@@ -1322,27 +1323,21 @@ class PyiGenerator:
                         json.dumps(pyi_hashes, indent=2, sort_keys=True) + "\n"
                     )
 
-        # Post-process the generated pyi files to add hacky type: ignore comments
-        for file_path in file_paths:
-            with FileInput(file_path, inplace=True) as f:
-                for line in f:
-                    # Hack due to ast not supporting comments in the tree.
-                    if (
-                        "def create(" in line
-                        or "Var[Figure]" in line
-                        or "Var[Template]" in line
-                    ):
-                        line = line.rstrip() + "  # type: ignore\n"
-                    print(line, end="")  # noqa: T201
-
 
 if __name__ == "__main__":
+    import argparse
+
+    parser = argparse.ArgumentParser(description="Generate .pyi stub files")
+    parser.add_argument(
+        "targets",
+        nargs="*",
+        default=["reflex/components", "reflex/experimental", "reflex/__init__.py"],
+        help="Target directories/files to process",
+    )
+    args = parser.parse_args()
+
     logging.basicConfig(level=logging.INFO)
     logging.getLogger("blib2to3.pgen2.driver").setLevel(logging.INFO)
 
     gen = PyiGenerator()
-    gen.scan_all(
-        ["reflex/components", "reflex/experimental", "reflex/__init__.py"],
-        None,
-        use_json=True,
-    )
+    gen.scan_all(args.targets, None, use_json=True)

reflex/utils/serializers.py

@@ -9,7 +9,7 @@ import functools
 import inspect
 import json
 import warnings
-from collections.abc import Callable, Sequence
+from collections.abc import Callable, Mapping, Sequence
 from datetime import date, datetime, time, timedelta
 from enum import Enum
 from pathlib import Path
@@ -335,6 +335,19 @@ def serialize_sequence(value: Sequence) -> list:
     return list(value)
 
 
+@serializer(to=dict)
+def serialize_mapping(value: Mapping) -> dict:
+    """Serialize a mapping type to a dictionary.
+
+    Args:
+        value: The mapping instance to serialize.
+
+    Returns:
+        A new dictionary containing the same key-value pairs as the input mapping.
+    """
+    return {**value}
+
+
 @serializer(to=str)
 def serialize_datetime(dt: date | datetime | time | timedelta) -> str:
     """Serialize a datetime to a JSON string.