Get content of tape.
559206
def get_tape(self):
        """"""
        result = ''
        for i in range(min(self.tape), max(self.tape) + 1):
            symbol = self.tape[i] if self.tape[i] != self.EMPTY_SYMBOL else ' '
            result += symbol
        # Remove unnecessary empty symbols on tape
        return result.strip()
727270
def content_bytes(self):
        """"""
        get_message = \
            self._communication.needle_positions.get_line_configuration_message
        return get_message(self._line_number)
33569
def _get_html_contents(html):
    """"""
    parser = MyHTMLParser()
    parser.feed(html)
    if parser.is_code:
        return ('code', parser.data.strip())
    elif parser.is_math:
        return ('math', parser.data.strip())
    else:
        return '', ''
72542
def get_content(self, obj):
        """"""
        election_day = ElectionDay.objects.get(
            date=self.context['election_date'])
        return PageContent.objects.office_content(election_day, obj)
688809
def get_content(path):
    """"""
    with codecs.open(abs_path(path), encoding='utf-8') as f:
        return f.read()
182196
def contents(self):
        """"""
        if not self._contents:
            if self._path:
                # Read file into memory so we don't run out of file descriptors
                f = open(self._path, "rb")
                self._contents = f.read()
                f.close()
            elif self._pil_image:
                # Write PIL image to string
                f = StringIO()
                self._pil_image.save(f, self.format)
                self._contents = f.getvalue()
        return self._contents
1362179
def content(self):
        """"""
        return _bfd.section_get_content(self.bfd, self._ptr, 0, self.size)
572817
def _unpack(self, content):
        """"""
        if self.compressor:
            try:
                content = self.compressor.decompress(content)
            except CompressError:
                pass
        if self.serializer:
            content = self.serializer.deserialize(content)
        return content
326137
def get(self):
        """"""
        r = self._session.get(self.content, headers={'Accept': '*/*'})
        return r.content
391477
def pluck(self) :
		""""""
		e = copy.copy(self)
		e.transcript = str(self.transcript)
		return e
783395
def get_content(self, obj):
        
        serializer = ContentSerializer(
            instance=obj.contentitem_set.all(),
            many=True,
            context=self.context,
        )
        return serializer.data
798310
def get_file_contents(self, pointer=False):
        '''
        
        '''
        if self.pointer:
            if pointer:
                return self.old_pointed
            else:
                return self.old_data
        else:
            return self.old_data
569008
def _get_contents_between(string, opener, closer):
    
    opener_location = string.index(opener)
    closer_location = string.index(closer)
    content = string[opener_location + 1:closer_location]
    return content
551923
def content(self):
        
        raw_content = self._manager.api.session.get(self.download_link).content
        data = BytesIO(raw_content)
        archive = ZipFile(data)
        filename = archive.filelist[0]  # Always 1 file in the archive
        return archive.read(filename)
148885
def _remotes_txt_content(self):
    """"""
    return '{}\n'.format('\n'.join(
      '{name} {url} {is_ssl}'.format(
        name=name,
        url=url,
        is_ssl=re.match(r'^https://', url) is not None)
        for name, url in self.get_options().conan_remotes.items()))
1159262
def get_data(self, path):
        """"""
        return LineCacheNotebookDecoder(
            code=self.code, raw=self.raw, markdown=self.markdown
        ).decode(self.decode(), self.path)
805860
def iter_content(self, chunk_size=1024):
        """"""
        r = self._session.get(self.content, stream=True)
        return r.iter_content(chunk_size)