OIF File Uploading

def __init__(self, filename):
    """Initialize instance from file."""
    self._fh = open(filename, 'rb')
    if self._fh.read(8) != b'\xd0\xcf\x11\xe0\xa1\xb1\x1a\xe1':
        self.close()
        raise ValueError('not a compound document file')
    (
        self.clsid,
        self.version_minor,
        self.version_major,
        byteorder,
        sector_shift,
        mini_sector_shift,
        _,
        _,
        self.dir_len,
        self.fat_len,
        self.dir_start,
        _,
        self.mini_stream_cutof_size,
        self.minifat_start,
        self.minifat_len,
        self.difat_start,
        self.difat_len,
    ) = struct.unpack('<16sHHHHHHIIIIIIIIII', self._fh.read(68))

    self.byteorder = {0xFFFE: '<', 0xFEFF: '>'}[byteorder]
    if self.byteorder != '<':
        raise NotImplementedError('big-endian byte order not supported')

    if self.clsid == b'\x00' * 16:
        self.clsid = None
    if self.clsid is not None:
        raise OifFileError(f'cannot handle clsid {self.clsid}')

    if self.version_minor != 0x3E:
        raise OifFileError(
            f'cannot handle version_minor {self.version_minor}')
    if mini_sector_shift != 0x0006:
        raise OifFileError(
            f'cannot handle mini_sector_shift {mini_sector_shift}')
    if not (
        (self.version_major == 0x4 and sector_shift == 0x000C) or
        (self.version_major == 0x3 and sector_shift == 0x0009 and
         self.dir_len == 0)
    ):
        raise OifFileError(
            f'cannot handle version_major {self.version_major} '
            f'and sector_shift {sector_shift}'
        )

    self.filename = filename
    self.sec_size = 2**sector_shift
    self.short_sec_size = 2**mini_sector_shift

    secfmt = '<' + ('I' * (self.sec_size // 4))
    # read DIFAT
    self._difat = list(
        struct.unpack('<' + ('I' * 109), self._fh.read(436))
    )
    nextsec = self.difat_start
    for i in range(self.difat_len):
        if nextsec >= CompoundFile.MAXREGSID:
            raise OifFileError('nextsec >= CompoundFile.MAXREGSID')
        sec = struct.unpack(secfmt, self._sec_read(nextsec))
        self._difat.extend(sec[:-1])
        nextsec = sec[-1]
    # if nextsec != CompoundFile.ENDOFCHAIN: raise OifFileError()
    self._difat = self._difat[:self.fat_len]
    # read FAT
    self._fat = []
    for secid in self._difat:
        self._fat.extend(struct.unpack(secfmt, self._sec_read(secid)))
    # read mini FAT
    self._minifat = []
    for i, sector in enumerate(self._sec_chain(self.minifat_start)):
        if i >= self.minifat_len:
            break
        self._minifat.extend(struct.unpack(secfmt, sector))
    # read directories
    self._dirs = []
    for sector in self._sec_chain(self.dir_start):
        for i in range(0, self.sec_size, 128):
            direntry = DirectoryEntry(sector[i:i+128], self.version_major)
            self._dirs.append(direntry)
    # read root storage
    if len(self._dirs) <= 0:
        raise OifFileError('no directories found')
    root = self._dirs[0]
    if root.name != 'Root Entry':
        raise OifFileError(
            f"no root directory found, got {root.name}")
    if root.create_time is not None:  # and root.modify_time is None
        raise OifFileError(f'invalid root.create_time {root.create_time}')
    if root.stream_size % self.short_sec_size != 0:
        raise OifFileError(
            f'root.stream_size {root.stream_size} does not match '
            f'short_sec_size {self.short_sec_size}'
        )
    # read mini stream
    self._ministream = b''.join(self._sec_chain(root.sector_start))
    self._ministream = self._ministream[:root.stream_size]
    # map stream/file names to directory entries
    nostream = CompoundFile.NOSTREAM
    join = '/'.join  # os.path.sep.join
    dirs = self._dirs
    visited = [False] * len(self._dirs)

    def parse(dirid, path):
        # return iterator over all file names and their directory entries
        # TODO: replace with red-black tree parser
        if dirid == nostream or visited[dirid]:
            return
        visited[dirid] = True
        de = dirs[dirid]
        if de.is_stream:
            yield join(path + [de.name]), de
        yield from parse(de.left_sibling_id, path)
        yield from parse(de.right_sibling_id, path)
        if de.is_storage:
            yield from parse(de.child_id, path + [de.name])

    self._files = dict(parse(self._dirs[0].child_id, []))

def __init__(self, data, version_major):
    """Initialize directory entry from 128 bytes."""
    (
        name,
        name_len,
        self.entry_type,
        self.color,
        self.left_sibling_id,
        self.right_sibling_id,
        self.child_id,
        self.clsid,
        self.user_flags,
        create_time,
        modify_time,
        self.sector_start,
        self.stream_size,
    ) = struct.unpack('<64sHBBIII16sIQQIQ', data)

    if version_major == 3:
        self.stream_size = struct.unpack('<I', data[-8:-4])[0]
    if self.clsid == b'\000' * 16:
        self.clsid = None

    if name_len % 2 != 0 or name_len > 64:
        raise OifFileError(f'invalid name_len {name_len}')
    if self.color not in (0, 1):
        raise OifFileError(f'invalid color {self.color}')

    self.name = name[:name_len-2].decode('utf-16')
    self.create_time = filetime(create_time)
    self.modify_time = filetime(modify_time)
    self.is_stream = self.entry_type == 2
    self.is_storage = self.entry_type == 1

def __init__(self, filename):
    """Open compound document and read OibInfo.txt settings."""
    self.filename = filename
    self.com = CompoundFile(filename)
    info = SettingsFile(self.com.open_file('OibInfo.txt'),
                        'OibInfo.txt')['OibSaveInfo']
    self.name = info.get('Name', None)
    self.version = info.get('Version', None)
    self.compression = info.get('Compression', None)
    self.mainfile = info[info['MainFileName']]
    # map OIB file names to CompoundFile file names
    oibfiles = {os.path.split(i)[-1]: i for i in self.com.files()}
    self._files = {v: oibfiles[k] for k, v in info.items()
                   if k.startswith('Stream')}
    # map storage names to directory names
    self._folders = {i[0]: i[1] for i in info.items()
                     if i[0].startswith('Storage')}
    # read main settings file
    self.settings = SettingsFile(self.open_file(self.mainfile),
                                 name=self.mainfile)

def __init__(self, filename):
    """Open OIF or OIB file and read main settings."""
    self.filename = filename
    if filename.lower().endswith('.oif'):
        self.filesystem = OifFileSystem(filename)
        self.is_oib = False
    else:
        self.filesystem = OibFileSystem(filename)
        self.is_oib = True
    self.mainfile = self.filesystem.settings
    # map file names to storage names (flattened name space)
    self._files_flat = {os.path.basename(f): f
                        for f in self.filesystem.files()}

def __init__(self, filename, storage_ext='.files'):
    """Open OIF file and read settings."""
    self.filename = filename
    self._path, self.mainfile = os.path.split(os.path.abspath(filename))
    self.settings = SettingsFile(filename, name=self.mainfile)
    self.name = self.settings['ProfileSaveInfo']['Name']
    self.version = self.settings['ProfileSaveInfo']['Version']
    # check that storage directory exists
    storage = os.path.join(self._path, self.mainfile + storage_ext)
    if not os.path.exists(storage) or not os.path.isdir(storage):
        raise OSError(
            f'OIF storage path not found: {self.mainfile}{storage_ext}')
    # list all files
    pathlen = len(self._path + os.path.sep)
    self._files = [self.mainfile]
    for f in glob(os.path.join(storage, '*')):
        self._files.append(f[pathlen:])

def __init__(self, arg, name=None):
    """Read settings file and parse into nested dictionaries.

    Parameters
    ----------
    arg : str or file object
        Name of file or open file containing little endian UTF-16 string.
        File objects are closed by this function.
    name : str
        Human readable label of stream.

    """
    dict.__init__(self)
    if isinstance(arg, str):
        self.name = arg
        stream = open(arg, 'rb')
    else:
        self.name = str(name)
        stream = arg

    try:
        content = stream.read()
    finally:
        stream.close()

    if content[:4] == b'\xFF\xFE\x5B\x00':
        # UTF16 BOM
        content = content.rsplit(
            b'[\x00C\x00o\x00l\x00o\x00r\x00L\x00U\x00T\x00'
            b'D\x00a\x00t\x00a\x00]\x00\x0D\x00\x0A\x00', 1)
        if len(content) > 1:
            self['ColorLUTData'] = numpy.fromstring(
                content[1], 'uint8').reshape(-1, 4)
        content = content[0].decode('utf-16')
    elif content[:1] == b'[':
        # try UTF-8
        content = content.rsplit(b'[ColorLUTData]\r\n', 1)
        if len(content) > 1:
            self['ColorLUTData'] = numpy.fromstring(
                content[1], 'uint8').reshape(-1, 4)
        try:
            content = content[0].decode('utf-8')
        except Exception as exc:
            raise ValueError('not a valid settings file') from exc
    else:
        raise ValueError('not a valid settings file')

    for line in content.splitlines():
        line = line.strip()
        if line.startswith(';'):
            continue
        if line.startswith('[') and line.endswith(']'):
            self[line[1:-1]] = properties = {}
        else:
            key, value = line.split('=')
            properties[key] = astype(value)