performance tuning

Author: skogsbaer

python/code/typeguard/_checkers.py

@@ -914,6 +914,10 @@ def check_type_internal(
     :param memo: a memo object containing configuration and information necessary for
         looking up forward references
     """
+    ty = type(value)
+    if ty == annotation or (value is None and ty is type(None)):
+        # some early exits for better performance
+        return
     annotation = resolve_alias_chains(annotation)
 
     if isinstance(annotation, ForwardRef):

python/code/wypp/location.py

@@ -217,6 +217,7 @@ def __init__(self, f: Callable, kind: CallableKind):
         self.__lineno = f.__code__.co_firstlineno
         self.__name = f.__name__
         self.__ast = parsecache.getAST(self.file)
+        self.__async = None
 
     def __repr__(self):
         return f'StdCallableInfo({self.name}, {self.kind})'
@@ -282,8 +283,10 @@ def getParamSourceLocation(self, paramName: str) -> Optional[Loc]:
 
     @property
     def isAsync(self) -> bool:
-        node = self._findDef()
-        return isinstance(node, ast.AsyncFunctionDef)
+        if self.__async is None:
+            node = self._findDef()
+            self.__async = isinstance(node, ast.AsyncFunctionDef)
+        return self.__async
 
 def classFilename(cls) -> str | None:
     """Best-effort path to the file that defined `cls`."""

python/code/wypp/typecheck.py

@@ -24,14 +24,14 @@ def isEmptySignature(sig: inspect.Signature) -> bool:
              return False
     return isEmptyAnnotation(sig.return_annotation)
 
-def handleMatchesTyResult(res: MatchesTyResult, tyLoc: Optional[location.Loc]) -> bool:
+def handleMatchesTyResult(res: MatchesTyResult, getTyLoc: Callable[[], Optional[location.Loc]]) -> bool:
     match res:
         case MatchesTyFailure(exc, ty):
             if isDebug():
                 debug(f'Exception occurred while calling matchesTy with type {ty}, re-raising')
                 raise exc
             else:
-                raise errors.WyppTypeError.invalidType(ty, tyLoc)
+                raise errors.WyppTypeError.invalidType(ty, getTyLoc())
         case b:
             return b
 
@@ -63,11 +63,17 @@ def checkSignature(sig: inspect.Signature, info: location.CallableInfo, cfg: Che
                 locDecl = info.getParamSourceLocation(name)
                 raise errors.WyppTypeError.partialAnnotationError(location.CallableName.mk(info), name, locDecl)
         if p.default is not inspect.Parameter.empty:
-            locDecl = info.getParamSourceLocation(name)
+            locDecl = lambda: info.getParamSourceLocation(name)
             if not handleMatchesTyResult(matchesTy(p.default, ty, cfg.ns), locDecl):
-                raise errors.WyppTypeError.defaultError(location.CallableName.mk(info), name, locDecl, ty, p.default)
+                raise errors.WyppTypeError.defaultError(location.CallableName.mk(info), name,
+                                                        locDecl(), ty, p.default)
+
+_argCountCache = {}
 
 def mandatoryArgCount(sig: inspect.Signature) -> int:
+    x = _argCountCache.get(sig)
+    if x is not None:
+        return x
     required_kinds = {
         inspect.Parameter.POSITIONAL_ONLY,
         inspect.Parameter.POSITIONAL_OR_KEYWORD,
@@ -77,10 +83,12 @@ def mandatoryArgCount(sig: inspect.Signature) -> int:
     for p in sig.parameters.values():
         if p.kind in required_kinds and p.default is inspect._empty:
             res = res + 1
+    _argCountCache[sig] = res
     return res
 
 def checkArgument(p: inspect.Parameter, name: str, idx: Optional[int], a: Any,
-                  locArg: Optional[location.Loc], info: location.CallableInfo, cfg: CheckCfg):
+                  getLocArg: Callable[[], Optional[location.Loc]],
+                  info: location.CallableInfo, cfg: CheckCfg):
     t = p.annotation
     if not isEmptyAnnotation(t):
         if p.kind == inspect.Parameter.VAR_POSITIONAL:
@@ -110,29 +118,38 @@ def checkArgument(p: inspect.Parameter, name: str, idx: Optional[int], a: Any,
             else:
                 raise ValueError(f'Invalid type for keyword argument: {t}')
             t = valT
-        locDecl = info.getParamSourceLocation(name)
+        locDecl = lambda: info.getParamSourceLocation(name)
         if not handleMatchesTyResult(matchesTy(a, t, cfg.ns), locDecl):
             cn = location.CallableName.mk(info)
             raise errors.WyppTypeError.argumentError(cn,
                                                      name,
                                                      idx,
-                                                     locDecl,
+                                                     locDecl(),
                                                      t,
                                                      a,
-                                                     locArg)
+                                                     getLocArg())
+
 def checkArguments(sig: inspect.Signature, args: tuple, kwargs: dict,
                    info: location.CallableInfo, cfg: CheckCfg) -> None:
-    debug(f'Checking arguments when calling {info}')
+    if isDebug():
+        debug(f'Checking arguments when calling {info}')
     paramNames = list(sig.parameters)
     mandatory = mandatoryArgCount(sig)
     kind = getKind(cfg, paramNames)
     offset = 1 if kind == 'method' else 0
-    fi = stacktrace.callerOutsideWypp()
-    callLoc = None if not fi else location.Loc.fromFrameInfo(fi)
     cn = location.CallableName.mk(info)
+    # stacktrace.callerOutsideWypp() is expensive, only access it lazily
+    def getCallLoc() -> Optional[location.Loc]:
+        fi = stacktrace.callerOutsideWypp()
+        return None if not fi else location.Loc.fromFrameInfo(fi)
+    def getLocArg(idxOrName: int | str) -> Callable[[], Optional[location.Loc]]:
+        def f():
+            fi = stacktrace.callerOutsideWypp()
+            return None if fi is None else location.locationOfArgument(fi, i)
+        return f
     def raiseArgMismatch():
         raise errors.WyppTypeError.argCountMismatch(cn,
-                                                    callLoc,
+                                                    getCallLoc(),
                                                     len(paramNames) - offset,
                                                     mandatory - offset,
                                                     len(args) - offset)
@@ -152,46 +169,46 @@ def raiseArgMismatch():
         raiseArgMismatch()
     # Check positional args
     for i in range(len(args)):
-        locArg = None if fi is None else location.locationOfArgument(fi, i)
         if i < len(positionalNames):
             name = positionalNames[i]
             p = sig.parameters[name]
-            checkArgument(p, name, i - offset, args[i], locArg, info, cfg)
+            checkArgument(p, name, i - offset, args[i], getLocArg(i), info, cfg)
         elif varPositionalParam is not None:
-            checkArgument(varPositionalParam, varPositionalParam.name, i - offset, args[i], locArg, info, cfg)
+            checkArgument(varPositionalParam, varPositionalParam.name, i - offset, args[i], getLocArg(i), info, cfg)
         else:
             raiseArgMismatch()
     # Check keyword args
     for name in kwargs:
-        locArg = None if fi is None else location.locationOfArgument(fi, name)
         if name in sig.parameters and sig.parameters[name].kind not in (
             inspect.Parameter.VAR_POSITIONAL, inspect.Parameter.VAR_KEYWORD
         ):
-            checkArgument(sig.parameters[name], name, None, kwargs[name], locArg, info, cfg)
+            checkArgument(sig.parameters[name], name, None, kwargs[name], getLocArg(name), info, cfg)
         elif varKeywordParam is not None:
-            checkArgument(varKeywordParam, name, None, kwargs[name], locArg, info, cfg)
+            checkArgument(varKeywordParam, name, None, kwargs[name], getLocArg(name), info, cfg)
         else:
-            raise errors.WyppTypeError.unknownKeywordArgument(cn, callLoc, name)
+            raise errors.WyppTypeError.unknownKeywordArgument(cn, getCallLoc(), name)
 
-def checkReturn(sig: inspect.Signature, returnFrame: Optional[inspect.FrameInfo],
+def checkReturn(sig: inspect.Signature, getReturnFrame: Callable[[], Optional[inspect.FrameInfo]],
                 result: Any, info: location.CallableInfo, cfg: CheckCfg) -> None:
     if info.isAsync:
         return
     t = sig.return_annotation
     if isEmptyAnnotation(t):
         t = None
-    debug(f'Checking return value when calling {info}, return type: {t}')
-    locDecl = info.getResultTypeLocation()
+    if isDebug():
+        debug(f'Checking return value when calling {info}, return type: {t}')
+    locDecl = lambda: info.getResultTypeLocation()
     if not handleMatchesTyResult(matchesTy(result, t, cfg.ns), locDecl):
         fi = stacktrace.callerOutsideWypp()
         if fi is not None:
             locRes = location.Loc.fromFrameInfo(fi)
         returnLoc = None
         extraFrames = []
+        returnFrame = getReturnFrame()
         if returnFrame:
             returnLoc = location.Loc.fromFrameInfo(returnFrame)
             extraFrames = [returnFrame]
-        raise errors.WyppTypeError.resultError(location.CallableName.mk(info), locDecl, t, returnLoc, result,
+        raise errors.WyppTypeError.resultError(location.CallableName.mk(info), locDecl(), t, returnLoc, result,
                                                locRes, extraFrames)
 
 
@@ -232,9 +249,9 @@ def wrapped(*args, **kwargs) -> T:
             utils._call_with_frames_removed(checkArguments, sig, args, kwargs, info, checkCfg)
             returnTracker = stacktrace.getReturnTracker()
             result = utils._call_with_next_frame_removed(f, *args, **kwargs)
-            retFrame = returnTracker.getReturnFrame(0)
+            getRetFrame = lambda: returnTracker.getReturnFrame(0)
             utils._call_with_frames_removed(
-                checkReturn, sig, retFrame, result, info, checkCfg
+                checkReturn, sig, getRetFrame, result, info, checkCfg
             )
             return result
         return wrapped