Refactoring: Path API compatibility with pathlib

Refactored dupeGuru to make hscommon.path's API a bit close to pathlib's
API. It's not 100% compatible yet, but it's much better than before.

This is more of a hscommon refactoring than a dupeguru one, but since
duepGuru is the main user of Path, it was the driver behind the
refactoring.

This refactoring also see the introduction of @pathify, which ensure
Path arguments. Previously, we were often unsure of whether the caller
of a function was passing a Path or a str. This problem is now solved
and this allows us to remove hscommon.io, an ill-conceived attempt to
solve that same ambiguity problem.

Fixes #235.

hscommon/path.py

@@ -12,6 +12,8 @@ import os.path as op
 import shutil
 import sys
 from itertools import takewhile
+from functools import wraps
+from inspect import signature
 
 class Path(tuple):
     """A handy class to work with paths.
@@ -94,12 +96,11 @@ class Path(tuple):
                 stop = -len(equal_elems) if equal_elems else None
                 key = slice(key.start, stop, key.step)
             return Path(tuple.__getitem__(self, key))
+        elif isinstance(key, (str, Path)):
+            return self + key
         else:
             return tuple.__getitem__(self, key)
     
-    def __getslice__(self, i, j): #I have to override it because tuple uses it.
-        return Path(tuple.__getslice__(self, i, j))
-    
     def __hash__(self):
         return tuple.__hash__(self)
     
@@ -133,6 +134,13 @@ class Path(tuple):
     def tobytes(self):
         return str(self).encode(sys.getfilesystemencoding())
     
+    def parent(self):
+        return self[:-1]
+    
+    @property
+    def name(self):
+        return self[-1]
+    
     # OS method wrappers
     def exists(self):
         return op.exists(str(self))
@@ -153,7 +161,7 @@ class Path(tuple):
         return op.islink(str(self))
 
     def listdir(self):
-        return os.listdir(str(self))
+        return [self[name] for name in os.listdir(str(self))]
 
     def mkdir(self, *args, **kwargs):
         return os.mkdir(str(self), *args, **kwargs)
@@ -182,3 +190,43 @@ class Path(tuple):
     def stat(self):
         return os.stat(str(self))
     
+def pathify(f):
+    """Ensure that every annotated :class:`Path` arguments are actually paths.
+    
+    When a function is decorated with ``@pathify``, every argument with annotated as Path will be
+    converted to a Path if it wasn't already. Example::
+    
+        @pathify
+        def foo(path: Path, otherarg):
+            return path.listdir()
+    
+    Calling ``foo('/bar', 0)`` will convert ``'/bar'`` to ``Path('/bar')``.
+    """
+    sig = signature(f)
+    pindexes = {i for i, p in enumerate(sig.parameters.values()) if p.annotation is Path}
+    pkeys = {k: v for k, v in sig.parameters.items() if v.annotation is Path}
+    def path_or_none(p):
+        return None if p is None else Path(p)
+    
+    @wraps(f)
+    def wrapped(*args, **kwargs):
+        args = tuple((path_or_none(a) if i in pindexes else a) for i, a in enumerate(args))
+        kwargs = {k: (path_or_none(v) if k in pkeys else v) for k, v in kwargs.items()}
+        return f(*args, **kwargs)
+    
+    return wrapped
+
+def log_io_error(func):
+    """ Catches OSError, IOError and WindowsError and log them
+    """
+    @wraps(func)
+    def wrapper(path, *args, **kwargs):
+        try:
+            return func(path, *args, **kwargs)
+        except (IOError, OSError) as e:
+            msg = 'Error "{0}" during operation "{1}" on "{2}": "{3}"'
+            classname = e.__class__.__name__
+            funcname = func.__name__
+            logging.warn(msg.format(classname, funcname, str(path), str(e)))
+    
+    return wrapper