zeed-movs-viewer 0.0.0__py3-none-any.whl

movsviewer/automation.py

@@ -0,0 +1,131 @@
+from contextlib import contextmanager
+from logging import info
+from os import listdir
+from pathlib import Path
+from tempfile import TemporaryDirectory
+from typing import TYPE_CHECKING
+
+from selenium.webdriver import Firefox
+from selenium.webdriver.common.by import By
+from selenium.webdriver.common.keys import Keys
+from selenium.webdriver.firefox.firefox_profile import FirefoxProfile
+from selenium.webdriver.firefox.options import Options
+from selenium.webdriver.firefox.service import Service
+from selenium.webdriver.remote.webelement import WebElement
+from selenium.webdriver.support.expected_conditions import all_of
+from selenium.webdriver.support.expected_conditions import (
+    element_to_be_clickable,
+)
+from selenium.webdriver.support.expected_conditions import (
+    invisibility_of_element,
+)
+from selenium.webdriver.support.expected_conditions import (
+    presence_of_element_located,
+)
+from selenium.webdriver.support.expected_conditions import url_contains
+from selenium.webdriver.support.select import Select
+from selenium.webdriver.support.wait import WebDriverWait
+
+from movsviewer.constants import GECKODRIVER_PATH
+
+if TYPE_CHECKING:
+    from collections.abc import Callable
+    from collections.abc import Iterator
+
+    from selenium.webdriver.remote.webdriver import WebDriver
+
+
+def get_options(dtemp: str) -> Options:
+    options = Options()
+
+    options.profile = FirefoxProfile()
+    # set download folder
+    options.profile.set_preference('browser.download.folderList', 2)
+    options.profile.set_preference('browser.download.dir', dtemp)
+
+    return options
+
+
+def _w(
+    wait: 'WebDriverWait[WebDriver]',
+    condition: """Callable[[tuple[str, str]],
+                           Callable[[WebDriver], bool | WebElement]]""",
+    css_selector: str,
+) -> WebElement:
+    ret = wait.until(condition((By.CSS_SELECTOR, css_selector)))
+    if not isinstance(ret, WebElement):
+        raise TypeError
+    return ret
+
+
+def _c(wait: 'WebDriverWait[WebDriver]', css_selector: str) -> WebElement:
+    return _w(wait, element_to_be_clickable, css_selector)
+
+
+def _p(wait: 'WebDriverWait[WebDriver]', css_selector: str) -> WebElement:
+    return _w(wait, presence_of_element_located, css_selector)
+
+
+def _i(wait: 'WebDriverWait[WebDriver]', css_selector: str) -> WebElement:
+    return _w(wait, invisibility_of_element, css_selector)
+
+
+def pl(wait: 'WebDriverWait[WebDriver]', wd: 'WebDriver') -> None:
+    _p(wait, '.pageLoader')
+    founds = wd.find_elements(By.CSS_SELECTOR, '.pageLoader')
+    wait.until(all_of(*(invisibility_of_element(found) for found in founds)))
+
+
+HP = 'https://bancoposta.poste.it/bpol/public/BPOL_ListaMovimentiAPP/index.html'
+
+
+@contextmanager
+def get_movimenti(
+    username: str, password: str, num_conto: str, get_otp: 'Callable[[], str]'
+) -> 'Iterator[Path]':
+    with (
+        TemporaryDirectory() as dtemp,
+        Firefox(
+            service=Service(executable_path=str(GECKODRIVER_PATH)),
+            options=get_options(dtemp),
+        ) as wd
+    ):  # fmt: skip
+        wait = WebDriverWait(wd, 1000)
+        # login
+        wd.get(HP)
+        pl(wait, wd)
+        wd.find_element(By.CSS_SELECTOR, '#username').send_keys(username)
+        wd.find_element(By.CSS_SELECTOR, '#password').send_keys(
+            password + Keys.RETURN
+        )
+        wait.until(
+            url_contains(
+                'https://idp-poste.poste.it/jod-idp-retail/cas/app.html'
+            )
+        )
+        pl(wait, wd)
+        _c(wait, '#_prosegui').click()
+        otp = get_otp()
+        wd.find_element(By.CSS_SELECTOR, '#otp').send_keys(otp + Keys.RETURN)
+
+        # choose conto and download text
+        _p(wait, f'select.numconto>option[value="string:{num_conto}"]')
+        pl(wait, wd)
+        Select(_p(wait, 'select.numconto')).select_by_value(
+            f'string:{num_conto}'
+        )
+
+        # hide cookie banner
+        wd.execute_script(
+            'document.querySelector("#content-alert-cookie")'
+            '.style.display="none"'
+        )
+        _c(wait, '#select>option[value=TESTO]')
+        Select(_p(wait, '#select')).select_by_value('TESTO')
+
+        info('prima: %s', listdir(dtemp))
+        _c(wait, '#downloadApi').click()
+        _i(wait, '.waiting')
+        info('dopo:  %s', listdir(dtemp))
+
+        yield Path(dtemp) / 'ListaMovimenti.txt'

movsviewer/chartview.py

@@ -0,0 +1,456 @@
+from abc import abstractmethod
+from dataclasses import dataclass
+from datetime import UTC
+from datetime import date
+from datetime import datetime
+from datetime import time
+from decimal import Decimal
+from itertools import accumulate
+from itertools import chain
+from itertools import groupby
+from typing import TYPE_CHECKING
+from typing import NamedTuple
+from typing import Self
+from typing import cast
+from typing import override
+
+from guilib.chartwidget.chartwidget import ChartWidget
+from guilib.chartwidget.modelgui import SeriesModel
+from guilib.chartwidget.modelgui import SeriesModelUnit
+from guilib.chartwidget.viewmodel import SortFilterViewModel
+from guilib.dates.converters import date2days
+from guilib.dates.converters import date2QDateTime
+from movslib.model import ZERO
+from PySide6.QtCharts import QBarCategoryAxis
+from PySide6.QtCharts import QBarSeries
+from PySide6.QtCharts import QBarSet
+from PySide6.QtCharts import QCategoryAxis
+from PySide6.QtCharts import QChart
+from PySide6.QtCharts import QLineSeries
+from PySide6.QtCharts import QValueAxis
+from PySide6.QtCore import Qt
+
+from movsviewer.reader import read
+
+if TYPE_CHECKING:
+    from collections.abc import Iterable
+    from collections.abc import Sequence
+
+    from guilib.chartwidget.model import Column
+    from guilib.chartwidget.model import ColumnHeader
+    from guilib.chartwidget.model import Info
+    from movslib.model import Row
+    from PySide6.QtWidgets import QGraphicsSceneMouseEvent
+    from PySide6.QtWidgets import QGraphicsSceneWheelEvent
+
+
+class Point(NamedTuple):
+    data: date
+    mov: Decimal
+
+
+def to_point(row: 'Row') -> Point:
+    if row.accrediti is not None:
+        mov = row.accrediti
+    elif row.addebiti is not None:
+        mov = -row.addebiti
+    else:
+        mov = ZERO
+    return Point(row.date, mov)
+
+
+def build_series(
+    data: 'Sequence[Row]', epoch: date = date(2008, 1, 1)
+) -> QLineSeries:
+    data = sorted(data, key=lambda row: row.date)
+
+    series = QLineSeries()
+    series.setName('data')
+
+    # add start and today
+    moves = chain(
+        (Point(epoch, ZERO),),
+        map(to_point, data),
+        (Point(datetime.now(tz=UTC).date(), ZERO),),
+    )
+
+    def sumy(a: Point, b: Point) -> Point:
+        return Point(b.data, a.mov + b.mov)
+
+    summes = accumulate(moves, func=sumy)
+
+    floats = (
+        (datetime.combine(data, time()).timestamp() * 1000, mov)
+        for data, mov in summes
+    )
+
+    # step the movements
+    last_mov: Decimal | None = None
+    for ts, mov in floats:
+        if last_mov is not None:
+            series.append(ts, float(last_mov))
+        series.append(ts, float(mov))
+        last_mov = mov
+
+    return series
+
+
+def build_group_by_year_series(
+    data: 'Sequence[Row]',
+) -> tuple[QBarSeries, QBarCategoryAxis]:
+    data = sorted(data, key=lambda row: row.date)
+
+    axis_x = QBarCategoryAxis()
+
+    series = QBarSeries()
+    barset = QBarSet('group by year')
+    series.append(barset)
+
+    def sum_points(points: 'Iterable[Point]') -> Decimal:
+        return sum((point.mov for point in points), start=ZERO)
+
+    years = []
+    for year, points in groupby(
+        map(to_point, data), lambda point: point.data.year
+    ):
+        barset.append(float(sum_points(points)))
+        years.append(f'{year}')
+    axis_x.setCategories(years)
+
+    return series, axis_x
+
+
+def build_group_by_month_series(
+    data: 'Sequence[Row]',
+) -> tuple[QBarSeries, QBarCategoryAxis]:
+    data = sorted(data, key=lambda row: row.date)
+
+    axis_x = QBarCategoryAxis()
+
+    series = QBarSeries()
+    barset = QBarSet('group by month')
+    series.append(barset)
+
+    def sum_points(points: 'Iterable[Point]') -> Decimal:
+        return sum((point.mov for point in points), start=ZERO)
+
+    year_months = []
+    for (year, month), points in groupby(
+        map(to_point, data), lambda point: (point.data.year, point.data.month)
+    ):
+        barset.append(float(sum_points(points)))
+        year_months.append(f'{year}-{month}')
+    axis_x.setCategories(year_months)
+
+    return series, axis_x
+
+
+class Chart(QChart):
+    def __init__(self, data: 'Sequence[Row]') -> None:
+        super().__init__()
+
+        def years(data: 'Sequence[Row]') -> list[date]:
+            if not data:
+                return []
+            data = sorted(data, key=lambda row: row.date)
+            start = data[0].date.year - 1
+            end = data[-1].date.year + 1
+            return [date(year, 1, 1) for year in range(start, end + 1)]
+
+        def months(data: 'Sequence[Row]', step: int = 1) -> list[date]:
+            if not data:
+                return []
+            data = sorted(data, key=lambda row: row.date)
+            start = data[0].date.year - 1
+            end = data[-1].date.year + 1
+            return [
+                date(year, month, 1)
+                for year in range(start, end + 1)
+                for month in range(1, 13, step)
+            ]
+
+        def reset_axis_x_labels() -> None:
+            if True:
+                pass
+
+        def ts(d: date) -> float:
+            return (
+                datetime(d.year, d.month, d.day, tzinfo=UTC).timestamp() * 1000
+            )
+
+        axis_y = QValueAxis()
+        axis_y.setTickType(QValueAxis.TickType.TicksDynamic)
+        axis_y.setTickAnchor(0.0)
+        axis_y.setTickInterval(10000.0)
+        axis_y.setMinorTickCount(9)
+        self.addAxis(axis_y, Qt.AlignmentFlag.AlignLeft)
+
+        axis_x = QCategoryAxis()
+        axis_x.setLabelsPosition(
+            QCategoryAxis.AxisLabelsPosition.AxisLabelsPositionOnValue
+        )
+        for dt in months(data, 6):
+            axis_x.append(f'{dt}', ts(dt))
+        self.addAxis(axis_x, Qt.AlignmentFlag.AlignBottom)
+
+        series = build_series(data)
+        self.addSeries(series)
+        series.attachAxis(axis_x)
+        series.attachAxis(axis_y)
+
+        group_by_year_series, axis_x_years = build_group_by_year_series(data)
+        self.addSeries(group_by_year_series)
+        self.addAxis(axis_x_years, Qt.AlignmentFlag.AlignBottom)
+        group_by_year_series.attachAxis(axis_y)
+
+        group_by_month_series, axis_x_months = build_group_by_month_series(data)
+        self.addSeries(group_by_month_series)
+        self.addAxis(axis_x_months, Qt.AlignmentFlag.AlignBottom)
+        group_by_month_series.attachAxis(axis_y)
+
+    @override
+    def wheelEvent(self, event: 'QGraphicsSceneWheelEvent') -> None:
+        super().wheelEvent(event)
+        y = event.delta()
+        if y < 0:
+            self.zoom(0.75)  # zoomOut is ~ .5
+        elif y > 0:
+            self.zoomIn()
+
+    @override
+    def mousePressEvent(self, event: 'QGraphicsSceneMouseEvent') -> None:
+        super().mousePressEvent(event)
+        event.accept()
+
+    @override
+    def mouseMoveEvent(self, event: 'QGraphicsSceneMouseEvent') -> None:
+        super().mouseMoveEvent(event)
+
+        x_curr, y_curr = cast(tuple[float, float], event.pos().toTuple())
+        x_prev, y_prev = cast(tuple[float, float], event.lastPos().toTuple())
+        self.scroll(x_prev - x_curr, y_curr - y_prev)
+
+
+class CH:
+    def __init__(self, name: str) -> None:
+        self.name = name
+
+    @override
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, CH):
+            return NotImplemented
+        return self.name == other.name
+
+
+class C:
+    def __init__(
+        self, header: 'ColumnHeader', howmuch: 'Decimal | None'
+    ) -> None:
+        self.header = header
+        self.howmuch = howmuch
+
+
+class I:  # noqa: E742
+    def __init__(self, when: 'date', columns: 'Sequence[Column]') -> None:
+        self.when = when
+        self.columns = columns
+
+    def howmuch(self, column_header: 'ColumnHeader') -> 'Decimal | None':
+        for column in self.columns:
+            if column.header == column_header:
+                return column.howmuch
+        return None
+
+
+MONEY_HEADER = CH('money')
+
+
+@dataclass
+class SMFShared:
+    x_min: date
+    x_max: date
+    y_min: Decimal
+    y_max: Decimal
+
+
+class SMFHelper:
+    def __init__(self, line_series: QLineSeries, shared: SMFShared) -> None:
+        self.line_series = line_series
+        self.shared = shared
+        self.acc = 0.0
+        self.last: date | None = None
+
+    @abstractmethod
+    def step(
+        self, when: date, when_d: int, howmuch: Decimal, howmuch_f: float
+    ) -> None: ...
+
+
+class SMFMoney(SMFHelper):
+    @override
+    def __init__(self, line_series: QLineSeries, shared: SMFShared) -> None:
+        super().__init__(line_series, shared)
+        self.line_series.setName('money')
+
+    @override
+    def step(
+        self,
+        when: date,  # @UnusedVariable
+        when_d: int,
+        howmuch: Decimal,
+        howmuch_f: float,
+    ) -> None:
+        self.line_series.append(when_d, 0)
+        # TODO @me: fix hover to deal with a variable number of items in series
+        # TOD000
+        self.line_series.append(when_d, howmuch_f)
+
+        self.shared.y_min = min(howmuch, self.shared.y_min)
+        self.shared.y_max = max(self.shared.y_max, howmuch)
+
+
+class SMFMoneyAcc(SMFHelper):
+    @override
+    def __init__(self, line_series: QLineSeries, shared: SMFShared) -> None:
+        super().__init__(line_series, shared)
+        self.line_series.setName('money acc')
+
+    @override
+    def step(
+        self,
+        when: date,  # @UnusedVariable
+        when_d: int,
+        howmuch: Decimal,  # @UnusedVariable
+        howmuch_f: float,
+    ) -> None:
+        self.line_series.append(when_d, self.acc)
+        self.acc += howmuch_f
+        self.line_series.append(when_d, self.acc)
+
+        if self.acc < self.shared.y_min:
+            self.shared.y_min = Decimal(self.acc)
+        if self.shared.y_max < self.acc:
+            self.shared.y_max = Decimal(self.acc)
+
+
+class SMFMoneyByMonth(SMFHelper):
+    @override
+    def __init__(self, line_series: QLineSeries, shared: SMFShared) -> None:
+        super().__init__(line_series, shared)
+        self.line_series.setName('money by month')
+
+    @override
+    def step(
+        self,
+        when: date,
+        when_d: int,
+        howmuch: Decimal,  # @UnusedVariable
+        howmuch_f: float,
+    ) -> None:
+        # money_by_month
+        self.line_series.append(when_d, self.acc)
+        if self.last is None or self.last.month != when.month:
+            self.acc = 0.0
+        else:
+            self.acc += howmuch_f
+        self.line_series.append(when_d, self.acc)
+        self.last = when
+
+        if self.acc < self.shared.y_min:
+            self.shared.y_min = Decimal(self.acc)
+        if self.shared.y_max < self.acc:
+            self.shared.y_max = Decimal(self.acc)
+
+
+class SMFMoneyByYear(SMFHelper):
+    @override
+    def __init__(self, line_series: QLineSeries, shared: SMFShared) -> None:
+        super().__init__(line_series, shared)
+        self.line_series.setName('money by year')
+
+    @override
+    def step(
+        self,
+        when: date,
+        when_d: int,
+        howmuch: Decimal,  # @UnusedVariable
+        howmuch_f: float,
+    ) -> None:
+        # money_by_year
+        self.line_series.append(when_d, self.acc)
+        if self.last is None or self.last.year != when.year:
+            self.acc = 0.0
+        else:
+            self.acc += howmuch_f
+        self.line_series.append(when_d, self.acc)
+        self.last = when
+
+        if self.acc < self.shared.y_min:
+            self.shared.y_min = Decimal(self.acc)
+        if self.shared.y_max < self.acc:
+            self.shared.y_max = Decimal(self.acc)
+
+
+def series_model_factory(infos: 'Sequence[Info]') -> 'SeriesModel':
+    """Extract money from info; accumulate and step; group by month / year."""
+    shared = SMFShared(
+        x_min=date.max,
+        x_max=date.min,
+        y_min=Decimal('inf'),
+        y_max=-Decimal('inf'),
+    )
+
+    money = SMFMoney(QLineSeries(), shared)
+    money_acc = SMFMoneyAcc(QLineSeries(), shared)
+    money_by_month = SMFMoneyByMonth(QLineSeries(), shared)
+    money_by_year = SMFMoneyByYear(QLineSeries(), shared)
+
+    for info in infos:
+        when = info.when
+        howmuch = info.howmuch(MONEY_HEADER)
+        if howmuch is None:
+            continue
+
+        shared.x_min = min(when, shared.x_min)
+        shared.x_max = max(when, shared.x_max)
+
+        when_d = date2days(when)
+        howmuch_f = float(howmuch)
+
+        money.step(when, when_d, howmuch, howmuch_f)
+        money_acc.step(when, when_d, howmuch, howmuch_f)
+        money_by_month.step(when, when_d, howmuch, howmuch_f)
+        money_by_year.step(when, when_d, howmuch, howmuch_f)
+
+    return SeriesModel(
+        [
+            money.line_series,
+            money_acc.line_series,
+            money_by_month.line_series,
+            money_by_year.line_series,
+        ],
+        date2QDateTime(shared.x_min),
+        date2QDateTime(shared.x_max),
+        float(shared.y_min),
+        float(shared.y_max),
+        SeriesModelUnit.EURO,
+    )
+
+
+class ChartWidgetWrapper(ChartWidget):
+    def __init__(self, data_path: str) -> None:
+        self.data_path = data_path
+        self.model = SortFilterViewModel()
+        super().__init__(self.model, None, series_model_factory, '%d/%m/%Y')
+        self.setCursor(Qt.CursorShape.CrossCursor)
+        self.reload()
+
+    def reload(self) -> Self:
+        _, data = read(self.data_path)
+        # convert data to infos
+        infos = [
+            I(row.date, [C(MONEY_HEADER, row.money)])
+            for row in sorted(data, key=lambda row: row.date)
+        ]
+        self.model.update(infos)
+        return self

movsviewer/constants.py

@@ -0,0 +1,16 @@
+from pathlib import Path
+from typing import Final
+
+
+def _resource(filename: str) -> Path:
+    return Path(__file__).with_name('resources') / filename
+
+
+MAINUI_UI_PATH: Final = _resource('mainui.ui')
+SETTINGSUI_UI_PATH: Final = _resource('settingsui.ui')
+
+GECKODRIVER_PATH: Final = _resource('geckodriver.exe')
+
+SETTINGS_USERNAME: Final = 'username'
+SETTINGS_PASSWORD: Final = 'password'
+SETTINGS_DATA_PATHS: Final = 'dataPaths'

movsviewer/mainui.py

@@ -0,0 +1,168 @@
+from pathlib import Path
+from sys import argv
+from typing import TYPE_CHECKING
+from typing import Final
+from typing import cast
+
+from guilib.multitabs.widget import MultiTabs
+from guilib.searchsheet.widget import SearchSheet
+from PySide6.QtCore import QCoreApplication
+from PySide6.QtCore import QItemSelection
+from PySide6.QtCore import QItemSelectionModel
+from PySide6.QtCore import Qt
+from PySide6.QtQuick import QQuickWindow
+from PySide6.QtQuick import QSGRendererInterface
+from PySide6.QtUiTools import QUiLoader
+from PySide6.QtWidgets import QApplication
+from PySide6.QtWidgets import QDialog
+from PySide6.QtWidgets import QDialogButtonBox
+from PySide6.QtWidgets import QFileDialog
+from PySide6.QtWidgets import QGridLayout
+from PySide6.QtWidgets import QLineEdit
+from PySide6.QtWidgets import QMainWindow
+from PySide6.QtWidgets import QPlainTextEdit
+from PySide6.QtWidgets import QToolButton
+from PySide6.QtWidgets import QWidget
+
+from movsviewer.chartview import ChartWidgetWrapper
+from movsviewer.constants import MAINUI_UI_PATH
+from movsviewer.constants import SETTINGSUI_UI_PATH
+from movsviewer.settings import Settings
+from movsviewer.validator import Validator
+from movsviewer.viewmodel import SortFilterViewModel
+
+if TYPE_CHECKING:
+    from collections.abc import Callable
+
+    from PySide6.QtGui import QAction
+
+
+_DATA_PATHS_SEPARATOR = '; \n'
+
+
+class Mainui(QMainWindow):
+    actionSettings: 'QAction'  # noqa: N815
+    actionUpdate: 'QAction'  # noqa: N815
+    gridLayout: QGridLayout  # noqa: N815
+    centralwidget: QWidget
+
+
+class Settingsui(QDialog):
+    usernameLineEdit: QLineEdit  # noqa: N815
+    passwordLineEdit: QLineEdit  # noqa: N815
+    dataPaths: QPlainTextEdit  # noqa: N815
+    buttonBox: QDialogButtonBox  # noqa: N815
+    openFileChooser: QToolButton  # noqa: N815
+
+
+def _set_data_paths(data_paths: QPlainTextEdit, file_names: list[str]) -> None:
+    data_paths.setPlainText(_DATA_PATHS_SEPARATOR.join(file_names))
+
+
+def _get_data_paths(data_paths: QPlainTextEdit) -> list[str]:
+    return data_paths.toPlainText().split(_DATA_PATHS_SEPARATOR)
+
+
+def new_settingsui(settings: Settings) -> Settingsui:
+    def save_settings() -> None:
+        settings.data_paths = _get_data_paths(settingsui.dataPaths)
+        settings.username = settingsui.usernameLineEdit.text()
+        settings.password = settingsui.passwordLineEdit.text()
+
+    def open_data_paths() -> None:
+        file_names, _ = QFileDialog.getOpenFileNames(
+            settingsui, dir=str(Path.home())
+        )
+        _set_data_paths(settingsui.dataPaths, file_names)
+
+    settingsui = cast(Settingsui, QUiLoader().load(SETTINGSUI_UI_PATH))
+    settingsui.usernameLineEdit.setText(settings.username)
+    settingsui.passwordLineEdit.setText(settings.password)
+    _set_data_paths(settingsui.dataPaths, settings.data_paths)
+
+    settingsui.accepted.connect(save_settings)
+    settingsui.openFileChooser.clicked.connect(open_data_paths)
+
+    return settingsui
+
+
+class NewMainui:
+    sheets_charts: Final[
+        dict[str, tuple[SearchSheet, ChartWidgetWrapper, int]]
+    ] = {}
+
+    settings: Settings
+    mainui: Mainui
+    multi_tabs: MultiTabs
+
+    def __call__(self, settings: Settings, settingsui: Settingsui) -> QWidget:
+        self.settings = settings
+        self.mainui = cast(Mainui, QUiLoader().load(MAINUI_UI_PATH))
+
+        self.multi_tabs = MultiTabs(self.mainui.centralwidget)
+        self.mainui.gridLayout.addWidget(self.multi_tabs, 0, 0, 1, 1)
+
+        self.mainui.actionUpdate.triggered.connect(self.update_helper)
+        self.mainui.actionSettings.triggered.connect(settingsui.show)
+        settingsui.accepted.connect(self.update_helper)
+
+        self.update_helper()  # on startup load
+
+        return self.mainui
+
+    def new_search_sheet(
+        self, data_path: str
+    ) -> tuple[SearchSheet, SortFilterViewModel]:
+        model = SortFilterViewModel(data_path)
+        sheet = SearchSheet(None)
+        sheet.set_model(model)
+        selection_model = sheet.selection_model()
+        selection_model.selectionChanged.connect(
+            self.update_status_bar(model, selection_model)
+        )
+        return sheet, model
+
+    def update_helper(self) -> None:
+        if not Validator(self.mainui, self.settings).validate():
+            return
+
+        data_paths = self.settings.data_paths[:]
+        for data_path, (sheet, chart, idx) in self.sheets_charts.items():
+            if data_path in data_paths:
+                data_paths.remove(data_path)
+                sheet.reload()
+                chart.reload()
+            else:
+                self.multi_tabs.remove_double_box(idx)
+                del self.sheets_charts[data_path]
+        for data_path in data_paths:
+            sheet, model = self.new_search_sheet(data_path)
+            chart = ChartWidgetWrapper(data_path)
+            idx = self.multi_tabs.add_double_box(sheet, chart, model.name)
+            self.sheets_charts[data_path] = (sheet, chart, idx)
+
+    def update_status_bar(
+        self, model: SortFilterViewModel, selection_model: QItemSelectionModel
+    ) -> 'Callable[[QItemSelection, QItemSelection], None]':
+        return lambda _selected, _deselected: model.selection_changed(
+            selection_model, self.mainui.statusBar()
+        )
+
+
+def main() -> None:
+    QCoreApplication.setAttribute(
+        Qt.ApplicationAttribute.AA_ShareOpenGLContexts
+    )
+    QQuickWindow.setGraphicsApi(
+        QSGRendererInterface.GraphicsApi.OpenGLRhi  # @UndefinedVariable
+    )
+
+    app = QApplication(argv)
+    settings = Settings(argv[1:])
+    settingsui = new_settingsui(settings)
+    new_mainui = NewMainui()
+    mainui = new_mainui(settings, settingsui)
+
+    mainui.show()
+
+    raise SystemExit(app.exec())

movsviewer/reader.py

@@ -0,0 +1,42 @@
+from typing import TYPE_CHECKING
+from typing import Protocol
+from typing import overload
+
+from movslib.libretto import read_libretto
+from movslib.movs import read_txt
+
+if TYPE_CHECKING:
+    from movslib.model import KV
+    from movslib.model import Row
+    from movslib.model import Rows
+
+
+class Reader(Protocol):
+    @overload
+    def __call__(self, fn: str) -> 'tuple[KV, list[Row]]': ...
+
+    @overload
+    def __call__(self, fn: str, name: str) -> 'tuple[KV, Rows]': ...
+
+    def __call__(
+        self, fn: str, name: str | None = None
+    ) -> 'tuple[KV, list[Row] | Rows]': ...
+
+
+def _get_reader(fn: str) -> Reader:
+    if fn.endswith('.xlsx'):
+        return read_libretto
+    return read_txt
+
+
+@overload
+def read(fn: str) -> 'tuple[KV, list[Row]]': ...
+
+
+@overload
+def read(fn: str, name: str) -> 'tuple[KV, Rows]': ...
+
+
+def read(fn: str, name: str | None = None) -> 'tuple[KV, list[Row] | Rows]':
+    reader = _get_reader(fn)
+    return reader(fn) if name is None else reader(fn, name)

movsviewer/resources/mainui.ui

@@ -0,0 +1,57 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<ui version="4.0">
+ <class>MainWindow</class>
+ <widget class="QMainWindow" name="MainWindow">
+  <property name="geometry">
+   <rect>
+    <x>0</x>
+    <y>0</y>
+    <width>800</width>
+    <height>600</height>
+   </rect>
+  </property>
+  <property name="windowTitle">
+   <string>MainWindow</string>
+  </property>
+  <widget class="QWidget" name="centralwidget">
+   <layout class="QGridLayout" name="gridLayout"/>
+  </widget>
+  <widget class="QMenuBar" name="menubar">
+   <property name="geometry">
+    <rect>
+     <x>0</x>
+     <y>0</y>
+     <width>800</width>
+     <height>25</height>
+    </rect>
+   </property>
+   <widget class="QMenu" name="menu">
+    <property name="title">
+     <string>&amp;File</string>
+    </property>
+    <addaction name="actionUpdate"/>
+    <addaction name="actionSettings"/>
+    <addaction name="action_Merge"/>
+   </widget>
+   <addaction name="menu"/>
+  </widget>
+  <widget class="QStatusBar" name="statusbar"/>
+  <action name="actionUpdate">
+   <property name="text">
+    <string>&amp;Update</string>
+   </property>
+  </action>
+  <action name="actionSettings">
+   <property name="text">
+    <string>&amp;Settings</string>
+   </property>
+  </action>
+  <action name="action_Merge">
+   <property name="text">
+    <string>&amp;Merge</string>
+   </property>
+  </action>
+ </widget>
+ <resources/>
+ <connections/>
+</ui>

movsviewer/resources/settingsui.ui

@@ -0,0 +1,129 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<ui version="4.0">
+ <class>Dialog</class>
+ <widget class="QDialog" name="Dialog">
+  <property name="geometry">
+   <rect>
+    <x>0</x>
+    <y>0</y>
+    <width>703</width>
+    <height>247</height>
+   </rect>
+  </property>
+  <property name="windowTitle">
+   <string>Dialog</string>
+  </property>
+  <layout class="QGridLayout" name="gridLayout">
+   <item row="2" column="0">
+    <widget class="QDialogButtonBox" name="buttonBox">
+     <property name="orientation">
+      <enum>Qt::Horizontal</enum>
+     </property>
+     <property name="standardButtons">
+      <set>QDialogButtonBox::Cancel|QDialogButtonBox::Ok</set>
+     </property>
+    </widget>
+   </item>
+   <item row="1" column="0">
+    <widget class="QGroupBox" name="groupBox_2">
+     <property name="title">
+      <string>General</string>
+     </property>
+     <layout class="QFormLayout" name="formLayout">
+      <item row="0" column="0">
+       <widget class="QLabel" name="label_3">
+        <property name="text">
+         <string>Data paths</string>
+        </property>
+       </widget>
+      </item>
+      <item row="0" column="1">
+       <widget class="QSplitter" name="splitter">
+        <property name="orientation">
+         <enum>Qt::Horizontal</enum>
+        </property>
+        <widget class="QPlainTextEdit" name="dataPaths">
+         <property name="sizeAdjustPolicy">
+          <enum>QAbstractScrollArea::AdjustToContents</enum>
+         </property>
+         <property name="readOnly">
+          <bool>true</bool>
+         </property>
+        </widget>
+        <widget class="QToolButton" name="openFileChooser">
+         <property name="text">
+          <string>&amp;Open...</string>
+         </property>
+        </widget>
+       </widget>
+      </item>
+     </layout>
+    </widget>
+   </item>
+   <item row="0" column="0">
+    <widget class="QGroupBox" name="groupBox">
+     <property name="title">
+      <string>Poste</string>
+     </property>
+     <layout class="QFormLayout" name="formLayout_2">
+      <item row="0" column="0">
+       <widget class="QLabel" name="label">
+        <property name="text">
+         <string>Username</string>
+        </property>
+       </widget>
+      </item>
+      <item row="0" column="1">
+       <widget class="QLineEdit" name="usernameLineEdit"/>
+      </item>
+      <item row="1" column="0">
+       <widget class="QLabel" name="label_2">
+        <property name="text">
+         <string>Password</string>
+        </property>
+       </widget>
+      </item>
+      <item row="1" column="1">
+       <widget class="QLineEdit" name="passwordLineEdit"/>
+      </item>
+     </layout>
+    </widget>
+   </item>
+  </layout>
+ </widget>
+ <resources/>
+ <connections>
+  <connection>
+   <sender>buttonBox</sender>
+   <signal>accepted()</signal>
+   <receiver>Dialog</receiver>
+   <slot>accept()</slot>
+   <hints>
+    <hint type="sourcelabel">
+     <x>257</x>
+     <y>190</y>
+    </hint>
+    <hint type="destinationlabel">
+     <x>157</x>
+     <y>199</y>
+    </hint>
+   </hints>
+  </connection>
+  <connection>
+   <sender>buttonBox</sender>
+   <signal>rejected()</signal>
+   <receiver>Dialog</receiver>
+   <slot>reject()</slot>
+   <hints>
+    <hint type="sourcelabel">
+     <x>325</x>
+     <y>190</y>
+    </hint>
+    <hint type="destinationlabel">
+     <x>286</x>
+     <y>199</y>
+    </hint>
+   </hints>
+  </connection>
+ </connections>
+</ui>

movsviewer/settings.py

@@ -0,0 +1,51 @@
+from typing import cast
+
+from PySide6.QtCore import QSettings
+
+from movsviewer.constants import SETTINGS_DATA_PATHS
+from movsviewer.constants import SETTINGS_PASSWORD
+from movsviewer.constants import SETTINGS_USERNAME
+
+
+class Settings:
+    def __init__(self, argv1: list[str]) -> None:
+        self.settings = QSettings('ZeeD', 'mypyui')
+        self.argv1 = argv1
+
+    @property
+    def username(self) -> str:
+        value = self.settings.value(SETTINGS_USERNAME)
+        return cast(str, value) if value is not None else ''
+
+    @username.setter
+    def username(self, username: str) -> None:
+        self.settings.setValue(SETTINGS_USERNAME, username)
+
+    @property
+    def password(self) -> str:
+        value = self.settings.value(SETTINGS_PASSWORD)
+        return cast(str, value) if value is not None else ''
+
+    @password.setter
+    def password(self, password: str) -> None:
+        self.settings.setValue(SETTINGS_PASSWORD, password)
+
+    @property
+    def data_paths(self) -> list[str]:
+        if self.argv1:
+            return self.argv1
+
+        value = self.settings.value(SETTINGS_DATA_PATHS)
+
+        if value is None:
+            return []
+        if isinstance(value, str):
+            return [value]
+        if isinstance(value, list):
+            return value
+
+        raise ValueError(value)
+
+    @data_paths.setter
+    def data_paths(self, data_paths: list[str]) -> None:
+        self.settings.setValue(SETTINGS_DATA_PATHS, data_paths)

movsviewer/validator.py

@@ -0,0 +1,78 @@
+from datetime import UTC
+from datetime import date
+from datetime import datetime
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+from PySide6.QtWidgets import QMessageBox
+from PySide6.QtWidgets import QWidget
+
+from movsviewer.reader import read
+
+if TYPE_CHECKING:
+    from movslib.model import KV
+    from movslib.model import Rows
+
+    from movsviewer.settings import Settings
+
+
+def validate_saldo(kv: 'KV', csv: 'Rows', messages: list[str]) -> bool:
+    messages.append(f'bpol.saldo_al:                      {kv.saldo_al}')
+    if kv.saldo_al:
+        ultimo_update = (datetime.now(tz=UTC).date() - kv.saldo_al).days
+        messages.append(
+            f'ultimo update:                      {ultimo_update} giorni fa'
+        )
+    messages.append(
+        f'bpol.saldo_contabile:               {float(kv.saldo_contabile):_}'
+    )
+    messages.append(
+        f'bpol.saldo_disponibile:             {float(kv.saldo_disponibile):_}'
+    )
+
+    s = sum(item.money for item in csv)
+    messages.append(f'Σ (item.accredito - item.addebito): {float(s):_}')
+    ret = kv.saldo_contabile == s == kv.saldo_disponibile
+    if not ret:
+        delta = max(
+            [abs(kv.saldo_contabile - s), abs(s - kv.saldo_disponibile)]
+        )
+        messages.append(f'Δ:                                  {float(delta):_}')
+    return ret
+
+
+def validate_dates(csv: 'Rows', messages: list[str]) -> bool:
+    data_contabile: date | None = None
+    for row in csv:
+        if data_contabile is not None and data_contabile < row.data_contabile:
+            messages.append(f'{data_contabile} < {row.data_contabile}!')
+            return False
+    return True
+
+
+def validate(fn: str, messages: list[str]) -> bool:
+    messages.append(fn)
+    kv, csv = read(fn, Path(fn).stem)
+    return all(
+        [validate_saldo(kv, csv, messages), validate_dates(csv, messages)]
+    )
+
+
+class Validator:
+    def __init__(self, parent: QWidget, settings: 'Settings') -> None:
+        self.parent = parent
+        self.settings = settings
+
+    def validate(self) -> bool:
+        for fn in self.settings.data_paths:
+            messages: list[str] = []
+            if not validate(fn, messages):
+                button = QMessageBox.warning(
+                    self.parent,
+                    f'{fn} seems has some problems!',
+                    '\n'.join(messages),
+                    QMessageBox.StandardButton.Yes
+                    | QMessageBox.StandardButton.No,
+                )
+                return button is QMessageBox.StandardButton.Yes
+        return True

movsviewer/viewmodel.py

@@ -0,0 +1,181 @@
+from dataclasses import fields
+from datetime import date
+from decimal import Decimal
+from operator import iadd
+from operator import isub
+from pathlib import Path
+from typing import TYPE_CHECKING
+from typing import Self
+from typing import cast
+from typing import override
+
+from guilib.searchsheet.model import SearchableModel
+from movslib.model import ZERO
+from movslib.model import Row
+from movslib.model import Rows
+from PySide6.QtCore import QAbstractTableModel
+from PySide6.QtCore import QItemSelectionModel
+from PySide6.QtCore import QModelIndex
+from PySide6.QtCore import QObject
+from PySide6.QtCore import QPersistentModelIndex
+from PySide6.QtCore import Qt
+from PySide6.QtGui import QBrush
+from PySide6.QtGui import QColor
+
+from movsviewer.reader import read
+
+if TYPE_CHECKING:
+    from PySide6.QtWidgets import QStatusBar
+
+
+FIELD_NAMES = [field.name for field in fields(Row)]
+
+T_FIELDS = date | Decimal | None | str
+
+
+def _abs(row: Row) -> Decimal:
+    if row.addebiti is not None:
+        return -row.addebiti
+    if row.accrediti is not None:
+        return row.accrediti
+    return ZERO
+
+
+T_INDEX = QModelIndex | QPersistentModelIndex
+
+
+_INDEX = QModelIndex()
+
+
+class ViewModel(QAbstractTableModel):
+    def __init__(self, data: Rows, parent: QObject | None = None) -> None:
+        super().__init__(parent)
+        self._set_data(data)
+
+    def _set_data(self, data: Rows) -> None:
+        self._data = data
+        abs_data = sorted([_abs(row) for row in data])
+        self._min = abs_data[0] if abs_data else ZERO
+        self._max = abs_data[-1] if abs_data else ZERO
+
+    @override
+    def rowCount(self, _parent: T_INDEX = _INDEX) -> int:
+        return len(self._data)
+
+    @override
+    def columnCount(self, _parent: T_INDEX = _INDEX) -> int:
+        return len(FIELD_NAMES)
+
+    @override
+    def headerData(
+        self,
+        section: int,
+        orientation: Qt.Orientation,
+        role: int = Qt.ItemDataRole.DisplayRole,
+    ) -> str | None:
+        if role != Qt.ItemDataRole.DisplayRole:
+            return None
+
+        if orientation != Qt.Orientation.Horizontal:
+            return None
+
+        return FIELD_NAMES[section]
+
+    @override
+    def data(
+        self,
+        index: QModelIndex | QPersistentModelIndex,
+        role: int = Qt.ItemDataRole.DisplayRole,
+    ) -> T_FIELDS | QBrush | None:
+        column = index.column()
+        row = index.row()
+
+        if role == Qt.ItemDataRole.DisplayRole:
+            return str(getattr(self._data[row], FIELD_NAMES[column]))
+
+        if role == Qt.ItemDataRole.BackgroundRole:
+            max_, min_, val = self._max, self._min, _abs(self._data[row])
+            perc = (
+                (val - min_) / (max_ - min_) if max_ != min_ else Decimal(0.5)
+            )
+
+            hue = int(perc * 120)  # 0..359 ; red=0, green=120
+            saturation = 223  # 0..255
+            lightness = 159  # 0..255
+
+            return QBrush(QColor.fromHsl(hue, saturation, lightness))
+
+        if role == Qt.ItemDataRole.UserRole:
+            return cast(T_FIELDS, getattr(self._data[row], FIELD_NAMES[column]))
+
+        return None
+
+    @override
+    def sort(
+        self, index: int, order: Qt.SortOrder = Qt.SortOrder.AscendingOrder
+    ) -> None:
+        def key(row: Row) -> date | Decimal | str:  # T_FIELDS - None
+            e: T_FIELDS = getattr(row, FIELD_NAMES[index])
+            if e is None:
+                return ZERO
+            return e
+
+        self.layoutAboutToBeChanged.emit()
+        try:
+            self._data.sort(
+                key=key, reverse=order == Qt.SortOrder.DescendingOrder
+            )
+        finally:
+            self.layoutChanged.emit()
+
+    def load(self, data: Rows) -> None:
+        self.beginResetModel()
+        try:
+            self._set_data(data)
+        finally:
+            self.endResetModel()
+
+    @property
+    def name(self) -> str:
+        return self._data.name
+
+
+class SortFilterViewModel(SearchableModel):
+    def __init__(self, data_path: str) -> None:
+        super().__init__(ViewModel(Rows('')))
+        self.data_path = data_path
+        self.reload()
+
+    @override
+    def sourceModel(self) -> ViewModel:
+        return cast(ViewModel, super().sourceModel())
+
+    @override
+    def sort(
+        self, column: int, order: Qt.SortOrder = Qt.SortOrder.AscendingOrder
+    ) -> None:
+        self.sourceModel().sort(column, order)
+
+    def selection_changed(
+        self, selection_model: QItemSelectionModel, statusbar: 'QStatusBar'
+    ) -> None:
+        addebiti_index = FIELD_NAMES.index('addebiti')
+        accrediti_index = FIELD_NAMES.index('accrediti')
+
+        bigsum = 0
+        for column, iop in ((addebiti_index, isub), (accrediti_index, iadd)):
+            for index in selection_model.selectedRows(column):
+                data = index.data(Qt.ItemDataRole.UserRole)
+                if data is not None:
+                    bigsum = iop(bigsum, data)
+
+        statusbar.showMessage(f'⅀ = {bigsum}')
+
+    def reload(self) -> Self:
+        _, data = read(self.data_path, Path(self.data_path).stem)
+        self.sourceModel().load(data)
+        return self
+
+    @property
+    def name(self) -> str:
+        return self.sourceModel().name

zeed_movs_viewer-0.0.0.dist-info/METADATA

@@ -0,0 +1,15 @@
+Metadata-Version: 2.1
+Name: zeed-movs-viewer
+Version: 0.0.0
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.12
+Project-URL: Homepage, https://github.com/ZeeD/movs-viewer
+Project-URL: Repository, https://github.com/ZeeD/movs-viewer.git
+Requires-Python: ==3.12.*
+Requires-Dist: pyside6!=6.8,!=6.8.0.1,>=6.7
+Requires-Dist: pythonqwt>=0.12.5
+Requires-Dist: selenium>=4.22
+Requires-Dist: zeed-guilib>=0.0.2
+Requires-Dist: zeed-movs-merger>=0
+Requires-Dist: zeed-movslib>=0.0.2
+

zeed_movs_viewer-0.0.0.dist-info/RECORD

@@ -0,0 +1,16 @@
+movsviewer/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+movsviewer/automation.py,sha256=HwMiywH2YboXB8WyxP8hIoQgNMmNK-Gq_RWtHJh4zBg,4323
+movsviewer/chartview.py,sha256=8XhOiXIo6vjL0uOGBhBQrl18u7q6X9OkdClfZTIhJDY,13470
+movsviewer/constants.py,sha256=06WyNwgQwEkBrkvrryzEtdWV5mRUBycKe9RTe7PQ_mk,428
+movsviewer/mainui.py,sha256=RLxEPoNL3uUxB4ieJemB8-P6-qZX7voUwwqR3rJ_XOA,5717
+movsviewer/reader.py,sha256=8glE4CSv5RMe8ezP3RvKdzLqYhoT-Oy03My1oP5Dmdk,997
+movsviewer/resources/geckodriver.exe,sha256=CCfcGwdNLMMpCWKc05nDO-3q6C88o3sEllUGV4HDGLM,3300792
+movsviewer/resources/mainui.ui,sha256=lCMfw4A0KkVw9KP14raCaGzDKc7Hx2W8OexZxT3npQk,1376
+movsviewer/resources/settingsui.ui,sha256=6eH5C9rkNrPlyp3JCQSW06drKhepwdQ0la4VGiqmPvE,3369
+movsviewer/settings.py,sha256=yMLzNHiWYo9iUQYtRMNvs5UYbt0k4DndW7svNU2O_tg,1462
+movsviewer/validator.py,sha256=huYRRRTIjVQHm6DlbtXVYROp0_SM5_7Vv7WV42d2or4,2560
+movsviewer/viewmodel.py,sha256=ZEDy4I3bcSQh3ewQ_1K_fJ6ZJTJRHmwN0kH4rUPUSnk,5204
+zeed_movs_viewer-0.0.0.dist-info/METADATA,sha256=3iC7EOQhBJ75187XeNUcLIcSA5ymg9hvq-UfTBer0PY,529
+zeed_movs_viewer-0.0.0.dist-info/WHEEL,sha256=pM0IBB6ZwH3nkEPhtcp50KvKNX-07jYtnb1g1m6Z4Co,90
+zeed_movs_viewer-0.0.0.dist-info/entry_points.txt,sha256=Cr9WqD8tBOMTJBuMV6-ayk_L49BmMfrKyZLk51-0008,71
+zeed_movs_viewer-0.0.0.dist-info/RECORD,,

zeed_movs_viewer-0.0.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: pdm-backend (2.4.2)
+Root-Is-Purelib: true
+Tag: py3-none-any

zeed_movs_viewer-0.0.0.dist-info/entry_points.txt

@@ -0,0 +1,5 @@
+[console_scripts]
+
+[gui_scripts]
+movs-viewer = movsviewer.mainui:main
+