예제 #1
0
파일: framework.py 프로젝트: kralf/morsel
  def createInstance(self, module, type, **kargs):
    for package in reversed(self.packages.keys()):
      try:
        imported = __import__(self.packages[package].module+"."+module,
          __builtin__.globals(), __builtin__.locals(), [type])
        instance = getattr(imported, type)
      except ImportError as importError:
        self.spam("Importing type "+type+" from "+
          self.packages[package].module+"."+module+" failed: "+
          str(importError))
        self.spam(traceback.format_exc())
      except AttributeError as attributeError:
        self.spam("Importing type "+type+" from "+
          self.packages[package].module+"."+module+" failed: "+
          str(attributeError))
        self.spam(traceback.format_exc())
      else:
        self.spam("Importing type "+type+" from "+
          self.packages[package].module+"."+module+" succeeded")
        return instance(**kargs)

    error = "Failed to import "+type+" from module "+module+"."
    if self.debug:
      error = error+" See debugging output for details."
    else:
      error = error+" Enable debugging output for details."
    self.error(error)
예제 #2
0
파일: framework.py 프로젝트: kralf/morsel
  def include(self, package, **kargs):
    package = package.replace("-", "_")
    if package in self.packages.keys():
      return
    
    self.info("Including package: "+package)
    try:
      self.packages[package] = Package(package, **kargs)
    except Exception as includeError:
      self.error("Failed to include package "+package+": "+str(includeError))
      
    if self.packages[package].requires:
      for required in self.packages[package].requires:
        self.include(required)
      
    packageModule = __import__(self.packages[package].module)
    packagePath = os.path.dirname(packageModule.__file__)
    modules = [name for _, name, _ in pkgutil.iter_modules([packagePath])]

    if "facade" in modules:      
      facade = __import__(self.packages[package].module+".facade",
        __builtin__.globals(), __builtin__.locals(), ["*"])
      for expression in dir(facade):
        if not __builtin__.__dict__.has_key(expression):
          __builtin__.__dict__[expression] = getattr(facade, expression)
예제 #3
0
    def _generate_logger(
        cls, name, level, buffer, terminator, colored_format, format
    ):
# #
        '''
            Creates a new logger instance by initializing all its components \
            with given arguments or default properties saved as class \
            properties.

            Examples:

            >>> Logger._generate_logger(
            ...     'test', ('info',), (Buffer(),), ('',), (''), ('',)
            ... ) # doctest: +ELLIPSIS
            <logging.Logger object at ...>
        '''
        # TODO check branches.
        properties = []
        for property_name in (
            'level', 'buffer', 'terminator', 'colored_format', 'format'
        ):
            properties.append(
                builtins.locals()[property_name] if builtins.locals()[
                    property_name
                ] else builtins.getattr(cls, property_name))
        for handler in getLogger(name).handlers:
            getLogger(name).removeHandler(handler)
        logger = getLogger(name)
        logger.propagate = False
        for _level, _buffer, _terminator, _colored_format, _format in \
        builtins.zip(properties[0], properties[1], properties[2], properties[3], properties[4]):
            handler = LoggingStreamHandler(stream=_buffer)
            handler.terminator = _terminator
            handler.setLevel(_level.upper())
            # TODO check new branches
            if _colored_format is None:
                handler.setFormatter(LoggingFormatter(_format))
            else:
                handler.setFormatter(ColoredLoggingFormatter(_colored_format))
            logger.addHandler(handler)
        '''
            Set meta logger level to first given level (level is first \
            property).
        '''
        logger.setLevel(builtins.getattr(logging, properties[0][0].upper()))
        return logger
예제 #4
0
def import_all_but_wx(name,
                      globals=__builtin__.globals(),
                      locals=__builtin__.locals(),
                      fromlist=[], level=-1,
                      default_import=__builtin__.__import__):
    if name == "wx" or name.startswith("wx."):
        raise ImportError("Not allowed to import wx!")
    return default_import(name, globals, locals, fromlist, level)
예제 #5
0
파일: package.py 프로젝트: kralf/morsel
  def __init__(self, name, homeVar = None, configDir = None, systemDir = None,
      userDir = None, module = None, requires = None, options = None,
      arguments = None, **kargs):
    super(Package, self).__init__()

    self.name = name
    self.module = module
    self.requires = requires
    self.options = options
    self.arguments = arguments
    
    self.homeVar = homeVar
    self.configDir = configDir
    self.systemDir = systemDir
    self.userDir = userDir

    if not self.module:
      self.module = self.name.replace("-", "_")

    imported = __import__(self.module+".config", __builtin__.globals(),
      __builtin__.locals(), ["config"])
    self.configuration = getattr(imported, "Configuration")()
      
    if not self.homeVar:
      self.homeVar = (self.name.replace("-", "_")+"_HOME").upper()
    if not self.configDir:
      self.configDir = self.configuration.configurationPath
    if not self.systemDir:
      self.systemDir = self.configuration.filePath
    if not self.userDir:
      self.userDir = os.path.join(os.environ["HOME"], "."+self.name)
    
    if not self.requires:
      if hasattr(self.configuration, "requires"):
        self.requires = self.configuration.requires
    if not self.options:
      if hasattr(self.configuration, "options"):
        self.options = self.configuration.options
    if not self.arguments:
      if hasattr(self.configuration, "arguments"):
        self.arguments = self.configuration.arguments
예제 #6
0
    def _set_properties(
        cls, level, buffer, terminator, colored_format, format
    ):
# #
        '''
            This method sets the class properties.

            Examples:

            >>> Logger._set_properties(
            ...     level=Logger.level, buffer=Logger.buffer,
            ...     terminator=Logger.terminator,
            ...     colored_format=Logger.colored_format, format=Logger.format
            ... ) # doctest: +ELLIPSIS
            <class '...Logger'>
        '''
        # TODO check branches.
        scope = builtins.locals()
        for name in builtins.filter(lambda name: scope[name], (
            'level', 'buffer', 'terminator', 'colored_format', 'format'
        )):
            builtins.setattr(cls, name, scope[name])
        return cls