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

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

@@ -0,0 +1,6 @@
+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

@@ -0,0 +1,6 @@
+[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

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

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

@@ -0,0 +1,27 @@
+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

@@ -0,0 +1,29 @@
+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

@@ -0,0 +1,6 @@
+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/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.38.4)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

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

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

jaclang/vendor/mypy_extensions.py

@@ -2,13 +2,12 @@
 supported by the mypy typechecker.
 
 Example usage:
-    from jaclang.vendor.mypy_extensions import TypedDict
+    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
@@ -16,9 +15,9 @@ 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"]:
+        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")
+            raise TypeError('TypedDict does not support instance and class checks')
     except (AttributeError, ValueError):
         pass
     return False
@@ -29,67 +28,51 @@ def _dict_new(cls, *args, **kwargs):
 
 
 def _typeddict_new(cls, _typename, _fields=None, **kwargs):
-    total = kwargs.pop("total", True)
+    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"
-        )
+        raise TypeError("TypedDict takes either a dict or keyword arguments,"
+                        " but not both")
 
-    ns = {"__annotations__": dict(_fields), "__total__": total}
+    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__")
+        ns['__module__'] = sys._getframe(1).f_globals.get('__name__', '__main__')
     except (AttributeError, ValueError):
         pass
 
-    return _TypedDictMeta(_typename, (), ns, _from_functional_call=True)
+    return _TypedDictMeta(_typename, (), ns)
 
 
 class _TypedDictMeta(type):
-    def __new__(cls, name, bases, ns, total=True, _from_functional_call=False):
+    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.
-
-        # We need the `if TypedDict in globals()` check,
-        # or we emit a DeprecationWarning when creating mypy_extensions.TypedDict itself
-        if "TypedDict" in globals():
-            import warnings
-
-            warnings.warn(
-                (
-                    "mypy_extensions.TypedDict is deprecated, "
-                    "and will be removed in a future version. "
-                    "Use typing.TypedDict or typing_extensions.TypedDict instead."
-                ),
-                DeprecationWarning,
-                stacklevel=(3 if _from_functional_call else 2),
-            )
-
-        ns["__new__"] = _typeddict_new if name == "TypedDict" else _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__", {})
+        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__", {}))
+            anns.update(base.__dict__.get('__annotations__', {}))
         tp_dict.__annotations__ = anns
-        if not hasattr(tp_dict, "__total__"):
+        if not hasattr(tp_dict, '__total__'):
             tp_dict.__total__ = total
         return tp_dict
 
     __instancecheck__ = __subclasscheck__ = _check_fails
 
 
-TypedDict = _TypedDictMeta("TypedDict", (dict,), {})
+TypedDict = _TypedDictMeta('TypedDict', (dict,), {})
 TypedDict.__module__ = __name__
-TypedDict.__doc__ = """A simple typed name space. At runtime it is equivalent to a plain dict.
+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
@@ -152,8 +135,7 @@ def KwArg(type=Any):
 
 
 # Return type that indicates a function does not return
-class NoReturn:
-    pass
+class NoReturn: pass
 
 
 def trait(cls):
@@ -219,14 +201,13 @@ class u8(metaclass=_NativeIntMeta):
 
 
 for _int_type in i64, i32, i16, u8:
-    _int_type.__doc__ = """A native fixed-width integer type when used with mypyc.
+    _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__
-    )
+        """.format(name=_int_type.__name__)
 del _int_type

jaclang/vendor/mypyc/README.md

@@ -0,0 +1,133 @@
+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

@@ -49,9 +49,7 @@ def main() -> None:
     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
-    )
+    cmd = subprocess.run([sys.executable, setup_file, "build_ext", "--inplace"], env=env)
     sys.exit(cmd.returncode)
 
 

jaclang/vendor/mypyc/analysis/attrdefined.py

@@ -161,10 +161,7 @@ def analyze_always_defined_attrs_in_class(cl: ClassIR, seen: set[ClassIR]) -> No
     for base in cl.mro:
         all_attrs.update(base.attributes)
     maybe_undefined = analyze_maybe_undefined_attrs_in_init(
-        m.blocks,
-        self_reg,
-        initial_undefined=all_attrs - cl.attrs_with_defaults,
-        cfg=cfg,
+        m.blocks, self_reg, initial_undefined=all_attrs - cl.attrs_with_defaults, cfg=cfg
     )
 
     always_defined = find_always_defined_attributes(
@@ -236,8 +233,7 @@ def find_always_defined_attributes(
                     # Gotos/branches can also be "exits".
                     if not dirty.after[block, i] and dirty.before[target, 0]:
                         attrs = attrs & (
-                            maybe_defined.after[target, 0]
-                            - maybe_undefined.after[target, 0]
+                            maybe_defined.after[target, 0] - maybe_undefined.after[target, 0]
                         )
     return attrs
 
@@ -279,10 +275,7 @@ def mark_attr_initialiation_ops(
         for i, op in enumerate(block.ops):
             if isinstance(op, SetAttr) and op.obj is self_reg:
                 attr = op.attr
-                if (
-                    attr not in maybe_defined.before[block, i]
-                    and not dirty.after[block, i]
-                ):
+                if attr not in maybe_defined.before[block, i] and not dirty.after[block, i]:
                     op.mark_as_initializer()
 
 
@@ -342,10 +335,7 @@ class AttributeMaybeDefinedVisitor(BaseAnalysisVisitor[str]):
 
 
 def analyze_maybe_defined_attrs_in_init(
-    blocks: list[BasicBlock],
-    self_reg: Register,
-    attrs_with_defaults: set[str],
-    cfg: CFG,
+    blocks: list[BasicBlock], self_reg: Register, attrs_with_defaults: set[str], cfg: CFG
 ) -> AnalysisResult[str]:
     return run_analysis(
         blocks=blocks,
@@ -406,9 +396,7 @@ def analyze_maybe_undefined_attrs_in_init(
     )
 
 
-def update_always_defined_attrs_using_subclasses(
-    cl: ClassIR, seen: set[ClassIR]
-) -> None:
+def update_always_defined_attrs_using_subclasses(cl: ClassIR, seen: set[ClassIR]) -> None:
     """Remove attributes not defined in all subclasses from always defined attrs."""
     if cl in seen:
         return
@@ -444,9 +432,5 @@ def detect_undefined_bitmap(cl: ClassIR, seen: set[ClassIR]) -> None:
     for base in cl.mro[1:]:
         if base.is_trait:
             for n, t in base.attributes.items():
-                if (
-                    t.error_overlap
-                    and not cl.is_always_defined(n)
-                    and n not in cl.bitmap_attrs
-                ):
+                if t.error_overlap and not cl.is_always_defined(n) and n not in cl.bitmap_attrs:
                     cl.bitmap_attrs.append(n)

jaclang/vendor/mypyc/analysis/dataflow.py

@@ -38,6 +38,7 @@ from mypyc.ir.ops import (
     MethodCall,
     Op,
     OpVisitor,
+    PrimitiveOp,
     RaiseStandardError,
     RegisterOp,
     Return,
@@ -234,6 +235,9 @@ class BaseAnalysisVisitor(OpVisitor[GenAndKill[T]]):
     def visit_call_c(self, op: CallC) -> GenAndKill[T]:
         return self.visit_register_op(op)
 
+    def visit_primitive_op(self, op: PrimitiveOp) -> GenAndKill[T]:
+        return self.visit_register_op(op)
+
     def visit_truncate(self, op: Truncate) -> GenAndKill[T]:
         return self.visit_register_op(op)
 
@@ -307,9 +311,7 @@ class DefinedVisitor(BaseAnalysisVisitor[Value]):
 
     def visit_assign(self, op: Assign) -> GenAndKill[Value]:
         # Loading an error value may undefine the register.
-        if isinstance(op.src, LoadErrorValue) and (
-            op.src.undefines or self.strict_errors
-        ):
+        if isinstance(op.src, LoadErrorValue) and (op.src.undefines or self.strict_errors):
             return set(), {op.dest}
         else:
             return {op.dest}, set()

jaclang/vendor/mypyc/analysis/ircheck.py

@@ -37,6 +37,7 @@ from mypyc.ir.ops import (
     MethodCall,
     Op,
     OpVisitor,
+    PrimitiveOp,
     RaiseStandardError,
     Register,
     Return,
@@ -77,9 +78,7 @@ class FnError:
 
     def __eq__(self, other: object) -> bool:
         return (
-            isinstance(other, FnError)
-            and self.source == other.source
-            and self.desc == other.desc
+            isinstance(other, FnError) and self.source == other.source and self.desc == other.desc
         )
 
     def __repr__(self) -> str:
@@ -95,16 +94,11 @@ def check_func_ir(fn: FuncIR) -> list[FnError]:
     for block in fn.blocks:
         if not block.terminated:
             errors.append(
-                FnError(
-                    source=block.ops[-1] if block.ops else block,
-                    desc="Block not terminated",
-                )
+                FnError(source=block.ops[-1] if block.ops else block, desc="Block not terminated")
             )
         for op in block.ops[:-1]:
             if isinstance(op, ControlOp):
-                errors.append(
-                    FnError(source=op, desc="Block has operations after control op")
-                )
+                errors.append(FnError(source=op, desc="Block has operations after control op"))
 
             if op in op_set:
                 errors.append(FnError(source=op, desc="Func has a duplicate op"))
@@ -168,8 +162,7 @@ def check_op_sources_valid(fn: FuncIR) -> list[FnError]:
                     if source not in valid_registers:
                         errors.append(
                             FnError(
-                                source=op,
-                                desc=f"Invalid op reference to register {source.name!r}",
+                                source=op, desc=f"Invalid op reference to register {source.name!r}"
                             )
                         )
 
@@ -224,15 +217,12 @@ class OpChecker(OpVisitor[None]):
     def check_control_op_targets(self, op: ControlOp) -> None:
         for target in op.targets():
             if target not in self.parent_fn.blocks:
-                self.fail(
-                    source=op, desc=f"Invalid control operation target: {target.label}"
-                )
+                self.fail(source=op, desc=f"Invalid control operation target: {target.label}")
 
     def check_type_coercion(self, op: Op, src: RType, dest: RType) -> None:
         if not can_coerce_to(src, dest):
             self.fail(
-                source=op,
-                desc=f"Cannot coerce source type {src.name} to dest type {dest.name}",
+                source=op, desc=f"Cannot coerce source type {src.name} to dest type {dest.name}"
             )
 
     def check_compatibility(self, op: Op, t: RType, s: RType) -> None:
@@ -275,20 +265,14 @@ class OpChecker(OpVisitor[None]):
         # has an error value.
         pass
 
-    def check_tuple_items_valid_literals(
-        self, op: LoadLiteral, t: tuple[object, ...]
-    ) -> None:
+    def check_tuple_items_valid_literals(self, op: LoadLiteral, t: tuple[object, ...]) -> None:
         for x in t:
-            if x is not None and not isinstance(
-                x, (str, bytes, bool, int, float, complex, tuple)
-            ):
+            if x is not None and not isinstance(x, (str, bytes, bool, int, float, complex, tuple)):
                 self.fail(op, f"Invalid type for item of tuple literal: {type(x)})")
             if isinstance(x, tuple):
                 self.check_tuple_items_valid_literals(op, x)
 
-    def check_frozenset_items_valid_literals(
-        self, op: LoadLiteral, s: frozenset[object]
-    ) -> None:
+    def check_frozenset_items_valid_literals(self, op: LoadLiteral, s: frozenset[object]) -> None:
         for x in s:
             if x is None or isinstance(x, (str, bytes, bool, int, float, complex)):
                 pass
@@ -398,6 +382,9 @@ class OpChecker(OpVisitor[None]):
     def visit_call_c(self, op: CallC) -> None:
         pass
 
+    def visit_primitive_op(self, op: PrimitiveOp) -> None:
+        pass
+
     def visit_truncate(self, op: Truncate) -> None:
         pass
 

jaclang/vendor/mypyc/analysis/selfleaks.py

@@ -31,6 +31,7 @@ from mypyc.ir.ops import (
     LoadStatic,
     MethodCall,
     OpVisitor,
+    PrimitiveOp,
     RaiseStandardError,
     Register,
     RegisterOp,
@@ -149,6 +150,9 @@ class SelfLeakedVisitor(OpVisitor[GenAndKill]):
     def visit_call_c(self, op: CallC) -> GenAndKill:
         return self.check_register_op(op)
 
+    def visit_primitive_op(self, op: PrimitiveOp) -> GenAndKill:
+        return self.check_register_op(op)
+
     def visit_truncate(self, op: Truncate) -> GenAndKill:
         return CLEAN
 

jaclang/vendor/mypyc/build.py

@@ -101,9 +101,7 @@ def fail(message: str) -> NoReturn:
     sys.exit(message)
 
 
-def emit_messages(
-    options: Options, messages: list[str], dt: float, serious: bool = False
-) -> None:
+def emit_messages(options: Options, messages: list[str], dt: float, serious: bool = False) -> None:
     # ... you know, just in case.
     if options.junit_xml:
         py_version = f"{options.python_version[0]}_{options.python_version[1]}"
@@ -135,9 +133,7 @@ def get_mypy_config(
 
     if compiler_options.separate:
         mypyc_sources = [
-            src
-            for src in mypyc_sources
-            if src.path and not src.path.endswith("__init__.py")
+            src for src in mypyc_sources if src.path and not src.path.endswith("__init__.py")
         ]
 
     if not mypyc_sources:
@@ -290,9 +286,7 @@ def build_using_shared_lib(
 
     for source in sources:
         module_name = source.module.split(".")[-1]
-        shim_file = generate_c_extension_shim(
-            source.module, module_name, build_dir, group_name
-        )
+        shim_file = generate_c_extension_shim(source.module, module_name, build_dir, group_name)
 
         # We include the __init__ in the "module name" we stick in the Extension,
         # since this seems to be needed for it to end up in the right place.
@@ -302,9 +296,7 @@ def build_using_shared_lib(
             full_module_name += ".__init__"
         extensions.append(
             get_extension()(
-                full_module_name,
-                sources=[shim_file],
-                extra_compile_args=extra_compile_args,
+                full_module_name, sources=[shim_file], extra_compile_args=extra_compile_args
             )
         )
 
@@ -459,10 +451,7 @@ def mypyc_build(
             if os.path.splitext(cfile)[1] == ".c":
                 cfilenames.append(cfile)
 
-        deps = [
-            os.path.join(compiler_options.target_dir, dep)
-            for dep in get_header_deps(cfiles)
-        ]
+        deps = [os.path.join(compiler_options.target_dir, dep) for dep in get_header_deps(cfiles)]
         group_cfilenames.append((cfilenames, deps))
 
     return groups, group_cfilenames
@@ -621,9 +610,7 @@ def mypycify(
             )
         else:
             extensions.extend(
-                build_single_module(
-                    group_sources, cfilenames + shared_cfilenames, cflags
-                )
+                build_single_module(group_sources, cfilenames + shared_cfilenames, cflags)
             )
 
     return extensions