def handlePackageScope(package, fqn): #print "handlePackageScope",package,fqn child = package.getChild(fqn) if child: return child if isinstance(package,Root): return getModuleOrPackageUsingFQN(fqn) # try searching the fs node = getModuleOrPackageUsingFQN(fqn,package.path) if node: return node # try the package init module initmod = package.getChild("__init__") if initmod is not None: type = getImportedType(initmod, fqn) if type: return type # maybe fqn is absolute return getTypeOf(getRoot(), fqn)
def resolveImportedModuleOrPackage(scope, fqn): # try searching from directory containing scope module path = os.path.dirname(scope.module.filename) node = getModuleOrPackageUsingFQN(fqn, path) if node is not None: return node # try searching from the root node = getModuleOrPackageUsingFQN(fqn) if node is not None: return node
def resolveImportedModuleOrPackage(scope,fqn): # try searching from directory containing scope module path = os.path.dirname(scope.module.filename) node = getModuleOrPackageUsingFQN(fqn,path) if node is not None: return node # try searching from the root node = getModuleOrPackageUsingFQN(fqn) if node is not None: return node
def getTypeOf(scope, fqn): if isinstance(scope, Root): return getModuleOrPackageUsingFQN(fqn) assert False, "Can't use getTypeOf to resolve from Root. Use getModuleOrPackageUsingFQN instead" #print_ "getTypeOf:"+fqn+" -- "+str(scope) #print_ #print_ str(getTypeOfStack) #print_ if (fqn, scope) in getTypeOfStack: # loop protection return None # this is crap! hashcode = str(scope) + fqn try: getTypeOfStack.append((fqn, scope)) try: type = Cache.instance.typecache[hashcode] except KeyError: type = getTypeOf_impl(scope, fqn) Cache.instance.typecache[hashcode] = type return type finally: del getTypeOfStack[-1]
def getTypeOf(scope, fqn): if isinstance(scope, Root): return getModuleOrPackageUsingFQN(fqn) assert False, "Can't use getTypeOf to resolve from Root. Use getModuleOrPackageUsingFQN instead" #print_ "getTypeOf:"+fqn+" -- "+str(scope) #print_ #print_ str(getTypeOfStack) #print_ if (fqn,scope) in getTypeOfStack: # loop protection return None # this is crap! hashcode = str(scope)+fqn try: getTypeOfStack.append((fqn,scope)) try: type = Cache.instance.typecache[hashcode] except KeyError: type = getTypeOf_impl(scope, fqn) Cache.instance.typecache[hashcode] = type return type finally: del getTypeOfStack[-1]
def test_worksForPackage(self): try: createPackageStructure("pass","pass") self.assertEqual(getModuleOrPackageUsingFQN("a.b").path, pkgstructureChilddir) finally: removePackageStructure()
def test_worksForFullPath(self): try: createPackageStructure("pass","pass") self.assertEqual(getModuleOrPackageUsingFQN("a.b.bah").filename, pkgstructureFile2) finally: removePackageStructure()
def test_worksForPackage(self): try: createPackageStructure("pass", "pass") self.assertEqual( getModuleOrPackageUsingFQN("a.b").path, pkgstructureChilddir) finally: removePackageStructure()
def test_worksForFullPath(self): try: createPackageStructure("pass", "pass") self.assertEqual( getModuleOrPackageUsingFQN("a.b.bah").filename, pkgstructureFile2) finally: removePackageStructure()
def test_handlesRecursionProblem(self): src = trimLines(""" def fn(root): node = root node = node.getPackage('something') """) root = createSourceNodeAt(src,"a.foo") m = getModuleOrPackageUsingFQN("a.foo") fn = getTypeOf(m,"fn") getTypeOf(fn,"node") # stack overflow!
def test_doesntGotIntoRecursiveLoopWhenEvaluatingARecursiveFunction(self): src = trimLines(""" def fn(v): if v < 45: return fn(root+1) val = fn(3) """) root = createSourceNodeAt(src,"a.foo") mod = getModuleOrPackageUsingFQN("a.foo") getTypeOf(mod,"val") # stack overflow!
def test_getsTypeOfClassReferencedViaAlias(self): src = trimLines(""" from b.bah import TheClass as FooBah FooBah() """) root = createSourceNodeAt(src,"a.foo") root = createSourceNodeAt(testdata.TheClass, "a.b.bah") themodule = getModuleOrPackageUsingFQN("a.foo") self.assertEqual(getTypeOf(themodule,"FooBah").name,"TheClass") self.assertEqual(getTypeOf(themodule,"FooBah").filename, os.path.abspath(os.path.join("a","b","bah.py")))
def resolveImportedModuleOrPackage(scope,fqn): # try searching from directory containing scope module path = os.path.dirname(scope.module.filename) node = getModuleOrPackageUsingFQN(fqn,path) if node is not None: return node # try searching in same package hierarchy basedir = getPackageBaseDirectory(scope.module.filename) if fqn.split('.')[0] == os.path.split(basedir)[-1]: # base package in fqn matches base directory restOfFqn = ".".join(fqn.split('.')[1:]) node = getModuleOrPackageUsingFQN(restOfFqn,basedir) if node is not None: return node # try searching the python path node = getModuleOrPackageUsingFQN(fqn) if node is not None: return node
def resolveImportedModuleOrPackage(scope, fqn): # try searching from directory containing scope module path = os.path.dirname(scope.module.filename) node = getModuleOrPackageUsingFQN(fqn, path) if node is not None: return node # try searching in same package hierarchy basedir = getPackageBaseDirectory(scope.module.filename) if fqn.split('.')[0] == os.path.split(basedir)[-1]: # base package in fqn matches base directory restOfFqn = ".".join(fqn.split('.')[1:]) node = getModuleOrPackageUsingFQN(restOfFqn, basedir) if node is not None: return node # try searching the python path node = getModuleOrPackageUsingFQN(fqn) if node is not None: return node
def test_getsTypeOfClassReferenceFromImportedPackage(self): src = trimLines(""" import b a = b.bah.TheClass() """) root = createSourceNodeAt(src,"a.foo") root = createSourceNodeAt(testdata.TheClass, "a.b.bah") module = getModuleOrPackageUsingFQN("a.foo") res = getTypeOf(module,"a") assert isinstance(res,Instance) assert isinstance(res.getType(),Class) assert res.getType().name == "TheClass"
def handlePackageScope(package, fqn): #print "handlePackageScope",package,fqn child = package.getChild(fqn) if child: return child if isinstance(package, Root): return getModuleOrPackageUsingFQN(fqn) # try searching the fs node = getModuleOrPackageUsingFQN(fqn, package.path) if node: return node # try the package init module initmod = package.getChild("__init__") if initmod is not None: type = getImportedType(initmod, fqn) if type: return type # maybe fqn is absolute return getTypeOf(getRoot(), fqn)
def test_getsTypeOfSimpleClassInstanceReference(self): src = trimLines(""" from b.bah import TheClass a = TheClass() a.theMethod() """) root = createSourceNodeAt(src,"a.foo") root = createSourceNodeAt(testdata.TheClass, "a.b.bah") module = getModuleOrPackageUsingFQN("a.foo") res = getTypeOf(module,"a") assert isinstance(res,Instance) assert isinstance(res.getType(),Class) assert res.getType().name == "TheClass"
def test_doesntGetTypeDefinedInChildFunction(self): src = trimLines(""" from b.bah import TheClass a = AnotherClass() def foo(): a = TheClass() a.theMethod() """) root = createSourceNodeAt(src,"a.foo") root = createSourceNodeAt(testdata.TheClass, "a.b.bah") themodule = getModuleOrPackageUsingFQN("a.foo") assert isinstance(getTypeOf(themodule,"a"),UnfoundType)
def test_getsTypeOfClassImportedFromPackageScope(self): initfile = trimLines(""" from bah import TheClass """) src = trimLines(""" from a import b b.TheClass() """) createSourceNodeAt(src,"a.foo") createSourceNodeAt(testdata.TheClass, "a.b.bah") createSourceNodeAt(initfile,"a.b.__init__") themodule = getModuleOrPackageUsingFQN("a.foo") self.assertEqual(getTypeOf(themodule,"b.TheClass").name,"TheClass") self.assertEqual(getTypeOf(themodule,"b.TheClass").filename, os.path.abspath(os.path.join("a","b","bah.py")))
def test_findsClassRefUsingFromImportStatement(self): src=trimLines(""" from a.b.bah import TheClass """) classsrc=trimLines(""" class TheClass: pass """) root = createSourceNodeAt(src,"a.foo") root = createSourceNodeAt(classsrc, "a.b.bah") module = getModuleOrPackageUsingFQN("a.foo") filename = os.path.abspath(os.path.join("a","foo.py")) defn = [x for x in findAllPossibleDefinitionsByCoords(filename,1,21)] assert defn[0].filename == os.path.abspath(os.path.join("a","b","bah.py")) assert defn[0].lineno == 1 assert defn[0].colno == 6 assert defn[0].confidence == 100
def test_getsTypeOfInstanceThatIsAnAttributeOfSelf(self): src = trimLines(""" class TheClass: def theMethod(self): pass class AnotherClass: def __init__(self): self.a = TheClass() def anotherFn(self): self.a.theMethod() """) root = createSourceNodeAt(src,"a.foo") module = getModuleOrPackageUsingFQN('a.foo') theclass = getTypeOf(module,"TheClass") fn = getTypeOf(module,"AnotherClass.anotherFn") self.assertEqual(getTypeOf(fn,"self.a").getType().name, "TheClass")
def test_findsClassRefUsingFromImportStatement(self): src = trimLines(""" from a.b.bah import TheClass """) classsrc = trimLines(""" class TheClass: pass """) root = createSourceNodeAt(src, "a.foo") root = createSourceNodeAt(classsrc, "a.b.bah") module = getModuleOrPackageUsingFQN("a.foo") filename = os.path.abspath(os.path.join("a", "foo.py")) defn = [x for x in findAllPossibleDefinitionsByCoords(filename, 1, 21)] assert defn[0].filename == os.path.abspath( os.path.join("a", "b", "bah.py")) assert defn[0].lineno == 1 assert defn[0].colno == 6 assert defn[0].confidence == 100
def visitFrom(self, node): if node.names[0][0] == '*': # e.g. from foo import * if not "."in self.targetfqn: module = resolveImportedModuleOrPackage(self.scope, node.modname) if module: self.match = getTypeOf(module, self.targetfqn) else: for name, alias in node.names: if alias == self.targetfqn or \ (alias is None and name == self.targetfqn): scope = resolveImportedModuleOrPackage(self.scope, node.modname) if scope is not None: if isinstance(scope,Package): self.match = getModuleOrPackageUsingFQN(name,scope.path) else: assert isinstance(scope,Module) self.match = getTypeOf(scope, name)
def visitFrom(self, node): if node.names[0][0] == '*': # e.g. from foo import * if not "." in self.targetfqn: module = resolveImportedModuleOrPackage( self.scope, node.modname) if module: self.match = getTypeOf(module, self.targetfqn) else: for name, alias in node.names: if alias == self.targetfqn or \ (alias is None and name == self.targetfqn): scope = resolveImportedModuleOrPackage( self.scope, node.modname) if scope is not None: if isinstance(scope, Package): self.match = getModuleOrPackageUsingFQN( name, scope.path) else: assert isinstance(scope, Module) self.match = getTypeOf(scope, name)