jaclang 0.6.0__py3-none-any.whl → 0.6.5__py3-none-any.whl

jaclang/vendor/lsprotocol/validators.py

@@ -0,0 +1,47 @@
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License.
+
+
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+    import attrs
+
+INTEGER_MIN_VALUE = -(2**31)
+INTEGER_MAX_VALUE = 2**31 - 1
+
+
+def integer_validator(
+    instance: Any,
+    attribute: "attrs.Attribute[int]",
+    value: Any,
+) -> bool:
+    """Validates that integer value belongs in the range expected by LSP."""
+    if not isinstance(value, int) or not (
+        INTEGER_MIN_VALUE <= value <= INTEGER_MAX_VALUE
+    ):
+        name = attribute.name if hasattr(attribute, "name") else str(attribute)
+        raise ValueError(
+            f"{instance.__class__.__qualname__}.{name} should be in range [{INTEGER_MIN_VALUE}:{INTEGER_MAX_VALUE}], but was {value}."
+        )
+    return True
+
+
+UINTEGER_MIN_VALUE = 0
+UINTEGER_MAX_VALUE = 2**31 - 1
+
+
+def uinteger_validator(
+    instance: Any,
+    attribute: "attrs.Attribute[int]",
+    value: Any,
+) -> bool:
+    """Validates that unsigned integer value belongs in the range expected by LSP."""
+    if not isinstance(value, int) or not (
+        UINTEGER_MIN_VALUE <= value <= UINTEGER_MAX_VALUE
+    ):
+        name = attribute.name if hasattr(attribute, "name") else str(attribute)
+        raise ValueError(
+            f"{instance.__class__.__qualname__}.{name} should be in range [{UINTEGER_MIN_VALUE}:{UINTEGER_MAX_VALUE}], but was {value}."
+        )
+    return True

jaclang/vendor/lsprotocol-2023.0.1.dist-info/LICENSE

@@ -0,0 +1,21 @@
+    MIT License
+
+    Copyright (c) Microsoft Corporation.
+
+    Permission is hereby granted, free of charge, to any person obtaining a copy
+    of this software and associated documentation files (the "Software"), to deal
+    in the Software without restriction, including without limitation the rights
+    to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+    copies of the Software, and to permit persons to whom the Software is
+    furnished to do so, subject to the following conditions:
+
+    The above copyright notice and this permission notice shall be included in all
+    copies or substantial portions of the Software.
+
+    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+    AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+    OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+    SOFTWARE

jaclang/vendor/lsprotocol-2023.0.1.dist-info/METADATA

@@ -0,0 +1,65 @@
+Metadata-Version: 2.1
+Name: lsprotocol
+Version: 2023.0.1
+Summary: Python implementation of the Language Server Protocol.
+Author-email: Microsoft Corporation <lsprotocol-help@microsoft.com>
+Maintainer-email: Brett Cannon <brett@python.org>, Karthik Nadig <kanadig@microsoft.com>
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Requires-Dist: attrs>=21.3.0
+Requires-Dist: cattrs!=23.2.1
+Project-URL: Issues, https://github.com/microsoft/lsprotocol/issues
+Project-URL: Source, https://github.com/microsoft/lsprotocol
+
+# Language Server Protocol Types implementation for Python
+
+`lsprotocol` is a python implementation of object types used in the Language Server Protocol (LSP). This repository contains the code generator and the generated types for LSP.
+
+## Overview
+
+LSP is used by editors to communicate with various tools to enables services like code completion, documentation on hover, formatting, code analysis, etc. The intent of this library is to allow you to build on top of the types used by LSP. This repository will be kept up to date with the latest version of LSP as it is updated.
+
+## Installation
+
+`python -m pip install lsprotocol`
+
+## Usage
+
+### Using LSP types
+
+```python
+from lsprotocol import types
+
+position = types.Position(line=10, character=3)
+```
+
+### Using built-in type converters
+
+```python
+# test.py
+import json
+from lsprotocol import converters, types
+
+position = types.Position(line=10, character=3)
+converter = converters.get_converter()
+print(json.dumps(converter.unstructure(position, unstructure_as=types.Position)))
+```
+
+Output:
+
+```console
+> python test.py
+{"line": 10, "character": 3}
+```
+

jaclang/vendor/lsprotocol-2023.0.1.dist-info/RECORD

@@ -0,0 +1,10 @@
+lsprotocol/__init__.py,sha256=zoT6Do2JtGHGb7pOeKpahg4ocXIsSpyowjhOrhUhx8g,94
+lsprotocol/_hooks.py,sha256=PCTq4Ve_dDd02DMcWQ8afu9gj_oyX0B4nDOomPghqYs,41570
+lsprotocol/converters.py,sha256=404tQOVoZL31R9CBrDe6Gx9Nok5cRph3glKlnSx00fo,433
+lsprotocol/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+lsprotocol/types.py,sha256=nZYiI5ZvHEBkRYjtPd8tpqe0n2NpmdaCZ2RLwHxoMLs,454735
+lsprotocol/validators.py,sha256=5UMUmWhk52_Ps66_KFydjNkMfLNUsPH3wmV0Buv645s,1420
+lsprotocol-2023.0.1.dist-info/LICENSE,sha256=ws_MuBL-SCEBqPBFl9_FqZkaaydIJmxHrJG2parhU4M,1141
+lsprotocol-2023.0.1.dist-info/WHEEL,sha256=EZbGkh7Ie4PoZfRQ8I0ZuP9VklN_TvcZ6DSE5Uar4z4,81
+lsprotocol-2023.0.1.dist-info/METADATA,sha256=oh7M_V0nCX-lx8MCik5z0_J8Wyd7ApJtdl30wWs4Tb8,2237
+lsprotocol-2023.0.1.dist-info/RECORD,,

jaclang/vendor/lsprotocol-2023.0.1.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: flit 3.9.0
+Root-Is-Purelib: true
+Tag: py3-none-any

jaclang/vendor/mypy/api.py

@@ -69,9 +69,7 @@ def run(args: list[str]) -> tuple[str, str, int]:
     from mypy.main import main
 
     return _run(
-        lambda stdout, stderr: main(
-            args=args, stdout=stdout, stderr=stderr, clean_exit=True
-        )
+        lambda stdout, stderr: main(args=args, stdout=stdout, stderr=stderr, clean_exit=True)
     )
 
 

jaclang/vendor/mypy/applytype.py

@@ -26,9 +26,7 @@ def get_target_type(
     tvar: TypeVarLikeType,
     type: Type,
     callable: CallableType,
-    report_incompatible_typevar_value: Callable[
-        [CallableType, Type, str, Context], None
-    ],
+    report_incompatible_typevar_value: Callable[[CallableType, Type, str, Context], None],
     context: Context,
     skip_unsatisfied: bool,
 ) -> Type | None:
@@ -47,10 +45,7 @@ def get_target_type(
         if isinstance(p_type, TypeVarType) and p_type.values:
             # Allow substituting T1 for T if every allowed value of T1
             # is also a legal value of T.
-            if all(
-                any(mypy.subtypes.is_same_type(v, v1) for v in values)
-                for v1 in p_type.values
-            ):
+            if all(any(mypy.subtypes.is_same_type(v, v1) for v in values) for v1 in p_type.values):
                 return type
         matching = []
         for value in values:
@@ -83,9 +78,7 @@ def get_target_type(
 def apply_generic_arguments(
     callable: CallableType,
     orig_types: Sequence[Type | None],
-    report_incompatible_typevar_value: Callable[
-        [CallableType, Type, str, Context], None
-    ],
+    report_incompatible_typevar_value: Callable[[CallableType, Type, str, Context], None],
     context: Context,
     skip_unsatisfied: bool = False,
 ) -> CallableType:
@@ -108,19 +101,12 @@ def apply_generic_arguments(
     id_to_type: dict[TypeVarId, Type] = {}
 
     for tvar, type in zip(tvars, orig_types):
-        assert not isinstance(
-            type, PartialType
-        ), "Internal error: must never apply partial type"
+        assert not isinstance(type, PartialType), "Internal error: must never apply partial type"
         if type is None:
             continue
 
         target_type = get_target_type(
-            tvar,
-            type,
-            callable,
-            report_incompatible_typevar_value,
-            context,
-            skip_unsatisfied,
+            tvar, type, callable, report_incompatible_typevar_value, context, skip_unsatisfied
         )
         if target_type is not None:
             id_to_type[tvar.id] = target_type
@@ -145,28 +131,42 @@ def apply_generic_arguments(
         # Same as for ParamSpec, callable with variadic types needs to be expanded as a whole.
         callable = expand_type(callable, id_to_type)
         assert isinstance(callable, CallableType)
-        return callable.copy_modified(
-            variables=[tv for tv in tvars if tv.id not in id_to_type]
-        )
+        return callable.copy_modified(variables=[tv for tv in tvars if tv.id not in id_to_type])
     else:
         callable = callable.copy_modified(
             arg_types=[expand_type(at, id_to_type) for at in callable.arg_types]
         )
 
-    # Apply arguments to TypeGuard if any.
+    # Apply arguments to TypeGuard and TypeIs if any.
     if callable.type_guard is not None:
         type_guard = expand_type(callable.type_guard, id_to_type)
     else:
         type_guard = None
+    if callable.type_is is not None:
+        type_is = expand_type(callable.type_is, id_to_type)
+    else:
+        type_is = None
 
     # The callable may retain some type vars if only some were applied.
     # TODO: move apply_poly() logic from checkexpr.py here when new inference
     # becomes universally used (i.e. in all passes + in unification).
     # With this new logic we can actually *add* some new free variables.
-    remaining_tvars = [tv for tv in tvars if tv.id not in id_to_type]
+    remaining_tvars: list[TypeVarLikeType] = []
+    for tv in tvars:
+        if tv.id in id_to_type:
+            continue
+        if not tv.has_default():
+            remaining_tvars.append(tv)
+            continue
+        # TypeVarLike isn't in id_to_type mapping.
+        # Only expand the TypeVar default here.
+        typ = expand_type(tv, id_to_type)
+        assert isinstance(typ, TypeVarLikeType)
+        remaining_tvars.append(typ)
 
     return callable.copy_modified(
         ret_type=expand_type(callable.ret_type, id_to_type),
         variables=remaining_tvars,
         type_guard=type_guard,
+        type_is=type_is,
     )

jaclang/vendor/mypy/argmap.py

@@ -75,9 +75,7 @@ def map_actuals_to_formals(
                         break
                     fi += 1
         elif actual_kind.is_named():
-            assert (
-                actual_names is not None
-            ), "Internal error: named kinds without names given"
+            assert actual_names is not None, "Internal error: named kinds without names given"
             name = actual_names[ai]
             if name in formal_names:
                 formal_to_actual[formal_names.index(name)].append(ai)
@@ -247,9 +245,7 @@ class ArgTypeExpander:
                     assert formal_name is not None
                 else:
                     # Pick an arbitrary item if no specified keyword is expected.
-                    formal_name = (
-                        set(actual_type.items.keys()) - self.kwargs_used
-                    ).pop()
+                    formal_name = (set(actual_type.items.keys()) - self.kwargs_used).pop()
                 self.kwargs_used.add(formal_name)
                 return actual_type.items[formal_name]
             elif (
@@ -259,9 +255,9 @@ class ArgTypeExpander:
             ):
                 # Only `Mapping` type can be unpacked with `**`.
                 # Other types will produce an error somewhere else.
-                return map_instance_to_supertype(
-                    actual_type, self.context.mapping_type.type
-                ).args[1]
+                return map_instance_to_supertype(actual_type, self.context.mapping_type.type).args[
+                    1
+                ]
             elif isinstance(actual_type, ParamSpecType):
                 # ParamSpec is valid in **kwargs but it can't be unpacked.
                 return actual_type

jaclang/vendor/mypy/binder.py

@@ -8,15 +8,7 @@ from typing_extensions import TypeAlias as _TypeAlias
 from mypy.erasetype import remove_instance_last_known_values
 from mypy.join import join_simple
 from mypy.literals import Key, literal, literal_hash, subkeys
-from mypy.nodes import (
-    Expression,
-    IndexExpr,
-    MemberExpr,
-    NameExpr,
-    RefExpr,
-    TypeInfo,
-    Var,
-)
+from mypy.nodes import Expression, IndexExpr, MemberExpr, NameExpr, RefExpr, TypeInfo, Var
 from mypy.subtypes import is_same_type, is_subtype
 from mypy.types import (
     AnyType,
@@ -220,12 +212,8 @@ class ConditionalTypeBinder:
             declaration_type = get_proper_type(self.declarations.get(key))
             if isinstance(declaration_type, AnyType):
                 # At this point resulting values can't contain None, see continue above
-                if not all(
-                    is_same_type(type, cast(Type, t)) for t in resulting_values[1:]
-                ):
-                    type = AnyType(
-                        TypeOfAny.from_another_any, source_any=declaration_type
-                    )
+                if not all(is_same_type(type, cast(Type, t)) for t in resulting_values[1:]):
+                    type = AnyType(TypeOfAny.from_another_any, source_any=declaration_type)
             else:
                 for other in resulting_values[1:]:
                     assert other is not None
@@ -244,11 +232,7 @@ class ConditionalTypeBinder:
                         # Simplify away any extra Any's that were added to the declared
                         # type when popping a frame.
                         simplified = UnionType.make_union(
-                            [
-                                t
-                                for t in type.items
-                                if not isinstance(get_proper_type(t), AnyType)
-                            ]
+                            [t for t in type.items if not isinstance(get_proper_type(t), AnyType)]
                         )
                         if simplified == self.declarations[key]:
                             type = simplified
@@ -295,11 +279,7 @@ class ConditionalTypeBinder:
         self.type_assignments = old_assignments
 
     def assign_type(
-        self,
-        expr: Expression,
-        type: Type,
-        declared_type: Type | None,
-        restrict_any: bool = False,
+        self, expr: Expression, type: Type, declared_type: Type | None, restrict_any: bool = False
     ) -> None:
         # We should erase last known value in binder, because if we are using it,
         # it means that the target is not final, and therefore can't hold a literal.
@@ -348,12 +328,9 @@ class ConditionalTypeBinder:
         elif (
             isinstance(p_type, AnyType)
             and isinstance(p_declared, UnionType)
-            and any(
-                isinstance(get_proper_type(item), NoneType) for item in p_declared.items
-            )
+            and any(isinstance(get_proper_type(item), NoneType) for item in p_declared.items)
             and isinstance(
-                get_proper_type(self.most_recent_enclosing_type(expr, NoneType())),
-                NoneType,
+                get_proper_type(self.most_recent_enclosing_type(expr, NoneType())), NoneType
             )
         ):
             # Replace any Nones in the union type with Any
@@ -364,9 +341,7 @@ class ConditionalTypeBinder:
             self.put(expr, UnionType(new_items))
         elif isinstance(p_type, AnyType) and not (
             isinstance(p_declared, UnionType)
-            and any(
-                isinstance(get_proper_type(item), AnyType) for item in p_declared.items
-            )
+            and any(isinstance(get_proper_type(item), AnyType) for item in p_declared.items)
         ):
             # Assigning an Any value doesn't affect the type to avoid false negatives, unless
             # there is an Any item in a declared union type.
@@ -392,18 +367,14 @@ class ConditionalTypeBinder:
         for dep in self.dependencies.get(key, set()):
             self._cleanse_key(dep)
 
-    def most_recent_enclosing_type(
-        self, expr: BindableExpression, type: Type
-    ) -> Type | None:
+    def most_recent_enclosing_type(self, expr: BindableExpression, type: Type) -> Type | None:
         type = get_proper_type(type)
         if isinstance(type, AnyType):
             return get_declaration(expr)
         key = literal_hash(expr)
         assert key is not None
         enclosers = [get_declaration(expr)] + [
-            f.types[key]
-            for f in self.frames
-            if key in f.types and is_subtype(type, f.types[key])
+            f.types[key] for f in self.frames if key in f.types and is_subtype(type, f.types[key])
         ]
         return enclosers[-1]
 
@@ -563,7 +534,5 @@ def collapse_variadic_union(typ: UnionType) -> Type:
     if len(first.items) == 0:
         simplified: Type = unpacked.copy_modified()
     else:
-        simplified = TupleType(
-            prefix + [unpack] + suffix, fallback=last.partial_fallback
-        )
+        simplified = TupleType(prefix + [unpack] + suffix, fallback=last.partial_fallback)
     return UnionType.make_union([simplified] + other_items)