`UPath(...)` detected as type `Any` in 0.3.2

[edgarrmondragon]

Probably caused by 023414d

I can reproduce this with

from typing import Any, assert_type

from upath import UPath

params: dict[str, Any] = {}

path = UPath("/foo/bar/baz", protocol="file", **params)
assert_type(path, UPath)

resolved = path.resolve()
assert_type(resolved, UPath)

which mypy doesn't like

$ uv run mypy main.py
main.py:8: error: Expression is of type "Any", not "UPath"  [assert-type]
main.py:11: error: Expression is of type "Any", not "UPath"  [assert-type]
Found 2 errors in 1 file (checked 1 source file)

nor does ty, for good measure

$ uv run ty check main.py
WARN ty is pre-release software and not ready for production use. Expect to encounter bugs, missing features, and fatal errors.
Checking ------------------------------------------------------------ 1/1 files
error[type-assertion-failure]: Argument does not have asserted type `UPath`
  --> main.py:11:1
   |
10 | resolved = path.resolve()
11 | assert_type(resolved, UPath)
   | ^^^^^^^^^^^^--------^^^^^^^^
   |             |
   |             Inferred type of argument is `Unknown`
   |
info: `UPath` and `Unknown` are not equivalent types
info: rule `type-assertion-failure` is enabled by default

Found 1 diagnostic

If I comment out the __new__ overloads in upath/core.py, the variable is revealed to be of type UPath.

[ap--]

Thanks for reporting!

from typing import Any, reveal_type

from upath.core import UPath

params: dict[str, Any] = {}

path2 = UPath("foo/bar/baz", protocol="s3")
reveal_type(path2)
resolved2 = path2.resolve()
reveal_type(resolved2)

path3 = UPath("foo/bar/baz", protocol="s3", **params)
reveal_type(path3)
resolved3 = path3.resolve()
reveal_type(resolved3)

path0 = UPath("/foo/bar/baz", protocol="file")
reveal_type(path0)
resolved0 = path0.resolve()
reveal_type(resolved0)

path1 = UPath("/foo/bar/baz", protocol="file", **params)
reveal_type(path1)

resolved1 = path1.resolve()
reveal_type(resolved1)

❯ uv run mypy --cache-dir=/dev/null --no-incremental upath-435.py
upath-435.py:8: note: Revealed type is "upath.implementations.cloud.S3Path"
upath-435.py:10: note: Revealed type is "upath.implementations.cloud.S3Path"
upath-435.py:13: note: Revealed type is "Any"
upath-435.py:15: note: Revealed type is "Any"
upath-435.py:18: note: Revealed type is "upath.implementations.local.FilePath"
upath-435.py:20: note: Revealed type is "upath.implementations.local.FilePath"
upath-435.py:23: note: Revealed type is "Any"
upath-435.py:26: note: Revealed type is "Any"
Success: no issues found in 1 source file

without the **params mypy seems to return the type correctly. ty doesn't though...

❯ uv run ty check upath-435.py                                   
WARN ty is pre-release software and not ready for production use. Expect to encounter bugs, missing features, and fatal errors.
Checking ------------------------------------------------------------ 1/1 files                                               info[revealed-type]: Revealed type
  --> upath-435.py:8:13
   |
 7 | path2 = UPath("foo/bar/baz", protocol="s3")
 8 | reveal_type(path2)
   |             ^^^^^ `UPath`
 9 | resolved2 = path2.resolve()
10 | reveal_type(resolved2)
   |

info[revealed-type]: Revealed type
  --> upath-435.py:10:13
   |
 8 | reveal_type(path2)
 9 | resolved2 = path2.resolve()
10 | reveal_type(resolved2)
   |             ^^^^^^^^^ `Unknown`
11 |
12 | path3 = UPath("foo/bar/baz", protocol="s3", **params)
   |

info[revealed-type]: Revealed type
  --> upath-435.py:13:13
   |
12 | path3 = UPath("foo/bar/baz", protocol="s3", **params)
13 | reveal_type(path3)
   |             ^^^^^ `UPath`
14 | resolved3 = path3.resolve()
15 | reveal_type(resolved3)
   |

info[revealed-type]: Revealed type
  --> upath-435.py:15:13
   |
13 | reveal_type(path3)
14 | resolved3 = path3.resolve()
15 | reveal_type(resolved3)
   |             ^^^^^^^^^ `Unknown`
16 |
17 | path0 = UPath("/foo/bar/baz", protocol="file")
   |

info[revealed-type]: Revealed type
  --> upath-435.py:18:13
   |
17 | path0 = UPath("/foo/bar/baz", protocol="file")
18 | reveal_type(path0)
   |             ^^^^^ `UPath`
19 | resolved0 = path0.resolve()
20 | reveal_type(resolved0)
   |

info[revealed-type]: Revealed type
  --> upath-435.py:20:13
   |
18 | reveal_type(path0)
19 | resolved0 = path0.resolve()
20 | reveal_type(resolved0)
   |             ^^^^^^^^^ `Unknown`
21 |
22 | path1 = UPath("/foo/bar/baz", protocol="file", **params)
   |

info[revealed-type]: Revealed type
  --> upath-435.py:23:13
   |
22 | path1 = UPath("/foo/bar/baz", protocol="file", **params)
23 | reveal_type(path1)
   |             ^^^^^ `UPath`
24 |
25 | resolved1 = path1.resolve()
   |

info[revealed-type]: Revealed type
  --> upath-435.py:26:13
   |
25 | resolved1 = path1.resolve()
26 | reveal_type(resolved1)
   |             ^^^^^^^^^ `Unknown`
   |

Found 8 diagnostics

I guess I need more typesafety tests then...

[ap--]

The draft PR restores mypy typing for your case, but ty still doesn't pick up anything...

[ap--]

okay, so ty doesn't respect return types of __new__ yet: astral-sh/ty#281

[ap--]

Oh my... Seems this only works by accident in current mypy:

from __future__ import annotations
from typing import overload
from typing import Literal
from typing import reveal_type
from typing import Self

class A:
    @overload
    def __new__(cls, x: Literal['b']) -> B: ...
    @overload
    def __new__(cls, x: str) -> Self: ...
    def __new__(cls, x: str) -> A:
        if x == "b":
            return object.__new__(B)
        else:
            return object.__new__(cls)

    # uncommenting __init__ breaks type inference on __new__
    # def __init__(self, x):
    #     self.x = x

class B(A):
    pass

print(type(A('?')))  # runtime: A
reveal_type(A('?'))  # static:  A
print(type(A('b')))  # runtime: B
reveal_type(A('b'))  # static:  B

running mypy on this will correctly infer the types of type(A('?')) is A and type(A('b')) is B but if you uncomment __init__ it breaks the type inference, and all are inferred to be A

• Honor return type of __new__ even if not a subclass python/mypy#15182