A few tweaks and fixes

fs/base.py

@@ -320,7 +320,7 @@ class FS(object):
         """
 
         def get_path(p):
-            if not full:
+            if not full or absolute:
                 return pathjoin(path, p)
 
         return [(p, self.getinfo(get_path(p)))

fs/ftpfs.py

@@ -543,8 +543,6 @@ class _FTPFile(object):
             self.ftp.voidcmd('TYPE I')
             self.conn = ftp.transfercmd('RETR '+path, None)
 
-            #self._ftp_thread = threading.Thread(target=do_read)
-            #self._ftp_thread.start()
         elif 'w' in mode or 'a' in mode:
             self.ftp.voidcmd('TYPE I')
             if 'a' in mode:
@@ -552,16 +550,6 @@ class _FTPFile(object):
                 self.conn = self.ftp.transfercmd('APPE '+path)
             else:
                 self.conn = self.ftp.transfercmd('STOR '+path)
-            #while 1:
-            #    buf = fp.read(blocksize)
-            #    if not buf: break
-            #    conn.sendall(buf)
-            #    if callback: callback(buf)
-            #conn.close()
-            #return self.voidresp()
-
-            #self._ftp_thread = threading.Thread(target=do_write)
-            #self._ftp_thread.start()
 
     @synchronize
     def read(self, size=None):
@@ -689,17 +677,20 @@ class _FTPFile(object):
         """
         endings = '\r\n'
         chars = []
+        append = chars.append
+        read = self.read
+        join = ''.join
         while True:
-            char = self.read(1)
+            char = read(1)
             if not char:
-                yield ''.join(chars)
-                del chars[:]
+                if chars:
+                    yield join(chars)
                 break
-            chars.append(char)
+            append(char)
             if char in endings:
-                line = ''.join(chars)
+                line = join(chars)
                 del chars[:]
-                c = self.read(1)
+                c = read(1)
                 if not char:
                     yield line
                     break
@@ -707,7 +698,7 @@ class _FTPFile(object):
                     yield line + c
                 else:
                     yield line
-                    chars.append(c)
+                    append(c)
 
 
 

fs/memoryfs.py

@@ -181,6 +181,7 @@ class MemoryFS(FS):
 
     def __init__(self, file_factory=None):
         super(MemoryFS, self).__init__(thread_synchronize=_thread_synchronize_default)
+
         self.dir_entry_factory = DirEntry
         self.file_factory = file_factory or MemoryFile
 
@@ -463,5 +464,3 @@ class MemoryFS(FS):
             info['size'] = len(dir_entry.data or '')
 
         return info
-
-

fs/mountfs.py

@@ -35,7 +35,7 @@ class MountFS(FS):
     FileMount = FileMount
 
     def __init__(self, thread_synchronize=_thread_synchronize_default):
-        FS.__init__(self, thread_synchronize=thread_synchronize)
+        super(MountFS, self).__init__(thread_synchronize=thread_synchronize)
         self.mount_tree = ObjectTree()
 
     def __str__(self):

fs/multifs.py

@@ -39,7 +39,7 @@ class MultiFS(FS):
     """
 
     def __init__(self):
-        FS.__init__(self, thread_synchronize=_thread_synchronize_default)
+        super(MultiFS, self).__init__(thread_synchronize=_thread_synchronize_default)
 
         self.fs_sequence = []
         self.fs_lookup =  {}
@@ -195,4 +195,3 @@ class MultiFS(FS):
             if fs.exists(path):
                 return fs.getinfo(path)
         raise ResourceNotFoundError(path)
-

fs/osfs.py

@@ -41,8 +41,7 @@ class OSFS(FS):
     methods in the os and os.path modules.
     """
 
-    def __init__(self, root_path, dir_mode=0700, thread_synchronize=_thread_synchronize_default, encoding=None):
-        
+    def __init__(self, root_path, dir_mode=0700, thread_synchronize=_thread_synchronize_default, encoding=None, create=False):
         """
         Creates an FS object that represents the OS Filesystem under a given root path
 
@@ -50,10 +49,11 @@ class OSFS(FS):
         :param dir_mode: srt
         :param thread_synchronize: If True, this object will be thread-safe by use of a threading.Lock object
         :param encoding: The encoding method for path strings
+        :param create: Of True, then root_path will be created (if neccesary)
 
         """
 
-        FS.__init__(self, thread_synchronize=thread_synchronize)
+        super(OSFS, self).__init__(thread_synchronize=thread_synchronize)
         self.encoding = encoding
         root_path = os.path.expanduser(os.path.expandvars(root_path))
         root_path = os.path.normpath(os.path.abspath(root_path))
@@ -61,6 +61,13 @@ class OSFS(FS):
         if sys.platform == "win32":
             if not root_path.startswith("\\\\?\\"):
                 root_path = u"\\\\?\\" + root_path
+
+        if create:
+            try:
+                os.makedirs(root_path, mode=dir_mode)
+            except OSError:
+                pass
+
         if not os.path.exists(root_path):
             raise ResourceNotFoundError(root_path,msg="Root directory does not exist: %(path)s")
         if not os.path.isdir(root_path):
@@ -225,5 +232,3 @@ class OSFS(FS):
         @convert_os_errors
         def listxattrs(self, path):
             return xattr.xattr(self.getsyspath(path)).keys()
-
-

fs/s3fs.py

@@ -88,7 +88,7 @@ class S3FS(FS):
             prefix = prefix + separator
         self._prefix = prefix
         self._tlocal = thread_local()
-        FS.__init__(self, thread_synchronize=thread_synchronize)
+        super(S3FS, self).__init__(thread_synchronize=thread_synchronize)
 
     #  Make _s3conn and _s3bukt properties that are created on demand,
     #  since they cannot be stored during pickling.
@@ -486,4 +486,3 @@ class S3FS(FS):
     def get_total_size(self):
         """Get total size of all files in this FS."""
         return sum(k.size for k in self._s3bukt.list(prefix=self._prefix))
-

fs/sftpfs.py

@@ -79,6 +79,7 @@ class SFTPFS(FS):
                 connection.connect(**credentials)
             self._transport = connection
         self.root_path = abspath(normpath(root_path))
+        super(SFTPFS, self).__init__()
 
     def __del__(self):
         self.close()
@@ -320,5 +321,3 @@ class SFTPFS(FS):
         npath = self._normpath(path)
         stats = self.client.stat(npath)
         return stats.st_size
- 
-

fs/tempfs.py

@@ -28,7 +28,7 @@ class TempFS(OSFS):
         """
         self._temp_dir = tempfile.mkdtemp(identifier or "TempFS",dir=temp_dir)
         self._cleaned = False
-        OSFS.__init__(self, self._temp_dir, dir_mode=dir_mode, thread_synchronize=thread_synchronize)
+        super(TempFS, self).__init__(self._temp_dir, dir_mode=dir_mode, thread_synchronize=thread_synchronize)
 
     def __str__(self):
         return '<TempFS: %s>' % self._temp_dir
@@ -86,5 +86,3 @@ class TempFS(OSFS):
             finally:
                 self._lock.release()
         super(TempFS,self).close()
-
-

fs/tests/__init__.py

@@ -26,7 +26,7 @@ except ImportError:
     import dummy_threading as threading
 
 
-class FSTestCases:
+class FSTestCases(object):
     """Base suite of testcases for filesystem implementations.
 
     Any FS subclass should be capable of passing all of these tests.
@@ -70,14 +70,14 @@ class FSTestCases:
         f = self.fs.open("test1.txt","w")
         f.write("testing")
         f.close()
-        self.check("test1.txt")
+        self.assertTrue(self.check("test1.txt"))
         f = self.fs.open("test1.txt","r")
         self.assertEquals(f.read(),"testing")
         f.close()
         f = self.fs.open("test1.txt","w")
         f.write("test file overwrite")
         f.close()
-        self.check("test1.txt")
+        self.assertTrue(self.check("test1.txt"))
         f = self.fs.open("test1.txt","r")
         self.assertEquals(f.read(),"test file overwrite")
         f.close()
@@ -165,7 +165,7 @@ class FSTestCases:
         self.fs.makedir(alpha)
         self.fs.createfile(alpha+"/a")
         self.fs.createfile(alpha+"/"+beta)
-        self.check(alpha)
+        self.assertTrue(self.check(alpha))
         self.assertEquals(sorted(self.fs.listdir(alpha)),["a",beta])
 
     def test_makedir(self):
@@ -746,5 +746,3 @@ class ThreadingTestCases:
                     self.assertEquals(self.fs.getsize("thread2.txt"),len(c))
                     self.assertEquals(self.fs.getcontents("thread2.txt"),c)
         self._runThreads(thread1,thread2)
-
-

fs/zipfs.py

@@ -55,18 +55,18 @@ class ZipFS(FS):
 
     """A FileSystem that represents a zip file."""
 
-    def __init__(self, zip_file, mode="r", compression="deflated", allowZip64=False, encoding="CP437", thread_synchronize=True):
+    def __init__(self, zip_file, mode="r", compression="deflated", allow_zip_64=False, encoding="CP437", thread_synchronize=True):
         """Create a FS that maps on to a zip file.
 
         :param zip_file: A (system) path, or a file-like object
         :param mode: Mode to open zip file: 'r' for reading, 'w' for writing or 'a' for appending
         :param compression: Can be 'deflated' (default) to compress data or 'stored' to just store date
-        :param allowZip64: -- Set to True to use zip files greater than 2 MB, default is False
+        :param allow_zip_64: -- Set to True to use zip files greater than 2 MB, default is False
         :param encoding: --  The encoding to use for unicode filenames
         :param thread_synchronize: -- Set to True (default) to enable thread-safety
 
         """
-        FS.__init__(self, thread_synchronize=thread_synchronize)
+        super(ZipFS, self).__init__(thread_synchronize=thread_synchronize)
         if compression == "deflated":
             compression_type = ZIP_DEFLATED
         elif compression == "stored":
@@ -80,7 +80,7 @@ class ZipFS(FS):
         self.zip_mode = mode
         self.encoding = encoding
         try:
-            self.zf = ZipFile(zip_file, mode, compression_type, allowZip64)
+            self.zf = ZipFile(zip_file, mode, compression_type, allow_zip_64)
         except IOError:
             raise ResourceNotFoundError(str(zip_file), msg="Zip file does not exist: %(path)s")
         self.zip_path = str(zip_file)
@@ -212,5 +212,3 @@ class ZipFS(FS):
             info['created_time'] = datetime.datetime(*zinfo['date_time'])
         info.update(zinfo)
         return info
-
-