Save all the translations of instance in post_save signal handler.
321302
def translation_save_translated_fields(instance, **kwargs):
    
    if not hasattr(instance, '_translation_cache'):
        return
    for l_id, translation in instance._translation_cache.iteritems():
        # set the translation ID just in case the translation was
        # created while instance was not stored in the DB yet

        # note: we're using _get_pk_val here even though it is
        # private, since that's the most reliable way to get the value
        # on older Django (pk property did not exist yet)
        translation.master_id = instance._get_pk_val()
        translation.save()
814927
def save(self, *args, **kwargs):
        """"""
        self.save_prep(instance_or_instances=self)
        return super(AbstractTokenModel, self).save(*args, **kwargs)
402342
def save_entity_signal_handler(sender, instance, **kwargs):
    
    if instance.__class__ in entity_registry.entity_registry:
        sync_entities(instance)

    if instance.__class__ in entity_registry.entity_watching:
        sync_entities_watching(instance)
732009
def put!(translations)
      Scope.flatten(translations).each do |key, value|
        storage.write(key, value)
      end
    end
1313312
async def save(self):
        """"""
        if hasattr(self._handler, "update"):
            if self._changed_data:
                update_data = dict(self._changed_data)
                update_data.update({
                    key: self._orig_data[key]
                    for key in self._handler.params
                })
                self._data = await self._handler.update(**update_data)
        else:
            raise AttributeError(
                "'%s' object doesn't support save." % type(self).__name__)
200838
def store_translations(locale, data, options = {})
      super
      ActiveRecord::Base.transaction do
        store_item(locale, data)
      end if store_items? && valid_locale?(locale)
    end
653567
public function saveinnlang()
    {
        $soxId = $this->getEditObjectId();
        $aParams = \OxidEsales\Eshop\Core\Registry::getConfig()->getRequestParameter("editval");

        // checkbox handling
        if (!isset($aParams['oxwrapping__oxactive'])) {
            $aParams['oxwrapping__oxactive'] = 0;
        }

        $oWrapping = oxNew(\OxidEsales\Eshop\Application\Model\Wrapping::class);

        if ($soxId != "-1") {
            $oWrapping->load($soxId);
        } else {
            $aParams['oxwrapping__oxid'] = null;
            //$aParams = $oWrapping->ConvertNameArray2Idx( $aParams);
        }

        //Disable editing for derived articles
        if ($oWrapping->isDerived()) {
            return;
        }

        $oWrapping->setLanguage(0);
        $oWrapping->assign($aParams);
        $oWrapping->setLanguage($this->_iEditLang);

        $oWrapping = \OxidEsales\Eshop\Core\Registry::getUtilsFile()->processFiles($oWrapping);
        $oWrapping->save();

        // set oxid if inserted
        $this->setEditObjectId($oWrapping->getId());
    }
1227596
def _save_params(self):
        
        self.model.save_params_to_file(self.current_params_fname)
        utils.cleanup_params_files(self.model.output_dir, self.max_params_files_to_keep, self.state.checkpoint,
                                   self.state.best_checkpoint, self.keep_initializations)
698779
private function readSavedTranslations()
    {
        if (!is_file($this->absPath) || !is_readable($this->absPath)) {
            return null;
        }

        try {
            $savedTranslations = Yaml::parse(file_get_contents($this->absPath), true);
        } catch (ParseException $e) {
            $this->app['logger.flash']->danger('Unable to parse the YAML translations' . $e->getMessage());

            return null;
        }

        if ($savedTranslations === null) {
            return []; // File seems to be empty
        } elseif (!is_array($savedTranslations)) {
            $savedTranslations = [$savedTranslations]; // account for file with one lin
        }

        $flatten = function ($data, $prefix = '') use (&$flatten, &$flattened) {
            if ($prefix) {
                $prefix .= '.';
            }
            foreach ($data as $key => $value) {
                if (is_array($value)) {
                    $flatten($value, $prefix . $key);
                } else {
                    $flattened[$prefix . $key] = ($value === null) ? '' : $value;
                }
            }
        };
        $flattened = [];
        $flatten($savedTranslations);

        return $flattened;
    }
869313
def manager_post_save_handler(sender, instance, created, **kwargs):
    """"""
    if instance.status == Data.STATUS_DONE or instance.status == Data.STATUS_ERROR or created:
        # Run manager at the end of the potential transaction. Otherwise
        # tasks are send to workers before transaction ends and therefore
        # workers cannot access objects created inside transaction.
        transaction.on_commit(lambda: commit_signal(instance.id))
524332
def _pop_translated_data(self):
        
        translated_data = {}
        for meta in self.Meta.model._parler_meta:
            translations = self.validated_data.pop(meta.rel_name, {})
            if translations:
                translated_data[meta.rel_name] = translations
        return translated_data
202191
public function save()
    {
        // Can only update the name and output_params
        $params = array('id' => $this->getId(), 'name' => $this->getName());
        foreach ($this->_output_params as $key => $val) {
            $params[DataSift_Push_Definition::OUTPUT_PARAMS_PREFIX . $key] = $val;
        }

        // Call the API and pass the returned object into init to update this object
        $this->init($this->_user->post('push/update', $params));
    }
486124
def save_translated_fields(self):
        
        fields = {}

        # Collect all translated fields {'name': 'value'}
        for field in self._translated_fields:
            try:
                value = self.cleaned_data[field]
            except KeyError:  # Field has a ValidationError
                continue
            fields[field] = value

        # Set the field values on their relevant models
        translations = self.instance._set_translated_fields(**fields)

        # Perform full clean on models
        non_translated_fields = set(('id', 'master_id', 'language_code'))
        for translation in translations:
            self._post_clean_translation(translation)

            # Assign translated fields to the model (using the TranslatedAttribute descriptor)
            for field in translation._get_field_names():
                if field in non_translated_fields:
                    continue
                setattr(self.instance, field, getattr(translation, field))
946864
function managesieve_saveraw()
    {
        $engine = $this->get_engine();

        if (!$this->rc->config->get('managesieve_raw_editor', true)) {
            return;
        }

        // load localization
        $this->add_texts('localization/', array('filters','managefilters'));

        $engine->saveraw();
    }
512317
def post_save(self):
        """"""
        if self.run:
            self.run = False
            self.create_tasks()
            self.save()
558455
public function saveTranslations($translations)
    {
        $this->backup();

        foreach ($translations as $lang => $lines) {
            $filename = $this->languageFilesPath.DIRECTORY_SEPARATOR."$lang.json";

            ksort($lines);

            file_put_contents($filename, json_encode($lines, JSON_UNESCAPED_UNICODE | JSON_PRETTY_PRINT));
        }
    }
121999
function _saveCanvas(ctx, data) {
	var transforms;
	ctx.save();
	transforms = _cloneTransforms(data.transforms);
	data.savedTransforms.push(transforms);
}