def cpdir(src, dst): """ Recursively copy a directory tree. :type src: str :type dst: str """ shutil.copytree(expandPath(src), expandPath(dst), copy_function=shutil.copy)
def frename(src, dst): """ Rename a file or director :type src: str :type dst: str """ os.rename(expandPath(src), expandPath(dst))
def make_plugins(self): """ Package built-in plugins into ZIP archives. """ if isdir('@plugins/'): mkdir(os.path.join(self.build_exe, 'plugins')) for file_or_directory in os.listdir(expandPath('@plugins/')): plugin = os.path.join(expandPath('@plugins/'), file_or_directory) if isdir(plugin): distutils.log.info('packaging plugin: %s', file_or_directory) zippath = os.path.join(self.build_exe, 'plugins', '%s.zip' % file_or_directory) with zipfile.ZipFile(zippath, 'w', zipfile.ZIP_STORED) as zipf: for root, dirs, files in os.walk(plugin): if not root.endswith('__pycache__'): for filename in files: path = expandPath(os.path.join(root, filename)) if path.endswith('.py'): new_path = '%s.pyc' % rstrip(path, '.py') py_compile.compile(path, new_path) arcname = os.path.join(file_or_directory, os.path.relpath(new_path, plugin)) zipf.write(new_path, arcname) fremove(new_path) else: arcname = os.path.join(file_or_directory, os.path.relpath(path, plugin)) zipf.write(path, arcname)
def doImportDescriptions(self): """ Start the CSV import process. """ # SELECT CSV FILE VIA FILE DIALOG dialog = QtWidgets.QFileDialog(self.session) dialog.setAcceptMode(QtWidgets.QFileDialog.AcceptOpen) dialog.setDirectory(expandPath('~')) dialog.setFileMode(QtWidgets.QFileDialog.ExistingFile) dialog.setViewMode(QtWidgets.QFileDialog.Detail) dialog.setNameFilters([File.Csv.value]) if not dialog.exec_(): return selected = expandPath(first(dialog.selectedFiles())) self.debug('Importing descriptions from file: {}'.format(selected)) reader = csv.reader(selected, dialect='excel', quoting=csv.QUOTE_ALL, quotechar='"') # PARSE CSV AND GENERATE COMMANDS commands = [] for row in reader: try: predicate, description = row[:2] # GET NODE CORRESPONDING TO PREDICATE for node in self.project.predicates(name=predicate): undo = self.project.meta(node.type(), node.text()) redo = undo.copy() redo[K_DESCRIPTION] = description undo[K_DESCRIPTION_STATUS] = undo.get( K_DESCRIPTION_STATUS, '') redo[K_DESCRIPTION_STATUS] = undo.get( K_DESCRIPTION_STATUS, '') # TODO: ADD STATUS COLUMN TO CSV # TODO: there is no conflict handler at the moment, # We need to provide here an interface for the user to # merge the current and imported description if redo != undo: commands.append( CommandNodeSetMeta(self.project, node.type(), node.text(), undo, redo)) except Exception as e: self.session.addNotification( textwrap.dedent(""" <b><font color="#7E0B17">ERROR</font></b>: Could not complete description import, please see the log for details. """)) return # APPLY CHANGES with BusyProgressDialog("Applying changes..."): self.session.undostack.beginMacro('edit {0} description'.format( self.node.name)) for command in commands: self.session.undostack.push(command) self.session.undostack.endMacro()
def path(self): """ Returns the path to the the reasoner (either a directory of a ZIP file). :rtype: str """ path = lstrip(inspect.getfile(self.__class__), expandPath('@reasoners/'), expandPath('@home/reasoners/')) home = first(filter(None, path.split(os.path.sep))) root = expandPath('@reasoners/' if self.isBuiltIn() else '@home/reasoners/') return os.path.join(root, home)
def path(self): """ Returns the path to the the plugin (either a directory of a ZIP file). :rtype: str """ path = lstrip(inspect.getfile(self.__class__), expandPath('@plugins/'), expandPath('@home/plugins/')) home = first(filter(None, path.split(os.path.sep))) root = expandPath('@plugins/' if self.isBuiltIn() else '@home/plugins/') return os.path.join(root, home)
def fcopy(src, dst): """ Copy the contents of the file named src to a file named dst. If dst specifies a directory, the file will be copied into dst using the base filename from src. :type src: str :type dst: str :rtype: str """ return shutil.copy(expandPath(src), expandPath(dst))
def doOpenProject(self): """ Bring up a modal window used to open a project. """ dialog = QtWidgets.QFileDialog(self) dialog.setAcceptMode(QtWidgets.QFileDialog.AcceptOpen) dialog.setDirectory(expandPath(self.workspace)) dialog.setFileMode(QtWidgets.QFileDialog.Directory) dialog.setOption(QtWidgets.QFileDialog.ShowDirsOnly, True) dialog.setViewMode(QtWidgets.QFileDialog.Detail) if dialog.exec_() == QtWidgets.QFileDialog.Accepted: self.sgnCreateSession.emit(expandPath(first(dialog.selectedFiles())))
def buildDmg(self): """Build the DMG image.""" try: import dmgbuild except ImportError: raise OSError( 'Unable to import dmgbuild: please install the dmgbuild package.' ) if fexists(self.dmgName): os.unlink(self.dmgName) defines = { 'appname': APPNAME, 'files': [self.bundleDir], 'license_file': expandPath('@root/LICENSE'), 'icon_locations': { '{}.app'.format(APPNAME): (60, 50) }, } if self.applications_shortcut: defines['symlinks'] = {'Applications': '/Applications'} defines['icon_locations']['Applications'] = (60, 130) if self.volume_background: if not fexists(self.volume_background): raise OSError( 'DMG volume background image not found at {0}'.format( self.volume_background)) print('Using DMG volume background: {0}'.format( self.volume_background)) from PIL import Image w, h = Image.open(self.volume_background).size defines['background'] = self.volume_background defines['window_rect'] = ((100, 500), (str(w), (str(h)))) if self.volume_icon: if not fexists(self.volume_icon): raise OSError('DMG volume icon not found at {0}'.format( self.volume_icon)) print('Using DMG volume icon: {0}'.format(self.volume_icon)) defines['icon'] = self.volume_icon # Create the disk image using dmgbuild package. dmgbuild.build_dmg( self.dmgName, self.volume_label, settings_file=expandPath('@support/dmgbuild/settings.py'), defines=defines, )
def fexists(path): """ Returns True if the given path identifies a regular file, False otherwise. :type path: str :rtype: bool """ return os.path.isfile(expandPath(path))
def isdir(path): """ Returns True if the given path identifies a directory, False otherwise. :type path: str :rtype: bool """ return os.path.isdir(expandPath(path))
def fremove(path): """ Removes the file identified by the given 'path'. :type path: str """ if fexists(path): os.remove(expandPath(path))
def test_load_ontology_from_graphml_2(session, qtbot): # GIVEN graphml = expandPath('@tests/test_resources/loaders/graphml/movie.graphml') project = session.project diagram = 'movie' with qtbot.waitSignal(session.sgnDiagramFocused): session.sgnFocusDiagram.emit(project.diagram('diagram')) # WHEN loader = GraphMLOntologyLoader(graphml, project, session) loader.run() # THEN assert diagram in map(lambda d: d.name, project.diagrams()) assert len(project.diagram(diagram).nodes()) == 347 assert len(project.diagram(diagram).edges()) == 433 assert len( list( filter(lambda n: n.type() == Item.ConceptNode, project.diagram(diagram).nodes()))) == 65 assert len( list( filter(lambda n: n.type() == Item.RoleNode, project.diagram(diagram).nodes()))) == 60 assert len( list( filter(lambda n: n.type() == Item.AttributeNode, project.diagram(diagram).nodes()))) == 27 assert len( list( filter(lambda n: n.type() == Item.IndividualNode, project.diagram(diagram).nodes()))) == 0
def rmdir(path): """ Removes the directory identified by given path if it exists. :type path: str """ if isdir(path): shutil.rmtree(expandPath(path))
def test_load_project_from_graphol_v1(session, qtbot, tmpdir): # GIVEN graphol = tmpdir.join('LUBM') cpdir(expandPath('@tests/test_resources/loaders/graphol/v1/LUBM'), str(graphol)) project = session.project diagram = 'LUBM' with qtbot.waitSignal(session.sgnDiagramFocused): session.sgnFocusDiagram.emit(project.diagram('diagram')) # WHEN loader = GrapholProjectLoader_v1(str(graphol), session) loader.run() # THEN assert diagram in map(lambda d: d.name, loader.project.diagrams()) assert len(loader.project.diagram(diagram).nodes()) == 71 assert len(loader.project.diagram(diagram).edges()) == 80 assert len( list( filter(lambda n: n.type() == Item.ConceptNode, loader.project.diagram(diagram).nodes()))) == 18 assert len( list( filter(lambda n: n.type() == Item.RoleNode, loader.project.diagram(diagram).nodes()))) == 9 assert len( list( filter(lambda n: n.type() == Item.AttributeNode, loader.project.diagram(diagram).nodes()))) == 5 assert len( list( filter(lambda n: n.type() == Item.IndividualNode, loader.project.diagram(diagram).nodes()))) == 0
def do_import(self): """ Import an ontology into the currently active Project. """ self.debug('Open dialog') dialog = QtWidgets.QFileDialog(self.session) dialog.setAcceptMode(QtWidgets.QFileDialog.AcceptOpen) dialog.setDirectory(expandPath('~')) dialog.setFileMode(QtWidgets.QFileDialog.ExistingFiles) dialog.setViewMode(QtWidgets.QFileDialog.Detail) if dialog.exec_(): selected = [x for x in dialog.selectedFiles() if fexists(x)] if selected: try: with BusyProgressDialog(parent=self.session) as progress: for path in selected: progress.setWindowTitle('Importing {0}...'.format( os.path.basename(path))) worker = DescriptionsLoader( path, self.session.project, self.session) worker.run() except Exception as e: msgbox = QtWidgets.QMessageBox(self.session) msgbox.setDetailedText(format_exception(e)) msgbox.setIconPixmap( QtGui.QIcon( ':/icons/48/ic_error_outline_black').pixmap(48)) msgbox.setStandardButtons(QtWidgets.QMessageBox.Close) msgbox.setText( 'Eddy could not import all the selected files!') msgbox.setWindowIcon(QtGui.QIcon(':/icons/128/ic_eddy')) msgbox.setWindowTitle('Import failed!') msgbox.exec_()
def mkdir(path): """ Create the directory identified by the given path if it doesn't exists. :type path: str """ if not isdir(path): os.mkdir(expandPath(path))
def doNewProject(self): """ Bring up a modal window used to create a new project. """ form = NewProjectDialog(self) if form.exec_() == NewProjectDialog.Accepted: self.sgnCreateSession.emit(expandPath(form.pathField.value()))
def find_spec(cls, file_or_directory): """ Searches the given file or directory for a 'plugin.spec' file and tries to load it, or returns 'None' if no such file exists. :type file_or_directory: str :rtype: PluginSpec """ file_or_directory = expandPath(file_or_directory) try: if os.path.exists(file_or_directory) and os.access( file_or_directory, os.R_OK): # READ SPEC FILE FROM DIRECTORY if isdir(file_or_directory): plugin_spec_path = os.path.join(file_or_directory, 'plugin.spec') if fexists(plugin_spec_path): return cls.spec(fread(plugin_spec_path)) # READ SPEC FILE FROM ZIP ARCHIVE elif is_zipfile(file_or_directory): zf = ZipFile(file_or_directory) zf_name_list = zf.namelist() if 'plugin.spec' in zf_name_list: plugin_spec_content = zf.read('plugin.spec').decode( 'utf8') return cls.spec(plugin_spec_content) except Exception as e: LOGGER.exception('Failed to load plugin spec: %s', e)
def doNewProject(self): """ Bring up a modal window used to create a new project. """ form = ProjectDialog(self) if form.exec_() == ProjectDialog.Accepted: self.sgnCreateSession.emit(expandPath(form.pathField.value()))
def test_export_diagram_to_pdf(self, _): # GIVEN self.session.sgnFocusDiagram.emit(self.project.diagram('diagram')) # WHEN worker = PdfDiagramExporter(self.session.mdi.activeDiagram(), self.session) worker.run(expandPath('@tests/.tests/diagram.pdf')) # THEN self.assertFileExists('@tests/.tests/diagram.pdf')
def getPath(self, section, option): """ Get the content of the given section/option performing path expansion. :type section: str :type option: str :rtype: str """ return expandPath(self.get(section, option))
def faccess(path, mode=os.R_OK): """ Returns whether the given path is accessible with the given mode. :type path: str :type mode: int :rtype: bool """ return os.access(expandPath(path), mode)
def doOpenProject(self, path): """ Open a recent project in a new session of Eddy. :type path: str """ if not self.pending: self.pending = True self.sgnCreateSession.emit(expandPath(path))
def test_load_project_from_graphol_v3(session, qtbot, tmpdir): # GIVEN graphol = tmpdir.join('MovieOntology/MovieOntology_v3.graphol') grapholDir = tmpdir.join('MovieOntology') mkdir(str(grapholDir)) os.open(str(graphol), os.O_CREAT) fcopy( expandPath( '@tests/test_resources/loaders/graphol/v3/MovieOntology/MovieOntology_v3.graphol' ), str(graphol)) project = session.project diagram1 = 'movie' diagram2 = 'territory' with qtbot.waitSignal(session.sgnDiagramFocused): session.sgnFocusDiagram.emit(project.diagram('diagram')) # WHEN loader = GrapholIRIProjectLoader_v3(str(graphol), session) loader.run() # THEN assert diagram1 in map(lambda d: d.name, loader.session.project.diagrams()) assert len(loader.session.project.diagram(diagram1).nodes()) == 347 assert len(loader.session.project.diagram(diagram1).edges()) == 433 assert len( list( filter(lambda n: n.type() == Item.ConceptIRINode, loader.session.project.diagram(diagram1).nodes()))) == 65 assert len( list( filter(lambda n: n.type() == Item.RoleIRINode, loader.session.project.diagram(diagram1).nodes()))) == 60 assert len( list( filter(lambda n: n.type() == Item.AttributeIRINode, loader.session.project.diagram(diagram1).nodes()))) == 27 assert len( list( filter(lambda n: n.type() == Item.IndividualIRINode, loader.session.project.diagram(diagram1).nodes()))) == 0 assert diagram2 in map(lambda d: d.name, loader.session.project.diagrams()) assert len(loader.session.project.diagram(diagram2).nodes()) == 8 assert len(loader.session.project.diagram(diagram2).edges()) == 8 assert len( list( filter(lambda n: n.type() == Item.ConceptIRINode, loader.session.project.diagram(diagram2).nodes()))) == 2 assert len( list( filter(lambda n: n.type() == Item.RoleIRINode, loader.session.project.diagram(diagram2).nodes()))) == 2 assert len( list( filter(lambda n: n.type() == Item.AttributeIRINode, loader.session.project.diagram(diagram2).nodes()))) == 0 assert len( list( filter(lambda n: n.type() == Item.IndividualIRINode, loader.session.project.diagram(diagram2).nodes()))) == 0
def start(self, options): """ Run the application by showing the welcome dialog. :type options: Namespace """ self.welcome = Welcome(self) self.welcome.show() if options.open and isdir(options.open): self.sgnCreateSession.emit(expandPath(options.open))
def fread(path): """ Read the file identified by the given 'path' and returns its content. :type path: str :rtype: str """ path = expandPath(path) with io.open(path, 'r', encoding='utf8') as ptr: return ptr.read()
def test_import_single_module_plugin_from_directory(): # GIVEN plugin_path = expandPath('@tests/test_resources/plugins/dir/testplugin1') # WHEN spec, plugin_path, plugin_class = PluginManager.import_plugin_from_path(plugin_path) # THEN assert spec is not None assert plugin_path is not None assert plugin_class is None assert 'testplugin1' == spec.get('plugin', 'id')
def find_qt_menu_nib(self): """ Returns the location of the qt_menu.nib. """ if self.qt_menu_nib: return self.qt_menu_nib path = expandPath(os.path.join(QT_BASE_PATH, 'Src/qtbase/src/plugins/platforms/cocoa/qt_menu.nib')) if os.path.exists(path): return path raise IOError("could not find qt_menu.nib: please install Qt5 source components")
def test_import_multi_module_plugin_from_zip(): # GIVEN plugin_path = expandPath('@tests/test_resources/plugins/zip/testplugin2.zip') # WHEN spec, plugin_path, plugin_class = PluginManager.import_plugin_from_path(plugin_path) # THEN assert spec is not None assert plugin_path is not None assert plugin_class is None assert 'testplugin2' == spec.get('plugin', 'id')
def make_zip(self): """ Create a ZIP distribution. """ zippath = os.path.join(self.dist_dir, '%s.zip' % DIST_NAME) with zipfile.ZipFile(zippath, 'w', zipfile.ZIP_DEFLATED) as zipf: for root, dirs, files in os.walk(self.build_exe): for filename in files: path = expandPath(os.path.join(root, filename)) arcname = os.path.join(DIST_NAME, os.path.relpath(path, self.build_exe)) zipf.write(path, arcname)
def finalize_options(self): """Finalize command options.""" if self.workpath is None: self.workpath = WORK_PATH if self.distpath is None: self.distpath = DIST_PATH if self.dist_dir is None: self.dist_dir = DIST_DIR if self.applications_shortcut is None: self.applications_shortcut = 1 if self.volume_label is None: self.volume_label = '%s %s' % (APPNAME, VERSION) if self.volume_background is None: self.volume_background = expandPath( '@resources/images/macos_background_dmg.png') if self.volume_icon is None: self.volume_icon = expandPath( '@resources/images/macos_icon_dmg.icns') if self.skip_build is None: self.skip_build = 0
def findJavaHome(): """ Locate and return the path to a valid JRE installation, or None if no such path can be found. :rtype: str """ # LOOK FOR BUNDLED JRE FIRST if os.path.isdir(expandPath('@resources/java/')): return expandPath('@resources/java/') # PREFER USER-SPECIFIED JAVA_HOME IF AVAILABLE if os.getenv('JAVA_HOME'): return os.getenv('JAVA_HOME') # JPype offers a nice utility to find Java from known locations if JniLib.JPYPE in _jvmLibraries: from jpype import ( getDefaultJVMPath, JVMNotFoundException, JVMNotSupportedException, ) try: jni_lib = getDefaultJVMPath() # Try to locate the root of the Java installation walking # the path backwards and checking for the existence # of the `java` executable. dirname, filename = os.path.split(jni_lib) java_exe = os.path.join('bin', 'java' if not IS_WIN else 'java.exe') while dirname != os.path.dirname(dirname): parent, subdir = os.path.split(dirname) if os.path.isfile(os.path.join(dirname, java_exe)): return parent if subdir == 'jre' else dirname dirname, filename = parent, subdir except JVMNotFoundException as e: LOGGER.error('Unable to locate JAVA_HOME', exc_info=e) except JVMNotSupportedException as e: LOGGER.exception('Found unsupported JVM', exc_info=e) except Exception as e: LOGGER.exception('Could not find JAVA_HOME', exc_info=e) # FALLBACK TO OTHER COMMON VARIABLES return os.getenv('JRE_HOME', os.getenv('JDK_HOME'))
def fwrite(content, path): """ Safely write the given 'content' in the file identified by the given 'path'. If the given path identifies an already existing file, its content is not truncated unless the writing operation is completed successfully. :type content: T <= bytes|str|unicode :type path: str """ components = os.path.split(expandPath(path)) stage = os.path.join(components[0], '.{0}'.format(components[1])) with io.open(stage, 'w', encoding='utf8') as ptr: ptr.write(content) fremove(path) frename(stage, path)
def buildDMG(self): """ Build the DMG image. """ if not isdir('@support/createdmg') or not fexists('@support/createdmg/create-dmg'): raise OSError('unable to find create-dmg utility: please clone Eddy with all its submodules' ) if fexists(self.dmgName): os.unlink(self.dmgName) stagingDir = os.path.join(self.buildDir, 'tmp') if isdir(stagingDir): rmdir(stagingDir) self.mkpath(stagingDir) # Move the app bundle into a separate folder that will be used as source folder for the DMG image if subprocess.call(['cp', '-R', self.bundleDir, stagingDir]) != 0: raise OSError('could not move app bundle in staging directory') # We create the DMG disk image using the create-dmg submodule. params = [expandPath('@support/createdmg/create-dmg')] params.extend(['--volname', self.volume_label]) params.extend(['--text-size', '12']) params.extend(['--icon-size', '48']) params.extend(['--icon', '{0}.app'.format(self.bundleName), '60', '50']) params.extend(['--hide-extension', '{0}.app'.format(self.bundleName)]) if self.applications_shortcut: params.extend(['--app-drop-link', '60', '130']) if self.volume_background: if not fexists(self.volume_background): raise OSError('DMG volume background image not found at {0}'.format(self.volume_background)) print('Using DMG volume background: {0}'.format(self.volume_background)) from PIL import Image w, h = Image.open(self.volume_background).size params.extend(['--background', self.volume_background, '--window-size', str(w), str(h)]) if self.volume_icon: if not fexists(self.volume_icon): raise OSError('DMG volume icon not found at {0}'.format(self.volume_icon)) print('Using DMG volume icon: {0}'.format(self.volume_icon)) params.extend(['--volicon', self.volume_icon]) params.extend([self.dmgName, stagingDir]) subprocess.call(params) rmdir(stagingDir)
def make_win32(self): """ Makes sure text files from directory have 'Windows style' end of lines. """ if sys.platform == 'win32': for root, dirs, files in os.walk(self.build_exe): for filename in files: path = expandPath(os.path.join(root, filename)) if not isdir(path) and path.rsplit('.', 1)[-1] in ('txt', 'md'): with open(path, mode='rb') as f: data = f.read() new_data = re.sub("\r?\n", "\r\n", data.decode(encoding='UTF-8')) if new_data != data: with open(path, mode='wb') as f: f.write(new_data.encode(encoding='UTF-8'))
def __init__(self, path, prefix, iri, profile, session=None): """ Initialize the graphol project. :type path: str :type prefix: str :type iri: str :type profile: AbstractProfile :type session: Session """ super().__init__(session) self.index = ProjectIndex() self.iri = iri self.path = expandPath(path) self.prefix = prefix self.profile = profile self.profile.setParent(self)
def choosePath(self): """ Bring up a modal window that allows the user to choose a valid workspace path. """ path = self.workspaceField.value() if not isPathValid(path): path = expandPath('~') dialog = QtWidgets.QFileDialog(self) dialog.setAcceptMode(QtWidgets.QFileDialog.AcceptOpen) dialog.setDirectory(path) dialog.setFileMode(QtWidgets.QFileDialog.Directory) dialog.setOption(QtWidgets.QFileDialog.ShowDirsOnly, True) dialog.setViewMode(QtWidgets.QFileDialog.Detail) if dialog.exec_() == QtWidgets.QFileDialog.Accepted: self.workspaceField.setValue(first(dialog.selectedFiles()))
def selectPlugin(self): """ Bring up a modal window that allows the user to choose a valid plugin archive. """ path = os.path.dirname(self.pluginField.value()) if not isPathValid(path): path = expandPath('~') dialog = QtWidgets.QFileDialog(self) dialog.setAcceptMode(QtWidgets.QFileDialog.AcceptOpen) dialog.setDirectory(path) dialog.setFileMode(QtWidgets.QFileDialog.ExistingFile) dialog.setViewMode(QtWidgets.QFileDialog.Detail) dialog.setNameFilters([File.Zip.value]) if dialog.exec_() == QtWidgets.QFileDialog.Accepted: self.pluginField.setValue(first(dialog.selectedFiles())) self.confirmationBox.setEnabled(not isEmpty(self.pluginField.value()))
def setUp(self): """ Initialize test case environment. """ # MAKE SURE TO USE CORRECT SETTINGS settings = QtCore.QSettings(ORGANIZATION, APPNAME) settings.setValue('workspace/home', WORKSPACE) settings.setValue('update/check_on_startup', False) settings.sync() # MAKE SURE THE WORKSPACE DIRECTORY EXISTS mkdir(expandPath(WORKSPACE)) # MAKE SURE TO HAVE A CLEAN TEST ENVIRONMENT rmdir('@tests/.tests/') mkdir('@tests/.tests/') # INITIALIZED VARIABLES self.eddy = None self.project = None self.session = None
def __init__(self, project, parent=None): """ Initialize the project block. :type project: str :type parent: QtWidgets.QWidget """ super().__init__(parent) self.nameLabel = QtWidgets.QLabel(os.path.basename(project), self) self.nameLabel.setContentsMargins(20, 0, 20, 0) self.nameLabel.setProperty('class', 'name') self.nameLabel.setFont(Font('Roboto', 12, bold=True)) self.pathLabel = QtWidgets.QLabel(compressPath(shortPath(project), 34), self) self.pathLabel.setContentsMargins(20, 0, 20, 0) self.pathLabel.setProperty('class', 'path') self.pathLabel.setFont(Font('Roboto', 12)) self.deleteBtn = PHCQPushButton(self) self.deleteBtn.setIcon(QtGui.QIcon(':/icons/24/ic_delete_black')) self.deleteBtn.setVisible(not isSubPath(expandPath('@examples/'), project)) connect(self.deleteBtn.clicked, self.onDeleteButtonClicked) self.leftWidget = QtWidgets.QWidget(self) self.leftWidget.setContentsMargins(0, 0, 0, 0) self.leftLayout = QtWidgets.QVBoxLayout(self.leftWidget) self.leftLayout.setContentsMargins(0, 0, 0, 0) self.leftLayout.setSpacing(0) self.leftLayout.addWidget(self.nameLabel) self.leftLayout.addWidget(self.pathLabel) self.rightWidget = QtWidgets.QWidget(self) self.rightWidget.setContentsMargins(0, 0, 10, 0) self.rightLayout = QtWidgets.QVBoxLayout(self.rightWidget) self.rightLayout.setContentsMargins(0, 0, 0, 0) self.rightLayout.setSpacing(0) self.rightLayout.addWidget(self.deleteBtn) self.mainLayout = QtWidgets.QHBoxLayout(self) self.mainLayout.setContentsMargins(0, 0, 0, 0) self.mainLayout.addWidget(self.leftWidget) self.mainLayout.addWidget(self.rightWidget, 1, QtCore.Qt.AlignRight) self.setContentsMargins(0, 0, 0, 0) self.setFixedHeight(40) self.path = project
from eddy.core.functions.fsystem import mkdir, rmdir from eddy.core.functions.path import expandPath from PyQt5 import QtCore ################################### # SETUP CONSTANTS DECLARATION ########################### LINUX = sys.platform.startswith('linux') MACOS = sys.platform.startswith('darwin') WIN32 = sys.platform.startswith('win32') BUILD_DIR = os.path.join(expandPath(os.path.dirname(__file__)), 'build') DIST_DIR = os.path.join(expandPath(os.path.dirname(__file__)), 'dist') DIST_NAME = '%s-%s-%s_%s' % (APPNAME, VERSION, platform.system().lower(), platform.machine().lower()) DIST_PATH = os.path.join(BUILD_DIR, DIST_NAME) EXEC_BASE = None EXEC_ICON = None EXEC_NAME = None if LINUX: EXEC_BASE = None EXEC_ICON = expandPath('@resources/images/eddy.png') EXEC_NAME = APPNAME if MACOS: EXEC_BASE = None EXEC_ICON = expandPath('@resources/images/eddy.icns')
def assertFileExists(self, filepath, msg=None): """Assert for the given path to represent a file""" if not fexists(filepath): standardMsg = '%s is not a file' % safe_repr(expandPath(filepath)) self.fail(self._formatMessage(msg, standardMsg))
def assertDirectoryExists(self, dirpath, msg=None): """Assert for the given path to represent a file""" if not isdir(dirpath): standardMsg = '%s is not a directory' % safe_repr(expandPath(dirpath)) self.fail(self._formatMessage(msg, standardMsg))
import jnius_config import os import sys from eddy.core.functions.path import expandPath from eddy.core.functions.fsystem import cpdir, isdir, mkdir, rmdir, fexists LINUX = sys.platform.startswith('linux') MACOS = sys.platform.startswith('darwin') WIN32 = sys.platform.startswith('win32') ############################################# # BEGIN JAVA VIRTUAL MACHINE SETUP ################################# if os.path.isdir(expandPath('@resources/java/')): os.environ['JAVA_HOME'] = expandPath('@resources/java/') if WIN32: path = os.getenv('Path', '') path = path.split(os.pathsep) path.insert(0, os.path.join(os.environ['JAVA_HOME'], 'bin', 'client')) os.environ['Path'] = os.pathsep.join(path) classpath = [] resources = expandPath('@resources/lib/') for name in os.listdir(resources): path = os.path.join(resources, name) if os.path.isfile(path): classpath.append(path)