extract data from Assembly_STEP & Parts_STP

[EgonScofield]

Hi, i want to optimize an existing programm, which is used fore feature-recognition. The actual programm gets its data from a part_list ( .csv), Assembly.STEP, the CAD parts ( also STEP. and STP) and a assembly_sequence list (.csv). In my example, i need 6 files. I want to get rid of the csv. files and want to use the full potenital of the .STEP/ .STP format and extract the assembly sequences and the parts out of my STEP-files. My "AssemblyImport" -module looks like this. Maybe someone could help me with my approach, where i should start, what i should change etc. I have been using python for a week and am still a beginner. I don't want an expedited solution, because I want to solve the problem myself. But since I have some starting difficulties, I am very grateful for every hint. If some extra information is needed, i m gonna add it asap. Greetings Egon

import csv

class assembly_plan():
    def __init__(self, ass_cad='', parts_cads=[], parts_file='', sequences_file=''):
        self._cads = cad_paths(ass_cad, parts_cads)
        self._partslist = parts_list(parts_file)
        self._sequenceslist = sequences_list(sequences_file)
    
    def plan_status(self):
        if self._cads.get_status() and self._partslist.get_status() and self._sequenceslist.get_status():
        # if self._partslist.get_status() and self._sequenceslist.get_status():
            return True
        else:
            return False

    def plan_part_status(self):
        if self._cads.get_parts_status() and self._partslist.get_status and self._sequenceslist.get_status():
            return True
        else:
            return False

    def set_ass_path(self, ass_path):
        self._cads.set_ass_path(ass_path)

    def set_parts_path(self, parts_cads):
        print('adding')
        if isinstance(parts_cads, list):
            for part_cad in parts_cads:
                print(part_cad)
                self._cads.add_parts_path_list(part_cad)
        else:
            self._cads.add_parts_path_list(parts_cads)

    def set_parts_file(self, parts_file):
        self._partslist = parts_list(parts_file)

    def set_sequences_file(self, sequences_file):
        self._sequenceslist = sequences_list(sequences_file)

    def generate_cad_paths(self):
        if self.plan_status:
            ass_path = self._cads.get_ass_path()
            # comp_paths = self._cads.get_parts_paths()
            comp_paths = self._cads.get_parts_paths()
            return [ass_path, comp_paths]
        else:
            return None

    def generate_parts_thread(self):
        if self.plan_status():
            return self._partslist.generate_parts_thread()

    def generate_sequences_thread(self):
        if self.plan_status():
            return self._sequenceslist.generate_sequences_thread()

    def generate_parts_list(self):
        if self.plan_status():
            return self._partslist.generate_parts_list()
        else:
            return None

    def generate_sequences_list(self):
        if self.plan_status():
            return self._sequenceslist.generate_sequences_list()
        else:
            return None

    def associate(self):
        '''
        THe function is to find the associations between parts CAD files
        and parts list as well as sequences.
        Filename builds the ass. between CADs and parts list.
        Part_number - StartComp/EndComp build the ass. between list and seq.
        '''
        print('associate')
        ass_list = []
        name_idx = -1
        if self.plan_part_status():
            parts_cads = self.generate_cad_paths()[1]
            parts_list = self.generate_parts_list()
            sequences = self.generate_sequences_list()
            parts_thread = self.generate_parts_thread()
            sequences_thread = self.generate_sequences_thread()
            name_idx = parts_thread.index('Filename')
            part_num_idx = parts_thread.index('Part_number')
            start_idx = sequences_thread.index('StartComp')
            end_idx = sequences_thread.index('EndComp')
            type_idx = sequences_thread.index('Type')

            for part_cad in parts_cads:
                mid_list = []
                part_cad_name = part_cad.split('/')[-1]
                for part in parts_list:
                    if part_cad_name == part[name_idx]:
                        related_seq_list = []
                        part_numbers = part[part_num_idx].split(';')
                        for pn in part_numbers:
                            seq_handling_list = []
                            seq_joining_list = []
                            seq_other_list = []
                            for sequence in sequences:
                                if pn in sequence[start_idx] or pn in sequence[end_idx]:
                                    if sequence[type_idx] == 'joining':
                                        seq_joining_list.append(sequence[0])
                                    elif sequence[type_idx] == 'handling':
                                        seq_handling_list.append(sequence[0])
                                    else:
                                        seq_other_list.append(sequence[0])

                            mid_list = [pn, part_cad, seq_joining_list, seq_handling_list, seq_other_list]
                            ass_list.append(mid_list)
        return ass_list


class cad_paths():

    def __init__(self, ass_cad='', comp_cads=[]):
        self._assembly_path = ass_cad
        self._parts_path_list = comp_cads

    def set_ass_path(self, ass_path):
        self._assembly_path = ass_path

    def get_ass_path(self):
        return self._assembly_path

    def add_parts_path_list(self, part_path):
        self._parts_path_list.append(part_path)

    def del_parts_path(self, part_path):
        if part_path in self._parts_path_list:
            del self._parts_path_list[self._parts_path_list.index(part_path)]

    def get_parts_paths(self):
        return self._parts_path_list

    def get_status(self):
        if self._assembly_path is not None and self._parts_path_list:
            return True
        else:
            return False

    def get_parts_status(self):
        if self._parts_path_list:
            return True

class parts_list():
    def __init__(self, parts_file):
        self._reader = None
        self._parts_data = None
        self._status = False
        try:
            self.csv_st = open(parts_file, newline='')
            self._status = True
        except FileNotFoundError:
            print('Warning: No parts file found.')

    @property
    def reader(self):
        if self._reader is None and self._status:
            self._reader = csv.reader(self.csv_st, delimiter=',')
        return self._reader

    @property
    def parts_data(self):
        if self._parts_data is None and self._status:
            self._parts_data = [row for row in self.reader]
        return self._parts_data

    
    def get_status(self):
        if self._status:
            return True
        else:
            return False

    def generate_parts_thread(self):
        if self._status and self.parts_data:
            self.thread = self.parts_data[0]
            return self.thread
        else:
            return []

    def generate_parts_list(self):
        if self._status and self.parts_data:
            parts_list = self.parts_data[1:]
            return parts_list
        return None

class sequences_list():
    def __init__(self, sequences_file):
        self._reader = None
        self._sequences_data = None
        self._status = False
        try:
            self.csv_mp = open(sequences_file, newline='')
            self._status = True
        except FileNotFoundError:
            print('Warning: No assembly sequences file found')

    @property
    def reader(self):
        if self._reader is None and self._status:
            self._reader = csv.reader(self.csv_mp, delimiter=',')
        return self._reader

    @property
    def sequences_data(self):
        if self._sequences_data is None and self._status:
            self._sequences_data = [row for row in self.reader]
        return self._sequences_data

    def get_status(self):
        if self._status:
            return True
        else:
            return False

    def generate_sequences_thread(self):
        if self._status:
            return self.sequences_data[0]

    def generate_sequences_list(self):
        if self._status:
            sequences_list = self.sequences_data[1:]
            return sequences_list
        else:
            return None

def str_to_list(in_str):
    result_list = []
    if in_str[0] == '[':
        for i in range(len(in_str)):
            if in_str[i] == '[':
                start_idx = i + 1
                b_vec = False
            elif in_str[i] == ';' or in_str[i] == ']':
                end_idx = i
                b_vec = True
            else:
                b_vec = False

            if b_vec:
                mid_str = in_str[start_idx:end_idx]
                result_list.append(mid_str)
                start_idx = end_idx + 1
    return result_list