def exportAll(self, file_path: QUrl, notify_progress: Optional["Signal"] = None) -> None: """ Export all materials to a certain file path. :param file_path: The path to export the materials to. """ registry = CuraContainerRegistry.getInstance() # Create empty archive. try: archive = zipfile.ZipFile(file_path.toLocalFile(), "w", compression=zipfile.ZIP_DEFLATED) except OSError as e: Logger.log( "e", f"Can't write to destination {file_path.toLocalFile()}: {type(e)} - {str(e)}" ) error_message = Message(text=catalog.i18nc( "@message:text", "Could not save material archive to {}:").format( file_path.toLocalFile()) + " " + str(e), title=catalog.i18nc( "@message:title", "Failed to save material archive"), message_type=Message.MessageType.ERROR) error_message.show() return materials_metadata = registry.findInstanceContainersMetadata( type="material") for index, metadata in enumerate(materials_metadata): if notify_progress is not None: progress = index / len(materials_metadata) notify_progress.emit(progress) if metadata["base_file"] != metadata[ "id"]: # Only process base files. continue if metadata[ "id"] == "empty_material": # Don't export the empty material. continue material = registry.findContainers(id=metadata["id"])[0] suffix = registry.getMimeTypeForContainer( type(material)).preferredSuffix filename = metadata["id"] + "." + suffix try: archive.writestr(filename, material.serialize()) except OSError as e: Logger.log( "e", f"An error has occurred while writing the material \'{metadata['id']}\' in the file \'{filename}\': {e}." )
def save(self, filename: QUrl) -> None: logging.info("Exporting to %s", filename.toLocalFile()) f = open(filename.toLocalFile(), "wt") start_code = self.getSettingValue("start_code").strip() if start_code != "": f.write(start_code + "\n") dialect = PluginRegistry.getInstance().createInstance(GCodeDialect, "CompatibilityDialect") assert dialect is not None for move in self.getMoves(): f.write("%s\n" % (dialect.convertMove(move))) end_code = self.getSettingValue("end_code").strip() if end_code != "": f.write(end_code + "\n") f.close()
def removeBookmark(self, spath): if not self.written: return if not os.path.exists(self.config_path): self.written = False return url = pathlib.Path(spath).as_uri() settings_qt5 = QSettings(self.config_path, QSettings.IniFormat) shortcuts = ray.getListInSettings(settings_qt5, 'FileDialog/shortcuts') for sc in shortcuts: sc_url = QUrl(sc) if sc_url.isLocalFile() and sc_url.toLocalFile() == spath: shortcuts.remove(sc) break else: self.written = False return settings_qt5.setValue('FileDialog/shortcuts', shortcuts) settings_qt5.sync() self.written = False
def importProfile(self, file_url: QUrl) -> Dict[str, str]: if not file_url.isValid(): return {"status": "error", "message": catalog.i18nc("@info:status", "Invalid file URL:") + " " + str(file_url)} path = file_url.toLocalFile() if not path: return {"status": "error", "message": catalog.i18nc("@info:status", "Invalid file URL:") + " " + str(file_url)} return self._container_registry.importProfile(path)
def dropEvent(self, e): if len(e.mimeData().urls()) == 1: file = QUrl.toLocalFile(e.mimeData().urls()[0]) self.load_and_prep_query_mesh(DataSet._read(file)) else: error_dialog = QtWidgets.QErrorMessage(parent=self) error_dialog.showMessage("Please drag only one mesh at the time.")
def importProfile(self, file_url: QUrl) -> Dict[str, str]: if not file_url.isValid(): return {"status": "error", "message": catalog.i18nc("@info:status", "Invalid file URL:") + " " + str(file_url)} path = file_url.toLocalFile() if not path: return {"status": "error", "message": catalog.i18nc("@info:status", "Invalid file URL:") + " " + str(file_url)} return cura.CuraApplication.CuraApplication.getInstance().getContainerRegistry().importProfile(path)
def exportProfile(self, instance_id: str, file_url: QUrl, file_type: str) -> None: if not file_url.isValid(): return path = file_url.toLocalFile() if not path: return self._container_registry.exportProfile(instance_id, path, file_type)
def importProfile(self, file_url: QUrl): if not file_url.isValid(): return path = file_url.toLocalFile() if not path: return return self._container_registry.importProfile(path)
def make_bookmark(self, spath): if self.written: return if not os.path.exists(self.config_path): #do not write shortcuts if file was not created by Qt5 himself return url = pathlib.Path(spath).as_uri() settings_qt5 = QSettings(self.config_path, QSettings.IniFormat) if not settings_qt5.isWritable(): return shortcuts = ray.get_list_in_settings(settings_qt5, 'FileDialog/shortcuts') for sc in shortcuts: sc_url = QUrl(sc) if sc_url.isLocalFile() and sc_url.toLocalFile() == spath: return shortcuts.append(url) settings_qt5.setValue('FileDialog/shortcuts', shortcuts) settings_qt5.sync() self.written = True
def exportQualityChangesGroup(self, quality_changes_group: "QualityChangesGroup", file_url: QUrl, file_type: str) -> None: if not file_url.isValid(): return path = file_url.toLocalFile() if not path: return container_list = [n.getContainer() for n in quality_changes_group.getAllNodes() if n.getContainer() is not None] self._container_registry.exportQualityProfile(container_list, path, file_type)
def _readLocalFile(self, file: QUrl) -> None: from UM.FileHandler.ReadFileJob import ReadFileJob filename = file.toLocalFile() job = ReadFileJob( filename, handler=self, add_to_recent_files=self.getAddToRecentFilesHint(filename)) job.finished.connect(self._readWorkspaceFinished) job.start()
def dropEvent(self, event): """ Object Method Params: QDropEvent event -> the drop object Return: None This method is called when a drop event occurs. The CSS file's path is sent to StyleScreen.addStyle(). """ print(type(event)) url = QUrl(event.mimeData().urls()[0]) self.screen.addStyle(url.toLocalFile())
def _readLocalFile(self, file: QUrl, add_to_recent_files_hint: bool = True): # We need to prevent circular dependency, so do some just in time importing. from UM.Mesh.ReadMeshJob import ReadMeshJob filename = file.toLocalFile() job = ReadMeshJob(filename, add_to_recent_files=add_to_recent_files_hint) job.finished.connect(self._readMeshFinished) job.start()
def eemport(self): file_name = QFileDialog.getOpenFileUrl(self.centralwidget, caption="Open image settings as text.", filter="Text file (*.txt)", supportedSchemes=["txt"]) file_name = QUrl.toLocalFile(file_name[0]) if file_name != "": with open(file_name, "r") as f: d = literal_eval(f.read()) self.load_dict(d)
def _on_map_dir_chaged(self): url = QUrl(self.map_dir) map_dir = QDir(url.toLocalFile()).path() self.map_info = get_map_info(map_dir) self.map_size = round(max(self.map_info.size.w, self.map_info.size.h)) self.map_name = '{} ({}x{})'.format(self.map_info.name, self.map_info.size.w, self.map_info.size.h) self.dot_size = self._get_dot_size() self.preview = QUrl.fromLocalFile(self.map_info.preview).toString()
def _readLocalFile(self, file: QUrl, add_to_recent_files_hint: bool = True) -> None: from UM.FileHandler.ReadFileJob import ReadFileJob filename = file.toLocalFile() job = ReadFileJob(filename, handler=self, add_to_recent_files=add_to_recent_files_hint) job.finished.connect(self._readWorkspaceFinished) job.start()
def dropEvent(self, dropEvent): filepaths = [ Path(QUrl.toLocalFile(url)) for url in dropEvent.mimeData().urls() ] starting_lane_index = self.rowAt(dropEvent.pos().y()) # Last row is the button. if starting_lane_index == self.model().rowCount() - 1: starting_lane_index = -1 self.addFilesRequestedDrop.emit(filepaths, starting_lane_index)
def to_local_file(self, url: QUrl) -> str: """ Convert the given QUrl to its local path equivalent. >>> to_local_file("file:///home/username/nuxeo") /home/username/nuxeo >>> to_local_file("file:///C:/Users/username/nuxeo") C:\\Users\\username\\nuxeo """ return abspath(url.toLocalFile())
def exportQualityChangesGroup(self, quality_changes_group: "QualityChangesGroup", file_url: QUrl, file_type: str) -> None: if not file_url.isValid(): return path = file_url.toLocalFile() if not path: return container_registry = cura.CuraApplication.CuraApplication.getInstance().getContainerRegistry() container_list = [cast(InstanceContainer, container_registry.findContainers(id = quality_changes_group.metadata_for_global["id"])[0])] # type: List[InstanceContainer] for metadata in quality_changes_group.metadata_per_extruder.values(): container_list.append(cast(InstanceContainer, container_registry.findContainers(id = metadata["id"])[0])) cura.CuraApplication.CuraApplication.getInstance().getContainerRegistry().exportQualityProfile(container_list, path, file_type)
def _map_to_signal(self, url: QUrl): """ This slot delegates clicked link signal to show the same html as before (eg. link to a point in the term has been clicked) or to delegates the filename given in the link as emitted signal_link_clicked(filename) signal. """ if url.fileName() == "" and url.path() == "/": logging.debug(str(url)) self.ui.contentWebView.setHtml(self._html, url) else: self.signal_link_clicked.emit(url.toLocalFile().split("/")[-1])
def export(self): d = self.get_dict() default = QUrl(f"file:project.txt") file_name = QFileDialog.getSaveFileUrl(self.centralwidget, caption="Save image settings as text.", filter="Text file (*.txt)", directory=default, supportedSchemes=["txt"]) file_name = QUrl.toLocalFile(file_name[0]) if file_name != "": with open(file_name, "w") as f: f.write(str(d))
def urlToLocalFile(self, u: QtCore.QUrl) -> str: """Convert QUrl to local file name string Parameters ---------- u URL to convert Returns ------- File name """ return u.toLocalFile()
def parentUrl(self, u: QtCore.QUrl) -> QtCore.QUrl: """Get URL of directory containing `u` Parameters ---------- u URL to get parent directory for Returns ------- URL to `u`'s parent """ return QtCore.QUrl.fromLocalFile(str(Path(u.toLocalFile()).parent))
def dropEvent(self, event): #print(event.dropAction() == Qt.CopyAction) #url = QUrl() links = [] for url in event.mimeData().urls(): url = QUrl(url) links.append(url.toLocalFile()) sys.modules['scr.core'].core.copy(sys.modules['scr.core'].core, links, os.getcwd()) self.refresh()
def pasteCB(self): #CLIPBOARD print("paste") print(self.app.clipboard().mimeData().urls()) links = [] mimeurls = self.app.clipboard().mimeData().urls() for url in mimeurls: url = QUrl(url) links.append(url.toLocalFile()) cp = sys.modules['scr.core'].core.copy cp(sys.modules['scr.core'].core, self.sourceDir, links, os.getcwd()) self.refresh() pass
def requestPixmap(self, id, size): url = QUrl(id) query = QUrlQuery(url.query()) map_dir = QDir(url.toLocalFile()).path() dot_size = round(float(query.queryItemValue('dot_size'))) should_flip = query.queryItemValue('flip') in ['True', 'true'] opacity = round(float(query.queryItemValue('opacity'))) try: img, size = self._generate_heatmap(map_dir, dot_size, opacity) if should_flip: img = flip(img) p = QPixmap.fromImage(img.toqimage()) return p, size except Exception: return QPixmap(), QSize(-1, -1)
def exportAll(self, file_path: QUrl) -> None: """ Export all materials to a certain file path. :param file_path: The path to export the materials to. """ registry = CuraContainerRegistry.getInstance() archive = zipfile.ZipFile(file_path.toLocalFile(), "w", compression = zipfile.ZIP_DEFLATED) for metadata in registry.findInstanceContainersMetadata(type = "material"): if metadata["base_file"] != metadata["id"]: # Only process base files. continue if metadata["id"] == "empty_material": # Don't export the empty material. continue material = registry.findContainers(id = metadata["id"])[0] suffix = registry.getMimeTypeForContainer(type(material)).preferredSuffix filename = metadata["id"] + "." + suffix archive.writestr(filename, material.serialize())
def insertFromMimeData(self, mime): if mime.hasImage(): tag = datetime.datetime.now().time().strftime("%H%M%S") url = QUrl("dropped_image_" + str(tag)) self.dropImage(url, mime.imageData()) mime.imageData().save("/tmp/" + url.toString(), "png") elif mime.hasUrls(): for url in mime.urls(): info = QFileInfo(url.toLocalFile()) ext = info.suffix().lower().encode('latin-1') if ext in QImageReader.supportedImageFormats(): print(str(info.filePath())) self.dropImage(url, info.filePath()) else: self.dropTextFile(url) else: super().insertFromMimeData(mime)
def save(self): width = self.validate(self.label_18, validate_int, self.widthLineEdit.text(), positive=True) height = self.validate(self.label_19, validate_int, self.heightLineEdit.text(), positive=True) default = QUrl(f"file:{self.fileNameLineEdit.text()}") file_name = QFileDialog.getSaveFileUrl(self.centralwidget, caption="Save image as PNG or JPEG.", filter="PNG file (*.png);;JPEG file (*.jpg)", directory=default, supportedSchemes=["png", "jpg"]) file_name = QUrl.toLocalFile(file_name[0]) if file_name != "": img = self.img.copy() img.thumbnail((width, height)) img.save(file_name, quality=self.qualitySlider.value())
def importProfile(self, file_url: QUrl) -> Dict[str, str]: if not file_url.isValid(): return { "status": "error", "message": catalog.i18nc("@info:status", "Invalid file URL:") + " " + str(file_url) } path = file_url.toLocalFile() if not path: return { "status": "error", "message": catalog.i18nc("@info:status", "Invalid file URL:") + " " + str(file_url) } return self._container_registry.importProfile(path)
def convert(self, pathToFile): pathToFile = QUrl(pathToFile).toLocalFile() images = [] for i in self._listOfImg: url = QUrl() url.setUrl(i) if url.isLocalFile(): img = Image.open(url.toLocalFile()) else: img = Image.open(urlopen(i)) if img.mode == "RGBA": img = img.convert('RGB') images.append(img) images.pop(0).save(pathToFile, "PDF", append_images=images, save_all=True)
def _download_blocklist_url(self, url: QUrl) -> None: """Take a blocklist url and queue it for download. Args: url: url to download """ if url.scheme() == "file": # The URL describes a local file on disk if the url scheme is # "file://". We handle those as a special case. filename = url.toLocalFile() if os.path.isdir(filename): for entry in os.scandir(filename): if entry.is_file(): self._import_local(entry.path) else: self._import_local(filename) else: download = downloads.download_temp(url) self._in_progress.append(download) download.finished.connect( functools.partial(self._on_download_finished, download))
def saveAnalogSignals(self, data, fileurl): url = QUrl(fileurl) filename = url.toLocalFile() signals = data.analog_signals.T framerate = data.framerate samplerate = data.analogSamplerate nsamples = signals.shape[0] config = data.config displacement = signals[:,1] * config.displacement_scale load = signals[:,0] * config.force_scale outdata = np.zeros((nsamples, 4)) outdata[:, 0] = np.arange(nsamples) / samplerate outdata[:, 1] = np.arange(nsamples) * (framerate/samplerate) outdata[:, 2] = displacement outdata[:, 3] = load header = 'time(s) video_frame displacement(m) load(N)' format = ('%1.8e', '%8d', '%1.8e', '%1.8e') np.savetxt(filename, outdata, fmt=format, header = header)
def onAnchorClicked(self, url: QUrl): from notes.ui.MainWindow import MainWindow import webbrowser host = url.host() scheme = url.scheme() if scheme == "http" or scheme == "https": webbrowser.open(url.toString()) elif scheme == "notesmanager": url.setScheme("file") local_path = url.toLocalFile() query = QUrlQuery(url) uuid = query.queryItemValue("uuid") if local_path == self.notebook.attachment_base.filename: self.noteViewManager.openNote(self.noteViewManager.notebook.get_note_by_uuid(uuid)) else: spawn = MainWindow(None, local_path, uuid) spawn.show()
def saveImageSeries(self, data, analysis_overlay, frames, folder_url, frameRange=True, addAnalogSignalPlot=False): url = QUrl(folder_url) folder = url.toLocalFile() extension = '.png' frames = frames.toVariant() if frameRange: frames = range(*(int(s) for s in frames)) else: frames = [int(s) for s in frames] if addAnalogSignalPlot: width = data.image_width plot_height = int(data.image_height * 0.25) plot, plot_area = self.get_analog_signals_plot(data, width, plot_height) master_image = QImage(width, data.image_height + plot_height, QImage.Format_ARGB32) painter = QPainter(master_image) for frame in frames: filename = os.path.join(folder, '{:06d}{}'.format(frame, extension)) print ('Saving', filename) snapshot = self.get_frame_image(data, analysis_overlay, frame) if addAnalogSignalPlot: painter.drawImage(0,0, snapshot) painter.drawImage(0, data.image_height, plot) cursor_x = plot_area[0] + frame/data.nFrames * plot_area[2] cursor_y1 = data.image_height + plot_area[1] cursor_y2 = data.image_height + plot_area[1] + plot_area[3] painter.setPen(QColor(0,0,255)) painter.drawLine(cursor_x, cursor_y1, cursor_x, cursor_y2) img = master_image else: img = snapshot if not img.save(filename): print('Error saving image.') if addAnalogSignalPlot: painter.end()
def saveImage(self, data, analysis_overlay, frame, fileurl): url = QUrl(fileurl) filename = url.toLocalFile() img = self.get_frame_image(data, analysis_overlay, frame) if not img.save(filename): print('Error saving image.')
def _readLocalFile(self, file: QUrl) -> None: from UM.FileHandler.ReadFileJob import ReadFileJob job = ReadFileJob(file.toLocalFile(), handler = self) job.finished.connect(self._readWorkspaceFinished) job.start()
from PyQt5.QtCore import QUrl url = QUrl("file:///.file/id=6571367.36737433") f = url.toLocalFile() print f #print url.toString()