def __init__(self, path, level, create=False, world_version=None, dat_world_version=None, compressors=None):
        """
        :param path: string, path to file.
        :param level: parent PocketLeveldbWorld instance.
        :param create: bool, wheter to create the world. Defaults to False.
        :param world_version: string or None, world version. Defaults to None.
        :param dat_world_version: char or None, binary world version as stored on the disk.
        :param compressors: None or tuple of ints: The compressor type(s) to be used.
                If None, the value is decided according to the 'dat_world_version'.
        :return: None
        """
        if not world_version:
            raise TypeError("Wrong world version sent: %s"%world_version)
        self.world_version = world_version
        self.dat_world_version = dat_world_version
        self.path = path
        if not os.path.exists(path):
            file(path, 'w').close()
        self.level = level
        self.compressors = compressors


        self.options = leveldb_mcpe.Options()
        self.writeOptions = leveldb_mcpe.WriteOptions()
        self.readOptions = leveldb_mcpe.ReadOptions()
        self.ldb = leveldb_mcpe

        if create:
            # Rework this, because leveldb.Options() is a function...
            #self.options.create_if_missing = True  # The database will be created once needed first.
            return

        needsRepair = False
        try:

            # Let's try to 'magicaly' find the right compression for the world.
            compressors_list = (None, (4,), (2,))
            i = 0
            while True:
                compressors = compressors_list[i]
                with self.world_db(compressors) as db:
                    try:
                        it = db.NewIterator(self.readOptions)
                        it.SeekToFirst()
                        if not db.Get(self.readOptions, it.key()) == it.value():
                            needsRepair = True
                        it.status()
                        del it
                        break
                    except leveldb_mcpe.ZipCompressionError:
                        if i < len(compressors_list) - 1:
                            i += 1
                            self._world_db.close()
                            self._world_db = None
                            self.compressors = None
                        else:
                            raise

        except RuntimeError as err:
            logger.error("Error while opening world database from %s (%s)"%(path, err))
            needsRepair = True

        if needsRepair:
            logger.info("Trying to repair world %s"%path)
            try:
                self.ldb.RepairWrapper(os.path.join(path, 'db'))
            except RuntimeError as err:
                logger.error("Error while repairing world %s %s"%(path, err))

        :param path: string, path to file.
        :param level: parent PocketLeveldbWorld instance.
        :param create: bool, wheter to create the world. Defaults to False.
        :param world_version: string or None, world version. Defaults to None.
        :param dat_world_version: char or None, binary world version as stored on the disk.
        :param compressors: None or tuple of ints: The compressor type(s) to be used.
                If None, the value is decided according to the 'dat_world_version'.
        :return: None
        
pymclevel/leveldbpocket.py