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))
