Пример #1
0
def checkVersion(file):
    vrs = None
    filename = os.path.abspath(file)
    ole = OleFileIO(filename)
    elements = ole.listdir(streams=True, storages=False)
    for e in elements:
        if (e[-1] == 'RSeDb'):
            data = ole.openstream(e).read()
            version, i = getVersionInfo(data, 20)
            if (version.major >= 14):
                setDumpFolder(file)
                return ole
            break

    if (version):
        vrsName = version.major
        if (version.major >= 11): vrsName += 1996
        QMessageBox.critical(
            FreeCAD.ActiveDocument, 'FreeCAD: Inventor workbench...',
            'Can\'t load file created with Inventor v%d' % (vrsName))
        logError('Can\'t load file created with Inventor v%d' % (vrsName))
    else:
        QMessageBox.critical(
            FreeCAD.ActiveDocument, 'FreeCAD: Inventor workbench...',
            'Can\'t determine Inventor version file was created with')
        logError('Can\'t determine Inventor version file was created with!')
    return None
Пример #2
0
 def get_streams(self,dump) -> (list,list):
     '''
     get streams
     '''
     _Listobjects = []
     _List = []
     ole = OleFileIO(dump)
     listdir = ole.listdir()
     for direntry in listdir:
         dirs = re.sub(r'[^\x20-\x7f]',r'', " : ".join(direntry))
         tempdecoded = sub(br'[^\x20-\x7F]+',b'', ole.openstream(direntry).getvalue())
         _Listobjects.append(tempdecoded)
         _List.append({"Name":dirs,"Parsed":tempdecoded.decode("utf-8",errors="ignore")})
     return _List,_Listobjects
Пример #3
0
def ReadFile(doc, readProperties):
    first = 0
    list = {}
    counters = {}

    # LOG.LOG_FILTER = LOG.LOG_FILTER | LOG.LOG_DEBUG

    if (isOleFile(getInventorFile())):
        ole = OleFileIO(getInventorFile())
        setFileVersion(ole)
        elements = ole.listdir(streams=True, storages=False)

        folder = getInventorFile()[0:-4]
        if not os.path.exists(folder):
            os.makedirs(folder)

        counter = 1
        list = []
        for fname in elements:
            if (len(fname) == 1):
                list.append(fname)
            else:
                #Ensure that RSe* files will be parsed first
                if (fname[-1].startswith('RSe')):
                    #ensure RSeDb is the very first "file" to be parsed
                    list.insert(first, fname)
                    if (fname[-1] == 'RSeDb'):
                        first += 1
                elif (not fname[-1].startswith('B')):
                    list.append(fname)

        for fname in list:
            ReadElement(ole, fname, doc, counter, readProperties)
            counter += 1
        ole.close()

        now = datetime.datetime.now()
        if (len(doc.Comment) > 0):
            doc.Comment += '\n'
        doc.Comment = '# %s: read from %s' % (
            now.strftime('%Y-%m-%d %H:%M:%S'), getInventorFile())

        logMessage("Dumped data to folder: '%s'" % (getInventorFile()[0:-4]),
                   LOG.LOG_INFO)

        return True
    logError("Error - '%s' is not a valid Autodesk Inventor file." % (infile))
    return False
Пример #4
0
class MdReader:
    """
    Чтение файла MD с извлечением примитивных структур и парсингом их в списки
    """
    class ReadedConfig:
        """
        Результат чтения конфигурации, является фабрикой для парсера
        """
        def __init__(self):
            self.dds = []
            self.dialog = []
            self.entry = {}
            self.md = None

        @property
        def MdObject(self):
            if not self.md:
                self.md = MDObject()
                self.md.parse(self.dds)
            return self.md

    def __init__(self, filename, metadata=True, dialog=False):
        self.filename = filename

        self.parse_metadata = metadata
        self.parse_dialog = dialog

        self.ole = None
        self.read_result = MdReader.ReadedConfig()

    def read(self):
        mylog.info(u'Начинаю чтение %s' % self.filename)
        self.ole = OleFileIO(self.filename)
        oledirs = self.ole.listdir()
        mylog.debug('OLE_DIRS: %s' % oledirs)
        for entry in oledirs:
            entry_name = entry[0]
            mylog.debug(u'entry_name: %s' % entry_name)
            try:
                if entry_name == 'Metadata':
                    if "Main MetaData Stream" in entry and self.parse_metadata:
                        self.handler_metadata(entry)
                if entry_name == 'Document':
                    if "Dialog Stream" in entry and self.parse_dialog:
                        self.handler_dialog(entry)
                    if "Container.Profile" in entry:
                        continue
                    if "Container.Contents" in entry:
                        continue
            except Exception as e:
                mylog.exception(u'Ошибка при чтении конфигурации %s' %
                                e.message)
        return self.read_result

    def handler_metadata(self, entry):
        if "Main MetaData Stream" in entry:
            with self.ole.openstream(entry) as f:
                tx = f.read()
            self.read_result.dds = ParseTree(
                tx.decode('cp1251', errors='ignore'))

    def handler_dialog(self, entry):
        if "Main MetaData Stream" in entry:
            with self.ole.openstream(entry) as f:
                tx = f.read()
            self.read_result.dialog = tx  # ParseTree(tx.decode('cp1251', errors='ignore'))
Пример #5
0
        files = sys.argv[1:]
        filename = files[0].decode(
            sys.getfilesystemencoding())  # make it UNICODE!
        setInventorFile(filename)
        if (isOleFile(filename)):
            if (len(files) == 1):
                open(filename)
            else:
                # this is only for debugging purposes...
                docname = os.path.splitext(os.path.basename(filename))[0]
                docname = decode(docname, utf=True)
                doc = FreeCAD.newDocument(docname)

                ole = OleFileIO(filename)
                setFileVersion(ole)
                elements = ole.listdir(streams=True, storages=False)
                counter = 1
                if (files[1] == 'l'):
                    for filename in elements:
                        ListElement(ole, filename, counter)
                        counter += 1
                else:
                    list = {}
                    counters = {}

                    for a in (elements):
                        path = PrintableName(a)
                        list['%s' % (counter)] = a
                        counters['%s' % (counter)] = counter
                        counter += 1
Пример #6
0
class MdReader:
    """
    Чтение файла MD с извлечением примитивных структур и парсингом их в списки
    """

    class ReadedConfig:
        """
        Результат чтения конфигурации, является фабрикой для парсера
        """
        def __init__(self):
            self.dds = []
            self.dialog = []
            self.entry = {}
            self.md = None

        @property
        def MdObject(self):
            if not self.md:
                self.md = MDObject()
                self.md.parse(self.dds)
            return self.md

    def __init__(self, filename, metadata=True, dialog=False):
        self.filename = filename

        self.parse_metadata = metadata
        self.parse_dialog = dialog

        self.ole = None
        self.read_result = MdReader.ReadedConfig()

    def read(self):
        mylog.info(u'Начинаю чтение %s' % self.filename)
        self.ole = OleFileIO(self.filename)
        oledirs = self.ole.listdir()
        mylog.debug('OLE_DIRS: %s' % oledirs)
        for entry in oledirs:
            entry_name = entry[0]
            mylog.debug(u'entry_name: %s' % entry_name)
            try:
                if entry_name == 'Metadata':
                    if "Main MetaData Stream" in entry and self.parse_metadata:
                        self.handler_metadata(entry)
                if entry_name == 'Document':
                    if "Dialog Stream" in entry and self.parse_dialog:
                        self.handler_dialog(entry)
                    if "Container.Profile" in entry:
                        continue
                    if "Container.Contents" in entry:
                        continue
            except Exception as e:
                mylog.exception(u'Ошибка при чтении конфигурации %s' % e.message)
        return self.read_result

    def handler_metadata(self, entry):
        if "Main MetaData Stream" in entry:
            with self.ole.openstream(entry) as f:
                tx = f.read()
            self.read_result.dds = ParseTree(tx.decode('cp1251', errors='ignore'))

    def handler_dialog(self, entry):
        if "Main MetaData Stream" in entry:
            with self.ole.openstream(entry) as f:
                tx = f.read()
            self.read_result.dialog = tx  # ParseTree(tx.decode('cp1251', errors='ignore'))
Пример #7
0
def parse_md(filename):
    mylog.info(u'Начинаю чтение %s' % filename)
    m = {'dds':[]}
    ole = OleFileIO(filename)
    # mylog.debug('OLE_DIRS: %s' % ole.listdir())
    m['entry'] = {}
    for entry in ole.listdir():
        mylog.debug(entry[0])

        #with open("stream_%s" % entry[0],'w+') as f:
        #    f.write(repr(entry))

        if entry[0]=='Document':
            #print entry
            if "Dialog Stream" in entry:
                continue
                try:
                    sz= ole.get_size(entry)
                    f=ole.openstream(entry)
                    #print f.read(sz)
                    f.close()
                except Exception as e:
                    mylog.exception(repr(e.args))
            if "Container.Profile" in entry:
                continue
                try:
                    sz= ole.get_size(entry)
                    f=ole.openstream(entry)
                    #print f.read(sz)
                    f.close()
                except:
                    mylog.exception()
            if "Container.Contents" in entry:
                continue
                sz= ole.get_size(entry)
                f=ole.openstream(entry)
                #print f.read(sz)
                f.close()

            if "MD Programm text" in entry:
                continue
                '''
                Пока что не работает, работало в прежних версиях python
                try:
                    sz= ole.get_size(entry)
                    f=ole.openstream(entry)
                    tx= f.read(sz)
                    f.close()
                    #print zlib.compress('test').encode('hex')
                    zi=zlib.decompress((zlib_head+tx))
                    print zi
                except Exception,e:
                    mylog.exception('read MD Programm text')
                    mylog.info(tx[:10].encode('hex'))
                    #print e
                '''
        if entry[0]=='Metadata':
            if "Main MetaData Stream" in entry:

                try:
                    #sz= ole.get_size(entry)
                    f = ole.openstream(entry)
                    tx = f.read()
                    f.close()
                    #print zlib.compress('test').encode('hex')
                    #d=zlib.decompressobj()
                    #zi=zlib.decompress(zlib_head+tx)
                    #tx_fixed = utils.fixunicode(tx,'cp1251')
                    #mylog.debug(tx.decode('cp1251'))
                    m['dds'] = ParseTree(tx.decode('cp1251', errors='ignore'))
                except Exception as e:
                    mylog.exception('parse metadata error')
        #if entry[0] == 'Journal':
        #write dumps
        if DUMP_META:
            if "MD Programm text" in entry:
                sz= ole.get_size(entry)
                f=ole.openstream(entry)
                tx= f.read(sz)
                f.close()
                hx = tx.encode('hex')
                if ztest.find(hx) > 0:
                    #print entry
                    #print hx
                    pass
                try:
                    #zlib.compress("//test").encode('hex')
                    #'789c d3d72f492d2e0100 0664021f'
                    #      d3d72f492d2e0100
                    tx=zlib.decompress(zlib_head+tx)
                    #print "MODULE:", tx
                    pass
                except Exception as e:
                    #print "size MD text:", sz, e.message
                    pass
                dump_stream("entry-%s" % entry, zlib_head+tx)
            else:
                dump_stream("entry-%s" % entry, ole.openstream(entry).read())
    return m
Пример #8
0
class OleFileFS(FS):

    _meta = dict(read_only=True, thread_safe=False, network=False, unicode_paths=True, case_insensitive_paths=True)

    def __init__(self, path):
        try:
            self._olefile = OleFileIO(path, path_encoding=None)
        except IOError as e:
            raise CreateFailedError(str(e), details=e)

    #
    # Essential methods
    #

    def open(
        self, path, mode="r", buffering=-1, encoding=None, errors=None, newline=None, line_buffering=False, **kwargs
    ):
        for unsupported in "w", "a", "+":
            if unsupported in mode:
                raise OperationFailedError("open", path=path)
        segments = path_to_segments_normalized(path)
        return self._olefile.openstream(segments)

    def isdir(self, path):
        segments = path_to_segments_normalized(path)
        sty = self._olefile.get_type(segments)
        return sty in (STGTY_STORAGE, STGTY_ROOT)

    def isfile(self, path):
        segments = path_to_segments_normalized(path)
        sty = self._olefile.get_type(segments)
        return sty is STGTY_STREAM

    def listdir(self, path="./", wildcard=None, full=False, absolute=False, dirs_only=False, files_only=False):
        items = self.ilistdir(
            path=path, wildcard=wildcard, full=full, absolute=absolute, dirs_only=dirs_only, files_only=files_only
        )
        return list(items)

    def getinfo(self, path):
        segments = path_to_segments_normalized(path)
        size = self._olefile.get_size(segments)
        ctime = self._olefile.getctime(segments)
        mtime = self._olefile.getmtime(segments)
        return {"size": size, "created_time": ctime, "modified_time": mtime}

    #
    # Non-essential methods
    #

    def close(self):
        self._olefile.close()
        FS.close(self)

    def ilistdir(self, path="./", wildcard=None, full=False, absolute=False, dirs_only=False, files_only=False):
        if dirs_only:
            olefile_listdir_args = dict(streams=False, storages=True)
        elif files_only:
            olefile_listdir_args = dict(streams=True, storages=False)
        else:
            olefile_listdir_args = dict()
        given_node = path_to_segments_normalized(path)
        leafs = self._olefile.listdir(**olefile_listdir_args)
        leafs = map(tuple, leafs)
        nodes = find_children(given_node, leafs)
        for segments in nodes:
            stgty = self._olefile.get_type(segments)
            if dirs_only and stgty not in (STGTY_STORAGE, STGTY_ROOT):
                continue
            elif files_only and stgty is not STGTY_STREAM:
                continue
            if absolute:
                yield absolute_path_from_segments(segments)
            elif full:
                yield full_path_from_segments(segments)
            else:
                yield segments[-1]
Пример #9
0
def parse_md(filename):
    mylog.info(u'Начинаю чтение %s' % filename)
    m = {'dds': []}
    ole = OleFileIO(filename)
    # mylog.debug('OLE_DIRS: %s' % ole.listdir())
    m['entry'] = {}
    for entry in ole.listdir():
        mylog.debug(entry[0])

        #with open("stream_%s" % entry[0],'w+') as f:
        #    f.write(repr(entry))

        if entry[0] == 'Document':
            #print entry
            if "Dialog Stream" in entry:
                continue
                try:
                    sz = ole.get_size(entry)
                    f = ole.openstream(entry)
                    #print f.read(sz)
                    f.close()
                except Exception as e:
                    mylog.exception(repr(e.args))
            if "Container.Profile" in entry:
                continue
                try:
                    sz = ole.get_size(entry)
                    f = ole.openstream(entry)
                    #print f.read(sz)
                    f.close()
                except:
                    mylog.exception()
            if "Container.Contents" in entry:
                continue
                sz = ole.get_size(entry)
                f = ole.openstream(entry)
                #print f.read(sz)
                f.close()

            if "MD Programm text" in entry:
                continue
                '''
                Пока что не работает, работало в прежних версиях python
                try:
                    sz= ole.get_size(entry)
                    f=ole.openstream(entry)
                    tx= f.read(sz)
                    f.close()
                    #print zlib.compress('test').encode('hex')
                    zi=zlib.decompress((zlib_head+tx))
                    print zi
                except Exception,e:
                    mylog.exception('read MD Programm text')
                    mylog.info(tx[:10].encode('hex'))
                    #print e
                '''
        if entry[0] == 'Metadata':
            if "Main MetaData Stream" in entry:

                try:
                    #sz= ole.get_size(entry)
                    f = ole.openstream(entry)
                    tx = f.read()
                    f.close()
                    #print zlib.compress('test').encode('hex')
                    #d=zlib.decompressobj()
                    #zi=zlib.decompress(zlib_head+tx)
                    #tx_fixed = utils.fixunicode(tx,'cp1251')
                    #mylog.debug(tx.decode('cp1251'))
                    m['dds'] = ParseTree(tx.decode('cp1251', errors='ignore'))
                except Exception as e:
                    mylog.exception('parse metadata error')
        #if entry[0] == 'Journal':
        #write dumps
        if DUMP_META:
            if "MD Programm text" in entry:
                sz = ole.get_size(entry)
                f = ole.openstream(entry)
                tx = f.read(sz)
                f.close()
                hx = tx.encode('hex')
                if ztest.find(hx) > 0:
                    #print entry
                    #print hx
                    pass
                try:
                    #zlib.compress("//test").encode('hex')
                    #'789c d3d72f492d2e0100 0664021f'
                    #      d3d72f492d2e0100
                    tx = zlib.decompress(zlib_head + tx)
                    #print "MODULE:", tx
                    pass
                except Exception as e:
                    #print "size MD text:", sz, e.message
                    pass
                dump_stream("entry-%s" % entry, zlib_head + tx)
            else:
                dump_stream("entry-%s" % entry, ole.openstream(entry).read())
    return m