예제 #1
0
    def __init__(self, parent):
        self.parent = parent
        super().__init__()
        self.setWindowFlags(QtCore.Qt.WindowStaysOnTopHint)

        my_ui = __file__.replace('.py', '.ui')
        if not os.path.exists(my_ui):
            raise Exception("can not find %s" % my_ui)
        uic.loadUi(my_ui, self)
        self.setWindowFlags(QtCore.Qt.WindowStaysOnTopHint)
        self.setWindowTitle(' '.join(
            re.findall('.[^A-Z]*',
                       os.path.basename(__file__).replace('.py', ''))))

        rxProjectName = QtCore.QRegExp(valid_project_name_regex)
        ProjectName_validator = QtGui.QRegExpValidator(rxProjectName, self)
        self.ProjectName.setValidator(ProjectName_validator)
        self.ProjectName.setText("")
        self.ProjectName.textChanged.connect(self.verify)
        # self.ProjectName.returnPressed.connect(self.PressedEnter)

        self.existing_projects = list_ATE_projects(self.parent.workspace_path)

        self.Feedback.setStyleSheet('color: orange')

        self.OKButton.clicked.connect(self.OKButtonPressed)
        self.CancelButton.clicked.connect(self.CancelButtonPressed)

        self.verify()
        self.show()
예제 #2
0
    def update_projects(self):
        print("update_projects")
        all_projects = list_projects(self.workspace_path)
        ATE_projects = list_ATE_projects(workspace_path)
        old_projects = [
            self.project_combo.itemText(i)
            for i in range(self.project_combo.count())
        ]

        if len(ATE_projects) == 0:
            ATE_projects.append('')
            all_projects.append('')
            self.active_project = ''

        if self.active_project not in ATE_projects:
            self.active_project = ATE_projects[0]

        if set(all_projects) != set(old_projects):
            self.project_combo.blockSignals(True)
            self.project_combo.clear()
            for index, project in enumerate(all_projects):
                self.project_combo.addItem(project)
                if project not in ATE_projects:
                    self.project_combo.model().item(index).setEnabled(False)
                if project == self.active_project:
                    self.project_combo.setCurrentIndex(index)
            self.project_combo.blockSignals(False)

        self.active_project_path = os.path.join(self.workspace_path,
                                                self.active_project)
        self.update_hardware()
예제 #3
0
    destination_base = os.path.dirname(destination)
    if not os.path.exists(destination_base):
        os.makedirs(destination_base)

    if mode == 'text':
        with open(source, 'r') as src:
            with open(destination, 'w') as dst:
                for line in src:
                    for item in translation:
                        look_for = "%%%s%%" % item
                        replace_with = translation[item]
                        if look_for in line:
                            line = line.replace(look_for, replace_with)
                    dst.write(line)
    else:
        shutil.copyfile(source, destination)


if __name__ == '__main__':
    from SpyderMockUp.SpyderMockUp import workspace
    from ATE.org.listings import list_ATE_projects
    ATE_projects = list_ATE_projects(workspace)
    if ATE_projects:  # ATE projects found
        translation_base = translation_template(
            os.path.join(workspace, ATE_projects[0]))
        print(translation_base)
        other_translation = {'foo': 'bar', 'USER': '******'}
        translation_base.update(other_translation)
        print(translation_base)
예제 #4
0
    if is_ATE_project(project_path):
        if hardware_version in list_hardware_setups(project_path):
            pcbs = dict_pcbs_for_hardware_setup(project_path, hardware_version)
            if pcbs['SingeSiteLoadboard'] != "":
                return True
    return False


def has_probe_card(project_path, hardware_version):
    from ATE.org.listings import dict_pcbs_for_hardware_setup
    from ATE.org.listings import list_hardware_setups

    if is_ATE_project(project_path):
        if hardware_version in list_hardware_setups(project_path):
            pcbs = dict_pcbs_for_hardware_setup(project_path, hardware_version)
            if pcbs['ProbeCard'] != "":
                return True
    return False


def has_single_site_DIB(project_path, hardware_version):
    pass


if __name__ == '__main__':
    from SpyderMockUp.SpyderMockUp import workspace
    from ATE.org.listings import list_ATE_projects

    for project in list_ATE_projects(workspace):
        print(project)
예제 #5
0
 def display_ateprojects(self):
     print("display_ateprojects")
     from ATE.org.listings import list_ATE_projects
     for project in list_ATE_projects(self.workspace_path):
         print("   ", project)
예제 #6
0
    def __init__(self):
        super().__init__()

        # get the appropriate .ui file and load it.
        my_ui = __file__.replace('.py', '.ui')
        if not os.path.exists(my_ui):
            raise Exception("'%s' doesn't exist" % my_ui)
        uic.loadUi(my_ui, self)

        # Initialize the main window
        self.setWindowFlags(QtCore.Qt.WindowStaysOnTopHint)
        self.setWindowTitle(' '.join(
            re.findall('.[^A-Z]*',
                       os.path.basename(__file__).replace('.py', ''))))

        # Check if OpenCV is available (without loading it !)
        spec = importlib.util.find_spec('cv2')
        self.open_cv_available = spec is not None

        # setup initial paths
        self.workspace_path = workspace_path
        if not os.path.exists(self.workspace_path):
            os.makedirs(self.workspace_path)

        self.tester_list = list_MiniSCTs()
        self.active_tester = self.tester_list[
            0]  # start with the first in the list
        print("active_tester =", self.active_tester)

        self.ATE_projects = list_ATE_projects(workspace_path) + ['']
        self.active_project = self.ATE_projects[0]  # there is always something
        if self.active_project != '':
            self.active_project_path = os.path.join(self.workspace_path,
                                                    self.active_project)
            self.project_info = listings(self.active_project_path)
        else:
            self.active_project_path = None
            self.project_info = None
        print("active_project =", self.active_project)

        if self.project_info != None:
            self.hw_list = self.project_info.list_hardwaresetups()
            if self.hw_list != []:
                self.active_hw = self.hw_list[
                    -1]  # take the most recent hardware setup
            else:
                self.active_hw = ''
        else:
            self.active_hw = ''
        print("active_hw =", self.active_hw)

        if self.project_info != None:
            self.active_base = 'Product'  # or 'Die'
            pass
        else:
            self.active_base = ''

    # connect the File/New/Project menu
        self.action_new_project.triggered.connect(self.new_project)

        # setup the project explorer
        self.tree.setContextMenuPolicy(QtCore.Qt.CustomContextMenu)
        self.tree.customContextMenuRequested.connect(self.context_menu_manager)

        # setup the screencaster
        self.screencast = screenCast()
        self.screencast.setPixmap(
            qta.icon('mdi.video', color='orange').pixmap(16, 16))
        self.screencast_state = 'idle'
        self.screencast.clicked.connect(self.screencast_start_stop)
        self.screencast.rightClicked.connect(self.screencast_settings)

        self.statusBar().addPermanentWidget(self.screencast)

        # setup the toolbar
        self.toolbar = self.create_toolbar(
        )  # sets active_tester, active_project, hwr (and base if necessary)

        self.update_toolbar()

        self.update_testers()
        self.update_projects()
        self.update_hardware()

        self.tree_update()
        #self.update_project_list()
        self.update_menu()
        self.show()