The last part of raw_parts.
439967
def raw_name(self):
        """"""
        parts = self.raw_parts
        if self.is_absolute():
            parts = parts[1:]
            if not parts:
                return ""
            else:
                return parts[-1]
        else:
            return parts[-1]
771955
def _complete_last_byte(self, packet):
        """"""
        padded_size = self.get_size()
        padding_bytes = padded_size - len(packet)
        if padding_bytes > 0:
            packet += Pad(padding_bytes).pack()
        return packet
1371170
def parts(path):
    # type: (Text) -> List[Text]
    
    _path = normpath(path)
    components = _path.strip("/")

    _parts = ["/" if _path.startswith("/") else "./"]
    if components:
        _parts += components.split("/")
    return _parts
576651
protected RawData __getSection() {
        return S.raw(S.isEmpty(layoutContent) ? layoutSections.get("__CONTENT__") : layoutContent);
    }
377991
def relevant_part(self, original, pos, sep=' '):
        
        start = original.rfind(sep, 0, pos) + 1
        end = original.find(sep, pos - 1)
        if end == -1:
            end = len(original)
        return original[start:end], start, end, pos - start
1211604
def final_objects(self):
        """"""
        return [obj for obj in self.database_objects
                if obj.status in [obj.known_statuses.COMPLETED]]
279224
def partital_dict(self, with_name=True):
        """"""

        d = self._dict(with_name=False)

        d = {k: d.get(k) for k, _, _ in PartialPartitionName._name_parts if d.get(k, False)}

        if 'format' in d and d['format'] == Name.DEFAULT_FORMAT:
            del d['format']

        d['name'] = self.name

        return d
797616
def _gather_image_parts(self):
        """"""
        for rel in self.iter_rels():
            if rel.is_external:
                continue
            if rel.reltype != RT.IMAGE:
                continue
            if rel.target_part in self.image_parts:
                continue
            self.image_parts.append(rel.target_part)
624995
def normalize(self, parts):
        

        part = parts.list[0]

        return {
            'content': part.file.read(),
            'content-type': part.type,
            'file-ext': extensions.get(part.type),
            'file-name': part.filename,
        }
1253534
def get_parts(self):
        
        return self.find_path(lambda x: isinstance(x[1], DictCell), on_targets=True)
1323422
def getbyteslice(self, start, end):
        """"""
        c = self._rawarray[start:end]
        return c
319949
def finish(self):
        
        chunks = []
        while lib.BrotliEncoderIsFinished(self._encoder) == lib.BROTLI_FALSE:
            chunks.append(self._compress(b'', lib.BROTLI_OPERATION_FINISH))

        return b''.join(chunks)
1031128
public function finish()
    {
        if ( $this->parserState != self::PARSE_STATE_POST_LAST )
        {
            // this should never happen
            // let's give the last parser a chance to clean up after himself
            if ( $this->currentPartParser !== null )
            {
                $part = $this->currentPartParser->finish();
                $this->partDone( $part );
                $this->currentPartParser = null;
            }
        }
        $multipart = $this->finishMultipart();
        ezcMailPartParser::parsePartHeaders( $this->headers, $multipart );
        $multipart->boundary = $this->boundary;
        return $multipart;
    }
1142889
private function extractBodyParts()
    {
        if (isset($this->body->pagination)) {
            $this->isPagination = true;
            $this->pagination = $this->body->pagination;
        }

        if (isset($this->body->meta)) {
            $this->isMetaData = true;
            $this->metaData = $this->body->meta;
        }

        $this->data = $this->body->data;
    }
447429
def format(self, parts):
        
        text = self.storage.state_separator.join(parts)
        return self.formatter(text)
1276388
def finalize(self):
        
        self._check_finalized()
        self._final = True

        for dest_w, values in self.dest_instrs_info.items():
            mux_vals = dict(zip(self.instructions, values))
            dest_w <<= sparse_mux(self.signal_wire, mux_vals)
896391
def raw(self):
        
        if self.input_string:
            return self.input_string[self.raw_start:self.raw_end]
        return None