def checkTypeMatchesDefinition(self, inspectedArgument: InspectedArgument, services2Classes: dict, aliases2Services: dict):
serviceClassType = self.__resolveServiceClassType(services2Classes, aliases2Services)
if serviceClassType == inspectedArgument.dtype:
return
serviceClass = loadClass(serviceClassType.moduleName, serviceClassType.className)
inspectedArgumentClass = loadClass(inspectedArgument.dtype.moduleName, inspectedArgument.dtype.className)
if not issubclass(serviceClass, inspectedArgumentClass):
raise ArgumentsValidatorException(inspectedArgument.name, str(inspectedArgument.dtype), str(serviceClassType))
def resolveConstructor(self, dtype: DType) -> List[InspectedArgument]:
classDefinition = loadClass(dtype.moduleName, dtype.className)
while '__init__' not in classDefinition.__dict__:
firstParentClass = classDefinition.__bases__[0]
# no constructor found in base class or parents
if firstParentClass.__module__ == 'builtins' and firstParentClass.__name__ == 'object':
return []
classDefinition = loadClass(firstParentClass.__module__,
firstParentClass.__name__)
return self.__resolve(getattr(classDefinition, '__init__'))
def loadContainerUsingEnvVar(appEnv: str) -> ContainerInterface:
if 'CONTAINER_INIT_FUNCTION' not in os.environ:
raise Exception(
'CONTAINER_INIT_FUNCTION environment variable must be set on cluster'
)
containerInitFunctionPath = os.environ['CONTAINER_INIT_FUNCTION']
containerInitModuleName = containerInitFunctionPath[
0:containerInitFunctionPath.rfind('.')]
containerInitFunctionName = containerInitFunctionPath[
containerInitFunctionPath.rfind('.') + 1:]
containerInitFunction = loadClass(containerInitModuleName,
containerInitFunctionName)
return containerInitFunction(appEnv)
def resolve(self, dtype: DType, pipelinePath: Path):
argumentType = str(dtype)
if argumentType in self.__serviceResolversMapping:
if self.__serviceResolversMapping[argumentType][0:1] != '@':
raise Exception('Service name must start with @')
serviceResolverName = self.__serviceResolversMapping[argumentType][
1:]
serviceResolver = self.__container.get(
serviceResolverName) # type: ServiceResolverInterface
return serviceResolver.resolve(pipelinePath)
class_ = loadClass(dtype.moduleName,
dtype.className) # pylint: disable = invalid-name
return self.__container.get(class_)
def resolve(self, functionArgument: InspectedArgument, decoratorArgument):
if decoratorArgument is not None:
return self.__resolveExplicitValue(functionArgument,
decoratorArgument)
argumentType = functionArgument.dtype
if functionArgument.hasDefaultValue():
return self.__checkType(functionArgument.defaultValue,
argumentType, functionArgument.name)
if not argumentType.isDefined():
raise Exception(
f'Argument "{functionArgument.name}" must either have explicit value, default value or typehint defined'
)
if str(argumentType) == 'logging.Logger':
return self.__logger
class_ = loadClass(
argumentType.moduleName,
argumentType.className) # pylint: disable = invalid-name
return self.__container.get(class_)
def resolveMethod(self, dtype: DType,
methodName: str) -> List[InspectedArgument]:
classDefinition = loadClass(dtype.moduleName, dtype.className)
return self.__resolve(getattr(classDefinition, methodName))