Python bz2.open() Examples
The following are 30
code examples of bz2.open().
You can vote up the ones you like or vote down the ones you don't like,
and go to the original project or source file by following the links above each example.
You may also want to check out all available functions/classes of the module
bz2
, or try the search function
.
Example #1
Source File: test_io.py From recruit with Apache License 2.0 | 7 votes |
def test_gzip_loadtxt(): # Thanks to another windows brokenness, we can't use # NamedTemporaryFile: a file created from this function cannot be # reopened by another open call. So we first put the gzipped string # of the test reference array, write it to a securely opened file, # which is then read from by the loadtxt function s = BytesIO() g = gzip.GzipFile(fileobj=s, mode='w') g.write(b'1 2 3\n') g.close() s.seek(0) with temppath(suffix='.gz') as name: with open(name, 'wb') as f: f.write(s.read()) res = np.loadtxt(name) s.close() assert_array_equal(res, [1, 2, 3])
Example #2
Source File: _datasource.py From lambda-packs with MIT License | 6 votes |
def _python2_bz2open(fn, mode, encoding, newline): """Wrapper to open bz2 in text mode. Parameters ---------- fn : str File name mode : {'r', 'w'} File mode. Note that bz2 Text files are not supported. encoding : str Ignored, text bz2 files not supported in Python2. newline : str Ignored, text bz2 files not supported in Python2. """ import bz2 _check_mode(mode, encoding, newline) if "t" in mode: # BZ2File is missing necessary functions for TextIOWrapper warnings.warn("Assuming latin1 encoding for bz2 text file in Python2", RuntimeWarning, stacklevel=5) mode = mode.replace("t", "") return bz2.BZ2File(fn, mode)
Example #3
Source File: files.py From udapi-python with GNU General Public License v3.0 | 6 votes |
def next_filehandle(self): """Go to the next file and retrun its filehandle or None (meaning no more files).""" filename = self.next_filename() if filename is None: fhandle = None elif filename == '-': fhandle = io.TextIOWrapper(sys.stdin.buffer, encoding=self.encoding) elif filename == '<filehandle_input>': fhandle = self.filehandle else: filename_extension = filename.split('.')[-1] if filename_extension == 'gz': myopen = gzip.open elif filename_extension == 'xz': myopen = lzma.open elif filename_extension == 'bz2': myopen = bz2.open else: myopen = open fhandle = myopen(filename, 'rt', encoding=self.encoding) self.filehandle = fhandle return fhandle
Example #4
Source File: test_io.py From recruit with Apache License 2.0 | 6 votes |
def check_compressed(self, fopen, suffixes): # Test that we can load data from a compressed file wanted = np.arange(6).reshape((2, 3)) linesep = ('\n', '\r\n', '\r') for sep in linesep: data = '0 1 2' + sep + '3 4 5' for suffix in suffixes: with temppath(suffix=suffix) as name: with fopen(name, mode='wt', encoding='UTF-32-LE') as f: f.write(data) res = self.loadfunc(name, encoding='UTF-32-LE') assert_array_equal(res, wanted) with fopen(name, "rt", encoding='UTF-32-LE') as f: res = self.loadfunc(f) assert_array_equal(res, wanted) # Python2 .open does not support encoding
Example #5
Source File: files.py From udapi-python with GNU General Public License v3.0 | 6 votes |
def _token_to_filenames(token): if token[0] == '!': pattern = token[1:] filenames = glob.glob(pattern) if not filenames: raise RuntimeError('No filenames matched "%s" pattern' % pattern) elif token[0] == '@': filelist_name = sys.stdin if token == '@-' else token[1:] with open(filelist_name) as filelist: filenames = [line.rstrip('\n') for line in filelist] directory = os.path.dirname(token[1:]) if directory != '.': filenames = [f if f[0] != '/' else directory + '/' + f for f in filenames] else: filenames = [token] return filenames
Example #6
Source File: _datasource.py From vnpy_crypto with MIT License | 6 votes |
def _python2_bz2open(fn, mode, encoding, newline): """Wrapper to open bz2 in text mode. Parameters ---------- fn : str File name mode : {'r', 'w'} File mode. Note that bz2 Text files are not supported. encoding : str Ignored, text bz2 files not supported in Python2. newline : str Ignored, text bz2 files not supported in Python2. """ import bz2 _check_mode(mode, encoding, newline) if "t" in mode: # BZ2File is missing necessary functions for TextIOWrapper raise ValueError("bz2 text files not supported in python2") else: return bz2.BZ2File(fn, mode)
Example #7
Source File: test_io.py From vnpy_crypto with MIT License | 6 votes |
def test_gzip_loadtxt(): # Thanks to another windows brokeness, we can't use # NamedTemporaryFile: a file created from this function cannot be # reopened by another open call. So we first put the gzipped string # of the test reference array, write it to a securely opened file, # which is then read from by the loadtxt function s = BytesIO() g = gzip.GzipFile(fileobj=s, mode='w') g.write(b'1 2 3\n') g.close() s.seek(0) with temppath(suffix='.gz') as name: with open(name, 'wb') as f: f.write(s.read()) res = np.loadtxt(name) s.close() assert_array_equal(res, [1, 2, 3])
Example #8
Source File: test_io.py From recruit with Apache License 2.0 | 6 votes |
def test_not_closing_opened_fid(self): # Test that issue #2178 is fixed: # verify could seek on 'loaded' file with temppath(suffix='.npz') as tmp: with open(tmp, 'wb') as fp: np.savez(fp, data='LOVELY LOAD') with open(tmp, 'rb', 10000) as fp: fp.seek(0) assert_(not fp.closed) np.load(fp)['data'] # fp must not get closed by .load assert_(not fp.closed) fp.seek(0) assert_(not fp.closed) #FIXME: Is this still true?
Example #9
Source File: _datasource.py From vnpy_crypto with MIT License | 6 votes |
def abspath(self, path): """ Return absolute path of file in the Repository directory. If `path` is an URL, then `abspath` will return either the location the file exists locally or the location it would exist when opened using the `open` method. Parameters ---------- path : str Can be a local file or a remote URL. This may, but does not have to, include the `baseurl` with which the `Repository` was initialized. Returns ------- out : str Complete path, including the `DataSource` destination directory. """ return DataSource.abspath(self, self._fullpath(path))
Example #10
Source File: recorders.py From pywr with GNU General Public License v3.0 | 6 votes |
def reset(self): import csv kwargs = {"newline": "", "encoding": "utf-8"} mode = "wt" if self.complib == "gzip": import gzip self._fh = gzip.open(self.csvfile, mode, self.complevel, **kwargs) elif self.complib in ("bz2", "bzip2"): import bz2 self._fh = bz2.open(self.csvfile, mode, self.complevel, **kwargs) elif self.complib is None: self._fh = open(self.csvfile, mode, **kwargs) else: raise KeyError("Unexpected compression library: {}".format(self.complib)) self._writer = csv.writer(self._fh, **self.csv_kwargs) # Write header data row = ["Datetime"] + [name for name in self._node_names] self._writer.writerow(row)
Example #11
Source File: test_io.py From recruit with Apache License 2.0 | 6 votes |
def test_utf8_file(self): utf8 = b"\xcf\x96" with temppath() as path: with open(path, "wb") as f: f.write((b"test1,testNonethe" + utf8 + b",test3\n") * 2) test = np.genfromtxt(path, dtype=None, comments=None, delimiter=',', encoding="UTF-8") ctl = np.array([ ["test1", "testNonethe" + utf8.decode("UTF-8"), "test3"], ["test1", "testNonethe" + utf8.decode("UTF-8"), "test3"]], dtype=np.unicode) assert_array_equal(test, ctl) # test a mixed dtype with open(path, "wb") as f: f.write(b"0,testNonethe" + utf8) test = np.genfromtxt(path, dtype=None, comments=None, delimiter=',', encoding="UTF-8") assert_equal(test['f0'], 0) assert_equal(test['f1'], "testNonethe" + utf8.decode("UTF-8"))
Example #12
Source File: test_io.py From vnpy_crypto with MIT License | 6 votes |
def test_utf8_file(self): utf8 = b"\xcf\x96" latin1 = b"\xf6\xfc\xf6" with temppath() as path: with open(path, "wb") as f: f.write((b"test1,testNonethe" + utf8 + b",test3\n") * 2) test = np.genfromtxt(path, dtype=None, comments=None, delimiter=',', encoding="UTF-8") ctl = np.array([ ["test1", "testNonethe" + utf8.decode("UTF-8"), "test3"], ["test1", "testNonethe" + utf8.decode("UTF-8"), "test3"]], dtype=np.unicode) assert_array_equal(test, ctl) # test a mixed dtype with open(path, "wb") as f: f.write(b"0,testNonethe" + utf8) test = np.genfromtxt(path, dtype=None, comments=None, delimiter=',', encoding="UTF-8") assert_equal(test['f0'], 0) assert_equal(test['f1'], "testNonethe" + utf8.decode("UTF-8"))
Example #13
Source File: test_io.py From vnpy_crypto with MIT License | 6 votes |
def test_record_unicode(self): utf8 = b'\xcf\x96' with temppath() as path: with open(path, 'wb') as f: f.write(b'1.312 foo' + utf8 + b' \n1.534 bar\n4.444 qux') dt = [('num', np.float64), ('val', 'U4')] x = np.fromregex(path, r"(?u)([0-9.]+)\s+(\w+)", dt, encoding='UTF-8') a = np.array([(1.312, 'foo' + utf8.decode('UTF-8')), (1.534, 'bar'), (4.444, 'qux')], dtype=dt) assert_array_equal(x, a) regexp = re.compile(r"([0-9.]+)\s+(\w+)", re.UNICODE) x = np.fromregex(path, regexp, dt, encoding='UTF-8') assert_array_equal(x, a) #####--------------------------------------------------------------------------
Example #14
Source File: _datasource.py From recruit with Apache License 2.0 | 6 votes |
def _python2_bz2open(fn, mode, encoding, newline): """Wrapper to open bz2 in text mode. Parameters ---------- fn : str File name mode : {'r', 'w'} File mode. Note that bz2 Text files are not supported. encoding : str Ignored, text bz2 files not supported in Python2. newline : str Ignored, text bz2 files not supported in Python2. """ import bz2 _check_mode(mode, encoding, newline) if "t" in mode: # BZ2File is missing necessary functions for TextIOWrapper warnings.warn("Assuming latin1 encoding for bz2 text file in Python2", RuntimeWarning, stacklevel=5) mode = mode.replace("t", "") return bz2.BZ2File(fn, mode)
Example #15
Source File: test_io.py From vnpy_crypto with MIT License | 6 votes |
def check_compressed(self, fopen, suffixes): # Test that we can load data from a compressed file wanted = np.arange(6).reshape((2, 3)) linesep = ('\n', '\r\n', '\r') for sep in linesep: data = '0 1 2' + sep + '3 4 5' for suffix in suffixes: with temppath(suffix=suffix) as name: with fopen(name, mode='wt', encoding='UTF-32-LE') as f: f.write(data) res = self.loadfunc(name, encoding='UTF-32-LE') assert_array_equal(res, wanted) with fopen(name, "rt", encoding='UTF-32-LE') as f: res = self.loadfunc(f) assert_array_equal(res, wanted) # Python2 .open does not support encoding
Example #16
Source File: _datasource.py From recruit with Apache License 2.0 | 6 votes |
def abspath(self, path): """ Return absolute path of file in the Repository directory. If `path` is an URL, then `abspath` will return either the location the file exists locally or the location it would exist when opened using the `open` method. Parameters ---------- path : str Can be a local file or a remote URL. This may, but does not have to, include the `baseurl` with which the `Repository` was initialized. Returns ------- out : str Complete path, including the `DataSource` destination directory. """ return DataSource.abspath(self, self._fullpath(path))
Example #17
Source File: _datasource.py From lambda-packs with MIT License | 6 votes |
def abspath(self, path): """ Return absolute path of file in the Repository directory. If `path` is an URL, then `abspath` will return either the location the file exists locally or the location it would exist when opened using the `open` method. Parameters ---------- path : str Can be a local file or a remote URL. This may, but does not have to, include the `baseurl` with which the `Repository` was initialized. Returns ------- out : str Complete path, including the `DataSource` destination directory. """ return DataSource.abspath(self, self._fullpath(path))
Example #18
Source File: svmlight_format.py From rankeval with Mozilla Public License 2.0 | 6 votes |
def _open(f, mode='r'): if mode not in ['r', 'w']: raise TypeError("expected mode to be 'r' or 'w', got %s" % mode) if mode == 'r': mode = 'rb' else: mode = 'wt' if isinstance(f, int): # file descriptor return io.open(f, mode, closefd=False) elif not isinstance(f, string_types): raise TypeError("expected {str, int, file-like}, got %s" % type(f)) _, ext = os.path.splitext(f) if ext == ".gz": import gzip return gzip.open(f, mode) elif ext == ".bz2": import bz2 return bz2.open(f, mode) else: return open(f, mode)
Example #19
Source File: _datasource.py From lambda-packs with MIT License | 6 votes |
def _check_mode(mode, encoding, newline): """Check mode and that encoding and newline are compatible. Parameters ---------- mode : str File open mode. encoding : str File encoding. newline : str Newline for text files. """ if "t" in mode: if "b" in mode: raise ValueError("Invalid mode: %r" % (mode,)) else: if encoding is not None: raise ValueError("Argument 'encoding' not supported in binary mode") if newline is not None: raise ValueError("Argument 'newline' not supported in binary mode")
Example #20
Source File: _datasource.py From vnpy_crypto with MIT License | 5 votes |
def open(path, mode='r', destpath=os.curdir, encoding=None, newline=None): """ Open `path` with `mode` and return the file object. If ``path`` is an URL, it will be downloaded, stored in the `DataSource` `destpath` directory and opened from there. Parameters ---------- path : str Local file path or URL to open. mode : str, optional Mode to open `path`. Mode 'r' for reading, 'w' for writing, 'a' to append. Available modes depend on the type of object specified by path. Default is 'r'. destpath : str, optional Path to the directory where the source file gets downloaded to for use. If `destpath` is None, a temporary directory will be created. The default path is the current directory. encoding : {None, str}, optional Open text file with given encoding. The default encoding will be what `io.open` uses. newline : {None, str}, optional Newline to use when reading text file. Returns ------- out : file object The opened file. Notes ----- This is a convenience function that instantiates a `DataSource` and returns the file object from ``DataSource.open(path)``. """ ds = DataSource(destpath) return ds.open(path, mode, encoding=encoding, newline=newline)
Example #21
Source File: _fileio.py From pysat with MIT License | 5 votes |
def __init__(self, name, mode='r', compression=None): """ Constructor. """ self.fp = None # file pointer to give access to self.ctype = None # compression type # in some cases an additional file pointer is needed self.fp_extra = None self.open(name, mode=mode, compression=compression)
Example #22
Source File: _datasource.py From lambda-packs with MIT License | 5 votes |
def _iswritemode(self, mode): """Test if the given mode will open a file for writing.""" # Currently only used to test the bz2 files. _writemodes = ("w", "+") for c in mode: if c in _writemodes: return True return False
Example #23
Source File: _datasource.py From lambda-packs with MIT License | 5 votes |
def open(self, path, mode='r', encoding=None, newline=None): """ Open and return file-like object prepending Repository base URL. If `path` is an URL, it will be downloaded, stored in the DataSource directory and opened from there. Parameters ---------- path : str Local file path or URL to open. This may, but does not have to, include the `baseurl` with which the `Repository` was initialized. mode : {'r', 'w', 'a'}, optional Mode to open `path`. Mode 'r' for reading, 'w' for writing, 'a' to append. Available modes depend on the type of object specified by `path`. Default is 'r'. encoding : {None, str}, optional Open text file with given encoding. The default encoding will be what `io.open` uses. newline : {None, str}, optional Newline to use when reading text file. Returns ------- out : file object File object. """ return DataSource.open(self, self._fullpath(path), mode, encoding=encoding, newline=newline)
Example #24
Source File: _datasource.py From lambda-packs with MIT License | 5 votes |
def _load(self): if self._loaded: return try: import bz2 if sys.version_info[0] >= 3: self._file_openers[".bz2"] = bz2.open else: self._file_openers[".bz2"] = _python2_bz2open except ImportError: pass try: import gzip if sys.version_info[0] >= 3: self._file_openers[".gz"] = gzip.open else: self._file_openers[".gz"] = _python2_gzipopen except ImportError: pass try: import lzma self._file_openers[".xz"] = lzma.open self._file_openers[".lzma"] = lzma.open except (ImportError, AttributeError): # There are incompatible backports of lzma that do not have the # lzma.open attribute, so catch that as well as ImportError. pass self._loaded = True
Example #25
Source File: _datasource.py From vnpy_crypto with MIT License | 5 votes |
def open(self, path, mode='r', encoding=None, newline=None): """ Open and return file-like object prepending Repository base URL. If `path` is an URL, it will be downloaded, stored in the DataSource directory and opened from there. Parameters ---------- path : str Local file path or URL to open. This may, but does not have to, include the `baseurl` with which the `Repository` was initialized. mode : {'r', 'w', 'a'}, optional Mode to open `path`. Mode 'r' for reading, 'w' for writing, 'a' to append. Available modes depend on the type of object specified by `path`. Default is 'r'. encoding : {None, str}, optional Open text file with given encoding. The default encoding will be what `io.open` uses. newline : {None, str}, optional Newline to use when reading text file. Returns ------- out : file object File object. """ return DataSource.open(self, self._fullpath(path), mode, encoding=encoding, newline=newline)
Example #26
Source File: _fileio.py From pysat with MIT License | 5 votes |
def open(self, name, mode='r', compression=None): """ Open a file pointer. Note that a file is *always* opened in text mode. The method inherits its input parameters from the constructor of :class:`FileObject`. """ if compression == 'use_ext': self.get_compression_type(name) else: self.ctype = compression if not self.ctype: self.fp = open(name, mode) elif self.ctype == 'gzip': self.fp = gzip.open(name, mode + 't') elif self.ctype == 'bzip2': try: # Python 3 supports opening bzip2 files in text mode # therefore, we prefer to open them this way self.fp = bz2.open(name, mode + 't') except: # BZ2File opens a file in binary mode # thus, we have to use codecs.getreader() # to be able to use it in text mode self.fp_extra = bz2.BZ2File(name, mode) if mode == 'r': self.fp = codecs.getreader('ascii')(self.fp_extra) else: # mode == 'w' self.fp = codecs.getwriter('ascii')(self.fp_extra) else: # self.ctype == 'lzma' # LZMA is available in Python 2 only if backports.lzma is installed # Python 3 supports it by default assert lzma_present, 'LZMA compression is unavailable.' self.fp = lzma.open(name, mode=mode + 't')
Example #27
Source File: test_io.py From vnpy_crypto with MIT License | 5 votes |
def test_not_closing_opened_fid(self): # Test that issue #2178 is fixed: # verify could seek on 'loaded' file with temppath(suffix='.npz') as tmp: with open(tmp, 'wb') as fp: np.savez(fp, data='LOVELY LOAD') with open(tmp, 'rb', 10000) as fp: fp.seek(0) assert_(not fp.closed) np.load(fp)['data'] # fp must not get closed by .load assert_(not fp.closed) fp.seek(0) assert_(not fp.closed)
Example #28
Source File: test_io.py From vnpy_crypto with MIT License | 5 votes |
def test_closing_zipfile_after_load(self): # Check that zipfile owns file and can close it. This needs to # pass a file name to load for the test. On windows failure will # cause a second error will be raised when the attempt to remove # the open file is made. prefix = 'numpy_test_closing_zipfile_after_load_' with temppath(suffix='.npz', prefix=prefix) as tmp: np.savez(tmp, lab='place holder') data = np.load(tmp) fp = data.zip.fp data.close() assert_(fp.closed)
Example #29
Source File: test_io.py From vnpy_crypto with MIT License | 5 votes |
def test_encoding(self): with temppath() as path: with open(path, "wb") as f: f.write('0.\n1.\n2.'.encode("UTF-16")) x = self.loadfunc(path, encoding="UTF-16") assert_array_equal(x, [0., 1., 2.])
Example #30
Source File: _datasource.py From vnpy_crypto with MIT License | 5 votes |
def _load(self): if self._loaded: return try: import bz2 if sys.version_info[0] >= 3: self._file_openers[".bz2"] = bz2.open else: self._file_openers[".bz2"] = _python2_bz2open except ImportError: pass try: import gzip if sys.version_info[0] >= 3: self._file_openers[".gz"] = gzip.open else: self._file_openers[".gz"] = _python2_gzipopen except ImportError: pass try: import lzma self._file_openers[".xz"] = lzma.open self._file_openers[".lzma"] = lzma.open except (ImportError, AttributeError): # There are incompatible backports of lzma that do not have the # lzma.open attribute, so catch that as well as ImportError. pass self._loaded = True