def has_changed(self, initial, data): if super().has_changed(initial, data): return True # For purposes of seeing whether something has changed, True isn't the # same as 1 and the order of keys doesn't matter. data = self.to_python(data) return json_01.dumps(initial, sort_keys=True) != json_01.dumps(data, sort_keys=True)
def validate(self, value, model_instance): super().validate(value, model_instance) options = {'cls': self.encoder} if self.encoder else {} try: json_01.dumps(value, **options) except TypeError: raise exceptions.ValidationError( self.error_messages['invalid'], code='invalid', params={'value': value}, )
def render_to_response(self, context, **response_kwargs): def indent(s): return s.replace('\n', '\n ') template = Engine().from_string(js_catalog_template) context['catalog_str'] = indent( json_01.dumps(context['catalog'], sort_keys=True, indent=2)) if context['catalog'] else None context['formats_str'] = indent( json_01.dumps(context['formats'], sort_keys=True, indent=2)) return HttpResponse(template.render(Context(context)), 'text/javascript; charset="utf-8"')
def build_attrs(self, base_attrs, extra_attrs=None): """ Set select2's AJAX attributes. Attributes can be set using the html5 data attribute. Nested attributes require a double dash as per https://select2.org/configuration/data-attributes#nested-subkey-options """ attrs = super().build_attrs(base_attrs, extra_attrs=extra_attrs) attrs.setdefault('class', '') attrs.update({ 'data-ajax--cache': 'true', 'data-ajax--delay': 250, 'data-ajax--type': 'GET', 'data-ajax--url': self.get_url(), 'data-theme': 'admin-autocomplete', 'data-allow-clear': json_01.dumps(not self.is_required), 'data-placeholder': '', # Allows clearing of the input. 'class': attrs['class'] + (' ' if attrs['class'] else '') + 'admin-autocomplete', }) return attrs
def value_to_string(self, obj): value = self.value_from_object(obj) if value is None: return None if value.isempty: return json_01.dumps({"empty": True}) base_field = self.base_field result = {"bounds": value._bounds} for end in ('lower', 'upper'): val = getattr(value, end) if val is None: result[end] = None else: obj = AttributeSetter(base_field.attname, val) result[end] = base_field.value_to_string(obj) return json_01.dumps(result)
def _encode_json(self, data, content_type): """ Return encoded JSON if data is a dict, list, or tuple and content_type is application/json. """ should_encode = JSON_CONTENT_TYPE_RE.match( content_type) and isinstance(data, (dict, list, tuple)) return json_01.dumps(data, cls=self.json_encoder) if should_encode else data
def save_manifest(self): payload = { 'paths': self.hashed_files, 'version': self.manifest_version } if self.exists(self.manifest_name): self.delete(self.manifest_name) contents = json_01.dumps(payload).encode() self._save(self.manifest_name, ContentFile(contents))
def log_action(self, user_id, content_type_id, object_id, object_repr, action_flag, change_message=''): if isinstance(change_message, list): change_message = json_01.dumps(change_message) return self.model.objects.create( user_id=user_id, content_type_id=content_type_id, object_id=str(object_id), object_repr=object_repr[:200], action_flag=action_flag, change_message=change_message, )
def json_script(value, element_id): """ Escape all the HTML/XML special characters with their unicode escapes, so value is safe to be output anywhere except for inside a tag attribute. Wrap the escaped JSON in a script tag. """ from django.core.serializers.json import DjangoJSONEncoder json_str = json_01.dumps( value, cls=DjangoJSONEncoder).translate(_json_script_escapes) return format_html('<script id="{}" type="application/json">{}</script>', element_id, mark_safe(json_str))
def inline_formset_data(self): verbose_name = self.opts.verbose_name return json_01.dumps({ 'name': '#%s' % self.formset.prefix, 'options': { 'prefix': self.formset.prefix, 'addText': gettext('Add another %(verbose_name)s') % { 'verbose_name': capfirst(verbose_name), }, 'deleteText': gettext('Remove'), } })
def value_to_string(self, obj): values = [] vals = self.value_from_object(obj) base_field = self.base_field for val in vals: if val is None: values.append(None) else: obj = AttributeSetter(base_field.attname, val) values.append(base_field.value_to_string(obj)) return json_01.dumps(values)
def format_for_json(packages, options): data = [] for dist in packages: info = { 'name': dist.project_name, 'version': six.text_type(dist.version), } if options.verbose >= 1: info['location'] = dist.location info['installer'] = get_installer(dist) if options.outdated: info['latest_version'] = six.text_type(dist.latest_version) info['latest_filetype'] = dist.latest_filetype data.append(info) return json_01.dumps(data)
def __init__(self, data, encoder=DjangoJSONEncoder, safe=True, json_dumps_params=None, **kwargs): if safe and not isinstance(data, dict): raise TypeError( 'In order to allow non-dict objects to be serialized set the ' 'safe parameter to False.') if json_dumps_params is None: json_dumps_params = {} kwargs.setdefault('content_type', 'application/json') data = json_01.dumps(data, cls=encoder, **json_dumps_params) super().__init__(content=data, **kwargs)
def main(): logger = logging.getLogger(__name__) logger.setLevel(logging.DEBUG) logger.addHandler(logging.StreamHandler(sys.stdout)) parser = argparse.ArgumentParser(description="OS distro info tool") parser.add_argument('--json', '-j', help="Output in machine readable format", action="store_true") args = parser.parse_args() if args.json: logger.info(json_01.dumps(info(), indent=4, sort_keys=True)) else: logger.info('Name: %s', name(pretty=True)) distribution_version = version(pretty=True) logger.info('Version: %s', distribution_version) distribution_codename = codename() logger.info('Codename: %s', distribution_codename)
def prepopulated_fields_js(context): """ Create a list of prepopulated_fields that should render Javascript for the prepopulated fields for both the admin form and inlines. """ prepopulated_fields = [] if 'adminform' in context: prepopulated_fields.extend(context['adminform'].prepopulated_fields) if 'inline_admin_formsets' in context: for inline_admin_formset in context['inline_admin_formsets']: for inline_admin_form in inline_admin_formset: if inline_admin_form.original is None: prepopulated_fields.extend( inline_admin_form.prepopulated_fields) prepopulated_fields_json = [] for field in prepopulated_fields: prepopulated_fields_json.append({ "id": "#%s" % field["field"].auto_id, "name": field["field"].name, "dependency_ids": [ "#%s" % dependency.auto_id for dependency in field["dependencies"] ], "dependency_list": [dependency.name for dependency in field["dependencies"]], "maxLength": field["field"].field.max_length or 50, "allowUnicode": getattr(field["field"].field, "allow_unicode", False) }) context.update({ 'prepopulated_fields': prepopulated_fields, 'prepopulated_fields_json': json_01.dumps(prepopulated_fields_json), }) return context
# print(d) # for c in enumerate(a): # print(c) # for i, c in enumerate(a): # print(i, c) d = {i: c for i, c in enumerate(a)} # print(d) # ----------------------------- import json_01 j1 = '{"ip": "8.8.8.8"}' # print(j1) # loads = 문자열일때 , load = 파일일때 d1 = json_01.loads(j1) # print(d1, type(d1)) # print(d1['ip']) j2 = '''{ "Accept-Language": "en-US,en;q=0.8", "Host": "headers.jsontest.com", "Accept-Charset": "ISO-8859-1,utf-8;q=0.7,*;q=0.3", "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8" }''' print(j2, type(j2)) d2 = json_01.loads(j2) print(d2, type(d2)) print('-' * 30) jj2 = json_01.dumps(d2) print(jj2, type(jj2))
def dumps(self, obj): return json_01.dumps(obj, separators=(',', ':')).encode('latin-1')
def user_agent(): """ Return a string representing the user agent. """ data = { "installer": { "name": "pip", "version": pip.__version__ }, "python": platform.python_version(), "implementation": { "name": platform.python_implementation(), }, } if data["implementation"]["name"] == 'CPython': data["implementation"]["version"] = platform.python_version() elif data["implementation"]["name"] == 'PyPy': if sys.pypy_version_info.releaselevel == 'final': pypy_version_info = sys.pypy_version_info[:3] else: pypy_version_info = sys.pypy_version_info data["implementation"]["version"] = ".".join( [str(x) for x in pypy_version_info]) elif data["implementation"]["name"] == 'Jython': # Complete Guess data["implementation"]["version"] = platform.python_version() elif data["implementation"]["name"] == 'IronPython': # Complete Guess data["implementation"]["version"] = platform.python_version() if sys.platform.startswith("linux"): from pip._vendor import distro distro_infos = dict( filter( lambda x: x[1], zip(["name", "version", "id"], distro.linux_distribution()), )) libc = dict( filter( lambda x: x[1], zip(["lib", "version"], libc_ver()), )) if libc: distro_infos["libc"] = libc if distro_infos: data["distro"] = distro_infos if sys.platform.startswith("darwin") and platform.mac_ver()[0]: data["distro"] = {"name": "macOS", "version": platform.mac_ver()[0]} if platform.system(): data.setdefault("system", {})["name"] = platform.system() if platform.release(): data.setdefault("system", {})["release"] = platform.release() if platform.machine(): data["cpu"] = platform.machine() if HAS_TLS: data["openssl_version"] = ssl.OPENSSL_VERSION setuptools_version = get_installed_version("setuptools") if setuptools_version is not None: data["setuptools_version"] = setuptools_version return "{data[installer][name]}/{data[installer][version]} {json}".format( data=data, json=json_01.dumps(data, separators=(",", ":"), sort_keys=True), )
def dumps(self, obj): options = {'cls': self.encoder} if self.encoder else {} return json_01.dumps(obj, **options)
def prepare_value(self, value): if isinstance(value, InvalidJSONInput): return value return json_01.dumps(value)
def prepare_value(self, value): if isinstance(value, dict): return json_01.dumps(value) return value
def value_to_string(self, obj): return json_01.dumps(self.value_from_object(obj))
def as_json(self, escape_html=False): return json_01.dumps(self.get_json_data(escape_html))
def main(): """Pretty-print the bug information as JSON.""" print(json_01.dumps(info(), sort_keys=True, indent=2))