return the partial for a new record.
965128
public function newPartialAction()
    {
        $postParams = $this->params()->fromPost();
        $parentName = $postParams['parent_name'];
        $childName  = $postParams['child_name'];
        $parent     = $postParams['parent'];

        $parent = $this->getService($parentName)->find($parent);
        $child  = $this->getService($childName)->getModel();

        $child->setParent($parent);

        $partial  = $this->dash($childName);
        $viewVars = array(lcfirst($this->camel($childName)) => $child);
        return $this->partialView($partial, $viewVars);
    }
332703
def _partial(self):
        """"""
        raw_stdout = self._process.readAllStandardOutput()
        stdout = handle_qbytearray(raw_stdout, _CondaAPI.UTF8)

        json_stdout = stdout.replace('\n\x00', '')
        try:
            json_stdout = json.loads(json_stdout)
        except Exception:
            json_stdout = stdout

        if self._partial_stdout is None:
            self._partial_stdout = stdout
        else:
            self._partial_stdout += stdout

        self.sig_partial.emit(self, json_stdout, None)
438508
def copy(self):
        """"""
        return self.__class__(self.record.copy(),
                              self.variables,  # a new one is made in all cases
                              self.info.copy(),
                              self.vartype)
647218
def _make_record(self,row):
        """"""
        res = dict(zip(self.all_fields,row))
        for k in self.types:
            res[k] = self.types[k](res[k])
        return res
175884
def __partial(source, data={})
      if source.kind_of?(Source)
        Undies::Template.new(source, data, @_undies_io)
      else
        @_undies_io.current.partial(source.to_s)
      end
    end
1132714
def _make_record(self,row):
        """"""
        res = dict(zip(['__id__']+[f for f in self.fields],row))
        for field_name in self.conv_func:
            res[field_name] = self.conv_func[field_name](res[field_name])
        return res
708425
def extra_from_record(self, record):
        
        return {
            attr_name: record.__dict__[attr_name]
            for attr_name in record.__dict__
            if attr_name not in BUILTIN_ATTRS
        }
719365
def _guess_record(self, rtype, name=None, content=None):
        """"""
        records = self._list_records_internal(
            identifier=None, rtype=rtype, name=name, content=content)
        if len(records) == 1:
            return records[0]
        if len(records) > 1:
            raise Exception(
                'Identifier was not provided and several existing '
                'records match the request for {0}/{1}'.format(rtype, name))
        raise Exception(
            'Identifier was not provided and no existing records match '
            'the request for {0}/{1}'.format(rtype, name))
290167
def _get_record(self):
        
        if not self.pk:
            raise AJAXError(400, _('Invalid request for record.'))

        try:
            return self.model.objects.get(pk=self.pk)
        except self.model.DoesNotExist:
            raise AJAXError(404, _('%s with id of "%s" not found.') % (
                self.model.__name__, self.pk))
1257084
def record_id(self, record, type_=None, selector=None):
        """"""
        pk = record_id(record, type_, selector, self.normalize_object_slot)
        return pk
490457
def bind_partial(self, *args, **kwargs):
        
        return self._bind(args, kwargs, partial=True)
573910
def partial_update(self, index, doc_type, id, doc=None, script=None, params=None,
                       upsert=None, querystring_args=None):
        
        if querystring_args is None:
            querystring_args = {}

        if doc is None and script is None:
            raise InvalidQuery("script or doc can not both be None")

        if doc is None:
            cmd = {"script": script}
            if params:
                cmd["params"] = params
            if upsert:
                cmd["upsert"] = upsert
        else:
            cmd = {"doc": doc }
        path = make_path(index, doc_type, id, "_update")

        return self._send_request('POST', path, cmd, querystring_args)
909437
def _new_url_record(cls, request: Request) -> URLRecord:
        ''''''
        url_record = URLRecord()

        url_record.url = request.url_info.url
        url_record.status = Status.in_progress
        url_record.try_count = 0
        url_record.level = 0

        return url_record
1308264
def format(self, record):
        
        if not hasattr(record, "type"):
            record.type = "   "
        return self._formatter.format(record)
1253934
def partial_regardless(self, fn, *a, **kw):
        """"""
        if self.has_annotations(fn):
            return self.partial(fn, *a, **kw)
        else:
            return functools.partial(fn, *a, **kw)
980191
def createRecordItem(self, record, parent=None):
        
        if parent is None:
            parent=self
        
        return self.recordItemClass(record)(parent, record)
326602
function include(partial, cb) {
    cb((params.partials && params.partials[partial]) ?
      params.partials[partial] :
      '[error] partial ' + partial + ' does not exist');
  }