def __init__(self, *args, **kw):  # {{{2

    try:

      # Set the Python FUSE API version.
      fuse.fuse_python_api = (0, 2)

      # Initialize the FUSE binding's internal state.
      fuse.Fuse.__init__(self, *args, **kw)

      # Set some options required by the Python FUSE binding.
      self.flags = 0
      self.multithreaded = 0

      # Initialize instance attributes.
      self.block_size = 1024 * 128
      self.buffers = {}
      self.bytes_read = 0
      self.bytes_written = 0
      self.cache_gc_last_run = time.time()
      self.cache_requests = 0
      self.cache_timeout = 60 # TODO Make this a command line option!
      self.cached_nodes = {}
      self.calls_log_filter = []
      self.datastore_file = '~/.dedupfs-datastore.db'
      self.fs_mounted_at = time.time()
      self.gc_enabled = True
      self.gc_hook_last_run = time.time()
      self.gc_interval = 60
      self.link_mode = stat.S_IFLNK | 0777
      self.memory_usage = 0
      self.metastore_file = '~/.dedupfs-metastore.sqlite3'
      self.opcount = 0
      self.read_only = False
      self.root_mode = stat.S_IFDIR | 0755
      self.time_spent_caching_nodes = 0
      self.time_spent_hashing = 0
      self.time_spent_interning = 0
      self.time_spent_querying_tree = 0
      self.time_spent_reading = 0
      self.time_spent_traversing_tree = 0
      self.time_spent_writing = 0
      self.time_spent_writing_blocks = 0
      self.__NODE_KEY_VALUE = 0
      self.__NODE_KEY_LAST_USED = 1

      # Initialize a Logger() object to handle logging.
      self.logger = logging.getLogger('dedupfs')
      self.logger.setLevel(logging.INFO)
      self.logger.addHandler(logging.StreamHandler(sys.stderr))

      # Register some custom command line options with the option parser.
      option_stored_in_db = " (this option is only useful when creating a new database, because your choice is stored in the database and can't be changed after that)"
      self.parser.set_conflict_handler('resolve') # enable overriding the --help message.
      self.parser.add_option('-h', '--help', action='help', help="show this help message followed by the command line options defined by the Python FUSE binding and exit")
      self.parser.add_option('-v', '--verbose', action='count', dest='verbosity', default=0, help="increase verbosity")
      self.parser.add_option('--print-stats', dest='print_stats', action='store_true', default=False, help="print the total apparent size and the actual disk usage of the file system and exit")
      self.parser.add_option('--log-file', dest='log_file', help="specify log file location")
      self.parser.add_option('--metastore', dest='metastore', metavar='FILE', default=self.metastore_file, help="specify the location of the file in which metadata is stored")
      self.parser.add_option('--datastore', dest='datastore', metavar='FILE', default=self.datastore_file, help="specify the location of the file in which data blocks are stored")
      self.parser.add_option('--block-size', dest='block_size', metavar='BYTES', default=self.block_size, type='int', help="specify the maximum block size in bytes" + option_stored_in_db)
      self.parser.add_option('--no-transactions', dest='use_transactions', action='store_false', default=True, help="don't use transactions when making multiple related changes, this might make the file system faster or slower (?)")
      self.parser.add_option('--nosync', dest='synchronous', action='store_false', default=True, help="disable SQLite's normal synchronous behavior which guarantees that data is written to disk immediately, because it slows down the file system too much (this means you might lose data when the mount point isn't cleanly unmounted)")
      self.parser.add_option('--nogc', dest='gc_enabled', action='store_false', default=True, help="disable the periodic garbage collection because it degrades performance (only do this when you've got disk space to waste or you know that nothing will be be deleted from the file system, which means little to no garbage will be produced)")
      self.parser.add_option('--verify-writes', dest='verify_writes', action='store_true', default=False, help="after writing a new data block to the database, check that the block was written correctly by reading it back again and checking for differences")

      # Dynamically check for supported hashing algorithms.
      msg = "specify the hashing algorithm that will be used to recognize duplicate data blocks: one of %s" + option_stored_in_db
      hash_functions = filter(lambda m: m[0] != '_' and m != 'new', dir(hashlib))
      msg %= ', '.join(fun % '%r' for fun in hash_functions)
      self.parser.add_option('--hash', dest='hash_function', metavar='FUNCTION', type='choice', choices=hash_functions, default='sha1', help=msg)

      # Dynamically check for supported compression methods.
      def noop(s): return s
      self.compressors = { 'none': (noop, noop) }
      compression_methods = ['none']
      for modname in 'lzo', 'zlib', 'bz2':
        try:
          module = __import__(modname)
          if hasattr(module, 'compress') and hasattr(module, 'decompress'):
            self.compressors[modname] = (module.compress, module.decompress)
            compression_methods.append(modname)
        except ImportError:
          pass
      msg = "enable compression of data blocks using one of the supported compression methods: one of %s" + option_stored_in_db
      msg %= ', '.join('%r' % mth for mth in compression_methods[1:])
      self.parser.add_option('--compress', dest='compression_method', metavar='METHOD', type='choice', choices=compression_methods, default='none', help=msg)

      # Dynamically check for profiling support.
      try:
        # Using __import__() here because of pyflakes.
        for p in 'cProfile', 'pstats': __import__(p)
        self.parser.add_option('--profile', action='store_true', default=False, help="use the Python modules cProfile and pstats to create a profile of time spent in various function calls and print out a table of the slowest functions at exit (of course this slows everything down but it can nevertheless give a good indication of the hot spots)")
      except ImportError:
        self.logger.warning("No profiling support available, --profile option disabled.")
        self.logger.warning("If you're on Ubuntu try `sudo apt-get install python-profiler'.")

    except Exception, e:
      self.__except_to_status('__init__', e)
      sys.exit(1)

  # FUSE API implementation: {{{2
dataset/ETHPy150Open xolox/dedupfs/dedupfs.py/DedupFS.__init__/swapped operands of `%`