@zzzen/pyright-internal 1.1.255 → 1.2.0-beta

package/src/tests/samples/loops16.py

@@ -1,322 +0,0 @@
-# This sample tests a complex function that contains a loop and a long
-# chain of if/elif statements.
-
-from random import randint
-
-
-def get_ipv4():
-    try:
-        while 1:
-            ip1, ip2, ip3, ip4 = (
-                randint(1, 255),
-                randint(1, 255),
-                randint(1, 255),
-                randint(1, 255),
-            )
-
-            if ip1 == 127:
-                continue
-            elif ip1 == 0:
-                continue
-            elif ip1 == 1:
-                continue
-            elif ip1 == 2:
-                continue
-            elif ip1 == 3:
-                continue
-            elif ip1 == 4:
-                continue
-            elif ip1 == 5:
-                continue
-            elif ip1 == 6:
-                continue
-            elif ip1 == 7:
-                continue
-            elif ip1 == 8:
-                continue
-            elif ip1 == 9:
-                continue
-            elif ip1 == 11:
-                continue
-            elif ip1 == 12:
-                continue
-            elif ip1 == 17:
-                continue
-            elif ip1 == 19:
-                continue
-            elif ip1 == 15:
-                continue
-            elif ip1 == 56:
-                continue
-            elif ip1 == 10:
-                continue
-            elif ip1 == 25:
-                continue
-            elif ip1 == 49:
-                continue
-            elif ip1 == 50:
-                continue
-            elif ip1 == 73:
-                continue
-            elif ip1 == 137:
-                continue
-            elif ip1 == 11:
-                continue
-            elif ip1 == 21:
-                continue
-            elif ip1 == 22:
-                continue
-            elif ip1 == 26:
-                continue
-            elif ip1 == 28:
-                continue
-            elif ip1 == 29:
-                continue
-            elif ip1 == 30:
-                continue
-            elif ip1 == 33:
-                continue
-            elif ip1 == 55:
-                continue
-            elif ip1 == 214:
-                continue
-            elif ip1 == 215:
-                continue
-            elif ip1 == 192 and ip2 == 168:
-                continue
-            elif ip1 == 146 and ip2 == 17:
-                continue
-            elif ip1 == 146 and ip2 == 80:
-                continue
-            elif ip1 == 146 and ip2 == 98:
-                continue
-            elif ip1 == 146 and ip2 == 154:
-                continue
-            elif ip1 == 147 and ip2 == 159:
-                continue
-            elif ip1 == 148 and ip2 == 114:
-                continue
-            elif ip1 == 150 and ip2 == 125:
-                continue
-            elif ip1 == 150 and ip2 == 133:
-                continue
-            elif ip1 == 150 and ip2 == 144:
-                continue
-            elif ip1 == 150 and ip2 == 149:
-                continue
-            elif ip1 == 150 and ip2 == 157:
-                continue
-            elif ip1 == 150 and ip2 == 184:
-                continue
-            elif ip1 == 150 and ip2 == 190:
-                continue
-            elif ip1 == 150 and ip2 == 196:
-                continue
-            elif ip1 == 152 and ip2 == 82:
-                continue
-            elif ip1 == 152 and ip2 == 229:
-                continue
-            elif ip1 == 157 and ip2 == 202:
-                continue
-            elif ip1 == 157 and ip2 == 217:
-                continue
-            elif ip1 == 161 and ip2 == 124:
-                continue
-            elif ip1 == 162 and ip2 == 32:
-                continue
-            elif ip1 == 155 and ip2 == 96:
-                continue
-            elif ip1 == 155 and ip2 == 149:
-                continue
-            elif ip1 == 155 and ip2 == 155:
-                continue
-            elif ip1 == 155 and ip2 == 178:
-                continue
-            elif ip1 == 164 and ip2 == 158:
-                continue
-            elif ip1 == 156 and ip2 == 9:
-                continue
-            elif ip1 == 167 and ip2 == 44:
-                continue
-            elif ip1 == 168 and ip2 == 68:
-                continue
-            elif ip1 == 168 and ip2 == 85:
-                continue
-            elif ip1 == 168 and ip2 == 102:
-                continue
-            elif ip1 == 203 and ip2 == 59:
-                continue
-            elif ip1 == 204 and ip2 == 34:
-                continue
-            elif ip1 == 207 and ip2 == 30:
-                continue
-            elif ip1 == 117 and ip2 == 55:
-                continue
-            elif ip1 == 117 and ip2 == 56:
-                continue
-            elif ip1 == 80 and ip2 == 235:
-                continue
-            elif ip1 == 207 and ip2 == 120:
-                continue
-            elif ip1 == 209 and ip2 == 35:
-                continue
-            elif ip1 == 64 and ip2 == 70:
-                continue
-            elif ip1 == 172 and ip2 >= 16 and ip2 < 32:
-                continue
-            elif ip1 == 100 and ip2 >= 64 and ip2 < 127:
-                continue
-            elif ip1 == 169 and ip2 > 254:
-                continue
-            elif ip1 == 198 and ip2 >= 18 and ip2 < 20:
-                continue
-            elif ip1 == 64 and ip2 >= 69 and ip2 < 227:
-                continue
-            elif ip1 == 128 and ip2 >= 35 and ip2 < 237:
-                continue
-            elif ip1 == 129 and ip2 >= 22 and ip2 < 255:
-                continue
-            elif ip1 == 130 and ip2 >= 40 and ip2 < 168:
-                continue
-            elif ip1 == 131 and ip2 >= 3 and ip2 < 251:
-                continue
-            elif ip1 == 132 and ip2 >= 3 and ip2 < 251:
-                continue
-            elif ip1 == 134 and ip2 >= 5 and ip2 < 235:
-                continue
-            elif ip1 == 136 and ip2 >= 177 and ip2 < 223:
-                continue
-            elif ip1 == 138 and ip2 >= 13 and ip2 < 194:
-                continue
-            elif ip1 == 139 and ip2 >= 31 and ip2 < 143:
-                continue
-            elif ip1 == 140 and ip2 >= 1 and ip2 < 203:
-                continue
-            elif ip1 == 143 and ip2 >= 45 and ip2 < 233:
-                continue
-            elif ip1 == 144 and ip2 >= 99 and ip2 < 253:
-                continue
-            elif ip1 == 146 and ip2 >= 165 and ip2 < 166:
-                continue
-            elif ip1 == 147 and ip2 >= 35 and ip2 < 43:
-                continue
-            elif ip1 == 147 and ip2 >= 103 and ip2 < 105:
-                continue
-            elif ip1 == 147 and ip2 >= 168 and ip2 < 170:
-                continue
-            elif ip1 == 147 and ip2 >= 198 and ip2 < 200:
-                continue
-            elif ip1 == 147 and ip2 >= 238 and ip2 < 255:
-                continue
-            elif ip1 == 150 and ip2 >= 113 and ip2 < 115:
-                continue
-            elif ip1 == 152 and ip2 >= 151 and ip2 < 155:
-                continue
-            elif ip1 == 153 and ip2 >= 21 and ip2 < 32:
-                continue
-            elif ip1 == 155 and ip2 >= 5 and ip2 < 10:
-                continue
-            elif ip1 == 155 and ip2 >= 74 and ip2 < 89:
-                continue
-            elif ip1 == 155 and ip2 >= 213 and ip2 < 222:
-                continue
-            elif ip1 == 157 and ip2 >= 150 and ip2 < 154:
-                continue
-            elif ip1 == 158 and ip2 >= 1 and ip2 < 21:
-                continue
-            elif ip1 == 158 and ip2 >= 235 and ip2 < 247:
-                continue
-            elif ip1 == 159 and ip2 >= 120 and ip2 < 121:
-                continue
-            elif ip1 == 160 and ip2 >= 132 and ip2 < 151:
-                continue
-            elif ip1 == 64 and ip2 >= 224 and ip2 < 227:
-                continue
-            elif ip1 == 162 and ip2 >= 45 and ip2 < 47:
-                continue
-            elif ip1 == 163 and ip2 >= 205 and ip2 < 207:
-                continue
-            elif ip1 == 164 and ip2 >= 45 and ip2 < 50:
-                continue
-            elif ip1 == 164 and ip2 >= 217 and ip2 < 233:
-                continue
-            elif ip1 == 207 and ip2 >= 60 and ip2 < 62:
-                continue
-            elif ip1 == 104 and ip2 >= 16 and ip2 < 31:
-                continue
-            elif ip1 == 193 and ip2 == 164:
-                continue
-            elif ip1 == 120 and ip2 >= 103 and ip2 < 108:
-                continue
-            elif ip1 == 188 and ip2 == 68:
-                continue
-            elif ip1 == 78 and ip2 == 46:
-                continue
-            elif ip1 >= 224:
-                continue
-            elif (ip1 == 178 and ip2 == 128) or (ip1 == 123 and ip2 == 59):
-                continue
-            elif (
-                (ip1 == 124 and ip2 == 244)
-                or (ip1 == 178 and ip2 == 254)
-                or (ip1 == 185 and ip2 == 168)
-                or (ip1 == 178 and ip2 == 79)
-            ):
-                continue
-            elif ip1 == 192 and ip2 == 88 and ip3 == 99:
-                continue
-            elif ip1 == 240:
-                continue
-            elif ip1 == 255 and ip2 == 255 and ip3 == 255 and ip4 == 255:
-                continue
-            elif ip1 == 126:
-                continue
-            elif ip1 == 13 and ip2 == 107 and ip3 == 6 and ip4 == 152:
-                continue
-            elif ip1 == 13 and ip2 == 107 and ip3 == 18 and ip4 == 10:
-                continue
-            elif ip1 == 13 and ip2 == 107 and ip3 == 128 and ip4 == 0:
-                continue
-            elif ip1 == 23 and ip2 == 103 and ip3 == 160 and ip4 == 0:
-                continue
-            elif ip1 == 40 and ip2 == 96 and ip3 == 0 and ip4 == 0:
-                continue
-            elif ip1 == 40 and ip2 == 104 and ip3 == 0 and ip4 == 0:
-                continue
-            elif ip1 == 52 and ip2 == 96 and ip3 == 0 and ip4 == 0:
-                continue
-            elif ip1 == 131 and ip2 == 253 and ip3 == 33 and ip4 == 215:
-                continue
-            elif ip1 == 132 and ip2 == 245 and ip3 == 0 and ip4 == 0:
-                continue
-            elif ip1 == 150 and ip2 == 171 and ip3 == 32 and ip4 == 0:
-                continue
-            elif ip1 == 204 and ip2 == 79 and ip3 == 197 and ip4 == 215:
-                continue
-            elif ip1 == 208 and ip2 == 71 and (ip3 > 120 and ip3 < 127):
-                continue
-            elif ip1 == 117 and ip2 == 102 and (ip3 > 128 and ip3 < 159):
-                continue
-            elif ip1 == 203 and ip2 == 171 and (ip3 > 192 and ip3 < 207):
-                continue
-            elif ip1 == 59 and (ip3 > 192 and ip3 < 255):
-                continue
-            elif ip1 == 163 and ip2 == 233:
-                continue
-            elif ip1 == 62 and ip2 <= 30:
-                continue  # honey pots
-            elif ip1 == 207 and ip2 >= 31 and ip3 <= 120:
-                continue  # fbi honey pots
-            elif ip1 == 65 and ip2 >= 224 and ip3 <= 226:
-                continue  # more honey pots
-            elif ip1 == 195 and ip2 == 10:
-                continue  # another honeypot
-            elif ip1 == 216 and (ip2 == 25 or ip2 == 94):
-                continue
-            elif ip1 == 212 and ip2 == 56:
-                continue
-
-            ip = f"{str(ip1)}.{str(ip2)}.{str(ip3)}.{str(ip4)}"
-            return ip
-    except:
-        pass

package/src/tests/samples/loops17.py

@@ -1,9 +0,0 @@
-# This sample tests the case where a loop involves an unannotated parameter
-# and therefore an "unknown" that propagates through the loop.
-
-def f(x):
-    e = 0
-    for _ in [0]:
-        e += x
-    reveal_type(e, expected_text="Unknown | Literal[0]")
-    return e

package/src/tests/samples/loops18.py

@@ -1,23 +0,0 @@
-# This sample tests type narrowing in a loop.
-
-from typing_extensions import Self
-from collections.abc import Generator
-
-
-class A:
-    parent: Self | None
-
-
-class B:
-    ...
-
-
-def foo(v: A | B | None) -> Generator[A, None, None]:
-    reveal_type(v)
-    if not isinstance(v, B):
-        reveal_type(v, expected_text="A | None")
-        while v is not None:
-            reveal_type(v, expected_text="A")
-            yield v
-            v = v.parent
-            reveal_type(v, expected_text="A | None")

package/src/tests/samples/loops19.py

@@ -1,14 +0,0 @@
-# This sample tests a loop that references instance variables.
-
-class Results:
-    zzz: int
-
-
-class Foo:
-    yyy: int
-
-    def method1(self, results: list[Results]):
-        abc = None
-        for result in results:
-            if abc is not None and abc.zzz < result.zzz:
-                abc = result

package/src/tests/samples/loops2.py

@@ -1,25 +0,0 @@
-# This sample tests a piece of code that involves lots
-# of cyclical dependencies for type resolution.
-
-from typing import Tuple
-
-
-def needs_str(a: str) -> Tuple[str, str]:
-    ...
-
-
-def xxx():
-    v1 = ""
-    v2 = ""
-    v3 = ""
-
-    v4 = None
-
-    _ = v1
-    v3, _ = v3, v2
-    v4 = v3
-
-    for _ in range(1):
-        assert v4 is not None
-        v1, v2 = needs_str(v4)
-        v3 = v1

package/src/tests/samples/loops20.py

@@ -1,41 +0,0 @@
-# This sample tests a case where variables within multiple loops, both
-# nested and sequential, depend on each other in ways that can result
-# in long analysis times.
-
-from math import isnan
-from typing import Callable
-
-
-def linspace(start: float, stop: float, num: int = 50):
-    if num == 1:
-        yield stop
-        return
-    step = (stop - start) / (num - 1)
-    for i in range(num):
-        yield start + step * i
-
-
-def find_zero(f: Callable[[float], float]) -> float:
-    x_0 = 0
-    x_1 = 0
-    f_x_0 = 0
-    f_x_1 = 0
-    while True:
-        if not(isnan(f_x_0)) and isnan(f_x_1):
-            x_tests = list(linspace(x_1, x_0, 25))
-            f_x_tests = (f(x) for x in x_tests)
-            for x, f_x in zip(x_tests, f_x_tests):
-                if not(isnan(f_x)):
-                    x_1 = x
-                    f_x_1 = f_x
-                    break
-
-        elif isnan(f_x_0) and not(isnan(f_x_1)):
-            x_tests = list(linspace(x_0, x_1, 25))
-            f_x_tests = (f(x) for x in x_tests)
-            for x, f_x in zip(x_tests, f_x_tests):
-                if not(isnan(f_x)):
-                    x_0 = x
-                    f_x_0 = f_x 
-                    break
-     

package/src/tests/samples/loops21.py

@@ -1,18 +0,0 @@
-# This sample tests a loop where some of the variables within the loop
-# depend on each other.
-
-# pyright: strict
-
-
-def find_min(nums: list[int]) -> int:
-    low = 0
-    high = len(nums) - 1
-    while low < high:
-        mid = (low + high) // 2
-        if nums[mid] > nums[high]:
-            low = mid + 1
-        elif nums[mid] < nums[high]:
-            high = mid
-        else:
-            high -= 1
-    return nums[low]

package/src/tests/samples/loops22.py

@@ -1,21 +0,0 @@
-# This sample tests a case where a loop contains multiple conditional
-# checks.
-
-# pyright: strict
-
-from __future__ import annotations
-
-
-class ListNode:
-    def __init__(self, val: int = 0, next: ListNode | None = None):
-        self.val = val
-        self.next = next
-
-
-def has_cycle(head: ListNode | None) -> bool:
-    fast_head = head
-    while head and fast_head:
-        fast_head = fast_head.next
-        if fast_head:
-            fast_head = fast_head.next
-    return False

package/src/tests/samples/loops23.py

@@ -1,16 +0,0 @@
-# This sample covers a case that resulted in a crash due to infinite
-# recursion within the code flow engine and type narrowing logic.
-
-
-from typing import Any
-
-
-def func():
-    c: Any = None
-
-    while True:
-        if a:  # type: ignore
-            if c:
-                pass
-
-        a = c == c.foo

package/src/tests/samples/loops24.py

@@ -1,12 +0,0 @@
-# This sample tests a loop that involves assignment of a tuple
-# within a loop.
-
-# pyright: strict
-
-var = 0
-while True:
-    if var and True:
-        break
-    else:
-        var, _ = var + 1, 0
-

package/src/tests/samples/loops25.py

@@ -1,45 +0,0 @@
-# This sample tests a series of nested loops containing variables
-# with significant dependencies.
-
-for val1 in range(10):
-    cnt1 = 4
-    for val2 in range(10 - val1):
-        cnt2 = 4
-        if val2 == val1:
-            cnt2 -= 1
-        for val3 in range(10 - val1 - val2):
-            cnt3 = 4
-            if val3 == val1:
-                cnt3 -= 1
-            if val3 == val2:
-                cnt3 -= 1
-            for val4 in range(10 - val1 - val2 - val3):
-                cnt4 = 4
-                if val4 == val1:
-                    cnt4 -= 1
-                if val4 == val2:
-                    cnt4 -= 1
-                if val4 == val3:
-                    cnt4 -= 1
-                for val5 in range(10 - val1 - val2 - val3 - val4):
-                    cnt5 = 4
-                    if val5 == val1:
-                        cnt5 -= 1
-                    if val5 == val2:
-                        cnt5 -= 1
-                    if val5 == val3:
-                        cnt5 -= 1
-                    if val5 == val4:
-                        cnt5 -= 1
-                    val6 = 10 - val1 - val2 - val3 - val4 - val5
-                    cnt6 = 4
-                    if val6 == val1:
-                        cnt6 -= 1
-                    if val6 == val2:
-                        cnt6 -= 1
-                    if val6 == val3:
-                        cnt6 -= 1
-                    if val6 == val4:
-                        cnt6 -= 1
-                    if val6 == val5:
-                        cnt6 -= 1

package/src/tests/samples/loops26.py

@@ -1,12 +0,0 @@
-# This sample tests proper type narrowing within a double loop.
-
-# pyright: strict
-
-from typing import Callable
-
-
-def func(call: Callable[[], None] | None):
-    while True:
-        while True:
-            if call is None or call():
-                break

package/src/tests/samples/loops3.py

@@ -1,11 +0,0 @@
-# This sample tests a piece of code that involves lots
-# of cyclical dependencies for type resolution.
-
-from typing import Optional
-
-n: Optional[str] = None
-while True:
-    if n is None:
-        n = ""
-    else:
-        n = n + ""

package/src/tests/samples/loops4.py

@@ -1,17 +0,0 @@
-# This sample tests a loop with self-references.
-
-a: bool = False
-x: int = 0
-
-while len(input()) < 42:
-
-    x += 43
-
-    if a and a:
-        continue
-
-    if a:
-        print("")
-        continue
-
-    x += 44

package/src/tests/samples/loops5.py

@@ -1,14 +0,0 @@
-# This sample tests a case where a potential type alias
-# ("a") is involved in a recursive type dependency
-# ("a" depends on "test" which depends on "a").
-
-# pyright: strict
-
-
-test = {"key": "value"}
-
-while True:
-    a = test
-    reveal_type(a, expected_text="dict[str, str]")
-    test = a.copy()
-    reveal_type(test, expected_text="dict[str, str]")

package/src/tests/samples/loops6.py

@@ -1,25 +0,0 @@
-# This sample tests a difficult set of circular dependencies
-# between untyped variables.
-
-
-class Foo:
-    def new_from_dict(self, param1):
-        return Foo()
-
-    def method1(self):
-        return {}, {}
-
-    def method3(self, param3):
-        while True:
-            for key in param3.keys():
-                foo1 = self.new_from_dict({key: None})
-                var1, var2 = foo1.method1()
-
-                if len(var1) < 2:
-                    param3 = var2
-                    break
-
-                foo2 = foo1.new_from_dict({})
-                var1, var2 = foo2.method1()
-            else:
-                break

package/src/tests/samples/loops7.py

@@ -1,14 +0,0 @@
-# This sample tests a difficult set of circular dependencies
-# between untyped variables.
-
-
-from typing import Optional
-
-
-class Foo:
-    name: Optional[str]
-
-    def correct(self):
-        if self.name is not None:
-            for _ in []:
-                self.name = self.name.replace("", "")

package/src/tests/samples/loops8.py

@@ -1,17 +0,0 @@
-# This sample tests a difficult set of circular dependencies
-# between untyped variables.
-
-# pyright: strict
-
-from typing import Iterable
-
-
-def test(parts: Iterable[str]):
-    x: list[str] = []
-    ns = ""
-    for part in parts:
-        if ns:
-            ns += "a"
-        else:
-            ns += part
-        x.append(ns)