jaclang 0.2.5__py3-none-any.whl → 0.3.1__py3-none-any.whl

jaclang/vendor/mypy/semanal_typeddict.py

@@ -349,6 +349,14 @@ class TypedDictAnalyzer:
             total = require_bool_literal_argument(
                 self.api, defn.keywords["total"], "total", True
             )
+        if defn.keywords and defn.keywords.keys() != {"total"}:
+            for_function = ' for "__init_subclass__" of "TypedDict"'
+            for key in defn.keywords:
+                if key == "total":
+                    continue
+                self.msg.unexpected_keyword_argument_for_function(
+                    for_function, key, defn
+                )
         required_keys = {
             field
             for (field, t) in zip(fields, types)
@@ -420,6 +428,23 @@ class TypedDictAnalyzer:
             types = [  # unwrap Required[T] to just T
                 t.item if isinstance(t, RequiredType) else t for t in types
             ]
+
+            # Perform various validations after unwrapping.
+            for t in types:
+                check_for_explicit_any(
+                    t,
+                    self.options,
+                    self.api.is_typeshed_stub_file,
+                    self.msg,
+                    context=call,
+                )
+            if self.options.disallow_any_unimported:
+                for t in types:
+                    if has_any_from_unimported_type(t):
+                        self.msg.unimported_type_becomes_any(
+                            "Type of a TypedDict key", t, call
+                        )
+
             existing_info = None
             if isinstance(node.analyzed, TypedDictExpr):
                 existing_info = node.analyzed.info
@@ -478,17 +503,6 @@ class TypedDictAnalyzer:
             # One of the types is not ready, defer.
             return None
         items, types, ok = res
-        for t in types:
-            check_for_explicit_any(
-                t, self.options, self.api.is_typeshed_stub_file, self.msg, context=call
-            )
-
-        if self.options.disallow_any_unimported:
-            for t in types:
-                if has_any_from_unimported_type(t):
-                    self.msg.unimported_type_becomes_any(
-                        "Type of a TypedDict key", t, dictexpr
-                    )
         assert total is not None
         return args[0].value, items, types, total, tvar_defs, ok
 

jaclang/vendor/mypy/stubdoc.py

@@ -44,11 +44,19 @@ def is_valid_type(s: str) -> bool:
 class ArgSig:
     """Signature info for a single argument."""
 
-    def __init__(self, name: str, type: str | None = None, default: bool = False):
+    def __init__(
+        self,
+        name: str,
+        type: str | None = None,
+        *,
+        default: bool = False,
+        default_value: str = "...",
+    ) -> None:
         self.name = name
         self.type = type
         # Does this argument have a default value?
         self.default = default
+        self.default_value = default_value
 
     def is_star_arg(self) -> bool:
         return self.name.startswith("*") and not self.name.startswith("**")
@@ -67,6 +75,7 @@ class ArgSig:
                 self.name == other.name
                 and self.type == other.type
                 and self.default == other.default
+                and self.default_value == other.default_value
             )
         return False
 
@@ -127,10 +136,10 @@ class FunctionSig(NamedTuple):
             if arg_type:
                 arg_def += ": " + arg_type
                 if arg.default:
-                    arg_def += " = ..."
+                    arg_def += f" = {arg.default_value}"
 
             elif arg.default:
-                arg_def += "=..."
+                arg_def += f"={arg.default_value}"
 
             args.append(arg_def)
 
@@ -400,7 +409,12 @@ def infer_ret_type_sig_from_docstring(docstr: str, name: str) -> str | None:
 
 def infer_ret_type_sig_from_anon_docstring(docstr: str) -> str | None:
     """Convert signature in form of "(self: TestClass, arg0) -> int" to their return type."""
-    return infer_ret_type_sig_from_docstring("stub" + docstr.strip(), "stub")
+    lines = [
+        "stub" + line.strip()
+        for line in docstr.splitlines()
+        if line.strip().startswith("(")
+    ]
+    return infer_ret_type_sig_from_docstring("".join(lines), "stub")
 
 
 def parse_signature(sig: str) -> tuple[str, list[str], list[str]] | None:

jaclang/vendor/mypy/stubgen.py

@@ -99,6 +99,7 @@ from mypy.nodes import (
     NameExpr,
     OpExpr,
     OverloadedFuncDef,
+    SetExpr,
     Statement,
     StrExpr,
     TempNode,
@@ -499,15 +500,28 @@ class ASTStubGenerator(BaseStubGenerator, mypy.traverser.TraverserVisitor):
             if kind.is_named() and not any(arg.name.startswith("*") for arg in args):
                 args.append(ArgSig("*"))
 
+            default = "..."
             if arg_.initializer:
                 if not typename:
                     typename = self.get_str_type_of_node(arg_.initializer, True, False)
+                potential_default, valid = self.get_str_default_of_node(
+                    arg_.initializer
+                )
+                if valid and len(potential_default) <= 200:
+                    default = potential_default
             elif kind == ARG_STAR:
                 name = f"*{name}"
             elif kind == ARG_STAR2:
                 name = f"**{name}"
 
-            args.append(ArgSig(name, typename, default=bool(arg_.initializer)))
+            args.append(
+                ArgSig(
+                    name,
+                    typename,
+                    default=bool(arg_.initializer),
+                    default_value=default,
+                )
+            )
 
         if ctx.class_info is not None and all(
             arg.type is None and arg.default is False for arg in args
@@ -1282,6 +1296,70 @@ class ASTStubGenerator(BaseStubGenerator, mypy.traverser.TraverserVisitor):
         # This is some other unary expr, we cannot do anything with it (yet?).
         return expr
 
+    def get_str_default_of_node(self, rvalue: Expression) -> tuple[str, bool]:
+        """Get a string representation of the default value of a node.
+
+        Returns a 2-tuple of the default and whether or not it is valid.
+        """
+        if isinstance(rvalue, NameExpr):
+            if rvalue.name in ("None", "True", "False"):
+                return rvalue.name, True
+        elif isinstance(rvalue, (IntExpr, FloatExpr)):
+            return f"{rvalue.value}", True
+        elif isinstance(rvalue, UnaryExpr):
+            if isinstance(rvalue.expr, (IntExpr, FloatExpr)):
+                return f"{rvalue.op}{rvalue.expr.value}", True
+        elif isinstance(rvalue, StrExpr):
+            return repr(rvalue.value), True
+        elif isinstance(rvalue, BytesExpr):
+            return "b" + repr(rvalue.value).replace("\\\\", "\\"), True
+        elif isinstance(rvalue, TupleExpr):
+            items_defaults = []
+            for e in rvalue.items:
+                e_default, valid = self.get_str_default_of_node(e)
+                if not valid:
+                    break
+                items_defaults.append(e_default)
+            else:
+                closing = ",)" if len(items_defaults) == 1 else ")"
+                default = "(" + ", ".join(items_defaults) + closing
+                return default, True
+        elif isinstance(rvalue, ListExpr):
+            items_defaults = []
+            for e in rvalue.items:
+                e_default, valid = self.get_str_default_of_node(e)
+                if not valid:
+                    break
+                items_defaults.append(e_default)
+            else:
+                default = "[" + ", ".join(items_defaults) + "]"
+                return default, True
+        elif isinstance(rvalue, SetExpr):
+            items_defaults = []
+            for e in rvalue.items:
+                e_default, valid = self.get_str_default_of_node(e)
+                if not valid:
+                    break
+                items_defaults.append(e_default)
+            else:
+                if items_defaults:
+                    default = "{" + ", ".join(items_defaults) + "}"
+                    return default, True
+        elif isinstance(rvalue, DictExpr):
+            items_defaults = []
+            for k, v in rvalue.items:
+                if k is None:
+                    break
+                k_default, k_valid = self.get_str_default_of_node(k)
+                v_default, v_valid = self.get_str_default_of_node(v)
+                if not (k_valid and v_valid):
+                    break
+                items_defaults.append(f"{k_default}: {v_default}")
+            else:
+                default = "{" + ", ".join(items_defaults) + "}"
+                return default, True
+        return "...", False
+
     def should_reexport(self, name: str, full_module: str, name_is_alias: bool) -> bool:
         is_private = self.is_private_name(name, full_module + "." + name)
         if (
@@ -1702,6 +1780,7 @@ def generate_stubs(options: Options) -> None:
                 doc_dir=options.doc_dir,
                 include_private=options.include_private,
                 export_less=options.export_less,
+                include_docstrings=options.include_docstrings,
             )
     num_modules = len(all_modules)
     if not options.quiet and num_modules > 0:

jaclang/vendor/mypy/stubgenc.py

@@ -136,10 +136,12 @@ class DocstringSignatureGenerator(SignatureGenerator):
         """Infer property type from docstring or docstring signature."""
         if ctx.docstring is not None:
             inferred = infer_ret_type_sig_from_anon_docstring(ctx.docstring)
-            if not inferred:
-                inferred = infer_ret_type_sig_from_docstring(ctx.docstring, ctx.name)
-            if not inferred:
-                inferred = infer_prop_type_from_docstring(ctx.docstring)
+            if inferred:
+                return inferred
+            inferred = infer_ret_type_sig_from_docstring(ctx.docstring, ctx.name)
+            if inferred:
+                return inferred
+            inferred = infer_prop_type_from_docstring(ctx.docstring)
             return inferred
         else:
             return None
@@ -249,6 +251,26 @@ class InspectionStubGenerator(BaseStubGenerator):
         self.resort_members = self.is_c_module
         super().__init__(_all_, include_private, export_less, include_docstrings)
         self.module_name = module_name
+        if self.is_c_module:
+            # Add additional implicit imports.
+            # C-extensions are given more lattitude since they do not import the typing module.
+            self.known_imports.update(
+                {
+                    "typing": [
+                        "Any",
+                        "Callable",
+                        "ClassVar",
+                        "Dict",
+                        "Iterable",
+                        "Iterator",
+                        "List",
+                        "NamedTuple",
+                        "Optional",
+                        "Tuple",
+                        "Union",
+                    ]
+                }
+            )
 
     def get_default_function_sig(
         self, func: object, ctx: FunctionContext
@@ -617,11 +639,31 @@ class InspectionStubGenerator(BaseStubGenerator):
                 if inferred[0].args and inferred[0].args[0].name == "cls":
                     decorators.append("@classmethod")
 
+        if docstring:
+            docstring = self._indent_docstring(docstring)
         output.extend(
             self.format_func_def(inferred, decorators=decorators, docstring=docstring)
         )
         self._fix_iter(ctx, inferred, output)
 
+    def _indent_docstring(self, docstring: str) -> str:
+        """Fix indentation of docstring extracted from pybind11 or other binding generators."""
+        lines = docstring.splitlines(keepends=True)
+        indent = self._indent + "    "
+        if len(lines) > 1:
+            if not all(line.startswith(indent) or not line.strip() for line in lines):
+                # if the docstring is not indented, then indent all but the first line
+                for i, line in enumerate(lines[1:]):
+                    if line.strip():
+                        lines[i + 1] = indent + line
+        # if there's a trailing newline, add a final line to visually indent the quoted docstring
+        if lines[-1].endswith("\n"):
+            if len(lines) > 1:
+                lines.append(indent)
+            else:
+                lines[-1] = lines[-1][:-1]
+        return "".join(lines)
+
     def _fix_iter(
         self, ctx: FunctionContext, inferred: list[FunctionSig], output: list[str]
     ) -> None:
@@ -671,7 +713,7 @@ class InspectionStubGenerator(BaseStubGenerator):
         if fget:
             alt_docstr = getattr(fget, "__doc__", None)
             if alt_docstr and docstring:
-                docstring += alt_docstr
+                docstring += "\n" + alt_docstr
             elif alt_docstr:
                 docstring = alt_docstr
 

jaclang/vendor/mypy/stubtest.py

@@ -55,6 +55,17 @@ MISSING: typing_extensions.Final = Missing()
 T = TypeVar("T")
 MaybeMissing: typing_extensions.TypeAlias = Union[T, Missing]
 
+
+class Unrepresentable:
+    """Marker object for unrepresentable parameter defaults."""
+
+    def __repr__(self) -> str:
+        return "<unrepresentable>"
+
+
+UNREPRESENTABLE: typing_extensions.Final = Unrepresentable()
+
+
 _formatter: typing_extensions.Final = FancyFormatter(sys.stdout, sys.stderr, False)
 
 
@@ -102,7 +113,19 @@ class Error:
         self.stub_object = stub_object
         self.runtime_object = runtime_object
         self.stub_desc = stub_desc or str(getattr(stub_object, "type", stub_object))
-        self.runtime_desc = runtime_desc or _truncate(repr(runtime_object), 100)
+
+        if runtime_desc is None:
+            runtime_sig = safe_inspect_signature(runtime_object)
+            if runtime_sig is None:
+                self.runtime_desc = _truncate(repr(runtime_object), 100)
+            else:
+                runtime_is_async = inspect.iscoroutinefunction(runtime_object)
+                description = describe_runtime_callable(
+                    runtime_sig, is_async=runtime_is_async
+                )
+                self.runtime_desc = _truncate(description, 100)
+        else:
+            self.runtime_desc = runtime_desc
 
     def is_missing_stub(self) -> bool:
         """Whether or not the error is for something missing from the stub."""
@@ -705,6 +728,7 @@ def _verify_arg_default_value(
                 if (
                     stub_default is not UNKNOWN
                     and stub_default is not ...
+                    and runtime_arg.default is not UNREPRESENTABLE
                     and (
                         stub_default != runtime_arg.default
                         # We want the types to match exactly, e.g. in case the stub has
@@ -1057,7 +1081,9 @@ def verify_funcitem(
     if signature:
         stub_sig = Signature.from_funcitem(stub)
         runtime_sig = Signature.from_inspect_signature(signature)
-        runtime_sig_desc = f'{"async " if runtime_is_coroutine else ""}def {signature}'
+        runtime_sig_desc = describe_runtime_callable(
+            signature, is_async=runtime_is_coroutine
+        )
         stub_desc = str(stub_sig)
     else:
         runtime_sig_desc, stub_desc = None, None
@@ -1564,7 +1590,27 @@ def is_read_only_property(runtime: object) -> bool:
 
 def safe_inspect_signature(runtime: Any) -> inspect.Signature | None:
     try:
-        return inspect.signature(runtime)
+        try:
+            return inspect.signature(runtime)
+        except ValueError:
+            if (
+                hasattr(runtime, "__text_signature__")
+                and "<unrepresentable>" in runtime.__text_signature__
+            ):
+                # Try to fix up the signature. Workaround for
+                # https://github.com/python/cpython/issues/87233
+                sig = runtime.__text_signature__.replace("<unrepresentable>", "...")
+                sig = inspect._signature_fromstr(inspect.Signature, runtime, sig)  # type: ignore[attr-defined]
+                assert isinstance(sig, inspect.Signature)
+                new_params = [
+                    parameter.replace(default=UNREPRESENTABLE)
+                    if parameter.default is ...
+                    else parameter
+                    for parameter in sig.parameters.values()
+                ]
+                return sig.replace(parameters=new_params)
+            else:
+                raise
     except Exception:
         # inspect.signature throws ValueError all the time
         # catch RuntimeError because of https://bugs.python.org/issue39504
@@ -1573,6 +1619,10 @@ def safe_inspect_signature(runtime: Any) -> inspect.Signature | None:
         return None
 
 
+def describe_runtime_callable(signature: inspect.Signature, *, is_async: bool) -> str:
+    return f'{"async " if is_async else ""}def {signature}'
+
+
 def is_subtype_helper(left: mypy.types.Type, right: mypy.types.Type) -> bool:
     """Checks whether ``left`` is a subtype of ``right``."""
     left = mypy.types.get_proper_type(left)

jaclang/vendor/mypy/stubutil.py

@@ -611,6 +611,14 @@ class BaseStubGenerator:
         self.sig_generators = self.get_sig_generators()
         # populated by visit_mypy_file
         self.module_name: str = ""
+        # These are "soft" imports for objects which might appear in annotations but not have
+        # a corresponding import statement.
+        self.known_imports = {
+            "_typeshed": ["Incomplete"],
+            "typing": ["Any", "TypeVar", "NamedTuple"],
+            "collections.abc": ["Generator"],
+            "typing_extensions": ["TypedDict", "ParamSpec", "TypeVarTuple"],
+        }
 
     def get_sig_generators(self) -> list[SignatureGenerator]:
         return []
@@ -702,15 +710,7 @@ class BaseStubGenerator:
         for name in self._all_ or ():
             self.import_tracker.reexport(name)
 
-        # These are "soft" imports for objects which might appear in annotations but not have
-        # a corresponding import statement.
-        known_imports = {
-            "_typeshed": ["Incomplete"],
-            "typing": ["Any", "TypeVar", "NamedTuple"],
-            "collections.abc": ["Generator"],
-            "typing_extensions": ["TypedDict", "ParamSpec", "TypeVarTuple"],
-        }
-        for pkg, imports in known_imports.items():
+        for pkg, imports in self.known_imports.items():
             for t in imports:
                 # require=False means that the import won't be added unless require_name() is called
                 # for the object during generation.

jaclang/vendor/mypy/test/testipc.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 import sys
 import time
-from multiprocessing import Process, Queue
+from multiprocessing import Queue, get_context
 from unittest import TestCase, main
 
 import pytest
@@ -35,10 +35,17 @@ def server_multi_message_echo(q: Queue[str]) -> None:
 
 
 class IPCTests(TestCase):
+    def setUp(self) -> None:
+        if sys.platform == "linux":
+            # The default "fork" start method is potentially unsafe
+            self.ctx = get_context("forkserver")
+        else:
+            self.ctx = get_context("spawn")
+
     def test_transaction_large(self) -> None:
-        queue: Queue[str] = Queue()
+        queue: Queue[str] = self.ctx.Queue()
         msg = "t" * 200000  # longer than the max read size of 100_000
-        p = Process(target=server, args=(msg, queue), daemon=True)
+        p = self.ctx.Process(target=server, args=(msg, queue), daemon=True)
         p.start()
         connection_name = queue.get()
         with IPCClient(connection_name, timeout=1) as client:
@@ -49,9 +56,9 @@ class IPCTests(TestCase):
         p.join()
 
     def test_connect_twice(self) -> None:
-        queue: Queue[str] = Queue()
+        queue: Queue[str] = self.ctx.Queue()
         msg = "this is a test message"
-        p = Process(target=server, args=(msg, queue), daemon=True)
+        p = self.ctx.Process(target=server, args=(msg, queue), daemon=True)
         p.start()
         connection_name = queue.get()
         with IPCClient(connection_name, timeout=1) as client:
@@ -69,8 +76,10 @@ class IPCTests(TestCase):
         assert p.exitcode == 0
 
     def test_multiple_messages(self) -> None:
-        queue: Queue[str] = Queue()
-        p = Process(target=server_multi_message_echo, args=(queue,), daemon=True)
+        queue: Queue[str] = self.ctx.Queue()
+        p = self.ctx.Process(
+            target=server_multi_message_echo, args=(queue,), daemon=True
+        )
         p.start()
         connection_name = queue.get()
         with IPCClient(connection_name, timeout=1) as client:

jaclang/vendor/mypy/test/teststubtest.py

@@ -72,7 +72,6 @@ class Tuple(Sequence[_T_co]): ...
 class NamedTuple(tuple[Any, ...]): ...
 def overload(func: _T) -> _T: ...
 def type_check_only(func: _T) -> _T: ...
-def deprecated(__msg: str) -> Callable[[_T], _T]: ...
 def final(func: _T) -> _T: ...
 """
 
@@ -449,6 +448,16 @@ class StubtestUnit(unittest.TestCase):
             error=None,
         )
 
+        # Simulate "<unrepresentable>"
+        yield Case(
+            stub="def f11() -> None: ...",
+            runtime="""
+            def f11(text=None) -> None: pass
+            f11.__text_signature__ = "(text=<unrepresentable>)"
+            """,
+            error="f11",
+        )
+
     @collect_cases
     def test_static_class_method(self) -> Iterator[Case]:
         yield Case(
@@ -687,7 +696,8 @@ class StubtestUnit(unittest.TestCase):
         )
         yield Case(
             stub="""
-            from typing import deprecated, final
+            from typing import final
+            from typing_extensions import deprecated
             class Foo:
                 @overload
                 @final
@@ -2388,6 +2398,14 @@ class StubtestMiscUnit(unittest.TestCase):
             == "def (a, b, *, c, d = ..., **kwargs)"
         )
 
+    def test_builtin_signature_with_unrepresentable_default(self) -> None:
+        sig = mypy.stubtest.safe_inspect_signature(bytes.hex)
+        assert sig is not None
+        assert (
+            str(mypy.stubtest.Signature.from_inspect_signature(sig))
+            == "def (self, sep = ..., bytes_per_sep = ...)"
+        )
+
     def test_config_file(self) -> None:
         runtime = "temp = 5\n"
         stub = "from decimal import Decimal\ntemp: Decimal\n"

jaclang/vendor/mypy/types.py

@@ -126,7 +126,7 @@ LITERAL_TYPE_NAMES: Final = ("typing.Literal", "typing_extensions.Literal")
 ANNOTATED_TYPE_NAMES: Final = ("typing.Annotated", "typing_extensions.Annotated")
 
 # Supported @deprecated type names
-DEPRECATED_TYPE_NAMES: Final = ("typing.deprecated", "typing_extensions.deprecated")
+DEPRECATED_TYPE_NAMES: Final = ("warnings.deprecated", "typing_extensions.deprecated")
 
 # We use this constant in various places when checking `tuple` subtyping:
 TUPLE_LIKE_INSTANCE_NAMES: Final = (

jaclang/vendor/mypyc/irbuild/prebuildvisitor.py

@@ -122,9 +122,10 @@ class PreBuildVisitor(ExtendedTraverserVisitor):
                 self.funcs_to_decorators[dec.func] = decorators_to_store
         super().visit_decorator(dec)
 
-    def visit_func_def(self, fdef: FuncItem) -> None:
+    def visit_func_def(self, fdef: FuncDef) -> None:
         # TODO: What about overloaded functions?
         self.visit_func(fdef)
+        self.visit_symbol_node(fdef)
 
     def visit_lambda_expr(self, expr: LambdaExpr) -> None:
         self.visit_func(expr)

jaclang/vendor/mypyc/test/test_run.py

@@ -172,12 +172,10 @@ class TestRun(MypycDataSuite):
             # new by distutils, shift the mtime of all of the
             # generated artifacts back by a second.
             fudge_dir_mtimes(WORKDIR, -1)
-            # On Ubuntu, changing the mtime doesn't work reliably. As
+            # On some OS, changing the mtime doesn't work reliably. As
             # a workaround, sleep.
-            #
             # TODO: Figure out a better approach, since this slows down tests.
-            if sys.platform == "linux":
-                time.sleep(1.0)
+            time.sleep(1.0)
 
             step += 1
             with chdir_manager(".."):

{jaclang-0.2.5.dist-info → jaclang-0.3.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: jaclang
-Version: 0.2.5
+Version: 0.3.1
 Home-page: https://github.com/Jaseci-Labs/jaclang
 Author: Jason Mars
 Author-email: jason@jaseci.org