Python webapp2.import_string函数代码示例

    def add(self, value, entry=IndexEntry, **kwargs):

        ''' Shortcut factory method to add an IndexEntry to an index. '''

        if entry == IndexEntry:
            if self.entry_base != _DEFAULT_ENTRY_PATH:
                entry = import_string(self.entry_base)
        else:
            ## validate base
            for k in self.entry_kind:
                found = False
                try:
                    m = import_string(k)
                    assert m == entry
                except AssertionError:
                    continue
                except ImportError:
                    continue
                else:
                    found = True
                    break

                if not found:
                    raise ValueError("Must pass in the EntryBase or a compatible EntryKind for this Index upon add.")

        return entry.new(self, value, **kwargs)

    def test_import_string(self):
        self.assertEqual(webapp2.import_string('webob.exc'), webob.exc)
        self.assertEqual(webapp2.import_string('webob'), webob)

        self.assertEqual(webapp2.import_string('asdfg', silent=True), None)
        self.assertEqual(webapp2.import_string('webob.asdfg', silent=True), None)

        self.assertRaises(webapp2.ImportStringError, webapp2.import_string, 'asdfg')
        self.assertRaises(webapp2.ImportStringError, webapp2.import_string, 'webob.asdfg')

    def test_import_string(self):
        self.assertEqual(webapp2.import_string('webob.exc'), webob.exc)
        self.assertEqual(webapp2.import_string('webob'), webob)

        self.assertEqual(webapp2.import_string('dfasfasdfdsfsd', silent=True), None)
        self.assertEqual(webapp2.import_string('webob.dfasfasdfdsfsd', silent=True), None)

        self.assertRaises(ImportError, webapp2.import_string, 'dfasfasdfdsfsd')
        self.assertRaises(AttributeError, webapp2.import_string, 'webob.dfasfasdfdsfsd')

 def oauth_config(self):
   try:
     oauth_config = webapp2.import_string("oauth_config.{0}".format(self.request.host.replace(":", "_")))
   except webapp2.ImportStringError:
     try:
       oauth_config = webapp2.import_string("oauth_config.{0}".format(self.request.host.split(":", 1)[0]))
     except webapp2.ImportStringError as e:
       logging.warning(e)
       try:
         from oauth_config import default as oauth_config
       except ImportError:
         return
   return oauth_config

def custom_dispatcher(router, request, response):
    route, args, kwargs = rv = router.match(request)
    request.route, request.route_args, request.route_kwargs = rv

    handler = route.handler
    if isinstance(handler, basestring):
        handler, args, kwargs = parse_handler_template(request, handler, args, kwargs)
        # debug logging
        # logging.info('handler is %s' % handler)
        # logging.info(request.route_args)
        # logging.info(request.route_kwargs)
        # for x in request.params:
        #     logging.info('Param is %s' % x)
        # logging.info(args)
        # logging.info(kwargs)
        try:
            handler = webapp2.import_string(handler)
            # Module, Controller, Action 文字列格納
            handler.adapted_handler_spec = kwargs
            # jinjaテンプレート定義
            handler.JINJA_ENVIRONMENT = jinja2.Environment(
                loader=jinja2.FileSystemLoader(
                    spy_setting.MODULES_DIR + "/" + kwargs["module"] + "/views/templates/" + kwargs["controller"]
                ),
                extensions=["jinja2.ext.autoescape"],
            )

            router.handlers[handler] = handler
        except webapp2.ImportStringError:
            webapp2.abort(404)

    return router.adapt(handler)(request, response)

def get_api():
  import endpoints
  api_services = list()
  for api in config.API:
    module = webapp2.import_string(api)
    api_services.extend(module.api_services)
  return endpoints.api_server(api_services)

    def create(self, class_name):
        logging.info(self.request.arguments())
        if self.checkModel(class_name) == False:
            return

        if models.BlackList.checkBanned():
            return

            # 文字列からモデルクラス、エンティティ取得
        classPath_str = "models." + functions.convertFromSnakeCaseToCamelCase(class_name)
        klass = webapp2.import_string(classPath_str)

        # マスタデータかどうかチェック & マスターデータだったら管理者以外は作成できないように。
        if klass.isMasterData == True and users.is_current_user_admin() == False:
            logging.warn("管理者以外がマスタデータを作成しようとしました")
            return False

            # 保存開始
        entity = klass()
        self.setPropertyFromRequestData(entity, self.request)
        entity.put()

        # 出力
        out = {
            "meta": functions.createMetaData(status="ok", code=200, method_name="createCustomObject"),
            "response": {"objects": [entity.toDict()]},
        }
        self.response.out.write(json.encode(out))

    def show(self, class_name):
        id = self.request.get("id", None)
        if id is None:
            out = {
                "meta": functions.createMetaData(
                    status="fail", code=400, method_name="showObjects", message="parameter missing"
                )
            }
            self.response.out.write(json.encode(out))
            return

            # 文字列からモデルクラス取得
        classPath_str = "models." + functions.convertFromSnakeCaseToCamelCase(class_name)
        klass = webapp2.import_string(classPath_str)
        obj = klass.get_by_id(int(id))

        if obj and obj.is_deleted == False:
            out = {
                "meta": functions.createMetaData(status="ok", code=200, method_name="showObjects"),
                "response": {"objects": [obj.toDict(full=True)]},
            }
        else:
            out = {
                "meta": functions.createMetaData(
                    status="fail", code=400, method_name="showObjects", message="object not found"
                )
            }

        self.response.out.write(json.encode(out))

    def __getitem__(self, module):
        """Returns the configuration for a module. If it is not already
        set, loads a ``default_config`` variable from the given module and
        updates the configuration with those default values

        Every module that allows some kind of configuration sets a
        ``default_config`` global variable that is loaded by this function,
        cached and used in case the requested configuration was not defined
        by the user.

        :param module:
            The module name.
        :returns:
            A configuration value.
        """
        if module not in self.loaded:
            # Load default configuration and update config.
            values = webapp2.import_string(module + '.default_config',
                                           silent=True)
            if values:
                self.setdefault(module, values)

            self.loaded.append(module)

        try:
            return dict.__getitem__(self, module)
        except KeyError:
            raise KeyError('Module %r is not configured.' % module)

	def list( self, class_name ):
		# 文字列からモデルクラス、エンティティ取得
		classPath_str = "models."+ class_name.capitalize()
		klass = webapp2.import_string( classPath_str )

		# entities = klass.query( klass.is_deleted==False ).order( -klass.created_at )
		entities = klass.query()


		entities_json = []
		for entity in entities:
			entities_json.append( entity.toDict() )


		# プロパティ情報を dict に入れる
		props = []
		for prop in klass.__dict__["_properties"]:
			props.append({
				"name": prop,
				"className": getattr(klass,prop).__class__.__name__,
			})
		# logging.info( props )

		res = jinja2.get_jinja2().render_template( 'admin/list.html', **{
			"entities": entities,
			"entities_json": json.encode( entities_json ),
			"props": props,
			"class_name": class_name,
		})
		self.response.out.write( res )

def readConfig(config=_config):

    ''' Parses extra config files and combines into one global config. '''

    global _compiled_config
    from webapp2 import import_string
    if _compiled_config is not None:
        return _compiled_config
    else:
        if config['apptools.system'].get('include', False) is not False and len(config['apptools.system']['include']) > 0:
            systemLog('Considering system config includes...')
            for name, configpath in config['apptools.system']['include']:
                systemLog('Checking include "' + str(name) + '" at path "' + str(configpath) + '".')
                try:
                    for key, cfg in import_string('.'.join(configpath.split('.') + ['config'])).items():
                        config[key] = cfg
                except Exception, e:
                    systemLog('Encountered exception of type "' + str(e.__class__) + '" when trying to parse config include "' + str(name) + '" at path "' + str(configpath))
                    if debug:
                        raise
                    else:
                        continue
        if len(config) > 0 and _compiled_config is None:
            _compiled_config = config

        return config

 def __init__(self, *args, **kwargs):
   super(BaseTestCase, self).__init__(*args, **kwargs)
   try:
     app = webapp2.import_string('main.app')
   except webapp2.ImportStringError:
     app = None
   self.app = app

    def user_model(self):
        """Configured user model."""
        cls = self.config['user_model']
        if isinstance(cls, basestring):
            cls = self.config['user_model'] = webapp2.import_string(cls)

        return cls

	def create( self ):
		target_model = self.request.get( 'target_model', None );
		target_id = self.request.get( 'target_id', None );

		# パラメータが足りなかったらエラー
		if target_model is None or target_id is None:
			message = "parameter missing"
			logging.warn( message );
			out = {"meta": functions.createMetaData( status="fail", code=400, method_name="createReport", message=message )};
			self.response.out.write( json.encode(out) )
			return

		# 文字列からターゲットのモデルクラス取得
		classPath_str = "models."+ target_model.capitalize()
		klass = webapp2.import_string( classPath_str )
		target_obj = klass.get_by_id( int(target_id) );

		# ターゲットオブジェクトがなければエラー	
		if target_obj is None:
			message = "target object not found"
			logging.warn( message );
			out = {"meta": functions.createMetaData( status="fail", code=400, method_name="createReport", message=message )};
			self.response.out.write( json.encode(out) )
			return

		# 保存
		entity = models.Report()
		entity.target_key = target_obj.key
		entity.user_key = self.user.key if self.user else None
		entity.put();

		# 出力
		out = {
			"meta": functions.createMetaData( status="ok", code=200, method_name="createReport" ),
			"response": {
				"reports":[
					entity.toDict(),
				],
			},
		};
		self.response.out.write( json.encode(out) )

		# 管理者にメール
		sender_address = "[email protected]"
		recipient = "[email protected]"
		subject = "通報を確認してください。"
		targetKey_str = str( target_obj.key.id() )
		modelName = target_model.capitalize().encode()
		gql = "SELECT * FROM "+ modelName +" where __key__ = Key( '"+ modelName +"', "+ targetKey_str +" )"

		body = """
通報がありました。
ターゲットのkeyは %(targetKey_str)s です

検索用 GQL は以下のとおりです。
%(gql)s

""" % locals()
		mail.send_mail( sender_address, recipient, subject, body )

def load_inherited_models(app):
    """ Load correct modules to resolve polymodels
    Returns the modules loaded
    """
    model_modules = []
    for game_name, game in app.config['games'].iteritems():
        model_modules.append(webapp2.import_string(game['model']))
    return model_modules