def get_migration_status(**options): # type: (**Any) -> str verbosity = options.get('verbosity', 1) for app_config in apps.get_app_configs(): if module_has_submodule(app_config.module, "management"): import_module('.management', app_config.name) app_labels = [options['app_label']] if options.get('app_label') else None db = options.get('database', DEFAULT_DB_ALIAS) out = StringIO() call_command( 'showmigrations', '--list', app_labels=app_labels, database=db, no_color=options.get('no_color', False), settings=options.get('settings', os.environ['DJANGO_SETTINGS_MODULE']), stdout=out, traceback=options.get('traceback', True), verbosity=verbosity, ) connections.close_all() out.seek(0) output = out.read() return re.sub('\x1b\[(1|0)m', '', output)
def export_info(self, context, info): data = StringIO() out = zipfile.ZipFile(data, 'w') for d in info: path = d.get('path', d.get('id')) filename = os.path.basename(path) dir_path = os.path.dirname(path) # Write data _d = d.get('data', '') fpath = os.path.join(dir_path, filename) out.writestr(fpath, _d) metadata = d.copy() for name in ('data', 'path'): if name in metadata: del metadata[name] # Write metadata metadata_path = os.path.join(dir_path, '.metadata') fpath = os.path.join(metadata_path, filename) _d = str(self.atxml_template(info=metadata)) out.writestr(fpath, _d) out.close() data.seek(0) return data
def test_num_failures_by_type(capfd): # Test that the number of failures by status type is correctly calculated. # Set up the handler. output = StringIO() logger = structuredlog.StructuredLogger("test_a") logger.add_handler(handlers.StreamHandler(output, ChromiumFormatter())) # Run some tests with different statuses: 3 passes, 1 timeout logger.suite_start(["t1", "t2", "t3", "t4"], run_info={}, time=123) logger.test_start("t1") logger.test_end("t1", status="PASS", expected="PASS") logger.test_start("t2") logger.test_end("t2", status="PASS", expected="PASS") logger.test_start("t3") logger.test_end("t3", status="PASS", expected="FAIL") logger.test_start("t4") logger.test_end("t4", status="TIMEOUT", expected="CRASH") logger.suite_end() # check nothing got output to stdout/stderr # (note that mozlog outputs exceptions during handling to stderr!) captured = capfd.readouterr() assert captured.out == "" assert captured.err == "" # check the actual output of the formatter output.seek(0) num_failures_by_type = json.load(output)["num_failures_by_type"] # We expect 3 passes and 1 timeout, nothing else. assert sorted(num_failures_by_type.keys()) == ["PASS", "TIMEOUT"] assert num_failures_by_type["PASS"] == 3 assert num_failures_by_type["TIMEOUT"] == 1
def test_chromium_required_fields(capfd): # Test that the test results contain a handful of required fields. # Set up the handler. output = StringIO() logger = structuredlog.StructuredLogger("test_a") logger.add_handler(handlers.StreamHandler(output, ChromiumFormatter())) # output a bunch of stuff logger.suite_start(["test-id-1"], run_info={}, time=123) logger.test_start("test-id-1") logger.test_end("test-id-1", status="PASS", expected="PASS") logger.suite_end() # check nothing got output to stdout/stderr # (note that mozlog outputs exceptions during handling to stderr!) captured = capfd.readouterr() assert captured.out == "" assert captured.err == "" # check the actual output of the formatter output.seek(0) output_obj = json.load(output) # Check for existence of required fields assert "interrupted" in output_obj assert "path_delimiter" in output_obj assert "version" in output_obj assert "num_failures_by_type" in output_obj assert "tests" in output_obj test_obj = output_obj["tests"]["test-id-1"] assert "actual" in test_obj assert "expected" in test_obj
def _decompress_xz(filename): """Eumlates an option function in read mode for xz. See the comment in _compress_xz for more information. This function tries to emulate the lzma module as much as possible """ if not filename.endswith('.xz'): filename = '{}.xz'.format(filename) try: with open(os.devnull, 'w') as null: string = subprocess.check_output( ['xz', '--decompress', '--stdout', filename], stderr=null) except OSError as e: if e.errno == errno.ENOENT: raise exceptions.PiglitFatalError( 'No xz binary available') raise # We need a file-like object, so the contents must be placed in # a StringIO object. io = StringIO() io.write(string) io.seek(0) yield io io.close()
def test_error(self): sio = StringIO() sio.write("bogus") sio.seek(0) r = flow.FlowReader(sio) tutils.raises(flow.FlowReadError, list, r.stream()) f = flow.FlowReadError("foo") assert f.strerror == "foo"
def colorize(source): """ write colorized version to "[filename].py.html" """ html = StringIO() Parser(source, html).format(None, None) html.flush() html.seek(0) return html.read()
def test_error(self): sio = StringIO() sio.write("bogus") sio.seek(0) r = flow.FlowReader(sio) tutils.raises(FlowReadException, list, r.stream()) f = FlowReadException("foo") assert str(f) == "foo"
def test_versioncheck(self): f = tutils.tflow() d = f.get_state() d["version"] = (0, 0) sio = StringIO() tnetstring.dump(d, sio) sio.seek(0) r = flow.FlowReader(sio) tutils.raises("version", list, r.stream())
def test_copy_from_cols(self): curs = self.conn.cursor() f = StringIO() for i in xrange(10): f.write("%s\n" % (i,)) f.seek(0) curs.copy_from(MinimalRead(f), "tcopy", columns=['id']) curs.execute("select * from tcopy order by id") self.assertEqual([(i, None) for i in range(10)], curs.fetchall())
def _treader(self): sio = StringIO() w = flow.FlowWriter(sio) for i in range(3): f = tutils.tflow(resp=True) w.add(f) for i in range(3): f = tutils.tflow(err=True) w.add(f) sio.seek(0) return flow.FlowReader(sio)
def read(self, html=None, code='@'): '''Get the content of the clipboard. html: BOOL. Whether to get the raw HTML code of the fomatted text on clipboard. code: coding of the text on clipboard.''' if (not html) and (not code): return super().read() else: stream = StringIO() clipb.clipboard_to_stream(stream, mode=None, code=code, null=None, html=html) stream.seek(0) return stream.read()
def _copy_to(self, curs, srec): f = StringIO() curs.copy_to(MinimalWrite(f), "tcopy") f.seek(0) ntests = 0 for line in f: n, s = line.split() if int(n) < len(string.ascii_letters): self.assertEqual(s, string.ascii_letters[int(n)] * srec) ntests += 1 self.assertEqual(ntests, len(string.ascii_letters))
def test_copy_from_cols_err(self): curs = self.conn.cursor() f = StringIO() for i in xrange(10): f.write("%s\n" % (i,)) f.seek(0) def cols(): raise ZeroDivisionError() yield 'id' self.assertRaises(ZeroDivisionError, curs.copy_from, MinimalRead(f), "tcopy", columns=cols())
def test_roundtrip(self): sio = StringIO() f = tutils.tflow() f.request.content = "".join(chr(i) for i in range(255)) w = flow.FlowWriter(sio) w.add(f) sio.seek(0) r = flow.FlowReader(sio) l = list(r.stream()) assert len(l) == 1 f2 = l[0] assert f2.get_state() == f.get_state() assert f2.request == f.request
def test_filter(self): sio = StringIO() fl = filt.parse("~c 200") w = flow.FilteredFlowWriter(sio, fl) f = tutils.tflow(resp=True) f.response.status_code = 200 w.add(f) f = tutils.tflow(resp=True) f.response.status_code = 201 w.add(f) sio.seek(0) r = flow.FlowReader(sio) assert len(list(r.stream()))
def _copy_from(self, curs, nrecs, srec, copykw): f = StringIO() for i, c in izip(xrange(nrecs), cycle(string.ascii_letters)): l = c * srec f.write("%s\t%s\n" % (i,l)) f.seek(0) curs.copy_from(MinimalRead(f), "tcopy", **copykw) curs.execute("select count(*) from tcopy") self.assertEqual(nrecs, curs.fetchone()[0]) curs.execute("select data from tcopy where id < %s order by id", (len(string.ascii_letters),)) for i, (l,) in enumerate(curs): self.assertEqual(l, string.ascii_letters[i] * srec)
def test_copy_no_column_limit(self): cols = [ "c%050d" % i for i in range(200) ] curs = self.conn.cursor() curs.execute('CREATE TEMPORARY TABLE manycols (%s)' % ',\n'.join( [ "%s int" % c for c in cols])) curs.execute("INSERT INTO manycols DEFAULT VALUES") f = StringIO() curs.copy_to(f, "manycols", columns = cols) f.seek(0) self.assertEqual(f.read().split(), ['\\N'] * len(cols)) f.seek(0) curs.copy_from(f, "manycols", columns = cols) curs.execute("select count(*) from manycols;") self.assertEqual(curs.fetchone()[0], 2)
def test_reftest_screenshots(capfd): # reftest_screenshots, if present, should be plumbed into artifacts. # Set up the handler. output = StringIO() logger = structuredlog.StructuredLogger("test_a") logger.add_handler(handlers.StreamHandler(output, ChromiumFormatter())) # Run a reftest with reftest_screenshots. logger.suite_start(["t1"], run_info={}, time=123) logger.test_start("t1") logger.test_end("t1", status="FAIL", expected="PASS", extra={ "reftest_screenshots": [ { "url": "foo.html", "hash": "HASH1", "screenshot": "DATA1" }, "!=", { "url": "foo-ref.html", "hash": "HASH2", "screenshot": "DATA2" }, ] }) logger.suite_end() # check nothing got output to stdout/stderr # (note that mozlog outputs exceptions during handling to stderr!) captured = capfd.readouterr() assert captured.out == "" assert captured.err == "" # check the actual output of the formatter output.seek(0) output_json = json.load(output) test_obj = output_json["tests"]["t1"] assert test_obj["artifacts"]["screenshots"] == [ "foo.html: DATA1", "foo-ref.html: DATA2", ]
def render(self, ctx, req): if not xlwt: return '' # pragma: no cover wb = xlwt.Workbook() ws = wb.add_sheet(ctx.__unicode__()) for i, col in enumerate(self.header(ctx, req)): ws.write(0, i, col) for j, item in enumerate(ctx.get_query(limit=1000)): for i, col in enumerate(self.row(ctx, req, item)): ws.write(j + 1, i, col) out = StringIO() wb.save(out) out.seek(0) return out.read()
def test_unexpected_subtest_pass(capfd): # A subtest that unexpectedly passes is considered a failure condition. # Set up the handler. output = StringIO() logger = structuredlog.StructuredLogger("test_a") formatter = ChromiumFormatter() logger.add_handler(handlers.StreamHandler(output, formatter)) # Run a test with a subtest that is expected to fail but passes. logger.suite_start(["t1"], run_info={}, time=123) logger.test_start("t1") logger.test_status("t1", status="PASS", expected="FAIL", subtest="t1_a", message="t1_a_message") # Since the subtest behaviour is unexpected, it's considered a failure, so # the test should be added to the set of tests with subtest failures. assert "t1" in formatter.tests_with_subtest_fails # The test status is reported as a pass here because the harness was able to # run the test to completion. logger.test_end("t1", status="PASS", expected="PASS") logger.suite_end() # check nothing got output to stdout/stderr # (note that mozlog outputs exceptions during handling to stderr!) captured = capfd.readouterr() assert captured.out == "" assert captured.err == "" # check the actual output of the formatter output.seek(0) output_json = json.load(output) test_obj = output_json["tests"]["t1"] t1_artifacts = test_obj["artifacts"] assert t1_artifacts["log"] == "[PASS expected FAIL] t1_a: t1_a_message\n" assert t1_artifacts["wpt_subtest_failure"] == "true" # Since the subtest status is unexpected, we fail the test. But we report # wpt_actual_status as an artifact assert t1_artifacts["wpt_actual_status"] == "PASS" assert test_obj["actual"] == "FAIL" assert test_obj["expected"] == "PASS" # Also ensure that the formatter cleaned up its internal state assert "t1" not in formatter.tests_with_subtest_fails
def table_io(self,fmt,obj=False, missing=False,ignore=True,required=False,extra=False): from ekklesia.data import objects_equal columns = ('a','b','c') coltypes = {'a':int,'b':int,'c':(int,)} t = DataTable(columns,coltypes=coltypes,fileformat=fmt,ignore=ignore,required=required) if fmt in ('json','jsondict'): f = {} else: f = StringIO() t.open(f,'w') if obj: t.write(Obj(a=0)) t.write(Obj(a=1)) elif missing: try: t.write({'a':0,'b':2}) assert ignore except: assert not ignore return elif extra: try: t.write({'a':0,'b':2,'c':[3,4],'d':4}) assert ignore except: assert not ignore return else: for i in range(3): t.write({'a':i,'b':2,'c':[3,4]}) if fmt in ('json','jsondict'): f2 = t.close() assert f is f2 else: t.close() f.seek(0) t = DataTable(columns,coltypes=coltypes,fileformat=fmt) t.open(f,'r') i = 0 for row in t: if obj: assert objects_equal(Obj(**row),Obj(a=i)) else: if missing: assert row == {'a':0,'b':2,'c':[]} else: assert row == {'a':i,'b':2,'c':[3,4]} i+=1 t.close()
def old(self, no_reduce_db): try: if no_reduce_db: touch('./dummydb') fileobj = StringIO() self.write_pdb(fileobj) fileobj.seek(0) reduce = os.path.join(os.getenv('LIBTBX_BUILD'), 'reduce', 'exe', 'reduce') if not os.path.exists(reduce): reduce = 'phenix.reduce' cmd = [reduce, '-BUILD', '-NUC', '-NOFLIP', '-DB ./dummydb', '-'] if no_reduce_db: process = subprocess.Popen([ reduce, '-BUILD', '-NUC', '-NOFLIP', '-DB ./dummydb', '-' ], stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE) else: process = subprocess.Popen( [reduce, '-BUILD', '-NUC', '-NOFLIP', '-'], stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE) out, err = process.communicate(str.encode(fileobj.read())) out = out.decode() err = err.decode() if process.wait(): logger.error("REDUCE returned non-zero exit status: " "See reduce_info.log for more details") # print out the reduce log even if it worked with open('reduce_info.log', 'w') as fh: fh.write(err) pdbh = StringIO(out) # not using load_file since it does not read StringIO print('-' * 80) print(pdbh) print('-' * 80) self.parm = parmed.read_PDB(pdbh) finally: fileobj.close() if no_reduce_db: os.unlink('./dummydb') return self
def write(self, content, html=None, table=None, code=None): '''Set clipboard content. content: the object which will be put onto the clipboard. html: BOOL. Whether the content is rich text coded in HTML. Default: False table: BOOL. Whether the content is a table. Default: False code: string. The coding of the content text.''' if table: from wavesynlib.languagecenter.html.utils import iterable_to_table html = True content = iterable_to_table(content) if (not html) and (not code) : super().write(content) else: stream = StringIO() stream.write(content) stream.seek(0) clipb.stream_to_clipboard(stream, mode=None, code=code, tee=None, null=None, html=html)
def parse(text, encoding='utf8'): """Parse the querystring into a normalized form.""" # Initialize the query object. query = Query() # Decode the text if we got bytes. if isinstance(text, six.binary_type): text = text.decode(encoding) # Iterate through the characters in the query string; one-by-one # in order to perform one-pass parsing. stream = StringIO() for character in text: # We want to stop reading the query and pass it off to someone # when we reach a logical or grouping operator. if character in (constants.LOGICAL_AND, constants.LOGICAL_OR): if not stream.tell(): # There is no content in the stream; a logical operator # was found out of place. raise ValueError('Found `{}` out of place'.format( character)) # Parse the segment up till the combinator segment = parse_segment(stream.getvalue(), character) query.segments.append(segment) stream.truncate(0) stream.seek(0) else: # This isn't a special character, just roll with it. stream.write(character) # TODO: Throw some nonsense here if the query string ended with a # & or ;, because that makes no sense. if stream.tell(): # Append the remainder of the query string. query.segments.append(parse_segment(stream.getvalue())) # Return the constructed query object. return query
def add_hydrogen(self, no_reduce_db=False): ''' Use reduce program to add hydrogen Parameters ---------- obj: file object or parmed.Structure or its derived class Returns ------- parm : parmed.Structure Requires -------- reduce ''' def touch(fname, times=None): with open(fname, 'a'): os.utime(fname, times) from mmtbx.utils import run_reduce_with_timeout parameters = '-BUILD -NUC -NOFLIP' if no_reduce_db: touch('./dummydb') parameters += ' -DB ./dummydb' parameters += ' -' fileobj = StringIO() self.write_pdb(fileobj) fileobj.seek(0) reduce_out = run_reduce_with_timeout( parameters=parameters, stdin_lines=fileobj.read(), stdout_splitlines=False, ) assert reduce_out.return_code == 0 pdbh = StringIO() pdbh.write(reduce_out.stdout_buffer) pdbh.seek(0) self.parm = parmed.read_PDB(pdbh) return self
def do_http(method, url, body=""): if isinstance(body, str): body = StringIO(body) elif isinstance(body, unicode): raise TypeError("do_http body must be a bytestring, not unicode") else: # We must give a Content-Length header to twisted.web, otherwise it # seems to get a zero-length file. I suspect that "chunked-encoding" # may fix this. assert body.tell assert body.seek assert body.read scheme, host, port, path = parse_url(url) if scheme == "http": c = httplib.HTTPConnection(host, port) elif scheme == "https": c = httplib.HTTPSConnection(host, port) else: raise ValueError("unknown scheme '%s', need http or https" % scheme) c.putrequest(method, path) c.putheader("Hostname", host) c.putheader("User-Agent", allmydata.__full_version__ + " (tahoe-client)") c.putheader("Accept", "text/plain, application/octet-stream") c.putheader("Connection", "close") old = body.tell() body.seek(0, os.SEEK_END) length = body.tell() body.seek(old) c.putheader("Content-Length", str(length)) try: c.endheaders() except socket_error as err: return BadResponse(url, err) while True: data = body.read(8192) if not data: break c.send(data) return c.getresponse()
def list_directory(self, path): """Helper to produce a directory listing (absent index.html). Return value is either a file object, or None (indicating an error). In either case, the headers are sent, making the interface the same as for send_head(). """ try: list = os.listdir(path) except os.error: self.send_error(404, "No permission to list directory") return None list.sort(key=lambda a: a.lower()) f = StringIO() displaypath = cgi.escape(urllib.unquote(self.path)) f.write('<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 3.2 Final//EN">') f.write("<html>\n<title>Directory listing for %s</title>\n" % displaypath) f.write("<body>\n<h2>Directory listing for %s</h2>\n" % displaypath) f.write("<hr>\n<ul>\n") for name in list: fullname = os.path.join(path, name) displayname = linkname = name # Append / for directories or @ for symbolic links if os.path.isdir(fullname): displayname = name + "/" linkname = name + "/" if os.path.islink(fullname): displayname = name + "@" # Note: a link to a directory displays with @ and links with / f.write('<li><a href="%s">%s</a>\n' % (urllib.quote(linkname), cgi.escape(displayname))) f.write("</ul>\n<hr>\n</body>\n</html>\n") length = f.tell() f.seek(0) self.send_response(200) encoding = sys.getfilesystemencoding() self.send_header("Content-type", "text/html; charset=%s" % encoding) self.send_header("Content-Length", str(length)) self.end_headers() return f
def is_balanced_statement(lines): """ Checks if the lines have balanced parens, brakets, curlies and strings Args: lines (list): list of strings Returns: bool: False if the statement is not balanced Doctest: >>> assert is_balanced_statement(['print(foobar)']) >>> assert is_balanced_statement(['foo = bar']) is True >>> assert is_balanced_statement(['foo = (']) is False >>> assert is_balanced_statement(['foo = (', "')(')"]) is True >>> assert is_balanced_statement( ... ['foo = (', "'''", ")]'''", ')']) is True >>> #assert is_balanced_statement(['foo = ']) is False >>> #assert is_balanced_statement(['== ']) is False """ from six.moves import cStringIO as StringIO import tokenize block = "\n".join(lines) if six.PY2: block = block.encode("utf8") stream = StringIO() stream.write(block) stream.seek(0) try: for t in tokenize.generate_tokens(stream.readline): pass except tokenize.TokenError as ex: message = ex.args[0] if message.startswith("EOF in multi-line"): return False raise else: # Note: trying to use ast.parse(block) will not work # here because it breaks in try, except, else return True
def test_subtest_messages(capfd): # Tests accumulation of test output # Set up the handler. output = StringIO() logger = structuredlog.StructuredLogger("test_a") logger.add_handler(handlers.StreamHandler(output, ChromiumFormatter())) # Run two tests with subtest messages. The subtest name should be included # in the output. We should also tolerate missing messages. logger.suite_start(["t1", "t2"], run_info={}, time=123) logger.test_start("t1") logger.test_status("t1", status="FAIL", subtest="t1_a", message="t1_a_message") logger.test_status("t1", status="PASS", subtest="t1_b", message="t1_b_message") logger.test_end("t1", status="PASS", expected="PASS") logger.test_start("t2") # Currently, subtests with empty messages will be ignored logger.test_status("t2", status="PASS", subtest="t2_a") # A test-level message will also be appended logger.test_end("t2", status="TIMEOUT", expected="PASS", message="t2_message") logger.suite_end() # check nothing got output to stdout/stderr # (note that mozlog outputs exceptions during handling to stderr!) captured = capfd.readouterr() assert captured.out == "" assert captured.err == "" # check the actual output of the formatter output.seek(0) output_json = json.load(output) t1_log = output_json["tests"]["t1"]["artifacts"]["log"] assert t1_log == "subtest_failure\n" \ "[FAIL expected PASS] t1_a: t1_a_message\n" \ "[PASS] t1_b: t1_b_message\n" t2_log = output_json["tests"]["t2"]["artifacts"]["log"] assert t2_log == "[TIMEOUT expected PASS] t2_message\n"
def dumps(self, indent=4): """ Writes the dataset out to the json format Example: >>> from coco_wrangler.coco_api import * >>> dataset = demo_coco_data() >>> self = CocoDataset(dataset, tag='demo') >>> text = self.dumps() >>> print(text) >>> self2 = CocoDataset(json.loads(text), tag='demo2') >>> assert self2.dataset == self.dataset >>> assert self2.dataset is not self.dataset """ from six.moves import cStringIO as StringIO fp = StringIO() self.dump(fp, indent=indent) fp.seek(0) text = fp.read() return text
def marshall(self, obj, marshaller): REQUEST = obj.REQUEST RESPONSE = REQUEST.RESPONSE ddata = marshaller.marshall(obj, REQUEST=REQUEST, RESPONSE=RESPONSE) if hasattr(aq_base(obj), 'marshall_hook') \ and obj.marshall_hook: ddata = obj.marshall_hook(ddata) content_type, length, data = ddata if isinstance(data, six.string_types): return StringIO(data) s = StringIO() while data is not None: s.write(data.data) data = data.next s.seek(0) return s
def test_subtest_messages(capfd): # Tests accumulation of test output # Set up the handler. output = StringIO() logger = structuredlog.StructuredLogger("test_a") logger.add_handler(handlers.StreamHandler(output, ChromiumFormatter())) # Run two tests with subtest messages. The subtest name should be included # in the output. We should also tolerate missing messages. logger.suite_start(["t1", "t2"], run_info={}, time=123) logger.test_start("t1") logger.test_status("t1", status="FAIL", subtest="t1_a", message="t1_a_message") logger.test_status("t1", status="PASS", subtest="t1_b", message="t1_b_message") logger.test_end("t1", status="PASS", expected="PASS") logger.test_start("t2") # Currently, subtests with empty messages will be ignored logger.test_status("t2", status="PASS", subtest="t2_a") # A test-level message will also be appended logger.test_end("t2", status="TIMEOUT", expected="PASS", message="t2_message") logger.suite_end() # check nothing got output to stdout/stderr # (note that mozlog outputs exceptions during handling to stderr!) captured = capfd.readouterr() assert captured.out == "" assert captured.err == "" # check the actual output of the formatter output.seek(0) output_json = json.load(output) t1_log = output_json["tests"]["t1"]["artifacts"]["log"] assert t1_log == "[FAIL] t1_a: t1_a_message\n" \ "[PASS] t1_b: t1_b_message\n" t2_log = output_json["tests"]["t2"]["artifacts"]["log"] assert t2_log == "[TIMEOUT] t2_message\n"
def make_string_buffer(string): """Returns a readable/writeable file-like object, containing string. >>> f = make_string_buffer(u'text') >>> print(f.read()) text If the string is a bytestring, then the returned object will operate in binary mode. >>> f = make_string_buffer(b'bytes') >>> f.read() == b'bytes' True """ if isinstance(string, six.text_type): buf = StringIO() else: buf = io.BytesIO() buf.write(string) buf.seek(0) return buf
def test_copy_from_with_fks(self): curs = self.conn.cursor() curs.execute(''' CREATE TEMPORARY TABLE tcopy_ref ( id serial, FOREIGN KEY(id) REFERENCES tcopy ) ''') f = StringIO() f.write("%s\t%s\n" % (1, 'b')) f.seek(0) curs.copy_from(MinimalRead(f), "tcopy") g = StringIO() g.write("%s\n" % (2)) g.seek(0) self.assertRaises(exceptions.OperationalError, curs.copy_from, MinimalRead(g), "tcopy_ref")
def get_concatenated_fd(filepaths): """ Generates a :class:`cStringIO` instance containing the content of the files at the provided ``filepaths``. The returned cStringIO instance is a file-like object, holding in memory the concatenated content of the source files, included in the same ordering as in the provided list. :param filepaths: List of filepaths :return: StringIO / cStringIO object with the contents of the files """ fds = [open(x, 'rb') for x in filepaths] data = StringIO() while fds: data_read = fds[0].read(-1) data.write(data_read) fds[0].close() fds.pop(0) data.seek(0) return data
def test_chromium_test_name_trie(capfd): # Ensure test names are broken into directories and stored in a trie with # test results at the leaves. # Set up the handler. output = StringIO() logger = structuredlog.StructuredLogger("test_a") logger.add_handler( handlers.StreamHandler(output, chromium.ChromiumFormatter())) # output a bunch of stuff logger.suite_start(["/foo/bar/test-id-1", "/foo/test-id-2"], run_info={}, time=123) logger.test_start("/foo/bar/test-id-1") logger.test_end("/foo/bar/test-id-1", status="TIMEOUT", expected="FAIL") logger.test_start("/foo/test-id-2") logger.test_end("/foo/test-id-2", status="ERROR", expected="TIMEOUT") logger.suite_end() # check nothing got output to stdout/stderr # (note that mozlog outputs exceptions during handling to stderr!) captured = capfd.readouterr() assert captured.out == "" assert captured.err == "" # check the actual output of the formatter output.seek(0) output_obj = json.load(output) # Ensure that the test names are broken up by directory name and that the # results are stored at the leaves. test_obj = output_obj["tests"]["foo"]["bar"]["test-id-1"] assert test_obj["actual"] == "TIMEOUT" assert test_obj["expected"] == "FAIL" test_obj = output_obj["tests"]["foo"]["test-id-2"] # The ERROR status is mapped to FAIL for Chromium assert test_obj["actual"] == "FAIL" assert test_obj["expected"] == "TIMEOUT"
def table_io(self,ids,fmt,encrypt=False,sign=False): from ekklesia.data import objects_equal columns = ('a','b','c') coltypes = {'a':int,'b':int,'c':int} t = DataTable(columns,coltypes=coltypes,gpg=ids['id1'],fileformat=fmt,required=False) if fmt in ('json','jsondict'): f = {} else: f = StringIO() t.open(f,'w',[receiver] if encrypt else False,sign) for i in range(3): t.write({'a':i,'b':2,'c':3}) if fmt in ('json','jsondict'): f2 = t.close() assert f is f2 else: t.close() f.seek(0) t = DataTable(columns,coltypes=coltypes,gpg=ids['id2'],fileformat=fmt) t.open(f,'r',encrypt,sender if sign else False) i = 0 for row in t: assert row == {'a':i,'b':2,'c':3} i+=1 t.close()
def test_tar(): lucky = Ska.ftp.FTP('lucky') lucky.cd('/{}'.format(USER)) files_before = lucky.ls() tar_put_fh = StringIO() with tarfile.open(mode='w:gz', fileobj=tar_put_fh) as tar_put: tar_put.add('test_tar.py') tar_put.add('test_tar.py') obj = {'cmd': 'test', 'tar': tar_put_fh.getvalue()} obj_fh_put = StringIO() pickle.dump(obj, obj_fh_put, protocol=-1) remotefile = 'test.pkl' obj_fh_put.seek(0) lucky.storbinary('STOR ' + remotefile, obj_fh_put) obj_fh_get = StringIO() lucky.retrbinary('RETR ' + remotefile, obj_fh_get.write) lucky.delete(remotefile) files_after = lucky.ls() assert files_before == files_after assert obj_fh_put.getvalue() == obj_fh_get.getvalue() lucky.close() obj_fh_get.seek(0) obj_get = pickle.load(obj_fh_get) tar = tarfile.open(mode='r', fileobj=StringIO(obj_get['tar'])) assert tar.getnames() == ['test_tar.py', 'test_tar.py'] test_basic = tar.extractfile('test_tar.py').read() assert test_basic == open('test_tar.py').read()
def background_src_api(rowid=None, fresh=False, **kwargs): r""" Returns the image file of annot <aid> Example: >>> # xdoctest: +REQUIRES(--slow) >>> # xdoctest: +REQUIRES(--web-tests) >>> from wbia.web.app import * # NOQA >>> import wbia >>> with wbia.opendb_with_web('testdb1') as (ibs, client): ... resp = client.get('/api/background/src/1/') >>> print(resp.data) b'\xff\xd8\xff\xe0\x00\x10JFIF... RESTful: Method: GET URL: /api/annot/src/<rowid>/ """ from PIL import Image # NOQA ibs = current_app.ibs gpath = ibs.get_annot_probchip_fpath(rowid) # Load image assert gpath is not None, 'image path should not be None' image = vt.imread(gpath, orient='auto') image = appf.resize_via_web_parameters(image) image = image[:, :, ::-1] # Encode image image_pil = Image.fromarray(image) if six.PY2: img_io = StringIO() else: img_io = BytesIO() image_pil.save(img_io, 'JPEG', quality=100) img_io.seek(0) return send_file(img_io, mimetype='image/jpeg')
def pt_upload(self, REQUEST, file=''): """Replace the document with the text in file.""" if SUPPORTS_WEBDAV_LOCKS and self.wl_isLocked(): raise ResourceLockedError("File is locked via WebDAV") if not isinstance(file, basestring): if not file: raise ValueError('File not specified') file = file.read() if file.startswith( "PK"): # FIXME: this condition is probably not enough # this is a OOo zip file, extract the content builder = OOoBuilder(file) attached_files_list = [ n for n in builder.getNameList() if n.startswith(self._OLE_directory_prefix) or n.startswith('Pictures') or n == 'META-INF/manifest.xml' ] # destroy a possibly pre-existing OLE document set if self.OLE_documents_zipstring: self.OLE_documents_zipstring = None # create a zip archive and store it if attached_files_list: memory_file = StringIO() try: zf = ZipFile(memory_file, mode='w', compression=ZIP_DEFLATED) except RuntimeError: zf = ZipFile(memory_file, mode='w') for attached_file in attached_files_list: zf.writestr(attached_file, builder.extract(attached_file)) zf.close() memory_file.seek(0) self.OLE_documents_zipstring = memory_file.read() self.content_type = builder.getMimeType() file = builder.prepareContentXml(self.ooo_xml_file_id) return ZopePageTemplate.pt_upload(self, REQUEST, file)
def test_wptreport_run_info_optional(capfd): """per the mozlog docs, run_info is optional; check we work without it""" # setup the logger output = StringIO() logger = structuredlog.StructuredLogger("test_a") logger.add_handler(handlers.StreamHandler(output, WptreportFormatter())) # output a bunch of stuff logger.suite_start(["test-id-1"]) # no run_info arg! logger.test_start("test-id-1") logger.test_end("test-id-1", "PASS") logger.suite_end() # check nothing got output to stdout/stderr # (note that mozlog outputs exceptions during handling to stderr!) captured = capfd.readouterr() assert captured.out == "" assert captured.err == "" # check the actual output of the formatter output.seek(0) output_obj = json.load(output) assert "run_info" not in output_obj or output_obj["run_info"] == {}
def extract_comments(source): """ Returns the text in each comment in a block of python code. Uses tokenize to account for quotations. CommandLine: python -m xdoctest.static_analysis extract_comments Example: >>> from xdoctest import utils >>> source = utils.codeblock( >>> ''' # comment 1 a = '# not a comment' # comment 2 c = 3 ''') >>> comments = list(extract_comments(source)) >>> assert comments == ['# comment 1', '# comment 2'] >>> comments = list(extract_comments(source.splitlines())) >>> assert comments == ['# comment 1', '# comment 2'] """ if not isinstance(source, six.string_types): source = '\n'.join(source) if six.PY2: try: source = source.encode('utf8') except Exception: pass stream = StringIO() stream.write(source) stream.seek(0) try: for t in tokenize.generate_tokens(stream.readline): if t[0] == tokenize.COMMENT: yield t[1] except tokenize.TokenError as ex: pass
def test_flaky_test_unexpected(capfd): # Check that a flaky test with multiple possible statuses is seen as # unexpected if its actual status is NOT one of the possible ones. # set up the handler. output = StringIO() logger = structuredlog.StructuredLogger("test_a") logger.add_handler(handlers.StreamHandler(output, ChromiumFormatter())) # Run a test that is known to be flaky logger.suite_start(["t1"], run_info={}, time=123) logger.test_start("t1") logger.test_end("t1", status="ERROR", expected="OK", known_intermittent=["TIMEOUT"]) logger.suite_end() # check nothing got output to stdout/stderr # (note that mozlog outputs exceptions during handling to stderr!) captured = capfd.readouterr() assert captured.out == "" assert captured.err == "" # check the actual output of the formatter output.seek(0) output_json = json.load(output) test_obj = output_json["tests"]["t1"] # The test's statuses are all mapped, changing ERROR->FAIL and OK->PASS assert test_obj["actual"] == "FAIL" # All the possible statuses are concatenated together into expected. assert test_obj["expected"] == "PASS TIMEOUT" # ...this is a regression and unexpected because the actual status is not # one of the expected ones assert test_obj["is_regression"] is True assert test_obj["is_unexpected"] is True
def test_wptreport_lone_surrogate_ucs2(capfd): # Since UCS4 is a superset of UCS2 we can meaningfully test the UCS2 code on a # UCS4 build, but not the reverse. However UCS2 is harder to handle and UCS4 is # the commonest (and sensible) configuration, so that's OK. output = StringIO() logger = structuredlog.StructuredLogger("test_a") logger.add_handler(handlers.StreamHandler(output, WptreportFormatter())) with mock.patch.object(wptreport, 'surrogate_replacement', wptreport.SurrogateReplacementUcs2()): # output a bunch of stuff logger.suite_start(["test-id-1"]) # no run_info arg! logger.test_start("test-id-1") logger.test_status("test-id-1", subtest=u"Name with surrogate\uD800", status="FAIL", message=u"\U0001F601 \uDE0A\uD83D \uD83D\uDE0A") logger.test_end("test-id-1", status="PASS", message=u"\uDE0A\uD83D \uD83D\uDE0A \U0001F601") logger.suite_end() # check nothing got output to stdout/stderr # (note that mozlog outputs exceptions during handling to stderr!) captured = capfd.readouterr() assert captured.out == "" assert captured.err == "" # check the actual output of the formatter output.seek(0) output_obj = json.load(output) test = output_obj["results"][0] assert test["message"] == u"U+de0aU+d83d \U0001f60a \U0001F601" subtest = test["subtests"][0] assert subtest["name"] == u"Name with surrogateU+d800" assert subtest["message"] == u"\U0001F601 U+de0aU+d83d \U0001f60a"
def finfindr_passport_src(aid=None, ibs=None, **kwargs): from six.moves import cStringIO as StringIO from io import BytesIO from PIL import Image # NOQA from flask import current_app, send_file from wbia.web import appfuncs as appf import six if ibs is None: ibs = current_app.ibs aid = int(aid) aid_list = [aid] passport_paths = ibs.depc_annot.get('FinfindrPassport', aid_list, 'image', read_extern=False, ensure=True) passport_path = passport_paths[0] # Load image assert passport_paths is not None, 'passport path should not be None' image = vt.imread(passport_path, orient='auto') image = appf.resize_via_web_parameters(image) image = image[:, :, ::-1] # Encode image image_pil = Image.fromarray(image) if six.PY2: img_io = StringIO() else: img_io = BytesIO() image_pil.save(img_io, 'JPEG', quality=100) img_io.seek(0) return send_file(img_io, mimetype='image/jpeg')
def background_src_api(rowid=None, fresh=False, **kwargs): r""" Returns the image file of annot <aid> Example: >>> # WEB_DOCTEST >>> from wbia.web.app import * # NOQA >>> import wbia >>> with wbia.opendb_bg_web('testdb1', start_job_queue=False, managed=True) as web_ibs: ... resp = web_ibs.send_wbia_request('/api/background/src/1/', type_='get', json=False) >>> print(resp) RESTful: Method: GET URL: /api/annot/src/<rowid>/ """ from PIL import Image # NOQA ibs = current_app.ibs gpath = ibs.get_annot_probchip_fpath(rowid) # Load image assert gpath is not None, 'image path should not be None' image = vt.imread(gpath, orient='auto') image = appf.resize_via_web_parameters(image) image = image[:, :, ::-1] # Encode image image_pil = Image.fromarray(image) if six.PY2: img_io = StringIO() else: img_io = BytesIO() image_pil.save(img_io, 'JPEG', quality=100) img_io.seek(0) return send_file(img_io, mimetype='image/jpeg')
class PMRequestListener(object): """ Daemon process that responds to requests """ def __init__(self, config, buildroot): self.config = config self.buildroot = buildroot self.rundir = buildroot.make_chroot_path(RUNDIR) self.socket_path = os.path.join(self.rundir, SOCKET_NAME) self.executed_commands = [] # util.do cannot return output when the command fails, we need to # capture it's logging self.log_buffer = StringIO() self.log = logging.getLogger("mockbuild.plugin.pm_request") self.log.level = logging.DEBUG self.log.addFilter(OutputFilter()) self.log.propagate = False self.log.addHandler(logging.StreamHandler(self.log_buffer)) def prepare_socket(self): sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) try: sock.connect(self.socket_path) except (socket.error, OSError): try: os.unlink(self.socket_path) except OSError: pass else: # there's another process listening sys.exit(0) util.mkdirIfAbsent(self.rundir) # Don't allow regular users to access the socket as they may not be in # the mock group os.chown(self.rundir, self.buildroot.chrootuid, self.buildroot.chrootgid) os.chmod(self.rundir, 0o770) sock.bind(self.socket_path) os.chown(self.socket_path, self.buildroot.chrootuid, self.buildroot.chrootgid) return sock def listen(self): sock = self.prepare_socket() sock.listen(MAX_CONNECTIONS) while True: try: connection, _ = sock.accept() try: line = connection.makefile().readline() command = shlex.split(line) # pylint:disable=E1101 if command == ["!LOG_EXECUTED"]: connection.sendall('\n'.join( self.executed_commands).encode()) elif command: success, out = self.execute_command(command) connection.sendall(b"ok\n" if success else b"nok\n") connection.sendall(out.encode()) if success: self.executed_commands.append(line.strip()) finally: connection.close() except socket.error: continue def execute_command(self, command): try: self.buildroot.pkg_manager.execute(*command, printOutput=False, logger=self.log, returnOutput=False, pty=False, raiseExc=True) success = True except Error: success = False out = self.log_buffer.getvalue() self.log_buffer.seek(0) self.log_buffer.truncate() return success, out
class SeekableLzopFile(Iterator): """ Filelike object supporting read-only semi-random access to bz2 compressed files for which an offset table (bz2t) has been generated by `bzip-table`. """ def __init__(self, filename, table_filename, block_cache_size=0, **kwargs): self.filename = filename self.table_filename = table_filename self.init_table() self.file = open(self.filename, "r") self.dirty = True self.at_eof = False self.file_pos = 0 self.current_block_index = -1 self.current_block = None if block_cache_size > 0: self.cache = lrucache.LRUCache(block_cache_size) else: self.cache = None def init_table(self): self.block_size = None self.block_info = [] # Position of corresponding block in compressed file (in bytes) for line in open(self.table_filename): fields = line.split() if fields[0] == "s": self.block_size = int(fields[1]) if fields[0] == "o": offset = int(fields[1]) compressed_size = int(fields[2]) size = int(fields[3]) self.block_info.append((offset, compressed_size, size)) self.nblocks = len(self.block_info) def close(self): self.file.close() def load_block(self, index): if self.cache is not None and index in self.cache: return self.cache[index] else: offset, csize, size = self.block_info[index] # Get the block of compressed data self.file.seek(offset) data = self.file.read(csize) # Need to prepend a header for python-lzo module (silly) data = ''.join(('\xf0', struct.pack("!I", size), data)) value = lzo.decompress(data) if self.cache is not None: self.cache[index] = value return value def fix_dirty(self): chunk, offset = self.get_block_and_offset(self.file_pos) if self.current_block_index != chunk: self.current_block = StringIO(self.load_block(chunk)) self.current_block.read(offset) self.current_block_index = chunk else: self.current_block.seek(offset) self.dirty = False def get_block_and_offset(self, index): return int(index // self.block_size), int(index % self.block_size) def seek(self, offset, whence=0): """ Move the file pointer to a particular offset. """ # Determine absolute target position if whence == 0: target_pos = offset elif whence == 1: target_pos = self.file_pos + offset elif whence == 2: raise Exception("seek from end not supported") ## target_pos = self.size - offset else: raise Exception("Invalid `whence` argument: %r", whence) # Check if this is a noop if target_pos == self.file_pos: return # Verify it is valid ## assert 0 <= target_pos < self.size, "Attempt to seek outside file" # Move the position self.file_pos = target_pos # Mark as dirty, the next time a read is done we need to actually # move the position in the bzip2 file self.dirty = True def tell(self): return self.file_pos def readline(self): if self.dirty: self.fix_dirty() if self.at_eof: return "" rval = [] while 1: line = self.current_block.readline() self.file_pos += len(line) rval.append(line) if len(line) > 0 and line[-1] == '\n': break elif self.current_block_index == self.nblocks - 1: self.at_eof = True break else: self.current_block_index += 1 self.current_block = StringIO( self.load_block(self.current_block_index)) return "".join(rval) def __next__(self): line = self.readline() if line == "": raise StopIteration def __iter__(self): return self
def exercise_cif_model(): loop = model.loop() loop["_loop_a"] = flex.double((1,2,3)) loop.add_columns({'_loop_c': [4,5,6], '_loop_b': ['7','8','9']}) loop.add_row((4,7,'0')) try: loop["_loop_invalid"] = (7,8) except AssertionError: pass else: raise Exception_expected assert len(loop) == 3 # the number of columns (keys) assert loop.size() == 4 # the number of rows (loop iterations) assert list(loop.keys()) == ['_loop_a', '_loop_c', '_loop_b'] try: loop["no_leading_underscore"] = 3 except Sorry: pass else: raise Exception_expected loop2 = model.loop(header=("_loop2_a", "_loop2_b"), data=(1,2,3,4,5,6)) assert list(loop2.keys()) == ["_loop2_a", "_loop2_b"] assert list(loop2.values()) == [flex.std_string(['1', '3', '5']), flex.std_string(['2', '4', '6'])] assert list(loop2.iterrows()) == [ {'_loop2_a': '1', '_loop2_b': '2'}, {'_loop2_a': '3', '_loop2_b': '4'}, {'_loop2_a': '5', '_loop2_b': '6'}] loop3 = model.loop( data={ "_loop3_a": flex.int((-1, 2, 3)), "_loop3_b": flex.double((1.1, 2.2, 3.3)), "_loop3_c": flex.size_t((1, 2, 3)), } ) for k in "abc": assert isinstance(loop3["_loop3_%s" % k], flex.std_string) # block = model.block() block["_tag"] = 3 block["_tag1"] = "'a string'" block["_another_tag"] = 3.142 assert "_tag" in block assert "_tag1" in block assert "_another_tag" in block assert block["_tag"] == '3' assert block["_tag1"] == "'a string'" assert block["_another_tag"] == "3.142" assert list(block.keys()) == ['_tag', '_tag1', '_another_tag'] assert list(block.values()) == ["3", "'a string'", "3.142"] try: block["no_leading_underscore"] = 3 except Sorry: pass else: raise Exception_expected block.add_loop(loop) assert len(block) == 6 assert list(block.items()) == [ ('_tag', '3'), ('_tag1', "'a string'"), ('_another_tag', '3.142'), ('_loop_a', flex.std_string(['1', '2', '3', '4'])), ('_loop_c', flex.std_string(['4', '5', '6', '7'])), ('_loop_b', flex.std_string(['7', '8', '9', '0']))] block['_loop_c'] = [11, 12, 13, 14] assert '_loop_c' in list(block.loops['_loop'].keys()) assert list(block['_loop_c']) == ['11', '12', '13', '14'] # block1 = model.block() block1["_tag"] = 2 block1["_tag2"] = 1.2 loop3 = model.loop(header=("_loop_a", "_loop_b"), data=(6,5,4,3,2,1)) block1.add_loop(loop2) block1.add_loop(loop3) block.update(block1) for key in block._items.keys(): assert key in ['_another_tag', '_tag2', '_tag', '_tag1'] for value in block._items.values(): assert value in ['3.142', '1.2', '2', "'a string'"] assert list(block.loops.keys()) == ['_loop', '_loop2'] assert list(block.keys()) == ['_tag', '_tag1', '_another_tag', '_loop_a', '_loop_b','_tag2', '_loop2_a', '_loop2_b'] assert list(block['_loop_a']) == ['6', '4', '2'] assert list(block['_loop_b']) == ['5', '3', '1'] assert list(block['_loop2_a']) == ['1', '3', '5'] assert list(block['_loop2_b']) == ['2', '4', '6'] try: block['_loop_c'] except KeyError: pass else: raise Exception_expected bad_loop = model.loop(header=("_a", "_b"), data=(1,2,3,4,5,6)) block1.add_loop(bad_loop) assert "_a" in block1 assert "_b" in block1 assert list(block.get_looped_item("_loop_a")) == ['6', '4', '2'] try: block.get_looped_item("_tag", value_error=ValueError) except ValueError: pass else: raise Exception_expected assert list(block.get_looped_item("_tag", value_error=None)) == ['2'] try: block.get_looped_item("_none_existent") except KeyError: pass else: raise Exception_expected assert block.get_looped_item( "_none_existent", key_error=None, default="my_default") == "my_default" assert block.get_single_item("_tag") == "2" try: block.get_single_item("_loop_a") except ValueError: pass else: raise Exception_expected assert block.get_single_item( "_loop_a", value_error=None, default="default") == "default" try: block.get_single_item("_none_existent") except KeyError: pass else: raise Exception_expected assert block.get_single_item("_none_existent", key_error=None) is None # cif_model = model.cif() cif_model["fred"] = block assert "fred" in cif_model assert cif_model["frEd"] is block assert cif_model["fred"]["_Tag"] == '2' cif_model["fred"]["_tag"] = 4 assert cif_model["fred"]["_tag"] == '4' del cif_model["fred"]["_tAg"] try: cif_model["fred"]["_tag"] except KeyError: pass else: raise Exception_expected cm = cif_model.deepcopy() l = cm["fred"]["_loop"] del cm["Fred"]["_loop_B"] assert "_loop_b" not in cm["fred"] assert "_loop_b" not in l assert "_loop" in cm["fred"].loops del cm["fred"]["_loop_a"] assert "_loop" not in cm["fred"].loops del cm["fred"]["_loop2"] assert "_loop2" not in cm["fred"].loops s = StringIO() print(cm, file=s) assert not show_diff(s.getvalue(), """\ data_fred _tag1 'a string' _another_tag 3.142 _tag2 1.2 """) # cm2 = cif_model.copy() cm3 = cif_model.deepcopy() assert cm2['fred']['_loop_a'] is cif_model ['fred']['_loop_a'] assert cm3['fred']['_loop_a'] is not cif_model ['fred']['_loop_a'] b2 = copy.copy(block) b3 = copy.deepcopy(block) assert b2['_loop_b'] is block['_loop_b'] assert b3['_loop_b'] is not block['_loop_b'] l2 = loop.copy() l3 = loop.deepcopy() assert l2['_loop_b'] is loop['_loop_b'] assert l3['_loop_b'] is not loop['_loop_b'] # s = StringIO() cif_model.show(out=s) assert not show_diff(s.getvalue(), """\ data_fred _tag1 'a string' _another_tag 3.142 loop_ _loop_a _loop_b 6 5 4 3 2 1 _tag2 1.2 loop_ _loop2_a _loop2_b 1 2 3 4 5 6 """) s = StringIO() cif_model.show(out=s, indent=" ", data_name_field_width=0) assert not show_diff(s.getvalue(), """\ data_fred _tag1 'a string' _another_tag 3.142 loop_ _loop_a _loop_b 6 5 4 3 2 1 _tag2 1.2 loop_ _loop2_a _loop2_b 1 2 3 4 5 6 """) s = StringIO() cif_model.show(out=s, indent="", indent_row=" ", data_name_field_width=0) assert not show_diff(s.getvalue(), """\ data_fred _tag1 'a string' _another_tag 3.142 loop_ _loop_a _loop_b 6 5 4 3 2 1 _tag2 1.2 loop_ _loop2_a _loop2_b 1 2 3 4 5 6 """) cif_model.sort(recursive=True) s = StringIO() cif_model.show(out=s) assert not show_diff(s.getvalue(), """\ data_fred _another_tag 3.142 _tag1 'a string' _tag2 1.2 loop_ _loop_a _loop_b 6 5 4 3 2 1 loop_ _loop2_a _loop2_b 1 2 3 4 5 6 """) save = model.save() save.add_loop(l3) save['_tag1'] = 3 block = model.block() block['bob'] = save cm = model.cif({'fred': block}) s = StringIO() cm.show(out=s) assert not show_diff(s.getvalue(), """data_fred save_bob loop_ _loop_a _loop_c _loop_b 1 11 7 2 12 8 3 13 9 4 14 0 _tag1 3 save_ """) b1 = model.block() b1['_a'] = 1 b1['_b'] = 2 b1['_c'] = 3 b2 = model.block() b2['_a'] = 2 b2['_c'] = 3 b2['_d'] = 4 b3 = b1.difference(b2) b4 = b2.difference(b1) for item in b3.items(): assert item in [('_b', '2'), ('_a', '2')] for item in b4.items(): assert item in [('_d', '4'), ('_a', '1')] l = model.loop(data=dict(_loop_d=(1,2),_loop_e=(3,4),_loop_f=(5,6))) assert l == l assert l == l.deepcopy() assert l != l2 assert l != l3 l2 = model.loop(data=dict(_loop_d=(1,2,3),_loop_e=(3,4,5),_loop_f=(5,6,7))) b1.add_loop(l) b2.add_loop(l2) b5 = b1.difference(b2) assert b5['_loop'] == l2 l = model.loop(data=OrderedDict((('_loop_a',(1,21,-13)), ('_loop_b',(-221.3,3.01,4.246)), ('_loop_c',("a","b","cc"))))) b = model.block() b.add_loop(l) cm = model.cif({'fred':b}) s = StringIO() cm.show(out=s, loop_format_strings={'_loop':'% 4i% 8.2f %s'}) assert not show_diff(s.getvalue(),"""\ data_fred loop_ _loop_a _loop_b _loop_c 1 -221.30 a 21 3.01 b -13 4.25 cc """) s = StringIO() cm.show(out=s) assert not show_diff(s.getvalue(),"""\ data_fred loop_ _loop_a _loop_b _loop_c 1 -221.3 a 21 3.01 b -13 4.246 cc """) l.add_row((".", "?", ".")) s = StringIO() cm.show(out=s) assert not show_diff(s.getvalue(),"""\ data_fred loop_ _loop_a _loop_b _loop_c 1 -221.3 a 21 3.01 b -13 4.246 cc . ? . """) l.delete_row(index=1) s = StringIO() cm.show(out=s) assert not show_diff(s.getvalue(),"""\ data_fred loop_ _loop_a _loop_b _loop_c 1 -221.3 a -13 4.246 cc . ? . """) l2 = l.deepcopy() l2.delete_row(index=0) l2.delete_row(index=0) l2.delete_row(index=0) try: l2.show(out=s) except AssertionError as e: pass else: raise Exception_expected l.clear() try: l.show(out=s) except AssertionError as e: pass else: raise Exception_expected # loop = model.loop(data={"_a_1": ('string with spaces','nospaces'), "_a_2": ('a', 'b')}) s = StringIO() loop.show(out=s, align_columns=True) assert not show_diff(s.getvalue(), """\ loop_ _a_1 _a_2 'string with spaces' a nospaces b """) # cb = model.block() cm = model.cif() cm["a"] = cb cb["_b"] = "" s = StringIO() cm.show(out=s) assert not show_diff(s.getvalue(), """\ data_a _b '' """) # loop = model.loop(data=OrderedDict(( ("_entity_poly.entity_id", ('1', '2', '3')), ("_entity_poly.pdbx_seq_one_letter_code", ( "TFGSGEADCGLRPLFEKKSLEDKTERELLESYIDGR", """\ IVEGSDAEIGMSPWQVMLFRKSPQELLCGASLISDRWVLTAAHCLLYPPWDKNFTENDLLVRIGKHSRTRYERNIEKISM THVFRLKKWIQKVIDQFGE""", "NGDFEEIPEE(TYS)LQ", )), ("_entity_poly.pdbx_seq_one_letter_code_can", ( "TFGSGEADCGLRPLFEKKSLEDKTERELLESYIDGR", """\ IVEGSDAEIGMSPWQVMLFRKSPQELLCGASLISDRWVLTAAHCLLYPPWDKNFTENDLLVRIGKHSRTRYERNIEKISM THVFRLKKWIQKVIDQFGE""", "NGDFEEIPEEYLQ", )), ("_entity_poly.pdbx_strand_id", ('L', 'H', 'I')) ))) s = StringIO() loop.show(out=s, align_columns=True) s.seek(0) assert not show_diff("\n".join(l.rstrip() for l in s.readlines()),"""\ loop_ _entity_poly.entity_id _entity_poly.pdbx_seq_one_letter_code _entity_poly.pdbx_seq_one_letter_code_can _entity_poly.pdbx_strand_id 1 TFGSGEADCGLRPLFEKKSLEDKTERELLESYIDGR TFGSGEADCGLRPLFEKKSLEDKTERELLESYIDGR L 2 ; IVEGSDAEIGMSPWQVMLFRKSPQELLCGASLISDRWVLTAAHCLLYPPWDKNFTENDLLVRIGKHSRTRYERNIEKISM THVFRLKKWIQKVIDQFGE ; ; IVEGSDAEIGMSPWQVMLFRKSPQELLCGASLISDRWVLTAAHCLLYPPWDKNFTENDLLVRIGKHSRTRYERNIEKISM THVFRLKKWIQKVIDQFGE ; H 3 NGDFEEIPEE(TYS)LQ NGDFEEIPEEYLQ I\ """) # cb = model.block() cm = model.cif() cm["a"] = cb cb["_a"] = '1 "a" 2' cb["_b"] = "1 'b' 3" cb["_c"] = "O1'" cb["_d"] = 'O2"' cb["_e"] = """1 'a' "b" 3""" s = StringIO() print(cm, file=s) s.seek(0) assert not show_diff("\n".join(l.rstrip() for l in s.readlines()), """\ data_a _a '1 "a" 2' _b "1 'b' 3" _c O1' _d O2" _e ; 1 'a' "b" 3 ; """) # verify that what we wrote out above is valid CIF and we can read it back in cm2 = iotbx.cif.reader(input_string=s.getvalue()).model() cb2 = cm2["a"] assert cb2["_a"] == cb["_a"] assert cb2["_b"] == cb["_b"] assert cb2["_c"] == cb["_c"] assert cb2["_d"] == cb["_d"] assert cb2["_e"].strip() == cb["_e"] # cm = iotbx.cif.reader(input_string="""\ data_a loop_ _pdbx_refine_tls_group.id _pdbx_refine_tls_group.refine_tls_id _pdbx_refine_tls_group.selection _pdbx_refine_tls_group.selection_details 1 1 ? "chain 'A' and (resid 2 through 15 )" 2 2 ? "chain 'A' and (resid 16 through 26 )" 3 3 ? "chain 'A' and (resid 27 through 43 )" 4 4 ? "chain 'B' and (resid 1 through 14 )" 5 5 ? "chain 'B' and (resid 15 through 20 )" """).model() print(cm) # cif_block = model.block() loop_a = model.loop(header=("_a.1", "_a.2"), data=(1,2,3,4,5,6)) cif_block.add_loop(loop_a) assert cif_block.get_loop("_a") is loop_a assert cif_block.get_loop_or_row("_a") is loop_a assert cif_block.get_loop("_b") is None assert cif_block.get_loop_or_row("_b") is None assert cif_block.get_loop("_b", default=loop_a) is loop_a assert cif_block.get_loop_or_row("_b", default=loop_a) is loop_a loop_a = cif_block.get_loop_with_defaults( "_a", default_dict={"_a.2":".", "_a.3":"?", "_a.4":"."}) assert list(cif_block["_a.1"]) == ['1', '3', '5'] assert list(cif_block["_a.2"]) == ['2', '4', '6'] assert list(cif_block["_a.3"]) == ['?', '?', '?'] assert list(cif_block["_a.4"]) == ['.', '.', '.'] loop_a.add_row({"_a.3":"a", "_a.4":"b"}) loop_a.add_row({"_a.3":"c", "_a.4":"d"}, default_value=".") assert list(cif_block["_a.1"]) == ['1', '3', '5', '?', '.'] assert list(cif_block["_a.2"]) == ['2', '4', '6', '?', '.'] assert list(cif_block["_a.3"]) == ['?', '?', '?', 'a', 'c'] assert list(cif_block["_a.4"]) == ['.', '.', '.', 'b', 'd'] loop_B = model.loop(header=("_B.1", "_B.2", "_B.3"), data=(1,2,3,4,5,6)) cif_block.add_loop(loop_B) assert cif_block.get_loop("_B") is loop_B assert cif_block.get_loop_or_row("_B") is loop_B assert cif_block.get_loop("_b") is loop_B assert cif_block.get_loop_or_row("_b") is loop_B # cif_block = model.block() cif_block['_a'] = """\ 123 456""" s = StringIO() cif_block.show(out=s) s.seek(0) assert not show_diff("\n".join([l.strip() for l in s.readlines()]), """\ _a ; 123 456 ; """) cm = iotbx.cif.reader(input_string="""\ data_a _test_row.id 1 _test_row.data2 2 _test_row.data3 3 _test_row.data4 44 # loop_ _test_row_range.sheet_id _test_row_range.id _test_row_range.beg_label_comp_id _test_row_range.beg_label_asym_id A 1 SER A A 2 MET A # """).model() # cif_block = list(cm.values())[0] loop_or_row = cif_block.get_loop_or_row('_test_row') assert loop_or_row.n_rows() == 1 assert loop_or_row.n_columns() == 4 assert list(loop_or_row['_test_row.id']) == ['1'] assert list(loop_or_row['_test_row.data2']) == ['2'] assert list(loop_or_row['_test_row.data3']) == ['3'] assert list(loop_or_row['_test_row.data4']) == ['44'] for r in loop_or_row.iterrows(): assert list(r['_test_row.id']) == ['1'] assert list(r['_test_row.data2']) == ['2'] assert list(r['_test_row.data3']) == ['3'] assert list(r['_test_row.data4']) == ['4','4']
class CLITest(TestCase): def setUp(self): self.output = StringIO() self.error = StringIO() self.input = StringIO() def test_cli_reading_web_form_password_with_multiple_password_attempts(self): password_attempts = (i for i in ("incorrect", "badger")) cli = self.build_cli( getpass=lambda prompt: next(password_attempts).encode("utf-8"), arguments=("--path", self.keychain_path, "onetosix",), ) cli.run() self.assert_output("123456\n") self.assert_no_error_output() def test_cli_with_bad_item_name(self): cli = self.build_cli( getpass=lambda prompt: "badger".encode("utf-8"), arguments=("--path", self.keychain_path, "onetos",), ) self.assert_exit_status(EX_DATAERR, cli.run) self.assert_no_output() self.assert_error_output("1pass: Could not find an item named 'onetos'\n") def test_cli_with_fuzzy_matching(self): cli = self.build_cli( getpass=lambda prompt: "badger".encode("utf-8"), arguments=("--fuzzy", "--path", self.keychain_path, "onetos",), ) cli.run() self.assert_output("123456\n") self.assert_no_error_output() def test_cli_cancelled_password_prompt(self): def keyboard_interrupt(prompt): raise KeyboardInterrupt() cli = self.build_cli( getpass=keyboard_interrupt, arguments=("--path", self.keychain_path, "onetosix",), ) self.assert_exit_status(0, cli.run) self.assert_output("\n") self.assert_no_error_output() def test_correct_password_from_stdin(self): def flunker(prompt): self.fail("Password prompt was invoked") self.input.write("badger\n") self.input.seek(0) cli = self.build_cli( getpass=flunker, arguments=("--no-prompt", "--path", self.keychain_path, "onetosix",), ) cli.run() self.assert_output("123456\n") self.assert_no_error_output() def test_incorrect_password_from_stdin(self): def flunker(prompt): self.fail("Password prompt was invoked") self.input.write("wrong-password\n") self.input.seek(0) cli = self.build_cli( getpass=flunker, arguments=("--no-prompt", "--path", self.keychain_path, "onetosix",), ) self.assert_exit_status(EX_DATAERR, cli.run) self.assert_no_output() self.assert_error_output("1pass: Incorrect master password\n") def build_cli(self, **kwargs): cli_kwargs = { "stdin": self.input, "stdout": self.output, "stderr": self.error, } cli_kwargs.update(kwargs) return CLI(**cli_kwargs) def assert_exit_status(self, expected_status, func): try: func() except SystemExit as exit: self.assertEquals(expected_status, exit.code) else: self.fail("Expected a SystemExit to be raised") def assert_output(self, expected_output): self.assertEquals(expected_output, self.output.getvalue()) def assert_no_output(self): self.assert_output("") def assert_error_output(self, expected_output): self.assertEquals(expected_output, self.error.getvalue()) def assert_no_error_output(self): self.assert_error_output("") @property def keychain_path(self): return os.path.join(os.path.dirname(__file__), "data", "1Password.agilekeychain")
def exercise_mmcif_tls(): pdb_file = libtbx.env.find_in_repositories( relative_path="phenix_regression/pdb/3orl.pdb", test=os.path.isfile) mmcif_file = libtbx.env.find_in_repositories( relative_path="phenix_regression/pdb/3orl.cif", test=os.path.isfile) if pdb_file is None or mmcif_file is None: print( "Skipping exercise_mmcif_tls(): missing phenix_regression directory." ) return pdb_input = iotbx.pdb.input(file_name=pdb_file) pdb_hierarchy = pdb_input.construct_hierarchy() cif_input = iotbx.pdb.input(file_name=mmcif_file) cif_hierarchy = cif_input.construct_hierarchy() pdb_tls_params = pdb_input.extract_tls_params(pdb_hierarchy).tls_params cif_block = cif_input.cif_block cif_tls_params = cif_input.extract_tls_params(cif_hierarchy).tls_params assert len(pdb_tls_params) == len(cif_tls_params) == 3 check_tls_params(pdb_tls_params, cif_tls_params) selection_strings = [tls.selection_string for tls in cif_tls_params] cif_block = iotbx.pdb.mmcif.tls_as_cif_block(cif_tls_params, selection_strings) cif_block.update(cif_hierarchy.as_cif_block()) cif_model = iotbx.cif.model.cif() cif_model["3orl"] = cif_block s = StringIO() print(cif_model, file=s) s.seek(0) cif_hierarchy_recycled = iotbx.pdb.input( lines=s.readlines(), source_info=None).construct_hierarchy() tls_params_recycled = cif_input.extract_tls_params( cif_hierarchy_recycled).tls_params assert len(tls_params_recycled) == len(cif_tls_params) == 3 check_tls_params(tls_params_recycled, cif_tls_params) # this one has phenix selection strings pdb_file = libtbx.env.find_in_repositories( relative_path="phenix_regression/pdb/4g9h.pdb", test=os.path.isfile) mmcif_file = libtbx.env.find_in_repositories( relative_path="phenix_regression/pdb/4g9h.cif", test=os.path.isfile) pdb_input = iotbx.pdb.input(file_name=pdb_file) pdb_hierarchy = pdb_input.construct_hierarchy() pdb_tls_params = pdb_input.extract_tls_params(pdb_hierarchy).tls_params cif_input = iotbx.pdb.input(file_name=mmcif_file) cif_hierarchy = cif_input.construct_hierarchy() cif_block = cif_input.cif_block cif_tls_params = cif_input.extract_tls_params(cif_hierarchy).tls_params assert len(pdb_tls_params) == len(cif_tls_params) == 18 check_tls_params(pdb_tls_params, cif_tls_params) selection_strings = [tls.selection_string for tls in cif_tls_params] cif_block = iotbx.pdb.mmcif.tls_as_cif_block(cif_tls_params, selection_strings) cif_block.update(cif_hierarchy.as_cif_block()) cif_model = iotbx.cif.model.cif() cif_model["4g9h"] = cif_block s = StringIO() print(cif_model, file=s) s.seek(0) cif_hierarchy_recycled = iotbx.pdb.input( lines=s.readlines(), source_info=None).construct_hierarchy() tls_params_recycled = cif_input.extract_tls_params( cif_hierarchy_recycled).tls_params assert len(tls_params_recycled) == len(cif_tls_params) == 18 check_tls_params(tls_params_recycled, cif_tls_params) # in this one the tls data items are not looped mmcif_file = libtbx.env.find_in_repositories( relative_path="phenix_regression/pdb/2xw9.cif", test=os.path.isfile) cif_input = iotbx.pdb.input(file_name=mmcif_file) cif_hierarchy = cif_input.construct_hierarchy() cif_block = cif_input.cif_block cif_tls_params = cif_input.extract_tls_params(cif_hierarchy).tls_params assert len(cif_tls_params) == 1 cif_tls = cif_tls_params[0] assert approx_equal(cif_tls.t, [0.0275, 0.0202, 0.0138, -0.0004, 0.0088, -0.0002]) assert approx_equal(cif_tls.l, [0.0554, 0.0231, 0.0573, -0.0127, 0.0112, -0.017]) assert approx_equal(cif_tls.s, [ -0.0001, -0.0012, -0.0037, -0.0006, 0.001, 0.0007, -0.0023, -0.0001, -0.0009 ]) assert approx_equal(cif_tls.origin, [-1.219, 1.557, 13.138]) assert approx_equal(cif_tls.selection_string, "(chain A and resseq 1:228)") selection_strings = [tls.selection_string for tls in cif_tls_params] cif_block = iotbx.pdb.mmcif.tls_as_cif_block(cif_tls_params, selection_strings) cif_block.update(cif_hierarchy.as_cif_block()) cif_model = iotbx.cif.model.cif() cif_model["2xw9"] = cif_block s = StringIO() print(cif_model, file=s) s.seek(0) cif_hierarchy_recycled = iotbx.pdb.input( lines=s.readlines(), source_info=None).construct_hierarchy() tls_params_recycled = cif_input.extract_tls_params( cif_hierarchy_recycled).tls_params assert len(tls_params_recycled) == len(cif_tls_params) == 1 check_tls_params(tls_params_recycled, cif_tls_params)
def newContent(self, REQUEST=None, **kw): """ The newContent method is overriden to implement smart content creation by detecting the portal type based on whatever information was provided and finding out the most appropriate module to store the content. explicit named parameters was: id - id of document portal_type - explicit portal_type parameter, must be honoured url - Identifier of external resource. Content will be downloaded from it container - if specified, it is possible to define where to contribute the content. Else, ContributionTool tries to guess. container_path - if specified, defines the container path and has precedence over container discover_metadata - Enable metadata extraction and discovery (default True) temp_object - build tempObject or not (default False) user_login - is the name under which the content will be created XXX - this is a security hole which needs to be fixed by making sure only Manager can use this parameter data - Binary representation of content filename - explicit filename of content """ # Useful for metadata discovery, keep it as it as been provided input_parameter_dict = kw.copy() # But file and data are exceptions. # They are potentialy too big to be keept into memory. # We want to keep only one reference of thoses values # on futur created document only ! if 'file' in input_parameter_dict: del input_parameter_dict['file'] if 'data' in input_parameter_dict: del input_parameter_dict['data'] if 'container' in input_parameter_dict: # Container is a persistent object # keep only its path in container_path key container = input_parameter_dict.pop('container') input_parameter_dict['container_path'] = container.getPath() # pop: remove keys which are not document properties url = kw.pop('url', None) container = kw.pop('container', None) container_path = kw.pop('container_path', None) discover_metadata = kw.pop('discover_metadata', True) user_login = kw.pop('user_login', None) document_id = kw.pop('id', None) # check file_name argument for backward compatibility. if 'file_name' in kw: if 'filename' not in kw: kw['filename'] = kw['file_name'] del (kw['file_name']) filename = kw.get('filename', None) temp_object = kw.get('temp_object', False) document = None portal = self.getPortalObject() if container is None and container_path: # Get persistent object from its path. # Container may disappear, be smoother by passing default value container = portal.restrictedTraverse(container_path, None) # Try to find the filename if not url: # check if file was provided file_object = kw.get('file') if file_object is not None: if not filename: filename = getattr(file_object, 'filename', None) else: # some channels supply data and file-name separately # this is the case for example for email ingestion # in this case, we build a file wrapper for it try: data = kw.pop('data') except KeyError: raise ValueError('data must be provided') if data is not None: file_object = StringIO() file_object.write(data) file_object.seek(0) kw['file'] = file_object content_type = kw.pop('content_type', None) else: file_object, filename, content_type = self._openURL(url) content_type = kw.pop('content_type', None) or content_type kw['file'] = file_object if not filename and url is None: raise ValueError('filename must be provided') if not content_type: # fallback to a default content_type according provided # filename content_type = self.guessMimeTypeFromFilename(filename) if content_type: kw['content_type'] = content_type portal_type = kw.pop('portal_type', None) if not portal_type: # Guess it with help of portal_contribution_registry portal_type = portal.portal_contribution_registry.findPortalTypeName( filename=filename, content_type=content_type) if not (container is None or container.isModuleType() or container.getTypeInfo().allowType(portal_type)): portal_type = 'Embedded File' if container is None: # If the portal_type was provided, we can go faster if portal_type: # We know the portal_type, let us find the default module # and use it as container try: container = portal.getDefaultModule(portal_type) except ValueError: pass elif not url: # Simplify things here and return a document immediately # XXX Nicolas: This will break support of WebDAV # if _setObject is not called document = container.newContent(document_id, portal_type, **kw) if discover_metadata: document.activate(after_path_and_method_id=(document.getPath(), ('convertToBaseFormat', 'Document_tryToConvertToBaseFormat')))\ .discoverMetadata(filename=filename, user_login=user_login, input_parameter_dict=input_parameter_dict) if REQUEST is not None: response = REQUEST.RESPONSE response.setHeader('X-Location', document.absolute_url()) return response.redirect(self.absolute_url()) return document # # Check if same file is already exists. if it exists, then update it. # property_dict = self.getMatchedFilenamePatternDict(filename) reference = property_dict.get('reference', None) version = property_dict.get('version', None) language = property_dict.get('language', None) if portal_type and reference and version and language: portal_catalog = portal.portal_catalog document = portal_catalog.getResultValue(portal_type=portal_type, reference=reference, version=version, language=language) if document is not None: # document is already uploaded. So overrides file. if not _checkPermission(Permissions.ModifyPortalContent, document): raise Unauthorized( "[DMS] You are not allowed to update the existing document which has the same coordinates (id %s)" % document.getId()) document.edit(file=kw['file']) return document # Temp objects use the standard newContent from Folder if temp_object: # For temp_object creation, use the standard method return BaseTool.newContent(self, portal_type=portal_type, **kw) # Then put the file inside ourselves for a short while document = self._setObject(document_id, None, portal_type=portal_type, user_login=user_login, container=container, discover_metadata=discover_metadata, filename=filename, input_parameter_dict=input_parameter_dict) object_id = document.getId() document = self[object_id] # Call __getitem__ to purge cache kw['filename'] = filename # Override filename property # Then edit the document contents (so that upload can happen) document._edit(**kw) if url: document.fromURL(url) # Allow reindexing, reindex it and return the document try: del document.isIndexable except AttributeError: # Document does not have such attribute pass document.reindexObject() if REQUEST is not None: return REQUEST.RESPONSE.redirect(self.absolute_url()) return document
class FileCacheObject(CacheObject): _struct = struct.Struct('dII') # double and two ints # timestamp, lifetime, position @classmethod def fromFile(cls, fd): dat = cls._struct.unpack(fd.read(cls._struct.size)) obj = cls(None, None, dat[1], dat[0]) obj.position = dat[2] return obj def __init__(self, *args, **kwargs): self._key = None self._data = None self._size = None self._buff = StringIO() super(FileCacheObject, self).__init__(*args, **kwargs) @property def size(self): if self._size is None: self._buff.seek(0, 2) size = self._buff.tell() if size == 0: if (self._key is None) or (self._data is None): raise RuntimeError json.dump([self.key, self.data], self._buff) self._size = self._buff.tell() self._size = size return self._size @size.setter def size(self, value): self._size = value @property def key(self): if self._key is None: try: self._key, self._data = json.loads(self._buff.getvalue()) except: pass return self._key @key.setter def key(self, value): self._key = value @property def data(self): if self._data is None: self._key, self._data = json.loads(self._buff.getvalue()) return self._data @data.setter def data(self, value): self._data = value def load(self, fd): fd.seek(self.position) self._buff.seek(0) self._buff.write(fd.read(self.size)) def dumpslot(self, fd): pos = fd.tell() fd.write(self._struct.pack(self.creation, self.lifetime, self.position)) def dumpdata(self, fd): self.size fd.seek(self.position) fd.write(self._buff.getvalue())
class FileCache( Iterator ): """ Wrapper for a file that cache blocks of data in memory. **NOTE:** this is currently an incomplete file-like object, it only supports seek, tell, and readline (plus iteration). Reading bytes is currently not implemented. """ def __init__( self, file, size, cache_size=DEFAULT_CACHE_SIZE, block_size=DEFAULT_BLOCK_SIZE ): """ Create a new `FileCache` wrapping the file-like object `file` that has total size `size` and caching blocks of size `block_size`. """ self.file = file self.size = size self.cache_size = cache_size self.block_size = block_size # Setup the cache self.nblocks = ( self.size // self.block_size ) + 1 self.cache = LRUCache( self.cache_size ) # Position in file self.dirty = True self.at_eof = False self.file_pos = 0 self.current_block_index = -1 self.current_block = None def fix_dirty( self ): chunk, offset = self.get_block_and_offset( self.file_pos ) if self.current_block_index != chunk: self.current_block = StringIO( self.load_block( chunk ) ) self.current_block.read( offset ) self.current_block_index = chunk else: self.current_block.seek( offset ) self.dirty = False def get_block_and_offset( self, index ): return int( index // self.block_size ), int( index % self.block_size ) def load_block( self, index ): if index in self.cache: return self.cache[index] else: real_offset = index * self.block_size self.file.seek( real_offset ) block = self.file.read( self.block_size ) self.cache[index] = block return block def seek( self, offset, whence=0 ): """ Move the file pointer to a particular offset. """ # Determine absolute target position if whence == 0: target_pos = offset elif whence == 1: target_pos = self.file_pos + offset elif whence == 2: target_pos = self.size - offset else: raise Exception( "Invalid `whence` argument: %r", whence ) # Check if this is a noop if target_pos == self.file_pos: return # Verify it is valid assert 0 <= target_pos < self.size, "Attempt to seek outside file" # Move the position self.file_pos = target_pos # Mark as dirty, the next time a read is done we need to actually # move the position in the bzip2 file self.dirty = True def readline( self ): if self.dirty: self.fix_dirty() if self.at_eof: return "" rval = [] while 1: line = self.current_block.readline() rval.append( line ) if len( line ) > 0 and line[-1] == '\n': break elif self.current_block_index == self.nblocks - 1: self.at_eof = True break else: self.current_block_index += 1 self.current_block = StringIO( self.load_block( self.current_block_index ) ) return "".join( rval ) def __next__( self ): line = self.readline() if line == "": raise StopIteration def __iter__( self ): return self def close( self ): self.file.close()