pymodaq 4.2.3__py3-none-any.whl → 5.0.0__py3-none-any.whl

pymodaq/resources/QtDesigner_Ressources/icons.svg

@@ -1,142 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" standalone="no"?>
-<svg
-   xmlns:dc="http://purl.org/dc/elements/1.1/"
-   xmlns:cc="http://creativecommons.org/ns#"
-   xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
-   xmlns:svg="http://www.w3.org/2000/svg"
-   xmlns="http://www.w3.org/2000/svg"
-   xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
-   xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
-   sodipodi:docname="icons.svg"
-   inkscape:version="1.0 (4035a4fb49, 2020-05-01)"
-   id="svg8"
-   version="1.1"
-   viewBox="0 0 210 297"
-   height="297mm"
-   width="210mm">
-  <defs
-     id="defs2" />
-  <sodipodi:namedview
-     inkscape:window-maximized="1"
-     inkscape:window-y="-8"
-     inkscape:window-x="1912"
-     inkscape:window-height="1017"
-     inkscape:window-width="1920"
-     showgrid="false"
-     inkscape:document-rotation="0"
-     inkscape:current-layer="layer1"
-     inkscape:document-units="mm"
-     inkscape:cy="251.2671"
-     inkscape:cx="161.985"
-     inkscape:zoom="2.8"
-     inkscape:pageshadow="2"
-     inkscape:pageopacity="0.0"
-     borderopacity="1.0"
-     bordercolor="#666666"
-     pagecolor="#ffffff"
-     id="base" />
-  <metadata
-     id="metadata5">
-    <rdf:RDF>
-      <cc:Work
-         rdf:about="">
-        <dc:format>image/svg+xml</dc:format>
-        <dc:type
-           rdf:resource="http://purl.org/dc/dcmitype/StillImage" />
-        <dc:title></dc:title>
-      </cc:Work>
-    </rdf:RDF>
-  </metadata>
-  <g
-     id="layer1"
-     inkscape:groupmode="layer"
-     inkscape:label="Calque 1">
-    <rect
-       inkscape:export-ydpi="300"
-       inkscape:export-xdpi="300"
-       y="18.174328"
-       x="18.174328"
-       height="10.958051"
-       width="10.958051"
-       id="rect833"
-       style="fill:#ff1c00;stroke:#000000;stroke-width:1;stroke-linecap:round;stroke-linejoin:round;paint-order:fill markers stroke;stroke-opacity:1;stroke-miterlimit:4;stroke-dasharray:none" />
-    <rect
-       inkscape:export-ydpi="300"
-       inkscape:export-xdpi="300"
-       style="fill:#ff1c00;stroke:#000000;stroke-width:1;stroke-linecap:round;stroke-linejoin:round;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1;paint-order:fill markers stroke"
-       id="rect833-2"
-       width="10.958051"
-       height="10.958051"
-       x="22.851545"
-       y="20.446119" />
-    <rect
-       inkscape:export-ydpi="300"
-       inkscape:export-xdpi="300"
-       style="fill:#ff1c00;stroke:#000000;stroke-width:1;stroke-linecap:round;stroke-linejoin:round;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1;paint-order:fill markers stroke"
-       id="rect833-1"
-       width="10.958051"
-       height="10.958051"
-       x="28.464205"
-       y="22.317005" />
-    <path
-       inkscape:export-ydpi="300"
-       inkscape:export-xdpi="300"
-       inkscape:export-filename="C:\Users\weber\Labo\Programmes Python\PyMoDAQ_Git\pymodaq\src\pymodaq\resources\QtDesigner_Ressources\Icon_Library\run_all.png"
-       transform="matrix(1.3430998,0,0,1,-6.6389431,1.2737737e-6)"
-       inkscape:transform-center-x="-2.441257"
-       d="m 19.34992,58.681279 0,-12.592905 10.905775,6.296453 z"
-       inkscape:randomized="0"
-       inkscape:rounded="0"
-       inkscape:flatsided="true"
-       sodipodi:arg2="3.1415927"
-       sodipodi:arg1="2.0943951"
-       sodipodi:r2="3.6352587"
-       sodipodi:r1="7.2705169"
-       sodipodi:cy="52.384827"
-       sodipodi:cx="22.985178"
-       sodipodi:sides="3"
-       id="path856"
-       style="fill:#16ff00;fill-opacity:1;stroke:#000000;stroke-width:0.862871;stroke-linecap:round;stroke-linejoin:round;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1;paint-order:fill markers stroke"
-       sodipodi:type="star" />
-    <path
-       inkscape:export-ydpi="300"
-       inkscape:export-xdpi="300"
-       inkscape:export-filename="C:\Users\weber\Labo\Programmes Python\PyMoDAQ_Git\pymodaq\src\pymodaq\resources\QtDesigner_Ressources\Icon_Library\run_all.png"
-       sodipodi:type="star"
-       style="fill:#16ff00;fill-opacity:1;stroke:#000000;stroke-width:0.862871;stroke-linecap:round;stroke-linejoin:round;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1;paint-order:fill markers stroke"
-       id="path856-6"
-       sodipodi:sides="3"
-       sodipodi:cx="22.985178"
-       sodipodi:cy="52.384827"
-       sodipodi:r1="7.2705169"
-       sodipodi:r2="3.6352587"
-       sodipodi:arg1="2.0943951"
-       sodipodi:arg2="3.1415927"
-       inkscape:flatsided="true"
-       inkscape:rounded="0"
-       inkscape:randomized="0"
-       d="m 19.34992,58.681279 0,-12.592905 10.905775,6.296453 z"
-       inkscape:transform-center-x="-2.441257"
-       transform="matrix(1.3430998,0,0,1,-3.817297,2.8172591)" />
-    <path
-       inkscape:export-ydpi="300"
-       inkscape:export-xdpi="300"
-       inkscape:export-filename="C:\Users\weber\Labo\Programmes Python\PyMoDAQ_Git\pymodaq\src\pymodaq\resources\QtDesigner_Ressources\Icon_Library\run_all.png"
-       sodipodi:type="star"
-       style="fill:#16ff00;fill-opacity:1;stroke:#000000;stroke-width:0.862871;stroke-linecap:round;stroke-linejoin:round;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1;paint-order:fill markers stroke"
-       id="path856-4"
-       sodipodi:sides="3"
-       sodipodi:cx="22.985178"
-       sodipodi:cy="52.384827"
-       sodipodi:r1="7.2705169"
-       sodipodi:r2="3.6352587"
-       sodipodi:arg1="2.0943951"
-       sodipodi:arg2="3.1415927"
-       inkscape:flatsided="true"
-       inkscape:rounded="0"
-       inkscape:randomized="0"
-       d="m 19.34992,58.681279 0,-12.592905 10.905775,6.296453 z"
-       inkscape:transform-center-x="-2.441257"
-       transform="matrix(1.3430998,0,0,1,-0.99565079,5.6345168)" />
-  </g>
-</svg>

pymodaq/resources/VERSION

@@ -1 +0,0 @@
-version = '4.2.3'

pymodaq/resources/config_template.toml

@@ -1,90 +0,0 @@
-#this is the configuration file of PyMoDAQ
-[style]
-darkstyle = true
-syntax_highlighting = 'github-dark'
-language = "English"
-country = "UnitedStates"
-
-[qtbackend]
-backends = [ "pyqt5", "pyqt6", "pyside2", "pyside6",]
-backend = "pyqt5"
-
-
-[data_saving]
-    [data_saving.h5file]
-    save_path = "C:\\Data"  #base path where data are automatically saved
-    compression_level = 5  # for hdf5 files between 0(min) and 9 (max)
-
-    [data_saving.hsds] #hsds connection option (https://www.hdfgroup.org/solutions/highly-scalable-data-service-hsds/)
-    #to save data in pymodaq using hpyd backend towards distant server or cloud (mimicking hdf5 files)
-    root_url = "http://hsds.sebastienweber.fr"
-    username = "pymodaq_user"
-    pwd = "pymodaq"
-
-    [data_saving.data_type]
-    dynamic = 'float64' # choose from below. This will force the datatype to be saved to
-    dynamics =  ['uint8', 'int8', 'uint16', 'int16', 'uint32', 'int32', 'uint64', 'int64', 'float64']
-
-
-[general]
-debug_level = "INFO" #either "DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"
-debug_levels = ["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"]
-check_version = true  # automatically check version at startup (or not if False)
-message_status_persistence = 1000  # ms
-
-[user]
-name = "User name"  # default name used as author in the hdf5 saving files
-
-[viewer]
-daq_type = 'DAQ0D' #either "DAQ0D", "DAQ1D", "DAQ2D", "DAQND"
-viewer_in_thread = true
-timeout = 10000  # default duration in ms to wait for data to be acquirred
-allow_settings_edition = false
-
-[plotting]
-backend = 'matplotlib'  # either 'matplotlib' or 'qt' or any other custom backend
-
-[network]
-    [network.logging]
-        [network.logging.user]
-        username = "pymodaq_user"
-        pwd = "pymodaq"
-
-        [network.logging.sql] #location of the postgresql database server and options where the DAQ_Logger will log data
-        ip = "10.47.3.22"
-        port = 5432
-
-    [network.tcp-server]
-    ip = "10.47.0.39"
-    port = 6341
-
-    [network.leco-server]
-    run_coordinator_at_startup = false
-    host = "localhost"
-    port = 12300  # pyleco default Coordinator port
-
-[presets]
-default_preset_for_scan = "preset_default"
-default_preset_for_logger = "preset_default"
-default_preset_for_pid = "beam_steering_mock"
-
-[actuator]
-    epsilon_default = 1
-    polling_interval_ms = 100  # ms Careful when using TCP/IP connection as you can saturate the connection with too much polling
-    polling_timeout_s = 20  # s
-    refresh_timeout_ms = 500  # ms
-    timeout = 10000  # default duration in ms to wait for data to be acquirred
-
-[scan]
-    scan_in_thread = true
-    show_popups = true
-    default = "Scan2D"
-    Naverage = 1  # minimum is 1
-    steps_limit = 1000  # the limit of the number of steps you can set in a given scan
-    sort1D = true
-
-    [scan.timeflow]
-    wait_time = 0
-    wait_time_between = 0
-    timeout = 10000  # in millisecond
-

pymodaq/utils/abstract/__init__.py

@@ -1,48 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-Created the 21/11/2022
-
-@author: Sebastien Weber
-
-Introduce some nice ABCMeta class allowing that a particular attribute has been declared when instantiating
-See https://stackoverflow.com/a/50381071/8090831
-"""
-
-from abc import ABCMeta as NativeABCMeta
-from abc import abstractmethod
-from typing import cast, Any, Callable, TypeVar
-
-
-R = TypeVar('R')
-
-
-class DummyAttribute:
-    pass
-
-
-def abstract_attribute(obj: Callable[[Any], R] = None) -> R:
-    _obj = cast(Any, obj)
-    if obj is None:
-        _obj = DummyAttribute()
-    _obj.__is_abstract_attribute__ = True
-    return cast(R, _obj)
-
-
-class ABCMeta(NativeABCMeta):
-
-    def __call__(cls, *args, **kwargs):
-        instance = NativeABCMeta.__call__(cls, *args, **kwargs)
-        abstract_attributes = {
-            name
-            for name in dir(instance)
-            if getattr(getattr(instance, name), '__is_abstract_attribute__', False)
-        }
-        if abstract_attributes:
-            raise NotImplementedError(
-                "Can't instantiate abstract class {} with"
-                " abstract attributes: {}".format(
-                    cls.__name__,
-                    ', '.join(abstract_attributes)
-                )
-            )
-        return instance

pymodaq/utils/enums.py

@@ -1,76 +0,0 @@
-from enum import Enum
-from pymodaq.utils.math_utils import find_index
-from pymodaq.utils.math_utils import my_moment
-import numpy as np
-from scipy.optimize import curve_fit
-from typing import List, Union
-
-
-class BaseEnum(Enum):
-    """Enum to be used within pymodaq with some utility methods"""
-
-    @classmethod
-    def names(cls) -> List[str]:
-        """Returns all the names of the enum"""
-        return list(cls.__members__.keys())
-
-    @classmethod
-    def values(cls) -> List[str]:
-        """Returns all the names of the enum"""
-        return [cls[name].value for name in cls.names()]
-
-    @classmethod
-    def to_dict(cls):
-        """ Returns the enum in form of a dict with names os keys
-
-        New in 4.0.2
-        """
-        return {name: cls[name].value for name in cls.names()}
-
-    @classmethod
-    def to_dict_value(cls):
-        """ Returns the enum in form of a dict with values os keys
-
-        New in 4.0.2
-        """
-        return {cls[name].value: name for name in cls.names()}
-
-    def __eq__(self, other: Union[str, Enum]):
-        """testing for equality using the enum name"""
-        if isinstance(other, str):
-            if other == self.name:
-                return True
-        return super().__eq__(other)
-
-
-def enum_checker(enum: BaseEnum, item: Union[BaseEnum, str]):
-    """Check if the item parameter is a valid enum or at least one valid string name of the enum
-
-    If a string, transforms it to a valid enum (case not important)
-
-    Parameters
-    ----------
-    enum: BaseEnum class or one of its derivated class
-
-    item: str or BaseEnum instance
-
-    Returns
-    -------
-    BaseEnum class or one of its derivated class
-    """
-
-    if not isinstance(item, enum):
-        if not isinstance(item, str):
-            raise ValueError(f'{item} is an invalid {enum}. Should be a {enum} enum or '
-                             f'a string in {enum.names()}')
-        for ind, name in enumerate(enum.names()):
-            if item.lower() == name.lower():
-                item = enum[name]
-                break
-        else:
-            raise ValueError(f'{item} is an invalid {enum}. Should be a {enum} enum or '
-                             f'a string in {enum.names()}')
-    return item
-
-
-

pymodaq/utils/factory.py

@@ -1,82 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-Created the 04/11/2022
-
-@author: Sebastien Weber
-"""
-from typing import Callable, Union
-from abc import ABCMeta, abstractmethod
-
-from pymodaq.utils.logger import set_logger, get_module_name
-
-logger = set_logger(get_module_name(__file__))
-
-
-class BuilderBase(ABCMeta):
-    """Abstract class defining an object/service builder with a callable interface accepting some arguments
-
-    See https://realpython.com/factory-method-python/ for some details
-
-    See Also
-    --------
-    pymodaq.post_treatment.process_1d_to_scalar
-    """
-    @abstractmethod
-    def __call__(self, *args, **kwargs):
-        pass
-
-
-class ObjectFactory(metaclass=ABCMeta):
-    """Generic ObjectFactory with a decorator register to add object builders to the factory with a
-    unique key identifier
-
-    See https://realpython.com/factory-method-python/ for some details
-
-    Examples
-    --------
-    @ObjectFactory.register('custom')
-    def my_custom_builder():
-        pass
-
-    See Also
-    --------
-    pymodaq.post_treatment.process_1d_to_scalar.Data1DProcessorFactory
-    """
-    _builders = {}
-
-    @classmethod
-    def register(cls, key: str) -> Callable:
-        def inner_wrapper(wrapped_class: Union[BuilderBase, Callable]) -> Callable:
-            if cls.__name__ not in cls._builders:
-                cls._builders[cls.__name__] = {}
-            if key not in cls._builders[cls.__name__]:
-                cls._builders[cls.__name__][key] = wrapped_class
-            else:
-                logger.warning(f'The {cls.__name__}/{key} builder is already registered. Replacing it')
-            return wrapped_class
-        return inner_wrapper
-
-    @property
-    def builders(self):
-        return self._builders
-
-    def keys_function(self, do_sort=True):
-        if do_sort:
-            return self.keys
-        else:
-            return list(self.builders[self.__class__.__name__].keys())
-
-    @property
-    def keys(self):
-        return sorted(list(self.builders[self.__class__.__name__].keys()))
-
-    @classmethod
-    def create(cls, key, **kwargs):
-        builder = cls._builders[cls.__name__].get(key)
-        if not builder:
-            raise ValueError(key)
-        return builder(**kwargs)
-
-    @classmethod
-    def get_class(cls, key):
-        return cls._builders[cls.__name__].get(key)

pymodaq/utils/gui_utils/custom_app.py

@@ -1,133 +0,0 @@
-from qtpy.QtCore import QObject, QLocale
-from pymodaq.utils.gui_utils.dock import DockArea
-from pymodaq.utils.managers.action_manager import ActionManager
-from pymodaq.utils.managers.parameter_manager import ParameterManager
-from pyqtgraph.dockarea import DockArea
-from qtpy import QtCore, QtWidgets
-from typing import Union, TYPE_CHECKING
-from pymodaq.utils.managers.modules_manager import ModulesManager
-
-if TYPE_CHECKING:
-    from pymodaq.dashboard import DashBoard
-
-
-class CustomApp(QObject, ActionManager, ParameterManager):
-    """Base Class to ease the implementation of User Interfaces
-
-    Inherits the MixIns ActionManager and ParameterManager classes. You have to subclass some methods and make
-    concrete implementation of a given number of methods:
-
-    * setup_actions: mandatory, see :class:`pymodaq.utils.managers.action_manager.ActionManager`
-    * value_changed: non mandatory, see :class:`pymodaq.utils.managers.parameter_manager.ParameterManager`
-    * child_added: non mandatory, see :class:`pymodaq.utils.managers.parameter_manager.ParameterManager`
-    * param_deleted: non mandatory, see :class:`pymodaq.utils.managers.parameter_manager.ParameterManager`
-    * setup_docks: mandatory
-    * setup_menu: non mandatory
-    * connect_things: mandatory
-
-    Parameters
-    ----------
-    parent: DockArea or QtWidget
-    dashboard: DashBoard, optional
-
-    See Also
-    --------
-    :class:`pymodaq.utils.managers.action_manager.ActionManager`,
-    :class:`pymodaq.utils.managers.parameter_manager.ParameterManager`,
-    :class:`pymodaq.utils.managers.modules_manager.ModulesManager`,
-    :class:`pymodaq.dashboard.DashBoard`
-    """
-
-    log_signal = QtCore.Signal(str)
-    params = []
-
-    def __init__(self, parent: Union[DockArea, QtWidgets.QWidget], dashboard: 'DashBoard'=None):
-        QObject.__init__(self)
-        ActionManager.__init__(self)
-        ParameterManager.__init__(self)
-        QLocale.setDefault(QLocale(QLocale.English, QLocale.UnitedStates))
-
-        if not isinstance(parent, DockArea):
-            if not isinstance(parent, QtWidgets.QWidget):
-                raise Exception('no valid parent container, expected a DockArea or a least a QWidget')
-
-        self.parent = parent
-        if isinstance(parent, DockArea):
-            self.dockarea: DockArea = parent
-            self.mainwindow: QtWidgets.QMainWindow = parent.parent()
-        else:
-            self.dockarea: DockArea = None
-            self.mainwindow: QtWidgets.QMainWindow = None
-        self.dashboard = dashboard
-
-        self.docks = dict([])
-        self.statusbar = None
-        self._toolbar = QtWidgets.QToolBar()
-
-        if self.mainwindow is not None:
-            self.mainwindow.addToolBar(self._toolbar)
-            self.statusbar = self.mainwindow.statusBar()
-
-        self.set_toolbar(self._toolbar)
-
-    def setup_ui(self):
-        self.setup_docks()
-
-        self.setup_actions()  # see ActionManager MixIn class
-
-        self.setup_menu()
-
-        self.connect_things()
-
-    def setup_docks(self):
-        """Mandatory method to be subclassed to setup the docks layout
-
-        Examples
-        --------
-        >>>self.docks['ADock'] = gutils.Dock('ADock name')
-        >>>self.dockarea.addDock(self.docks['ADock'])
-        >>>self.docks['AnotherDock'] = gutils.Dock('AnotherDock name')
-        >>>self.dockarea.addDock(self.docks['AnotherDock'''], 'bottom', self.docks['ADock'])
-
-        See Also
-        --------
-        pyqtgraph.dockarea.Dock
-        """
-        raise NotImplementedError
-
-    def setup_menu(self):
-        """Non mandatory method to be subclassed in order to create a menubar
-
-        create menu for actions contained into the self._actions, for instance:
-
-        Examples
-        --------
-        >>>file_menu = self._menubar.addMenu('File')
-        >>>self.affect_to('load', file_menu)
-        >>>self.affect_to('save', file_menu)
-
-        >>>file_menu.addSeparator()
-        >>>self.affect_to('quit', file_menu)
-
-        See Also
-        --------
-        pymodaq.utils.managers.action_manager.ActionManager
-        """
-        pass
-
-    def connect_things(self):
-        """Connect actions and/or other widgets signal to methods"""
-        raise NotImplementedError
-
-    @property
-    def modules_manager(self) -> ModulesManager:
-        """useful tool to interact with DAQ_Moves and DAQ_Viewers
-
-        Will be available if a DashBoard has been set
-
-        Returns
-        -------
-        ModulesManager
-        """
-        if self.dashboard is not None:
-            return self.dashboard.modules_manager

pymodaq/utils/gui_utils/dock.py

@@ -1,107 +0,0 @@
-import warnings
-
-from qtpy.QtCore import Signal, QObject
-from qtpy import QtGui, QtCore, QtWidgets
-from pyqtgraph.dockarea import Dock, DockArea, DockLabel
-from pyqtgraph.dockarea.DockArea import TempAreaWindow
-from pyqtgraph.widgets.VerticalLabel import VerticalLabel
-
-
-class Dock(Dock):
-    dock_focused = Signal(str)
-    def __init__(self, name, *args, fontSize='20px', **kwargs):
-        kwargs['fontSize'] = fontSize
-        super().__init__(name, *args, **kwargs)
-
-    def removeWidgets(self):
-        for widget in self.widgets:
-            self.layout.removeWidget(widget)
-            widget.close()
-        self.widgets = []
-
-    def setOrientation(self, o='auto', force=False):
-        """
-        Sets the orientation of the title bar for this Dock.
-        Must be one of 'auto', 'horizontal', or 'vertical'.
-        By default ('auto'), the orientation is determined
-        based on the aspect ratio of the Dock.
-        """
-        if self.container() is not None:  # patch here for when Dock is closed and when the QApplication
-            # event loop is processed
-            if o == 'auto' and self.autoOrient:
-                if self.container().type() == 'tab':
-                    o = 'horizontal'
-                elif self.width() > self.height() * 1.5:
-                    o = 'vertical'
-                else:
-                    o = 'horizontal'
-            if force or self.orientation != o:
-                self.orientation = o
-                self.label.setOrientation(o)
-                self.updateStyle()
-
-
-class DockArea(DockArea, QObject):
-    """
-    Custom Dockarea class subclassing from the standard DockArea class and QObject so it can emit a signal when docks
-    are moved around (one subclassed method: moveDock)
-    See Also
-    --------
-    pyqtgraph.dockarea
-    """
-    dock_signal = Signal()
-
-    def __init__(self, parent=None, temporary=False, home=None):
-        super(DockArea, self).__init__(parent, temporary, home)
-
-    def moveDock(self, dock, position, neighbor):
-        """
-        Move an existing Dock to a new location.
-        """
-        # Moving to the edge of a tabbed dock causes a drop outside the tab box
-        if position in ['left', 'right', 'top',
-                        'bottom'] and neighbor is not None and neighbor.container() is not None and neighbor.container().type() == 'tab':
-            neighbor = neighbor.container()
-        self.addDock(dock, position, neighbor)
-        self.dock_signal.emit()
-
-    def addTempArea(self):
-        if self.home is None:
-            area = DockArea(temporary=True, home=self)
-            self.tempAreas.append(area)
-            win = TempAreaWindow(area)
-            area.win = win
-            win.show()
-        else:
-            area = self.home.addTempArea()
-        # print "added temp area", area, area.window()
-        return area
-
-
-if __name__ == '__main__':
-    import sys
-    from pymodaq.utils.parameter import ParameterTree
-    app = QtWidgets.QApplication(sys.argv)
-    import qdarkstyle
-    app.setStyleSheet(qdarkstyle.load_stylesheet(qdarkstyle.DarkPalette))
-
-    labelv = DockLabel('mysuperlabel', fontSize='25px')
-    docky = Dock('MysuperDockLogger', fontSize='30px')
-    dockx = Dock('MysuperDockLoggerx', fontSize='30px')
-    area = DockArea()
-    area.addDock(docky)
-    area.addDock(dockx)
-    dockx.addWidget(ParameterTree())
-    labelv.setAlignment(QtCore.Qt.AlignmentFlag.AlignTop | QtCore.Qt.AlignmentFlag.AlignHCenter)
-    f = labelv.font()
-    f.setPixelSize(25)
-    labelv.setFont(f)
-    docky.label.setFont(f)
-    labelv.show()
-    area.show()
-    QtWidgets.QApplication.processEvents()
-    print(f'labelv size hint: {labelv.sizeHint()}')
-    print(f'labelv size: {labelv.size()}')
-    print(f'labelv margins: {labelv.contentsMargins().top()}, {labelv.contentsMargins().bottom()}')
-
-    sys.exit(app.exec())