gmdbuilder 0.1.0__tar.gz

gmdbuilder-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Xtreme
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

gmdbuilder-0.1.0/PKG-INFO

@@ -0,0 +1,101 @@
+Metadata-Version: 2.4
+Name: gmdbuilder
+Version: 0.1.0
+Summary: An unopinionated General-Purpose Geometry Dash framework for safe and easy level editing and scripting
+License: MIT
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: gmdkit>=0.4.0
+Requires-Dist: questionary>=2.1.1
+Provides-Extra: dev
+Requires-Dist: basedpyright; extra == "dev"
+Requires-Dist: ruff; extra == "dev"
+Requires-Dist: pytest>=7.0; extra == "dev"
+Dynamic: license-file
+
+![Python Badge](https://img.shields.io/badge/Python-3776AB?logo=python&logoColor=fff&style=for-the-badge)
+![Framework](https://img.shields.io/badge/Framework-6A1B9A?style=for-the-badge)
+![License](https://img.shields.io/badge/license-MIT-blue?style=for-the-badge)
+![Level Editor](https://img.shields.io/badge/Level%20Editor-424242?style=for-the-badge)
+
+# gmdbuilder
+A type-safe general-purpose Python framework for pragmatic Geometry Dash level editing and scripting.
+
+gmdbuilder lets you:
+- Read & write Geometry Dash levels
+- Automatically scan and protect against bugs (property types/ranges, spawn limit, etc.)
+- Work directly with triggers, groups, and objects - and choose your own abstractions
+- Use pre-built systems and templates to accelerate development
+
+**gmdbuilder** is developed in collaboration with HDanke, the creator of **gmdkit** (a dependency of this framework) and his unofficial **GD Editor Docs**.
+
+*(No overengineered language was made in the making of this project)* 
+
+## Why Python?
+
+Python fits surprisingly well as a language for GD scripting:
+- Exceptionally good at building/verifying dictionaries (which all GD objects are)
+- Operator overloading for counters and other special logic
+- Any programming paradigm that you want is well supported
+- Reliable type system with good debugger/type-checker tooling
+- Huge package ecosystem
+
+## Installation
+Install the latest release from PyPI (i didnt set this up yet):
+
+```bash
+pip install gmdkit
+```
+
+Install the latest development version from GitHub:
+
+```bash
+pip install git+https://github.com/UHDanke/gmdkit.git
+```
+
+## Getting Started
+
+```python
+from gmdbuilder import level
+
+# This group gets deleted at level-load and automatically added to new objects at level-export
+level.tag_group = 9999 # Set to 9999 by default
+
+# From .gmd file, supports full object editing/deleting
+level.from_file("example.gmd")
+
+# From WSLiveEditor, only supports adidng objects
+level.from_live_editor()
+
+obj_list = level.objects # mutations are validated
+
+# Object properties are in the form { "a<key number>": value }
+repr(obj_list[1])
+
+# Object ID and Property enums (all values are Literal) 
+from gmdbuilder.mappings.obj_prop import ObjProp
+from gmdbuilder.mappings.obj_id import ObjId
+
+for obj in obj_list:
+    if obj[ObjProp.ID] == ObjID.Trigger.MOVE:
+        obj[ObjProp.GROUPS] = {}
+    elif obj[ObjProp.ID] == ObjID.Trigger.COUNT:
+        obj_list.remove(obj)
+
+# Translates to { a1: 1 }
+block = from_raw_object({1: 1})
+
+obj_list.delete_where(block)
+obj_list.delete_where(lambda obj: obj[ObjProp.ID] == 1)
+
+# Translates to { a1: 1611, a2: 50, a3: 45 }
+object = from_object_string("1,1611,2,50,3,45;", obj_type=CountType)
+object[ObjProp.Trigger.Count.ACTIVATE_GROUP] = True
+
+# Export object edits, deletions and additions
+level.export_to_file(file_path="example_updated.gmd")
+
+# Export added objects to WSLiveEditor
+level.export_to_live_editor()
+```

gmdbuilder-0.1.0/README.md

@@ -0,0 +1,85 @@
+![Python Badge](https://img.shields.io/badge/Python-3776AB?logo=python&logoColor=fff&style=for-the-badge)
+![Framework](https://img.shields.io/badge/Framework-6A1B9A?style=for-the-badge)
+![License](https://img.shields.io/badge/license-MIT-blue?style=for-the-badge)
+![Level Editor](https://img.shields.io/badge/Level%20Editor-424242?style=for-the-badge)
+
+# gmdbuilder
+A type-safe general-purpose Python framework for pragmatic Geometry Dash level editing and scripting.
+
+gmdbuilder lets you:
+- Read & write Geometry Dash levels
+- Automatically scan and protect against bugs (property types/ranges, spawn limit, etc.)
+- Work directly with triggers, groups, and objects - and choose your own abstractions
+- Use pre-built systems and templates to accelerate development
+
+**gmdbuilder** is developed in collaboration with HDanke, the creator of **gmdkit** (a dependency of this framework) and his unofficial **GD Editor Docs**.
+
+*(No overengineered language was made in the making of this project)* 
+
+## Why Python?
+
+Python fits surprisingly well as a language for GD scripting:
+- Exceptionally good at building/verifying dictionaries (which all GD objects are)
+- Operator overloading for counters and other special logic
+- Any programming paradigm that you want is well supported
+- Reliable type system with good debugger/type-checker tooling
+- Huge package ecosystem
+
+## Installation
+Install the latest release from PyPI (i didnt set this up yet):
+
+```bash
+pip install gmdkit
+```
+
+Install the latest development version from GitHub:
+
+```bash
+pip install git+https://github.com/UHDanke/gmdkit.git
+```
+
+## Getting Started
+
+```python
+from gmdbuilder import level
+
+# This group gets deleted at level-load and automatically added to new objects at level-export
+level.tag_group = 9999 # Set to 9999 by default
+
+# From .gmd file, supports full object editing/deleting
+level.from_file("example.gmd")
+
+# From WSLiveEditor, only supports adidng objects
+level.from_live_editor()
+
+obj_list = level.objects # mutations are validated
+
+# Object properties are in the form { "a<key number>": value }
+repr(obj_list[1])
+
+# Object ID and Property enums (all values are Literal) 
+from gmdbuilder.mappings.obj_prop import ObjProp
+from gmdbuilder.mappings.obj_id import ObjId
+
+for obj in obj_list:
+    if obj[ObjProp.ID] == ObjID.Trigger.MOVE:
+        obj[ObjProp.GROUPS] = {}
+    elif obj[ObjProp.ID] == ObjID.Trigger.COUNT:
+        obj_list.remove(obj)
+
+# Translates to { a1: 1 }
+block = from_raw_object({1: 1})
+
+obj_list.delete_where(block)
+obj_list.delete_where(lambda obj: obj[ObjProp.ID] == 1)
+
+# Translates to { a1: 1611, a2: 50, a3: 45 }
+object = from_object_string("1,1611,2,50,3,45;", obj_type=CountType)
+object[ObjProp.Trigger.Count.ACTIVATE_GROUP] = True
+
+# Export object edits, deletions and additions
+level.export_to_file(file_path="example_updated.gmd")
+
+# Export added objects to WSLiveEditor
+level.export_to_live_editor()
+```

gmdbuilder-0.1.0/pyproject.toml

@@ -0,0 +1,51 @@
+[build-system]
+requires = ["setuptools>=68.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "gmdbuilder"
+version = "0.1.0"
+description = "An unopinionated General-Purpose Geometry Dash framework for safe and easy level editing and scripting"
+readme = "README.md"
+requires-python = ">=3.11"
+license = {text = "MIT"}
+dependencies = [
+    "gmdkit>=0.4.0",
+    "questionary>=2.1.1"
+]
+
+# Optional dependencies for development
+[project.optional-dependencies]
+dev = [
+    "basedpyright",
+    "ruff",
+    "pytest>=7.0",
+]
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.basedpyright]
+typeCheckingMode = "strict"
+reportAny = "none"
+reportExplicitAny = "none"
+reportMissingTypeStubs = "none"
+
+[tool.ruff.lint]
+ignore = [
+    "E701",  # Multiple statements on one line (colon)
+    "E702",  # Multiple statements on one line (semicolon)
+    "E731",  # Do not assign a lambda expression, use a def
+    "E741",  # Ambiguous variable name (allows single letter vars like l, o, I)
+    # "E402",  # Import not at top line
+    # "F401",  # Imported but unused (useful for __init__.py files)
+    # "F403",  # Star imports (from module import *)
+    # "B008",  # Do not perform function call in argument defaults
+    # "B904",  # Use raise from to specify exception cause
+    # "N802",  # Function name should be lowercase
+    # "N803",  # Argument name should be lowercase
+    # "N806",  # Variable in function should be lowercase
+]
+
+[tool.pytest.ini_options]
+addopts = "-qv"

gmdbuilder-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

gmdbuilder-0.1.0/src/gmdbuilder/core.py

@@ -0,0 +1,158 @@
+"""Core utilities for working with ObjectType dicts."""
+
+from functools import lru_cache
+from typing import Any, Literal, TypeVar, overload
+from gmdkit.models.object import Object as KitObject
+from gmdkit.models.prop.list import IDList, RemapList
+
+
+from gmdbuilder.mappings import obj_prop
+from gmdbuilder.validation import validate
+import gmdbuilder.object_types as td
+
+ObjectType = td.ObjectType
+
+T = TypeVar('T', bound=ObjectType)
+
+
+class Object(dict[str, Any]):
+    """
+    Note: Not for users to call directly
+    
+    The actual dict implementation hidden behind the ObjectType TypedDict
+    
+    This is to intercept & validate mutations of objects and add new helpers.
+    """
+    __slots__ = ("_obj_id",)
+
+    def __init__(self, obj_id: int):
+        super().__init__()
+        self._obj_id = int(obj_id)
+        super().__setitem__("a1", self._obj_id)
+
+    def __setitem__(self, k: str, v: Any):
+        validate(self._obj_id, k, v)
+        if k == obj_prop.ID:
+            self._obj_id = int(v)
+        super().__setitem__(k, v)
+
+    def update(self, *args: Any, **kwargs: Any):
+        # Construct items dict from args and kwargs
+        items: dict[str, Any]
+        if args:
+            if len(args) != 1:
+                raise TypeError(f"update() takes at most 1 positional argument ({len(args)} given)")
+            __m = args[0]
+            items = dict(__m)
+            items.update(kwargs)
+        else:
+            items = dict(kwargs)
+        
+        for k, v in items.items():
+            validate(self._obj_id, k, v)
+        if obj_prop.ID in items:
+            self._obj_id = int(items[obj_prop.ID])
+        super().update(items)
+
+
+
+@lru_cache(maxsize=1024)
+def _to_raw_key_cached(key: str) -> int | str:
+    if key.startswith('k'):
+        return key
+    if key.startswith('a'):
+        tail = key[1:]
+        if tail.isdigit():
+            return int(tail)
+    raise ValueError()
+
+def to_kit_object(obj: ObjectType) -> KitObject:
+    """
+    Convert ObjectType to a new gmdkit int-keyed dict for gmdkit or debugging.
+    
+    Example:
+        {'a1': 900, 'a2': 50, 'a57': {2}} → {1: 900, 2: 50, 57: IDList([2])}
+    """
+    raw: dict[int|str, Any] = {}
+    for k, v in obj.items():
+        match k:
+            case obj_prop.GROUPS:
+                raw[_to_raw_key_cached(k)] = IDList(v)
+            case obj_prop.PARENT_GROUPS:
+                raw[_to_raw_key_cached(k)] = IDList(v)
+            case obj_prop.Trigger.Spawn.REMAPS:
+                raw[_to_raw_key_cached(k)] = RemapList.from_dict(v) # type: ignore
+            case _:
+                try:
+                    raw[_to_raw_key_cached(k)] = v
+                except ValueError as e:
+                    raise ValueError(f"Object has bad/unsupported key {k!r}:\n{obj=}") from e
+    return KitObject(raw)
+
+
+@lru_cache(maxsize=1024)
+def _from_raw_key_cached(key: object) -> str:
+    if isinstance(key, int):
+        return f"a{key}"
+    if isinstance(key, str) and (key.startswith("a") or key.startswith("k")):
+        return key
+    raise ValueError()
+
+
+def from_kit_object(obj: dict[int|str, Any]) -> ObjectType:
+    """
+    Convert gmdkit object dict to object typeddict.
+    
+    Example:
+        {1: 900, 2: 50, 57: IDList([2])} → {a1: 900, a2: 50, a57: {2}}
+    """
+    new = {}
+    for k, v in obj.items():
+        match k:
+            case 57:
+                new[obj_prop.GROUPS] = set(v) if v else set()
+            case 274:
+                new[obj_prop.PARENT_GROUPS] = set(v) if v else set()
+            case 442:
+                new[obj_prop.Trigger.Spawn.REMAPS] = v.to_dict()
+            case 52:
+                new[obj_prop.Trigger.Pulse.TARGET_TYPE] = bool(v)
+            case _:
+                try:
+                    new[_from_raw_key_cached(k)] = v
+                except ValueError as e:
+                    raise ValueError(f"Object has bad/unsupported key {k!r}: \n{obj=}") from e
+    return new # type: ignore
+
+
+@overload
+def from_object_string(obj_string: str) -> ObjectType: ...
+@overload
+def from_object_string(obj_string: str, *, obj_type: type[T]) -> T: ...
+def from_object_string(obj_string: str, *, obj_type: type[ObjectType] | None = None) -> ObjectType:
+    """
+    Convert GD level object string to ObjectType.
+    
+    Example:
+        "1,1,2,50,3,45;" → {'a1': 1, 'a2': 50, 'a3': 45}
+    """
+    return from_kit_object(KitObject.from_string(obj_string)) # type: ignore
+
+
+@overload
+def new_object(object_id: Literal[3016]) -> td.AdvFollowType: ...
+@overload
+def new_object(object_id: Literal[1346]) -> td.RotateType: ...
+@overload
+def new_object(object_id: Literal[901]) -> td.MoveType: ...
+@overload
+def new_object(object_id: int) -> ObjectType: ...
+def new_object(object_id: int) -> ObjectType:
+    """
+    Create a new Object with defaults from gmdkit.
+        
+    Returns:
+        ObjectType dict with default properties (using 'a<num>' keys)
+    """
+    # Convert from gmdkit's {1: val, 2: val} to our {'a1': val, 'a2': val}
+    return from_kit_object(KitObject.default(object_id)) # type: ignore

gmdbuilder-0.1.0/src/gmdbuilder/fields.py

@@ -0,0 +1,222 @@
+
+from typing import Any, Callable, Literal, Union, get_args, get_origin, Required
+from gmdbuilder.mappings import obj_id, obj_prop
+from gmdbuilder import object_types as td
+
+ObjectType = td.ObjectType
+tid = obj_id.Trigger
+cid = obj_id.Collectible
+ID_TO_TYPEDDICT: dict[int, type[ObjectType]] = {
+    tid.ALPHA: td.AlphaType,
+    tid.ADV_FOLLOW: td.AdvFollowType,
+    tid.ADV_RANDOM: td.AdvRandomType,
+    tid.ANIMATE: td.AnimateType,
+    tid.ANIMATE_KEYFRAME: td.AnimateKeyframeType,
+    tid.ARROW: td.ArrowType,
+    tid.BG_EFFECT_ENABLE: td.TriggerType,
+    tid.BG_EFFECT_DISABLE: td.TriggerType,
+    tid.BPM: td.BpmType,
+    tid.CAMERA_EDGE: td.CameraEdgeType,
+    tid.CAMERA_GUIDE: td.CameraGuideType,
+    tid.CAMERA_MODE: td.CameraModeType,
+    tid.CHANGE_BG: td.ChangeBgType,
+    tid.CHANGE_GR: td.ChangeGrType,
+    tid.CHANGE_MG: td.ChangeMgType,
+    tid.CHECKPOINT: td.CheckpointType,
+    tid.COUNT: td.CountType,
+    tid.COLOR: td.ColorType,
+    tid.COLLISION: td.CollisionType,
+    tid.COLLISION_BLOCK: td.CollisionBlockType,
+    tid.EDIT_ADV_FOLLOW: td.EditAdvFollowType,
+    tid.EDIT_MG: td.MgEditType,
+    tid.EVENT: td.EventType,
+    tid.EDIT_SFX: td.SfxType,
+    tid.EDIT_SONG: td.SongType,
+    tid.END: td.EndType,
+    tid.FOLLOW: td.FollowType,
+    tid.FOLLOW_PLAYER_Y: td.FollowPlayerYType,
+    tid.FORCE_BLOCK: td.ForceBlockType,
+    tid.GAMEPLAY_OFFSET: td.GameplayOffsetType,
+    tid.GRADIENT: td.GradientType,
+    tid.GRAVITY: td.GravityType,
+    tid.INSTANT_COLLISION: td.InstantCollisionType,
+    tid.INSTANT_COUNT: td.InstantCountType,
+    tid.ITEM_COMPARE: td.ItemCompareType,
+    tid.ITEM_EDIT: td.ItemEditType,
+    tid.ITEM_PERSIST: td.ItemPersistType,
+    tid.KEYFRAME: td.KeyframeType,
+    tid.LINK_VISIBLE: td.LinkVisibleType,
+    tid.MG_SPEED: td.MgSpeedType,
+    tid.MOVE: td.MoveType,
+    tid.ON_DEATH: td.OnDeathType,
+    tid.OPTIONS: td.OptionsType,
+    tid.OFFSET_CAMERA: td.OffsetCameraType,
+    tid.PICKUP: td.PickupType,
+    tid.PLAYER_CONTROL: td.PlayerControlType,
+    tid.PULSE: td.PulseType,
+    tid.RANDOM: td.RandomType,
+    tid.RESET: td.ResetType,
+    tid.ROTATE: td.RotateType,
+    tid.ROTATE_CAMERA: td.RotateCameraType,
+    tid.SCALE: td.ScaleType,
+    tid.SEQUENCE: td.SequenceType,
+    tid.SFX: td.SfxType,
+    tid.STOP: td.StopType,
+    tid.SHAKE: td.ShakeType,
+    tid.SONG: td.SongType,
+    tid.SPAWN: td.SpawnType,
+    tid.SPAWN_PARTICLE: td.SpawnParticleType,
+    tid.STATE_BLOCK: td.StateBlockType,
+    tid.STATIC_CAMERA: td.StaticCameraType,
+    tid.TELEPORT: td.TeleportType,
+    tid.TIME: td.TimeType,
+    tid.TIMEWARP: td.TimewarpType,
+    tid.TIME_CONTROL: td.TimeControlType,
+    tid.TIME_EVENT: td.TimeEventType,
+    tid.TOGGLE: td.ToggleType,
+    tid.TOGGLE_BLOCK: td.ToggleBlockType,
+    tid.TOUCH: td.TouchType,
+    tid.UI: td.UiType,
+    tid.ZOOM_CAMERA: td.ZoomCameraType,
+    tid.PLAYER_HIDE: td.TriggerType,
+    tid.PLAYER_SHOW: td.TriggerType,
+    tid.Enter.MOVE: td.EffectType,
+    tid.EnterPreset.FADE_ONLY: td.TriggerType,
+    cid.KEY: td.CollectibleType,
+    cid.USER_COIN: td.AnimatedType,
+    cid.SMALL_COIN: td.CollectibleType,
+    obj_id.TEXT: td.TextType,
+    obj_id.ITEM_LABEL: td.ItemLabelType,
+    obj_id.PARTICLE_OBJECT: td.ParticleType,
+    obj_id.Orb.BLACK: td.TriggerType,
+    obj_id.Orb.BLUE: td.TriggerType,
+    obj_id.Orb.GREEN: td.TriggerType,
+    obj_id.Orb.RED: td.TriggerType,
+    obj_id.Orb.YELLOW: td.TriggerType,
+    obj_id.Orb.PINK: td.TriggerType,
+    obj_id.Orb.SPIDER: td.TriggerType,
+    obj_id.Orb.TELEPORT: td.TriggerType,
+    obj_id.Orb.TOGGLE: td.ToggleBlockType,
+    obj_id.Orb.DASH_GREEN: td.DashType,
+    obj_id.Orb.DASH_PINK: td.DashType,
+    obj_id.Portal.Teleport.ENTER: td.PortalType,
+    obj_id.Portal.Teleport.EXIT: td.ExitPortalType,
+    obj_id.Portal.Teleport.LINKED: td.PortalType,
+    3002: td.AnimatedType,
+    1020: td.SawType,
+    1582: td.SawType,
+    1709: td.SawType,
+}
+"""Unfinished mapping of Object IDs to non-common Object TypedDicts"""
+
+
+def _append_types(cls: object, obj_type: type[ObjectType]):
+    if isinstance(cls, list):
+        for c in cls:
+            if isinstance(c, int):
+                ID_TO_TYPEDDICT[c] = obj_type
+    else:
+        for obj in [v for v in vars(cls).values() if isinstance(v, int)]:
+            ID_TO_TYPEDDICT[obj] = obj_type
+
+_append_types(obj_id.Pad, td.TriggerType)
+_append_types(obj_id.Portal, td.GamemodePortalType)
+_append_types(obj_id.Speed, td.TriggerType)
+_append_types(obj_id.Modifier, td.TriggerType)
+_append_types(obj_id.Trigger.Shader, td.ShaderType)
+_append_types(obj_id.Trigger.Area, td.EffectType)
+_append_types([i for i in range(920, 925)], td.AnimatedType)
+_append_types([i for i in range(1849, 1859)], td.AnimatedType)
+_append_types([1936, 1937, 1938, 1939], td.AnimatedType)
+_append_types([i for i in range(2020, 2056)], td.AnimatedType)
+_append_types([2864, 2865], td.AnimatedType)
+_append_types([i for i in range(2867, 2895)], td.AnimatedType)
+_append_types([3000, 3001, 3002], td.AnimatedType)
+_append_types([85, 86, 87, 88, 89], td.SawType)
+_append_types([97, 98], td.SawType)
+_append_types([137, 138, 139], td.SawType)
+_append_types([154, 155, 156], td.SawType)
+_append_types([i for i in range(180, 189)], td.SawType)
+_append_types([222, 223, 224], td.SawType)
+_append_types([375, 376, 377, 378], td.SawType)
+_append_types([i for i in range(394, 400)], td.SawType)
+
+ID_TO_ALLOWED_KEYS = {
+    k: set(v.__required_keys__) | set(v.__optional_keys__) 
+    for k, v in ID_TO_TYPEDDICT.items()
+}
+
+COMMON_ALLOWED_KEYS = td.ObjectType.__required_keys__ | td.ObjectType.__optional_keys__
+
+UNHASHABLE_VALUE_KEYS = {
+    obj_prop.GROUPS,
+    obj_prop.PARENT_GROUPS,
+    obj_prop.Trigger.Spawn.REMAPS,
+    obj_prop.Trigger.AdvRandom.TARGETS,
+    obj_prop.Trigger.Event.EVENTS,
+    obj_prop.Trigger.Sequence.SEQUENCE
+}
+
+
+hashable_value_key_to_isinstance: dict[str, Callable[[Any], bool]] = {}
+
+
+# ACTUAL FUNCTION WE CARE ABOUT
+def value_is_correct_type(key: str, v: Any) -> bool:
+    """Check if value v is of the correct type for key."""
+    if key in UNHASHABLE_VALUE_KEYS:
+        raise ValueError(f"Key {key} has unhashable value, cannot be type checked.")
+    if key not in hashable_value_key_to_isinstance:
+        raise ValueError(f"No type information available for key {key!r} : {v!r}")
+    return hashable_value_key_to_isinstance[key](v)
+
+
+def _type_to_isinstance(typ: Any) -> Callable[[Any], bool]:
+    """Convert a type annotation to a runtime check function."""
+    origin = get_origin(typ)
+    
+    if origin is Required:
+        inner_type = get_args(typ)[0]
+        return _type_to_isinstance(inner_type)
+    if origin is Union:
+        checks = [_type_to_isinstance(t) for t in get_args(typ)]
+        return lambda v: any(check(v) for check in checks)
+    elif origin is Literal:
+        allowed = get_args(typ)
+        return lambda v: v in allowed
+    elif typ is Any:
+        return lambda v: True
+    elif isinstance(typ, type):
+        if typ is bool:
+            return lambda v: isinstance(v, bool)
+        elif typ is float:
+            return lambda v: isinstance(v, (int, float)) and not isinstance(v, bool)
+        elif typ is int:
+            return lambda v: isinstance(v, int) and not isinstance(v, bool)
+        else:
+            return lambda v: isinstance(v, typ)
+
+    raise ValueError(f"Unsupported type annotation: {typ!r}")
+
+
+def _typeddict_to_isinstance(typeddict: type):
+    """Extract type annotations from a TypedDict and populate runtime checks."""
+    annotations: dict[str, Any] = {}
+    
+    for base in reversed(typeddict.__mro__):
+        if hasattr(base, '__annotations__'):
+            annotations.update(base.__annotations__)
+    
+    for key, typ in annotations.items():
+        if key in hashable_value_key_to_isinstance: continue
+        if key in UNHASHABLE_VALUE_KEYS: continue
+        
+        try:
+            hashable_value_key_to_isinstance[key] = _type_to_isinstance(typ)
+        except ValueError as e:
+            print(f"Warning: Skipping key {key!r} with type {typ}: {e}")
+
+
+_typeddict_to_isinstance(td.ObjectType)
+for tyd in ID_TO_TYPEDDICT.values():
+    _typeddict_to_isinstance(tyd)