UncountablePythonSDK 0.0.7__py3-none-any.whl → 0.0.92__py3-none-any.whl

pkgs/serialization_util/dataclasses.py

@@ -0,0 +1,14 @@
+from dataclasses import fields
+from typing import TYPE_CHECKING, Any, Iterator
+
+if TYPE_CHECKING:
+    from _typeshed import DataclassInstance
+
+
+def iterate_fields(d: "DataclassInstance") -> Iterator[tuple[str, Any]]:
+    for field in fields(d):
+        yield field.name, getattr(d, field.name)
+
+
+def dict_fields(d: "DataclassInstance") -> dict[str, Any]:
+    return dict(iterate_fields(d))

pkgs/serialization_util/serialization_helpers.py

@@ -1,26 +1,31 @@
+# warnings -- types here assume that keys to dictionaries are strings
+# this is true most of the time, but there are cases where we have integer indexes
+
+import dataclasses
 import datetime
+import enum
+import functools
+from collections.abc import Callable, Mapping, Sequence
 from decimal import Decimal
 from typing import (
     TYPE_CHECKING,
     Any,
-    Callable,
-    Mapping,
-    Optional,
-    Sequence,
+    ClassVar,
+    Protocol,
     TypeVar,
     Union,
+    overload,
 )
 
-from pkgs.argument_parser import camel_to_snake_case, snake_to_camel_case
+from pkgs.argument_parser import snake_to_camel_case
 from pkgs.serialization import (
     MISSING_SENTRY,
-    MissingSentryType,
-    MissingType,
     OpaqueKey,
     get_serial_class_data,
 )
 
 from ._get_type_for_serialization import SerializationType, get_serialization_type
+from .dataclasses import iterate_fields
 
 # Inlined types which otherwise would import from types/base.py
 JsonScalar = Union[str, float, bool, Decimal, None, datetime.datetime, datetime.date]
@@ -29,51 +34,101 @@ if TYPE_CHECKING:
 else:
     JsonValue = Union[JsonScalar, dict[str, Any], list[Any]]
 
+T = TypeVar("T")
+
+
+class Dataclass(Protocol):
+    __dataclass_fields__: ClassVar[dict]  # type: ignore[type-arg,unused-ignore]
+
+
+def identity(x: T) -> T:
+    return x
 
-def key_convert_to_camelcase(o: Any) -> Any:
+
+@overload
+def key_convert_to_camelcase(o: str) -> str: ...
+
+
+@overload
+def key_convert_to_camelcase(o: int) -> int: ...
+
+
+def key_convert_to_camelcase(o: Any) -> str | int:
     if isinstance(o, OpaqueKey):
         return o
+    if isinstance(o, enum.StrEnum):
+        return o.value
     if isinstance(o, str):
         return snake_to_camel_case(o)
-    return o
+    if isinstance(o, int):
+        # we allow dictionaries to use integer keys
+        return o
+    raise ValueError("Unexpected key type", o)
 
 
-def _convert_dict(d: Any) -> Any:
+def _convert_dict(d: dict[str, Any]) -> dict[str, JsonValue]:
     return {
-        key_convert_to_camelcase(k): convert_to_camelcase(v)
+        key_convert_to_camelcase(k): serialize_for_api(v)
         for k, v in d.items()
         if v != MISSING_SENTRY
     }
 
 
-def _serialize_dict(d: Any) -> dict[str, Any]:
-    return {k: serialize(v) for k, v in d.items() if v != MISSING_SENTRY}
+def _serialize_dict(d: dict[str, Any]) -> dict[str, JsonValue]:
+    return {k: serialize_for_storage(v) for k, v in d.items() if v != MISSING_SENTRY}
 
 
-def _convert_dataclass(d: Any) -> Any:
-    dct = type(d)
-    scd = get_serial_class_data(dct)
+def _serialize_dataclass(d: Any) -> dict[str, JsonValue]:
+    return {
+        k: serialize_for_storage(v) for k, v in iterate_fields(d) if v != MISSING_SENTRY
+    }
+
+
+def _to_string_value(value: Any) -> str:
+    assert isinstance(value, (Decimal, int))
+    return str(value)
+
+
+@dataclasses.dataclass(kw_only=True)
+class DataclassConversions:
+    key_conversions: dict[str, str]
+    value_conversion_functions: dict[str, Callable[[Any], JsonValue]]
 
-    def key_convert(key: Any) -> Any:
+
+@functools.lru_cache(maxsize=10000)
+def _get_dataclass_conversion_lookups(dataclass_type: Any) -> DataclassConversions:
+    scd = get_serial_class_data(dataclass_type)
+
+    key_conversions: dict[str, str] = {}
+    value_conversion_functions: dict[str, Callable[[Any], JsonValue]] = {}
+
+    for field in dataclasses.fields(dataclass_type):
+        key = field.name
         if scd.has_unconverted_key(key):
-            return key
-        return key_convert_to_camelcase(key)
+            key_conversions[key] = key
+        else:
+            key_conversions[key] = key_convert_to_camelcase(key)
 
-    def value_convert(key: Any, value: Any) -> Any:
-        if value is None:
-            return None
         if scd.has_to_string_value(key):
-            # Limit to types we know we need to support to avoid surprises
-            # Generics, like List/Dict would need to be per-value stringified
-            assert isinstance(value, (Decimal, int))
-            return str(value)
-        if scd.has_unconverted_value(key):
-            return value
-        return convert_to_camelcase(value)
+            value_conversion_functions[key] = _to_string_value
+        elif scd.has_unconverted_value(key):
+            value_conversion_functions[key] = identity
+        else:
+            value_conversion_functions[key] = serialize_for_api
 
+    return DataclassConversions(
+        key_conversions=key_conversions,
+        value_conversion_functions=value_conversion_functions,
+    )
+
+
+def _convert_dataclass(d: Any) -> dict[str, JsonValue]:
+    conversions = _get_dataclass_conversion_lookups(type(d))  # type: ignore[arg-type]
     return {
-        key_convert(k): value_convert(k, v)
-        for k, v in d.__dict__.items()
+        conversions.key_conversions[k]: (
+            conversions.value_conversion_functions[k](v) if v is not None else None
+        )
+        for k, v in iterate_fields(d)
         if v != MISSING_SENTRY
     }
 
@@ -82,38 +137,54 @@ _SERIALIZATION_FUNCS_STANDARD = {
     SerializationType.ENUM: lambda x: str(x.value),
     SerializationType.DATE: lambda x: x.isoformat(),
     SerializationType.TIMEDELTA: lambda x: x.total_seconds(),
-    SerializationType.UNKNOWN: lambda x: x,
+    SerializationType.UNKNOWN: identity,
 }
 
-_CONVERSION_SERIALIZATION_FUNCS = {
+_CONVERSION_SERIALIZATION_FUNCS: dict[SerializationType, Callable[[Any], JsonValue]] = {
     **_SERIALIZATION_FUNCS_STANDARD,
     SerializationType.NAMED_TUPLE: lambda x: _convert_dict(x._asdict()),
-    SerializationType.ITERABLE: lambda x: [convert_to_camelcase(v) for v in x],
+    SerializationType.ITERABLE: lambda x: [serialize_for_api(v) for v in x],
     SerializationType.DICT: _convert_dict,
     SerializationType.DATACLASS: _convert_dataclass,
 }
 
 
-def convert_to_camelcase(obj: Any) -> Any:
-    """@DEPRECATED prefer serialize_for_api"""
-    return serialize_for_api(obj)
+@overload
+def serialize_for_api(obj: None) -> None: ...
+
 
+@overload
+def serialize_for_api(obj: dict[str, Any]) -> dict[str, JsonValue]: ...
 
-def serialize_for_api(obj: Any) -> Any:
+
+@overload
+def serialize_for_api(obj: Dataclass) -> dict[str, JsonValue]: ...
+
+
+@overload
+def serialize_for_api(obj: Any) -> JsonValue: ...
+
+
+def serialize_for_api(obj: Any) -> JsonValue:
     """
     Serialize to a parsed-JSON format suitably encoded for API output.
 
     Use the CachedParser.parse_api to parse this data.
     """
     serialization_type = get_serialization_type(type(obj))  # type: ignore
-    return _CONVERSION_SERIALIZATION_FUNCS[serialization_type](obj)
+    if (
+        serialization_type == SerializationType.UNKNOWN
+    ):  # performance optimization to not do function lookup
+        return obj  # type: ignore
+    r = _CONVERSION_SERIALIZATION_FUNCS[serialization_type](obj)
+    return r
 
 
 _SERIALIZATION_FUNCS_DICT: dict[
     SerializationType, Callable[[Any], dict[str, JsonValue]]
 ] = {
     SerializationType.DICT: _serialize_dict,
-    SerializationType.DATACLASS: lambda x: _serialize_dict(x.__dict__),
+    SerializationType.DATACLASS: _serialize_dataclass,
 }
 
 
@@ -121,15 +192,10 @@ _SERIALIZATION_FUNCS: dict[SerializationType, Callable[[Any], JsonValue]] = {
     **_SERIALIZATION_FUNCS_STANDARD,
     **_SERIALIZATION_FUNCS_DICT,
     SerializationType.NAMED_TUPLE: lambda x: _serialize_dict(x._asdict()),
-    SerializationType.ITERABLE: lambda x: [serialize(v) for v in x],
+    SerializationType.ITERABLE: lambda x: [serialize_for_storage(v) for v in x],
 }
 
 
-def serialize(obj: Any) -> Any:
-    """@DEPRECATED: prefer serialize_for_storage"""
-    return serialize_for_storage(obj)
-
-
 def serialize_for_storage(obj: Any) -> JsonValue:
     """
     Convert a value into the pseudo-JSON form for
@@ -138,37 +204,16 @@ def serialize_for_storage(obj: Any) -> JsonValue:
     Use the CachedParser.parse_storage to parse this data.
     """
     serialization_type = get_serialization_type(type(obj))  # type: ignore
+    if (
+        serialization_type == SerializationType.UNKNOWN
+    ):  # performance optimization to not do function lookup
+        return obj  # type: ignore
     return _SERIALIZATION_FUNCS[serialization_type](obj)
 
 
-def serialize_for_storage_dict(obj: Any) -> dict[str, JsonValue]:
+def serialize_for_storage_dict(obj: dict | Dataclass) -> dict[str, JsonValue]:  # type: ignore[type-arg]
     """
     Same as serialize for storage but guarantees outer object is a dictionary
     """
-    serialization_type = get_serialization_type(type(obj))  # type: ignore
+    serialization_type = get_serialization_type(type(obj))
     return _SERIALIZATION_FUNCS_DICT[serialization_type](obj)
-
-
-def key_convert_to_snake_case(o: Any) -> Any:
-    if isinstance(o, OpaqueKey):
-        return o
-    if isinstance(o, str):
-        return camel_to_snake_case(o)
-    return o
-
-
-def convert_dict_to_snake_case(data: Any) -> Any:
-    return {
-        key_convert_to_snake_case(k): convert_dict_to_snake_case(v)
-        if isinstance(v, dict)
-        else v
-        for k, v in data.items()
-        if v != MISSING_SENTRY
-    }
-
-
-T = TypeVar("T")
-
-
-def resolve_missing_to_none(val: MissingType[T]) -> Optional[T]:
-    return val if not isinstance(val, MissingSentryType) else None

pkgs/strenum_compat/strenum_compat.py

@@ -1,9 +1 @@
-import sys
-from enum import Enum
-
-if sys.version_info >= (3, 11):
-    from enum import StrEnum as StrEnum
-else:
-
-    class StrEnum(str, Enum):
-        pass
+from enum import StrEnum as StrEnum

pkgs/type_spec/actions_registry/__main__.py

@@ -0,0 +1,126 @@
+"""
+This processes the directory main/unc/materials/shared/actions_registry and emits actions_registry/action_definitions.tsx
+"""
+
+import os
+import sys
+from collections import defaultdict
+from dataclasses import dataclass
+from typing import TypeVar
+
+from main.base.types import actions_registry_t
+from pkgs.type_spec import builder
+
+from ...argument_parser import CachedParser
+from ..emit_typescript_util import ts_name
+from ..util import rewrite_file
+from .emit_typescript import ActionDefinitionWithArgument, emit_action_definitions
+
+key_name = "name"
+key_icon = "icon"
+key_short_description = "short_description"
+key_description = "description"
+
+
+TypeT = TypeVar("TypeT")
+
+
+class InvalidSpecException(Exception):
+    pass
+
+
+@dataclass(kw_only=True)
+class ActionRegistryFileInfo:
+    directories: list[str]
+    filename: str
+    filepath: str
+
+
+ACTIONS_REGISTRY_ROOT = "main/unc/materials/shared/actions_registry/"
+action_definition_parser = CachedParser(
+    dict[str, actions_registry_t.ActionDefinitionYaml]
+)
+
+
+def get_action_registry_files_info() -> list[ActionRegistryFileInfo]:
+    files_info = []
+    for dirname, _, files in os.walk(ACTIONS_REGISTRY_ROOT):
+        directories = dirname.replace(ACTIONS_REGISTRY_ROOT, "").split("/")
+        for filename in files:
+            filepath = os.path.join(dirname, filename)
+            if os.path.isfile(filepath) and filepath.endswith(".yaml"):
+                files_info.append(
+                    ActionRegistryFileInfo(
+                        directories=directories,
+                        filename=filename.replace(".yaml", ""),
+                        filepath=filepath,
+                    )
+                )
+    return files_info
+
+
+def main() -> None:
+    files_info = get_action_registry_files_info()
+    action_definitions: defaultdict[str, list[ActionDefinitionWithArgument]] = (
+        defaultdict(list)
+    )
+    all_action_definitions: list[actions_registry_t.ActionDefinitionInternal] = []
+    action_definitions_with_arguments_list: list[ActionDefinitionWithArgument] = []
+    for file_info in files_info:
+        in_action_definitions = action_definition_parser.parse_yaml_file(
+            file_info.filepath
+        )
+        if len(in_action_definitions) == 0:
+            continue
+        for ref_name, definition in in_action_definitions.items():
+            modules = [*file_info.directories]
+            # if the actions are stored in index.yaml, parent dir should be treated as module
+            if file_info.filename != "index":
+                modules.append(file_info.filename)
+
+            module_str = "_".join(modules)
+            action_definition = actions_registry_t.ActionDefinitionInternal(
+                name=definition.name,
+                short_description=definition.short_description,
+                description=definition.description,
+                icon=definition.icon,
+                ref_name=ref_name,
+                module=actions_registry_t.ActionsRegistryModule(
+                    ts_name(module_str, name_case=builder.NameCase.convert)
+                ),
+                visibility_scope=[
+                    actions_registry_t.ActionDefinitionVisibilityScope(item)
+                    for item in definition.visibility_scope
+                ]
+                if definition.visibility_scope is not None
+                else None,
+            )
+            action_definitions_with_arguments_list.append(
+                ActionDefinitionWithArgument(
+                    module=module_str,
+                    ref_name=ref_name,
+                    arguments=definition.arguments,
+                    definition=action_definition,
+                )
+            )
+            all_action_definitions.append(action_definition)
+    action_definitions_with_arguments_list = sorted(
+        action_definitions_with_arguments_list,
+        key=lambda item: (item.module, item.ref_name),
+    )
+
+    for action_definition_with_argument in action_definitions_with_arguments_list:
+        action_definitions[action_definition_with_argument.module].append(
+            action_definition_with_argument
+        )
+
+    ts_content = emit_action_definitions(action_definitions)
+    rewrite_file(
+        "main/site/js/materials/base/actions_registry/action_definitions.tsx",
+        ts_content,
+    )
+
+    sys.exit(0)
+
+
+main()

pkgs/type_spec/actions_registry/emit_typescript.py

@@ -0,0 +1,182 @@
+import io
+from collections import defaultdict
+from dataclasses import dataclass
+
+from main.base.types import actions_registry_t
+
+from ...type_spec import builder
+from ..emit_typescript_util import (
+    INDENT,
+    MODIFY_NOTICE,
+    resolve_namespace_ref,
+    ts_name,
+    ts_type_name,
+)
+from ..util import encode_common_string
+
+
+def _action_symbol_name(
+    action_definition: actions_registry_t.ActionDefinitionInternal,
+) -> str:
+    return f"{ts_name(action_definition.ref_name, name_case=builder.NameCase.convert)}"
+
+
+def _action_type_name(ref_name: str) -> str:
+    return f"{ts_type_name(ref_name)}"
+
+
+def _action_namespace_name(name: str) -> str:
+    return f"{resolve_namespace_ref(builder.SpecNamespace(name=name))}"
+
+
+def _action_module_name_base(module: str) -> str:
+    return f"{ts_name(module, name_case=builder.NameCase.convert)}"
+
+
+def _action_module_name_obj(module: str) -> str:
+    return f"{_action_module_name_base(module)}Actions"
+
+
+def _action_module_name(module: str) -> str:
+    return f"ActionsRegistryT.ActionsRegistryModule.{_action_module_name_base(module)}"
+
+
+@dataclass(kw_only=True)
+class ActionDefinitionWithArgument:
+    module: str
+    ref_name: str
+    arguments: str | None
+    definition: actions_registry_t.ActionDefinitionInternal
+
+
+def _emit_imports(
+    action_definitions: defaultdict[str, list[ActionDefinitionWithArgument]],
+) -> str:
+    out = io.StringIO()
+    namespaces = set()
+    for definitions in action_definitions.values():
+        for definition in definitions:
+            if definition.arguments is not None:
+                argument_parts = definition.arguments.split(".")
+                namespace = argument_parts[0]
+                namespaces.add(namespace)
+    namespaces_to_import = ", ".join(
+        sorted([f"type {_action_namespace_name(item)}" for item in list(namespaces)])
+    )
+    out.write(
+        f'import {{ ActionsRegistryT, {namespaces_to_import} }} from "unc_types"\n\n'
+    )
+    out.write(MODIFY_NOTICE)
+    return out.getvalue()
+
+
+def emit_action_definitions(
+    action_definitions: defaultdict[str, list[ActionDefinitionWithArgument]],
+) -> str:
+    out = io.StringIO()
+    out.write(MODIFY_NOTICE)
+    out.write("\n")
+    out.write(_emit_imports(action_definitions))
+    modules = []
+    for key, values in action_definitions.items():
+        out.write(MODIFY_NOTICE)
+        modules.append(key)
+        out.write(f"export const {_action_module_name_obj(key)} = {{\n")
+        for item in values:
+            out.write(MODIFY_NOTICE)
+            out.write(_emit_action_definition(item.definition, item.arguments, INDENT))
+        out.write("}\n")
+
+    out.write(MODIFY_NOTICE)
+    out.write("\n")
+    out.write(MODIFY_NOTICE)
+    out.write("\n")
+    out.write("export const actionDefinitions = {\n")
+    for module in modules:
+        out.write(
+            f"{INDENT}[{_action_module_name(module)}]: {_action_module_name_obj(module)},\n"
+        )
+
+    out.write("}\n")
+    out.write(_emit_action_definition_types(modules, indent=""))
+    out.write(MODIFY_NOTICE)
+    out.write("\n")
+
+    return out.getvalue()
+
+
+def _get_argument_type(arguments: str | None) -> str | None:
+    if arguments is None:
+        return None
+    argument_parts = arguments.split(".")
+    namespace = argument_parts[0]
+    type_name = argument_parts[1]
+    return f"{_action_namespace_name(namespace)}.{type_name}"
+
+
+def _emit_action_definition(
+    action_definition: actions_registry_t.ActionDefinitionInternal,
+    arguments: str | None,
+    indent: str,
+) -> str:
+    out = io.StringIO()
+
+    sub_indent = indent + INDENT
+    argument_type = _get_argument_type(arguments)
+    argument_type = f"<{argument_type}>" if argument_type is not None else ""
+    out.write(f"{indent}{_action_symbol_name(action_definition)}: {{\n")
+    out.write(f"{sub_indent}name: {encode_common_string(action_definition.name)},\n")
+    if action_definition.icon is not None:
+        out.write(
+            f"{sub_indent}icon: {encode_common_string(action_definition.icon)},\n"
+        )
+    out.write(
+        f"{sub_indent}shortDescription: {encode_common_string(action_definition.short_description)},\n"
+    )
+    out.write(
+        f"{sub_indent}description: {encode_common_string(action_definition.description)},\n"
+    )
+    out.write(
+        f"{sub_indent}refName: {encode_common_string(action_definition.ref_name)},\n"
+    )
+    out.write(f"{sub_indent}module: {_action_module_name(action_definition.module)},\n")
+    if (
+        action_definition.visibility_scope is not None
+        and len(action_definition.visibility_scope) > 0
+    ):
+        out.write(
+            f"{sub_indent}visibilityScope: {_emit_visibility_scope(action_definition.visibility_scope)},\n"
+        )
+    out.write(f"{indent}}} as ActionsRegistryT.ActionDefinition{argument_type},\n")
+    return out.getvalue()
+
+
+def _emit_action_definition_types(modules: list[str], indent: str) -> str:
+    out = io.StringIO()
+
+    sub_indent = indent + INDENT
+    out.write(
+        f"{indent}type RefNameKeys<M extends ActionsRegistryT.ActionsRegistryModule> = keyof (typeof actionDefinitions)[M]\n"
+    )
+    out.write(
+        f"{indent}type ActionDefinitionIdentifierGetter<M extends ActionsRegistryT.ActionsRegistryModule> = {{ module: M; refName: RefNameKeys<M> }}\n"
+    )
+    out.write(f"{indent}export type ActionDefinitionIdentifier =\n")
+    for module in modules:
+        out.write(
+            f"{sub_indent}| ActionDefinitionIdentifierGetter<{_action_module_name(module)}>\n"
+        )
+    out.write("\n")
+    return out.getvalue()
+
+
+def _emit_visibility_scope(
+    visibility_scope: list[actions_registry_t.ActionDefinitionVisibilityScope],
+) -> str:
+    visibility_scope_types = ",".join([
+        f"ActionsRegistryT.ActionDefinitionVisibilityScope.{ts_name(visibility_item, name_case=builder.NameCase.convert)}"
+        for visibility_item in visibility_scope
+        if visibility_item is not None
+    ])
+
+    return f"[ {visibility_scope_types} ]"