jaclang 0.7.33__py3-none-any.whl → 0.8.0__py3-none-any.whl

jaclang/vendor/mypy-1.10.0.dist-info/WHEEL

@@ -1,6 +0,0 @@
-Wheel-Version: 1.0
-Generator: bdist_wheel (0.43.0)
-Root-Is-Purelib: false
-Tag: cp312-cp312-manylinux_2_17_x86_64
-Tag: cp312-cp312-manylinux2014_x86_64
-

jaclang/vendor/mypy-1.10.0.dist-info/entry_points.txt

@@ -1,6 +0,0 @@
-[console_scripts]
-dmypy = mypy.dmypy.client:console_entry
-mypy = mypy.__main__:console_entry
-mypyc = mypyc.__main__:main
-stubgen = mypy.stubgen:main
-stubtest = mypy.stubtest:main

jaclang/vendor/mypy-1.10.0.dist-info/top_level.txt

@@ -1,3 +0,0 @@
-7f0197f6d050da244d93__mypyc
-mypy
-mypyc

jaclang/vendor/mypy_extensions-1.0.0.dist-info/LICENSE

@@ -1,27 +0,0 @@
-Mypy extensions are licensed under the terms of the MIT license, reproduced below.
-
-= = = = =
-
-The MIT License
-
-Copyright (c) 2016-2017 Jukka Lehtosalo and contributors
-
-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/mypy_extensions-1.0.0.dist-info/METADATA

@@ -1,29 +0,0 @@
-Metadata-Version: 2.1
-Name: mypy-extensions
-Version: 1.0.0
-Summary: Type system extensions for programs checked with the mypy type checker.
-Home-page: https://github.com/python/mypy_extensions
-Author: The mypy developers
-Author-email: jukka.lehtosalo@iki.fi
-License: MIT License
-Classifier: Development Status :: 5 - Production/Stable
-Classifier: Environment :: Console
-Classifier: Intended Audience :: Developers
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.5
-Classifier: Programming Language :: Python :: 3.6
-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: Topic :: Software Development
-Requires-Python: >=3.5
-License-File: LICENSE
-
-Mypy Extensions
-===============
-
-The "mypy_extensions" module defines extensions to the standard "typing" module
-that are supported by the mypy type checker and the mypyc compiler.

jaclang/vendor/mypy_extensions-1.0.0.dist-info/RECORD

@@ -1,6 +0,0 @@
-mypy_extensions.py,sha256=i6mP8-60N5kj1W7ebvPbU4AeGOSph_ekHLkMbfoK2a0,6227
-mypy_extensions-1.0.0.dist-info/LICENSE,sha256=pQRQ2h1TzXd7gM7XfFj_lqvgzNh5cGvRQsPsIOJF8LQ,1204
-mypy_extensions-1.0.0.dist-info/METADATA,sha256=YX1g3_sAgmoi9WYhFNgRHQL6Kf-x7GfjnWgUCE73VIY,1134
-mypy_extensions-1.0.0.dist-info/WHEEL,sha256=2wepM1nk4DS4eFpYrW1TTqPcoGNfHhhO_i5m4cOimbo,92
-mypy_extensions-1.0.0.dist-info/top_level.txt,sha256=TllnGWqDoFMhKyTiX9peoF1VC1wmkRgILHdebnubEb8,16
-mypy_extensions-1.0.0.dist-info/RECORD,,

jaclang/vendor/mypy_extensions-1.0.0.dist-info/top_level.txt

@@ -1 +0,0 @@
-mypy_extensions

jaclang/vendor/mypy_extensions.py

@@ -1,213 +0,0 @@
-"""Defines experimental extensions to the standard "typing" module that are
-supported by the mypy typechecker.
-
-Example usage:
-    from mypy_extensions import TypedDict
-"""
-
-from typing import Any
-
-import sys
-# _type_check is NOT a part of public typing API, it is used here only to mimic
-# the (convenient) behavior of types provided by typing module.
-from typing import _type_check  # type: ignore
-
-
-def _check_fails(cls, other):
-    try:
-        if sys._getframe(1).f_globals['__name__'] not in ['abc', 'functools', 'typing']:
-            # Typed dicts are only for static structural subtyping.
-            raise TypeError('TypedDict does not support instance and class checks')
-    except (AttributeError, ValueError):
-        pass
-    return False
-
-
-def _dict_new(cls, *args, **kwargs):
-    return dict(*args, **kwargs)
-
-
-def _typeddict_new(cls, _typename, _fields=None, **kwargs):
-    total = kwargs.pop('total', True)
-    if _fields is None:
-        _fields = kwargs
-    elif kwargs:
-        raise TypeError("TypedDict takes either a dict or keyword arguments,"
-                        " but not both")
-
-    ns = {'__annotations__': dict(_fields), '__total__': total}
-    try:
-        # Setting correct module is necessary to make typed dict classes pickleable.
-        ns['__module__'] = sys._getframe(1).f_globals.get('__name__', '__main__')
-    except (AttributeError, ValueError):
-        pass
-
-    return _TypedDictMeta(_typename, (), ns)
-
-
-class _TypedDictMeta(type):
-    def __new__(cls, name, bases, ns, total=True):
-        # Create new typed dict class object.
-        # This method is called directly when TypedDict is subclassed,
-        # or via _typeddict_new when TypedDict is instantiated. This way
-        # TypedDict supports all three syntaxes described in its docstring.
-        # Subclasses and instances of TypedDict return actual dictionaries
-        # via _dict_new.
-        ns['__new__'] = _typeddict_new if name == 'TypedDict' else _dict_new
-        tp_dict = super(_TypedDictMeta, cls).__new__(cls, name, (dict,), ns)
-
-        anns = ns.get('__annotations__', {})
-        msg = "TypedDict('Name', {f0: t0, f1: t1, ...}); each t must be a type"
-        anns = {n: _type_check(tp, msg) for n, tp in anns.items()}
-        for base in bases:
-            anns.update(base.__dict__.get('__annotations__', {}))
-        tp_dict.__annotations__ = anns
-        if not hasattr(tp_dict, '__total__'):
-            tp_dict.__total__ = total
-        return tp_dict
-
-    __instancecheck__ = __subclasscheck__ = _check_fails
-
-
-TypedDict = _TypedDictMeta('TypedDict', (dict,), {})
-TypedDict.__module__ = __name__
-TypedDict.__doc__ = \
-    """A simple typed name space. At runtime it is equivalent to a plain dict.
-
-    TypedDict creates a dictionary type that expects all of its
-    instances to have a certain set of keys, with each key
-    associated with a value of a consistent type. This expectation
-    is not checked at runtime but is only enforced by typecheckers.
-    Usage::
-
-        Point2D = TypedDict('Point2D', {'x': int, 'y': int, 'label': str})
-        a: Point2D = {'x': 1, 'y': 2, 'label': 'good'}  # OK
-        b: Point2D = {'z': 3, 'label': 'bad'}           # Fails type check
-        assert Point2D(x=1, y=2, label='first') == dict(x=1, y=2, label='first')
-
-    The type info could be accessed via Point2D.__annotations__. TypedDict
-    supports two additional equivalent forms::
-
-        Point2D = TypedDict('Point2D', x=int, y=int, label=str)
-
-        class Point2D(TypedDict):
-            x: int
-            y: int
-            label: str
-
-    The latter syntax is only supported in Python 3.6+, while two other
-    syntax forms work for 3.2+
-    """
-
-# Argument constructors for making more-detailed Callables. These all just
-# return their type argument, to make them complete noops in terms of the
-# `typing` module.
-
-
-def Arg(type=Any, name=None):
-    """A normal positional argument"""
-    return type
-
-
-def DefaultArg(type=Any, name=None):
-    """A positional argument with a default value"""
-    return type
-
-
-def NamedArg(type=Any, name=None):
-    """A keyword-only argument"""
-    return type
-
-
-def DefaultNamedArg(type=Any, name=None):
-    """A keyword-only argument with a default value"""
-    return type
-
-
-def VarArg(type=Any):
-    """A *args-style variadic positional argument"""
-    return type
-
-
-def KwArg(type=Any):
-    """A **kwargs-style variadic keyword argument"""
-    return type
-
-
-# Return type that indicates a function does not return
-class NoReturn: pass
-
-
-def trait(cls):
-    return cls
-
-
-def mypyc_attr(*attrs, **kwattrs):
-    return lambda x: x
-
-
-# TODO: We may want to try to properly apply this to any type
-# variables left over...
-class _FlexibleAliasClsApplied:
-    def __init__(self, val):
-        self.val = val
-
-    def __getitem__(self, args):
-        return self.val
-
-
-class _FlexibleAliasCls:
-    def __getitem__(self, args):
-        return _FlexibleAliasClsApplied(args[-1])
-
-
-FlexibleAlias = _FlexibleAliasCls()
-
-
-class _NativeIntMeta(type):
-    def __instancecheck__(cls, inst):
-        return isinstance(inst, int)
-
-
-_sentinel = object()
-
-
-class i64(metaclass=_NativeIntMeta):
-    def __new__(cls, x=0, base=_sentinel):
-        if base is not _sentinel:
-            return int(x, base)
-        return int(x)
-
-
-class i32(metaclass=_NativeIntMeta):
-    def __new__(cls, x=0, base=_sentinel):
-        if base is not _sentinel:
-            return int(x, base)
-        return int(x)
-
-
-class i16(metaclass=_NativeIntMeta):
-    def __new__(cls, x=0, base=_sentinel):
-        if base is not _sentinel:
-            return int(x, base)
-        return int(x)
-
-
-class u8(metaclass=_NativeIntMeta):
-    def __new__(cls, x=0, base=_sentinel):
-        if base is not _sentinel:
-            return int(x, base)
-        return int(x)
-
-
-for _int_type in i64, i32, i16, u8:
-    _int_type.__doc__ = \
-        """A native fixed-width integer type when used with mypyc.
-
-        In code not compiled with mypyc, behaves like the 'int' type in these
-        runtime contexts:
-
-        * {name}(x[, base=n]) converts a number or string to 'int'
-        * isinstance(x, {name}) is the same as isinstance(x, int)
-        """.format(name=_int_type.__name__)
-del _int_type

jaclang/vendor/mypyc/README.md

@@ -1,133 +0,0 @@
-mypyc: Mypy to Python C Extension Compiler
-==========================================
-
-**NOTE: We are in the process of moving the mypyc README to the**
-**[mypyc repository](https://github.com/mypyc/mypyc)**
-
-**This may be out of date!**
-
-Mypyc is a compiler that compiles mypy-annotated, statically typed
-Python modules into CPython C extensions. Currently our primary focus
-is on making mypy faster through compilation -- the default mypy wheels
-are compiled with mypyc.  Compiled mypy is about 4x faster than
-without compilation.
-
-Mypyc compiles what is essentially a Python language variant using "strict"
-semantics. This means (among some other things):
-
- * Most type annotations are enforced at runtime (raising ``TypeError`` on mismatch)
-
- * Classes are compiled into extension classes without ``__dict__``
-   (much, but not quite, like if they used ``__slots__``)
-
- * Monkey patching doesn't work
-
- * Instance attributes won't fall back to class attributes if undefined
-
- * Also there are still a bunch of bad bugs and unsupported features :)
-
-Compiled modules can import arbitrary Python modules, and compiled modules
-can be used from other Python modules.  Typically mypyc is used to only
-compile modules that contain performance bottlenecks.
-
-You can run compiled modules also as normal, interpreted Python
-modules, since mypyc targets valid Python code. This means that
-all Python developer tools and debuggers can be used.
-
-macOS Requirements
-------------------
-
-* macOS Sierra or later
-
-* Xcode command line tools
-
-* Python 3.5+ from python.org (other versions are untested)
-
-Linux Requirements
-------------------
-
-* A recent enough C/C++ build environment
-
-* Python 3.5+
-
-Windows Requirements
---------------------
-
-* Windows has been tested with Windows 10 and MSVC 2017.
-
-* Python 3.5+
-
-Quick Start for Contributors
-----------------------------
-
-First clone the mypy git repository:
-
-    $ git clone https://github.com/python/mypy.git
-    $ cd mypy
-
-Optionally create a virtualenv (recommended):
-
-    $ python3 -m venv <directory>
-    $ source <directory>/bin/activate
-
-Then install the dependencies:
-
-    $ python3 -m pip install -r test-requirements.txt
-
-Now you can run the tests:
-
-    $ pytest -q mypyc
-
-Look at the [issue tracker](https://github.com/mypyc/mypyc/issues)
-for things to work on. Please express your interest in working on an
-issue by adding a comment before doing any significant work, since
-there is a risk of duplicate work.
-
-Note that the issue tracker is hosted on the mypyc GitHub project, not
-with mypy itself.
-
-Documentation
--------------
-
-We have some [developer documentation](doc/dev-intro.md).
-
-Development Status and Roadmap
-------------------------------
-
-These are the current planned major milestones:
-
-1. [DONE] Support a smallish but useful Python subset. Focus on compiling
-   single modules, while the rest of the program is interpreted and does not
-   need to be type checked.
-
-2. [DONE] Support compiling multiple modules as a single compilation unit (or
-   dynamic linking of compiled modules).  Without this inter-module
-   calls will use slower Python-level objects, wrapper functions and
-   Python namespaces.
-
-3. [DONE] Mypyc can compile mypy.
-
-4. [DONE] Optimize some important performance bottlenecks.
-
-5. [PARTIALLY DONE] Generate useful errors for code that uses unsupported Python
-   features instead of crashing or generating bad code.
-
-6. [DONE] Release a version of mypy that includes a compiled mypy.
-
-7.
-    1. More feature/compatibility work. (100% compatibility with Python is distinctly
-       an anti-goal, but more than we have now is a good idea.)
-    2. [DONE] Support compiling Black, which is a prominent tool that could benefit
-       and has maintainer buy-in.
-       (Let us know if you maintain another Python tool or library and are
-       interested in working with us on this!)
-    3. More optimization! Code size reductions in particular are likely to
-       be valuable and will speed up mypyc compilation.
-
-8.  We'll see! Adventure is out there!
-
-Future
-------
-
-We have some ideas for
-[future improvements and optimizations](doc/future.md).

jaclang/vendor/mypyc/__main__.py

@@ -1,57 +0,0 @@
-"""Mypyc command-line tool.
-
-Usage:
-
-    $ mypyc foo.py [...]
-    $ python3 -c 'import foo'  # Uses compiled 'foo'
-
-
-This is just a thin wrapper that generates a setup.py file that uses
-mypycify, suitable for prototyping and testing.
-"""
-
-from __future__ import annotations
-
-import os
-import os.path
-import subprocess
-import sys
-
-base_path = os.path.join(os.path.dirname(__file__), "..")
-
-setup_format = """\
-from setuptools import setup
-from mypyc.build import mypycify
-
-setup(name='mypyc_output',
-      ext_modules=mypycify({}, opt_level="{}", debug_level="{}"),
-)
-"""
-
-
-def main() -> None:
-    build_dir = "build"  # can this be overridden??
-    try:
-        os.mkdir(build_dir)
-    except FileExistsError:
-        pass
-
-    opt_level = os.getenv("MYPYC_OPT_LEVEL", "3")
-    debug_level = os.getenv("MYPYC_DEBUG_LEVEL", "1")
-
-    setup_file = os.path.join(build_dir, "setup.py")
-    with open(setup_file, "w") as f:
-        f.write(setup_format.format(sys.argv[1:], opt_level, debug_level))
-
-    # We don't use run_setup (like we do in the test suite) because it throws
-    # away the error code from distutils, and we don't care about the slight
-    # performance loss here.
-    env = os.environ.copy()
-    base_path = os.path.join(os.path.dirname(__file__), "..")
-    env["PYTHONPATH"] = base_path + os.pathsep + env.get("PYTHONPATH", "")
-    cmd = subprocess.run([sys.executable, setup_file, "build_ext", "--inplace"], env=env)
-    sys.exit(cmd.returncode)
-
-
-if __name__ == "__main__":
-    main()