UncountablePythonSDK 0.0.191__py3-none-any.whl → 0.0.193__py3-none-any.whl

pkgs/argument_parser/parse_fallback.py

@@ -0,0 +1,26 @@
+import dataclasses
+import inspect
+import typing
+from collections.abc import Callable, Mapping
+
+from .parser_function_type import ParserFunction
+
+
+@dataclasses.dataclass(kw_only=True, frozen=True)
+class DataclassParseFallback:
+    legacy_key: str
+    legacy_parser: ParserFunction[object]
+    convert: Callable[[typing.Any], object]
+
+    def applies(self, *, value: Mapping[str, object], field_raw_value: object) -> bool:
+        return (
+            field_raw_value is dataclasses.MISSING or field_raw_value is None
+        ) and value.get(self.legacy_key) is not None
+
+    def parse(self, value: Mapping[str, object]) -> object:
+        return self.convert(self.legacy_parser(value[self.legacy_key]))
+
+
+def parse_fallback_legacy_type(convert: Callable[..., object]) -> typing.Any:
+    legacy_parameter = next(iter(inspect.signature(convert).parameters))
+    return typing.get_type_hints(convert, include_extras=True)[legacy_parameter]

pkgs/argument_parser/parser_inner.py

@@ -15,6 +15,7 @@ import dateutil.parser
 from pkgs.serialization import (
     MissingSentryType,
     OpaqueKey,
+    SerialClassDataInspector,
     UnknownBrand,
     get_serial_class_data,
     get_serial_union_data,
@@ -22,6 +23,7 @@ from pkgs.serialization import (
 
 from .case_convert import camel_to_snake_case, snake_to_camel_case
 from .field_name_resolution import resolve_serialized_field_name
+from .parse_fallback import DataclassParseFallback, parse_fallback_legacy_type
 from .parser_error import (
     ParserEnumError,
     ParserError,
@@ -255,6 +257,39 @@ def _build_parser_for_type_alias(
     return build_parser_inner(alias.__value__, context, merged_alias_map)
 
 
+def _build_parser_for_dict(
+    *,
+    key_type: typing.Any,
+    value_type: typing.Any,
+    context: ParserContext,
+    type_var_map: dict[typing.TypeVar, type],
+) -> ParserFunction[T]:
+    k_inner_parser = build_parser_inner(
+        key_type,
+        context,
+        type_var_map,
+    )
+
+    def key_parser(value: typing.Any) -> object:
+        inner = k_inner_parser(value)
+        if (
+            isinstance(inner, str)
+            # enum keys and OpaqueData's would also have string value types,
+            # but their explicit type is not a string, thus shouldn't be converted
+            and key_type is str
+            and context.options.is_api_encoding
+        ):
+            return camel_to_snake_case(value)
+        return inner
+
+    v_parser = build_parser_inner(value_type, context, type_var_map)
+
+    def parse_dict(value: typing.Any) -> typing.Any:
+        return {key_parser(k): v_parser(v) for k, v in value.items()}
+
+    return parse_dict
+
+
 def _build_parser_for_collection(
     *,
     parsed_type: type[T]
@@ -289,6 +324,32 @@ def _build_parser_for_collection(
     return parse
 
 
+# first parse ints to decimal to allow scientific notation and decimals
+# e.g. (1) 1e4 => 1000, (2) 3.0 => 3
+def _parse_int(value: typing.Any) -> int:
+    if isinstance(value, str):
+        assert "_" not in value, "numbers with underscores not considered integers"
+
+    dec_value = Decimal(value)
+    int_value = int(dec_value)
+    assert int_value == dec_value, (
+        f"value ({value}) cannot be parsed to int without discarding precision"
+    )
+    return int_value
+
+
+def _parse_str(value: typing.Any) -> str:
+    if isinstance(value, str):
+        return value
+    if isinstance(value, (Decimal, float, int)):
+        return str(value)
+    raise ParserError(
+        f"Invalid string value: {type(value)}: {value}",
+        value=value,
+        expected_type=str,
+    )
+
+
 def build_parser_inner(
     parsed_type: type[T]
     | typing.TypeVar
@@ -437,53 +498,20 @@ def build_parser_inner(
                 "Dict types only support two arguments for now",
                 expected_type=parsed_type,
             )
-        k_inner_parser = build_parser_inner(
-            args[0],
-            context,
-            type_var_map,
+        key_type, value_type = args
+        return _build_parser_for_dict(
+            key_type=key_type,
+            value_type=value_type,
+            context=context,
+            type_var_map=type_var_map,
         )
 
-        def key_parser(value: typing.Any) -> object:
-            inner = k_inner_parser(value)
-            if (
-                isinstance(inner, str)
-                # enum keys and OpaqueData's would also have string value types,
-                # but their explicit type is not a string, thus shouldn't be converted
-                and args[0] is str
-                and context.options.is_api_encoding
-            ):
-                return camel_to_snake_case(value)
-            return inner
-
-        v_parser = build_parser_inner(args[1], context, type_var_map)
-
-        def parse_dict(value: typing.Any) -> typing.Any:
-            return origin((key_parser(k), v_parser(v)) for k, v in value.items())
-
-        return parse_dict
-
     if origin == typing.Literal:
         valid_values: set[T] = set(typing.get_args(parsed_type))
         return lambda value: _invoke_membership_parser(valid_values, value)
 
     if parsed_type is int:
-        # first parse ints to decimal to allow scientific notation and decimals
-        # e.g. (1) 1e4 => 1000, (2) 3.0 => 3
-
-        def parse_int(value: typing.Any) -> int:
-            if isinstance(value, str):
-                assert "_" not in value, (
-                    "numbers with underscores not considered integers"
-                )
-
-            dec_value = Decimal(value)
-            int_value = int(dec_value)
-            assert int_value == dec_value, (
-                f"value ({value}) cannot be parsed to int without discarding precision"
-            )
-            return int_value
-
-        return parse_int  # type: ignore[return-value]
+        return _parse_int  # type: ignore[return-value]
 
     if parsed_type is datetime.datetime:
 
@@ -511,19 +539,7 @@ def build_parser_inner(
     # MyPy: It's unclear why `parsed_type in (str, OpaqueKey)` is flagged as invalid
     # Thus an or statement is used instead, which isn't flagged as invalid.
     if parsed_type is str or parsed_type is OpaqueKey:
-
-        def parse_str(value: typing.Any) -> str:
-            if isinstance(value, str):
-                return value
-            if isinstance(value, (Decimal, float, int)):
-                return str(value)
-            raise ParserError(
-                f"Invalid string value: {type(value)}: {value}",
-                value=value,
-                expected_type=str,
-            )
-
-        return parse_str  # type: ignore[return-value]
+        return _parse_str  # type: ignore[return-value]
 
     if parsed_type in (float, Decimal):
         numeric_type: type[Decimal | float] = (
@@ -636,6 +652,7 @@ def _build_parser_dataclass(
     ] = []
 
     serial_class_data = get_serial_class_data(parsed_type)
+    dc_parse_fallbacks: dict[str, DataclassParseFallback] = {}
 
     def parse(value: typing.Any) -> typing.Any:
         # Use an exact type match to prevent base/derived class mismatches
@@ -656,10 +673,17 @@ def _build_parser_dataclass(
                     serialized_field_name,
                     dataclasses.MISSING,
                 )
+                parse_fallback = dc_parse_fallbacks.get(field.name)
                 if context.options.strict_property_parsing:
                     all_allowed_field_names.add(serialized_field_name)
+                    if parse_fallback is not None:
+                        all_allowed_field_names.add(parse_fallback.legacy_key)
                 field_value: typing.Any
-                if field_raw_value == dataclasses.MISSING:
+                if parse_fallback is not None and parse_fallback.applies(
+                    value=value, field_raw_value=field_raw_value
+                ):
+                    field_value = parse_fallback.parse(value)
+                elif field_raw_value == dataclasses.MISSING:
                     if serial_class_data.has_parse_require(field.name):
                         raise ParserError(
                             "missing-required-field", field_name=field.name
@@ -726,4 +750,42 @@ def _build_parser_dataclass(
             build_parser_inner(field_type_hint, context, type_var_map),
         ))
 
+    dc_parse_fallbacks.update(
+        _build_dataclass_parse_fallbacks(
+            parsed_type=parsed_type,
+            serial_class_data=serial_class_data,
+            context=context,
+            type_var_map=type_var_map,
+        )
+    )
+
     return parser_function
+
+
+def _build_dataclass_parse_fallbacks(
+    *,
+    parsed_type: type[DataclassT],
+    serial_class_data: SerialClassDataInspector[DataclassT],
+    context: ParserContext,
+    type_var_map: dict[typing.TypeVar, type],
+) -> dict[str, DataclassParseFallback]:
+    field_names = {field.name for field in dataclasses.fields(parsed_type)}
+    dc_parse_fallbacks: dict[str, DataclassParseFallback] = {}
+    for field_name, parse_fallback in serial_class_data.get_parse_fallbacks().items():
+        assert field_name in field_names, (
+            f"parse fallback for {field_name!r}, which is not a field of {parsed_type}"
+        )
+        dc_parse_fallbacks[field_name] = DataclassParseFallback(
+            legacy_key=resolve_serialized_field_name(
+                serial_class_data=serial_class_data,
+                field_name=parse_fallback.legacy_field,
+                source_encoding=context.options.encoding,
+            ),
+            legacy_parser=build_parser_inner(
+                parse_fallback_legacy_type(parse_fallback.convert),
+                context,
+                type_var_map,
+            ),
+            convert=parse_fallback.convert,
+        )
+    return dc_parse_fallbacks

pkgs/codeowners.py

@@ -0,0 +1,157 @@
+import re
+from collections.abc import Iterable, Mapping
+from dataclasses import dataclass
+from functools import cached_property
+from itertools import chain
+
+GLOB_CHARS = "*?["
+TEAM_OWNER_PREFIX = "@uncountableinc/"
+
+
+def generate_team_username(team_slug: str) -> str:
+    return f"{TEAM_OWNER_PREFIX}{team_slug}"
+
+
+def _glob_regex(pattern: str) -> re.Pattern[str]:
+    directory_pattern = pattern.endswith("/**")
+    normalized_pattern = pattern[:-3] if directory_pattern else pattern
+    regex_parts: list[str] = []
+    index = 0
+    while index < len(normalized_pattern):
+        dotfile_guard = (
+            "(?!\\.)" if index == 0 or normalized_pattern[index - 1] == "/" else ""
+        )
+        if normalized_pattern.startswith("**/", index):
+            regex_parts.append("(?:(?!\\.)[^/]+/)*")
+            index += 3
+        elif normalized_pattern.startswith("**", index):
+            regex_parts.append(".*")
+            index += 2
+        elif normalized_pattern[index] == "*":
+            regex_parts.append(f"{dotfile_guard}[^/]*")
+            index += 1
+        elif normalized_pattern[index] == "?":
+            regex_parts.append(f"{dotfile_guard}[^/]")
+            index += 1
+        elif normalized_pattern[index] == "[":
+            closing_index = normalized_pattern.find("]", index + 1)
+            if closing_index == -1:
+                regex_parts.append(r"\[")
+                index += 1
+            else:
+                character_class = normalized_pattern[index + 1 : closing_index]
+                if character_class.startswith("!"):
+                    character_class = f"^{character_class[1:]}"
+                regex_parts.append(f"{dotfile_guard}[{character_class}]")
+                index = closing_index + 1
+        else:
+            regex_parts.append(re.escape(normalized_pattern[index]))
+            index += 1
+    suffix = "(?:/(?!\\.)[^/]+)*" if directory_pattern else ""
+    return re.compile(f"^{''.join(regex_parts)}{suffix}$")
+
+
+@dataclass(kw_only=True)
+class CodeownerRule:
+    owners: list[str]
+    glob: str
+
+    @cached_property
+    def normalized_globs(self) -> list[str]:
+        normalized_glob = self.glob.strip("/")
+
+        # /path/to/file should the file /path/to/file
+        globs = [normalized_glob]
+
+        # /path/to/file should also match files in subdirectory
+        # /path/to/file/foo
+        # heuristic: treat as directory if no wildcard and last path part has no dot
+        last_part = normalized_glob.split("/")[-1]
+        if (
+            "*" not in normalized_glob
+            and "?" not in normalized_glob
+            and "." not in last_part
+        ):
+            globs.append(f"{normalized_glob}/**")
+
+        return globs
+
+    @cached_property
+    def matches_everything(self) -> bool:
+        return "*" in self.normalized_globs
+
+    @cached_property
+    def _compiled_matchers(self) -> list[re.Pattern[str]]:
+        return [_glob_regex(pattern) for pattern in self.normalized_globs]
+
+    def check_path(self, path: str) -> bool:
+        if self.matches_everything:
+            return True
+        return any(pattern.match(path) for pattern in self._compiled_matchers)
+
+
+def clean_line(line: str) -> str:
+    return line.strip().split("#", 1)[0]
+
+
+def _rules_from_lines(lines: Iterable[str]) -> list[CodeownerRule]:
+    rules: list[CodeownerRule] = []
+    for raw_line in lines:
+        line = clean_line(raw_line)
+        parts = line.split()
+        if len(parts) > 1:
+            rules.append(CodeownerRule(glob=parts[0], owners=parts[1:]))
+    return rules
+
+
+def get_codeowner_rules(codeowners_path: str) -> list[CodeownerRule]:
+    with open(codeowners_path, encoding="utf-8") as codeowners_file:
+        return _rules_from_lines(codeowners_file)
+
+
+def get_codeowner_rules_from_text(text: str) -> list[CodeownerRule]:
+    return _rules_from_lines(text.splitlines())
+
+
+def last_matching_rule(rules: list[CodeownerRule], path: str) -> CodeownerRule | None:
+    """The rule that owns `path` under CODEOWNERS last-match-wins precedence."""
+    matching_rules = [rule for rule in rules if rule.check_path(path)]
+    return matching_rules[-1] if matching_rules else None
+
+
+def get_owners_for_file(rules: list[CodeownerRule], path: str) -> list[str]:
+    rule = last_matching_rule(rules, path)
+    return rule.owners if rule is not None else []
+
+
+def evaluate_codeowner_rules(rules: list[CodeownerRule], files: list[str]) -> set[str]:
+    return set(chain.from_iterable(get_owners_for_file(rules, file) for file in files))
+
+
+def get_owners(codeowners_path: str, files: list[str]) -> set[str]:
+    return evaluate_codeowner_rules(get_codeowner_rules(codeowners_path), files)
+
+
+def get_codeowner_team_slugs(*, rules: list[CodeownerRule]) -> set[str]:
+    return {
+        owner.removeprefix(TEAM_OWNER_PREFIX)
+        for rule in rules
+        for owner in rule.owners
+        if owner.startswith(TEAM_OWNER_PREFIX)
+    }
+
+
+def get_codeowner_team_slugs_for_files(
+    *,
+    files: list[str],
+    codeowner_rules: list[CodeownerRule],
+    all_teams_lookup: Mapping[str, object],
+) -> list[str]:
+    if len(files) == 0:
+        return []
+    codeowners = evaluate_codeowner_rules(codeowner_rules, files)
+    return [
+        slug
+        for slug in all_teams_lookup
+        if generate_team_username(team_slug=slug) in codeowners
+    ]

pkgs/serialization/__init__.py

@@ -12,6 +12,7 @@ from .serial_alias import (
     serial_alias_annotation as serial_alias_annotation,
 )
 from .serial_class import (
+    ParseFallback as ParseFallback,
     SerialClassDataInspector as SerialClassDataInspector,
     get_serial_class_data as get_serial_class_data,
     get_serial_string_enum_data as get_serial_string_enum_data,

pkgs/serialization/serial_class.py

@@ -3,11 +3,18 @@ from __future__ import annotations
 import dataclasses
 from collections.abc import Callable
 from enum import StrEnum
-from typing import Any, TypeVar, cast
+from typing import Any, Generic, TypeVar, cast
 
 from .annotation import SerialBase, SerialInspector, SerialType
 
 ClassT = TypeVar("ClassT")
+LegacyT = TypeVar("LegacyT")
+
+
+@dataclasses.dataclass(kw_only=True, frozen=True)
+class ParseFallback(Generic[LegacyT]):
+    legacy_field: str
+    convert: Callable[[LegacyT], object]
 
 
 @dataclasses.dataclass(kw_only=True, frozen=True, eq=True)
@@ -17,6 +24,9 @@ class _SerialClassData(SerialBase):
     to_string_values: set[str] = dataclasses.field(default_factory=set)
     parse_require: set[str] = dataclasses.field(default_factory=set)
     emit_api_overrides: dict[str, str] = dataclasses.field(default_factory=dict)
+    parse_fallbacks: dict[str, ParseFallback[Any]] = dataclasses.field(
+        default_factory=dict
+    )
     named_type_path: str | None = None
 
 
@@ -30,6 +40,7 @@ def serial_class(
     to_string_values: set[str] | None = None,
     parse_require: set[str] | None = None,
     emit_api_overrides: dict[str, str] | None = None,
+    parse_fallbacks: dict[str, ParseFallback[Any]] | None = None,
     named_type_path: str | None = None,
     is_dynamic_allowed: bool = False,
 ) -> Callable[[ClassT], ClassT]:
@@ -59,6 +70,12 @@ def serial_class(
         storage encoding are unaffected. Replaces the default camelCase
         conversion. Cannot be combined with `unconverted_keys` for the
         same field; doing so raises at parse and serialize time.
+    @param parse_fallbacks
+        Maps Python field name -> a legacy field that the parser reads when
+        the input omits the field or sets it to null. The parser parses the
+        legacy value with the type of the first parameter of `convert`, and
+        stores the result of `convert` in the field. The legacy field is not
+        part of the type, so serialization never writes it.
     @param named_type_path
         The type_spec type-path to this type. This applies only to named types.
     """
@@ -70,6 +87,7 @@ def serial_class(
             to_string_values=to_string_values or set(),
             parse_require=parse_require or set(),
             emit_api_overrides=emit_api_overrides or {},
+            parse_fallbacks=parse_fallbacks or {},
             named_type_path=named_type_path,
             from_decorator=True,
             is_dynamic_allowed=is_dynamic_allowed,
@@ -103,6 +121,9 @@ class SerialClassDataInspector(SerialInspector[ClassT]):
     def get_emit_api_override(self, key: str) -> str | None:
         return self.current.emit_api_overrides.get(key)
 
+    def get_parse_fallbacks(self) -> dict[str, ParseFallback[Any]]:
+        return self.current.parse_fallbacks
+
 
 def get_merged_serial_class_data(
     type_class: SerialType[Any],
@@ -136,6 +157,10 @@ def get_merged_serial_class_data(
                         **curr_base_class_data.emit_api_overrides,
                         **base_class_data.emit_api_overrides,
                     },
+                    parse_fallbacks={
+                        **curr_base_class_data.parse_fallbacks,
+                        **base_class_data.parse_fallbacks,
+                    },
                 )
     return base_class_data