def __init__(self, *args, **kwargs): kwargs.pop('namedtuple_as_object', None) kwargs.pop('use_decimal', None) kwargs.pop('item_sort_key', None) kwargs.pop('for_json', None) kwargs.pop('bigint_as_string', None) kwargs.pop('tuple_as_array', None) kwargs.pop('ignore_nan', None) DjangoJSONEncoder.__init__(self, *args, **kwargs)
def encode_task_to_json(task): """ Encode Task to a JSON serialisable object. """ datetime_json_encoder = DjangoJSONEncoder() return {'id': task.id, 'date': datetime_json_encoder.encode(task.date), 'notes': task.notes,}
def json_v1(req): enc = DjangoJSONEncoder( ensure_ascii=False, indent=2, separators=(',', ':')) return HttpResponse(enc.encode( [ info.toolinfo() for info in ToolInfo.objects.all().order_by('name') ]), content_type="application/json; charset=utf8" )
def get_context_data(self, **kwargs): data = super(MarketDetail, self).get_context_data(**kwargs) serializer = DjangoJSONEncoder() stations = (self.object.stations.filter(active=True) .order_by('-latest_snapshot__timestamp') .select_related('latest_snapshot') ) data['stations'] = stations json_data = { 'stations': map(self.station_to_json, stations), 'updated_at': stations[0].updated_at, } data['station_json'] = serializer.encode(json_data) return data
def default(self, obj): """ Enable serialisation of a ValuesQuerySet This function must return a serializable object for any object type it receives. ValuesQuerySet will return dictionaries when used as an iterable. Here we differentiate between a ValuesQuerySet with one or more items and return either a dictionary/list of dictionaries. You can test ajax queries from the terminal with: $ curl -H 'X-Requested-With: XMLHttpRequest' <url> Serialising querysets - returns a multiple item list if isinstance(obj, QuerySet): return json.loads(serializers.serialize('json', obj)) Serialising models - returns a single item list if isinstance(obj, models.Model): obj = [obj] # Iterable required return json.loads(serializers.serialize("json", obj))[0] """ if isinstance(obj, ValuesQuerySet): if len(obj) > 0: return list(obj) else: return list(obj)[0] return DjangoJSONEncoder.default(self, obj)
def encode_event_to_json(event): """ Encode Event to a JSON serialisable object. """ datetime_json_encoder = DjangoJSONEncoder() return {'id': event.id, 'title': event.title, 'from_date': datetime_json_encoder.encode(event.from_date), 'from_time': datetime_json_encoder.encode(event.from_time), 'to_date': datetime_json_encoder.encode(event.to_date), 'to_time': datetime_json_encoder.encode(event.to_time), 'location': event.location, 'note': event.note, 'lecturer': '%s' % event.lecturer, 'module': '%s' % event.module,}
def default(self, obj): if isinstance(obj, QuerySet): return json.loads(serialize('json', obj)) elif isinstance(obj, Model): return json.loads(serialize('json', [obj]))[0] else: return DjangoJSONEncoder.default(self, obj)
def default(self, obj): impl = getattr(obj, to_json_implementation, None) if impl and callable(impl): return impl() if hasattr(obj, 'isoformat'): return obj.isoformat() return DjangoJSONEncoder.default(self, obj)
def save(self, old_record, list_record, detail_record): license_type = self.get_or_create_lookup( 'license_type', list_record['license_type_code'], list_record['license_type_code'], make_text_slug=False) disposition = self.get_or_create_lookup('disposition', list_record['disposition'], list_record['disposition'], make_text_slug=False) violation_lookups = [ self.get_or_create_lookup('violation', v[0], v[0], make_text_slug=False) for v in list_record['violations'] ] violation_lookup_text = ','.join( [str(v.id) for v in violation_lookups]) v_lookup_dict = dict([(v.code, v.id) for v in violation_lookups]) v_list = [{ 'lookup_id': v_lookup_dict[code], 'number': number } for code, number in list_record['violations']] details_json = DjangoJSONEncoder().encode(v_list) title = u'%s inspected: %s violation%s' % ( list_record['business_name'], list_record['total_violations'], list_record['total_violations'] != 1 and 's' or '') values = { 'title': title, 'item_date': list_record['inspection_date'], 'location_name': '%s, %s' % (list_record['address'], list_record['city']), } attributes = { 'inspection_visit_id': list_record['inspection_visit_id'], 'license_id': list_record['license_id'], 'license_number': list_record['license_number'], 'business_name': list_record['business_name'], 'inspection_number': list_record['inspection_number'], 'license_type': license_type.id, 'critical_violations': list_record['critical_violations'], 'noncritical_violations': list_record['noncritical_violations'], 'total_violations': list_record['total_violations'], 'visit_number': list_record['visit_number'], 'disposition': disposition.id, 'violation': violation_lookup_text, 'violation_details': details_json, } if old_record is None: self.create_newsitem(attributes, **values) else: self.update_existing(old_record, values, attributes)
def get_models(result): encoder = DjangoJSONEncoder() content = [] for e in result: rep = "" if hasattr(e, "__unicode__"): rep = e.__unicode__() else: rep = e.__str__() fields = {"repr": rep} for f in e._meta.fields: try: fields[f.name] = encoder.default(getattr(e, f.name)) except: fields[f.name] = getattr(e, f.name) content.append(fields) return content
def default(self, obj): if type(obj) == QuerySet: return serializers.serialize("python", obj, ensure_ascii=False) if type(obj) == EmptyQuerySet: return serializers.serialize("python", obj, ensure_ascii=False) return DjangoJSONEncoder.default(self, obj)
def poll_specifications(sandbox_pk: int) -> None: """Poll specifications of a sandbox and send it to the correct group.""" sandbox = Sandbox.objects.get(pk=sandbox_pk) sandbox_specs, container_specs = async_to_sync( sandbox.poll_specifications)() channel_layer = get_channel_layer() async_to_sync(channel_layer.group_send)( f"sandbox_sandbox_specs_{sandbox_pk}", { 'type': 'sandbox_specs', 'specs': DjangoJSONEncoder().encode(dgeq.serialize(sandbox_specs)) }) async_to_sync(channel_layer.group_send)( f"sandbox_container_specs_{sandbox_pk}", { 'type': 'container_specs', 'specs': DjangoJSONEncoder().encode( dgeq.serialize(container_specs)) })
def handle_object(self, object, fields=None, exclude=None): """ Called to handle everything, looks for the correct handling """ # print type(object) # print object # print inspect.isclass(object) # print inspect.ismethod(object) # print inspect.isfunction(object) # print inspect.isbuiltin(object) # print inspect.isroutine(object) # print inspect.isabstract(object) # print type(object) == 'staticmethod' if (inspect.isroutine(object) or inspect.isbuiltin(object) or inspect.isclass(object)): raise UnableToSerializeMethodTypesError(type(object)) elif isinstance(object, dict): return self.handle_dictionary(object) elif (isinstance(object, list) or isinstance(object, tuple) or isinstance(object, set)): return self.handle_list(object) elif isinstance(object, Model): if hasattr(object, 'serialize'): exclude = self.exclude return self.handle_object( getattr(object, 'serialize')(fields, exclude), fields, exclude) else: return self.handle_model(object, fields, self.exclude) #return PythonSerializer().serialize([object],**self.options.copy())[0]['fields'] elif isinstance(object, QuerySet): #return super(JSONSerializer,self).serialize(object, **self.options.copy())[0] ret = [] for item in object: ret.append(self.handle_object(item, fields, exclude)) return ret elif (isinstance(object, int) or isinstance(object, float) or isinstance(object, long) or isinstance(object, basestring) or isinstance(object, bool) or object is None): return object elif (isinstance(object, datetime.datetime) or isinstance(object, datetime.date) or isinstance(object, datetime.time) or isinstance(object, decimal.Decimal)): return DjangoJSONEncoder().default(object) elif isinstance(object, GEOSGeometry): return getattr(object, self.geom_format) elif isinstance(object, File): return object.name elif isinstance(object, uuid.UUID): return str(object) elif hasattr(object, '__dict__'): # call an objects serialize method if it exists if hasattr(object, 'serialize'): return getattr(object, 'serialize')() else: return self.handle_dictionary(object.__dict__) else: raise UnableToSerializeError(type(object))
def default(self, obj): #Add the ability to deal with timedelta if isinstance(obj, timedelta): ARGS = ('days', 'seconds', 'microseconds') #So if we get a time-delta object return a dictionary with type and a list of the day, second, microseconds return {'__type__': 'datetime.timedelta', 'args': [getattr(obj, a) for a in ARGS]} if isinstance(obj, QuerySet): return [item for item in obj] return DjangoJSONEncoder.default(self, obj)
def default(self, value): if isinstance(value, datetime.date): return DjangoJSONEncoder.default(self, value) if isinstance(value, bytes): def bool_from_byte(byte_value): return 1 if byte_value == b'\x01' else 0 return bool_from_byte(value) if isinstance(value, Decimal): return float(value) else: return value.__dict__
def default(self, obj): if isinstance(obj, Matrix): return { "__matrix__": True, "cols": obj.cols, "width": obj.width, "rows": obj.rows, "height": obj.height, "matrix": obj.matrix.items(), } return DjangoJSONEncoder.default(self, obj)
def __init__(self, verbose_name=None, name=None, encoder=DjangoJSONEncoder(), **kwargs): models.TextField.__init__(self, verbose_name, name, blank=True, **kwargs) self.encoder = encoder
def default(self, obj): if isinstance(obj, Decimal): return float(obj) if isinstance(obj, datetime.datetime): return obj.strftime('%Y-%m-%d %H:%M:%S') if isinstance(obj, datetime.date): return obj.strftime('%Y-%m-%d') else: if type(obj)==ipaddr.IPv4Network or type(obj)==ipaddr.IPAddress: return str(obj) return DjangoJSONEncoder().default(obj)
def poll_usage(sandbox_pk: int) -> None: """Poll usage of a sandbox and send it to the correct group.""" sandbox = Sandbox.objects.get(pk=sandbox_pk) usage = async_to_sync(sandbox.poll_usage)() channel_layer = get_channel_layer() async_to_sync(channel_layer.group_send)( f"sandbox_usage_{sandbox_pk}", { 'type': 'sandbox_usage', 'usage': DjangoJSONEncoder().encode(dgeq.serialize(usage)) })
def _render_app_html(request, initial_json): html = loader.render_to_string('app.html') html = html.replace( "window.initialJSON=null", "window.initialJSON=" + json.dumps(initial_json, default=DjangoJSONEncoder().default)) if request.get_host() == 'localhost:3000': html = re.sub(r'static/app(-.*)js', 'app.js', html) html = re.sub(r'<link\s+href="/static/app.*css"[^>]*>', '', html) return HttpResponse(html, content_type="text/html")
def __init__(self, verbose_name=None, name=None, encoder=DjangoJSONEncoder(), **kwargs): blank = kwargs.pop('blank', True) models.TextField.__init__(self, verbose_name, name, blank=blank, **kwargs) self.encoder = encoder
def test_get_single(self): response = self.client.get( reverse("pl_sandbox:request-detail", args=(self.request.pk, ))) # Encode and decode the expected output so that the date format match expected = json.loads(DjangoJSONEncoder().encode({ "status": True, "row": dgeq.serialize(self.request), })) self.assertEqual(200, response.status_code) self.assertEqual(expected, response.json())
def create_set(self, project, json_data=None, **options): """Create a new articleset. Provide the needed arguments using the post_data or with key-value pairs""" url = articleset_url.format(**locals()) if json_data is None: # form encoded request return self.request(url, method="post", data=options) else: if not isinstance(json_data, (str, unicode)): json_data = DjangoJSONEncoder().encode(json_data) headers = {'content-type': 'application/json'} return self.request(url, method='post', data=json_data, headers=headers)
def serialize(obj): if isinstance(obj, Mapping): for k, v in obj.items(): obj[k] = serialize(v) elif isinstance(obj, Collection) and not isinstance(obj, str): for i in obj: i = serialize(i) elif isinstance(obj, (datetime.datetime, datetime.date, datetime.time)): obj = DjangoJSONEncoder().default(obj) elif isinstance(obj, decimal.Decimal): obj = float(obj) # DjangoJSONEncoder().default(obj) return obj
def default(self, obj): if isinstance(obj, models.Model): if self.__serializable__(obj): return obj.serialize() else: return loads(serialize('json', obj)) if isinstance(obj, QuerySet): list = [] for o in obj: list.append(o.serialize()) return list return DjangoJSONEncoder.default(self, obj)
def default(self, obj): if isinstance(obj, models.Model): if self.__serializable__(obj): return obj.serialize() else: return loads(serialize('json', obj)) if isinstance(obj, QuerySet): list = [] for o in obj: list.append(o.serialize()) return list return DjangoJSONEncoder.default(self, obj)
def default(self, obj, **kwargs): if isinstance(obj, date): return str(obj) elif isinstance(obj, models.Model): return model_to_dict(obj) elif isinstance(obj, ImageFieldFile): if obj: return obj.url return None elif isinstance(obj, Decimal): return str(obj) else: return DjangoJSONEncoder.default(obj, **kwargs)
def default(self, obj): """Add the ability to deal with timedelta""" if isinstance(obj, timedelta): args = ('days', 'seconds', 'microseconds') # So if we get a time-delta object return a dictionary with # type and a list of the day, second, microseconds return { '__type__': 'datetime.timedelta', 'args': [getattr(obj, arg) for arg in args] } if isinstance(obj, QuerySet): return list(obj) return DjangoJSONEncoder.default(self, obj)
def wrapper(**kwargs): with atomic(): # We can get a hold of the log entry here and provide it to all # operations, return it, connect it to higher-level operations (we can # detect that this is a nested action). log = DataLog.objects.create( # We could also include the idea of adding an object's hash and # use it to prevent parallel operations on the same object, but # the calling code would be responsible of passing it here. operation_name=action_func.__name__, data=DjangoJSONEncoder().encode(kwargs), ) return action_func(**kwargs)
def save(self, old_record, list_record, detail_record): if old_record is not None: return # We already have this inspection. restaurant_type = self.get_or_create_lookup( 'restaurant_type', list_record['restaurant_type'], list_record['restaurant_type']) violation_lookups = [ self.get_or_create_lookup('violation', v[0], v[0], make_text_slug=False) for v in list_record['violation_list'] ] violation_lookup_text = ','.join( [str(v.id) for v in violation_lookups]) # There's a bunch of data about every particular violation, and we # store it as a JSON object. Here, we create the JSON object. v_lookup_dict = dict([(v.code, v) for v in violation_lookups]) v_list = [{ 'lookup_id': v_lookup_dict[code].id, 'comment': comment } for code, comment in list_record['violation_list']] details_json = DjangoJSONEncoder().encode({ 'notes': list_record['notes'], 'violations': v_list }) title = u'%s inspected: ' % list_record['restaurant_name'] if not list_record['violation_list']: title += u'No critical violations' else: num = len(list_record['violation_list']) title += u'%s critical violation%s' % (num, num != 1 and 's' or '') attributes = { 'raw_address': list_record['raw_address'], 'raw_city': list_record['raw_city'], 'restaurant_hash': list_record['restaurant_hash'], 'details': details_json, 'restaurant_name': list_record['restaurant_name'], 'restaurant_type': restaurant_type.id, 'violation': violation_lookup_text, } self.create_newsitem( attributes, title=title, item_date=list_record['inspection_date'], location_name=list_record['address'], )
def default(self, value): if isinstance(value, datetime.date): return DjangoJSONEncoder.default(self, value) elif isinstance(value, bytes): def bool_from_byte(byte_value): return 1 if byte_value == b'\x01' else 0 return bool_from_byte(value) else: value_to_return = value.__dict__ if '_state' in value_to_return.keys(): del value_to_return['_state'] return value_to_return
def default(o): if isinstance(o, models.Model): return o.pk if isinstance(o, models.QuerySet): return list(o.values_list('pk', flat=True)) if isinstance(o, (Generator, set)): return list(o) if hasattr(o, '__json__'): return o.__json__() return DjangoJSONEncoder().default(o)
def serialize_personal_quiz(microlearning_average): json_encoder = DjangoJSONEncoder() project = microlearning_average.get_project() step_microlearnings = MicroLearning.objects.filter_by_step( microlearning_average.step) teams = project.teams.all() # Old version socket data serialized_data = microlearning_average.serialize() # Append data for new socket version serialized_data['personalRating'] = serialized_data.get('user') serialized_data['teamRatings'] = [] for microlearning in step_microlearnings: for team in teams.filter(stream=microlearning.step_stream.stream): team_microlearning_avg = MicroLearningAverage( step_stream=microlearning.step_stream, user=None, team=team ) data = team_microlearning_avg.serialize() serialized_data['teamRatings'].append( json.loads( json_encoder.encode({ 'pkTeam': team.pk, 'nameTeam': team.name, 'ratings': data.get('ratings'), 'avg': data.get('allTeamAvg'), }) ) ) serialized_data['teamRatings'] = sorted( serialized_data['teamRatings'], key=lambda x: x['pkTeam']) return serialized_data
def create_articles(self, project, articleset, json_data=None, **options): """Create one or more articles in the set. Provide the needed arguments using the json_data or with key-value pairs json_data can be a dictionary or list of dictionaries. Each dict can contain a 'children' attribute which is another list of dictionaries. """ url = article_url.format(**locals()) if json_data is None: #TODO duplicated from create_set, move into requests (or separate post method?) # form encoded request return self.request(url, method="post", data=options) else: if not isinstance(json_data, (str, unicode)): json_data = DjangoJSONEncoder().encode(json_data) headers = {'content-type': 'application/json'} return self.request(url, method='post', data=json_data, headers=headers)
def get_or_create(self, table_name, **fields): """ Check if a resource exists in and if so return it. If it does not exist, create the resource and return it. """ try: return self.get(table_name, **fields) except NotFoundError: pass for field_name, field_value in fields.iteritems(): fields[field_name] = eval(DjangoJSONEncoder().encode(field_value)) return self.coreapi_client.action(self.coreapi_schema, [table_name, "create"], params=fields)
def get(self, request, **kwargs): del_window = datetime.timedelta(hours=12) serializer = DjangoJSONEncoder() station = self.model.objects.get(market__slug=kwargs['slug'], slug=kwargs['station_slug']) # make querysets recent_start = timezone.now() - datetime.timedelta(hours=11) recent_qs = station.history.filter( timestamp__gt=recent_start, timestamp__lte=recent_start + del_window, ) yesterday_start = recent_start - datetime.timedelta(days=1) yesterday_qs = station.history.filter( timestamp__gt=yesterday_start, timestamp__lte=yesterday_start + del_window, ) lastweek_start = recent_start - datetime.timedelta(days=7) lastweek_qs = station.history.filter( timestamp__gt=lastweek_start, timestamp__lte=lastweek_start + del_window, ) # convert querysets to json recent = map(self.snapshot_to_json, recent_qs) yesterday = map(self.snapshot_to_json, yesterday_qs) lastweek = map(self.snapshot_to_json, lastweek_qs) data = { 'capacity': station.capacity, 'recent': recent, 'yesterday': yesterday, 'lastweek': lastweek, } return HttpResponse(serializer.encode(data), content_type='application/json')
def main_app(request, *args, **kwargs): """Loads the react single page app.""" html = loader.render_to_string('app.html') html = html.replace( "window.initialJSON=null", "window.initialJSON=" + json.dumps({'user': _get_json_for_user(request.user)}, default=DjangoJSONEncoder().default)) if request.get_host() == 'localhost:3000': html = re.sub(r'static/app(-.*)js', 'app.js', html) html = re.sub(r'<link\s+href="/static/app.*css"[^>]*>', '', html) return HttpResponse(html, content_type="text/html")
def encode(self, o, *args, **kwargs): from djblets.webapi.resources import get_resource_for_object if isinstance(o, QuerySet): return list(o) resource = get_resource_for_object(o) if resource: return resource.serialize_object(o, *args, **kwargs) try: return DjangoJSONEncoder().default(o) except TypeError: return None
class WebsocketBindingWithMembers(WebsocketBinding): """ Outgoing binding binding subclass based on WebsocketBinding. Additionally enables sending of member variables, properties and methods. Member methods can only have self as a required argument. Just add the name of the member to the send_members-list. Example: class MyModel(models.Model): my_field = models.IntegerField(default=0) my_var = 3 @property def my_property(self): return self.my_var + self.my_field def my_function(self): return self.my_var - self.my_vield class MyBinding(BindingWithMembersMixin, WebsocketBinding): model = MyModel stream = 'mystream' send_members = ['my_var', 'my_property', 'my_function'] """ model = None send_members = [] encoder = DjangoJSONEncoder() def serialize_data(self, instance): data = super(WebsocketBindingWithMembers, self).serialize_data(instance) member_data = {} for m in self.send_members: member = instance for s in m.split('.'): member = getattr(member, s) if callable(member): member_data[m.replace('.', '__')] = member() else: member_data[m.replace('.', '__')] = member member_data = json.loads(self.encoder.encode(member_data)) # the update never overwrites any value from data, # because an object can't have two attributes with the same name data.update(member_data) return data
def month_picker_params(self) -> Optional[str]: """Returns the parameters for the month-picker, as a JSON text string. Returns: The parameters for the month-picker, as a JSON text string, or None if there is no data. """ if self._data_start is None: return None start = datetime.date(self._data_start.year, self._data_start.month, 1) return DjangoJSONEncoder().encode({ "locale": Language.current().locale, "minDate": start, "maxDate": self._data_end, "defaultDate": self.chosen_month(), })
def _render_app_html(request, initial_json): html = loader.render_to_string('app.html') ui_version = re.search('static/app-(.*)\.js', html).group(1) initial_json['meta'] = { 'version': '{}-{}'.format(SEQR_VERSION, ui_version) } html = html.replace( "window.initialJSON=null", "window.initialJSON=" + json.dumps(initial_json, default=DjangoJSONEncoder().default)) if request.get_host() == 'localhost:3000': html = re.sub(r'static/app(-.*)js', 'app.js', html) html = re.sub(r'<link\s+href="/static/app.*css"[^>]*>', '', html) return HttpResponse(html, content_type="text/html")
def pformat(value): """ Better `pretty-print-format` using `DjangoJSONEncoder` with fallback to `pprint.pformat()` Try to use JSON fist, because it nicer than pprint.pformat() ;) Use DjangoJSONEncoder, because it can encode additional types like: date/time, decimal types, UUIDs """ try: value = DjangoJSONEncoder(indent=4, sort_keys=True, ensure_ascii=False).encode(value) except TypeError: # Fallback if values are not serializable with JSON: value = pprint.pformat(value, width=120) return value
def render_component(path_to_source, props=None, to_static_markup=False, json_encoder=None): if not os.path.isabs(path_to_source): path_to_source = finders.find(path_to_source) or path_to_source if json_encoder is None: json_encoder = DjangoJSONEncoder().encode html = render_core(path_to_source, props, to_static_markup, json_encoder, service_url=SERVICE_URL) return RenderedComponent(html, path_to_source, props, json_encoder)
def save(self, old_record, list_record, detail_records): for record in detail_records: # Since parse_detail emits more than one record, we check for existing # records here rather than in self.existing_record() try: qs = NewsItem.objects.filter( schema__id=self.schema.id, item_date=record['inspection_date']) obj = qs.by_attribute(self.schema_fields['facility_id'], list_record['facid'])[0] except IndexError: pass else: return None if record['inspection_type'] == 'Consultation/Education - Field': continue inspection_type_lookup = self.get_or_create_lookup( 'inspection_type', record['inspection_type'], record['inspection_type'], make_text_slug=False) violations_lookups = [] for v in record['violations']: vl = self.get_or_create_lookup('violations', v['violation'], v['violation'], make_text_slug=False) violations_lookups.append(vl) attributes = { 'name': list_record['name'], 'inspection_type': inspection_type_lookup.id, 'points': record['points'], 'violations': ','.join([str(l.id) for l in violations_lookups]), 'violations_json': DjangoJSONEncoder().encode(record['violations']), 'facility_id': list_record['facid'], } self.create_newsitem( attributes, title=list_record['name'], url= 'http://www.decadeonline.com/fac.phtml?agency=skc&forceresults=1&facid=%s' % list_record['facid'], item_date=record['inspection_date'], location_name=smart_title(list_record['location']))
def default(self, obj): if isinstance(obj, recurly.resource.Money): return str(obj) # Resolve 'relatiator' attributes if callable(obj): result = obj() try: return result.to_dict(js=self.js) except: return result if isinstance(obj, recurly.Resource): return obj.to_dict(js=self.js) try: if issubclass(obj, dict) or issubclass(obj, list): return list(obj) except: pass return DjangoJSONEncoder.default(self, obj)
def default(self, obj): if isinstance(obj, ObjectId): return str(obj) else: return DjangoJSONEncoder.default(self, obj)
def default(self, obj): # to do not import pymongo it just compares class name if type(obj).__name__ == "ObjectId": return str(obj) else: return DjangoJSONEncoder.default(self, obj)
def json_response(response_obj): Encoder = DjangoJSONEncoder() return HttpResponse(Encoder.encode(response_obj))
def default(self, obj): if (isinstance(obj, (date, list, dict, str, int, float, bool, type(None), Decimal)) or isinstance(obj, six.string_types)): return DjangoJSONEncoder.default(self, obj) return '{}'.format(type(obj).__name__)
def default(self, obj): try: return DjangoJSONEncoder.default(self, obj) except TypeError: return obj.__dict__
def instance_to_json(instance, fields=None, exclude=None, indent=1): encoder = DjangoJSONEncoder( encoding='utf-8', ensure_ascii=False, sort_keys=False, indent=indent) return encoder.encode(instance_to_dict(instance, fields=fields, exclude=exclude))
def default(self, obj): if isinstance(obj, Decimal): return float(obj) return DjangoJSONEncoder.default(self, obj)
def json_encode(data): encoder = DjangoJSONEncoder() return encoder.encode(data)
def default(self, o, **kwargs): if isinstance(o, ObjectId): return str(o) else: return DjangoJSONEncoder.default(self, o, **kwargs)
def json_pack(feed): encoder=DjangoJSONEncoder() return HttpResponse(encoder.encode(feed))
def default(self, obj): if isinstance(obj, QuerySet): return serializers.serialize("python", obj, ensure_ascii=False) return DjangoJSONEncoder.default(self, obj)
def default(self, obj): if isinstance(obj, ApiModel): return obj.__dict__ else: return DjangoJSONEncoder.default(self, obj)
def default(self, o): if isinstance(o, datetime.datetime): o = make_local_time(o) return DjangoJSONEncoder.default(self, o)
def default(self, obj): if isinstance(obj, timedelta): ARGS = ('days', 'seconds', 'microseconds') return {'__type__': 'datetime.timedelta', 'args': [getattr(obj, a) for a in ARGS]} return DjangoJSONEncoder.default(self, obj)
def test_0_encode_default(self): djangoencoder = DjangoJSONEncoder() self.assertEquals(self.encoder.encode('str'), djangoencoder.encode('str'))