def __init__(self, buf, callback, *args): StringIO.__init__(self, buf) self.seek(0, os.SEEK_END) self._total = self.tell() self.seek(0) self._callback = callback self._args = args
def __init__(self, terminal_type, capture): if terminal_type not in ['stdout', 'stderr']: raise Exception('Invalid terminal type') self.terminal_type = terminal_type self.terminal = sys.__dict__[self.terminal_type] self.capture = capture StringIO.__init__(self)
def __init__(self, conn, bucket_name, object_name, meta={}, buf=''): StringIO.__init__(self, buf) self.MAX_OBJECT_SIZE = 5368709120 #5GB self.conn = conn self.bucket_name = bucket_name self.object_name = object_name self.key = '%s/%s' % (self.bucket_name, self.object_name) self.meta = meta self.sent_len = 0 #num bytes that have been sent to Amazon self.get_complete = False #tells if the get of the object has been completed self.closed = False if buf: self.dirty = True else: self.dirty = False #any unflushed write will set dirty to true #make sure this bucket exists, otherwise create it response = self.conn.list_bucket(bucket_name) if response.http_response.status == 404: response = self.conn.create_bucket(bucket_name) check_http_response(response, 200) elif response.http_response.status != 200: raise S3ResponseError, response
def __init__(self,*args,**kwargs): self.name = args[0] self.mode = args[1] if self.mode == "r+b" or self.mode == "rb": StringIO.__init__(self, MC.get(self.name)) else: StringIO.__init__(self)
def __init__(self, request, stream_format = 'text/html'): StringIO.__init__(self) self.__stream_format = stream_format self.__request = request self.__open = 1 self.__utf8 = 0 self.__textual = stream_format.startswith("text/")
def __init__(self, *args, **kwargs): """ :type self: StringIO.StringIO """ StringIO.__init__(self) self.obd_header=[0x82, 0xf1, 0x7e] self.proto = 0
def __init__(self, *args, **kwargs): """The constructor, which passes the `*args, **kwargs` method to `StringIO.__init__`. """ StringIO.__init__(self, *args, **kwargs) self.priority = 1 self.lastMBox = None
def __init__(self, status=500, reason='Cuz I said so', mimetype='text/plain', content=''): StringIO.__init__(self, content) self.status = status self.reason = reason self.mimetype = mimetype self.msg = self # for self.msg.gettype()
def __init__(self, ssh_session, io_file): assert isinstance(ssh_session, SSHPrompt) self.ssh_session = ssh_session self.io_file = io_file self.io_file_open = True # noinspection PyTypeChecker,PyTypeChecker StringIO.__init__(self)
def __init__(self, name): """ @param name: Name of this file. @type name: C{str} """ self.name = name StringIO.__init__(self)
def __init__(self, mailfile, file_path, mode, metadata, *args, **kwargs): StringIO.__init__(self, *args, **kwargs) self._file_path = file_path self._open_mode = mode self._mailfile = mailfile self._lock = mailfile._lock self._metadata = metadata
def __init__(self, locq, running, replaces=None): #: The queue tokens will be placed in self.locq = locq #: The value indicating if the curses screen is running self.running = running #: The buffer this replaces. self.replaces = replaces StringIO.__init__(self)
def open(self, mode): """Recreates the StringIO base object to simulate opening.""" StringIO.__init__(self) if mode == 'w' or mode == 'w+': return self.write(self._contents) if mode == 'r' or mode == 'r+': self.seek(0, 0)
def __init__(self, fileobj, charset): # Return to position 0 fileobj.seek(0) # Put in StringIO StringIO.__init__(fileobj.read()) self.filename = fileobj.filename.decode(charset) self.type = fileobj.type self.headers = fileobj.headers
def __init__(self, name, message): """ Custom initialization method. :param str name: The filename. :return: Null """ self.name = name StringIO.__init__(self, message)
def __init__(self, response): #super(CachedResponse, self).__init__(response.read()) StringIO.__init__(self, response.read()) self.seek(0) self.headers = response.info() self.url = response.url self.code = response.code self.msg = response.msg
def __init__(self, orig, pid=None): StringIO.__init__(self) self.orig = orig self._queue = Queue() if pid is None: self.pid = os.getpid() else: self.pid = pid
def __init__(self, stream, **kwds): if type(stream) == str: data = stream else: data = stream.getvalue() self.filepath = self StringIO.__init__(self, data) MpegAudio.__init__(self, **kwds)
def __init__(self, handler, stream_format = 'text/html'): # 'handler' is a RequestHandler StringIO.__init__(self) self.__stream_format = stream_format self.__handler = handler self.__open = True self.__utf8 = False self.__textual = stream_format.startswith("text/")
def __init__(self,locq,running, replaces=None): #: The queue tokens will be placed in self.locq = locq #: The value indicating if the curses screen is running self.running = running #: The buffer this replaces. self.replaces = replaces StringIO.__init__(self)
def __init__(self, max_size=None, buffer=None): """ max_size is the max size of the buffer in bytes """ args = [] if buffer is not None: args.append(buffer) StringIO.__init__(self, *args) self.__max_size = max_size
def __init__(self, path, inode, mode): self.path = path self.inode = inode self.mode = mode if 'w' in mode: InodeLookupCache.delete(self.path) inode.put_content('') inode.put() StringIO.__init__(self, inode.get_content())
def __init__(self, file_object=None, fd=1): if file_object: self.buffer = file_object else: self.buffer = self self.fd = fd StringIO.__init__(self)
def __init__(self, uri, data='', filename='', mimeType='', format='', accept=''): self.uri = uri if data: self.data = data elif filename: if os.path.exists(filename): fh = file(filename) self.data = fh.read() fh.close() else: # try to fetch uri try: req = urllib2.Request(uri) if accept: # add custom accept header req.add_header('Accept', accept) else: # otherwise add default req.add_header('Accept', accept_header) fh = urllib2.urlopen(req) self.data = fh.read() self.info = fh.info() mimeType = self.info.dict.get('content-type', mimeType) self.uri = fh.geturl() fh.close() except: raise OreException( 'ReMDocument must either have data or filename') if not format: try: mt = conneg.parse(mimeType) if mt: mimeType = mt[0].mimetype1 + '/' + mt[0].mimetype2 except: pass mimeHash = { 'application/atom+xml': 'atom', 'application/xhtml+xml': 'rdfa', 'application/rdf+xml': 'xml', 'text/plain': 'nt', # yes, really 'text/rdf+n3': 'n3', 'application/x-turtle': 'turtle', 'application/rdf+nt': 'nt' } format = mimeHash.get(mimeType, '') self.mimeType = mimeType self.format = format StringIO.__init__(self, self.data)
def __init__(self, filename=None): if filename != None: self.filename = filename else: self.filename = None if self.filename != None: StringIO.__init__(self, open(self.filename).read()) else: StringIO.__init__(self)
def __init__(self, data='', code=200): """Create a new mock object for the objects returned by url_open. Args: data: str. Response data. code: int. HTTP response code. """ StringIO.__init__(self, data) self.code = code
def __init__(self, buffer='', writers=None): """If ``writers`` is given and is a file-like object or an iterable of same, it/they will be written to whenever this StringIO instance is written to. """ StringIO.__init__(self, buffer) if writers is None: writers = [] elif hasattr(writers, 'write'): writers = [writers] self.writers = writers
def __init__(self, buffer='', cc=None): """ If ``cc`` is given and is a file-like object or an iterable of same, it/they will be written to whenever this StringIO instance is written to. """ StringIO.__init__(self, buffer) if cc is None: cc = [] elif hasattr(cc, 'write'): cc = [cc] self.cc = cc
def __init__(self, *args, **kwargs): """Summary Args: *args: Description **kwargs: Description """ if 'logger' in kwargs: self.log = kwargs['logger'] or logging.getLogger(__name__ + '.' + self.__class__.__name__) self.managers = weakref.WeakValueDictionary() StringIO.__init__(self, *args, **kwargs)
def __init__(self, old_stdout, old_stderr, useold): """ Initializes the Logger object Extends StringIO in order to capture stdout and stderr @param old_stdout @param old_stderr @param useold """ StringIO.__init__(self) #overriding object must implement StringIO self.output = Tkinter.StringVar() self.useold = useold self.old_stdout = old_stdout self.old_stderr = old_stderr
def __init__(self, filename): """ constructor @param filename filename """ StringIO.__init__(self) self.filename = filename if os.path.exists(filename): os.remove(filename) self.handle = None self.redirect = {} self.to = None
def __init__(self, name='', **kw): StringIO.__init__(self) self.name = name self.is_sub = False self.is_main = False self.duration = 0 self.settings = deepcopy(self.DEFAULT_PARA) for key in kw: self.settings[key] = kw[key] self.seq = [] self.stats = [0, 0] self.write('MAGIC 3004\r\nLINES ') self.update(trailer=True)
def __init__(self, data, path, mode, filemgr): """ @param data: initial contents. Ignored if opened in write mode. @param path: path to the file @param mode: e.g. 'r', 'r+', 'w', 'a' @param filemgr: a filesystem (DatabaseFS instance) with at least the following funcitons: - flush_callback(path,data): called every time file is flushed - close_callback(path): called when file is closed """ StringIO.__init__(self, data if 'w' not in mode else '') if mode=='r' or '+' in mode: self.seek(0) self.filemgr = filemgr self.path = path self.mode = mode self.modified = False
def __init__(self, data, path, mode, filemgr): """ @param data: initial contents. Ignored if opened in write mode. @param path: path to the file @param mode: e.g. 'r', 'r+', 'w', 'a' @param filemgr: a filesystem (DatabaseFS instance) with at least the following funcitons: - flush_callback(path,data): called every time file is flushed - close_callback(path): called when file is closed """ StringIO.__init__(self, data if 'w' not in mode else '') if mode == 'r' or '+' in mode: self.seek(0) self.filemgr = filemgr self.path = path self.mode = mode self.modified = False
def __init__(self, old_stdout, old_stderr, logpath, useold=True): """ Initializes the Logger object Extends StringIO in order to capture stdout and stderr @param parent @param gui @param options """ StringIO.__init__(self) #overriding object must implement StringIO self.logpath = logpath if (not os.path.exists(self.logpath)): os.makedirs(self.logpath) self.logfile = os.path.join(self.logpath, 'output.log') self.useold = useold self.old_stdout = old_stdout self.old_stderr = old_stderr
def __init__(self, num, thread, download, buf=''): StringIO.__init__(self) # Force self.buf to be a string or unicode if not isinstance(buf, basestring): buf = str(buf) self.buf = buf self.len = len(buf) self.buflist = [] self.pos = 0 self.closed = False self.softspace = 0 self.thread = thread self.num = num self.download = download self.total = self.len * self.thread
def __init__(self, total, line_count, update_interval=.05): StringIO.__init__(self) self.container = {} self.counter = {} self.total = total self.columns = ['name', 'progress', 'update', 'count'] self._make_board(line_count) if self._is_notebook(): self.fmt = self._notebook_format self.flush = self._notebook_flush else: self.fmt = self._console_format self.flush = self._console_flush interval = int(update_interval * self.total) self.interval = interval if interval > 0 else 1
def __init__(self, info, parent_name): """ Creates an instance of the internal file based on the data in the intenral file. :Paramters: - `info`: cpioarchive item from ._infos - `parent_name`: name of the parent file """ StringIO.__init__(self, info.read()) self.name = info.name class Dummy(object): pass self.fileobj = Dummy() self.fileobj.name = parent_name
def __init__( self, stream = sys.stdout, loglevel = info, *args, **kwargs ): self.stream = stream self.loglevel = loglevel return StringIO.__init__(self, *args, **kwargs)
def __init__(self, windows): StringIO.__init__(self) self.windows = windows self.autoscroll = {} self.pos = {} self.lines = {} self.maxsize = {} self.stdout = None self.logfile = None self.wrapper = TextWrapper(width=80, initial_indent="", subsequent_indent=" ", replace_whitespace=False) if NCURSES: for windex in windows: h, w = windows[windex][0].getmaxyx() self.maxsize[windex] = (h, w) self.pos[windex] = [0, 0] self.autoscroll[windex] = True self.lines[windex] = 0
def __init__(self, source = None, name = "data") : """Constructor @param source Source data to compress (as a stream/File/Buffer - anything with a read() method) @param name Name of the data within the zip file""" # Source file self.source = source # OEF reached for source ? self.source_eof = False # Buffer self.buffer = "" StringIO.__init__(self) # Inherited constructor # Init ZipFile that writes to us (the StringIO buffer) self.zipfile = GzipFile(name, 'wb', 9, self)
def __init__(self, source=None, name="data"): """Constructor @param source Source data to compress (as a stream/File/Buffer - anything with a read() method) @param name Name of the data within the zip file""" # Source file self.source = source # OEF reached for source ? self.source_eof = False # Buffer self.buffer = "" StringIO.__init__(self) # Inherited constructor # Init ZipFile that writes to us (the StringIO buffer) self.zipfile = GzipFile(name, 'wb', 9, self)
def __init__(self, filename, opt=''): self.opt = opt buf = '' self.filename = xbmcvfs_path(filename) if 'r' in opt or 'a' in opt: exst = exists(filename) if not exst and 'r' in opt: from errno import ENOENT raise IOError(ENOENT, 'Not a file', filename) if exst: # read f = xbmcvfs.File(self.filename) buf = f.read() f.close() StringIO.__init__(self, buf) if 'a' in opt: self.seek(0, mode=2)
def __init__(self, parent, ira_browse, mode): nodes.node_descriptor.__init__(self, parent) self._size = 0L if mode.endswith('b'): mode = mode[:-1] if mode in ('r', 'r+'): cr = ira_browse._cr # reuse the cursor of the browse object, just now cr.execute('SELECT db_datas FROM ir_attachment WHERE id = %s', (ira_browse.id, )) data = cr.fetchone()[0] if data: self._size = len(data) StringIO.__init__(self, data) elif mode in ('w', 'w+'): StringIO.__init__(self, None) # at write, we start at 0 (= overwrite), but have the original # data available, in case of a seek() elif mode == 'a': StringIO.__init__(self, None) else: logging.getLogger('document.storage').error( "Incorrect mode %s specified", mode) raise IOError(errno.EINVAL, "Invalid file mode") self.mode = mode
def __init__(self, hosted_file, mode, content_type=None, filename=None): self.url = hosted_file._wadl_resource.url if mode == 'r': if content_type is not None: raise ValueError("Files opened for read access can't " "specify content_type.") if filename is not None: raise ValueError("Files opened for read access can't " "specify filename.") response, value = hosted_file._root._browser.get( self.url, return_response=True) content_type = response['content-type'] last_modified = response.get('last-modified') # The Content-Location header contains the URL of the file # hosted by the web service. We happen to know that the # final component of the URL is the name of the uploaded # file. content_location = response['content-location'] path = urlparse(content_location)[2] filename = urllib.unquote(path.split("/")[-1]) elif mode == 'w': value = '' if content_type is None: raise ValueError("Files opened for write access must " "specify content_type.") if filename is None: raise ValueError("Files opened for write access must " "specify filename.") last_modified = None else: raise ValueError("Invalid mode. Supported modes are: r, w") self.hosted_file = hosted_file self.mode = mode self.content_type = content_type self.filename = filename self.last_modified = last_modified StringIO.__init__(self, value)
def __init__(self, stream, parameters): """ Create a TemplatedStream by populating variables from the parameters mapping. Silently passes matching strings that do not have a corresponding key defined in parameters as empty strings. """ StringIO.__init__(self) def dbrace_expand(match): if match.group(1) in parameters: # we may occassionally be handed non-string object in # parameters. Just convert them to string, they will # be re-run through the YAML parser anyway. return str(parameters[match.group(1)]) else: return '' for line in stream: self.write(self.dbrace_re.sub(dbrace_expand, line)) self.seek(0)