Convert this modification to a FUSION data dictionary.

        Don't use this without checking ``self.type == FUSION`` first.

        :rtype: dict
163075
def _fusion_to_json(self):
        
        if self.p5_reference:
            range_5p = fusion_range(
                reference=str(self.p5_reference),
                start=int_or_str(self.p5_start),
                stop=int_or_str(self.p5_stop),
            )
        else:
            range_5p = missing_fusion_range()

        if self.p3_reference:
            range_3p = fusion_range(
                reference=str(self.p3_reference),
                start=int_or_str(self.p3_start),
                stop=int_or_str(self.p3_stop),
            )
        else:
            range_3p = missing_fusion_range()

        return {
            PARTNER_5P: self.p5_partner.to_json(),  # just the identifier pair
            PARTNER_3P: self.p3_partner.to_json(),  # just the identifier pair
            RANGE_5P: range_5p,
            RANGE_3P: range_3p,
        }
531636
def _to_dict(self):
        """"""
        _dict = {}
        if hasattr(self, 'type') and self.type is not None:
            _dict['type'] = self.type
        if hasattr(self, 'data') and self.data is not None:
            _dict['data'] = self.data._to_dict()
        return _dict
1046099
def as_dict(self):
        

        output_dictionary = dict()

        for attribute_name, type_instance in inspect.getmembers(self):

            if attribute_name.startswith('__') or inspect.ismethod(type_instance):
                continue

            if isinstance(type_instance, bool):
                output_dictionary[attribute_name] = type_instance
            elif isinstance(type_instance, self.__class__):
                output_dictionary[attribute_name] = type_instance.as_dict()

        return output_dictionary
995358
def to_dict(potential):
    
    from .. import potential as gp

    if isinstance(potential, gp.CompositePotential):
        d = dict()
        d['class'] = potential.__class__.__name__
        d['components'] = []
        for k, p in potential.items():
            comp_dict = _to_dict_help(p)
            comp_dict['name'] = k
            d['components'].append(comp_dict)

        if potential.__class__.__name__ == 'CompositePotential' or \
           potential.__class__.__name__ == 'CCompositePotential':
            d['type'] = 'composite'
        else:
            d['type'] = 'custom'

    else:
        d = _to_dict_help(potential)

    return d
903255
def convert_to_dict(self):
        """"""
        out_dict = {}
        out_dict["groupName"] = self.group_name
        out_dict["atomNameList"] = self.atom_name_list
        out_dict["elementList"] = self.element_list
        out_dict["bondOrderList"] = self.bond_order_list
        out_dict["bondAtomList"] = self.bond_atom_list
        out_dict["formalChargeList"] = self.charge_list
        out_dict["singleLetterCode"] = self.single_letter_code
        out_dict["chemCompType"] = self.group_type
        return out_dict
462585
def dict(self):
        
        d = {p.key: getattr(self, p.key) for p in self.__mapper__.attrs
             if p.key not in ('contents', 'dataset')}

        d['modified_datetime'] = self.modified_datetime
        d['modified_ago'] = self.modified_ago

        return d
343378
def to_dict(self):
        

        input_dict = super(RBF, self)._save_to_input_dict()
        input_dict["class"] = "GPy.kern.RBF"
        input_dict["inv_l"] = self.use_invLengthscale
        if input_dict["inv_l"] == True:
            input_dict["lengthscale"] = np.sqrt(1 / float(self.inv_l))
        return input_dict
379636
def to_dict(self):
        
        
        ret = merge_dicts(self.__attributes__, self.__relations__, self.__fields__)
        ret = {k : v.value for k,v in ret.items()}
        ret['maps'] = {k : v.value for k,v in self.maps.items()}
        return ret
49834
def to_dict(self, include_delta=True):
        
        if self.deleted:
            return {
                'timestamp': self.timestamp,
                'version': self.version
            }
        delta = self.parse_payload(self.desired, self.reported)
        payload = {}
        if self.desired is not None:
            payload['desired'] = self.desired
        if self.reported is not None:
            payload['reported'] = self.reported
        if include_delta and (delta is not None and len(delta.keys()) != 0):
            payload['delta'] = delta

        metadata = {}
        if self.metadata_desired is not None:
            metadata['desired'] = self.metadata_desired
        if self.metadata_reported is not None:
            metadata['reported'] = self.metadata_reported

        return {
            'state': payload,
            'metadata': metadata,
            'timestamp': self.timestamp,
            'version': self.version
        }
234979
def as_dict(self):
        
        d = {"@module": self.__class__.__module__,
             "@class": self.__class__.__name__,
             "defect": self.defect.as_dict(),
             "uncorrected_energy": self.uncorrected_energy,
             "corrections": self.corrections,
             "parameters": self.parameters,
             "entry_id": self.entry_id}
        return d
46318
def as_dict(self):
        
        d = self.final_structure.as_dict()
        d["@module"] = self.__class__.__module__
        d["@class"] = self.__class__.__name__
        d["history"] = jsanitize(self.history)
        d["version"] = __version__
        d["last_modified"] = str(datetime.datetime.utcnow())
        d["other_parameters"] = jsanitize(self.other_parameters)
        return d
877910
def to_dict(self):
        # type: () -> OrderedDict
        

        d = OrderedDict()
        if self.typeid:
            d["typeid"] = self.typeid

        for k in self.call_types:
            # check_camel_case(k)
            d[k] = serialize_object(getattr(self, k))

        return d
317654
def to_dict(self):
        
        return dict((parameter.name, parameter.value) for parameter in self.values())
125240
def to_dict(self):
        
        return {key: val.to_dict() if isinstance(val, NestedDict) else val
                for key, val in self.items()}
340762
def dict(self):
        
        d = {p.key: getattr(self, p.key) for p in self.__mapper__.attrs
             if p.key not in ('table', 'stats', '_codes', 'data')}

        if not d:
            raise Exception(self.__dict__)

        d['schema_type'] = self.schema_type

        if self.data:
            # Copy data fields into top level dict, but don't overwrite existind values.
            for k, v in six.iteritems(self.data):
                if k not in d and k not in ('table', 'stats', '_codes', 'data'):
                    d[k] = v

        return d
594576
def as_dict(self):
        
        opt_info = {}
        opt_info["type"] = "value"
        opt_info["name"] = self.name
        opt_info["value"] = self.value
        opt_info["otype"] = self.otype.as_dict()
        #TODO: est-ce que l'on ne met pas a plat et les attr de otype et ceux de l'option
        return opt_info
739819
def to_dict(self):
        
        expansion_strings = []

        for expansion in self.expansions:
            expansion_strings.extend(expansion.to_strings())

        return {
            self.type: expansion_strings,
        }