ScopeFoundry package

Subpackages

• ScopeFoundry.examples package
  • Subpackages
    • ScopeFoundry.examples.hardware package
      • Submodules
      • ScopeFoundry.examples.hardware.dummy_xy_stage module
      • Module contents
  • Submodules
  • ScopeFoundry.examples.example_gui module
  • ScopeFoundry.examples.example_xy_slowscan module
  • Module contents
• ScopeFoundry.scanning package
  • Submodules
  • ScopeFoundry.scanning.base_cartesian_scan module
  • ScopeFoundry.scanning.base_cartesian_scan_test module
  • Module contents

Submodules

ScopeFoundry.base_app module

Created on Jul 23, 2014

Modified by Ed Barnard UI enhancements by Ed Barnard, Alan Buckley

class ScopeFoundry.base_app.BaseApp(argv=[])

Bases: PyQt4.QtCore.QObject

exec_()

settings_load_ini(fname)

settings_load_ini_ask(dir=None)

Opens a Load dialogue asking the user which .ini file to load into our app settings. Loads settings from an .ini file.

settings_save_ini(fname, save_ro=True)

settings_save_ini_ask(dir=None, save_ro=True)

Opens a Save dialogue asking the user to select a save destination and give the save file a filename. Saves settings to an .ini file.

setup()

setup_console_widget(kernel=None)

Create and return console QWidget. If Jupyter / IPython is installed this widget will be a full-featured IPython console. If Jupyter is unavailable it will fallback to a pyqtgraph.console.ConsoleWidget.

If the app is started in an Jupyter notebook, the console will be connected to the notebook’s IPython kernel.

the returned console_widget will also be accessible as self.console_widget

In order to see the console widget, remember to insert it into an existing window or call self.console_widget.show() to create a new window

setup_logging()

class ScopeFoundry.base_app.BaseMicroscopeApp(argv=[])

Bases: ScopeFoundry.base_app.BaseApp

add_figure(name, widget)

add_hardware(hw)

Loads a HardwareComponent object into the app. After calling this, the HW appears in the Hardware tree.

If hw is a class, rather an instance, create an instance and add it to self.hardware

add_hardware_component(hw)

add_mdi_subwin(widget, name)

add_measurement(measure)

Loads a Measurement object into the app. After calling this, the measurement appears in the Measurement tree.

If measure is a class, rather an instance, create an instance and add it to self.measurements

add_measurement_component(measure)

add_pg_graphics_layout(name, widget)

add_quickbar(widget)

bring_mdi_subwin_to_front(subwin)

bring_measure_ui_to_front(measure)

cascade_layout()

Cascades subwindows in user interface. Specifically in the Multi Document Interface.

get_window_positions()

hardware_components

load_window_positions_json(fname)

logged_quantities

lq_path(path)

returns the lq based on path string of the form ‘domain/[component/]setting’ domain = “measurement”, “hardware” or “app”

lq_paths_list()

returns all logged_quantity paths as a list

mdi = True

Multiple Document Interface flag. Tells the app whether to include an MDI widget in the app.

measurement_components

name = 'ScopeFoundry'

The name of the microscope app, default is ScopeFoundry.

on_close()

on_hardware_tree_context_menu(position)

on_measure_tree_context_menu(position)

save_window_positions_json(fname)

set_subwindow_mode()

Switches Multiple Document Interface to Subwindowed viewing mode.

set_tab_mode()

Switches Multiple Document Interface to Tabbed viewing mode.

set_window_positions(positions)

settings_auto_save_ini()

Saves the ini file to the pre-defined directory with a time stamp in the filename.

settings_load_dialog()

Opens a load ini dialogue in the app user interface

settings_load_h5(fname)

Loads h5 settings given a filename.

Arguments:	Type:	Description:
fname	str	relative path to the filename of the h5 file.

settings_load_ini(fname)

Arguments:	Type:	Description:
fname	str	relative path to the filename of the ini file.

settings_load_last()

Loads last saved ini file.

settings_save_dialog()

Opens a save as ini dialogue in the app user interface.

settings_save_h5(fname)

Saves h5 file to a file.

Arguments:	Type:	Description:
fname	str	relative path to the filename of the h5 file.

settings_save_ini(fname, save_ro=True, save_app=True, save_hardware=True, save_measurements=True)

Arguments:	Type:	Description:
fname	str	relative path to the filename of the ini file.

setup()

Override to add Hardware and Measurement Components

setup_default_ui()

setup_ui()

Override to set up ui elements after default ui is built

show()

Tells Qt to show the user interface

tile_layout()

Tiles subwindows in user interface. Specifically in the Multi Document Interface.

class ScopeFoundry.base_app.LoggingQTextEditHandler(textEdit, level=0)

Bases: logging.Handler, PyQt4.QtCore.QObject

emit(record)

Do whatever it takes to actually log the specified logging record.

This version is intended to be implemented by subclasses and so raises a NotImplementedError.

format(record)

Format the specified record.

If a formatter is set, use it. Otherwise, use the default formatter for the module.

level_styles = {'CRITICAL': 'color: red;', 'DEBUG': 'color: green;', 'ERROR': 'color: red;', 'INFO': 'color: green;', 'NOTSET': '', 'WARNING': 'color: orange;'}

new_log_signal

on_new_log(log_entry)

ScopeFoundry.base_app.log_unhandled_exception(*exc_info)

ScopeFoundry.data_browser module

class ScopeFoundry.data_browser.DataBrowser(argv)

Bases: ScopeFoundry.base_app.BaseApp

auto_select_view(fname)

return the name of the last supported view for the given fname

load_view(new_view)

name = 'DataBrowser'

on_change_browse_dir()

on_change_data_filename()

on_change_file_filter()

on_change_view_name()

on_treeview_selection_change(sel, desel)

setup()

class ScopeFoundry.data_browser.DataBrowserView(databrowser)

Bases: PyQt4.QtCore.QObject

Abstract class for DataBrowser Views

is_file_supported(fname)

on_change_data_filename(fname=None)

setup()

class ScopeFoundry.data_browser.FileInfoView(databrowser)

Bases: ScopeFoundry.data_browser.DataBrowserView

is_file_supported(fname)

name = 'file_info'

on_change_data_filename(fname=None)

setup()

class ScopeFoundry.data_browser.HyperSpectralBaseView(databrowser)

Bases: ScopeFoundry.data_browser.DataBrowserView

is_file_supported(fname)

load_data(fname)

override to set hyperspectral dataset and the display image need to define:

• self.hyperspec_data (shape Ny, Nx, Nspec)
• self.display_image (shape Ny, Nx)
• self.spec_x_array (shape Nspec)

name = 'HyperSpectralBaseView'

on_change_data_filename(fname)

on_change_rect_roi(roi=None)

on_update_circ_roi(roi=None)

scan_specific_setup()

setup()

update_display()

class ScopeFoundry.data_browser.NPZView(databrowser)

Bases: ScopeFoundry.data_browser.DataBrowserView

is_file_supported(fname)

name = 'npz_view'

on_change_data_filename(fname=None)

setup()

ScopeFoundry.h5_io module

ScopeFoundry.h5_io.h5_base_file(app, fname=None, measurement=None)

ScopeFoundry.h5_io.h5_create_emd_dataset(name, h5parent, shape=None, data=None, maxshape=None, dim_arrays=None, dim_names=None, dim_units=None, **kwargs)

create an EMD dataset v0.2 inside h5parent returns an h5 group emd_grp

to access N-dim dataset: emd_grp[‘data’] to access a specific dimension array: emd_grp[‘dim1’]

• h5parent

  • name [emd_grp] (<–returned)

    • emd_group_type = 1

    D data [shape = shape] D dim1 [shape = shape[0]]

    • name
    • units

    … D dimN [shape = shape[-1]]

h5parent : parent HDF5 group

shape : Dataset shape of N dimensions. Required if “data” isn’t provided.

data : Provide data to initialize the dataset. If used, you can omit

shape and dtype arguments.

Keyword Args:

dtype : Numpy dtype or string. If omitted, dtype(‘f’) will be used.

Required if “data” isn’t provided; otherwise, overrides data array’s dtype.

dim_arrays : optional, a list of N dimension arrays

dim_names : optional, a list of N strings naming the dataset dimensions

dim_units : optional, a list of N strings specifying units of dataset dimensions

Other keyword arguments follow from h5py.File.create_dataset

emd_grp : h5 group containing dataset and dimension arrays, see hierarchy below

ScopeFoundry.h5_io.h5_create_measurement_group(measurement, h5group, group_name=None)

ScopeFoundry.h5_io.h5_save_app_lq(app, h5group)

ScopeFoundry.h5_io.h5_save_hardware_lq(app, h5group)

ScopeFoundry.h5_io.h5_save_lqcoll_to_attrs(settings, h5group)

take a LQCollection and create attributes inside h5group

Parameters:

• logged_quantities –
• h5group –

Returns:

None

ScopeFoundry.h5_io.h5_save_measurement_settings(measurement, h5_meas_group)

ScopeFoundry.hardware module

class ScopeFoundry.hardware.HardwareComponent(app, debug=False, name=None)

Bases: PyQt4.QtCore.QObject

HardwareComponent

Base class for ScopeFoundry Hardware objects

to subclass, implement setup(), connect() and disconnect()

add_logged_quantity(name, **kwargs)

add_operation(name, op_func)

Create an operation for the HardwareComponent.

op_func is a function that will be called upon operation activation

operations are typically exposed in the default ScopeFoundry gui via a pushButton

add_widgets_to_tree(tree)

connect()

Opens a connection to hardware and connects LoggedQuantity settings to related hardware functions and parameters

connection_failed

connection_succeeded

disconnect()

Disconnects the hardware and severs hardware–LoggedQuantity links

enable_connection(enable=True)

gui

new_control_widgets()

on_connection_failed()

on_connection_succeeded()

read_from_hardware()

Read all settings (LoggedQuantity) connected to hardware states

setup()

Runs during __init__, before the hardware connection is established Should generate desired LoggedQuantities, operations

thread_lock_all_lq()

thread_lock_lq(lq)

web_ui()

ScopeFoundry.helper_funcs module

class ScopeFoundry.helper_funcs.ConfirmCloseEventEater(title='Close ScopeFoundry?', message='Do you wish to shut down ScopeFoundry?', func_on_close=None)

Bases: PyQt4.QtCore.QObject

Tells the Qt to confirm the closing of the app by the user with a pop-up confirmation dialog.

eventFilter(obj, event)

Listens for QtCore.QEvent.Close signal and asks the user whether to close the app in a pop-up dialog.

class ScopeFoundry.helper_funcs.IgnoreCloseEventEater

Bases: PyQt4.QtCore.QObject

This class is utilized to prevent the closing of important subwindows and prevent the deletion of related python objects. Tells the Qt event manager to ignore calls to close the subwindow when user hits [x] on the subwindow.

eventFilter(self, QObject, QEvent) → bool

class ScopeFoundry.helper_funcs.LogLock(name)

Bases: object

acquire(blocking=True)

release()

class ScopeFoundry.helper_funcs.OrderedAttrDict

Bases: object

add(name, obj)

items()

keys()

values()

class ScopeFoundry.helper_funcs.QLock

Bases: PyQt4.QtCore.QMutex

acquire()

release()

ScopeFoundry.helper_funcs.confirm_on_close(widget, title='Close ScopeFoundry?', message='Do you wish to shut down ScopeFoundry?', func_on_close=None)

Calls the ConfirmCloseEventEater class which asks for user confirmation in a pop-up dialog upon closing the ScopeFoundry app.

ScopeFoundry.helper_funcs.get_logger_from_class(obj)

returns a named Logger from the logging package using the full name of the class of the object (obj) as the log name

ScopeFoundry.helper_funcs.ignore_on_close(widget)

Calls the IgnoreCloseEventEater class which intercepts the QtCore.QEvent.Close signal and prevents the deletion of subwindows and their associated objects.

ScopeFoundry.helper_funcs.load_qt_ui_file(ui_filename)

Loads a QT user interface file (files ending in .ui). This function is typically called from Measurement level modules.

ScopeFoundry.helper_funcs.print_all_connected(qobject, signal=None)

ScopeFoundry.helper_funcs.print_signals_and_slots(obj)

ScopeFoundry.helper_funcs.replace_spinbox_in_layout(old_widget, **kwargs)

ScopeFoundry.helper_funcs.replace_widget_in_layout(old_widget, new_widget, retain_font=True, retain_sizePolicy=True, retain_size=True)

Replace a widget with a new widget instance in an existing layout.

returns new_widget

Useful for replacing placeholder widgets created with QtCreator with custom widgets Note: currently works for widgets in QGridLayouts only

inspiration from: – http://stackoverflow.com/questions/4625102/how-to-replace-a-widget-with-another-using-qt – http://stackoverflow.com/questions/24189202/how-to-get-the-row-column-location-of-a-widget-in-a-qgridlayout

ScopeFoundry.helper_funcs.sibling_path(a, b)

Returns the path of a filename b in the same folder as a (i.e. dirname(a)/b )

Arguments:
a	directory name of pathname a
b	path suffix

Returns:combined path of above arguments.

ScopeFoundry.helper_funcs.str2bool(v)

ScopeFoundry.logged_quantity module

class ScopeFoundry.logged_quantity.ArrayLQ(name, dtype=<class 'float'>, hardware_read_func=None, hardware_set_func=None, initial=[], fmt='%g', si=True, ro=False, unit=None, vmin=-1000000000000.0, vmax=1000000000000.0, choices=None)

Bases: ScopeFoundry.logged_quantity.LoggedQuantity

array_tableView

change_shape(newshape)

coerce_to_type(x)

Force x to dtype of the LQ

Arguments	Description
x	value of type str, bool, int, etc.

Returns:Same value, x of the same type as its respective logged

quantity

connect_element_follower_lq(lq, index, bidir=True)

connects an LQ to follow the changes of the array and display a specific element

create_tableView(**kwargs)

ini_string_value()

Returns:A string showing the logged quantity value.

new_default_widget()

returns the approriate QWidget for the datatype of the LQ. automatically connects widget

same_values(v1, v2)

Compares two values of the LQ type, used in update_value

Arguments	Description
v1	value 1
v2	value 2

Returns:Boolean value (True or False)

send_display_updates(force=False)

Emit updated_value signals if value has changed.

Arguments	Description
force	will emit signals regardless of value change.

Returns:None

string_value()

updated_shape

class ScopeFoundry.logged_quantity.DummyLock

Bases: object

acquire()

release()

class ScopeFoundry.logged_quantity.FileLQ(name, default_dir=None, is_dir=False, **kwargs)

Bases: ScopeFoundry.logged_quantity.LoggedQuantity

Specialized str type LoggedQuantity that handles a filename (or directory) and associated file.

connect_to_browse_widgets(lineEdit, pushButton)

file_browser()

new_default_widget()

returns the approriate QWidget for the datatype of the LQ. automatically connects widget

class ScopeFoundry.logged_quantity.LQCircularNetwork(lq_dict)

Bases: PyQt4.QtCore.QObject

LQCircularNetwork is collection of logged quantities Helper class if a network of lqs with circular structures are present Use update_values_synchronously method if the specified lqs should be updated at once. The internal lock-flag prevents infinite loops.

update_values_synchronously(**kwargs)

kwargs is dict containing lq_key and new_vals Note: lq_key is not necessarily the name of the lq but key of lq_dict

as specified at initialization

updated_values

class ScopeFoundry.logged_quantity.LQCollection

Bases: object

LQCollection is a smart dictionary of LoggedQuantity objects.

attribute access such as lqcoll.x1 will return full LoggedQuantity object

dictionary-style access lqcoll[‘x1’] allows direct reading and writing of the LQ’s value, handling the signals automatically

New LQ’s can be created with New()

LQRange objects can be created with New_Range() and will be stored in :attr:ranges

Add(lq)

Add an existing LoggedQuantity to the Collection Examples of usefulness: add hardware lq to measurement settings

New(name, dtype=<class 'float'>, **kwargs)

Create a new LoggedQuantity with name and dtype

New_Range(name, include_center_span=False, **kwargs)

New_UI(include=None, exclude=[])

create a default Qt Widget that contains widgets for all settings in the LQCollection

add_widgets_to_subtree(tree_item)

as_dict()

as_list()

disconnect_all_from_hardware()

get_lq(key)

get_val(key)

keys()

remove(name)

class ScopeFoundry.logged_quantity.LQRange(min_lq, max_lq, step_lq, num_lq, center_lq=None, span_lq=None)

Bases: ScopeFoundry.logged_quantity.LQCircularNetwork

LQRange is a collection of logged quantities that describe a numpy.linspace array inputs. Four (or six) LQ’s are defined, min, max, num, step (center, span) and are connected by signals/slots that keep the quantities in sync. LQRange.array is the linspace array and is kept upto date with changes to the 4 (or 6) LQ’s

array

calc_center(min_, max_)

calc_max(center, span)

calc_min(center, span)

calc_num(min_, max_, step)

enforces num to be a positive integer and adjust step accordingly returns num,step

calc_span(min_, max_)

calc_step(min_, max_, num)

excludes num=1 to prevent division by zero, returns step

on_change_center_span()

on_change_min_max()

on_change_num()

on_change_step()

class ScopeFoundry.logged_quantity.LoggedQuantity(name, dtype=<class 'float'>, hardware_read_func=None, hardware_set_func=None, initial=0, fmt='%g', si=False, ro=False, unit=None, spinbox_decimals=2, spinbox_step=0.1, vmin=-1000000000000.0, vmax=1000000000000.0, choices=None, reread_from_hardware_after_write=False, description=None)

Bases: PyQt4.QtCore.QObject

LoggedQuantity objects are containers that wrap settings. These settings may be a number (integer or float) or a string and occasionally small arrays of them.

These objects emit signals when changed and can be connected bidirectionally to Qt Widgets.

In ScopeFoundry we represent the values in an object called a LoggedQuantity. A LoggedQuantity is a class that contains a value, a bool, float, int, str etc that is part of an application’s state. In the case of microscope and equipment control, these also can represent the state of a piece of hardware. These are very useful objects because the are the central location of the value contained within. All graphical interface views will be guaranteed to be consistent with the LQ state. The data of these quantities will also be saved in datafiles created by ScopeFoundry.

add_listener(func, argtype=(), **kwargs)

Connect ‘func’ as a listener (Qt Slot) for the updated_value signal. By default ‘func’ should take no arguments, but argtype can define the data type that it should accept. but should be limited to those supported by LoggedQuantity (i.e. int, float, str) **kwargs are passed to the connect function appends the ‘func’ to the ‘listeners’ list

change_choice_list(choices)

change_min_max(vmin=-1000000000000.0, vmax=1000000000000.0)

change_readonly(ro=True)

change_unit(unit)

coerce_to_type(x)

Force x to dtype of the LQ

Arguments	Description
x	value of type str, bool, int, etc.

Returns:Same value, x of the same type as its respective logged

quantity

connect_bidir_to_widget(widget)

connect_lq_math(lqs, func, reverse_func=None)

Links LQ to other LQs using math functions

takes a func that takes a set of logged quantities new_val = f(lq1, lq2, …)

when any of the lqs change, the value of this derived LQ will be updated based on func

reverse_func allows changes to this LQ to update lqs via reverse func

new_lq1_val, new_lq2_val, … = g(new_val, old_lqs_values) or new_lq1_val, new_lq2_val, … = g(new_val)

connect_lq_scale(lq, scale)

connect_to_hardware(read_func=None, write_func=None)

connect_to_lq(lq)

connect_to_widget(widget)

Creates Qt signal-slot connections between LQ and the QtWidget widget

connects updated_value signal to the appropriate slot depending on the type of widget

Makes a bidirectional connection to a QT widget, ie when LQ is updated, widget gets a signal and when widget is updated, the LQ receives a signal and update_value() slot is called.

Handles many types of widgets:

• QDoubleSpinBox
• QCheckBox
• QLineEdit
• QComboBox
• pyqtgraph.widgets.SpinBox.SpinBox

Arguments	Description
widget	The name of the Qt GUI Object, examples of which are listed above. For example, if you have a QDoubleSpinBox in the gui which you renamed int_value_doubleSpinBox in the Qt Designer Object Inspector, use self.ui.int_value_doubleSpinBox

Returns:None

disconnect_from_hardware(dis_read=True, dis_write=True)

has_hardware_read()

has_hardware_write()

ini_string_value()

Returns:A string showing the logged quantity value.

is_connected_to_hardware()

Returns:True if either self.hardware_read_func or

self.hardware_set_func are defined. False if None.

new_default_widget()

returns the approriate QWidget for the datatype of the LQ. automatically connects widget

read_from_hardware(send_signal=True)

read_from_lq_math()

same_values(v1, v2)

Compares two values of the LQ type, used in update_value

Arguments	Description
v1	value 1
v2	value 2

Returns:Boolean value (True or False)

send_display_updates(force=False)

Emit updated_value signals if value has changed.

Arguments	Description
force	will emit signals regardless of value change.

Returns:None

string_value()

update_choice_index_value(new_choice_index, **kwargs)

update_value(new_val=None, update_hardware=True, send_signal=True, reread_hardware=None)

Update stored value with new_val

Change value of LQ and emit signals to inform listeners of change

if update_hardware is true: call connected hardware write function

Arguments:	Description:
new_val	New value for the LoggedQuantity to store
update_hardware	calls hardware_set_func if defined (default True)
send_signal	sends out QT signals on upon change (default True)
reread_hardware	read from hardware after writing to hardware to ensure change (defaults to self.reread_from_hardware_after_write)

Returns:None

updated_choice_index_value

updated_min_max

updated_readonly

updated_text_value

updated_value

value

return stored value

write_to_hardware(reread_hardware=None)

ScopeFoundry.measurement module

Created on Tue Apr 1 09:25:48 2014 @author: esbarnard

class ScopeFoundry.measurement.Measurement(app, name=None)

Bases: PyQt4.QtCore.QObject

Base class for ScopeFoundry Hardware objects

to subclass, implement setup(), run()

for measurements with graphical interfaces, subclass and additionally implement setup_figure(), update_display()

add_logged_quantity(name, **kwargs)

Create a new LoggedQuantity and adds it to the measurement’s settings (LQCollection)

add_operation(name, op_func)

Used to create a logged quantity connection between a button in the Measurement tree and a function.

type name:	type op_func:
str	QtCore.Slot

add_widgets_to_tree(tree)

Adds Measurement items and their controls to Measurements tree in the user interface.

gui

interrupt()

Kindly ask the measurement to stop.

This raises the interrupt_measurement_called flag To actually stop, the threaded run() method must check for this flag and exit

is_measuring()

Returns whether the acquisition thread is running

load_ui(ui_fname=None)

Loads and shows user interface.

Arguments:
ui_fname	filename of user interface file (usually made with Qt Designer)

measurement_interrupted

signal sent when measurement is complete due to an interruption

measurement_sucessfully_completed

signal sent when full measurement is complete

new_control_widgets()

post_run()

Override this method to enable main-thread finalization after to measurement thread completes

pre_run()

Override this method to enable main-thread initialization prior to measurement thread start

run()

run method runs in an separate thread and is used for data acquisition

No GUI updates should occur within the run function, any Qt related GUI work should occur in update_display()

set_progress(pct)

This function updates the logged quantity progress which is used for the display of progress bars in the UI.

Arguments:
pct	The percentage of progress given by a measurement module

setup()

Override this to set up logged quantities and gui connections Runs during __init__, before the hardware connection is established Should generate desired LoggedQuantities

setup_figure()

Overide setup_figure to build graphical interfaces. This function is run on ScopeFoundry startup.

show_ui()

Shows the graphical user interface of this measurement. ui

start()

Starts the measurement

calls pre_run creates acquisition thread runs thread

start_nested_measure_and_wait(measure, nested_interrupt=True, polling_func=None, polling_time=0.1)

Start another nested measurement measure and wait until completion.

Optionally it can call a polling function polling_func with no arguments at an interval polling_time in seconds.

if nested_interrupt is True then interrupting the nested measure will also interrupt the outer measurement. nested_interrupt defaults to True

start_stop(start)

Use boolean start to either start (True) or interrupt (False) measurement. Test.

terminate()

Terminate MeasurementQThread.

update_display()

Override this function to provide figure updates when the display timer runs

web_ui()

class ScopeFoundry.measurement.MeasurementQThread(measurement, parent=None)

Bases: PyQt4.QtCore.QThread

run(self)

ScopeFoundry.ndarray_interactive module

class ScopeFoundry.ndarray_interactive.ArrayLQ_QTableModel(lq, col_names=None, row_names=None, parent=None, **kwargs)

Bases: ScopeFoundry.ndarray_interactive.NumpyQTableModel

on_dataChanged(topLeft=None, bottomRight=None)

on_lq_updated_value()

class ScopeFoundry.ndarray_interactive.NumpyQTableModel(narray, col_names=None, row_names=None, fmt='%g', copy=True, transpose=False, parent=None)

Bases: PyQt4.QtCore.QAbstractTableModel

array

columnCount(self, parent: QModelIndex = QModelIndex()) → int

data(self, QModelIndex, role: int = Qt.DisplayRole) → object

flags(self, QModelIndex) → Qt.ItemFlags

headerData(self, int, Qt.Orientation, role: int = Qt.DisplayRole) → object

rowCount(self, parent: QModelIndex = QModelIndex()) → int

setData(self, QModelIndex, object, role: int = Qt.EditRole) → bool

set_array(narray)

ScopeFoundry.setup module

ScopeFoundry.table_models module

Module contents