python-constricter 0.4.1__cp313-cp313-win32.whl

constricter/fix/libraries/walks.py

@@ -0,0 +1,49 @@
+# SPDX-License-Identifier: MIT
+"""`--fix` for `os.walk(top)`: what a loop over it binds, by `top`'s type.
+
+Its return (`Iterator[tuple[AnyStr, list[AnyStr], list[AnyStr]]]`) nests deeper than the tables hold.
+"""
+
+import ast
+from collections.abc import Callable
+from typing import Final, TypeAlias
+
+from constricter.fix.core.known import Inference, Known
+from constricter.fix.libraries import stdlib
+
+_WALK: Final = "os.walk"
+_STR: Final = "str"
+_BYTES: Final = "bytes"
+_KINDS: Final = frozenset({"loop", "stdlib"})
+_Infer: TypeAlias = Callable[[ast.expr], Inference | None]
+
+
+def walked(iterable: ast.expr, known: Known, infer: _Infer) -> Inference | None:
+    """Infer what a loop over `os.walk(top)` binds: a directory's path, its directories' names and its files'.
+
+    A `str` and two lists of them, where `top` is a `str` or a `pathlib` path; `bytes`, where it's
+    a `bytes`. `infer` types `top`.
+
+    Returns:
+      The tuple's annotation and its reason; `None` for any other value, or a `top` of no such type.
+
+    """
+    func: ast.expr
+    top: ast.expr
+    match iterable:
+        case ast.Call(func=func, args=[top, *_]) if stdlib.resolved(func, known.names.stdlib) == _WALK:
+            found: Inference | None
+            if (found := infer(top)) is None:
+                return None
+            name: str | None = _BYTES if found.annotation == _BYTES else None
+            if found.annotation == _STR or stdlib.is_path(found.annotation, known):
+                name = _STR
+            if name is None:
+                return None
+            return Inference(
+                f"tuple[{name}, list[{name}], list[{name}]]",
+                "`os.walk`, which yields a directory's path and its entries' names",
+                found.kinds | _KINDS,
+            )
+        case _:
+            return None

constricter/fix/tables/aliases.json

@@ -0,0 +1,147 @@
+{
+"asyncio.base_events.BaseEventLoop": "asyncio.BaseEventLoop",
+"asyncio.base_events.Server": "asyncio.Server",
+"asyncio.events.AbstractEventLoop": "asyncio.AbstractEventLoop",
+"asyncio.events.AbstractServer": "asyncio.AbstractServer",
+"asyncio.events.Handle": "asyncio.Handle",
+"asyncio.events.TimerHandle": "asyncio.TimerHandle",
+"asyncio.exceptions.BrokenBarrierError": "asyncio.BrokenBarrierError",
+"asyncio.exceptions.CancelledError": "asyncio.CancelledError",
+"asyncio.exceptions.IncompleteReadError": "asyncio.IncompleteReadError",
+"asyncio.exceptions.InvalidStateError": "asyncio.InvalidStateError",
+"asyncio.exceptions.LimitOverrunError": "asyncio.LimitOverrunError",
+"asyncio.exceptions.SendfileNotAvailableError": "asyncio.SendfileNotAvailableError",
+"asyncio.exceptions.TimeoutError": "asyncio.TimeoutError",
+"asyncio.graph.FrameCallGraphEntry": "asyncio.FrameCallGraphEntry",
+"asyncio.graph.FutureCallGraph": "asyncio.FutureCallGraph",
+"asyncio.locks.Barrier": "asyncio.Barrier",
+"asyncio.locks.BoundedSemaphore": "asyncio.BoundedSemaphore",
+"asyncio.locks.Condition": "asyncio.Condition",
+"asyncio.locks.Event": "asyncio.Event",
+"asyncio.locks.Lock": "asyncio.Lock",
+"asyncio.locks.Semaphore": "asyncio.Semaphore",
+"asyncio.protocols.BaseProtocol": "asyncio.BaseProtocol",
+"asyncio.protocols.BufferedProtocol": "asyncio.BufferedProtocol",
+"asyncio.protocols.DatagramProtocol": "asyncio.DatagramProtocol",
+"asyncio.protocols.Protocol": "asyncio.Protocol",
+"asyncio.protocols.SubprocessProtocol": "asyncio.SubprocessProtocol",
+"asyncio.queues.QueueEmpty": "asyncio.QueueEmpty",
+"asyncio.queues.QueueFull": "asyncio.QueueFull",
+"asyncio.queues.QueueShutDown": "asyncio.QueueShutDown",
+"asyncio.runners.Runner": "asyncio.Runner",
+"asyncio.streams.StreamReader": "asyncio.StreamReader",
+"asyncio.streams.StreamReaderProtocol": "asyncio.StreamReaderProtocol",
+"asyncio.streams.StreamWriter": "asyncio.StreamWriter",
+"asyncio.taskgroups.TaskGroup": "asyncio.TaskGroup",
+"asyncio.timeouts.Timeout": "asyncio.Timeout",
+"asyncio.transports.BaseTransport": "asyncio.BaseTransport",
+"asyncio.transports.DatagramTransport": "asyncio.DatagramTransport",
+"asyncio.transports.ReadTransport": "asyncio.ReadTransport",
+"asyncio.transports.SubprocessTransport": "asyncio.SubprocessTransport",
+"asyncio.transports.Transport": "asyncio.Transport",
+"asyncio.transports.WriteTransport": "asyncio.WriteTransport",
+"asyncio.unix_events.AbstractChildWatcher": "asyncio.AbstractChildWatcher",
+"asyncio.unix_events.FastChildWatcher": "asyncio.FastChildWatcher",
+"asyncio.unix_events.MultiLoopChildWatcher": "asyncio.MultiLoopChildWatcher",
+"asyncio.unix_events.PidfdChildWatcher": "asyncio.PidfdChildWatcher",
+"asyncio.unix_events.SafeChildWatcher": "asyncio.SafeChildWatcher",
+"asyncio.unix_events.ThreadedChildWatcher": "asyncio.ThreadedChildWatcher",
+"asyncio.windows_events.IocpProactor": "asyncio.IocpProactor",
+"asyncio.windows_events.ProactorEventLoop": "asyncio.ProactorEventLoop",
+"asyncio.windows_events.WindowsProactorEventLoopPolicy": "asyncio.WindowsProactorEventLoopPolicy",
+"asyncio.windows_events.WindowsSelectorEventLoopPolicy": "asyncio.WindowsSelectorEventLoopPolicy",
+"compression.bz2.BZ2Compressor": "bz2.BZ2Compressor",
+"compression.bz2.BZ2Decompressor": "bz2.BZ2Decompressor",
+"compression.bz2.BZ2File": "bz2.BZ2File",
+"compression.gzip.BadGzipFile": "gzip.BadGzipFile",
+"compression.gzip.GzipFile": "gzip.GzipFile",
+"compression.lzma.LZMACompressor": "lzma.LZMACompressor",
+"compression.lzma.LZMADecompressor": "lzma.LZMADecompressor",
+"compression.lzma.LZMAError": "lzma.LZMAError",
+"compression.lzma.LZMAFile": "lzma.LZMAFile",
+"compression.zlib.error": "zlib.error",
+"concurrent.futures.TimeoutError": "asyncio.TimeoutError",
+"concurrent.futures.interpreter.InterpreterPoolExecutor": "concurrent.futures.InterpreterPoolExecutor",
+"concurrent.futures.process.ProcessPoolExecutor": "concurrent.futures.ProcessPoolExecutor",
+"concurrent.futures.thread.ThreadPoolExecutor": "concurrent.futures.ThreadPoolExecutor",
+"distutils.command.build_py.Mixin2to3": "distutils.util.Mixin2to3",
+"distutils.command.build_scripts.Mixin2to3": "distutils.util.Mixin2to3",
+"distutils.core.Command": "distutils.cmd.Command",
+"distutils.core.Distribution": "distutils.dist.Distribution",
+"distutils.core.Extension": "distutils.extension.Extension",
+"importlib.resources.ResourceReader": "importlib.abc.ResourceReader",
+"importlib.resources.abc.Traversable": "importlib.abc.Traversable",
+"importlib.resources.abc.TraversableResources": "importlib.abc.TraversableResources",
+"importlib.resources.readers.FileReader": "importlib.readers.FileReader",
+"importlib.resources.readers.MultiplexedPath": "importlib.readers.MultiplexedPath",
+"importlib.resources.readers.NamespaceReader": "importlib.readers.NamespaceReader",
+"importlib.resources.readers.ZipReader": "importlib.readers.ZipReader",
+"importlib.resources.simple.ResourceContainer": "importlib.simple.ResourceContainer",
+"importlib.resources.simple.ResourceHandle": "importlib.simple.ResourceHandle",
+"importlib.resources.simple.SimpleReader": "importlib.simple.SimpleReader",
+"importlib.resources.simple.TraversableReader": "importlib.simple.TraversableReader",
+"json.decoder.JSONDecodeError": "json.JSONDecodeError",
+"json.decoder.JSONDecoder": "json.JSONDecoder",
+"json.encoder.JSONEncoder": "json.JSONEncoder",
+"multiprocessing.context.AuthenticationError": "multiprocessing.AuthenticationError",
+"multiprocessing.context.BufferTooShort": "multiprocessing.BufferTooShort",
+"multiprocessing.context.Process": "multiprocessing.Process",
+"multiprocessing.context.ProcessError": "multiprocessing.ProcessError",
+"multiprocessing.context.TimeoutError": "multiprocessing.TimeoutError",
+"multiprocessing.dummy.Barrier": "threading.Barrier",
+"multiprocessing.dummy.BoundedSemaphore": "threading.BoundedSemaphore",
+"multiprocessing.dummy.Condition": "threading.Condition",
+"multiprocessing.dummy.Event": "threading.Event",
+"multiprocessing.dummy.Semaphore": "threading.Semaphore",
+"nt.stat_result": "os.stat_result",
+"nt.statvfs_result": "os.statvfs_result",
+"nt.terminal_size": "os.terminal_size",
+"nt.times_result": "os.times_result",
+"nt.uname_result": "os.uname_result",
+"posix.sched_param": "os.sched_param",
+"posix.stat_result": "os.stat_result",
+"posix.statvfs_result": "os.statvfs_result",
+"posix.terminal_size": "os.terminal_size",
+"posix.times_result": "os.times_result",
+"posix.uname_result": "os.uname_result",
+"posix.waitid_result": "os.waitid_result",
+"secrets.SystemRandom": "random.SystemRandom",
+"sqlite3.dbapi2.Blob": "sqlite3.Blob",
+"sqlite3.dbapi2.Connection": "sqlite3.Connection",
+"sqlite3.dbapi2.Cursor": "sqlite3.Cursor",
+"sqlite3.dbapi2.DataError": "sqlite3.DataError",
+"sqlite3.dbapi2.DatabaseError": "sqlite3.DatabaseError",
+"sqlite3.dbapi2.Error": "sqlite3.Error",
+"sqlite3.dbapi2.IntegrityError": "sqlite3.IntegrityError",
+"sqlite3.dbapi2.InterfaceError": "sqlite3.InterfaceError",
+"sqlite3.dbapi2.InternalError": "sqlite3.InternalError",
+"sqlite3.dbapi2.NotSupportedError": "sqlite3.NotSupportedError",
+"sqlite3.dbapi2.OperationalError": "sqlite3.OperationalError",
+"sqlite3.dbapi2.PrepareProtocol": "sqlite3.PrepareProtocol",
+"sqlite3.dbapi2.ProgrammingError": "sqlite3.ProgrammingError",
+"sqlite3.dbapi2.Row": "sqlite3.Row",
+"sqlite3.dbapi2.Warning": "sqlite3.Warning",
+"sre_compile.error": "re.error",
+"sre_constants.error": "re.error",
+"sre_parse.error": "re.error",
+"unittest.async_case.IsolatedAsyncioTestCase": "unittest.IsolatedAsyncioTestCase",
+"unittest.case.FunctionTestCase": "unittest.FunctionTestCase",
+"unittest.case.SkipTest": "unittest.SkipTest",
+"unittest.case.TestCase": "unittest.TestCase",
+"unittest.loader.TestLoader": "unittest.TestLoader",
+"unittest.main.TestProgram": "unittest.TestProgram",
+"unittest.result.TestResult": "unittest.TestResult",
+"unittest.runner.TextTestRunner": "unittest.TextTestRunner",
+"unittest.suite.BaseTestSuite": "unittest.BaseTestSuite",
+"unittest.suite.TestSuite": "unittest.TestSuite",
+"urllib.request.HTTPError": "urllib.error.HTTPError",
+"xml.etree.cElementTree.C14NWriterTarget": "xml.etree.ElementTree.C14NWriterTarget",
+"xml.etree.cElementTree.ParseError": "xml.etree.ElementTree.ParseError",
+"xml.etree.cElementTree.QName": "xml.etree.ElementTree.QName",
+"xml.etree.cElementTree.TreeBuilder": "xml.etree.ElementTree.TreeBuilder",
+"xml.parsers.expat.ExpatError": "pyexpat.ExpatError",
+"xml.parsers.expat.XMLParserType": "pyexpat.XMLParserType",
+"xml.sax.handler.ContentHandler": "xml.sax.ContentHandler",
+"xml.sax.handler.ErrorHandler": "xml.sax.ErrorHandler",
+"xml.sax.xmlreader.InputSource": "xml.sax.InputSource"
+}