[refactor] Remove indirection with call operator

I don't understand why it existed int he first place.
It adds anotherhasattr check, but as the attributes are already checked
in __init__, this should only have any meaning when attributes are
removed dynamically from the object after giving it to __init__.
This is not supported anymore!

Author: mxmlnkn

mfusepy.py

@@ -1177,7 +1177,7 @@ class as is to Operations, instead of just the fh field.
 
             # Function pointer members are tested for using the
             # getattr(operations, name) above but are dynamically
-            # invoked using self.operations(name)
+            # invoked using self.operations.name
             if hasattr(prototype, 'argtypes'):
                 val = prototype(functools.partial(self._wrapper, getattr(self, name)))
 
@@ -1268,7 +1268,7 @@ def getattr(self, path: bytes, buf, fip):  # type: ignore
             return self.fgetattr(path, buf, None)
 
     def readlink(self, path: bytes, buf, bufsize: int) -> int:
-        ret = self.operations('readlink', path.decode(self.encoding)).encode(self.encoding)
+        ret = self.operations.readlink(path.decode(self.encoding)).encode(self.encoding)
 
         # copies a string into the given buffer
         # (null terminated and truncated if necessary)
@@ -1277,24 +1277,24 @@ def readlink(self, path: bytes, buf, bufsize: int) -> int:
         return 0
 
     def mknod(self, path: bytes, mode: int, dev: int) -> int:
-        return self.operations('mknod', path.decode(self.encoding), mode, dev)
+        return self.operations.mknod(path.decode(self.encoding), mode, dev)
 
     def mkdir(self, path: bytes, mode: int) -> int:
-        return self.operations('mkdir', path.decode(self.encoding), mode)
+        return self.operations.mkdir(path.decode(self.encoding), mode)
 
     def unlink(self, path: bytes) -> int:
-        return self.operations('unlink', path.decode(self.encoding))
+        return self.operations.unlink(path.decode(self.encoding))
 
     def rmdir(self, path: bytes) -> int:
-        return self.operations('rmdir', path.decode(self.encoding))
+        return self.operations.rmdir(path.decode(self.encoding))
 
     def symlink(self, source: bytes, target: bytes) -> int:
         'creates a symlink `target -> source` (e.g. ln -s source target)'
 
-        return self.operations('symlink', target.decode(self.encoding), source.decode(self.encoding))
+        return self.operations.symlink(target.decode(self.encoding), source.decode(self.encoding))
 
     def _rename(self, old: bytes, new: bytes) -> int:
-        return self.operations('rename', old.decode(self.encoding), new.decode(self.encoding))
+        return self.operations.rename(old.decode(self.encoding), new.decode(self.encoding))
 
     if fuse_version_major == 2:
         rename = _rename
@@ -1306,17 +1306,17 @@ def rename(self, old: bytes, new: bytes, flags: int) -> int:  # type: ignore
     def link(self, source: bytes, target: bytes):
         'creates a hard link `target -> source` (e.g. ln source target)'
 
-        return self.operations('link', target.decode(self.encoding), source.decode(self.encoding))
+        return self.operations.link(target.decode(self.encoding), source.decode(self.encoding))
 
     if fuse_version_major == 2:
 
         def chmod(self, path: Optional[bytes], mode: int) -> int:
-            return self.operations('chmod', None if path is None else path.decode(self.encoding), mode)
+            return self.operations.chmod(None if path is None else path.decode(self.encoding), mode)
 
     elif fuse_version_major == 3:
 
         def chmod(self, path: Optional[bytes], mode: int, fip) -> int:  # type: ignore
-            return self.operations('chmod', None if path is None else path.decode(self.encoding), mode)
+            return self.operations.chmod(None if path is None else path.decode(self.encoding), mode)
 
     def _chown(self, path: Optional[bytes], uid: int, gid: int) -> int:
         # Check if any of the arguments is a -1 that has overflowed
@@ -1325,38 +1325,38 @@ def _chown(self, path: Optional[bytes], uid: int, gid: int) -> int:
         if c_gid_t(gid + 1).value == 0:
             gid = -1
 
-        return self.operations('chown', None if path is None else path.decode(self.encoding), uid, gid)
+        return self.operations.chown(None if path is None else path.decode(self.encoding), uid, gid)
 
     if fuse_version_major == 2:
 
-        def chown(self, path: bytes, uid: int, gid: int) -> int:
+        def chown(self, path: Optional[bytes], uid: int, gid: int) -> int:
             return self._chown(path, uid, gid)
 
     elif fuse_version_major == 3:
 
-        def chown(self, path: bytes, uid: int, gid: int, fip) -> int:  # type: ignore
+        def chown(self, path: Optional[bytes], uid: int, gid: int, fip) -> int:  # type: ignore
             return self._chown(path, uid, gid)
 
     if fuse_version_major == 2:
 
         def truncate(self, path: Optional[bytes], length: int) -> int:
-            return self.operations('truncate', None if path is None else path.decode(self.encoding), length)
+            return self.operations.truncate(None if path is None else path.decode(self.encoding), length)
 
     elif fuse_version_major == 3:
 
         def truncate(self, path: Optional[bytes], length: int, fip) -> int:  # type: ignore
-            return self.operations('truncate', None if path is None else path.decode(self.encoding), length)
+            return self.operations.truncate(None if path is None else path.decode(self.encoding), length)
 
     def open(self, path: bytes, fip) -> int:
         fi = fip.contents
         if self.raw_fi:
-            return self.operations('open', path.decode(self.encoding), fi)
-        fi.fh = self.operations('open', path.decode(self.encoding), fi.flags)
+            return self.operations.open(path.decode(self.encoding), fi)
+        fi.fh = self.operations.open(path.decode(self.encoding), fi.flags)
         return 0
 
     def read(self, path: Optional[bytes], buf, size: int, offset: int, fip) -> int:
         fh = fip.contents if self.raw_fi else fip.contents.fh
-        ret = self.operations('read', None if path is None else path.decode(self.encoding), size, offset, fh)
+        ret = self.operations.read(None if path is None else path.decode(self.encoding), size, offset, fh)
 
         if not ret:
             return 0
@@ -1370,11 +1370,11 @@ def read(self, path: Optional[bytes], buf, size: int, offset: int, fip) -> int:
     def write(self, path: Optional[bytes], buf, size: int, offset: int, fip) -> int:
         data = ctypes.string_at(buf, size)
         fh = fip.contents if self.raw_fi else fip.contents.fh
-        return self.operations('write', None if path is None else path.decode(self.encoding), data, offset, fh)
+        return self.operations.write(None if path is None else path.decode(self.encoding), data, offset, fh)
 
     def statfs(self, path: bytes, buf) -> int:
         stv = buf.contents
-        attrs = self.operations('statfs', path.decode(self.encoding))
+        attrs = self.operations.statfs(path.decode(self.encoding))
         for key, val in attrs.items():
             if hasattr(stv, key):
                 setattr(stv, key, val)
@@ -1383,19 +1383,18 @@ def statfs(self, path: bytes, buf) -> int:
 
     def flush(self, path: Optional[bytes], fip) -> int:
         fh = fip.contents if self.raw_fi else fip.contents.fh
-        return self.operations('flush', None if path is None else path.decode(self.encoding), fh)
+        return self.operations.flush(None if path is None else path.decode(self.encoding), fh)
 
     def release(self, path: Optional[bytes], fip) -> int:
         fh = fip.contents if self.raw_fi else fip.contents.fh
-        return self.operations('release', None if path is None else path.decode(self.encoding), fh)
+        return self.operations.release(None if path is None else path.decode(self.encoding), fh)
 
     def fsync(self, path: Optional[bytes], datasync: int, fip) -> int:
         fh = fip.contents if self.raw_fi else fip.contents.fh
-        return self.operations('fsync', None if path is None else path.decode(self.encoding), datasync, fh)
+        return self.operations.fsync(None if path is None else path.decode(self.encoding), datasync, fh)
 
     def setxattr(self, path: bytes, name: bytes, value, size: int, options, *args) -> int:
-        return self.operations(
-            'setxattr',
+        return self.operations.setxattr(
             path.decode(self.encoding),
             name.decode(self.encoding),
             ctypes.string_at(value, size),
@@ -1404,7 +1403,7 @@ def setxattr(self, path: bytes, name: bytes, value, size: int, options, *args) -
         )
 
     def getxattr(self, path: bytes, name: bytes, value, size: int, *args) -> int:
-        ret = self.operations('getxattr', path.decode(self.encoding), name.decode(self.encoding), *args)
+        ret = self.operations.getxattr(path.decode(self.encoding), name.decode(self.encoding), *args)
 
         retsize = len(ret)
         # allow size queries
@@ -1422,7 +1421,7 @@ def getxattr(self, path: bytes, name: bytes, value, size: int, *args) -> int:
         return retsize
 
     def listxattr(self, path: bytes, namebuf, size: int) -> int:
-        attrs = self.operations('listxattr', path.decode(self.encoding)) or ''
+        attrs = self.operations.listxattr(path.decode(self.encoding)) or ''
         ret = '\x00'.join(attrs).encode(self.encoding)
         if len(ret) > 0:
             ret += '\x00'.encode(self.encoding)
@@ -1442,11 +1441,11 @@ def listxattr(self, path: bytes, namebuf, size: int) -> int:
         return retsize
 
     def removexattr(self, path: bytes, name: bytes) -> int:
-        return self.operations('removexattr', path.decode(self.encoding), name.decode(self.encoding))
+        return self.operations.removexattr(path.decode(self.encoding), name.decode(self.encoding))
 
     def opendir(self, path: bytes, fip) -> int:
         # Ignore raw_fi
-        fip.contents.fh = self.operations('opendir', path.decode(self.encoding))
+        fip.contents.fh = self.operations.opendir(path.decode(self.encoding))
         return 0
 
     # == About readdir and what should be returned ==
@@ -1512,7 +1511,7 @@ def opendir(self, path: bytes, fip) -> int:
     #     fuse.h#L263C1-L280C3
     def _readdir(self, path: Optional[bytes], buf, filler, offset: int, fip) -> int:
         # Ignore raw_fi
-        for item in self.operations('readdir', None if path is None else path.decode(self.encoding), fip.contents.fh):
+        for item in self.operations.readdir(None if path is None else path.decode(self.encoding), fip.contents.fh):
             if isinstance(item, str):
                 name, st, offset = item, None, 0
             else:
@@ -1549,13 +1548,11 @@ def readdir(self, path: Optional[bytes], buf, filler, offset, fip, flags) -> int
 
     def releasedir(self, path: Optional[bytes], fip) -> int:
         # Ignore raw_fi
-        return self.operations('releasedir', None if path is None else path.decode(self.encoding), fip.contents.fh)
+        return self.operations.releasedir(None if path is None else path.decode(self.encoding), fip.contents.fh)
 
     def fsyncdir(self, path: Optional[bytes], datasync: int, fip) -> int:
         # Ignore raw_fi
-        return self.operations(
-            'fsyncdir', None if path is None else path.decode(self.encoding), datasync, fip.contents.fh
-        )
+        return self.operations.fsyncdir(None if path is None else path.decode(self.encoding), datasync, fip.contents.fh)
 
     def _init(self, conn, config) -> None:
         if hasattr(self.operations, "init_with_config") and not getattr(
@@ -1578,40 +1575,40 @@ def init(self, conn, config) -> None:  # type: ignore
             self._init(conn, config)
 
     def destroy(self, private_data) -> None:
-        return self.operations('destroy', '/')
+        return self.operations.destroy('/')
 
     def access(self, path: bytes, amode: int) -> int:
-        return self.operations('access', path.decode(self.encoding), amode)
+        return self.operations.access(path.decode(self.encoding), amode)
 
     def create(self, path: bytes, mode: int, fip) -> int:
         fi = fip.contents
         decoded_path = path.decode(self.encoding)
 
         if self.raw_fi:
-            return self.operations('create', decoded_path, mode, fi)
+            return self.operations.create(decoded_path, mode, fi)
         if len(inspect.signature(self.operations.create).parameters) == 2:
-            fi.fh = self.operations('create', decoded_path, mode)
+            fi.fh = self.operations.create(decoded_path, mode)
         else:
-            fi.fh = self.operations('create', decoded_path, mode, fi.flags)
+            fi.fh = self.operations.create(decoded_path, mode, fi.flags)
         return 0
 
     def ftruncate(self, path: Optional[bytes], length: int, fip) -> int:
         fh = fip.contents if self.raw_fi else fip.contents.fh
-        return self.operations('truncate', None if path is None else path.decode(self.encoding), length, fh)
+        return self.operations.truncate(None if path is None else path.decode(self.encoding), length, fh)
 
     def fgetattr(self, path: Optional[bytes], buf, fip) -> int:
         ctypes.memset(buf, 0, ctypes.sizeof(c_stat))
 
         st = buf.contents
         fh = (fip.contents if self.raw_fi else fip.contents.fh) if fip else fip
 
-        attrs = self.operations('getattr', None if path is None else path.decode(self.encoding), fh)
+        attrs = self.operations.getattr(None if path is None else path.decode(self.encoding), fh)
         set_st_attrs(st, attrs, use_ns=self.use_ns)
         return 0
 
     def lock(self, path: Optional[bytes], fip, cmd: int, lock) -> int:
         fh = fip.contents if self.raw_fi else fip.contents.fh
-        return self.operations('lock', None if path is None else path.decode(self.encoding), fh, cmd, lock)
+        return self.operations.lock(None if path is None else path.decode(self.encoding), fh, cmd, lock)
 
     def _utimens(self, path: Optional[bytes], buf) -> int:
         if buf:
@@ -1621,7 +1618,7 @@ def _utimens(self, path: Optional[bytes], buf) -> int:
         else:
             times = None
 
-        return self.operations('utimens', None if path is None else path.decode(self.encoding), times)
+        return self.operations.utimens(None if path is None else path.decode(self.encoding), times)
 
     if fuse_version_major == 2:
         utimens = _utimens
@@ -1631,33 +1628,31 @@ def utimens(self, path: Optional[bytes], buf, fip) -> int:  # type: ignore
             return self._utimens(path, buf)
 
     def bmap(self, path: bytes, blocksize: int, idx) -> int:
-        return self.operations('bmap', path.decode(self.encoding), blocksize, idx)
+        return self.operations.bmap(path.decode(self.encoding), blocksize, idx)
 
     def ioctl(self, path: Optional[bytes], cmd: int, arg, fip, flags: int, data) -> int:
         fh = fip.contents if self.raw_fi else fip.contents.fh
-        return self.operations('ioctl', None if path is None else path.decode(self.encoding), cmd, arg, fh, flags, data)
+        return self.operations.ioctl(None if path is None else path.decode(self.encoding), cmd, arg, fh, flags, data)
 
     def poll(self, path: Optional[bytes], fip, ph, reventsp) -> int:
         fh = fip.contents if self.raw_fi else fip.contents.fh
-        return self.operations('poll', None if path is None else path.decode(self.encoding), fh, ph, reventsp)
+        return self.operations.poll(None if path is None else path.decode(self.encoding), fh, ph, reventsp)
 
     def write_buf(self, path: bytes, buf, offset: int, fip) -> int:
         fh = fip.contents if self.raw_fi else fip.contents.fh
-        return self.operations('write_buf', path.decode(self.encoding), buf, offset, fh)
+        return self.operations.write_buf(path.decode(self.encoding), buf, offset, fh)
 
     def read_buf(self, path: bytes, bufpp, size: int, offset: int, fip) -> int:
         fh = fip.contents if self.raw_fi else fip.contents.fh
-        return self.operations('read_buf', path.decode(self.encoding), bufpp, size, offset, fh)
+        return self.operations.read_buf(path.decode(self.encoding), bufpp, size, offset, fh)
 
     def flock(self, path: bytes, fip, op: int) -> int:
         fh = fip.contents if self.raw_fi else fip.contents.fh
-        return self.operations('flock', path.decode(self.encoding), fh, op)
+        return self.operations.flock(path.decode(self.encoding), fh, op)
 
     def fallocate(self, path: Optional[bytes], mode: int, offset: int, size: int, fip) -> int:
         fh = fip.contents if self.raw_fi else fip.contents.fh
-        return self.operations(
-            'fallocate', None if path is None else path.decode(self.encoding), mode, offset, size, fh
-        )
+        return self.operations.fallocate(None if path is None else path.decode(self.encoding), mode, offset, size, fh)
 
 
 def _nullable_dummy_function(method):
@@ -1695,11 +1690,6 @@ class Operations:
     than int.
     '''
 
-    def __call__(self, op, *args):
-        if not hasattr(self, op):
-            raise FuseOSError(errno.EFAULT)
-        return getattr(self, op)(*args)
-
     @_nullable_dummy_function
     def access(self, path: str, amode: int) -> int:
         return 0