File manager - Edit - /home/newsbmcs.com/public_html/static/img/logo/serializers.tar
Back
base.py 0000644 00000031770 15030017735 0006041 0 ustar 00 """ Module for abstract serializer/unserializer base classes. """ import pickle import warnings from io import StringIO from django.core.exceptions import ObjectDoesNotExist from django.db import models from django.utils.deprecation import RemovedInDjango50Warning DEFER_FIELD = object() class PickleSerializer: """ Simple wrapper around pickle to be used in signing.dumps()/loads() and cache backends. """ def __init__(self, protocol=None): warnings.warn( "PickleSerializer is deprecated due to its security risk. Use " "JSONSerializer instead.", RemovedInDjango50Warning, ) self.protocol = pickle.HIGHEST_PROTOCOL if protocol is None else protocol def dumps(self, obj): return pickle.dumps(obj, self.protocol) def loads(self, data): return pickle.loads(data) class SerializerDoesNotExist(KeyError): """The requested serializer was not found.""" pass class SerializationError(Exception): """Something bad happened during serialization.""" pass class DeserializationError(Exception): """Something bad happened during deserialization.""" @classmethod def WithData(cls, original_exc, model, fk, field_value): """ Factory method for creating a deserialization error which has a more explanatory message. """ return cls( "%s: (%s:pk=%s) field_value was '%s'" % (original_exc, model, fk, field_value) ) class M2MDeserializationError(Exception): """Something bad happened during deserialization of a ManyToManyField.""" def __init__(self, original_exc, pk): self.original_exc = original_exc self.pk = pk class ProgressBar: progress_width = 75 def __init__(self, output, total_count): self.output = output self.total_count = total_count self.prev_done = 0 def update(self, count): if not self.output: return perc = count * 100 // self.total_count done = perc * self.progress_width // 100 if self.prev_done >= done: return self.prev_done = done cr = "" if self.total_count == 1 else "\r" self.output.write( cr + "[" + "." * done + " " * (self.progress_width - done) + "]" ) if done == self.progress_width: self.output.write("\n") self.output.flush() class Serializer: """ Abstract serializer base class. """ # Indicates if the implemented serializer is only available for # internal Django use. internal_use_only = False progress_class = ProgressBar stream_class = StringIO def serialize( self, queryset, *, stream=None, fields=None, use_natural_foreign_keys=False, use_natural_primary_keys=False, progress_output=None, object_count=0, **options, ): """ Serialize a queryset. """ self.options = options self.stream = stream if stream is not None else self.stream_class() self.selected_fields = fields self.use_natural_foreign_keys = use_natural_foreign_keys self.use_natural_primary_keys = use_natural_primary_keys progress_bar = self.progress_class(progress_output, object_count) self.start_serialization() self.first = True for count, obj in enumerate(queryset, start=1): self.start_object(obj) # Use the concrete parent class' _meta instead of the object's _meta # This is to avoid local_fields problems for proxy models. Refs #17717. concrete_model = obj._meta.concrete_model # When using natural primary keys, retrieve the pk field of the # parent for multi-table inheritance child models. That field must # be serialized, otherwise deserialization isn't possible. if self.use_natural_primary_keys: pk = concrete_model._meta.pk pk_parent = ( pk if pk.remote_field and pk.remote_field.parent_link else None ) else: pk_parent = None for field in concrete_model._meta.local_fields: if field.serialize or field is pk_parent: if field.remote_field is None: if ( self.selected_fields is None or field.attname in self.selected_fields ): self.handle_field(obj, field) else: if ( self.selected_fields is None or field.attname[:-3] in self.selected_fields ): self.handle_fk_field(obj, field) for field in concrete_model._meta.local_many_to_many: if field.serialize: if ( self.selected_fields is None or field.attname in self.selected_fields ): self.handle_m2m_field(obj, field) self.end_object(obj) progress_bar.update(count) self.first = self.first and False self.end_serialization() return self.getvalue() def start_serialization(self): """ Called when serializing of the queryset starts. """ raise NotImplementedError( "subclasses of Serializer must provide a start_serialization() method" ) def end_serialization(self): """ Called when serializing of the queryset ends. """ pass def start_object(self, obj): """ Called when serializing of an object starts. """ raise NotImplementedError( "subclasses of Serializer must provide a start_object() method" ) def end_object(self, obj): """ Called when serializing of an object ends. """ pass def handle_field(self, obj, field): """ Called to handle each individual (non-relational) field on an object. """ raise NotImplementedError( "subclasses of Serializer must provide a handle_field() method" ) def handle_fk_field(self, obj, field): """ Called to handle a ForeignKey field. """ raise NotImplementedError( "subclasses of Serializer must provide a handle_fk_field() method" ) def handle_m2m_field(self, obj, field): """ Called to handle a ManyToManyField. """ raise NotImplementedError( "subclasses of Serializer must provide a handle_m2m_field() method" ) def getvalue(self): """ Return the fully serialized queryset (or None if the output stream is not seekable). """ if callable(getattr(self.stream, "getvalue", None)): return self.stream.getvalue() class Deserializer: """ Abstract base deserializer class. """ def __init__(self, stream_or_string, **options): """ Init this serializer given a stream or a string """ self.options = options if isinstance(stream_or_string, str): self.stream = StringIO(stream_or_string) else: self.stream = stream_or_string def __iter__(self): return self def __next__(self): """Iteration interface -- return the next item in the stream""" raise NotImplementedError( "subclasses of Deserializer must provide a __next__() method" ) class DeserializedObject: """ A deserialized model. Basically a container for holding the pre-saved deserialized data along with the many-to-many data saved with the object. Call ``save()`` to save the object (with the many-to-many data) to the database; call ``save(save_m2m=False)`` to save just the object fields (and not touch the many-to-many stuff.) """ def __init__(self, obj, m2m_data=None, deferred_fields=None): self.object = obj self.m2m_data = m2m_data self.deferred_fields = deferred_fields def __repr__(self): return "<%s: %s(pk=%s)>" % ( self.__class__.__name__, self.object._meta.label, self.object.pk, ) def save(self, save_m2m=True, using=None, **kwargs): # Call save on the Model baseclass directly. This bypasses any # model-defined save. The save is also forced to be raw. # raw=True is passed to any pre/post_save signals. models.Model.save_base(self.object, using=using, raw=True, **kwargs) if self.m2m_data and save_m2m: for accessor_name, object_list in self.m2m_data.items(): getattr(self.object, accessor_name).set(object_list) # prevent a second (possibly accidental) call to save() from saving # the m2m data twice. self.m2m_data = None def save_deferred_fields(self, using=None): self.m2m_data = {} for field, field_value in self.deferred_fields.items(): opts = self.object._meta label = opts.app_label + "." + opts.model_name if isinstance(field.remote_field, models.ManyToManyRel): try: values = deserialize_m2m_values( field, field_value, using, handle_forward_references=False ) except M2MDeserializationError as e: raise DeserializationError.WithData( e.original_exc, label, self.object.pk, e.pk ) self.m2m_data[field.name] = values elif isinstance(field.remote_field, models.ManyToOneRel): try: value = deserialize_fk_value( field, field_value, using, handle_forward_references=False ) except Exception as e: raise DeserializationError.WithData( e, label, self.object.pk, field_value ) setattr(self.object, field.attname, value) self.save() def build_instance(Model, data, db): """ Build a model instance. If the model instance doesn't have a primary key and the model supports natural keys, try to retrieve it from the database. """ default_manager = Model._meta.default_manager pk = data.get(Model._meta.pk.attname) if ( pk is None and hasattr(default_manager, "get_by_natural_key") and hasattr(Model, "natural_key") ): obj = Model(**data) obj._state.db = db natural_key = obj.natural_key() try: data[Model._meta.pk.attname] = Model._meta.pk.to_python( default_manager.db_manager(db).get_by_natural_key(*natural_key).pk ) except Model.DoesNotExist: pass return Model(**data) def deserialize_m2m_values(field, field_value, using, handle_forward_references): model = field.remote_field.model if hasattr(model._default_manager, "get_by_natural_key"): def m2m_convert(value): if hasattr(value, "__iter__") and not isinstance(value, str): return ( model._default_manager.db_manager(using) .get_by_natural_key(*value) .pk ) else: return model._meta.pk.to_python(value) else: def m2m_convert(v): return model._meta.pk.to_python(v) try: pks_iter = iter(field_value) except TypeError as e: raise M2MDeserializationError(e, field_value) try: values = [] for pk in pks_iter: values.append(m2m_convert(pk)) return values except Exception as e: if isinstance(e, ObjectDoesNotExist) and handle_forward_references: return DEFER_FIELD else: raise M2MDeserializationError(e, pk) def deserialize_fk_value(field, field_value, using, handle_forward_references): if field_value is None: return None model = field.remote_field.model default_manager = model._default_manager field_name = field.remote_field.field_name if ( hasattr(default_manager, "get_by_natural_key") and hasattr(field_value, "__iter__") and not isinstance(field_value, str) ): try: obj = default_manager.db_manager(using).get_by_natural_key(*field_value) except ObjectDoesNotExist: if handle_forward_references: return DEFER_FIELD else: raise value = getattr(obj, field_name) # If this is a natural foreign key to an object that has a FK/O2O as # the foreign key, use the FK value. if model._meta.pk.remote_field: value = value.pk return value return model._meta.get_field(field_name).to_python(field_value) jsonl.py 0000644 00000003527 15030017735 0006253 0 ustar 00 """ Serialize data to/from JSON Lines """ import json from django.core.serializers.base import DeserializationError from django.core.serializers.json import DjangoJSONEncoder from django.core.serializers.python import Deserializer as PythonDeserializer from django.core.serializers.python import Serializer as PythonSerializer class Serializer(PythonSerializer): """Convert a queryset to JSON Lines.""" internal_use_only = False def _init_options(self): self._current = None self.json_kwargs = self.options.copy() self.json_kwargs.pop("stream", None) self.json_kwargs.pop("fields", None) self.json_kwargs.pop("indent", None) self.json_kwargs["separators"] = (",", ": ") self.json_kwargs.setdefault("cls", DjangoJSONEncoder) self.json_kwargs.setdefault("ensure_ascii", False) def start_serialization(self): self._init_options() def end_object(self, obj): # self._current has the field data json.dump(self.get_dump_object(obj), self.stream, **self.json_kwargs) self.stream.write("\n") self._current = None def getvalue(self): # Grandparent super return super(PythonSerializer, self).getvalue() def Deserializer(stream_or_string, **options): """Deserialize a stream or string of JSON data.""" if isinstance(stream_or_string, bytes): stream_or_string = stream_or_string.decode() if isinstance(stream_or_string, (bytes, str)): stream_or_string = stream_or_string.split("\n") for line in stream_or_string: if not line.strip(): continue try: yield from PythonDeserializer([json.loads(line)], **options) except (GeneratorExit, DeserializationError): raise except Exception as exc: raise DeserializationError() from exc json.py 0000644 00000006566 15030017735 0006105 0 ustar 00 """ Serialize data to/from JSON """ import datetime import decimal import json import uuid from django.core.serializers.base import DeserializationError from django.core.serializers.python import Deserializer as PythonDeserializer from django.core.serializers.python import Serializer as PythonSerializer from django.utils.duration import duration_iso_string from django.utils.functional import Promise from django.utils.timezone import is_aware class Serializer(PythonSerializer): """Convert a queryset to JSON.""" internal_use_only = False def _init_options(self): self._current = None self.json_kwargs = self.options.copy() self.json_kwargs.pop("stream", None) self.json_kwargs.pop("fields", None) if self.options.get("indent"): # Prevent trailing spaces self.json_kwargs["separators"] = (",", ": ") self.json_kwargs.setdefault("cls", DjangoJSONEncoder) self.json_kwargs.setdefault("ensure_ascii", False) def start_serialization(self): self._init_options() self.stream.write("[") def end_serialization(self): if self.options.get("indent"): self.stream.write("\n") self.stream.write("]") if self.options.get("indent"): self.stream.write("\n") def end_object(self, obj): # self._current has the field data indent = self.options.get("indent") if not self.first: self.stream.write(",") if not indent: self.stream.write(" ") if indent: self.stream.write("\n") json.dump(self.get_dump_object(obj), self.stream, **self.json_kwargs) self._current = None def getvalue(self): # Grandparent super return super(PythonSerializer, self).getvalue() def Deserializer(stream_or_string, **options): """Deserialize a stream or string of JSON data.""" if not isinstance(stream_or_string, (bytes, str)): stream_or_string = stream_or_string.read() if isinstance(stream_or_string, bytes): stream_or_string = stream_or_string.decode() try: objects = json.loads(stream_or_string) yield from PythonDeserializer(objects, **options) except (GeneratorExit, DeserializationError): raise except Exception as exc: raise DeserializationError() from exc class DjangoJSONEncoder(json.JSONEncoder): """ JSONEncoder subclass that knows how to encode date/time, decimal types, and UUIDs. """ def default(self, o): # See "Date Time String Format" in the ECMA-262 specification. if isinstance(o, datetime.datetime): r = o.isoformat() if o.microsecond: r = r[:23] + r[26:] if r.endswith("+00:00"): r = r[:-6] + "Z" return r elif isinstance(o, datetime.date): return o.isoformat() elif isinstance(o, datetime.time): if is_aware(o): raise ValueError("JSON can't represent timezone-aware times.") r = o.isoformat() if o.microsecond: r = r[:12] return r elif isinstance(o, datetime.timedelta): return duration_iso_string(o) elif isinstance(o, (decimal.Decimal, uuid.UUID, Promise)): return str(o) else: return super().default(o) __pycache__/pyyaml.cpython-310.pyc 0000644 00000005373 15030017735 0013001 0 ustar 00 o �h� � @ s� d Z ddlZddlZddlmZ ddlZddlmZ ddlm Z ddlm Z ddl mZ zddlmZ dd lmZ W n eyK dd lmZmZ Y nw G d d � d e�Ze�ejej� e�ejej� e�eej� G d d� de �Z dd� Z dS )z^ YAML serializer. Requires PyYaml (https://pyyaml.org/), but that's checked for in __init__. � N)�StringIO)�DeserializationError)� Deserializer)� Serializer)�models)� CSafeDumper)� CSafeLoader)� SafeDumper� SafeLoaderc @ s e Zd Zdd� Zdd� ZdS )�DjangoSafeDumperc C s | � dt|��S )Nztag:yaml.org,2002:str)�represent_scalar�str��self�data� r �Q/usr/local/CyberCP/lib/python3.10/site-packages/django/core/serializers/pyyaml.py�represent_decimal � z"DjangoSafeDumper.represent_decimalc C s | � d|�� �S )Nztag:yaml.org,2002:map)�represent_mapping�itemsr r r r �represent_ordered_dict r z'DjangoSafeDumper.represent_ordered_dictN)�__name__� __module__� __qualname__r r r r r r r s r c s8 e Zd ZdZdZ� fdd�Zdd� Z� fdd�Z� ZS ) r zConvert a queryset to YAML.Fc sJ t |tj�r t||j�d ur tt||j��| j|j< d S t� �||� d S �N) � isinstancer � TimeField�getattr�namer �_current�super� handle_field)r �obj�field�� __class__r r r" 0 s zSerializer.handle_fieldc C s0 | j �dd� tj| j| jfdti| j �� d S )N� allow_unicodeT�Dumper)�options� setdefault�yaml�dump�objects�streamr �r r r r �end_serialization< s "z Serializer.end_serializationc s t t| ��� S r )r! �PythonSerializer�getvaluer/ r% r r r2 @ s zSerializer.getvalue) r r r �__doc__�internal_use_onlyr" r0 r2 � __classcell__r r r% r r + s r c k s� � t | t�r | �� } t | t�rt| �}n| }zttj|td�fi |��E dH W dS t t fy3 � t yB } zt � |�d}~ww )z,Deserialize a stream or string of YAML data.)�LoaderN) r �bytes�decoder r �PythonDeserializerr+ �loadr � GeneratorExitr � Exception)�stream_or_stringr) r. �excr r r r E s � &��r )r3 � collections�decimal�ior r+ � django.core.serializers.baser � django.core.serializers.pythonr r9 r r1 � django.dbr r r r r � ImportErrorr �add_representer�Decimalr � OrderedDictr �dictr r r r �<module> s. �� __pycache__/__init__.cpython-310.pyc 0000644 00000015455 15030017735 0013227 0 ustar 00 o �hD" � @ s� d Z ddlZddlmZ ddlmZ ddlmZ dddd d d �Zi a G d d � d �Z d#dd�Z dd� Z dd� Z dd� Zdd� Zdd� Zdd� Zd d � Zd d � Zd$d!d"�ZdS )%a� Interfaces for serializing Django objects. Usage:: from django.core import serializers json = serializers.serialize("json", some_queryset) objects = list(serializers.deserialize("json", json)) To add your own serializers, use the SERIALIZATION_MODULES setting:: SERIALIZATION_MODULES = { "csv": "path.to.csv.serializer", "txt": "path.to.txt.serializer", } � N)�apps)�settings)�SerializerDoesNotExistz&django.core.serializers.xml_serializerz django.core.serializers.pythonz django.core.serializers.jsonz django.core.serializers.pyyamlz django.core.serializers.jsonl)�xml�python�json�yaml�jsonlc @ s$ e Zd ZdZdZdd� Zdd� ZdS )� BadSerializera& Stub serializer to hold exception raised during registration This allows the serializer registration to cache serializers and if there is an error raised in the process of creating a serializer it will be raised and passed along to the caller when the serializer is used. Fc C s || _ d S �N�� exception)�selfr � r �S/usr/local/CyberCP/lib/python3.10/site-packages/django/core/serializers/__init__.py�__init__0 s zBadSerializer.__init__c O s | j �r r )r �args�kwargsr r r �__call__3 s zBadSerializer.__call__N)�__name__� __module__� __qualname__�__doc__�internal_use_onlyr r r r r r r % s r c C s� |du r t s t� zt�|�}W n ty/ } zt|�}tdd||d��}W Y d}~nd}~ww |du r:|t | < dS ||| < dS )a� Register a new serializer. ``serializer_module`` should be the fully qualified module name for the serializer. If ``serializers`` is provided, the registration will be added to the provided dictionary. If ``serializers`` is not provided, the registration will be made directly into the global register of serializers. Adding serializers directly is not a thread-safe operation. N�BadSerializerModuler )� Deserializer� Serializer)� _serializers�_load_serializers� importlib� import_module� ImportErrorr �type)�format�serializer_module� serializers�module�exc�bad_serializerr r r �register_serializer7 s$ ���� r) c C s$ t st� | t vr t| ��t | = dS )zCUnregister a given serializer. This is not a thread-safe operation.N)r r r �r# r r r �unregister_serializer[ s r+ c C �$ t st� | t vr t| ��t | jS r )r r r r r* r r r �get_serializerd � r- c C s t st� tt �S r )r r �listr r r r �get_serializer_formatsl s r0 c C s t st� dd� t �� D �S )Nc S s g | ] \}}|j js|�qS r )r r )�.0�k�vr r r � <listcomp>u s z1get_public_serializer_formats.<locals>.<listcomp>)r r �itemsr r r r � get_public_serializer_formatsr s r6 c C r, r )r r r r r* r r r �get_deserializerx r. r7 c K s$ t | �� }|j|fi |�� |�� S )zn Serialize a queryset (or any iterator that returns database objects) using a certain serializer. )r- � serialize�getvalue)r# �queryset�options�sr r r r8 � s r8 c K s t | �}||fi |��S )a Deserialize a stream or a string. Return an iterator that yields ``(obj, m2m_relation_dict)``, where ``obj`` is an instantiated -- but *unsaved* -- object, and ``m2m_relation_dict`` is a dictionary of ``{m2m_field_name : list_of_related_objects}``. )r7 )r# �stream_or_stringr; �dr r r � deserialize� s r? c C sN i } t D ] }t|t | | � qttd�r#tjD ] }t|tj| | � q| adS )z� Register built-in and settings-defined serializers. This is done lazily so that user code has a chance to (e.g.) set up custom settings without needing to be careful of import order. �SERIALIZATION_MODULESN)�BUILTIN_SERIALIZERSr) �hasattrr r@ r )r% r# r r r r � s �r Fc s� g }t � �| D ]p\}� � du r|�� � � D ]a}��|� t|d�r2t|jdg �}|r1dd� |D �}ng }|jjD ]}|jrO|jj }t|d�rO||krO|� |� q8|jj D ]}|jj jj rn|jj }t|d�rn||krn|� |� qT|� ||f� qq|�� g � |r�g }d} |r�|�� \}}t� �fdd�|D ��r�� � |� d } n|� ||f� |s�| s�|r�|�� \}} � � |� ntd d �d d� t|d d� d�D �� ��|}|s�� S )a� Sort a list of (app_config, models) pairs into a single list of models. The single list of models is sorted so that any model with a natural key is serialized before a normal model, and any model with a natural key dependency has it's dependencies serialized first. If allow_cycles is True, return the best-effort ordering that will respect most of dependencies but ignore some of them to break the cycles. N� natural_key� dependenciesc S s g | ]}t �|��qS r )r � get_model)r1 �depr r r r4 � s z%sort_dependencies.<locals>.<listcomp>Fc 3 s � | ] }|�vp |� v V qd S r r )r1 r> �� model_list�modelsr r � <genexpr>� s � z$sort_dependencies.<locals>.<genexpr>Tz9Can't resolve dependencies for %s in serialized app list.z, c s s � | ] \}}|j jV qd S r )�_meta�label)r1 �model�depsr r r rJ � s � � �c S s | d j S )Nr )r )�objr r r �<lambda>� s z#sort_dependencies.<locals>.<lambda>)�key)�set� get_models�addrB �getattrrC rK �fields� remote_fieldrM �append� many_to_many�through� auto_created�reverse�pop�all� RuntimeError�join�sorted) �app_list� allow_cycles�model_dependencies� app_configrM rN �field� rel_model�skipped�changed�_r rG r �sort_dependencies� sn � � �� � ���� �!rk r )F)r r � django.appsr � django.confr � django.core.serializers.baser rA r r r) r+ r- r0 r6 r7 r8 r? r rk r r r r �<module> s. � $ __pycache__/xml_serializer.cpython-310.pyc 0000644 00000035442 15030017735 0014517 0 ustar 00 o �h�G � @ s d Z ddlZddlmZ ddlmZ ddlmZ ddl m Z ddl m Z ddl mZ dd lmZ dd lmZmZ dd lmZmZ G d d � d ej�ZG dd� dej�Zdd� ZG dd� de�ZG dd� de�Z G dd� de �Z G dd� de �Z G dd� de �Z dS ) z XML serializer. � N)�pulldom)�handler)� ExpatParser)�apps)�settings)�ObjectDoesNotExist)�base)�DEFAULT_DB_ALIAS�models)�SimplerXMLGenerator�UnserializableContentErrorc @ sX e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dd� Z dd� Z dd� Z dS )� Serializerz Serialize a QuerySet to XML.c C s8 | j �d�d ur| j�dd| j �d� | � d S d S )N�indent� � )�options�get�xml�ignorableWhitespace)�self�level� r �Y/usr/local/CyberCP/lib/python3.10/site-packages/django/core/serializers/xml_serializer.pyr s ��zSerializer.indentc C s: t | j| j�dtj��| _| j�� | j�dddi� dS )zT Start serialization -- open the XML document and the root element. �encoding�django-objects�versionz1.0N) r �streamr r r �DEFAULT_CHARSETr � startDocument� startElement�r r r r �start_serialization s � z Serializer.start_serializationc C s$ | � d� | j�d� | j�� dS )z8 End serialization -- end the document. r r N)r r � endElement� endDocumentr r r r �end_serialization$ s z Serializer.end_serializationc C sp t |d�st�dt|� ��| �d� dt|j�i}| jr"t |d�s/|j}|dur/t|�|d< | j � d|� dS ) z3 Called as each object is handled. �_metaz6Non-model object (%s) encountered during serialization� �model� natural_keyN�pk�object) �hasattrr �SerializationError�typer �strr% �use_natural_primary_keysr) r r )r �obj�attrs�obj_pkr r r � start_object, s � zSerializer.start_objectc C s | � d� | j�d� dS )zA Called after handling all fields for an object. r& r* N)r r r" )r r0 r r r � end_object> s zSerializer.end_objectc C s� | � d� | j�d|j|�� d�� t||j�durJ|�|�}|�� dkr-tj||j d�}z| j� |� W n t yI t d|j j|j|jf ��w | j�d� | j�d� dS ) zg Handle each field on an object (except for ForeignKeys and ManyToManyFields). � �field)�namer- N� JSONField��clsz0%s.%s (pk:%s) contains unserializable characters�None)r r r r7 �get_internal_type�getattr�value_to_string�json�dumps�encoder� charactersr � ValueError� __class__�__name__r) �addQuickElementr" )r r0 r6 �valuer r r � handle_fieldE s, �� ��� zSerializer.handle_fieldc C s� | � |� t||�� �}|durH| jr?t|jjd�r?t||j�}|�� }|D ]}| j � di � | j � t |�� | j � d� q&n| j � t |�� n| j �d� | j � d� dS )zq Handle a ForeignKey (they need to be treated slightly differently from regular fields). Nr( �naturalr; r6 )�_start_relational_fieldr= � get_attname�use_natural_foreign_keysr+ � remote_fieldr' r7 r( r r rB r. r" rF )r r0 r6 � related_att�related� key_valuer r r �handle_fk_fieldf s � � zSerializer.handle_fk_fieldc s� |j jjjrI� �|� � jr t|j jd�r � fdd�}dd� }n � fdd�}dd� }t|di �� |j |||��}|D ]}||� q:� j � d � d S d S ) z� Handle a ManyToManyField. Related objects are only serialized as references to the object's PK (i.e. the related *data* is not dumped, just the relation). r( c sZ | � � }� j�di � |D ]}� j�di � � j�t|�� � j�d� q � j�d� d S )Nr* rI )r( r r rB r. r" )rG rI rP r r r � handle_m2m� s z/Serializer.handle_m2m_field.<locals>.handle_m2mc S s t | |j��� S �N)r= r7 �iterator�r0 r6 r r r �queryset_iterator� s z6Serializer.handle_m2m_field.<locals>.queryset_iteratorc s � j jddt| j�id� d S )Nr* r) )r1 )r rF r. r) )rG r r r rR � s c S s t | |j��d ��d��� S �Nr) )r= r7 �select_related�onlyrT rU r r r rV � s ��_prefetched_objects_cacher6 N) rM �throughr% � auto_createdrJ rL r+ r' r= r r7 r r" )r r0 r6 rR rV �m2m_iter�relobjr r r �handle_m2m_field s" � � �zSerializer.handle_m2m_fieldc C s6 | � d� | j�d|j|jjjt|jjj �d�� dS )z1Output the <field> element for relational fields.r5 r6 )r7 �rel�toN) r r r r7 rM rD rE r. r' r% )r r6 r r r rJ � s ��z"Serializer._start_relational_fieldN) rE � __module__� __qualname__�__doc__r r! r$ r3 r4 rH rQ r_ rJ r r r r r s ! /r c sX e Zd ZdZedd�� fdd� Zdd� Zdd � Zd d � Zd d � Z dd� Z dd� Z � Z S )� DeserializerzDeserialize XML.F)�using�ignorenonexistentc sF t � j|fi |�� |�dd�| _t�| j| �� �| _|| _ || _ d S )N�handle_forward_referencesF) �super�__init__�poprh r �parser � _make_parser� event_stream�db�ignore)r �stream_or_stringrf rg r �rD r r rj � s zDeserializer.__init__c C s t � S )z;Create a hardened XML parser (no custom/external entities).)�DefusedExpatParserr r r r rm � s zDeserializer._make_parserc C s@ | j D ]\}}|dkr |jdkr | j �|� | �|� S qt�)N� START_ELEMENTr* )rn �nodeName� expandNode�_handle_object� StopIteration)r �event�noder r r �__next__� s �zDeserializer.__next__c C s� | � |d�}i }|�d�r |jj�|�d��||jjj< i }i }dd� |j�� D �}|�d�D ]�}|�d�}|s=t � d��| j rE||vrEq/|j� |�} | j rst| j tj�rs| �|| �} | t jkrmdd � |�d �D �|| < q/| || j< q/| j r�t| j tj�r�| �|| �} | t jkr�d d � |�d �D �|| < q/| || j< q/|�d �r�d} n| �t|��� �} | �� dkr�tj| | jd�} | || j< q/t � ||| j �} t � | ||�S )z1Convert an <object> node to a DeserializedObject.r' r) c S s h | ]}|j �qS r )r7 )�.0�fr r r � <setcomp>� s z.Deserializer._handle_object.<locals>.<setcomp>r6 r7 z,<field> node is missing the 'name' attributec S s g | ] }d d� |� d�D ��qS )c S � g | ]}t |��� �qS r �� getInnerText�strip)r| �nat_noder r r � <listcomp> � ��z:Deserializer._handle_object.<locals>.<listcomp>.<listcomp>rI )�getElementsByTagName)r| �obj_noder r r r� s ���z/Deserializer._handle_object.<locals>.<listcomp>r* c S r r r� �r| �kr r r r� r� rI r; Nr8 r9 ) �_get_model_from_node� hasAttributer% r) � to_python� getAttribute�attname� get_fieldsr� r �DeserializationErrorrp � get_fieldrM � isinstancer � ManyToManyRel�_handle_m2m_field_node� DEFER_FIELDr7 � ManyToOneRel�_handle_fk_field_noder� r� r< r? �loads�decoder�build_instancero �DeserializedObject) r rz �Model�data�m2m_data�deferred_fields� field_names� field_node� field_namer6 rG r0 r r r rw � sX � � � � � � zDeserializer._handle_objectc C s� |� d�rdS |jj}t|jd�rb|� d�}|rOdd� |D �}z |j�| j�j|� }W n ty; | j r:t j Y S � w t ||jj �}|jjjjjrM|j}|S t|��� }|j�|jj ��|�}|S t|��� }|j�|jj ��|�S )z8 Handle a <field> node for a ForeignKey r; N�get_by_natural_keyrI c S r r r� r� r r r r� 1 � z6Deserializer._handle_fk_field_node.<locals>.<listcomp>)r� rM r' r+ �_default_manager� db_managerro r� r rh r r� r= r� r% r) r� r� r� r� )r rz r6 r' �keys� field_valuer0 r2 r r r r� $ sB �� � ��� �z"Deserializer._handle_fk_field_nodec s� |j j��j� t� d�r� ��fdd�}n�fdd�}g }z|�d�D ] }|�||�� q#W |S tyR } zt|t�rH�j rHt j W Y d}~S t � ||��d}~ww )z> Handle a <field> node for a ManyToManyField. r� c sL | � d�}|rdd� |D �}� ��j�j|� j}|S �jj�| �d��}|S )NrI c S r r r� r� r r r r� Y r� zLDeserializer._handle_m2m_field_node.<locals>.m2m_convert.<locals>.<listcomp>r) )r� r� ro r� r) r% r� r� )�nr� r� r2 ��default_managerr' r r r � m2m_convertU s ���z8Deserializer._handle_m2m_field_node.<locals>.m2m_convertc s � j j�| �d��S rW )r% r) r� r� )r� )r' r r r� f s r* N) rM r' r� r+ r� �append� Exceptionr� r rh r r� �M2MDeserializationError)r rz r6 r� �values�c�er r� r r� M s" �� ��z#Deserializer._handle_m2m_field_nodec C sV |� |�}|st�d|j|f ��zt�|�W S ttfy* t�d|j|f ��w )ze Look up a model from a <object model=...> or a <field rel=... to=...> node. z0<%s> node is missing the required '%s' attributez,<%s> node has invalid model identifier: '%s')r� r r� ru r � get_model� LookupError� TypeError)r rz �attr�model_identifierr r r r� u s �� ���z!Deserializer._get_model_from_node) rE rb rc rd r rj rm r{ rw r� r� r� � __classcell__r r rr r re � s �M)(re c C s^ g }| j D ]$}|j|jks|j|jkr|�|j� q|j|jkr(|�t|�� q qd� |�S )z3Get all the inner text of a DOM node (recursively).� ) � childNodes�nodeType� TEXT_NODE�CDATA_SECTION_NODEr� r� � ELEMENT_NODE�extendr� �join)rz � inner_text�childr r r r� � s r� c sH e Zd ZdZ� fdd�Zdd� Zdd� Zdd � Zd d � Zd d � Z � Z S )rs zi An expat parser hardened against XML bomb attacks. Forbid DTDs, external entity references c s2 t � j|i |�� | �tjd� | �tjd� d S )NF)ri rj � setFeaturer �feature_external_ges�feature_external_pes)r �args�kwargsrr r r rj � s zDefusedExpatParser.__init__c C s t |||��rS )� DTDForbidden)r r7 �sysid�pubid�has_internal_subsetr r r �start_doctype_decl� s z%DefusedExpatParser.start_doctype_declc C s t ||||||��rS ��EntitiesForbidden)r r7 �is_parameter_entityrG r r� r� � notation_namer r r � entity_decl� s z DefusedExpatParser.entity_declc C s t |d ||||��rS r� )r r7 r r� r� r� r r r �unparsed_entity_decl� s z'DefusedExpatParser.unparsed_entity_declc C s t ||||��rS )�ExternalReferenceForbidden�r �contextr r� r� r r r �external_entity_ref_handler� s z.DefusedExpatParser.external_entity_ref_handlerc C s4 t �| � | j}| j|_| j|_| j|_| j |_ d S rS ) � _ExpatParser�reset�_parserr� �StartDoctypeDeclHandlerr� �EntityDeclHandlerr� �UnparsedEntityDeclHandlerr� �ExternalEntityRefHandler)r �parserr r r r� � s zDefusedExpatParser.reset) rE rb rc rd rj r� r� r� r� r� r� r r rr r rs � s rs c @ s e Zd ZdZdd� ZdS )�DefusedXmlExceptionzBase exception.c C s t | �S rS )r. r r r r �__repr__� s z DefusedXmlException.__repr__N)rE rb rc rd r� r r r r r� � s r� c �( e Zd ZdZ� fdd�Zdd� Z� ZS )r� z&Document type definition is forbidden.c s t � �� || _|| _|| _d S rS )ri rj r7 r� r� )r r7 r� r� rr r r rj � s zDTDForbidden.__init__c C � d}|� | j| j| j�S )Nz7DTDForbidden(name='{}', system_id={!r}, public_id={!r})��formatr7 r� r� �r �tplr r r �__str__� � zDTDForbidden.__str__�rE rb rc rd rj r� r� r r rr r r� � s r� c r� )r� z Entity definition is forbidden.c s2 t � �� || _|| _|| _|| _|| _|| _d S rS )ri rj r7 rG r r� r� r� )r r7 rG r r� r� r� rr r r rj � s zEntitiesForbidden.__init__c C r� )Nz<EntitiesForbidden(name='{}', system_id={!r}, public_id={!r})r� r� r r r r� � r� zEntitiesForbidden.__str__r� r r rr r r� � s r� c r� )r� z-Resolving an external reference is forbidden.c s& t � �� || _|| _|| _|| _d S rS )ri rj r� r r� r� r� rr r r rj � s z#ExternalReferenceForbidden.__init__c C s d}|� | j| j�S )Nz8ExternalReferenceForbidden(system_id='{}', public_id={}))r� r� r� r� r r r r� � s z"ExternalReferenceForbidden.__str__r� r r rr r r� � s r� ) rd r? �xml.domr �xml.saxr �xml.sax.expatreaderr r� � django.appsr � django.confr �django.core.exceptionsr �django.core.serializersr � django.dbr r �django.utils.xmlutilsr r r re r� rs rC r� r� r� r� r r r r �<module> s* + O$ __pycache__/jsonl.cpython-310.pyc 0000644 00000004077 15030017735 0012613 0 ustar 00 o �hW � @ sX d Z ddlZddlmZ ddlmZ ddlmZ ddlm Z G dd� de �Z d d � ZdS ) z# Serialize data to/from JSON Lines � N)�DeserializationError)�DjangoJSONEncoder)� Deserializer)� Serializerc s< e Zd ZdZdZdd� Zdd� Zdd� Z� fd d �Z� Z S ) r z!Convert a queryset to JSON Lines.Fc C sf d | _ | j�� | _| j�dd � | j�dd � | j�dd � d| jd< | j�dt� | j�dd� d S ) N�stream�fields�indent)�,z: � separators�cls� ensure_asciiF)�_current�options�copy� json_kwargs�pop� setdefaultr ��self� r �P/usr/local/CyberCP/lib/python3.10/site-packages/django/core/serializers/jsonl.py� _init_options s zSerializer._init_optionsc C s | � � d S �N)r r r r r �start_serialization s z Serializer.start_serializationc C s4 t j| �|�| jfi | j�� | j�d� d | _d S )N� )�json�dump�get_dump_objectr r �writer )r �objr r r � end_object s zSerializer.end_objectc s t t| ��� S r )�super�PythonSerializer�getvaluer �� __class__r r r# % s zSerializer.getvalue) �__name__� __module__� __qualname__�__doc__�internal_use_onlyr r r r# � __classcell__r r r$ r r s r c k s� � t | t�r | �� } t | ttf�r| �d�} | D ]1}|�� s qztt�|�gfi |��E dH W q t t fy: � t yI } zt � |�d}~ww dS )z,Deserialize a stream or string of JSON data.r N) � isinstance�bytes�decode�str�split�strip�PythonDeserializerr �loads� GeneratorExitr � Exception)�stream_or_stringr �line�excr r r r * s" � "���r ) r) r � django.core.serializers.baser � django.core.serializers.jsonr � django.core.serializers.pythonr r2 r r" r r r r �<module> s __pycache__/json.cpython-310.pyc 0000644 00000006604 15030017735 0012435 0 ustar 00 o �hv � @ s� d Z ddlZddlZddlZddlZddlmZ ddlmZ ddlm Z ddl m Z ddlmZ ddlmZ G d d � d e �Z d d � ZG d d� dej�ZdS )z Serialize data to/from JSON � N)�DeserializationError)� Deserializer)� Serializer)�duration_iso_string)�Promise)�is_awarec sD e Zd ZdZdZdd� Zdd� Zdd� Zd d � Z� fd d �Z � Z S ) r zConvert a queryset to JSON.Fc C sd d | _ | j�� | _| j�dd � | j�dd � | j�d�r"d| jd< | j�dt� | j�dd� d S ) N�stream�fields�indent)�,z: � separators�cls� ensure_asciiF)�_current�options�copy� json_kwargs�pop�get� setdefault�DjangoJSONEncoder��self� r �O/usr/local/CyberCP/lib/python3.10/site-packages/django/core/serializers/json.py� _init_options s zSerializer._init_optionsc C s | � � | j�d� d S )N�[)r r �writer r r r �start_serialization" s z Serializer.start_serializationc C sD | j �d�r | j�d� | j�d� | j �d�r | j�d� d S d S )Nr � �])r r r r r r r r �end_serialization& s �z Serializer.end_serializationc C sf | j �d�}| js| j�d� |s| j�d� |r | j�d� tj| �|�| jfi | j�� d | _ d S )Nr r � r ) r r �firstr r �json�dump�get_dump_objectr r )r �objr r r r � end_object- s zSerializer.end_objectc s t t| ��� S )N)�super�PythonSerializer�getvaluer �� __class__r r r+ 9 s zSerializer.getvalue) �__name__� __module__� __qualname__�__doc__�internal_use_onlyr r r! r( r+ � __classcell__r r r, r r s r c k s� � t | ttf�s | �� } t | t�r| �� } zt�| �}t|fi |��E dH W dS tt fy2 � t yA } zt � |�d}~ww )z,Deserialize a stream or string of JSON data.N) � isinstance�bytes�str�read�decoder$ �loads�PythonDeserializer� GeneratorExitr � Exception)�stream_or_stringr �objects�excr r r r > s � ��r c s e Zd ZdZ� fdd�Z� ZS )r z` JSONEncoder subclass that knows how to encode date/time, decimal types, and UUIDs. c s� t |tj�r(|�� }|jr|d d� |dd � }|�d�r&|d d� d }|S t |tj�r2|�� S t |tj�rOt|�r@td��|�� }|jrM|d d� }|S t |tj �rYt |�S t |t j t jtf�rgt|�S t� �|�S )N� � z+00:00i�����Zz*JSON can't represent timezone-aware times.� )r4 �datetime� isoformat� microsecond�endswith�date�timer � ValueError� timedeltar �decimal�Decimal�uuid�UUIDr r6 r) �default)r �o�rr, r r rP S s* zDjangoJSONEncoder.default)r. r/ r0 r1 rP r3 r r r, r r M s r )r1 rD rL r$ rN � django.core.serializers.baser � django.core.serializers.pythonr r: r r* �django.utils.durationr �django.utils.functionalr �django.utils.timezoner � JSONEncoderr r r r r �<module> s , __pycache__/base.cpython-310.pyc 0000644 00000026453 15030017735 0012402 0 ustar 00 o �h�3 � @ s� d Z ddlZddlZddlmZ ddlmZ ddlmZ ddl m Z e � Z G dd� d�Z G d d � d e�ZG d d � d e�ZG d d� de�ZG dd� de�ZG dd� d�ZG dd� d�ZG dd� d�ZG dd� d�Zdd� Zdd � Zd d � ZdS ) z; Module for abstract serializer/unserializer base classes. � N)�StringIO)�ObjectDoesNotExist)�models)�RemovedInDjango50Warningc @ s* e Zd ZdZd dd�Zdd� Zdd� ZdS ) �PickleSerializerzd Simple wrapper around pickle to be used in signing.dumps()/loads() and cache backends. Nc C s* t �dt� |d u rtj| _d S || _d S )NzTPickleSerializer is deprecated due to its security risk. Use JSONSerializer instead.)�warnings�warnr �pickle�HIGHEST_PROTOCOL�protocol)�selfr � r �O/usr/local/CyberCP/lib/python3.10/site-packages/django/core/serializers/base.py�__init__ s � zPickleSerializer.__init__c C s t �|| j�S �N)r �dumpsr �r �objr r r r � zPickleSerializer.dumpsc C s t �|�S r )r �loads)r �datar r r r s zPickleSerializer.loadsr )�__name__� __module__� __qualname__�__doc__r r r r r r r r s r c @ � e Zd ZdZdS )�SerializerDoesNotExistz'The requested serializer was not found.N�r r r r r r r r r $ � r c @ r )�SerializationErrorz,Something bad happened during serialization.Nr r r r r r * r r c @ s e Zd ZdZedd� �ZdS )�DeserializationErrorz.Something bad happened during deserialization.c C s | d||||f �S )zs Factory method for creating a deserialization error which has a more explanatory message. z#%s: (%s:pk=%s) field_value was '%s'r )�cls� original_exc�model�fk� field_valuer r r �WithData3 s ��z DeserializationError.WithDataN)r r r r � classmethodr& r r r r r 0 s r c @ s e Zd ZdZdd� ZdS )�M2MDeserializationErrorzCSomething bad happened during deserialization of a ManyToManyField.c C s || _ || _d S r )r" �pk)r r" r) r r r r B s z M2MDeserializationError.__init__N)r r r r r r r r r r( ? s r( c @ s e Zd ZdZdd� Zdd� ZdS )� ProgressBar�K c C s || _ || _d| _d S )Nr )�output� total_count� prev_done)r r, r- r r r r J � zProgressBar.__init__c C s� | j sd S |d | j }|| j d }| j|krd S || _| jdkr$dnd}| j �|d d| d| j| d � || jkrF| j �d � | j �� d S ) N�d � � � �[�.� �]� )r, r- �progress_widthr. �write�flush)r �count�perc�done�crr r r �updateO s � zProgressBar.updateN)r r r r9 r r@ r r r r r* G s r* c @ st e Zd ZdZdZeZeZddddddd�dd�Z dd � Z d d � Z d d � Z dd� Z dd� Zdd� Zdd� Zdd� ZdS )� Serializerz) Abstract serializer base class. FNr )�stream�fields�use_natural_foreign_keys�use_natural_primary_keys�progress_output� object_countc K st || _ |dur |n| �� | _|| _|| _|| _| �||�} | �� d| _t |dd�D ]�\} } | � | � | j j } | jrJ| j j } | jrG| jjrG| nd}nd}| j jD ]5}|jsY||u r�|jdu rp| jdu si|j| jv ro| �| |� qP| jdu s|jdd� | jv r�| �| |� qP| j jD ]}|jr�| jdu s�|j| jv r�| �| |� q�| �| � | �| � | jo�d| _q*| �� | �� S )z' Serialize a queryset. NTr1 )�start���F)�options� stream_classrB �selected_fieldsrD rE �progress_class�start_serialization�first� enumerate� start_object�_meta�concrete_modelr) � remote_field� parent_link� local_fields� serialize�attname� handle_field�handle_fk_field�local_many_to_many�handle_m2m_field� end_objectr@ �end_serialization�getvalue)r �querysetrB rC rD rE rF rG rJ � progress_barr< r rS r) � pk_parent�fieldr r r rW k sL � � � � zSerializer.serializec C � t d��)zA Called when serializing of the queryset starts. zDsubclasses of Serializer must provide a start_serialization() method��NotImplementedError�r r r r rN � � �z Serializer.start_serializationc C � dS )z? Called when serializing of the queryset ends. Nr rg r r r r^ � � z Serializer.end_serializationc C rd )z> Called when serializing of an object starts. z=subclasses of Serializer must provide a start_object() methodre r r r r rQ � rh zSerializer.start_objectc C ri )z< Called when serializing of an object ends. Nr r r r r r] � rj zSerializer.end_objectc C rd )zW Called to handle each individual (non-relational) field on an object. z=subclasses of Serializer must provide a handle_field() methodre �r r rc r r r rY � rh zSerializer.handle_fieldc C rd )z6 Called to handle a ForeignKey field. z@subclasses of Serializer must provide a handle_fk_field() methodre rk r r r rZ � rh zSerializer.handle_fk_fieldc C rd )z5 Called to handle a ManyToManyField. zAsubclasses of Serializer must provide a handle_m2m_field() methodre rk r r r r\ � rh zSerializer.handle_m2m_fieldc C s t t| jdd��r| j�� S dS )zn Return the fully serialized queryset (or None if the output stream is not seekable). r_ N)�callable�getattrrB r_ rg r r r r_ � s �zSerializer.getvalue)r r r r �internal_use_onlyr* rM r rK rW rN r^ rQ r] rY rZ r\ r_ r r r r rA ` s( �C rA c @ s( e Zd ZdZdd� Zdd� Zdd� ZdS ) � Deserializerz+ Abstract base deserializer class. c K s( || _ t|t�rt|�| _dS || _dS )zA Init this serializer given a stream or a string N)rJ � isinstance�strr rB )r �stream_or_stringrJ r r r r � s zDeserializer.__init__c C s | S r r rg r r r �__iter__� s zDeserializer.__iter__c C rd )z9Iteration interface -- return the next item in the streamz;subclasses of Deserializer must provide a __next__() methodre rg r r r �__next__� s �zDeserializer.__next__N)r r r r r rs rt r r r r ro � s ro c @ s6 e Zd ZdZd dd�Zdd� Zd dd �Zdd d �ZdS )�DeserializedObjectae A deserialized model. Basically a container for holding the pre-saved deserialized data along with the many-to-many data saved with the object. Call ``save()`` to save the object (with the many-to-many data) to the database; call ``save(save_m2m=False)`` to save just the object fields (and not touch the many-to-many stuff.) Nc C s || _ || _|| _d S r )�object�m2m_data�deferred_fields)r r rw rx r r r r r/ zDeserializedObject.__init__c C s d| j j| jjj| jjf S )Nz<%s: %s(pk=%s)>)� __class__r rv rR �labelr) rg r r r �__repr__ s �zDeserializedObject.__repr__Tc K sV t jj| jf|dd�|�� | jr&|r&| j�� D ] \}}t| j|��|� qd | _d S )NT)�using�raw)r �Model� save_baserv rw �itemsrm �set)r �save_m2mr| �kwargs� accessor_name� object_listr r r �save s zDeserializedObject.savec C s i | _ | j�� D ]q\}}| jj}|jd |j }t|jt j �rIz t |||dd�}W n t yA } z t �|j|| jj|j��d }~ww || j |j< qt|jt j�ryz t|||dd�}W n typ } z t �||| jj|��d }~ww t| j|j|� q| �� d S )Nr5 F)�handle_forward_references)rw rx r� rv rR � app_label� model_namerp rT r � ManyToManyRel�deserialize_m2m_valuesr( r r& r" r) �name� ManyToOneRel�deserialize_fk_value� Exception�setattrrX r� ) r r| rc r% �optsrz �values�e�valuer r r �save_deferred_fields) s< ���� � ���� z'DeserializedObject.save_deferred_fields)NN)TNr )r r r r r r{ r� r� r r r r ru s ru c C s� | j j}|�| j jj�}|du rIt|d�rIt| d�rI| di |��}||j_|�� }z| j j� |� |�j |� j�|| j jj< W n | j yH Y nw | di |��S )z� Build a model instance. If the model instance doesn't have a primary key and the model supports natural keys, try to retrieve it from the database. N�get_by_natural_key� natural_keyr ) rR �default_manager�getr) rX �hasattr�_state�dbr� � to_python� db_managerr� � DoesNotExist)r~ r r� r� r) r r� r r r �build_instanceE s$ ����r� c s� | j j� t� jd�r� �fdd�}n� fdd�}zt|�}W n ty/ } zt||��d }~ww zg }|D ] }|�||�� q5|W S tya } zt |t �rX|rXt W Y d }~S t||��d }~ww )Nr� c s6 t | d�rt| t�s� j���j| � jS � jj�| �S )Nrs ) r� rp rq �_default_managerr� r� r) rR r� )r� �r# r| r r � m2m_convertc s ��z+deserialize_m2m_values.<locals>.m2m_convertc s � j j�| �S r )rR r) r� )�v)r# r r r� o r ) rT r# r� r� �iter� TypeErrorr( �appendr� rp r � DEFER_FIELD) rc r% r| r� r� �pks_iterr� r� r) r r� r r� _ s* �� ��r� c C s� |d u rd S | j j}|j}| j j}t|d�rHt|d�rHt|t�sHz |�|�j|� }W n t y8 |r7t Y S � w t ||�}|j j j rF|j }|S |j �|��|�S )Nr� rs )rT r# r� � field_namer� rp rq r� r� r r� rm rR r) � get_fieldr� ) rc r% r| r� r# r� r� r r� r r r r� � s. ��� � r� )r r r �ior �django.core.exceptionsr � django.dbr �django.utils.deprecationr rv r� r �KeyErrorr r� r r r( r* rA ro ru r� r� r� r r r r �<module> s* A # __pycache__/python.cpython-310.pyc 0000644 00000013400 15030017735 0012775 0 ustar 00 o �h� � @ sf d Z ddlmZ ddlmZ ddlmZmZ ddlm Z G dd� dej �Z edd �d d �Z d d � Z dS )z� A Python "serializer". Doesn't do much serializing per se -- just converts to and from basic Python data types (lists, dicts, strings, etc.). Useful as a basis for other serializers. � )�apps)�base)�DEFAULT_DB_ALIAS�models)�is_protected_typec @ sd e Zd ZdZdZdd� Zdd� Zdd� Zd d � Zd d � Z d d� Z dd� Z dd� Z dd� Z dd� ZdS )� Serializerz7 Serialize a QuerySet to basic Python objects. Tc C s d | _ g | _d S �N)�_current�objects��self� r �Q/usr/local/CyberCP/lib/python3.10/site-packages/django/core/serializers/python.py�start_serialization s z Serializer.start_serializationc C s d S r r r r r r �end_serialization s z Serializer.end_serializationc C s i | _ d S r )r �r �objr r r � start_object s zSerializer.start_objectc C s | j �| �|�� d | _d S r )r �append�get_dump_objectr r r r r � end_object s zSerializer.end_objectc C s@ dt |j�i}| jrt|d�s| �||jj�|d< | j|d< |S )N�model� natural_key�pk�fields)�str�_meta�use_natural_primary_keys�hasattr�_value_from_fieldr r )r r �datar r r r " s zSerializer.get_dump_objectc C s |� |�}t|�r |S |�|�S r )�value_from_objectr �value_to_string)r r �field�valuer r r r ) s z Serializer._value_from_fieldc C s | � ||�| j|j< d S r )r r �name)r r r# r r r � handle_field0 s zSerializer.handle_fieldc C sP | j rt|jjd�rt||j�}|r|�� }n d }n| �||�}|| j|j< d S )Nr ) �use_natural_foreign_keysr � remote_fieldr �getattrr% r r r )r r r# �relatedr$ r r r �handle_fk_field3 s � zSerializer.handle_fk_fieldc s� |j jjjr@�jrt|j jd�rdd� � dd� }n �fdd�� dd� }t|di ��|j |||��}� fd d �|D ��j |j < d S d S ) Nr c S s | � � S r )r �r$ r r r � m2m_valueF s z.Serializer.handle_m2m_field.<locals>.m2m_valuec S s t | |j��� S r )r) r% �iterator�r r# r r r �queryset_iteratorI � z6Serializer.handle_m2m_field.<locals>.queryset_iteratorc s � � | | jj�S r )r r r r, r r r r- N r1 c S s t | |j��d ��d��� S )Nr )r) r% �select_related�onlyr. r/ r r r r0 Q s ��_prefetched_objects_cachec s g | ]}� |��qS r r )�.0r* )r- r r � <listcomp>] s z/Serializer.handle_m2m_field.<locals>.<listcomp>) r( �throughr � auto_createdr' r r r) �getr% r )r r r# r0 �m2m_iterr )r- r r �handle_m2m_field@ s � � �zSerializer.handle_m2m_fieldc C s | j S r )r r r r r �getvalue_ s zSerializer.getvalueN)�__name__� __module__� __qualname__�__doc__�internal_use_onlyr r r r r r r& r+ r; r< r r r r r s r F)�using�ignorenonexistentc k s� � |� dd�}i }| D �]2}zt|d �}W n tjy# |r"Y q � w i }d|v rVz|jj�|�d��||jjj< W n t yU } ztj� | |d |�d�d��d} ~ ww i } i } ||vrjdd� |j� � D �||< || } |d � � D ]�\} }|r| | vrqt|j� | �}|jr�t|jtj�r�z t�||||�}W n tjy� } ztj� | j|d |�d�| j��d} ~ ww |tjkr�|| |< qt|| |j< qt|j�r t|jtj��r z t�||||�}W n t y� } ztj� | |d |�d�|��d} ~ ww |tjk�r|| |< qt|||j< qtz |�|�||j< W qt t �y. } ztj� | |d |�d�|��d} ~ ww t�|||�}t�|| | �V q dS ) z� Deserialize simple Python objects back into Django ORM instances. It's expected that you pass the Python objects themselves (instead of a stream or a string) to the constructor �handle_forward_referencesFr r Nc S s h | ]}|j �qS r )r% )r5 �fr r r � <setcomp>� s z Deserializer.<locals>.<setcomp>r )�pop� _get_modelr �DeserializationErrorr r � to_pythonr9 �attname� Exception�WithData� get_fields�items� get_fieldr( � isinstancer � ManyToManyRel�deserialize_m2m_values�M2MDeserializationError� original_exc� DEFER_FIELDr% � ManyToOneRel�deserialize_fk_value�build_instance�DeserializedObject)� object_listrB rC �optionsrD �field_names_cache�d�Modelr �e�m2m_data�deferred_fields� field_names� field_name� field_valuer# �valuesr$ r r r r � Deserializerc s� � �"��� ����� ����� ����rg c C s. zt �| �W S ttfy t�d| ��w )z6Look up a model from an "app_label.model_name" string.z Invalid model identifier: '%s')r � get_model� LookupError� TypeErrorr rI )�model_identifierr r r rH � s ��rH N) r@ � django.appsr �django.core.serializersr � django.dbr r �django.utils.encodingr r rg rH r r r r �<module> s W � Y python.py 0000644 00000015322 15030017735 0006443 0 ustar 00 """ A Python "serializer". Doesn't do much serializing per se -- just converts to and from basic Python data types (lists, dicts, strings, etc.). Useful as a basis for other serializers. """ from django.apps import apps from django.core.serializers import base from django.db import DEFAULT_DB_ALIAS, models from django.utils.encoding import is_protected_type class Serializer(base.Serializer): """ Serialize a QuerySet to basic Python objects. """ internal_use_only = True def start_serialization(self): self._current = None self.objects = [] def end_serialization(self): pass def start_object(self, obj): self._current = {} def end_object(self, obj): self.objects.append(self.get_dump_object(obj)) self._current = None def get_dump_object(self, obj): data = {"model": str(obj._meta)} if not self.use_natural_primary_keys or not hasattr(obj, "natural_key"): data["pk"] = self._value_from_field(obj, obj._meta.pk) data["fields"] = self._current return data def _value_from_field(self, obj, field): value = field.value_from_object(obj) # Protected types (i.e., primitives like None, numbers, dates, # and Decimals) are passed through as is. All other values are # converted to string first. return value if is_protected_type(value) else field.value_to_string(obj) def handle_field(self, obj, field): self._current[field.name] = self._value_from_field(obj, field) def handle_fk_field(self, obj, field): if self.use_natural_foreign_keys and hasattr( field.remote_field.model, "natural_key" ): related = getattr(obj, field.name) if related: value = related.natural_key() else: value = None else: value = self._value_from_field(obj, field) self._current[field.name] = value def handle_m2m_field(self, obj, field): if field.remote_field.through._meta.auto_created: if self.use_natural_foreign_keys and hasattr( field.remote_field.model, "natural_key" ): def m2m_value(value): return value.natural_key() def queryset_iterator(obj, field): return getattr(obj, field.name).iterator() else: def m2m_value(value): return self._value_from_field(value, value._meta.pk) def queryset_iterator(obj, field): return ( getattr(obj, field.name) .select_related(None) .only("pk") .iterator() ) m2m_iter = getattr(obj, "_prefetched_objects_cache", {}).get( field.name, queryset_iterator(obj, field), ) self._current[field.name] = [m2m_value(related) for related in m2m_iter] def getvalue(self): return self.objects def Deserializer( object_list, *, using=DEFAULT_DB_ALIAS, ignorenonexistent=False, **options ): """ Deserialize simple Python objects back into Django ORM instances. It's expected that you pass the Python objects themselves (instead of a stream or a string) to the constructor """ handle_forward_references = options.pop("handle_forward_references", False) field_names_cache = {} # Model: <list of field_names> for d in object_list: # Look up the model and starting build a dict of data for it. try: Model = _get_model(d["model"]) except base.DeserializationError: if ignorenonexistent: continue else: raise data = {} if "pk" in d: try: data[Model._meta.pk.attname] = Model._meta.pk.to_python(d.get("pk")) except Exception as e: raise base.DeserializationError.WithData( e, d["model"], d.get("pk"), None ) m2m_data = {} deferred_fields = {} if Model not in field_names_cache: field_names_cache[Model] = {f.name for f in Model._meta.get_fields()} field_names = field_names_cache[Model] # Handle each field for field_name, field_value in d["fields"].items(): if ignorenonexistent and field_name not in field_names: # skip fields no longer on model continue field = Model._meta.get_field(field_name) # Handle M2M relations if field.remote_field and isinstance( field.remote_field, models.ManyToManyRel ): try: values = base.deserialize_m2m_values( field, field_value, using, handle_forward_references ) except base.M2MDeserializationError as e: raise base.DeserializationError.WithData( e.original_exc, d["model"], d.get("pk"), e.pk ) if values == base.DEFER_FIELD: deferred_fields[field] = field_value else: m2m_data[field.name] = values # Handle FK fields elif field.remote_field and isinstance( field.remote_field, models.ManyToOneRel ): try: value = base.deserialize_fk_value( field, field_value, using, handle_forward_references ) except Exception as e: raise base.DeserializationError.WithData( e, d["model"], d.get("pk"), field_value ) if value == base.DEFER_FIELD: deferred_fields[field] = field_value else: data[field.attname] = value # Handle all other fields else: try: data[field.name] = field.to_python(field_value) except Exception as e: raise base.DeserializationError.WithData( e, d["model"], d.get("pk"), field_value ) obj = base.build_instance(Model, data, using) yield base.DeserializedObject(obj, m2m_data, deferred_fields) def _get_model(model_identifier): """Look up a model from an "app_label.model_name" string.""" try: return apps.get_model(model_identifier) except (LookupError, TypeError): raise base.DeserializationError( "Invalid model identifier: '%s'" % model_identifier ) pyyaml.py 0000644 00000005613 15030017735 0006437 0 ustar 00 """ YAML serializer. Requires PyYaml (https://pyyaml.org/), but that's checked for in __init__. """ import collections import decimal from io import StringIO import yaml from django.core.serializers.base import DeserializationError from django.core.serializers.python import Deserializer as PythonDeserializer from django.core.serializers.python import Serializer as PythonSerializer from django.db import models # Use the C (faster) implementation if possible try: from yaml import CSafeDumper as SafeDumper from yaml import CSafeLoader as SafeLoader except ImportError: from yaml import SafeDumper, SafeLoader class DjangoSafeDumper(SafeDumper): def represent_decimal(self, data): return self.represent_scalar("tag:yaml.org,2002:str", str(data)) def represent_ordered_dict(self, data): return self.represent_mapping("tag:yaml.org,2002:map", data.items()) DjangoSafeDumper.add_representer(decimal.Decimal, DjangoSafeDumper.represent_decimal) DjangoSafeDumper.add_representer( collections.OrderedDict, DjangoSafeDumper.represent_ordered_dict ) # Workaround to represent dictionaries in insertion order. # See https://github.com/yaml/pyyaml/pull/143. DjangoSafeDumper.add_representer(dict, DjangoSafeDumper.represent_ordered_dict) class Serializer(PythonSerializer): """Convert a queryset to YAML.""" internal_use_only = False def handle_field(self, obj, field): # A nasty special case: base YAML doesn't support serialization of time # types (as opposed to dates or datetimes, which it does support). Since # we want to use the "safe" serializer for better interoperability, we # need to do something with those pesky times. Converting 'em to strings # isn't perfect, but it's better than a "!!python/time" type which would # halt deserialization under any other language. if isinstance(field, models.TimeField) and getattr(obj, field.name) is not None: self._current[field.name] = str(getattr(obj, field.name)) else: super().handle_field(obj, field) def end_serialization(self): self.options.setdefault("allow_unicode", True) yaml.dump(self.objects, self.stream, Dumper=DjangoSafeDumper, **self.options) def getvalue(self): # Grandparent super return super(PythonSerializer, self).getvalue() def Deserializer(stream_or_string, **options): """Deserialize a stream or string of YAML data.""" if isinstance(stream_or_string, bytes): stream_or_string = stream_or_string.decode() if isinstance(stream_or_string, str): stream = StringIO(stream_or_string) else: stream = stream_or_string try: yield from PythonDeserializer(yaml.load(stream, Loader=SafeLoader), **options) except (GeneratorExit, DeserializationError): raise except Exception as exc: raise DeserializationError() from exc xml_serializer.py 0000644 00000043630 15030017735 0010156 0 ustar 00 """ XML serializer. """ import json from xml.dom import pulldom from xml.sax import handler from xml.sax.expatreader import ExpatParser as _ExpatParser from django.apps import apps from django.conf import settings from django.core.exceptions import ObjectDoesNotExist from django.core.serializers import base from django.db import DEFAULT_DB_ALIAS, models from django.utils.xmlutils import SimplerXMLGenerator, UnserializableContentError class Serializer(base.Serializer): """Serialize a QuerySet to XML.""" def indent(self, level): if self.options.get("indent") is not None: self.xml.ignorableWhitespace( "\n" + " " * self.options.get("indent") * level ) def start_serialization(self): """ Start serialization -- open the XML document and the root element. """ self.xml = SimplerXMLGenerator( self.stream, self.options.get("encoding", settings.DEFAULT_CHARSET) ) self.xml.startDocument() self.xml.startElement("django-objects", {"version": "1.0"}) def end_serialization(self): """ End serialization -- end the document. """ self.indent(0) self.xml.endElement("django-objects") self.xml.endDocument() def start_object(self, obj): """ Called as each object is handled. """ if not hasattr(obj, "_meta"): raise base.SerializationError( "Non-model object (%s) encountered during serialization" % type(obj) ) self.indent(1) attrs = {"model": str(obj._meta)} if not self.use_natural_primary_keys or not hasattr(obj, "natural_key"): obj_pk = obj.pk if obj_pk is not None: attrs["pk"] = str(obj_pk) self.xml.startElement("object", attrs) def end_object(self, obj): """ Called after handling all fields for an object. """ self.indent(1) self.xml.endElement("object") def handle_field(self, obj, field): """ Handle each field on an object (except for ForeignKeys and ManyToManyFields). """ self.indent(2) self.xml.startElement( "field", { "name": field.name, "type": field.get_internal_type(), }, ) # Get a "string version" of the object's data. if getattr(obj, field.name) is not None: value = field.value_to_string(obj) if field.get_internal_type() == "JSONField": # Dump value since JSONField.value_to_string() doesn't output # strings. value = json.dumps(value, cls=field.encoder) try: self.xml.characters(value) except UnserializableContentError: raise ValueError( "%s.%s (pk:%s) contains unserializable characters" % (obj.__class__.__name__, field.name, obj.pk) ) else: self.xml.addQuickElement("None") self.xml.endElement("field") def handle_fk_field(self, obj, field): """ Handle a ForeignKey (they need to be treated slightly differently from regular fields). """ self._start_relational_field(field) related_att = getattr(obj, field.get_attname()) if related_att is not None: if self.use_natural_foreign_keys and hasattr( field.remote_field.model, "natural_key" ): related = getattr(obj, field.name) # If related object has a natural key, use it related = related.natural_key() # Iterable natural keys are rolled out as subelements for key_value in related: self.xml.startElement("natural", {}) self.xml.characters(str(key_value)) self.xml.endElement("natural") else: self.xml.characters(str(related_att)) else: self.xml.addQuickElement("None") self.xml.endElement("field") def handle_m2m_field(self, obj, field): """ Handle a ManyToManyField. Related objects are only serialized as references to the object's PK (i.e. the related *data* is not dumped, just the relation). """ if field.remote_field.through._meta.auto_created: self._start_relational_field(field) if self.use_natural_foreign_keys and hasattr( field.remote_field.model, "natural_key" ): # If the objects in the m2m have a natural key, use it def handle_m2m(value): natural = value.natural_key() # Iterable natural keys are rolled out as subelements self.xml.startElement("object", {}) for key_value in natural: self.xml.startElement("natural", {}) self.xml.characters(str(key_value)) self.xml.endElement("natural") self.xml.endElement("object") def queryset_iterator(obj, field): return getattr(obj, field.name).iterator() else: def handle_m2m(value): self.xml.addQuickElement("object", attrs={"pk": str(value.pk)}) def queryset_iterator(obj, field): return ( getattr(obj, field.name) .select_related(None) .only("pk") .iterator() ) m2m_iter = getattr(obj, "_prefetched_objects_cache", {}).get( field.name, queryset_iterator(obj, field), ) for relobj in m2m_iter: handle_m2m(relobj) self.xml.endElement("field") def _start_relational_field(self, field): """Output the <field> element for relational fields.""" self.indent(2) self.xml.startElement( "field", { "name": field.name, "rel": field.remote_field.__class__.__name__, "to": str(field.remote_field.model._meta), }, ) class Deserializer(base.Deserializer): """Deserialize XML.""" def __init__( self, stream_or_string, *, using=DEFAULT_DB_ALIAS, ignorenonexistent=False, **options, ): super().__init__(stream_or_string, **options) self.handle_forward_references = options.pop("handle_forward_references", False) self.event_stream = pulldom.parse(self.stream, self._make_parser()) self.db = using self.ignore = ignorenonexistent def _make_parser(self): """Create a hardened XML parser (no custom/external entities).""" return DefusedExpatParser() def __next__(self): for event, node in self.event_stream: if event == "START_ELEMENT" and node.nodeName == "object": self.event_stream.expandNode(node) return self._handle_object(node) raise StopIteration def _handle_object(self, node): """Convert an <object> node to a DeserializedObject.""" # Look up the model using the model loading mechanism. If this fails, # bail. Model = self._get_model_from_node(node, "model") # Start building a data dictionary from the object. data = {} if node.hasAttribute("pk"): data[Model._meta.pk.attname] = Model._meta.pk.to_python( node.getAttribute("pk") ) # Also start building a dict of m2m data (this is saved as # {m2m_accessor_attribute : [list_of_related_objects]}) m2m_data = {} deferred_fields = {} field_names = {f.name for f in Model._meta.get_fields()} # Deserialize each field. for field_node in node.getElementsByTagName("field"): # If the field is missing the name attribute, bail (are you # sensing a pattern here?) field_name = field_node.getAttribute("name") if not field_name: raise base.DeserializationError( "<field> node is missing the 'name' attribute" ) # Get the field from the Model. This will raise a # FieldDoesNotExist if, well, the field doesn't exist, which will # be propagated correctly unless ignorenonexistent=True is used. if self.ignore and field_name not in field_names: continue field = Model._meta.get_field(field_name) # As is usually the case, relation fields get the special treatment. if field.remote_field and isinstance( field.remote_field, models.ManyToManyRel ): value = self._handle_m2m_field_node(field_node, field) if value == base.DEFER_FIELD: deferred_fields[field] = [ [ getInnerText(nat_node).strip() for nat_node in obj_node.getElementsByTagName("natural") ] for obj_node in field_node.getElementsByTagName("object") ] else: m2m_data[field.name] = value elif field.remote_field and isinstance( field.remote_field, models.ManyToOneRel ): value = self._handle_fk_field_node(field_node, field) if value == base.DEFER_FIELD: deferred_fields[field] = [ getInnerText(k).strip() for k in field_node.getElementsByTagName("natural") ] else: data[field.attname] = value else: if field_node.getElementsByTagName("None"): value = None else: value = field.to_python(getInnerText(field_node).strip()) # Load value since JSONField.to_python() outputs strings. if field.get_internal_type() == "JSONField": value = json.loads(value, cls=field.decoder) data[field.name] = value obj = base.build_instance(Model, data, self.db) # Return a DeserializedObject so that the m2m data has a place to live. return base.DeserializedObject(obj, m2m_data, deferred_fields) def _handle_fk_field_node(self, node, field): """ Handle a <field> node for a ForeignKey """ # Check if there is a child node named 'None', returning None if so. if node.getElementsByTagName("None"): return None else: model = field.remote_field.model if hasattr(model._default_manager, "get_by_natural_key"): keys = node.getElementsByTagName("natural") if keys: # If there are 'natural' subelements, it must be a natural key field_value = [getInnerText(k).strip() for k in keys] try: obj = model._default_manager.db_manager( self.db ).get_by_natural_key(*field_value) except ObjectDoesNotExist: if self.handle_forward_references: return base.DEFER_FIELD else: raise obj_pk = getattr(obj, field.remote_field.field_name) # If this is a natural foreign key to an object that # has a FK/O2O as the foreign key, use the FK value if field.remote_field.model._meta.pk.remote_field: obj_pk = obj_pk.pk else: # Otherwise, treat like a normal PK field_value = getInnerText(node).strip() obj_pk = model._meta.get_field( field.remote_field.field_name ).to_python(field_value) return obj_pk else: field_value = getInnerText(node).strip() return model._meta.get_field(field.remote_field.field_name).to_python( field_value ) def _handle_m2m_field_node(self, node, field): """ Handle a <field> node for a ManyToManyField. """ model = field.remote_field.model default_manager = model._default_manager if hasattr(default_manager, "get_by_natural_key"): def m2m_convert(n): keys = n.getElementsByTagName("natural") if keys: # If there are 'natural' subelements, it must be a natural key field_value = [getInnerText(k).strip() for k in keys] obj_pk = ( default_manager.db_manager(self.db) .get_by_natural_key(*field_value) .pk ) else: # Otherwise, treat like a normal PK value. obj_pk = model._meta.pk.to_python(n.getAttribute("pk")) return obj_pk else: def m2m_convert(n): return model._meta.pk.to_python(n.getAttribute("pk")) values = [] try: for c in node.getElementsByTagName("object"): values.append(m2m_convert(c)) except Exception as e: if isinstance(e, ObjectDoesNotExist) and self.handle_forward_references: return base.DEFER_FIELD else: raise base.M2MDeserializationError(e, c) else: return values def _get_model_from_node(self, node, attr): """ Look up a model from a <object model=...> or a <field rel=... to=...> node. """ model_identifier = node.getAttribute(attr) if not model_identifier: raise base.DeserializationError( "<%s> node is missing the required '%s' attribute" % (node.nodeName, attr) ) try: return apps.get_model(model_identifier) except (LookupError, TypeError): raise base.DeserializationError( "<%s> node has invalid model identifier: '%s'" % (node.nodeName, model_identifier) ) def getInnerText(node): """Get all the inner text of a DOM node (recursively).""" # inspired by https://mail.python.org/pipermail/xml-sig/2005-March/011022.html inner_text = [] for child in node.childNodes: if ( child.nodeType == child.TEXT_NODE or child.nodeType == child.CDATA_SECTION_NODE ): inner_text.append(child.data) elif child.nodeType == child.ELEMENT_NODE: inner_text.extend(getInnerText(child)) else: pass return "".join(inner_text) # Below code based on Christian Heimes' defusedxml class DefusedExpatParser(_ExpatParser): """ An expat parser hardened against XML bomb attacks. Forbid DTDs, external entity references """ def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) self.setFeature(handler.feature_external_ges, False) self.setFeature(handler.feature_external_pes, False) def start_doctype_decl(self, name, sysid, pubid, has_internal_subset): raise DTDForbidden(name, sysid, pubid) def entity_decl( self, name, is_parameter_entity, value, base, sysid, pubid, notation_name ): raise EntitiesForbidden(name, value, base, sysid, pubid, notation_name) def unparsed_entity_decl(self, name, base, sysid, pubid, notation_name): # expat 1.2 raise EntitiesForbidden(name, None, base, sysid, pubid, notation_name) def external_entity_ref_handler(self, context, base, sysid, pubid): raise ExternalReferenceForbidden(context, base, sysid, pubid) def reset(self): _ExpatParser.reset(self) parser = self._parser parser.StartDoctypeDeclHandler = self.start_doctype_decl parser.EntityDeclHandler = self.entity_decl parser.UnparsedEntityDeclHandler = self.unparsed_entity_decl parser.ExternalEntityRefHandler = self.external_entity_ref_handler class DefusedXmlException(ValueError): """Base exception.""" def __repr__(self): return str(self) class DTDForbidden(DefusedXmlException): """Document type definition is forbidden.""" def __init__(self, name, sysid, pubid): super().__init__() self.name = name self.sysid = sysid self.pubid = pubid def __str__(self): tpl = "DTDForbidden(name='{}', system_id={!r}, public_id={!r})" return tpl.format(self.name, self.sysid, self.pubid) class EntitiesForbidden(DefusedXmlException): """Entity definition is forbidden.""" def __init__(self, name, value, base, sysid, pubid, notation_name): super().__init__() self.name = name self.value = value self.base = base self.sysid = sysid self.pubid = pubid self.notation_name = notation_name def __str__(self): tpl = "EntitiesForbidden(name='{}', system_id={!r}, public_id={!r})" return tpl.format(self.name, self.sysid, self.pubid) class ExternalReferenceForbidden(DefusedXmlException): """Resolving an external reference is forbidden.""" def __init__(self, context, base, sysid, pubid): super().__init__() self.context = context self.base = base self.sysid = sysid self.pubid = pubid def __str__(self): tpl = "ExternalReferenceForbidden(system_id='{}', public_id={})" return tpl.format(self.sysid, self.pubid) __init__.py 0000644 00000021104 15030017735 0006654 0 ustar 00 """ Interfaces for serializing Django objects. Usage:: from django.core import serializers json = serializers.serialize("json", some_queryset) objects = list(serializers.deserialize("json", json)) To add your own serializers, use the SERIALIZATION_MODULES setting:: SERIALIZATION_MODULES = { "csv": "path.to.csv.serializer", "txt": "path.to.txt.serializer", } """ import importlib from django.apps import apps from django.conf import settings from django.core.serializers.base import SerializerDoesNotExist # Built-in serializers BUILTIN_SERIALIZERS = { "xml": "django.core.serializers.xml_serializer", "python": "django.core.serializers.python", "json": "django.core.serializers.json", "yaml": "django.core.serializers.pyyaml", "jsonl": "django.core.serializers.jsonl", } _serializers = {} class BadSerializer: """ Stub serializer to hold exception raised during registration This allows the serializer registration to cache serializers and if there is an error raised in the process of creating a serializer it will be raised and passed along to the caller when the serializer is used. """ internal_use_only = False def __init__(self, exception): self.exception = exception def __call__(self, *args, **kwargs): raise self.exception def register_serializer(format, serializer_module, serializers=None): """Register a new serializer. ``serializer_module`` should be the fully qualified module name for the serializer. If ``serializers`` is provided, the registration will be added to the provided dictionary. If ``serializers`` is not provided, the registration will be made directly into the global register of serializers. Adding serializers directly is not a thread-safe operation. """ if serializers is None and not _serializers: _load_serializers() try: module = importlib.import_module(serializer_module) except ImportError as exc: bad_serializer = BadSerializer(exc) module = type( "BadSerializerModule", (), { "Deserializer": bad_serializer, "Serializer": bad_serializer, }, ) if serializers is None: _serializers[format] = module else: serializers[format] = module def unregister_serializer(format): "Unregister a given serializer. This is not a thread-safe operation." if not _serializers: _load_serializers() if format not in _serializers: raise SerializerDoesNotExist(format) del _serializers[format] def get_serializer(format): if not _serializers: _load_serializers() if format not in _serializers: raise SerializerDoesNotExist(format) return _serializers[format].Serializer def get_serializer_formats(): if not _serializers: _load_serializers() return list(_serializers) def get_public_serializer_formats(): if not _serializers: _load_serializers() return [k for k, v in _serializers.items() if not v.Serializer.internal_use_only] def get_deserializer(format): if not _serializers: _load_serializers() if format not in _serializers: raise SerializerDoesNotExist(format) return _serializers[format].Deserializer def serialize(format, queryset, **options): """ Serialize a queryset (or any iterator that returns database objects) using a certain serializer. """ s = get_serializer(format)() s.serialize(queryset, **options) return s.getvalue() def deserialize(format, stream_or_string, **options): """ Deserialize a stream or a string. Return an iterator that yields ``(obj, m2m_relation_dict)``, where ``obj`` is an instantiated -- but *unsaved* -- object, and ``m2m_relation_dict`` is a dictionary of ``{m2m_field_name : list_of_related_objects}``. """ d = get_deserializer(format) return d(stream_or_string, **options) def _load_serializers(): """ Register built-in and settings-defined serializers. This is done lazily so that user code has a chance to (e.g.) set up custom settings without needing to be careful of import order. """ global _serializers serializers = {} for format in BUILTIN_SERIALIZERS: register_serializer(format, BUILTIN_SERIALIZERS[format], serializers) if hasattr(settings, "SERIALIZATION_MODULES"): for format in settings.SERIALIZATION_MODULES: register_serializer( format, settings.SERIALIZATION_MODULES[format], serializers ) _serializers = serializers def sort_dependencies(app_list, allow_cycles=False): """Sort a list of (app_config, models) pairs into a single list of models. The single list of models is sorted so that any model with a natural key is serialized before a normal model, and any model with a natural key dependency has it's dependencies serialized first. If allow_cycles is True, return the best-effort ordering that will respect most of dependencies but ignore some of them to break the cycles. """ # Process the list of models, and get the list of dependencies model_dependencies = [] models = set() for app_config, model_list in app_list: if model_list is None: model_list = app_config.get_models() for model in model_list: models.add(model) # Add any explicitly defined dependencies if hasattr(model, "natural_key"): deps = getattr(model.natural_key, "dependencies", []) if deps: deps = [apps.get_model(dep) for dep in deps] else: deps = [] # Now add a dependency for any FK relation with a model that # defines a natural key for field in model._meta.fields: if field.remote_field: rel_model = field.remote_field.model if hasattr(rel_model, "natural_key") and rel_model != model: deps.append(rel_model) # Also add a dependency for any simple M2M relation with a model # that defines a natural key. M2M relations with explicit through # models don't count as dependencies. for field in model._meta.many_to_many: if field.remote_field.through._meta.auto_created: rel_model = field.remote_field.model if hasattr(rel_model, "natural_key") and rel_model != model: deps.append(rel_model) model_dependencies.append((model, deps)) model_dependencies.reverse() # Now sort the models to ensure that dependencies are met. This # is done by repeatedly iterating over the input list of models. # If all the dependencies of a given model are in the final list, # that model is promoted to the end of the final list. This process # continues until the input list is empty, or we do a full iteration # over the input models without promoting a model to the final list. # If we do a full iteration without a promotion, that means there are # circular dependencies in the list. model_list = [] while model_dependencies: skipped = [] changed = False while model_dependencies: model, deps = model_dependencies.pop() # If all of the models in the dependency list are either already # on the final model list, or not on the original serialization list, # then we've found another model with all it's dependencies satisfied. if all(d not in models or d in model_list for d in deps): model_list.append(model) changed = True else: skipped.append((model, deps)) if not changed: if allow_cycles: # If cycles are allowed, add the last skipped model and ignore # its dependencies. This could be improved by some graph # analysis to ignore as few dependencies as possible. model, _ = skipped.pop() model_list.append(model) else: raise RuntimeError( "Can't resolve dependencies for %s in serialized app list." % ", ".join( model._meta.label for model, deps in sorted( skipped, key=lambda obj: obj[0].__name__ ) ), ) model_dependencies = skipped return model_list
| ver. 1.4 |
Github
|
.
| PHP 8.2.28 | Generation time: 0.02 |
proxy
|
phpinfo
|
Settings