[Python] Fix type annotations for inref, IList, DateKind, and regex collections (#4317)

Author: dbrattli

src/Fable.Cli/CHANGELOG.md

@@ -9,6 +9,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Fixed
 
+* [Python] Fix type annotations for inref, IList, DateKind, and regex collections (by @dbrattli)
 * [Python] Fix type annotations for protocols, ABCs, Atom, and Set module (by @dbrattli)
 * [Python] Fix type annotations for async functions, date operations, and None handling (by @dbrattli)
 * [Python] Fix type annotations for tuple indexing, generic defaults, and reflection (by @dbrattli)

src/Fable.Compiler/CHANGELOG.md

@@ -9,6 +9,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Fixed
 
+* [Python] Fix type annotations for inref, IList, DateKind, and regex collections (by @dbrattli)
 * [Python] Fix type annotations for protocols, ABCs, Atom, and Set module (by @dbrattli)
 * [Python] Fix type annotations for async functions, date operations, and None handling (by @dbrattli)
 * [Python] Fix type annotations for tuple indexing, generic defaults, and reflection (by @dbrattli)

src/Fable.Transforms/Python/Fable2Python.Annotation.fs

@@ -12,6 +12,15 @@ open Fable.Transforms.Python.AST
 open Fable.Transforms.Python.Types
 open Fable.Transforms.Python.Util
 
+/// Check if type is an inref (in-reference) or Any type.
+/// In F#, struct instance method's `this` parameter is represented as inref<StructType>,
+/// but in Python the struct is passed directly, not wrapped in FSharpRef.
+let isInRefOrAnyType (com: IPythonCompiler) =
+    function
+    | Replacements.Util.IsInRefType com _ -> true
+    | Fable.Any -> true
+    | _ -> false
+
 let tryPyConstructor (com: IPythonCompiler) ctx ent =
     match Py.Replacements.tryConstructor com ent with
     | Some e -> com.TransformAsExpr(ctx, e) |> Some
@@ -253,7 +262,7 @@ let typeAnnotation
         makeGenericTypeAnnotation com ctx "list" [ genArg ] repeatedGenerics, []
     | Fable.Array(genArg, _) -> fableModuleTypeHint com ctx "array_" "Array" [ genArg ] repeatedGenerics
     | Fable.List genArg -> fableModuleTypeHint com ctx "list" "FSharpList" [ genArg ] repeatedGenerics
-    | Replacements.Util.Builtin kind -> makeBuiltinTypeAnnotation com ctx kind repeatedGenerics
+    | Replacements.Util.Builtin kind as typ -> makeBuiltinTypeAnnotation com ctx typ repeatedGenerics kind
     | Fable.AnonymousRecordType(_, _genArgs, _) ->
         let value = Expression.name "dict"
         let any, stmts = stdlibModuleTypeHint com ctx "typing" "Any" [] repeatedGenerics
@@ -370,8 +379,8 @@ let makeEntityTypeAnnotation com ctx (entRef: Fable.EntityRef) genArgs repeatedG
         fableModuleAnnotation com ctx "protocols" "ICollection" resolved, stmts
     | Types.ilist, _
     | Types.ilistGeneric, _ ->
-        // Map IList<T> to list[T] in Python since arrays are lists
-        makeGenericTypeAnnotation com ctx "list" genArgs repeatedGenerics, []
+        // Map IList<T> to MutableSequence[T] which both list and FSharpArray implement
+        stdlibModuleTypeHint com ctx "collections.abc" "MutableSequence" genArgs repeatedGenerics
     | Types.idisposable, _ -> libValue com ctx "util" "IDisposable", []
     | Types.iobserverGeneric, _ ->
         let resolved, stmts = resolveGenerics com ctx genArgs repeatedGenerics
@@ -450,12 +459,17 @@ let makeEntityTypeAnnotation com ctx (entRef: Fable.EntityRef) genArgs repeatedG
                 | _ -> stdlibModuleTypeHint com ctx "typing" "Any" [] repeatedGenerics
             | None -> stdlibModuleTypeHint com ctx "typing" "Any" [] repeatedGenerics
 
-let makeBuiltinTypeAnnotation com ctx kind repeatedGenerics =
+let makeBuiltinTypeAnnotation com ctx typ repeatedGenerics kind =
     match kind with
     | Replacements.Util.BclGuid -> stdlibModuleTypeHint com ctx "uuid" "UUID" [] repeatedGenerics
     | Replacements.Util.FSharpReference genArg ->
-        let resolved, stmts = resolveGenerics com ctx [ genArg ] repeatedGenerics
-        fableModuleAnnotation com ctx "types" "FSharpRef" resolved, stmts
+        // For inref types (like struct instance member's 'this' parameter),
+        // use the inner type directly since Python doesn't wrap them in FSharpRef
+        if isInRefOrAnyType com typ then
+            typeAnnotation com ctx repeatedGenerics genArg
+        else
+            let resolved, stmts = resolveGenerics com ctx [ genArg ] repeatedGenerics
+            fableModuleAnnotation com ctx "types" "FSharpRef" resolved, stmts
     (*
     | Replacements.Util.BclTimeSpan -> NumberTypeAnnotation
     | Replacements.Util.BclDateTime -> makeSimpleTypeAnnotation com ctx "Date"

src/Fable.Transforms/Python/Replacements.fs

@@ -2339,7 +2339,6 @@ let intrinsicFunctions (com: ICompiler) (ctx: Context) r t (i: CallInfo) (thisAr
         let upper =
             match upper with
             | Value(NewOption(None, _, _), _) -> Helper.GlobalCall("len", t, [ ar ], [ t ], ?loc = r)
-            //getExpr None (Int32.Number) ar (makeStrConst "length2")
             | _ -> add upper (makeIntConst 1)
 
         Helper.InstanceCall(ar, "slice", t, [ lower; upper ], ?loc = r) |> Some

src/fable-library-py/fable_library/async_builder.py

@@ -199,11 +199,11 @@ def run_later(
         action: Callable[[], None],
         due_time: float = 0.0,
     ):
-        loop = asyncio.get_event_loop()
+        loop = asyncio.get_running_loop()
         loop.call_later(due_time, action)
 
     def run(self, action: Callable[[], None]):
-        loop = asyncio.get_event_loop()
+        loop = asyncio.get_running_loop()
 
         if self.increment_and_check():
             self.call_count = 0

src/fable-library-py/fable_library/core/array.pyi

@@ -51,6 +51,10 @@ class FSharpArray[T](MutableSequence[T]):
     def __len__(self) -> int: ...
     def __setitem__(self, idx: int | slice, value: Any) -> None: ...
 
+    # F# interop property
+    @property
+    def length(self) -> Int32: ...
+
     # IEnumerable implementation (for .NET compatibility)
     def GetEnumerator(self, __unit: None = None) -> IEnumerator[T]: ...
 
@@ -367,7 +371,7 @@ def pairwise[T](array: FSharpArray[T] | Iterable[T]) -> FSharpArray[tuple[T, T]]
 def partition[T](
     f: Callable[[T], bool], array: FSharpArray[T] | Iterable[T], cons: FSharpCons[T] | None = None
 ) -> tuple[FSharpArray[T], FSharpArray[T]]: ...
-def permute[T](f: Callable[[SupportsInt], SupportsInt], array: FSharpArray[T] | Iterable[T]) -> FSharpArray[T]: ...
+def permute[T](f: Callable[[Int32], SupportsInt], array: FSharpArray[T] | Iterable[T]) -> FSharpArray[T]: ...
 def pick[T, U](chooser: Callable[[T], U | None], array: FSharpArray[T] | Iterable[T]) -> U: ...
 def reduce[T](reduction: Callable[[T, T], T], array: FSharpArray[T] | Iterable[T]) -> T: ...
 def reduce_back[T](reduction: Callable[[T, T], T], array: FSharpArray[T] | Iterable[T]) -> T: ...

src/fable-library-py/fable_library/date.py

@@ -3,12 +3,12 @@
 import re
 from datetime import UTC, datetime, timedelta
 from math import fmod
-from typing import Any, overload
+from typing import Any, SupportsInt, overload
 
 from .singleton_local_time_zone import local_time_zone
 from .time_span import TimeSpan, total_microseconds
 from .time_span import create as create_time_span
-from .types import FSharpRef, float64
+from .types import FSharpRef, float64, int32, int64
 from .util import DateKind
 
 
@@ -86,7 +86,7 @@ def create(
     s: int = 0,
     ms: int = 0,
     mc: int = 0,
-    kind: DateKind | None = None,
+    kind: int32 | None = None,
 ) -> datetime:
     if kind == DateKind.UTC:
         date = datetime(
@@ -107,36 +107,36 @@ def create(
     return date
 
 
-def year(d: datetime) -> int:
-    return d.year
+def year(d: datetime) -> int32:
+    return int32(d.year)
 
 
-def month(d: datetime) -> int:
-    return d.month
+def month(d: datetime) -> int32:
+    return int32(d.month)
 
 
-def day(d: datetime) -> int:
-    return d.day
+def day(d: datetime) -> int32:
+    return int32(d.day)
 
 
-def hour(d: datetime) -> int:
-    return d.hour
+def hour(d: datetime) -> int32:
+    return int32(d.hour)
 
 
-def minute(d: datetime) -> int:
-    return d.minute
+def minute(d: datetime) -> int32:
+    return int32(d.minute)
 
 
-def second(d: datetime) -> int:
-    return d.second
+def second(d: datetime) -> int32:
+    return int32(d.second)
 
 
-def millisecond(d: datetime) -> int:
-    return d.microsecond // 1_000
+def millisecond(d: datetime) -> int32:
+    return int32(d.microsecond // 1_000)
 
 
-def microsecond(d: datetime) -> int:
-    return d.microsecond
+def microsecond(d: datetime) -> int32:
+    return int32(d.microsecond)
 
 
 def to_universal_time(d: datetime) -> datetime:
@@ -365,15 +365,15 @@ def date_to_string_with_custom_format(date: datetime, format: str, utc: bool) ->
 
                 match kind(date):
                     case DateKind.UTC:
-                        utc_offet_text = localized_date.strftime("%z")
+                        utc_offset_text = localized_date.strftime("%z")
                     case DateKind.Local:
-                        utc_offet_text = localized_date.strftime("%z")
-                    case DateKind.Unspecified:
-                        utc_offet_text = to_local_time(date).strftime("%z")
+                        utc_offset_text = localized_date.strftime("%z")
+                    case _:  # DateKind.Unspecified
+                        utc_offset_text = to_local_time(date).strftime("%z")
 
-                sign = utc_offet_text[:1]
-                hours = int(utc_offet_text[1:3])
-                minutes = int(utc_offet_text[3:5])
+                sign = utc_offset_text[:1]
+                hours = int(utc_offset_text[1:3])
+                minutes = int(utc_offset_text[3:5])
 
                 match token_length:
                     case 1:
@@ -600,16 +600,16 @@ def days_in_month(year: int, month: int) -> int:
     return 31
 
 
-def add_years(d: datetime, v: int) -> datetime:
+def add_years(d: datetime, v: SupportsInt) -> datetime:
     new_month = month(d)
-    new_year = year(d) + v
+    new_year = year(d) + int(v)
     _days_in_month = days_in_month(new_year, new_month)
     new_day = min(_days_in_month, day(d))
     return create(new_year, new_month, new_day, hour(d), minute(d), second(d), millisecond(d), microsecond(d), kind(d))
 
 
-def add_months(d: datetime, v: int) -> datetime:
-    new_month = month(d) + v
+def add_months(d: datetime, v: SupportsInt) -> datetime:
+    new_month = int(month(d)) + int(v)
     new_month_ = 0
     year_offset = 0
     if new_month > 12:
@@ -620,37 +620,37 @@ def add_months(d: datetime, v: int) -> datetime:
         new_month_ = 12 + int(fmod(new_month, 12))
         year_offset = new_month // 12 + (-1 if new_month_ == 12 else 0)
         new_month = new_month_
-    new_year = year(d) + year_offset
+    new_year = int(year(d)) + year_offset
     _days_in_month = days_in_month(new_year, new_month)
-    new_day = min(_days_in_month, day(d))
+    new_day = min(_days_in_month, int(day(d)))
     return create(new_year, new_month, new_day, hour(d), minute(d), second(d), millisecond(d), microsecond(d), kind(d))
 
 
-def add_days(d: datetime, v: int) -> datetime:
+def add_days(d: datetime, v: SupportsInt) -> datetime:
     return d + timedelta(days=int(v))
 
 
-def add_hours(d: datetime, v: int) -> datetime:
+def add_hours(d: datetime, v: SupportsInt) -> datetime:
     return d + timedelta(hours=int(v))
 
 
-def add_minutes(d: datetime, v: int) -> datetime:
+def add_minutes(d: datetime, v: SupportsInt) -> datetime:
     return d + timedelta(minutes=int(v))
 
 
-def add_seconds(d: datetime, v: int) -> datetime:
+def add_seconds(d: datetime, v: SupportsInt) -> datetime:
     return d + timedelta(seconds=int(v))
 
 
-def add_milliseconds(d: datetime, v: int) -> datetime:
+def add_milliseconds(d: datetime, v: SupportsInt) -> datetime:
     return d + timedelta(milliseconds=int(v))
 
 
-def add_microseconds(d: datetime, v: int) -> datetime:
+def add_microseconds(d: datetime, v: SupportsInt) -> datetime:
     return d + timedelta(microseconds=int(v))
 
 
-def kind(d: datetime) -> DateKind:
+def kind(d: datetime) -> int32:
     if d.tzinfo == UTC:
         return DateKind.UTC
 
@@ -661,11 +661,11 @@ def kind(d: datetime) -> DateKind:
     return DateKind.Local
 
 
-def specify_kind(d: datetime, kind: DateKind) -> datetime:
+def specify_kind(d: datetime, kind: int32) -> datetime:
     return create(year(d), month(d), day(d), hour(d), minute(d), second(d), millisecond(d), microsecond(d), kind)
 
 
-def ticks(d: datetime) -> int:
+def ticks(d: datetime) -> int64:
     # Note: It can happens that Ticks differs a little bit from the .NET implementation
     # because of some rounding/precision issues in Python
     # DateTime(1, 1, 1, 0, 0, 0, 0, 99, DateTimeKind.Utc).Ticks should be 990
@@ -674,20 +674,20 @@ def ticks(d: datetime) -> int:
     # - returns     -62135596799.9999
     # - instead of  -62135596800000
     # compute timestamp in microseconds
-    return unix_epoch_microseconds_to_ticks(int(d.timestamp() * 1_000_000), date_offset(d) * 1_000)
+    return unix_epoch_microseconds_to_ticks(int64(d.timestamp() * 1_000_000), date_offset(d) * 1_000)
 
 
-def unix_epoch_microseconds_to_ticks(us: int, offset: int) -> int:
-    return int(((us + 62135596800000000) + offset) * 10)
+def unix_epoch_microseconds_to_ticks(us: int64, offset: int64) -> int64:
+    return ((us + 62135596800000000) + offset) * 10
 
 
-def ticks_to_unix_epoch_microseconds(ticks: int) -> int:
-    return int((ticks - 621355968000000000) // 10)
+def ticks_to_unix_epoch_microseconds(ticks: SupportsInt) -> int:
+    return (int(ticks) - 621355968000000000) // 10
 
 
-def date_offset(d: datetime) -> int:
+def date_offset(d: datetime) -> int64:
     if d.tzinfo == UTC:
-        return 0
+        return int64.ZERO
     else:
         utc_offset = d.utcoffset()
 
@@ -696,14 +696,14 @@ def date_offset(d: datetime) -> int:
         if utc_offset is None:
             forced_utc_offset = d.astimezone().utcoffset()
             assert forced_utc_offset is not None
-            return int(forced_utc_offset.total_seconds() * 1_000)
+            return int64(forced_utc_offset.total_seconds() * 1_000)
         else:
-            return int(utc_offset.total_seconds() * 1_000)
+            return int64(utc_offset.total_seconds() * 1_000)
 
     # return 0 if d.tzinfo == timezone.utc else
 
 
-def create_from_epoch_microseconds(us: int, kind: DateKind | None = None) -> datetime:
+def create_from_epoch_microseconds(us: int, kind: int32 | None = None) -> datetime:
     if kind == DateKind.UTC:
         date = datetime.fromtimestamp(us / 1_000_000, UTC)
     else:
@@ -714,7 +714,7 @@ def create_from_epoch_microseconds(us: int, kind: DateKind | None = None) -> dat
     return date
 
 
-def from_ticks(ticks: int, kind: DateKind | None = None) -> datetime:
+def from_ticks(ticks: SupportsInt, kind: int32 | None = None) -> datetime:
     # Better default than Unspecified
     kind = kind or DateKind.Local
     date = create_from_epoch_microseconds(ticks_to_unix_epoch_microseconds(ticks), kind)