Python serializers.json方法代码示例

# 需要导入模块: import serializers [as 别名]
# 或者: from serializers import json [as 别名]
def CONTAINS(self,first,second,case_sensitive=False):
        if first.type in ('string','text', 'json'):
            if isinstance(second,Expression):
                second = Expression(None,self.CONCAT('%',Expression(
                            None,self.REPLACE(second,('%','%%'))),'%'))
            else:
                second = '%'+str(second).replace('%','%%')+'%'
        elif first.type.startswith('list:'):
            if isinstance(second,Expression):
                second = Expression(None,self.CONCAT(
                        '%|',Expression(None,self.REPLACE(
                                Expression(None,self.REPLACE(
                                        second,('%','%%'))),('|','||'))),'|%'))
            else:
                second = '%|'+str(second).replace('%','%%')\
                    .replace('|','||')+'|%'
        op = case_sensitive and self.LIKE or self.ILIKE
        return op(first,second) 

# 需要导入模块: import serializers [as 别名]
# 或者: from serializers import json [as 别名]
def build_parsemap(self):
        self.parsemap = {
            'id':self.parse_id,
            'integer':self.parse_integer,
            'bigint':self.parse_integer,
            'float':self.parse_double,
            'double':self.parse_double,
            'reference':self.parse_reference,
            'boolean':self.parse_boolean,
            'date':self.parse_date,
            'time':self.parse_time,
            'datetime':self.parse_datetime,
            'blob':self.parse_blob,
            'decimal':self.parse_decimal,
            'json':self.parse_json,
            'list:integer':self.parse_list_integers,
            'list:reference':self.parse_list_references,
            'list:string':self.parse_list_strings,
            } 

# 需要导入模块: import serializers [as 别名]
# 或者: from serializers import json [as 别名]
def as_json(self, mode='object', default=None):
        """
        serializes the rows to a JSON list or object with objects
        mode='object' is not implemented (should return a nested
        object structure)
        """

        items = [record.as_json(mode=mode, default=default,
                                serialize=False,
                                colnames=self.colnames) for
                 record in self]

        if have_serializers:
            return serializers.json(items,
                                    default=default or
                                    serializers.custom_json)
        elif simplejson:
            return simplejson.dumps(items)
        else:
            raise RuntimeError("missing simplejson")

    # for consistent naming yet backwards compatible 

# 需要导入模块: import serializers [as 别名]
# 或者: from serializers import json [as 别名]
def ASSIGNJS(**kargs):
    """
    Example:
        ASSIGNJS(var1='1', var2='2') will return the following javascript variables assignations :

            var var1 = "1";
            var var2 = "2";

    Args:
        **kargs: Any keywords arguments and assigned values.

    Returns:
        Javascript vars assignations for the key/value passed.

    """
    from gluon.serializers import json
    s = ""
    for key, value in kargs.items():
        s += 'var %s = %s;\n' % (key, json(value))
    return XML(s) 

# 需要导入模块: import serializers [as 别名]
# 或者: from serializers import json [as 别名]
def as_json(self, sanitize=True):
        d = self.as_dict(flat=True, sanitize=sanitize)
        from serializers import json
        return json(d) 

# 需要导入模块: import serializers [as 别名]
# 或者: from serializers import json [as 别名]
def ASSIGNJS(**kargs):
    from gluon.serializers import json
    s = ""
    for key, value in kargs.items():
        s+='var %s = %s;\n' % (key, json(value))
    return XML(s) 

# 需要导入模块: import serializers [as 别名]
# 或者: from serializers import json [as 别名]
def widget(cls, field, value, **attributes):
        """
        generates a TEXTAREA for JSON notation.

        see also: :meth:`FormWidget.widget`
        """
        if not isinstance(value, basestring):
            if value is not None:
                value = serializers.json(value)
        default = dict(value=value)
        attr = cls._attributes(field, default, **attributes)
        return TEXTAREA(**attr) 

# 需要导入模块: import serializers [as 别名]
# 或者: from serializers import json [as 别名]
def expand(self, expression, field_type=None):
        if isinstance(expression, Field):
            out = '%s.%s' % (expression.table._tablename, expression.name)
            if field_type == 'string' and not expression.type in (
                'string','text','json','password'):
                out = 'CAST(%s AS %s)' % (out, self.types['text'])
            return out
        elif isinstance(expression, (Expression, Query)):
            first = expression.first
            second = expression.second
            op = expression.op
            optional_args = expression.optional_args or {}
            if not second is None:
                out = op(first, second, **optional_args)
            elif not first is None:
                out = op(first,**optional_args)
            elif isinstance(op, str):
                if op.endswith(';'):
                    op=op[:-1]
                out = '(%s)' % op
            else:
                out = op()
            return out
        elif field_type:
            return str(self.represent(expression,field_type))
        elif isinstance(expression,(list,tuple)):
            return ','.join(self.represent(item,field_type) \
                                for item in expression)
        elif isinstance(expression, bool):
            return '1' if expression else '0'
        else:
            return str(expression) 

# 需要导入模块: import serializers [as 别名]
# 或者: from serializers import json [as 别名]
def parse_json(self, value, field_type):
        if not self.native_json:
            if not isinstance(value, basestring):
                raise RuntimeError('json data not a string')
            if isinstance(value, unicode):
                value = value.encode('utf-8')
            if have_serializers:
                value = serializers.loads_json(value)
            elif simplejson:
                value = simplejson.loads(value)
            else:
                raise RuntimeError("missing simplejson")
        return value 

# 需要导入模块: import serializers [as 别名]
# 或者: from serializers import json [as 别名]
def try_json(self):
        # check JSON data type support
        # (to be added to after_connection)
        if self.driver_name == "pg8000":
            supports_json = self.connection.server_version >= "9.2.0"
        elif (self.driver_name == "psycopg2") and \
             (self.driver.__version__ >= "2.0.12"):
            supports_json = self.connection.server_version >= 90200
        elif self.driver_name == "zxJDBC":
            supports_json = self.connection.dbversion >= "9.2.0"
        else: supports_json = None
        if supports_json:
            self.types["json"] = "JSON"
            self.native_json = True
        else: LOGGER.debug("Your database version does not support the JSON data type (using TEXT instead)") 

# 需要导入模块: import serializers [as 别名]
# 或者: from serializers import json [as 别名]
def LIKE(self,first,second):
        args = (self.expand(first), self.expand(second,'string'))
        if not first.type in ('string', 'text', 'json'):
            return '(CAST(%s AS CHAR(%s)) LIKE %s)' % (args[0], first.length, args[1])
        else:
            return '(%s LIKE %s)' % args 

# 需要导入模块: import serializers [as 别名]
# 或者: from serializers import json [as 别名]
def ILIKE(self,first,second):
        args = (self.expand(first), self.expand(second,'string'))
        if not first.type in ('string', 'text', 'json'):
            return '(CAST(%s AS CHAR(%s)) LIKE %s)' % (args[0], first.length, args[1])
        else:
            return '(%s ILIKE %s)' % args 

# 需要导入模块: import serializers [as 别名]
# 或者: from serializers import json [as 别名]
def represent(self, obj, fieldtype):
        value = BaseAdapter.represent(self, obj, fieldtype)
        if fieldtype in ('string','text', 'json') and value[:1]=="'":
            value = 'N'+value
        return value 

# 需要导入模块: import serializers [as 别名]
# 或者: from serializers import json [as 别名]
def __init__(self,db,uri,pool_size=0,folder=None,db_codec ='UTF-8',
                 credential_decoder=IDENTITY, driver_args={},
                 adapter_args={}, do_connect=True, after_connection=None):
        self.types.update({
                'boolean': gae.BooleanProperty,
                'string': (lambda **kwargs: gae.StringProperty(multiline=True, **kwargs)),
                'text': gae.TextProperty,
                'json': gae.TextProperty,
                'password': gae.StringProperty,
                'blob': gae.BlobProperty,
                'upload': gae.StringProperty,
                'integer': gae.IntegerProperty,
                'bigint': gae.IntegerProperty,
                'float': gae.FloatProperty,
                'double': gae.FloatProperty,
                'decimal': GAEDecimalProperty,
                'date': gae.DateProperty,
                'time': gae.TimeProperty,
                'datetime': gae.DateTimeProperty,
                'id': None,
                'reference': gae.IntegerProperty,
                'list:string': (lambda **kwargs: gae.StringListProperty(default=None, **kwargs)),
                'list:integer': (lambda **kwargs: gae.ListProperty(int,default=None, **kwargs)),
                'list:reference': (lambda **kwargs: gae.ListProperty(int,default=None, **kwargs)),
                })
        self.db = db
        self.uri = uri
        self.dbengine = 'google:datastore'
        self.folder = folder
        db['_lastsql'] = ''
        self.db_codec = 'UTF-8'
        self._after_connection = after_connection
        self.pool_size = 0
        match = self.REGEX_NAMESPACE.match(uri)
        if match:
            namespace_manager.set_namespace(match.group('namespace')) 

# 需要导入模块: import serializers [as 别名]
# 或者: from serializers import json [as 别名]
def startswith(self, value):
        db = self.db
        if not self.type in ('string', 'text', 'json'):
            raise SyntaxError("startswith used with incompatible field type")
        return Query(db, db._adapter.STARTSWITH, self, value)