emlib 1.16.5__py3-none-any.whl

emlib/__init__.py

@@ -0,0 +1,23 @@
+"""
+**emlib** is a set of modules with miscellaneous functionality:
+
+Repository: https://github.com/gesellkammer/emlib
+
+Features
+--------
+
+- maths:
+    - base conversion, euclidian distance, min. common denominator, etc.
+    - combinatorics
+    - number theory
+    - number series
+    - markov chains
+    - utilities to traverse graphs
+- matplotlib enhancements
+- csv utilities
+- iterator tools (similar to more_itertools)
+- containers: RecordList (a list of named tuples)
+- doctools: tools to generate documentation (for mkdocs particularly)
+- etc
+"""
+

emlib/_dialogsqt.py

@@ -0,0 +1,263 @@
+from __future__ import annotations
+import sys
+import logging
+import emlib.misc
+from PyQt5 import QtWidgets, QtCore, QtGui
+from PyQt5.QtCore import Qt
+from typing import TYPE_CHECKING
+if TYPE_CHECKING:
+    from typing import *
+
+
+logger = logging.getLogger(__name__)
+
+__all__ = (
+    'FilteredList',
+    'selectItem',
+    'selectFile',
+    'saveDialog',
+    'showInfo'
+)
+
+
+def _makeApp():
+    app = QtWidgets.QApplication.instance()
+    if app is None:
+        logger.debug("Making new qt QApplication")
+        app = QtWidgets.QApplication([])
+    else:
+        logger.debug("Using existing QApplication instance")
+    return app
+
+
+class _FilterEdit(QtWidgets.QLineEdit):
+    def __init__(self, parent: FilteredList, font:Tuple[str, int]=None):
+        self.parent = parent
+        super().__init__()
+        if font:
+            self.setFont(QtGui.QFont(*font))
+
+    def keyPressEvent(self, keyEvent):
+        k = keyEvent.key()
+        if k == Qt.Key_Return:
+            self.parent.accept()
+        elif k in (Qt.Key_Up, Qt.Key_Down):
+            self.parent.view.keyPressEvent(keyEvent)
+        elif k == Qt.Key_Escape:
+            self.parent.dismiss()
+        else:
+            # re = QRegularExpression(pattern, QRegularExpression.CaseInsensitiveOption | QRegularExpression.DotMatchesEverythingOption)
+            rx = QtCore.QRegularExpression(self.text(), QtCore.QRegularExpression.CaseInsensitiveOption | QtCore.QRegularExpression.DotMatchesEverythingOption)
+            self.parent.proxy_model.setFilterRegularExpression(rx)
+            self.parent.proxy_model.setFilterWildcard("*" + self.text() + "*")
+            super().keyPressEvent(keyEvent)
+
+
+class _FilteredListView(QtWidgets.QListView):
+    def __init__(self, parent: FilteredList, font:Tuple[str, int]=None):
+        self.parent = parent
+        super().__init__()
+        if font:
+            self.setFont(QtGui.QFont(*font))
+
+    def keyPressEvent(self, keyEvent):
+        k = keyEvent.key()
+        if k == Qt.Key_Return:
+            self.parent.accept()
+        elif k == Qt.Key_Escape:
+            self.parent.dismiss()
+        else:
+            super().keyPressEvent(keyEvent)
+
+
+def _calculateTextWidth(s: str, fontfamily: str, size: int) -> float:
+    f = QtGui.QFont(fontfamily, size)
+    fm = QtGui.QFontMetrics(f)
+    width = fm.horizontalAdvance(s)
+    return width
+
+
+class FilteredList(QtWidgets.QMainWindow):
+    def __init__(self, items:Sequence[str], title:str,
+                 listFont:Tuple[str, int]=None,
+                 entryFont:Tuple[str, int]=None):
+        super().__init__()
+        self.out = None
+        self.view = _FilteredListView(self, font=listFont)  # QListView()
+        self.model = QtCore.QStringListModel(items)
+        self.proxy_model = QtCore.QSortFilterProxyModel()
+        self.proxy_model.setSourceModel(self.model)
+        self.proxy_model.setSortCaseSensitivity(Qt.CaseInsensitive)
+        self.view.setModel(self.proxy_model)
+        self.setWindowTitle(title)
+        self.searchbar = _FilterEdit(self, font=entryFont)  # QLineEdit()
+        # choose the type of search by connecting to a different slot here.
+        # see https://doc.qt.io/qt-5/qsortfilterproxymodel.html#public-slots
+        self.searchbar.textChanged.connect(self.proxy_model.setFilterFixedString)
+        minw = _calculateTextWidth(max(items, key=lambda s:len(s)), listFont[0], listFont[1])
+        self.setMinimumWidth(int(minw + 60))
+
+        layout = QtWidgets.QVBoxLayout()
+        layout.addWidget(self.searchbar)
+        layout.addWidget(self.view)
+
+        container = QtWidgets.QWidget()
+        container.setLayout(layout)
+        self.setCentralWidget(container)
+
+    def accept(self):
+        idx = self.view.currentIndex()
+        selection = idx.data()
+        if selection is None and self.proxy_model.rowCount():
+            selection = self.proxy_model.index(0, 0).data()
+        self.out = selection
+        self.close()
+
+    def dismiss(self):
+        self.out = None
+        self.close()
+
+
+def selectItem(items: Sequence[str], title='Select',
+               listFont:Tuple[str, int]=None,
+               entryFont: Tuple[str, int]=None
+               ) -> Optional[str]:
+    app = _makeApp()
+    w = FilteredList(items, title=title, listFont=listFont, entryFont=entryFont)
+    w.show()
+    app.exec_()
+    return w.out
+
+
+class _FilteredComboBox(QtWidgets.QComboBox):
+    def __init__(self, parent=None, title:str=''):
+        super().__init__(parent)
+        self.dismissed = False
+        if title:
+            self.setWindowTitle(title)
+
+        self.setFocusPolicy(Qt.StrongFocus)
+        self.setEditable(True)
+
+        # add a filter model to filter matching items
+        self.pFilterModel = QtCore.QSortFilterProxyModel(self)
+        self.pFilterModel.setFilterCaseSensitivity(Qt.CaseInsensitive)
+        self.pFilterModel.setSourceModel(self.model())
+
+        # add a completer, which uses the filter model
+        self.completer = QtCore.QCompleter(self.pFilterModel, self)
+        # always show all (filtered) completions
+        self.completer.setCompletionMode(QtCore.QCompleter.UnfilteredPopupCompletion)
+        self.setCompleter(self.completer)
+
+        # connect signals
+        self.lineEdit().textEdited.connect(self.pFilterModel.setFilterFixedString)
+        self.completer.activated.connect(self.on_completer_activated)
+
+    # on selection of an item from the completer, select the corresponding item from combobox
+    def on_completer_activated(self, text):
+        if text:
+            index = self.findText(text)
+            self.setCurrentIndex(index)
+            self.activated[str].emit(self.itemText(index))
+
+    # on model change, update the models of the filter and completer as well
+    def setModel(self, model):
+        super().setModel(model)
+        self.pFilterModel.setSourceModel(model)
+        self.completer.setModel(self.pFilterModel)
+
+    # on model column change, update the model column of the filter and completer as well
+    def setModelColumn(self, column):
+        self.completer.setCompletionColumn(column)
+        self.pFilterModel.setFilterKeyColumn(column)
+        super().setModelColumn(column)
+
+    def keyPressEvent(self, e):
+        if e.key() == Qt.Key_Escape:
+            self.dismissed = True
+            self.close()
+        elif e.key() == Qt.Key_Enter or e.key() == Qt.Key_Return:
+            self.close()
+        else:
+            super().keyPressEvent(e)
+
+
+def selectFromCombobox(items: List[str], title="Select", width=300, height=40
+                       ) -> Optional[str]:
+    app = _makeApp()
+    combo = _FilteredComboBox(title=title)
+    # either fill the standard model of the combobox
+    # combo.addItems(options)
+
+    # or use another model
+    combo.setModel(QtCore.QStringListModel(items))
+
+    combo.resize(width, height)
+    combo.show()
+    app.exec_()
+    return None if combo.dismissed else combo.currentText()
+
+
+def selectFile(directory:str=None, filter="All (*.*)", title="Open file") -> str:
+    app = _makeApp()
+    options = QtWidgets.QFileDialog.Options()
+    options |= QtWidgets.QFileDialog.DontUseNativeDialog
+    filter = filter.replace(",", " ")
+    name, mask = QtWidgets.QFileDialog.getOpenFileName(None, title, directory=directory,
+                                                       filter=filter)
+    return name
+
+
+def saveDialog(filter="All (*.*)", title="Save file", directory:str=None) -> str:
+    app = _makeApp()
+    filter = filter.replace(",", " ")
+    name, mask = QtWidgets.QFileDialog.getSaveFileName(None, title, filter=filter,
+                                                       directory=directory)
+    return name
+
+
+def showInfo(msg:str, title:str='Info', font:Tuple[str,int]=None, icon:str=None) -> None:
+    """
+    Open a message box with a text
+
+    Args:
+        msg: the text to display (one line)
+        title: the title of the dialog
+        font: if given, a tuple (fontfamily, size)
+        icon: either None or one of 'question', 'information', 'warning', 'critical'
+    """
+    app = _makeApp()
+    mbox = QtWidgets.QMessageBox()
+    mbox.setText(msg)
+    mbox.setBaseSize(QtCore.QSize(600, 120));
+    if title:
+        mbox.setWindowTitle(title)
+    if font:
+        mbox.setFont(QtCore.QFont(*font))
+    if icon:
+        if icon == 'question':
+            mbox.setIcon(QtWidgets.QMessageBox.Question)
+        elif icon == 'information':
+            mbox.setIcon(QtWidgets.QMessageBox.Information)
+        elif icon == 'warning':
+            mbox.setIcon(QtWidgets.QMessageBox.Warning)
+        elif icon == 'critical':
+            mbox.setIcon(QtWidgets.QMessageBox.Critical)
+    mbox.exec_()
+
+
+# init
+if sys.platform == 'darwin' and emlib.misc.inside_ipython() and not emlib.misc.inside_jupyter():
+    # macos needs loop integration inside ipython
+    ip = get_ipython()
+    if ip.active_eventloop is None:
+        logger.debug("Starting ipython/qt eventloop integration")
+        ip.run_line_magic('gui', 'qt')
+    elif ip.active_eventloop not in ('qt', 'qt5'):
+        logger.warning(
+                f"IPython has an active eventloop for {ip.active_eventloop}, but "
+                f"emlib.dialogs needs the qt eventloop to be able to open qt dialogs"
+                f" without blocking the shell. ")
+        ip.run_line_magic('gui', 'qt')
+

emlib/calculus.py

@@ -0,0 +1,189 @@
+"""
+Calculus utilities, based on calculus.jl
+
+"""
+from __future__ import annotations
+import math
+import struct as _struct
+import random as _random
+from typing import Callable
+
+NAN = float('nan')
+epsilon = math.ldexp(1.0, -53)      # smallest double such that eps+0.5!=0.5
+maxfloat = float(2**1024 - 2**971)  # From the IEEE 754 standard
+minfloat = math.ldexp(1.0, -1022)   # min positive normalized double
+smalleps = math.ldexp(1.0, -1074)   # smallest increment for doubles < minfloat
+infinity = math.ldexp(1.0, 1023) * 2
+
+
+def nextafter(x:float, direction=1) -> float:
+    """
+    returns the next float after x in the direction indicated
+
+    if not possible, returns x
+
+    Args:
+        x: the value to evaluate
+        direction: if 1, the next float is searched upwards, otherwise downwards
+
+    Returns:
+        a next representable float from `x` in the direction indicated
+    """
+    if math.isnan(x) or math.isinf(x):
+        return x
+    # return small numbers for x very close to 0.0
+    if -minfloat < x < minfloat:
+        if direction > 0:
+            return x + smalleps
+        else:
+            return x - smalleps
+
+    # it looks like we have a normalized number
+    # break x down into a mantissa and exponent
+    m, e = math.frexp(x)
+
+    # all the special cases have been handled
+    if direction > 0:
+        m += epsilon
+    else:
+        m -= epsilon
+    return math.ldexp(m, e)
+
+
+def eps(x:float) -> float:
+    """
+    Difference with the next representable float
+    """
+    if math.isinf(x):
+        return NAN
+    return abs(nextafter(x) - x)
+
+
+def next_float_up(x:float) -> float:
+    """
+    Return the next representable float
+    """
+    # NaNs and positive infinity map to themselves.
+    if math.isnan(x) or (math.isinf(x) and x > 0):
+        return x
+
+    # 0.0 and -0.0 both map to the smallest +ve float.
+    if x == 0.0:
+        x = 0.0
+
+    n = _struct.unpack('<q', _struct.pack('<d', x))[0]
+    if n >= 0:
+        n += 1
+    else:
+        n -= 1
+    return _struct.unpack('<d', _struct.pack('<q', n))[0]
+
+
+def next_float_down(x:float) -> float:
+    """
+    return the previous representable float
+    """
+    return -next_float_up(-x)
+
+
+def next_toward(x:float, y:float) -> float:
+    """
+    return the next representable float between x and y
+    """
+    # If either argument is a NaN, return that argument.
+    # This matches the implementation in decimal.Decimal
+    if math.isnan(x):
+        return x
+    if math.isnan(y):
+        return y
+    if y == x:
+        return y
+    elif y > x:
+        return next_float_up(x)
+    else:
+        return next_float_down(x)
+
+
+def cbrt(x:float) -> float:
+    """ cubic root """
+    return math.pow(x, 1.0 / 3)
+
+
+def finite_difference_forward(func, x:float, h:float=None) -> float:
+    epsilon = math.sqrt(eps(max(1, abs(x)))) if h is None else h
+    # use machine-representable numbers
+    return (func(x + epsilon) - func(x)) / epsilon
+
+
+def finite_difference_central(func, x:float, h:float=None) -> float:
+    epsilon = cbrt(eps(max(1, abs(x)))) if h is None else h
+    return (func(x + epsilon) - func(x - epsilon)) / (2 * epsilon)
+
+
+def finite_difference(func, x:float, mode='central') -> float:
+    """
+    derivative of func at x
+    """
+    if mode == 'forward':
+        return finite_difference_forward(func, x)
+    elif mode == 'central':
+        return finite_difference_central(func, x)
+    else:
+        raise ValueError("mode must be 'forward' or 'central'")
+
+
+def derivative(func) -> Callable[[float], float]:
+    """
+    return a new function representing the derivative of func
+    """
+    return lambda x: finite_difference_central(func, x)
+
+
+def _integrate_adaptive_simpsons_inner(f:Callable, a:float, b:float, eps:float, S:float,
+                                       fa:float, fb:float, fc:float, bottom:float) -> float:
+    c = (a + b) / 2
+    h = b - a
+    d = (a + c) / 2
+    g = (c + b) / 2
+    fd = f(d)
+    fe = f(g)
+    Sleft = (h / 12) * (fa + 4 * fd + fc)
+    Sright = (h / 12) * (fc + 4 * fe + fb)
+    S2 = Sleft + Sright
+    if bottom <= 0 or abs(S2 - S) <= 15 * epsilon:
+        return S2 + (S2 - S) / 15
+    inner = _integrate_adaptive_simpsons_inner
+    return (
+        inner(f, a, c, eps/2, Sleft, fa, fc, fd, bottom - 1) +
+        inner(f, c, b, eps/2, Sright, fc, fb, fe, bottom - 1)
+    )
+
+
+def integrate_adaptive_simpsons(f:Callable, a:float, b:float, accuracy=10e-10,
+                                max_iterations=50) -> float:
+    c = (a + b) / 2
+    h = b - a
+    fa = f(a)
+    fb = f(b)
+    fc = f(c)
+    S = (h / 6) * (fa + 4 * fc + fb)
+    return _integrate_adaptive_simpsons_inner(f, a, b, accuracy,
+                                              S, fa, fb, fc, max_iterations)
+
+
+def integrate_monte_carlo(f:Callable, a:float, b:float, iterations:int):
+    estimate = 0.0
+    width = (b - a)
+    for i in range(iterations):
+        x = width * _random.random() + a
+        estimate += f(x) * width
+    return estimate / iterations
+
+
+def integrate(f:Callable, a:float, b:float, method='simpsons') -> float:
+    if method == 'simpsons':
+        return integrate_adaptive_simpsons(f, a, b)
+    elif method == 'montecarlo':
+        return integrate_monte_carlo(f, a, b, 10000)
+    else:
+        raise ValueError("Unknown method of integration")

emlib/classproperty.py

@@ -0,0 +1,32 @@
+"""
+Very simple implementation of a class property
+
+Example
+~~~~~~~
+
+    class Foo:
+        _active: Foo | None = None
+        _initdone = False
+
+        def __init__(self, bar=None):
+            self.bar = bar
+
+        @classmethod
+        def _initclass(self):
+            if Foo._initdone:
+                return
+            Foo._initdone = True
+            Foo._active = Foo()
+
+        @classproperty
+        def active(cls) -> Foo
+            assert Foo._initdone and Foo._active is not None
+            return Foo._active
+
+    Foo._initclass()
+"""
+
+
+class classproperty(property):
+    def __get__(self, owner_self, owner_cls):
+        return self.fget(owner_cls)

emlib/colordata.py

@@ -0,0 +1,167 @@
+"""
+These color definitions are taken from matplotlib._color_data.py
+
+We include it here to be able to access color names without needing to import matplotlib
+"""
+
+BASE_COLORS = {
+    'b': (0, 0, 1),        # blue
+    'g': (0, 0.5, 0),      # green
+    'r': (1, 0, 0),        # red
+    'c': (0, 0.75, 0.75),  # cyan
+    'm': (0.75, 0, 0.75),  # magenta
+    'y': (0.75, 0.75, 0),  # yellow
+    'k': (0, 0, 0),        # black
+    'w': (1, 1, 1),        # white
+}
+
+# https://drafts.csswg.org/css-color-4/#named-colors
+CSS4_COLORS = {
+    'aliceblue':            '#F0F8FF',
+    'antiquewhite':         '#FAEBD7',
+    'aqua':                 '#00FFFF',
+    'aquamarine':           '#7FFFD4',
+    'azure':                '#F0FFFF',
+    'beige':                '#F5F5DC',
+    'bisque':               '#FFE4C4',
+    'black':                '#000000',
+    'blanchedalmond':       '#FFEBCD',
+    'blue':                 '#0000FF',
+    'blueviolet':           '#8A2BE2',
+    'brown':                '#A52A2A',
+    'burlywood':            '#DEB887',
+    'cadetblue':            '#5F9EA0',
+    'chartreuse':           '#7FFF00',
+    'chocolate':            '#D2691E',
+    'coral':                '#FF7F50',
+    'cornflowerblue':       '#6495ED',
+    'cornsilk':             '#FFF8DC',
+    'crimson':              '#DC143C',
+    'cyan':                 '#00FFFF',
+    'darkblue':             '#00008B',
+    'darkcyan':             '#008B8B',
+    'darkgoldenrod':        '#B8860B',
+    'darkgray':             '#A9A9A9',
+    'darkgreen':            '#006400',
+    'darkgrey':             '#A9A9A9',
+    'darkkhaki':            '#BDB76B',
+    'darkmagenta':          '#8B008B',
+    'darkolivegreen':       '#556B2F',
+    'darkorange':           '#FF8C00',
+    'darkorchid':           '#9932CC',
+    'darkred':              '#8B0000',
+    'darksalmon':           '#E9967A',
+    'darkseagreen':         '#8FBC8F',
+    'darkslateblue':        '#483D8B',
+    'darkslategray':        '#2F4F4F',
+    'darkslategrey':        '#2F4F4F',
+    'darkturquoise':        '#00CED1',
+    'darkviolet':           '#9400D3',
+    'deeppink':             '#FF1493',
+    'deepskyblue':          '#00BFFF',
+    'dimgray':              '#696969',
+    'dimgrey':              '#696969',
+    'dodgerblue':           '#1E90FF',
+    'firebrick':            '#B22222',
+    'floralwhite':          '#FFFAF0',
+    'forestgreen':          '#228B22',
+    'fuchsia':              '#FF00FF',
+    'gainsboro':            '#DCDCDC',
+    'ghostwhite':           '#F8F8FF',
+    'gold':                 '#FFD700',
+    'goldenrod':            '#DAA520',
+    'gray':                 '#808080',
+    'green':                '#008000',
+    'greenyellow':          '#ADFF2F',
+    'grey':                 '#808080',
+    'honeydew':             '#F0FFF0',
+    'hotpink':              '#FF69B4',
+    'indianred':            '#CD5C5C',
+    'indigo':               '#4B0082',
+    'ivory':                '#FFFFF0',
+    'khaki':                '#F0E68C',
+    'lavender':             '#E6E6FA',
+    'lavenderblush':        '#FFF0F5',
+    'lawngreen':            '#7CFC00',
+    'lemonchiffon':         '#FFFACD',
+    'lightblue':            '#ADD8E6',
+    'lightcoral':           '#F08080',
+    'lightcyan':            '#E0FFFF',
+    'lightgoldenrodyellow': '#FAFAD2',
+    'lightgray':            '#D3D3D3',
+    'lightgreen':           '#90EE90',
+    'lightgrey':            '#D3D3D3',
+    'lightpink':            '#FFB6C1',
+    'lightsalmon':          '#FFA07A',
+    'lightseagreen':        '#20B2AA',
+    'lightskyblue':         '#87CEFA',
+    'lightslategray':       '#778899',
+    'lightslategrey':       '#778899',
+    'lightsteelblue':       '#B0C4DE',
+    'lightyellow':          '#FFFFE0',
+    'lime':                 '#00FF00',
+    'limegreen':            '#32CD32',
+    'linen':                '#FAF0E6',
+    'magenta':              '#FF00FF',
+    'maroon':               '#800000',
+    'mediumaquamarine':     '#66CDAA',
+    'mediumblue':           '#0000CD',
+    'mediumorchid':         '#BA55D3',
+    'mediumpurple':         '#9370DB',
+    'mediumseagreen':       '#3CB371',
+    'mediumslateblue':      '#7B68EE',
+    'mediumspringgreen':    '#00FA9A',
+    'mediumturquoise':      '#48D1CC',
+    'mediumvioletred':      '#C71585',
+    'midnightblue':         '#191970',
+    'mintcream':            '#F5FFFA',
+    'mistyrose':            '#FFE4E1',
+    'moccasin':             '#FFE4B5',
+    'navajowhite':          '#FFDEAD',
+    'navy':                 '#000080',
+    'oldlace':              '#FDF5E6',
+    'olive':                '#808000',
+    'olivedrab':            '#6B8E23',
+    'orange':               '#FFA500',
+    'orangered':            '#FF4500',
+    'orchid':               '#DA70D6',
+    'palegoldenrod':        '#EEE8AA',
+    'palegreen':            '#98FB98',
+    'paleturquoise':        '#AFEEEE',
+    'palevioletred':        '#DB7093',
+    'papayawhip':           '#FFEFD5',
+    'peachpuff':            '#FFDAB9',
+    'peru':                 '#CD853F',
+    'pink':                 '#FFC0CB',
+    'plum':                 '#DDA0DD',
+    'powderblue':           '#B0E0E6',
+    'purple':               '#800080',
+    'rebeccapurple':        '#663399',
+    'red':                  '#FF0000',
+    'rosybrown':            '#BC8F8F',
+    'royalblue':            '#4169E1',
+    'saddlebrown':          '#8B4513',
+    'salmon':               '#FA8072',
+    'sandybrown':           '#F4A460',
+    'seagreen':             '#2E8B57',
+    'seashell':             '#FFF5EE',
+    'sienna':               '#A0522D',
+    'silver':               '#C0C0C0',
+    'skyblue':              '#87CEEB',
+    'slateblue':            '#6A5ACD',
+    'slategray':            '#708090',
+    'slategrey':            '#708090',
+    'snow':                 '#FFFAFA',
+    'springgreen':          '#00FF7F',
+    'steelblue':            '#4682B4',
+    'tan':                  '#D2B48C',
+    'teal':                 '#008080',
+    'thistle':              '#D8BFD8',
+    'tomato':               '#FF6347',
+    'turquoise':            '#40E0D0',
+    'violet':               '#EE82EE',
+    'wheat':                '#F5DEB3',
+    'white':                '#FFFFFF',
+    'whitesmoke':           '#F5F5F5',
+    'yellow':               '#FFFF00',
+    'yellowgreen':          '#9ACD32'}