예제 #1
0
def filled_database():
    database = Database('sqlite:///:memory:')
    for i in range(1, 11):
        entry = DatabaseEntry()
        database.add(entry)
        # every fourth entry gets the tag 'foo'
        if i % 4 == 0:
            database.tag(entry, 'foo')
        # every fifth entry gets the tag 'bar'
        if i % 5 == 0:
            database.tag(entry, 'bar')
    database.commit()
    return database
예제 #2
0
def filled_database():
    database = Database('sqlite:///:memory:')
    for i in xrange(1, 11):
        entry = DatabaseEntry()
        database.add(entry)
        # every fourth entry gets the tag 'foo'
        if i % 4 == 0:
            database.tag(entry, 'foo')
        # every fifth entry gets the tag 'bar'
        if i % 5 == 0:
            database.tag(entry, 'bar')
    database.commit()
    return database
예제 #3
0
def split_function_database():
    """
    Generates a custom database to test the split_database function
    """
    database = Database('sqlite:///:memory:')
    for i in range(1, 11):
        entry = DatabaseEntry()
        database.add(entry)
        # every fourth entry gets the instrument 'EIA'
        if i % 4 == 0:
            database.edit(entry, instrument='EIA')
        # every fifth entry gets the instrument 'AIA_3'
        elif i % 5 == 0:
            database.edit(entry, instrument='AIA_3')
        # every other entry gets instrument 'RHESSI'
        else:
            database.edit(entry, instrument='RHESSI')
        # all  entries have provider 'xyz'
        database.edit(entry, provider='xyz')
    database.commit()
    return database
예제 #4
0
def split_function_database():
    """
    Generates a custom database to test the split_database function
    """
    database = Database('sqlite:///:memory:')
    for i in range(1, 11):
        entry = DatabaseEntry()
        database.add(entry)
        # every fourth entry gets the instrument 'EIA'
        if i % 4 == 0:
            database.edit(entry, instrument='EIA')
        # every fifth entry gets the instrument 'AIA_3'
        elif i % 5 == 0:
            database.edit(entry, instrument='AIA_3')
        # every other entry gets instrument 'RHESSI'
        else:
            database.edit(entry, instrument='RHESSI')
        # all  entries have provider 'xyz'
        database.edit(entry, provider='xyz')
    database.commit()
    return database
예제 #5
0
class DownloadResultController(ToolController):
    queries = {}
    app_ctrl: AppController = RequiredFeature(AppController.__name__)
    content_ctrl: ContentController = RequiredFeature(ContentController.name)

    def __init__(self):
        self._view = QtWidgets.QWidget()
        self._ui = Ui_DownloadResult()
        self._ui.setupUi(self._view)

        self._ui.tabs.clear()
        self._ui.tabs.tabCloseRequested.connect(self._onRemoveTab)

        self.database = Database()

        self.tabs = {}
        self.queries = {}
        self.query_id = 0
        self.loading = []
        self.loaded = {
            entry.fileid: entry.path
            for entry in list(self.database)
        }

        self._ui.download_button.clicked.connect(
            lambda evt: self._onDownloadSelected())
        self._ui.open_button.clicked.connect(
            lambda evt: self._onOpenSelected())

    def query(self, attrs):
        # open tool if not already opened
        self.app_ctrl.openController(self.name)

        self.query_id += 1

        # add pending tab
        tab = ResultTab(self.query_id)
        self.tabs[self.query_id] = tab
        index = self._ui.tabs.addTab(tab, "Query " + str(self.query_id))
        self._ui.tabs.setCurrentIndex(index)
        # start query
        executeTask(Fido.search, attrs, self._onQueryResult, [self.query_id])
        # register events
        tab.download.connect(
            lambda f_id, q_id=self.query_id: self.download(q_id, f_id))
        tab.open.connect(lambda f_id: self._onOpen(f_id))

    def _onQueryResult(self, query, id):
        if id not in self.tabs:
            return
        query_model = self._convertQuery(query)
        self.tabs[id].loadQuery(query_model)
        self.tabs[id].setLoading(self.loading)
        self.tabs[id].setLoaded(self.loaded.keys())
        self.queries[id] = query

    def download(self, q_id, f_id):
        req = copy.copy(self.queries[q_id])
        req._list = [copy.copy(r) for r in req]
        for resp in req:
            resp[:] = [item for item in resp if item.fileid == f_id]

        self._addLoading([f_id])
        executeTask(Fido.fetch, [req], self._onDownloadResult, [f_id, req])

    def _onDownloadResult(self, paths, f_id, request):
        path = paths[0]
        entry = list(
            tables.entries_from_fido_search_result(
                request, self.database.default_waveunit))[0]
        entry.path = path
        self.database.add(entry)
        self.database.commit()
        self._addLoaded({f_id: path})

    def _onOpen(self, f_id):
        viewer = MapViewerController.fromFile(self.loaded[f_id])
        self.content_ctrl.addViewerController(viewer)

    def _onRemoveTab(self, index):
        tab = self._ui.tabs.widget(index)
        self._ui.tabs.removeTab(index)
        self.tabs.pop(tab.q_id)

    def _onDownloadSelected(self):
        tab = self._ui.tabs.currentWidget()
        f_ids = tab.getSelectedFIds()
        for f_id in f_ids:
            if f_id in self.loading or f_id in self.loaded:
                continue
            self.download(tab.q_id, f_id)

    def _onOpenSelected(self):
        tab = self._ui.tabs.currentWidget()
        f_ids = tab.getSelectedFIds()
        for f_id in f_ids:
            if f_id not in self.loaded:
                continue
            self._onOpen(f_id)

    def _convertQuery(self, query):
        items = [item for response in query for item in response]
        return [[c[1](item) for c in columns] for item in items]

    def _addLoading(self, f_ids):
        self.loading.extend(f_ids)
        for tab in self.tabs.values():
            tab.setLoading(f_ids)

    def _addLoaded(self, dict):
        self.loading = [
            f_id for f_id in self.loading if f_id not in dict.keys()
        ]
        self.loaded.update(dict)
        for tab in self.tabs.values():
            tab.setLoaded(dict.keys())

    @property
    def item_config(self) -> ItemConfig:
        return ItemConfig().setTitle("Download Results").setOrientation(
            QtCore.Qt.BottomDockWidgetArea)

    @property
    def view(self) -> QtWidgets:
        return self._view
예제 #6
0
class DataManagerController(ToolController):
    content_ctrl: ContentController = RequiredFeature(ContentController.name)

    def __init__(self):
        self._view = QtWidgets.QWidget()
        self._ui = Ui_DataManager()
        self._ui.setupUi(self._view)

        self._ui.refresh_button.setIcon(self._view.style().standardIcon(
            QStyle.SP_BrowserReload))
        self._ui.remove_button.setIcon(self._view.style().standardIcon(
            QStyle.SP_DialogNoButton))
        self._ui.add_button.setIcon(self._view.style().standardIcon(
            QStyle.SP_DialogYesButton))

        self.dlg = DataManagerFilterDialog()

        db = QtSql.QSqlDatabase.addDatabase('QSQLITE')
        db.setDatabaseName(
            sunpy.config.get("database", "url").replace("sqlite:///", ""))

        model = QtSql.QSqlTableModel()
        model.setTable("data")
        model.setEditStrategy(QtSql.QSqlTableModel.OnFieldChange)
        model.select()
        self._ui.data_table.setModel(model)

        self.initTableHeader(model)

        self._ui.add_button.clicked.connect(lambda x: self.onAdd())
        self._ui.remove_button.clicked.connect(lambda x: self.onRemove())
        self._ui.open_button.clicked.connect(lambda x: self.onOpen())
        self._ui.refresh_button.clicked.connect(lambda x: self.model.select())
        self._ui.filter_button.clicked.connect(lambda x: self.onFilter())

        self.sunpy_db = Database()
        self.model = model

    def initTableHeader(self, model):
        header = self._ui.data_table.horizontalHeader()
        for i in range(model.columnCount()):
            header.setSectionResizeMode(i,
                                        QtWidgets.QHeaderView.ResizeToContents)
        header.setContextMenuPolicy(QtCore.Qt.CustomContextMenu)
        header.customContextMenuRequested.connect(self.onHeaderMenu)
        self._ui.data_table.setContextMenuPolicy(QtCore.Qt.CustomContextMenu)
        self._ui.data_table.customContextMenuRequested.connect(
            self.onHeaderMenu)

        self._ui.data_table.hideColumn(0)
        self._ui.data_table.hideColumn(2)
        self._ui.data_table.hideColumn(3)
        self._ui.data_table.hideColumn(4)
        self._ui.data_table.hideColumn(8)
        self._ui.data_table.hideColumn(11)
        self._ui.data_table.hideColumn(12)
        self._ui.data_table.hideColumn(13)
        self._ui.data_table.hideColumn(14)

    def onAdd(self):
        paths, _ = QtWidgets.QFileDialog.getOpenFileNames(
            None, filter="FITS files (*.fits; *.fit; *.fts)")
        for p in paths:
            self.sunpy_db.add_from_file(p)
            self.sunpy_db.commit()
        self.model.select()

    def onRemove(self):
        rows = set([i.row() for i in self._ui.data_table.selectedIndexes()])
        for r in rows:
            self.model.removeRow(r)
        self.model.submitAll()
        self.model.select()

    def onOpen(self):
        rows = set([i.row() for i in self._ui.data_table.selectedIndexes()])
        paths = [
            self.model.index(row, self.model.fieldIndex("path")).data()
            for row in rows
        ]
        for path in paths:
            viewer_ctrl = MapViewerController.fromFile(path)
            self.content_ctrl.addViewerController(viewer_ctrl)

    def onFilter(self):
        if self.dlg.exec_():
            self.model.setFilter(self.dlg.getFilter())
            self.model.select()

    def onHeaderMenu(self, point):
        menu = QMenu(self._view)

        actions = []
        for column in range(self.model.columnCount()):
            label = self.model.headerData(column, QtCore.Qt.Horizontal)
            action = QtWidgets.QAction(label)
            action.setCheckable(True)
            action.setChecked(not self._ui.data_table.isColumnHidden(column))
            event = lambda checked, c=column: self._ui.data_table.showColumn(
                c) if checked else self._ui.data_table.hideColumn(c)
            action.triggered.connect(event)
            actions.append(action)
        menu.addActions(actions)

        menu.exec_(QCursor.pos())

    @property
    def item_config(self) -> ItemConfig:
        return ItemConfig().setMenuPath("File/Data Manager").setTitle(
            "Data Manager")

    @property
    def view(self) -> QWidget:
        self.model.select()
        return self._view