Пример #1
0
def session(file):
    print('\nWelcome to Vocabulary Expander!\n'
          '\nWhich mod do you prefer?\n'
          'Just write one of the given names:\n'
          'Smart / Simple\n'
          'To exit print 0.')

    mod = input()
    mod = mod.capitalize()

    while mod != 'Simple' and mod != 'Smart':
        if mod == '0':
            program_exit()
        print('Wrong value. Try again. To exit print 0.')
        mod = input()
        mod = mod.capitalize()

    expander = Expander(file, mod)

    print('\nWhat number of words would you like to learn for each iteration?'
          '\nTo exit print value 0 or less.')

    w_num = int(input())
    if w_num <= 0:
        program_exit()

    expander.teaching(w_num)
Пример #2
0
 def testDoSubstitutionNoDefinition(self):
   if IGNORE_TEST:
     return
   executor = Executor()
   expander = Expander(executor, self.message)
   result = expander.do(SUBSTITUTION1)
   self.assertEqual(result[0], SUBSTITUTION1)
 def __init__(self, template_string):
     """
 :param str template_string: string containing template variables
     and template escape statements to execute
 """
     self._extractor = LineExtractor(template_string)
     self._message = StatusMessage(self._extractor)
     self._executor = Executor()
     self._expander = Expander(self._executor, self._message)
     self._command = None  # Command being processed
     self._define_variable_statements = []
Пример #4
0
 def testDo(self):
   if IGNORE_TEST:
     return
   executor = Executor()
   executor.setDefinitions(DEFINITIONS)
   expander = Expander(executor, self.message)
   result = expander.do(SUBSTITUTION1)
   self.assertEqual(result[0], SUBSTITUTION1)
   result = expander.do(SUBSTITUTION2)
   expected = len(DEFINITIONS['a'])
   self.assertEqual(len(result), expected)
Пример #5
0
 def testMakeSubtitutionList(self):
   if IGNORE_TEST:
     return
   substitution_list = Expander.makeSubstitutionList(DEFINITIONS)
   expected = np.prod([len(v) for v in DEFINITIONS.values()])
   self.assertEqual(len(substitution_list), expected)
   substitution_list = Expander.makeSubstitutionList({})
   self.assertEqual(len(substitution_list), 0)
   definitions = dict(DEFINITIONS)
   key = list(DEFINITIONS.keys())[0]
   del definitions[key]
   substitution_list = Expander.makeSubstitutionList(definitions)
   expected = np.prod([len(v) for v in definitions.values()])
   self.assertEqual(len(substitution_list), expected)
Пример #6
0
    def __init__(self, vp_value_count, output_shape, name='Full Network'):
        """
        Initializes the Full Network.
        :param output_shape: (5-tuple) The desired output shape for generated videos. Must match video input shape.
                              Legal values: (bsz, 3, 8, 112, 112) and (bsz, 3, 16, 112, 112)
        :param name: (str, optional) The name of the network (default 'Full Network').
        Raises:
            ValueError: if 'vp_value_count' is not a legal value count
            ValueError: if 'output_shape' does not contain a legal number of frames.
        """
        if vp_value_count not in self.VALID_VP_VALUE_COUNTS:
            raise ValueError('Invalid number of vp values: %d' % vp_value_count)
        if output_shape[2] not in self.VALID_FRAME_COUNTS:
            raise ValueError('Invalid number of frames in desired output: %d' % output_shape[2])

        super(FullNetwork, self).__init__()

        self.net_name = name
        self.vp_value_count = vp_value_count
        self.output_shape = output_shape
        self.out_frames = output_shape[2]

        self.vgg = vgg16(pretrained=True, weights_path=vgg_weights_path)
        self.i3d = InceptionI3d(final_endpoint='Mixed_5c_small', in_frames=self.out_frames,
                                pretrained=True, weights_path=i3d_weights_path)

        self.deconv = Deconv(in_channels=256, out_frames=self.out_frames)
        self.exp = Expander(vp_value_count=self.vp_value_count, out_frames=self.out_frames, out_size=28)
        self.trans = Transformer(in_channels=32 + self.vp_value_count)

        self.gen = Generator(in_channels=32 + 32, out_frames=self.out_frames)
Пример #7
0
 def testExpandTemplateExpressions(self):
   if IGNORE_TEST:
     return
   executor = Executor()
   var = 'n'
   definitions = {var: [1, 2, 3]}
   executor.setDefinitions(definitions)
   expander = Expander(executor, self.message)
   template = "T{%s} + A -> T{%s+1}" % (var, var)
   expansion = expander.do(template)
   self.assertEqual(len(expansion), len(definitions[var]))
   # Check that each substitution is found
   for value in definitions[var]:
     found = False
     for substitution in expansion:
       if "T%d" % value in substitution:
         found = True
         break
     self.assertTrue(found)
Пример #8
0
    def EnumerateExpanders(self):
        """Enumerate all storage expanders on the system

        returns:
            An array of object paths for storage expanders
        """
        l = list()
        for i in self.iface.EnumerateExpanders():
            obj = Expander(i)
            l.append(obj)
        return l
Пример #9
0
class Geochains:

    def __init__(self):
        self.pattern = PATTERN
        self.sub_rule = GeochainsSubstitutionRule()
        self.geodb = GeoIPDBMaxMind()
        self.sub_rule.geodb = self.geodb
        self.expander = Expander(self.pattern, self.sub_rule)

    def process_file(self, filename):
        f = open(filename, 'r')
        input_str = f.read()
        f.close()
        self.process_input(input_str)

    def process_input(self, input_str):
        output = self.expander.expand(input_str)
        print output
Пример #10
0
 def __init__(self):
     self.pattern = PATTERN
     self.sub_rule = GeochainsSubstitutionRule()
     self.geodb = GeoIPDBMaxMind()
     self.sub_rule.geodb = self.geodb
     self.expander = Expander(self.pattern, self.sub_rule)
class TemplateProcessor(object):
    """
  This class processes an Antimony model written using template variable substitutions.
  See the project README for syntax details.
  """
    def __init__(self, template_string):
        """
    :param str template_string: string containing template variables
        and template escape statements to execute
    """
        self._extractor = LineExtractor(template_string)
        self._message = StatusMessage(self._extractor)
        self._executor = Executor()
        self._expander = Expander(self._executor, self._message)
        self._command = None  # Command being processed
        self._define_variable_statements = []

    @classmethod
    def processFile(cls, inpath, outpath):
        """
    Processes template strings in a file.
    :param str inpath: path to the file containing the templated model
    :param str outpath: path to the file where the flattened model is placed
    """
        template = ''
        with open(inpath, 'r') as infile:
            for line in infile:
                template += "\n" + line
        processor = cls(template)
        expansion = processor.do()
        with open(outpath, 'w') as outfile:
            outfile.write(expansion)

    @staticmethod
    def _makeComment(line):
        return "%s%s" % (COMMENT_STG, line)

    def _processCommand(self):
        """
    Handles command processing, either the current line
    is a command or in the midst of processing a paired command.
    :param list-of-str expansion:
    :return bool: True if processed line
    """
        line = self._extractor.getCurrentLine()
        line_type = self._extractor.getCurrentLineType()
        is_processed = False
        # Current line is a command
        if line_type == LINE_COMMAND:
            is_processed = True
            # Check for nested commands
            if self._command is not None:
                new_command = Command(line)
                # Is this a paired command?
                if new_command.getCommandVerb()  \
                    == self._command.getCommandVerb():
                    if new_command.isEnd():
                        pass
                    else:
                        self._message.error("Cannot nest commands")
            # Valid placement for a command.
            self._command = Command(line)
            # DefineVariables Command
            if self._command.isDefineVariables():
                if self._command.isBegin():
                    self._define_variables_statements = []
                elif self._command.isEnd():
                    try:
                        program = '\n'.join(self._define_variables_statements)
                        self._executor.doScript(program)
                    except Exception as err:
                        msg = "***Error %s executing in : \n%s"  \
                            % (str(err), program)
                        self._message.error(msg)
                    self._command = None
            # SetVersion command
            elif self._command.isSetVersion():
                version = self._command.getArguments()[0]
                if float(version) > float(VERSION):
                    self._message.error("Unsupported version %s" % version)
                self._command = None
            # Other commands
            else:
                self._message.error("Unknown command")
        # Process statements occurring within paired commands
        elif self._command is not None:
            is_processed = True
            if self._command.isDefineVariables() and self._command.isBegin():
                self._define_variables_statements.append(line)
            else:
                self._message.error("Invalid paired command.")
        return is_processed

    def do(self):
        """
    Processes the template string and returns the expanded lines for input
    to road runner.
    Phases
      1. Construct content lines (non-blank, not comments)
      2. Extract the template variable definitions
      3. Construct the substitution instances
      4. Process the lines with template variables
    State used:
      reads: _definitions
    :return str expanded_string:
    :raises ValueError: errors encountered in the template string
    """
        cls = TemplateProcessor
        expansion = []
        line, line_type = self._extractor.do()
        statements = []
        while line is not None:
            if self._processCommand():
                expansion.append(cls._makeComment(line))
            # No command being processed
            else:
                # Transparent line (comment)
                if line_type == LINE_TRAN:
                    expansion.append(line)
                elif line_type == LINE_NONE:
                    pass
                # Line to be substituted
                elif line_type == LINE_SUBS:
                    # Do the variable substitutions
                    try:
                        substitutions = self._expander.do(line)
                    except Exception as err:
                        msg = "Runtime error in expression"
                        self._message.error(msg)
                    if len(substitutions) > 1:
                        expansion.append(cls._makeComment(line))
                    expansion.extend(substitutions)
                else:
                    import pdb
                    pdb.set_trace()
                    raise RuntimeError("Unexepcted state")
            line, line_type = self._extractor.do()
        if self._command is not None:
            msg = "Still processing command %s at EOF" % str(self._command)
            self._message.error(msg)
        return "\n".join(expansion)
Пример #12
0
class MainWindow(QMainWindow):
    htmlReady = pyqtSignal(str)

    def __init__(self, app):
        QMainWindow.__init__(self)
        self.install_directory = os.getcwd()

        self.app = app
        self.book = None
        self.last_book = ""
        self.filename = ""
        self._part_is_new = False
        self.tread_running = False
        self.initTheme()
        self.createUi()
        self.loadPlugins()
        self.createMenus()
        self.createStatusBar()
        self.readSettings()

        self.text_edit.textChanged.connect(self.textChanged)

    def initTheme(self):
        settings = QSettings(QSettings.IniFormat, QSettings.UserScope,
                             QCoreApplication.organizationName(),
                             QCoreApplication.applicationName())
        self.theme = settings.value("theme", "DarkFusion")
        hilite_color = settings.value(
            "hiliteColor",
            self.palette().highlight().color().name())
        self.changeStyle(self.theme, hilite_color)

    def showEvent(self, event):
        if self.last_book:
            self.loadBook(self.last_book)

    def changeStyle(self, theme, hilite_color):
        self.theme = theme
        if theme == "DarkFusion":
            QApplication.setStyle(DarkFusion(hilite_color))
        else:
            QApplication.setStyle(QStyleFactory.create(theme))
            pal = self.app.palette()
            pal.setColor(QPalette.Highlight, QColor(hilite_color))
            self.app.setPalette(pal)

    def createUi(self):
        self.content = Expander("Content", ":/images/parts.svg")
        self.images = Expander("Images", ":/images/images.svg")
        self.settings = Expander("Settings", ":/images/settings.svg")

        self.setWindowTitle(QCoreApplication.applicationName() + " " +
                            QCoreApplication.applicationVersion())
        vbox = QVBoxLayout()
        vbox.addWidget(self.content)
        vbox.addWidget(self.images)
        vbox.addWidget(self.settings)
        vbox.addStretch()

        self.content_list = QListWidget()
        self.content_list.setSizePolicy(QSizePolicy.Ignored, QSizePolicy.Fixed)
        content_box = QVBoxLayout()
        content_box.addWidget(self.content_list)
        self.item_edit = QLineEdit()
        self.item_edit.setMaximumHeight(0)
        self.item_edit.editingFinished.connect(self.editItemFinished)
        self.item_anim = QPropertyAnimation(self.item_edit,
                                            "maximumHeight".encode("utf-8"))
        content_box.addWidget(self.item_edit)
        button_layout = QHBoxLayout()
        plus_button = FlatButton(":/images/plus.svg")
        self.edit_button = FlatButton(":/images/edit.svg")
        self.trash_button = FlatButton(":/images/trash.svg")
        self.up_button = FlatButton(":/images/up.svg")
        self.down_button = FlatButton(":/images/down.svg")
        self.trash_button.enabled = False
        self.up_button.enabled = False
        self.down_button.enabled = False
        button_layout.addWidget(plus_button)
        button_layout.addWidget(self.up_button)
        button_layout.addWidget(self.down_button)
        button_layout.addWidget(self.edit_button)
        button_layout.addWidget(self.trash_button)
        content_box.addLayout(button_layout)
        self.content.addLayout(content_box)
        plus_button.clicked.connect(self.addPart)
        self.trash_button.clicked.connect(self.dropPart)
        self.up_button.clicked.connect(self.partUp)
        self.down_button.clicked.connect(self.partDown)
        self.edit_button.clicked.connect(self.editPart)

        self.image_list = QListWidget()
        self.image_list.setSizePolicy(QSizePolicy.Ignored, QSizePolicy.Fixed)
        image_box = QVBoxLayout()
        image_box.addWidget(self.image_list)
        image_button_layout = QHBoxLayout()
        image_plus_button = FlatButton(":/images/plus.svg")
        self.image_trash_button = FlatButton(":/images/trash.svg")
        self.image_trash_button.enabled = False
        image_button_layout.addWidget(image_plus_button)
        image_button_layout.addWidget(self.image_trash_button)
        image_box.addLayout(image_button_layout)
        self.images.addLayout(image_box)
        image_plus_button.clicked.connect(self.addImage)
        self.image_trash_button.clicked.connect(self.dropImage)

        scroll_content = QWidget()
        scroll_content.setLayout(vbox)
        scroll = QScrollArea()
        scroll.setHorizontalScrollBarPolicy(Qt.ScrollBarAsNeeded)
        scroll.setVerticalScrollBarPolicy(Qt.ScrollBarAsNeeded)
        scroll.setWidget(scroll_content)
        scroll.setWidgetResizable(True)
        scroll.setMaximumWidth(200)
        scroll.setMinimumWidth(200)

        self.navigationdock = QDockWidget("Navigation", self)
        self.navigationdock.setAllowedAreas(Qt.LeftDockWidgetArea
                                            | Qt.RightDockWidgetArea)
        self.navigationdock.setWidget(scroll)
        self.navigationdock.setObjectName("Navigation")
        self.addDockWidget(Qt.LeftDockWidgetArea, self.navigationdock)

        self.splitter = QSplitter()
        self.text_edit = MarkdownEdit()
        self.text_edit.setFont(QFont("Courier", 15))  # 11 on Linux
        self.preview = QWebEngineView()
        self.preview.setMinimumWidth(300)
        self.setWindowTitle(QCoreApplication.applicationName())

        self.splitter.addWidget(self.text_edit)
        self.splitter.addWidget(self.preview)
        self.setCentralWidget(self.splitter)

        self.content.expanded.connect(self.contentExpanded)
        self.images.expanded.connect(self.imagesExpanded)
        self.settings.expanded.connect(self.settingsExpanded)
        self.settings.clicked.connect(self.openSettings)
        self.content_list.currentItemChanged.connect(self.partSelectionChanged)
        self.image_list.currentItemChanged.connect(self.imageSelectionChanged)
        self.image_list.itemDoubleClicked.connect(self.insertImage)

        self.text_edit.undoAvailable.connect(self.undoAvailable)
        self.text_edit.redoAvailable.connect(self.redoAvailable)
        self.text_edit.copyAvailable.connect(self.copyAvailable)

        QApplication.clipboard().dataChanged.connect(self.clipboardDataChanged)

    def undoAvailable(self, value):
        self.undo_act.setEnabled(value)

    def redoAvailable(self, value):
        self.redo_act.setEnabled(value)

    def copyAvailable(self, value):
        self.copy_act.setEnabled(value)
        self.cut_act.setEnabled(value)

    def clipboardDataChanged(self):
        md = QApplication.clipboard().mimeData()
        self.paste_act.setEnabled(md.hasText())

    def openSettings(self):
        dlg = Settings(self.book, self.install_directory)
        dlg.exec()
        if dlg.saved:
            self.setWindowTitle(QCoreApplication.applicationName() + " - " +
                                self.book.name)

    def addPart(self):
        self.item_edit.setText("")
        self.item_edit.setFocus()
        self.item_anim.setStartValue(0)
        self.item_anim.setEndValue(23)
        self.item_anim.start()
        self._part_is_new = True

    def addItem(self):
        text = self.item_edit.text()
        if text:
            if not self.book.getPart(text):
                self.book.addPart(text)
                self.loadBook(self.last_book)

    def updateItem(self):
        text = self.item_edit.text()
        if text:
            if not self.book.getPart(text):
                self.book.updatePart(
                    self.content_list.currentItem().data(1).name, text)
                self.loadBook(self.last_book)

    def editItemFinished(self):
        if self._part_is_new:
            self.addItem()
        else:
            self.updateItem()
        self.item_anim.setStartValue(23)
        self.item_anim.setEndValue(0)
        self.item_anim.start()

    def editPart(self):
        item = self.content_list.currentItem().data(1).name
        self.item_edit.setText(item)
        self.item_edit.setFocus()
        self.item_anim.setStartValue(0)
        self.item_anim.setEndValue(23)
        self.item_anim.start()
        self._part_is_new = False

    def dropPart(self):
        item = self.content_list.currentItem().data(1).name
        msgBox = QMessageBox()
        msgBox.setText("You are about to delete the part <i>" + item + "</i>")
        msgBox.setInformativeText("Do you really want to delete the item?")
        msgBox.setStandardButtons(QMessageBox.Yes | QMessageBox.Cancel)
        msgBox.setDefaultButton(QMessageBox.Cancel)
        ret = msgBox.exec()
        if ret == QMessageBox.Yes:
            self.book.dropPart(item)
            self.loadBook(self.last_book)

    def addImage(self):
        fileName = ""
        dialog = QFileDialog()
        dialog.setFileMode(QFileDialog.AnyFile)
        dialog.setNameFilter("Image Files(*.png *.jpg *.bmp *.gif);;All (*)")
        dialog.setWindowTitle("Load Image")
        dialog.setOption(QFileDialog.DontUseNativeDialog, True)
        dialog.setAcceptMode(QFileDialog.AcceptOpen)
        if dialog.exec_():
            fileName = dialog.selectedFiles()[0]
        del dialog
        if not fileName:
            return

        base = os.path.basename(fileName)
        if not os.path.exists(
                os.path.join(self.book.source_path, "images", base)):
            copy(fileName, os.path.join(self.book.source_path, "images"))
        item = QListWidgetItem()
        item.setText(Path(fileName).name)
        item.setData(
            1,
            os.path.join(self.book.source_path, "images",
                         Path(fileName).name))
        self.image_list.addItem(item)

    def dropImage(self):
        item = self.image_list.currentItem()
        image = item.data(1)
        filename = os.path.join(self.book.source_path, "parts", image)
        os.remove(filename)
        self.loadImages()

    def loadImages(self):
        self.image_list.clear()
        for root, dir, files in os.walk(
                os.path.join(self.book.source_path, "images")):
            for file in files:
                filename = os.path.join(self.book.source_path, "images",
                                        Path(file).name)
                item = QListWidgetItem()
                item.setToolTip("Doubleclick image to insert into text")
                item.setText(Path(file).name)
                item.setData(1, filename)
                self.image_list.addItem(item)

    def partUp(self):
        pos = self.content_list.currentRow()
        item = self.content_list.takeItem(pos)
        self.content_list.insertItem(pos - 1, item)
        self.content_list.setCurrentRow(pos - 1)
        self.book.partUp(item.data(1).name)

    def partDown(self):
        pos = self.content_list.currentRow()
        item = self.content_list.takeItem(pos)
        self.content_list.insertItem(pos + 1, item)
        self.content_list.setCurrentRow(pos + 1)
        self.book.partDown(item.data(1).name)

    def partSelectionChanged(self, item):
        if item:
            part = item.data(1)
            self.filename = os.path.join(self.book.source_path, "parts",
                                         part.src)
            with open(self.filename, "r") as f:
                t = f.read()
                self.text_edit.setPlainText(t)
            self.trash_button.enabled = True
            self.up_button.enabled = self.content_list.currentRow() > 0
            self.down_button.enabled = self.content_list.currentRow(
            ) < self.content_list.count() - 1
            self.edit_button.enabled = True
        else:
            self.text_edit.setText("")
            self.trash_button.enabled = False
            self.up_button.enabled = False
            self.down_button.enabled = False
            self.edit_button.enabled = False

    def imageSelectionChanged(self, item):
        if item:
            self.image_trash_button.enabled = True
        else:
            self.image_trash_button.enabled = False

    def contentExpanded(self, value):
        if value:
            self.images.setExpanded(False)
            self.settings.setExpanded(False)

    def imagesExpanded(self, value):
        if value:
            self.content.setExpanded(False)
            self.settings.setExpanded(False)

    def appearanceExpanded(self, value):
        if value:
            self.content.setExpanded(False)
            self.images.setExpanded(False)
            self.settings.setExpanded(False)

    def settingsExpanded(self, value):
        if value:
            self.content.setExpanded(False)
            self.images.setExpanded(False)

    def closeEvent(self, event):
        self.writeSettings()
        event.accept()

    def createMenus(self):
        new_icon = QIcon(QPixmap(":/images/new.svg"))
        open_icon = QIcon(QPixmap(":/images/open.svg"))
        book_icon = QIcon(QPixmap(":/images/book.svg"))
        bold_icon = QIcon(QPixmap(":/images/bold.svg"))
        italic_icon = QIcon(QPixmap(":/images/italic.svg"))
        image_icon = QIcon(QPixmap(":/images/image.svg"))
        table_icon = QIcon(QPixmap(":/images/table.svg"))
        á_icon = QIcon(QPixmap(":/images/á.svg"))
        ã_icon = QIcon(QPixmap(":/images/ã.svg"))
        é_icon = QIcon(QPixmap(":/images/é.svg"))
        ê_icon = QIcon(QPixmap(":/images/ê.svg"))
        ó_icon = QIcon(QPixmap(":/images/ó.svg"))

        new_act = QAction(new_icon, "&New", self)
        new_act.setShortcuts(QKeySequence.New)
        new_act.setStatusTip("Create a new ebook project")
        new_act.triggered.connect(self.newFile)
        new_act.setToolTip("Create new ebook project")

        open_act = QAction(open_icon, "&Open", self)
        open_act.setShortcuts(QKeySequence.Open)
        open_act.setStatusTip("Open an existing ebook project")
        open_act.triggered.connect(self.open)
        open_act.setToolTip("Open an existing ebook project")

        book_act = QAction(book_icon, "&Create Book", self)
        book_act.setShortcuts(QKeySequence.SaveAs)
        book_act.setStatusTip("Create an ebook")
        book_act.triggered.connect(self.create)
        book_act.setToolTip("Create an ebook")

        pdf_act = QAction("Create &PDF", self)
        pdf_act.setStatusTip("Create PDF")
        pdf_act.setToolTip("Create PDF")
        pdf_act.triggered.connect(self.pdfExport)

        settings_act = QAction("&Settings", self)
        settings_act.setStatusTip("Open settings dialog")
        settings_act.triggered.connect(self.settingsDialog)
        settings_act.setToolTip("Open settings dialog")

        exit_act = QAction("E&xit", self)
        exit_act.setShortcuts(QKeySequence.Quit)
        exit_act.setStatusTip("Exit the application")
        exit_act.triggered.connect(self.close)

        self.undo_act = QAction("Undo", self)
        self.undo_act.setShortcut(QKeySequence.Undo)
        self.undo_act.setEnabled(False)
        self.undo_act.triggered.connect(self.doUndo)

        self.redo_act = QAction("Redo", self)
        self.redo_act.setShortcut(QKeySequence.Redo)
        self.redo_act.setEnabled(False)
        self.undo_act.triggered.connect(self.doRedo)

        self.cut_act = QAction("Cu&t", self)
        self.cut_act.setShortcut(QKeySequence.Cut)
        self.cut_act.triggered.connect(self.doCut)
        self.cut_act.setEnabled(False)

        self.copy_act = QAction("&Copy", self)
        self.copy_act.setShortcut(QKeySequence.Copy)
        self.copy_act.triggered.connect(self.doCopy)
        self.copy_act.setEnabled(False)

        self.paste_act = QAction("&Paste", self)
        self.paste_act.setShortcut(QKeySequence.Paste)
        self.paste_act.triggered.connect(self.doPaste)
        self.paste_act.setEnabled(False)

        bold_act = QAction(bold_icon, "Bold", self)
        bold_act.setShortcut(Qt.CTRL + Qt.Key_B)
        bold_act.triggered.connect(self.bold)

        italic_act = QAction(italic_icon, "Italic", self)
        italic_act.setShortcut(Qt.CTRL + Qt.Key_I)
        italic_act.triggered.connect(self.italic)

        image_act = QAction(image_icon, "Image", self)
        image_act.setShortcut(Qt.CTRL + Qt.Key_G)
        image_act.triggered.connect(self.insertImage)
        image_act.setToolTip("Insert an image")

        table_act = QAction(table_icon, "Table", self)
        table_act.setShortcut(Qt.CTRL + Qt.Key_T)
        table_act.triggered.connect(self.insertTable)
        table_act.setToolTip("Insert a table")

        á_act = QAction(á_icon, "á", self)
        á_act.triggered.connect(self.insertLetterA1)
        á_act.setToolTip("Insert letter á")

        ã_act = QAction(ã_icon, "ã", self)
        ã_act.triggered.connect(self.insertLetterA2)
        ã_act.setToolTip("Insert letter ã")

        é_act = QAction(é_icon, "é", self)
        é_act.triggered.connect(self.insertLetterE1)
        é_act.setToolTip("Insert letter é")

        ê_act = QAction(ê_icon, "ê", self)
        ê_act.triggered.connect(self.insertLetterE2)
        ê_act.setToolTip("Insert letter ê")

        ó_act = QAction(ó_icon, "ó", self)
        ó_act.triggered.connect(self.insertLetterO1)
        ó_act.setToolTip("Insert letter ó")

        about_act = QAction("&About", self)
        about_act.triggered.connect(self.about)
        about_act.setStatusTip("Show the application's About box")

        spell_act = QAction("&Spellcheck", self)
        spell_act.setShortcut(Qt.CTRL + Qt.Key_P)
        spell_act.triggered.connect(self.spellCheck)
        spell_act.setStatusTip("Spellcheck")

        file_menu = self.menuBar().addMenu("&File")
        file_menu.addAction(new_act)
        file_menu.addAction(open_act)
        file_menu.addAction(book_act)
        file_menu.addAction(pdf_act)
        file_menu.addSeparator()
        file_menu.addAction(settings_act)
        file_menu.addSeparator()
        file_menu.addAction(exit_act)

        edit_menu = self.menuBar().addMenu("&Edit")
        edit_menu.addAction(self.undo_act)
        edit_menu.addAction(self.redo_act)
        edit_menu.addSeparator()
        edit_menu.addAction(self.cut_act)
        edit_menu.addAction(self.copy_act)
        edit_menu.addAction(self.paste_act)

        format_menu = self.menuBar().addMenu("&Format")
        format_menu.addAction(bold_act)
        format_menu.addAction(italic_act)

        insert_menu = self.menuBar().addMenu("&Insert")
        insert_menu.addAction(image_act)
        insert_menu.addAction(table_act)

        for key in Plugins.generatorPluginNames():
            gen = Plugins.getGeneratorPlugin(key)
            if gen:
                act = QAction(gen.display_name, self)
                #act.triggered.connect(self.insertTable)
                #act.setToolTip("Insert a table")
                insert_menu.addAction(act)
                act.triggered.connect(gen.menu_action)

        help_menu = self.menuBar().addMenu("&Help")
        help_menu.addAction(about_act)
        help_menu.addAction(spell_act)

        file_tool_bar = self.addToolBar("File")
        file_tool_bar.addAction(new_act)
        file_tool_bar.addAction(open_act)
        file_tool_bar.addAction(book_act)

        format_tool_bar = self.addToolBar("Format")
        format_tool_bar.addAction(bold_act)
        format_tool_bar.addAction(italic_act)

        insert_toolbar = self.addToolBar("Insert")
        insert_toolbar.addAction(image_act)
        insert_toolbar.addAction(table_act)
        insert_toolbar.addAction(á_act)
        insert_toolbar.addAction(ã_act)
        insert_toolbar.addAction(é_act)
        insert_toolbar.addAction(ê_act)
        insert_toolbar.addAction(ó_act)

    def doUndo(self):
        self.text_edit.undo()

    def doRedo(self):
        self.text_edit.redo()

    def doCut(self):
        self.text_edit.cut()

    def doCopy(self):
        self.text_edit.copy()

    def doPaste(self):
        self.text_edit.paste()

    def insertImage(self):
        if not self.book:
            QMessageBox.warning(self, QCoreApplication.applicationName(),
                                "You have to load or create a book first!")
            return
        if not self.filename:
            QMessageBox.warning(
                self, QCoreApplication.applicationName(),
                "You have to select part from the book content first!")
            return
        if self.image_list.count() == 0:
            QMessageBox.warning(
                self, QCoreApplication.applicationName(),
                "You have to add an image to the image list first!")
            return
        if not self.image_list.currentItem():
            QMessageBox.warning(
                self, QCoreApplication.applicationName(),
                "You have to select an image from the image list first!")
            return

        item = self.image_list.currentItem()
        filename = item.text()
        cursor = self.text_edit.textCursor()
        pos = cursor.position()
        base = filename.split(".")[0].replace("_", "-")
        cursor.insertText("![" + base + "](../images/" + filename + " \"" +
                          base + "\")")
        cursor.setPosition(pos)
        self.text_edit.setTextCursor(cursor)

    def insertTable(self):
        cursor = self.text_edit.textCursor()
        pos = cursor.position()
        cursor.insertText(
            "| alignLeft | alignCenter | unAligned | alignRight |\n"
            "|  :---     |   :---:     |   ---     |   ---:     |\n"
            "|  cell a   |   cell b    |   cell c  |   cell d   |\n"
            "|  cell e   |   cell f    |   cell g  |   cell h   |\n")
        cursor.setPosition(pos)
        self.text_edit.setTextCursor(cursor)

    def insertLetterA1(self):
        cursor = self.text_edit.textCursor()
        pos = cursor.position()
        cursor.insertText("á")
        cursor.setPosition(pos + 1)
        self.text_edit.setTextCursor(cursor)

    def insertLetterA2(self):
        cursor = self.text_edit.textCursor()
        pos = cursor.position()
        cursor.insertText("ã")
        cursor.setPosition(pos + 1)
        self.text_edit.setTextCursor(cursor)

    def insertLetterE1(self):
        cursor = self.text_edit.textCursor()
        pos = cursor.position()
        cursor.insertText("é")
        cursor.setPosition(pos + 1)
        self.text_edit.setTextCursor(cursor)

    def insertLetterE2(self):
        cursor = self.text_edit.textCursor()
        pos = cursor.position()
        cursor.insertText("ê")
        cursor.setPosition(pos + 1)
        self.text_edit.setTextCursor(cursor)

    def insertLetterO1(self):
        cursor = self.text_edit.textCursor()
        pos = cursor.position()
        cursor.insertText("ó")
        cursor.setPosition(pos + 1)
        self.text_edit.setTextCursor(cursor)

    def createStatusBar(self):
        self.statusBar().showMessage("Ready")

    def about(self):
        QMessageBox.about(
            self, "About " + QCoreApplication.applicationName(),
            "EbookCreator\nVersion: " + QCoreApplication.applicationVersion() +
            "\n(C) Copyright 2020 CrowdWare. All rights reserved.\n\nThis program is provided AS IS with NO\nWARRANTY OF ANY KIND, INCLUDING THE\nWARRANTY OF DESIGN, MERCHANTABILITY AND\nFITNESS FOR A PATICULAR PURPOSE."
        )

    def newFile(self):
        dlg = ProjectWizard(self.install_directory, parent=self)
        dlg.loadBook.connect(self.loadBook)
        dlg.show()

    def open(self):
        fileName = ""
        dialog = QFileDialog()
        dialog.setFileMode(QFileDialog.AnyFile)
        dialog.setNameFilter("EbookCreator (book.qml);;All (*)")
        dialog.setWindowTitle("Load Ebook")
        dialog.setOption(QFileDialog.DontUseNativeDialog, True)
        dialog.setAcceptMode(QFileDialog.AcceptOpen)
        dialog.setDirectory(os.path.join(self.install_directory, "sources"))
        if dialog.exec_():
            fileName = dialog.selectedFiles()[0]
        del dialog
        if not fileName:
            return
        self.loadBook(fileName)

    def writeSettings(self):
        settings = QSettings(QSettings.IniFormat, QSettings.UserScope,
                             QCoreApplication.organizationName(),
                             QCoreApplication.applicationName())
        settings.setValue("geometry", self.saveGeometry())
        settings.setValue("lastBook", self.last_book)

    def readSettings(self):
        settings = QSettings(QSettings.IniFormat, QSettings.UserScope,
                             QCoreApplication.organizationName(),
                             QCoreApplication.applicationName())
        geometry = settings.value("geometry", QByteArray())
        self.last_book = settings.value("lastBook")
        if not geometry:
            availableGeometry = QApplication.desktop().availableGeometry(self)
            self.resize(availableGeometry.width() / 3,
                        availableGeometry.height() / 2)
            self.move((availableGeometry.width() - self.width()) / 2,
                      (availableGeometry.height() - self.height()) / 2)
        else:
            self.restoreGeometry(geometry)

    def bold(self):
        if not self.filename:
            QMessageBox.warning(
                self, QCoreApplication.applicationName(),
                "You have to select part from the book content first!")
            return
        cursor = self.text_edit.textCursor()
        pos = cursor.position()
        if not cursor.hasSelection():
            cursor.select(QTextCursor.WordUnderCursor)
        cursor.insertText("**" + cursor.selectedText() + "**")
        cursor.setPosition(pos + 2)
        self.text_edit.setTextCursor(cursor)

    def italic(self):
        if not self.filename:
            QMessageBox.warning(
                self, QCoreApplication.applicationName(),
                "You have to select part from the book content first!")
            return
        cursor = self.text_edit.textCursor()
        pos = cursor.position()
        if not cursor.hasSelection():
            cursor.select(QTextCursor.WordUnderCursor)
        cursor.insertText("*" + cursor.selectedText() + "*")
        cursor.setPosition(pos + 1)
        self.text_edit.setTextCursor(cursor)

    def create(self):
        filename = ""
        dialog = QFileDialog()
        dialog.setFileMode(QFileDialog.AnyFile)
        dialog.setNameFilter("ePub3 (*.epub);;All (*)")
        dialog.setWindowTitle("Create Ebook")
        dialog.setOption(QFileDialog.DontUseNativeDialog, True)
        dialog.setAcceptMode(QFileDialog.AcceptSave)
        dialog.setDirectory(self.book.source_path)
        dialog.setDefaultSuffix("epub")
        if dialog.exec_():
            filename = dialog.selectedFiles()[0]
        del dialog
        if not filename:
            return
        QApplication.setOverrideCursor(Qt.WaitCursor)
        createEpub(filename, self.book, self)
        QApplication.restoreOverrideCursor()

    def loadStatusChanged(self, status):
        if status == 1:
            self.book = self.component.create()
            if self.book is not None:
                self.book.setFilename(self.last_book)
                self.book.setWindow(self)
            else:
                for error in self.component.errors():
                    print(error.toString())
                return

            self.content_list.clear()
            for part in self.book.parts:
                item = QListWidgetItem()
                item.setText(part.name)
                item.setData(1, part)
                self.content_list.addItem(item)

            self.loadImages()
            self.setWindowTitle(QCoreApplication.applicationName() + " - " +
                                self.book.name)

            self.content.setExpanded(True)
            self.content_list.setCurrentRow(0)
        elif status == 3:
            for error in self.component.errors():
                print(error.toString())
            return

    def loadBook(self, filename):
        self.last_book = filename
        self.filename = ""
        engine = QQmlEngine()
        self.component = QQmlComponent(engine)
        self.component.statusChanged.connect(self.loadStatusChanged)
        self.component.loadUrl(QUrl.fromLocalFile(filename))

    def settingsDialog(self):
        dlg = SettingsDialog(self.theme,
                             self.palette().highlight().color().name(),
                             parent=self)
        dlg.exec()
        if dlg.theme != self.theme or dlg.hilite_color != self.palette(
        ).highlight().color().name():
            settings = QSettings(QSettings.IniFormat, QSettings.UserScope,
                                 QCoreApplication.organizationName(),
                                 QCoreApplication.applicationName())
            settings.setValue("theme", dlg.theme)
            settings.setValue("hiliteColor", dlg.hilite_color)

            msgBox = QMessageBox()
            msgBox.setText("Please restart the app to change the theme!")
            msgBox.exec()

    def textChanged(self):
        text = self.text_edit.toPlainText()
        if self.filename:
            with open(self.filename, "w") as f:
                f.write(text)

        self.lock = Lock()
        with self.lock:
            if not self.tread_running:
                self.tread_running = True
                self.htmlReady.connect(self.previewReady)
                thread = Thread(target=self.createHtml, args=(text, ))
                thread.daemon = True
                thread.start()

    def previewReady(self, html):
        self.preview.setHtml(
            html,
            baseUrl=QUrl(
                Path(os.path.join(self.book.source_path, "parts",
                                  "index.html")).as_uri()))
        self.htmlReady.disconnect()
        with self.lock:
            self.tread_running = False

    def createHtml(self, text):
        html = '<html>\n<head>\n'
        html += '<link href="../css/pastie.css" rel="stylesheet" type="text/css"/>\n'
        html += '<link href="../css/stylesheet.css" rel="stylesheet" type="text/css"/>\n'
        html += '</head>\n<body>\n'
        html += markdown(text,
                         html4tags=False,
                         extras=[
                             "fenced-code-blocks", "wiki-tables", "tables",
                             "header-ids"
                         ])
        html += '\n</body>\n</html>'
        html = addLineNumbers(html)
        self.htmlReady.emit(html)

    def pdfExport(self):
        p = PdfExport(self.book, self.statusBar())

    def spellCheck(self):
        if not self.filename:
            QMessageBox.warning(
                self, QCoreApplication.applicationName(),
                "You have to select part from the book content first!")
            return
        cursor = self.text_edit.textCursor()
        pos = cursor.position()
        if not cursor.hasSelection():
            cursor.select(QTextCursor.WordUnderCursor)
        spell = Speller(lang='en')
        changed = spell(cursor.selectedText())
        if changed != cursor.selectedText():
            cursor.insertText(changed)
            self.text_edit.setTextCursor(cursor)

    def loadPlugins(self):
        # check if we are running in a frozen environment (pyinstaller --onefile)
        if getattr(sys, "frozen", False):
            bundle_dir = sys._MEIPASS
            # if we are running in a onefile environment, then copy all plugin to /tmp/...
            if bundle_dir != os.getcwd():
                os.mkdir(os.path.join(bundle_dir, "plugins"))
                for root, dirs, files in os.walk(
                        os.path.join(os.getcwd(), "plugins")):
                    for file in files:
                        shutil.copy(os.path.join(root, file),
                                    os.path.join(bundle_dir, "plugins"))
                        print("copy", file)
                    break  # do not copy __pycache__
        else:
            bundle_dir = os.getcwd()

        plugins_dir = os.path.join(bundle_dir, "plugins")
        for root, dirs, files in os.walk(plugins_dir):
            for file in files:
                modulename, ext = os.path.splitext(file)
                if ext == ".py":
                    module = import_module("plugins." + modulename)
                    for name, klass in inspect.getmembers(
                            module, inspect.isclass):
                        if klass.__module__ == "plugins." + modulename:
                            instance = klass()
                            if isinstance(instance, GeneratorInterface):
                                Plugins.addGeneratorPlugin(name, instance)
                                instance.setTextEdit(self.text_edit)
                                #instance.registerContenType()
            break  # not to list __pycache__
Пример #13
0
    def __init__(self):
        QMainWindow.__init__(self)
        self.setWindowTitle("Qt Expander Demo")
        self.resize(640, 480)

        edit = QTextEdit()
        edit.setPlainText("Lorem ipsum dolor...")
        self.content = Expander("Content", "parts.svg")
        self.images = Expander("Images", "images.svg")
        self.settings = Expander("Settings", "settings.svg")
        vbox = QVBoxLayout()
        vbox.addWidget(self.content)
        vbox.addWidget(self.images)
        vbox.addWidget(self.settings)
        vbox.addStretch()
        scroll_content = QWidget()
        scroll_content.setLayout(vbox)
        scroll = QScrollArea()
        scroll.setHorizontalScrollBarPolicy(Qt.ScrollBarAsNeeded)
        scroll.setVerticalScrollBarPolicy(Qt.ScrollBarAsNeeded)
        scroll.setWidget(scroll_content)
        scroll.setWidgetResizable(True)
        scroll.setMaximumWidth(200)
        scroll.setMinimumWidth(200)
        self.navigationdock = QDockWidget("Navigation", self)
        self.navigationdock.setAllowedAreas(Qt.LeftDockWidgetArea
                                            | Qt.RightDockWidgetArea)
        self.navigationdock.setWidget(scroll)
        self.navigationdock.setObjectName("Navigation")
        self.addDockWidget(Qt.LeftDockWidgetArea, self.navigationdock)
        self.setCentralWidget(edit)

        # fill content
        self.content_list = QListWidget()
        self.content_list.setSizePolicy(QSizePolicy.Ignored, QSizePolicy.Fixed)
        for i in range(5):
            item = QListWidgetItem()
            item.setText("Item " + str(i))
            self.content_list.addItem(item)
        content_box = QVBoxLayout()
        content_box.addWidget(self.content_list)
        self.content.addLayout(content_box)

        # fill images
        self.images_list = QListWidget()
        self.images_list.setSizePolicy(QSizePolicy.Ignored, QSizePolicy.Fixed)
        for i in range(5):
            item = QListWidgetItem()
            item.setText("Image " + str(i))
            self.images_list.addItem(item)
        images_box = QVBoxLayout()
        images_box.addWidget(self.images_list)
        self.images.addLayout(images_box)

        #fill settings
        self.settings_list = QListWidget()
        self.settings_list.setSizePolicy(QSizePolicy.Ignored,
                                         QSizePolicy.Fixed)
        for i in range(5):
            item = QListWidgetItem()
            item.setText("Setting " + str(i))
            self.settings_list.addItem(item)
        settings_box = QVBoxLayout()
        settings_box.addWidget(self.settings_list)
        self.settings.addLayout(settings_box)

        self.content.expanded.connect(self.contentExpanded)
        self.images.expanded.connect(self.imagesExpanded)
        self.settings.expanded.connect(self.settingsExpanded)
Пример #14
0
 def __init__(self, id, parent):
     Widget.__init__(self, id, parent)
     self.widgets.expander = Expander()
     self.widgets.surface_table = FitTable()
     self.widgets.signal_table = FitTable()
Пример #15
0
 def setUp(self):
   self.extractor = LineExtractor("")
   self.message = StatusMessage(self.extractor)
   self.expander = Expander(Executor(), self.message)
Пример #16
0
class TestSubtituter(unittest.TestCase):

  def setUp(self):
    self.extractor = LineExtractor("")
    self.message = StatusMessage(self.extractor)
    self.expander = Expander(Executor(), self.message)

  def testMakeSubtitutionList(self):
    if IGNORE_TEST:
      return
    substitution_list = Expander.makeSubstitutionList(DEFINITIONS)
    expected = np.prod([len(v) for v in DEFINITIONS.values()])
    self.assertEqual(len(substitution_list), expected)
    substitution_list = Expander.makeSubstitutionList({})
    self.assertEqual(len(substitution_list), 0)
    definitions = dict(DEFINITIONS)
    key = list(DEFINITIONS.keys())[0]
    del definitions[key]
    substitution_list = Expander.makeSubstitutionList(definitions)
    expected = np.prod([len(v) for v in definitions.values()])
    self.assertEqual(len(substitution_list), expected)

  def testGetTemplateExpressions(self):
    if IGNORE_TEST:
      return
    expression1 = "a + b"
    expression2 = "x"
    expression3 = "cos(a) + sin(b)"
    proto_template = "xy%s%s%sz + yz%s%s%sx"  
    for expr in [expression1, expression2, expression3]:
      template = proto_template % (
          EXPRESSION_START, expr, EXPRESSION_END,
          EXPRESSION_START, expr, EXPRESSION_END)
      result = self.expander.getTemplateExpressions(template)
      self.assertEqual(len(result), 1)
      self.assertEqual(result[0], expr)

  def _testGetTemplateExpression(self, line, expecteds):
    if IGNORE_TEST:
      return
    expressions = self.expander.getTemplateExpressions(line)
    self.assertEqual(set(expressions), set(expecteds))

  def testGetTemplateExpressions2(self):
    if IGNORE_TEST:
      return
    self._testGetTemplateExpression("x{a} -> x + {a}; k*{a}", ["a"])
    self._testGetTemplateExpression("x{a} -> x + {b}; k*{a}",
        ["a", "b"])
    self._testGetTemplateExpression("x{a} -> x + { b }; k*{a}",
        ["a", "b"])
    self._testGetTemplateExpression("T{n} + A -> A + T{n+1}",
        ["n", "n+1"])
    self._testGetTemplateExpression("T{n} + A -> A + T{n+1} + T{2*n + n }",
        ["n", "n+1", "2*n + n"])
    
  def testDo(self):
    if IGNORE_TEST:
      return
    executor = Executor()
    executor.setDefinitions(DEFINITIONS)
    expander = Expander(executor, self.message)
    result = expander.do(SUBSTITUTION1)
    self.assertEqual(result[0], SUBSTITUTION1)
    result = expander.do(SUBSTITUTION2)
    expected = len(DEFINITIONS['a'])
    self.assertEqual(len(result), expected)
    
  def testDoSubstitutionNoDefinition(self):
    if IGNORE_TEST:
      return
    executor = Executor()
    expander = Expander(executor, self.message)
    result = expander.do(SUBSTITUTION1)
    self.assertEqual(result[0], SUBSTITUTION1)

  def testExpandTemplateExpressions(self):
    if IGNORE_TEST:
      return
    executor = Executor()
    var = 'n'
    definitions = {var: [1, 2, 3]}
    executor.setDefinitions(definitions)
    expander = Expander(executor, self.message)
    template = "T{%s} + A -> T{%s+1}" % (var, var)
    expansion = expander.do(template)
    self.assertEqual(len(expansion), len(definitions[var]))
    # Check that each substitution is found
    for value in definitions[var]:
      found = False
      for substitution in expansion:
        if "T%d" % value in substitution:
          found = True
          break
      self.assertTrue(found)
Пример #17
0
    def createUi(self):
        self.content = Expander("Content", ":/images/parts.svg")
        self.images = Expander("Images", ":/images/images.svg")
        self.settings = Expander("Settings", ":/images/settings.svg")

        self.setWindowTitle(QCoreApplication.applicationName() + " " +
                            QCoreApplication.applicationVersion())
        vbox = QVBoxLayout()
        vbox.addWidget(self.content)
        vbox.addWidget(self.images)
        vbox.addWidget(self.settings)
        vbox.addStretch()

        self.content_list = QListWidget()
        self.content_list.setSizePolicy(QSizePolicy.Ignored, QSizePolicy.Fixed)
        content_box = QVBoxLayout()
        content_box.addWidget(self.content_list)
        self.item_edit = QLineEdit()
        self.item_edit.setMaximumHeight(0)
        self.item_edit.editingFinished.connect(self.editItemFinished)
        self.item_anim = QPropertyAnimation(self.item_edit,
                                            "maximumHeight".encode("utf-8"))
        content_box.addWidget(self.item_edit)
        button_layout = QHBoxLayout()
        plus_button = FlatButton(":/images/plus.svg")
        self.edit_button = FlatButton(":/images/edit.svg")
        self.trash_button = FlatButton(":/images/trash.svg")
        self.up_button = FlatButton(":/images/up.svg")
        self.down_button = FlatButton(":/images/down.svg")
        self.trash_button.enabled = False
        self.up_button.enabled = False
        self.down_button.enabled = False
        button_layout.addWidget(plus_button)
        button_layout.addWidget(self.up_button)
        button_layout.addWidget(self.down_button)
        button_layout.addWidget(self.edit_button)
        button_layout.addWidget(self.trash_button)
        content_box.addLayout(button_layout)
        self.content.addLayout(content_box)
        plus_button.clicked.connect(self.addPart)
        self.trash_button.clicked.connect(self.dropPart)
        self.up_button.clicked.connect(self.partUp)
        self.down_button.clicked.connect(self.partDown)
        self.edit_button.clicked.connect(self.editPart)

        self.image_list = QListWidget()
        self.image_list.setSizePolicy(QSizePolicy.Ignored, QSizePolicy.Fixed)
        image_box = QVBoxLayout()
        image_box.addWidget(self.image_list)
        image_button_layout = QHBoxLayout()
        image_plus_button = FlatButton(":/images/plus.svg")
        self.image_trash_button = FlatButton(":/images/trash.svg")
        self.image_trash_button.enabled = False
        image_button_layout.addWidget(image_plus_button)
        image_button_layout.addWidget(self.image_trash_button)
        image_box.addLayout(image_button_layout)
        self.images.addLayout(image_box)
        image_plus_button.clicked.connect(self.addImage)
        self.image_trash_button.clicked.connect(self.dropImage)

        scroll_content = QWidget()
        scroll_content.setLayout(vbox)
        scroll = QScrollArea()
        scroll.setHorizontalScrollBarPolicy(Qt.ScrollBarAsNeeded)
        scroll.setVerticalScrollBarPolicy(Qt.ScrollBarAsNeeded)
        scroll.setWidget(scroll_content)
        scroll.setWidgetResizable(True)
        scroll.setMaximumWidth(200)
        scroll.setMinimumWidth(200)

        self.navigationdock = QDockWidget("Navigation", self)
        self.navigationdock.setAllowedAreas(Qt.LeftDockWidgetArea
                                            | Qt.RightDockWidgetArea)
        self.navigationdock.setWidget(scroll)
        self.navigationdock.setObjectName("Navigation")
        self.addDockWidget(Qt.LeftDockWidgetArea, self.navigationdock)

        self.splitter = QSplitter()
        self.text_edit = MarkdownEdit()
        self.text_edit.setFont(QFont("Courier", 15))  # 11 on Linux
        self.preview = QWebEngineView()
        self.preview.setMinimumWidth(300)
        self.setWindowTitle(QCoreApplication.applicationName())

        self.splitter.addWidget(self.text_edit)
        self.splitter.addWidget(self.preview)
        self.setCentralWidget(self.splitter)

        self.content.expanded.connect(self.contentExpanded)
        self.images.expanded.connect(self.imagesExpanded)
        self.settings.expanded.connect(self.settingsExpanded)
        self.settings.clicked.connect(self.openSettings)
        self.content_list.currentItemChanged.connect(self.partSelectionChanged)
        self.image_list.currentItemChanged.connect(self.imageSelectionChanged)
        self.image_list.itemDoubleClicked.connect(self.insertImage)

        self.text_edit.undoAvailable.connect(self.undoAvailable)
        self.text_edit.redoAvailable.connect(self.redoAvailable)
        self.text_edit.copyAvailable.connect(self.copyAvailable)

        QApplication.clipboard().dataChanged.connect(self.clipboardDataChanged)
Пример #18
0
def create_model():
    m = pe.ConcreteModel()
    m.fs = fs = FlowsheetBlock(default={"dynamic": False})
    fs.vapor_props = vapor_props = PhysicalParameterBlock(
        default={"valid_phase": 'Vap'})
    fs.properties = props = PhysicalParameterBlock(
        default={"valid_phase": ('Vap', 'Liq')})
    fs.reaction_params = MethanolReactionParameterBlock(
        default={'property_package': vapor_props})

    fs.feed = feed = Feed(default={"property_package": vapor_props})
    fs.compressor1 = IdealGasIsentropicCompressor(
        default={
            "property_package": vapor_props,
            "has_phase_equilibrium": False
        })
    fs.cooler1 = Heater(default={
        "property_package": vapor_props,
        "has_phase_equilibrium": False
    })
    fs.compressor2 = IdealGasIsentropicCompressor(
        default={
            "property_package": vapor_props,
            "has_phase_equilibrium": False
        })
    fs.equal_electric = pe.Constraint(
        expr=fs.compressor1.work[0.0] == fs.compressor2.work[0.0])
    fs.mixer = Mixer(
        default={
            'property_package': vapor_props,
            'inlet_list': ['feed', 'recycle'],
            'momentum_mixing_type': MomentumMixingType.equality
        })

    # Reactor
    fs.reactor = StoichiometricReactor(
        default={
            'property_package': vapor_props,
            'reaction_package': fs.reaction_params,
            'has_heat_of_reaction': True,
            'has_pressure_change': False
        })
    fs.reactor.conversion_eq = pe.Var()
    fs.reactor.t_inv = pe.Var()
    fs.reactor.p_sq_inv = pe.Var()
    fs.reactor.conversion = pe.Var()
    fs.reactor.consumption_rate = pe.Var()
    fs.reactor.t_inv_con = pe.Constraint(expr=fs.reactor.t_inv *
                                         fs.reactor.outlet.temperature[0] == 1)
    fs.reactor.p_sq_inv_con = pe.Constraint(
        expr=fs.reactor.p_sq_inv * fs.reactor.inlet.pressure[0]**2 == 1)
    fs.reactor.conversion_eq_con = pe.Constraint(expr=(
        fs.reactor.conversion_eq == 0.415 *
        (1 - 26.25 * pe.exp(-18 * fs.reactor.t_inv) * fs.reactor.p_sq_inv)))
    fs.reactor.conversion_con = pe.Constraint(
        expr=(fs.reactor.conversion == fs.reactor.conversion_eq *
              (1 - pe.exp(-5)) * (fs.reactor.inlet.mole_frac[0, "H2"] +
                                  fs.reactor.inlet.mole_frac[0, "CO"] +
                                  fs.reactor.inlet.mole_frac[0, "CH3OH"])))
    fs.reactor.consumption_rate_con = pe.Constraint(
        expr=(fs.reactor.consumption_rate == fs.reactor.conversion *
              fs.reactor.inlet.mole_frac[0, "H2"] *
              fs.reactor.inlet.flow_mol[0]))
    fs.reactor.h2_consumption_con = pe.Constraint(expr=(
        fs.reactor.outlet.flow_mol[0] *
        fs.reactor.outlet.mole_frac[0, "H2"] == fs.reactor.inlet.flow_mol[0] *
        fs.reactor.inlet.mole_frac[0, "H2"] - fs.reactor.consumption_rate))

    fs.expander = Expander(default={
        'property_package': vapor_props,
        'has_phase_equilibrium': False
    })
    fs.cooler2 = Heater(default={
        "property_package": vapor_props,
        "has_phase_equilibrium": False
    })
    fs.flash = Flash(default={"property_package": props})
    fs.purge_splitter = Separator(
        default={
            'property_package': vapor_props,
            'outlet_list': ['purge', 'recycle'],
            'ideal_separation': False
        })
    fs.compressor3 = IdealGasIsentropicCompressor(
        default={
            "property_package": vapor_props,
            "has_phase_equilibrium": False
        })

    ###########################
    # Set scaling factors
    ###########################
    fs.compressor1.control_volume.scaling_factor_energy.value = 1
    fs.compressor2.control_volume.scaling_factor_energy.value = 1
    fs.cooler1.control_volume.scaling_factor_energy.value = 1
    fs.flash.control_volume.scaling_factor_energy.value = 1
    fs.reactor.control_volume.scaling_factor_energy.value = 1
    fs.cooler2.control_volume.scaling_factor_energy.value = 1
    fs.compressor3.control_volume.scaling_factor_energy.value = 1
    fs.mixer.scaling_factor_energy.value = 1

    fs.cooler1.control_volume.scaling_factor_pressure.value = 1
    fs.flash.control_volume.scaling_factor_pressure.value = 1
    fs.reactor.control_volume.scaling_factor_pressure.value = 1
    fs.cooler2.control_volume.scaling_factor_pressure.value = 1

    ###########################
    # Objective
    ###########################
    m.objective = pe.Objective(expr=(-fs.flash.liq_outlet.flow_mol[0.0]))

    ###########################
    # Connect Units
    ###########################
    fs.stream1 = network.Arc(source=feed.outlet,
                             destination=fs.compressor1.inlet)
    fs.stream2 = network.Arc(source=fs.compressor1.outlet,
                             destination=fs.cooler1.inlet)
    fs.stream3 = network.Arc(source=fs.cooler1.outlet,
                             destination=fs.compressor2.inlet)
    fs.stream4 = network.Arc(source=fs.compressor2.outlet,
                             destination=fs.mixer.feed)
    fs.stream5 = network.Arc(source=fs.mixer.outlet,
                             destination=fs.reactor.inlet)
    fs.stream6 = network.Arc(source=fs.reactor.outlet,
                             destination=fs.expander.inlet)
    fs.stream7 = network.Arc(source=fs.expander.outlet,
                             destination=fs.cooler2.inlet)
    fs.stream8 = network.Arc(source=fs.cooler2.outlet,
                             destination=fs.flash.inlet)
    fs.stream9 = network.Arc(source=fs.flash.vap_outlet,
                             destination=fs.purge_splitter.inlet)
    fs.stream10 = network.Arc(source=fs.purge_splitter.recycle,
                              destination=fs.compressor3.inlet)
    fs.stream11 = network.Arc(source=fs.compressor3.outlet,
                              destination=fs.mixer.recycle)
    pe.TransformationFactory("network.expand_arcs").apply_to(m)

    ###########################
    # Set problem specs
    ###########################
    feed.flow_mol.fix(3.40898)
    feed.pressure.fix(1)
    feed.temperature.fix(3)
    feed.mole_frac[0.0, "CH4"].fix(0.05)
    feed.mole_frac[0.0, "CO"].fix(0.3)
    feed.mole_frac[0.0, "H2"].fix(0.6)
    feed.mole_frac[0.0, "CH3OH"].fix(0.05)

    fs.cooler1.heat_duty[0.0].setub(0)  # it is a cooler
    fs.cooler1.outlet.temperature[0.0].setlb(3)

    fs.flash.heat_duty.fix(0)
    fs.flash.deltaP.fix(0)

    fs.cooler2.heat_duty[0.0].setub(0)  # it is a cooler
    fs.cooler2.outlet.temperature[0.0].setlb(3)

    fs.compressor2.outlet.pressure[0.0].setub(10)
    fs.flash.liq_outlet.mole_frac[0.0, 'CH3OH'].expr.setlb(0.9)

    fs.purge_splitter.split_fraction[0.0, 'purge'].fix(0.05)

    ###########################
    # Prepare for initialization
    ###########################
    fs.compressor1.outlet.pressure.fix(5)
    fs.compressor2.outlet.pressure.fix(10)
    fs.cooler1.outlet.temperature.fix(3)
    fs.expander.outlet.pressure[0.0].fix(5)
    fs.cooler2.outlet.temperature[0.0].fix(3)
    fs.flash.liq_outlet.mole_frac[0.0, 'CH3OH'].expr.setlb(None)

    # Setup decomposition process
    seq = network.SequentialDecomposition()
    seq.options.select_tear_method = "heuristic"
    seq.options.tear_method = "Wegstein"
    seq.options.iterLim = 5

    # Determine tear stream and calculation order
    G = seq.create_graph(m)
    heu_result = seq.tear_set_arcs(G, method="heuristic")
    order = seq.calculation_order(G)

    # Display tear stream and calculation order
    print("Tear")
    for o in heu_result:
        print(o.name)
    print("Order")
    for o in order:
        for oo in o:
            print(oo.name)

    # Set guesses for tear stream
    tear_guesses = {
        "flow_mol": {
            0: 10
        },
        "mole_frac": {
            (0, 'CH3OH'): 0.06,
            (0, 'CH4'): 0.21,
            (0, 'CO'): 0.24,
            (0, 'H2'): 0.50
        },
        "temperature": {
            0: 4.4
        },
        "pressure": {
            0: 15
        }
    }
    seq.set_guesses_for(m.fs.reactor.inlet, tear_guesses)

    # Define method for initialising each block
    def function(unit):
        unit.initialize(outlvl=1)

    # Run sequential initialisation
    seq.run(m, function)

    ###########################
    # Unfix vars that were fixed for initialization
    ###########################
    m.fs.compressor1.outlet.pressure.unfix()
    m.fs.compressor2.outlet.pressure.unfix()
    m.fs.cooler1.outlet.temperature.unfix()
    m.fs.expander.outlet.pressure.unfix()
    m.fs.cooler2.outlet.temperature.unfix()
    m.fs.flash.liq_outlet.mole_frac[0.0, 'CH3OH'].expr.setlb(0.9)

    return m