From 9d7e353ed3424d8df0adea64850a69fa85f21b48 Mon Sep 17 00:00:00 2001 From: Khaleel Al-Adhami Date: Wed, 13 Nov 2024 18:40:06 -0800 Subject: [PATCH] fix pyright issues --- reflex/vars/base.py | 14 +++++------ reflex/vars/function.py | 10 ++++---- reflex/vars/number.py | 32 ++++++++++++------------- reflex/vars/object.py | 11 +++++---- reflex/vars/sequence.py | 52 +++++++++++++++++++++-------------------- 5 files changed, 62 insertions(+), 57 deletions(-) diff --git a/reflex/vars/base.py b/reflex/vars/base.py index 1e6d4163e..13b0635c9 100644 --- a/reflex/vars/base.py +++ b/reflex/vars/base.py @@ -75,7 +75,7 @@ from reflex.utils.types import ( if TYPE_CHECKING: from reflex.state import BaseState - from .function import ArgsFunctionOperation, ReflexCallable + from .function import ArgsFunctionOperation from .number import BooleanVar, NumberVar from .object import ObjectVar from .sequence import ArrayVar, StringVar @@ -930,7 +930,7 @@ class Var(Generic[VAR_TYPE]): """ from .number import equal_operation - return ~equal_operation(self, other) + return (~equal_operation(self, other)).guess_type() def bool(self) -> BooleanVar: """Convert the var to a boolean. @@ -940,7 +940,7 @@ class Var(Generic[VAR_TYPE]): """ from .number import boolify - return boolify(self) + return boolify(self).guess_type() def __and__(self, other: Var | Any) -> Var: """Perform a logical AND operation on the current instance and another variable. @@ -992,7 +992,7 @@ class Var(Generic[VAR_TYPE]): Returns: A `BooleanVar` object representing the result of the logical NOT operation. """ - return ~self.bool() + return (~self.bool()).guess_type() def to_string(self, use_json: bool = True) -> StringVar: """Convert the var to a string. @@ -1539,7 +1539,7 @@ def var_operation( def var_operation( func: Callable[..., CustomVarOperationReturn[T]], -) -> ArgsFunctionOperation: +) -> ArgsFunctionOperation[ReflexCallable[..., T]]: """Decorator for creating a var operation. Example: @@ -1604,7 +1604,7 @@ def var_operation( function_name=func_name, type_computer=custom_operation_return._type_computer, _var_type=ReflexCallable[ - tuple(arg_python_type for _, arg_python_type in args_with_type_hints), + tuple(arg_python_type for _, arg_python_type in args_with_type_hints), # type: ignore custom_operation_return._var_type, ], ) @@ -3143,7 +3143,7 @@ def nary_type_computer( def type_computer(*args: Var): if len(args) != len(types): return ( - ReflexCallable[[], types[len(args)]], + ReflexCallable[[], types[len(args)]], # type: ignore functools.partial(type_computer, *args), ) return ( diff --git a/reflex/vars/function.py b/reflex/vars/function.py index ebe3eba5c..e41c348c8 100644 --- a/reflex/vars/function.py +++ b/reflex/vars/function.py @@ -239,7 +239,7 @@ class FunctionVar(Var[CALLABLE_TYPE], default_type=ReflexCallable[Any, Any]): """ args_types, return_type = unwrap_reflex_callalbe(self._var_type) if isinstance(args_types, tuple): - return ReflexCallable[[*args_types[len(args) :]], return_type], None + return ReflexCallable[[*args_types[len(args) :]], return_type], None # type: ignore return ReflexCallable[..., return_type], None def _arg_len(self) -> int | None: @@ -507,9 +507,9 @@ class ArgsFunctionOperation(CachedVarOperation, FunctionVar[CALLABLE_TYPE]): _cached_var_name = cached_property_no_lock(format_args_function_operation) - _pre_check = pre_check_args + _pre_check = pre_check_args # type: ignore - _partial_type = figure_partial_type + _partial_type = figure_partial_type # type: ignore @classmethod def create( @@ -574,9 +574,9 @@ class ArgsFunctionOperationBuilder( _cached_var_name = cached_property_no_lock(format_args_function_operation) - _pre_check = pre_check_args + _pre_check = pre_check_args # type: ignore - _partial_type = figure_partial_type + _partial_type = figure_partial_type # type: ignore @classmethod def create( diff --git a/reflex/vars/number.py b/reflex/vars/number.py index 0f2cb4e46..87793e140 100644 --- a/reflex/vars/number.py +++ b/reflex/vars/number.py @@ -70,7 +70,7 @@ class NumberVar(Var[NUMBER_T], python_types=(int, float)): """ if not isinstance(other, NUMBER_TYPES): raise_unsupported_operand_types("+", (type(self), type(other))) - return number_add_operation(self, +other) + return number_add_operation(self, +other).guess_type() @overload def __radd__(self, other: number_types) -> NumberVar: ... @@ -89,7 +89,7 @@ class NumberVar(Var[NUMBER_T], python_types=(int, float)): """ if not isinstance(other, NUMBER_TYPES): raise_unsupported_operand_types("+", (type(other), type(self))) - return number_add_operation(+other, self) + return number_add_operation(+other, self).guess_type() @overload def __sub__(self, other: number_types) -> NumberVar: ... @@ -109,7 +109,7 @@ class NumberVar(Var[NUMBER_T], python_types=(int, float)): if not isinstance(other, NUMBER_TYPES): raise_unsupported_operand_types("-", (type(self), type(other))) - return number_subtract_operation(self, +other) + return number_subtract_operation(self, +other).guess_type() @overload def __rsub__(self, other: number_types) -> NumberVar: ... @@ -129,7 +129,7 @@ class NumberVar(Var[NUMBER_T], python_types=(int, float)): if not isinstance(other, NUMBER_TYPES): raise_unsupported_operand_types("-", (type(other), type(self))) - return number_subtract_operation(+other, self) + return number_subtract_operation(+other, self).guess_type() def __abs__(self): """Get the absolute value of the number. @@ -164,7 +164,7 @@ class NumberVar(Var[NUMBER_T], python_types=(int, float)): if not isinstance(other, NUMBER_TYPES): raise_unsupported_operand_types("*", (type(self), type(other))) - return number_multiply_operation(self, +other) + return number_multiply_operation(self, +other).guess_type() @overload def __rmul__(self, other: number_types | boolean_types) -> NumberVar: ... @@ -191,7 +191,7 @@ class NumberVar(Var[NUMBER_T], python_types=(int, float)): if not isinstance(other, NUMBER_TYPES): raise_unsupported_operand_types("*", (type(other), type(self))) - return number_multiply_operation(+other, self) + return number_multiply_operation(+other, self).guess_type() @overload def __truediv__(self, other: number_types) -> NumberVar: ... @@ -211,7 +211,7 @@ class NumberVar(Var[NUMBER_T], python_types=(int, float)): if not isinstance(other, NUMBER_TYPES): raise_unsupported_operand_types("/", (type(self), type(other))) - return number_true_division_operation(self, +other) + return number_true_division_operation(self, +other).guess_type() @overload def __rtruediv__(self, other: number_types) -> NumberVar: ... @@ -231,7 +231,7 @@ class NumberVar(Var[NUMBER_T], python_types=(int, float)): if not isinstance(other, NUMBER_TYPES): raise_unsupported_operand_types("/", (type(other), type(self))) - return number_true_division_operation(+other, self) + return number_true_division_operation(+other, self).guess_type() @overload def __floordiv__(self, other: number_types) -> NumberVar: ... @@ -251,7 +251,7 @@ class NumberVar(Var[NUMBER_T], python_types=(int, float)): if not isinstance(other, NUMBER_TYPES): raise_unsupported_operand_types("//", (type(self), type(other))) - return number_floor_division_operation(self, +other) + return number_floor_division_operation(self, +other).guess_type() @overload def __rfloordiv__(self, other: number_types) -> NumberVar: ... @@ -271,7 +271,7 @@ class NumberVar(Var[NUMBER_T], python_types=(int, float)): if not isinstance(other, NUMBER_TYPES): raise_unsupported_operand_types("//", (type(other), type(self))) - return number_floor_division_operation(+other, self) + return number_floor_division_operation(+other, self).guess_type() @overload def __mod__(self, other: number_types) -> NumberVar: ... @@ -291,7 +291,7 @@ class NumberVar(Var[NUMBER_T], python_types=(int, float)): if not isinstance(other, NUMBER_TYPES): raise_unsupported_operand_types("%", (type(self), type(other))) - return number_modulo_operation(self, +other) + return number_modulo_operation(self, +other).guess_type() @overload def __rmod__(self, other: number_types) -> NumberVar: ... @@ -311,7 +311,7 @@ class NumberVar(Var[NUMBER_T], python_types=(int, float)): if not isinstance(other, NUMBER_TYPES): raise_unsupported_operand_types("%", (type(other), type(self))) - return number_modulo_operation(+other, self) + return number_modulo_operation(+other, self).guess_type() @overload def __pow__(self, other: number_types) -> NumberVar: ... @@ -331,7 +331,7 @@ class NumberVar(Var[NUMBER_T], python_types=(int, float)): if not isinstance(other, NUMBER_TYPES): raise_unsupported_operand_types("**", (type(self), type(other))) - return number_exponent_operation(self, +other) + return number_exponent_operation(self, +other).guess_type() @overload def __rpow__(self, other: number_types) -> NumberVar: ... @@ -351,7 +351,7 @@ class NumberVar(Var[NUMBER_T], python_types=(int, float)): if not isinstance(other, NUMBER_TYPES): raise_unsupported_operand_types("**", (type(other), type(self))) - return number_exponent_operation(+other, self) + return number_exponent_operation(+other, self).guess_type() def __neg__(self): """Negate the number. @@ -874,7 +874,7 @@ def comparison_operator( """ @var_operation - def operation(lhs: Var, rhs: Var): + def operation(lhs: Var[Any], rhs: Var[Any]): return var_operation_return( js_expression=func(lhs, rhs), var_type=bool, @@ -890,7 +890,7 @@ def comparison_operator( Returns: The comparison operation. """ - return operation(lhs, rhs) + return operation(lhs, rhs).guess_type() return wrapper diff --git a/reflex/vars/object.py b/reflex/vars/object.py index 6aabd8c80..8607e7b9f 100644 --- a/reflex/vars/object.py +++ b/reflex/vars/object.py @@ -91,7 +91,7 @@ class ObjectVar(Var[OBJECT_TYPE], python_types=dict): Returns: The keys of the object. """ - return object_keys_operation(self) + return object_keys_operation(self).guess_type() @overload def values( @@ -107,7 +107,7 @@ class ObjectVar(Var[OBJECT_TYPE], python_types=dict): Returns: The values of the object. """ - return object_values_operation(self) + return object_values_operation(self).guess_type() @overload def entries( @@ -123,7 +123,7 @@ class ObjectVar(Var[OBJECT_TYPE], python_types=dict): Returns: The entries of the object. """ - return object_entries_operation(self) + return object_entries_operation(self).guess_type() items = entries @@ -296,7 +296,7 @@ class ObjectVar(Var[OBJECT_TYPE], python_types=dict): Returns: The result of the check. """ - return object_has_own_property_operation(self, key) + return object_has_own_property_operation(self, key).guess_type() @dataclasses.dataclass( @@ -445,6 +445,7 @@ def object_values_operation(value: Var): ReflexCallable[[Any], List[Any]], lambda x: List[x.to(ObjectVar)._value_type()], ), + var_type=List[Any], ) @@ -465,6 +466,7 @@ def object_entries_operation(value: Var): ReflexCallable[[Any], List[Tuple[str, Any]]], lambda x: List[Tuple[str, x.to(ObjectVar)._value_type()]], ), + var_type=List[Tuple[str, Any]], ) @@ -489,6 +491,7 @@ def object_merge_operation(lhs: Var, rhs: Var): unionize(*[arg.to(ObjectVar)._value_type() for arg in args]), ], ), + var_type=Dict[Any, Any], ) diff --git a/reflex/vars/sequence.py b/reflex/vars/sequence.py index 84f4d8146..908cd9334 100644 --- a/reflex/vars/sequence.py +++ b/reflex/vars/sequence.py @@ -168,7 +168,7 @@ class StringVar(Var[STRING_TYPE], python_types=str): isinstance(i, NumberVar) and i._is_strict_float() ): raise_unsupported_operand_types("[]", (type(self), type(i))) - return string_item_operation(self, i) + return string_item_operation(self, i).guess_type() def length(self) -> NumberVar: """Get the length of the string. @@ -184,7 +184,7 @@ class StringVar(Var[STRING_TYPE], python_types=str): Returns: The string lower operation. """ - return string_lower_operation(self) + return string_lower_operation(self).guess_type() def upper(self) -> StringVar: """Convert the string to uppercase. @@ -192,7 +192,7 @@ class StringVar(Var[STRING_TYPE], python_types=str): Returns: The string upper operation. """ - return string_upper_operation(self) + return string_upper_operation(self).guess_type() def strip(self) -> StringVar: """Strip the string. @@ -200,7 +200,7 @@ class StringVar(Var[STRING_TYPE], python_types=str): Returns: The string strip operation. """ - return string_strip_operation(self) + return string_strip_operation(self).guess_type() def reversed(self) -> StringVar: """Reverse the string. @@ -235,8 +235,8 @@ class StringVar(Var[STRING_TYPE], python_types=str): if field is not None: if not isinstance(field, (StringVar, str)): raise_unsupported_operand_types("contains", (type(self), type(field))) - return string_contains_field_operation(self, other, field) - return string_contains_operation(self, other) + return string_contains_field_operation(self, other, field).guess_type() + return string_contains_operation(self, other).guess_type() @overload def split(self, separator: StringVar | str = "") -> ArrayVar[List[str]]: ... @@ -255,7 +255,7 @@ class StringVar(Var[STRING_TYPE], python_types=str): """ if not isinstance(separator, (StringVar, str)): raise_unsupported_operand_types("split", (type(self), type(separator))) - return string_split_operation(self, separator) + return string_split_operation(self, separator).guess_type() @overload def startswith(self, prefix: StringVar | str) -> BooleanVar: ... @@ -274,7 +274,7 @@ class StringVar(Var[STRING_TYPE], python_types=str): """ if not isinstance(prefix, (StringVar, str)): raise_unsupported_operand_types("startswith", (type(self), type(prefix))) - return string_starts_with_operation(self, prefix) + return string_starts_with_operation(self, prefix).guess_type() @overload def __lt__(self, other: StringVar | str) -> BooleanVar: ... @@ -294,7 +294,7 @@ class StringVar(Var[STRING_TYPE], python_types=str): if not isinstance(other, (StringVar, str)): raise_unsupported_operand_types("<", (type(self), type(other))) - return string_lt_operation(self, other) + return string_lt_operation(self, other).guess_type() @overload def __gt__(self, other: StringVar | str) -> BooleanVar: ... @@ -314,7 +314,7 @@ class StringVar(Var[STRING_TYPE], python_types=str): if not isinstance(other, (StringVar, str)): raise_unsupported_operand_types(">", (type(self), type(other))) - return string_gt_operation(self, other) + return string_gt_operation(self, other).guess_type() @overload def __le__(self, other: StringVar | str) -> BooleanVar: ... @@ -334,7 +334,7 @@ class StringVar(Var[STRING_TYPE], python_types=str): if not isinstance(other, (StringVar, str)): raise_unsupported_operand_types("<=", (type(self), type(other))) - return string_le_operation(self, other) + return string_le_operation(self, other).guess_type() @overload def __ge__(self, other: StringVar | str) -> BooleanVar: ... @@ -354,7 +354,7 @@ class StringVar(Var[STRING_TYPE], python_types=str): if not isinstance(other, (StringVar, str)): raise_unsupported_operand_types(">=", (type(self), type(other))) - return string_ge_operation(self, other) + return string_ge_operation(self, other).guess_type() @var_operation @@ -796,7 +796,7 @@ class ArrayVar(Var[ARRAY_VAR_TYPE], python_types=(list, tuple, set)): i._var_value if isinstance(i, LiteralStringVar) else i for i in args ) ) - return array_join_operation(self, sep) + return array_join_operation(self, sep).guess_type() def reverse(self) -> ArrayVar[ARRAY_VAR_TYPE]: """Reverse the array. @@ -804,7 +804,7 @@ class ArrayVar(Var[ARRAY_VAR_TYPE], python_types=(list, tuple, set)): Returns: The reversed array. """ - return array_reverse_operation(self) + return array_reverse_operation(self).to(ArrayVar, self._var_type) @overload def __add__(self, other: ArrayVar[ARRAY_VAR_TYPE]) -> ArrayVar[ARRAY_VAR_TYPE]: ... @@ -824,7 +824,9 @@ class ArrayVar(Var[ARRAY_VAR_TYPE], python_types=(list, tuple, set)): if not isinstance(other, ArrayVar): raise_unsupported_operand_types("+", (type(self), type(other))) - return array_concat_operation(self, other) + return array_concat_operation(self, other).to( + ArrayVar, unionize(self._var_type, other._var_type) + ) @overload def __getitem__(self, i: slice) -> ArrayVar[ARRAY_VAR_TYPE]: ... @@ -945,7 +947,7 @@ class ArrayVar(Var[ARRAY_VAR_TYPE], python_types=(list, tuple, set)): Returns: The length of the array. """ - return array_length_operation(self) + return array_length_operation(self).guess_type() @overload @classmethod @@ -1002,7 +1004,7 @@ class ArrayVar(Var[ARRAY_VAR_TYPE], python_types=(list, tuple, set)): start = first_endpoint end = second_endpoint - return array_range_operation(start, end, step or 1) + return array_range_operation(start, end, step or 1).guess_type() @overload def contains(self, other: Any) -> BooleanVar: ... @@ -1023,8 +1025,8 @@ class ArrayVar(Var[ARRAY_VAR_TYPE], python_types=(list, tuple, set)): if field is not None: if not isinstance(field, (StringVar, str)): raise_unsupported_operand_types("contains", (type(self), type(field))) - return array_contains_field_operation(self, other, field) - return array_contains_operation(self, other) + return array_contains_field_operation(self, other, field).guess_type() + return array_contains_operation(self, other).guess_type() def pluck(self, field: StringVar | str) -> ArrayVar: """Pluck a field from the array. @@ -1057,7 +1059,7 @@ class ArrayVar(Var[ARRAY_VAR_TYPE], python_types=(list, tuple, set)): ): raise_unsupported_operand_types("*", (type(self), type(other))) - return repeat_array_operation(self, other) + return repeat_array_operation(self, other).to(ArrayVar, self._var_type) __rmul__ = __mul__ # type: ignore @@ -1079,7 +1081,7 @@ class ArrayVar(Var[ARRAY_VAR_TYPE], python_types=(list, tuple, set)): if not isinstance(other, (ArrayVar, list, tuple)): raise_unsupported_operand_types("<", (type(self), type(other))) - return array_lt_operation(self, other) + return array_lt_operation(self, other).guess_type() @overload def __gt__(self, other: ArrayVar[ARRAY_VAR_TYPE]) -> BooleanVar: ... @@ -1099,7 +1101,7 @@ class ArrayVar(Var[ARRAY_VAR_TYPE], python_types=(list, tuple, set)): if not isinstance(other, (ArrayVar, list, tuple)): raise_unsupported_operand_types(">", (type(self), type(other))) - return array_gt_operation(self, other) + return array_gt_operation(self, other).guess_type() @overload def __le__(self, other: ArrayVar[ARRAY_VAR_TYPE]) -> BooleanVar: ... @@ -1119,7 +1121,7 @@ class ArrayVar(Var[ARRAY_VAR_TYPE], python_types=(list, tuple, set)): if not isinstance(other, (ArrayVar, list, tuple)): raise_unsupported_operand_types("<=", (type(self), type(other))) - return array_le_operation(self, other) + return array_le_operation(self, other).guess_type() @overload def __ge__(self, other: ArrayVar[ARRAY_VAR_TYPE]) -> BooleanVar: ... @@ -1139,7 +1141,7 @@ class ArrayVar(Var[ARRAY_VAR_TYPE], python_types=(list, tuple, set)): if not isinstance(other, (ArrayVar, list, tuple)): raise_unsupported_operand_types(">=", (type(self), type(other))) - return array_ge_operation(self, other) + return array_ge_operation(self, other).guess_type() def foreach(self, fn: Any): """Apply a function to each element of the array. @@ -1692,7 +1694,7 @@ def map_array_operation( type_computer=nary_type_computer( ReflexCallable[[List[Any], ReflexCallable], List[Any]], ReflexCallable[[ReflexCallable], List[Any]], - computer=lambda args: List[unwrap_reflex_callalbe(args[1]._var_type)[1]], + computer=lambda args: List[unwrap_reflex_callalbe(args[1]._var_type)[1]], # type: ignore ), )