recolul 1.20.0__tar.gz

recolul-1.20.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) [year] [fullname]
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

recolul-1.20.0/PKG-INFO

@@ -0,0 +1,72 @@
+Metadata-Version: 2.1
+Name: recolul
+Version: 1.20.0
+Summary: Overtime management for RecoRu
+Home-page: https://github.com/Maerig/recolul
+Author: Jean-Loup Roussel-Clouet
+Author-email: jean-loup@cryptact.com
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Provides-Extra: dev
+Provides-Extra: gui
+License-File: LICENSE
+
+# RecoLul
+
+## Installation
+
+```
+pip install recolul
+recolul config
+```
+
+## Usage
+
+### Overtime balance
+
+```shell
+$ recolul balance
+Monthly overtime balance: 00:51
+
+Last day 2/6(月)
+  Clock-in: 09:10
+  Working hours: 07:19
+  Break: 01:00
+```
+
+### Overtime balance graph
+
+```shell
+$ recolul graph
+```
+
+![Overtime balance graph](./doc/graph_example.png)
+
+### When to leave
+
+```shell
+$ recolul when
+Leave today at 17:43 to avoid overtime (includes a 1-hour break).
+```
+
+## Config
+
+### Environment variables
+
+- `RECORU_AUTH_ID`
+- `RECORU_CONTRACT_ID`
+- `RECORU_PASSWORD`
+
+### Config file
+
+```
+recolul config
+```
+
+## Build
+
+```
+python -m build
+```

recolul-1.20.0/README.md

@@ -0,0 +1,57 @@
+# RecoLul
+
+## Installation
+
+```
+pip install recolul
+recolul config
+```
+
+## Usage
+
+### Overtime balance
+
+```shell
+$ recolul balance
+Monthly overtime balance: 00:51
+
+Last day 2/6(月)
+  Clock-in: 09:10
+  Working hours: 07:19
+  Break: 01:00
+```
+
+### Overtime balance graph
+
+```shell
+$ recolul graph
+```
+
+![Overtime balance graph](./doc/graph_example.png)
+
+### When to leave
+
+```shell
+$ recolul when
+Leave today at 17:43 to avoid overtime (includes a 1-hour break).
+```
+
+## Config
+
+### Environment variables
+
+- `RECORU_AUTH_ID`
+- `RECORU_CONTRACT_ID`
+- `RECORU_PASSWORD`
+
+### Config file
+
+```
+recolul config
+```
+
+## Build
+
+```
+python -m build
+```

recolul-1.20.0/RecoLul.egg-info/PKG-INFO

@@ -0,0 +1,72 @@
+Metadata-Version: 2.1
+Name: recolul
+Version: 1.20.0
+Summary: Overtime management for RecoRu
+Home-page: https://github.com/Maerig/recolul
+Author: Jean-Loup Roussel-Clouet
+Author-email: jean-loup@cryptact.com
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Provides-Extra: dev
+Provides-Extra: gui
+License-File: LICENSE
+
+# RecoLul
+
+## Installation
+
+```
+pip install recolul
+recolul config
+```
+
+## Usage
+
+### Overtime balance
+
+```shell
+$ recolul balance
+Monthly overtime balance: 00:51
+
+Last day 2/6(月)
+  Clock-in: 09:10
+  Working hours: 07:19
+  Break: 01:00
+```
+
+### Overtime balance graph
+
+```shell
+$ recolul graph
+```
+
+![Overtime balance graph](./doc/graph_example.png)
+
+### When to leave
+
+```shell
+$ recolul when
+Leave today at 17:43 to avoid overtime (includes a 1-hour break).
+```
+
+## Config
+
+### Environment variables
+
+- `RECORU_AUTH_ID`
+- `RECORU_CONTRACT_ID`
+- `RECORU_PASSWORD`
+
+### Config file
+
+```
+recolul config
+```
+
+## Build
+
+```
+python -m build
+```

recolul-1.20.0/RecoLul.egg-info/SOURCES.txt

@@ -0,0 +1,26 @@
+LICENSE
+README.md
+pyproject.toml
+setup.cfg
+RecoLul.egg-info/PKG-INFO
+RecoLul.egg-info/SOURCES.txt
+RecoLul.egg-info/dependency_links.txt
+RecoLul.egg-info/entry_points.txt
+RecoLul.egg-info/requires.txt
+RecoLul.egg-info/top_level.txt
+recolul/__init__.py
+recolul/cli.py
+recolul/config.py
+recolul/duration.py
+recolul/errors.py
+recolul/plotting.py
+recolul/time.py
+recolul.egg-info/PKG-INFO
+recolul.egg-info/SOURCES.txt
+recolul.egg-info/dependency_links.txt
+recolul.egg-info/entry_points.txt
+recolul.egg-info/requires.txt
+recolul.egg-info/top_level.txt
+recolul/recoru/__init__.py
+recolul/recoru/attendance_chart.py
+recolul/recoru/recoru_session.py

recolul-1.20.0/RecoLul.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

recolul-1.20.0/RecoLul.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+recolul = recolul.cli:main

recolul-1.20.0/RecoLul.egg-info/requires.txt

@@ -0,0 +1,11 @@
+beautifulsoup4~=4.11
+plotly~=5.18
+requests~=2.31
+
+[dev]
+build~=1.0.3
+pytest~=7.4
+twine~=5.1.1
+
+[gui]
+pyside6~=6.7.0

recolul-1.20.0/RecoLul.egg-info/top_level.txt

@@ -0,0 +1 @@
+recolul

recolul-1.20.0/pyproject.toml

@@ -0,0 +1,3 @@
+[build-system]
+requires = ["setuptools == 65.5.0", "wheel"]
+build-backend = "setuptools.build_meta"

recolul-1.20.0/recolul/__init__.py

@@ -0,0 +1 @@
+__version__ = "1.20.0"

recolul-1.20.0/recolul/cli.py

@@ -0,0 +1,127 @@
+import argparse
+import sys
+from getpass import getpass
+
+from recolul import __version__, plotting, time
+from recolul.config import Config
+from recolul.duration import Duration
+from recolul.errors import NoClockInError
+from recolul.recoru.attendance_chart import AttendanceChart
+from recolul.recoru.recoru_session import RecoruSession
+from recolul.time import get_row_work_time, until_today
+
+
+def balance(exclude_last_day: bool) -> None:
+    full_attendance_chart = _get_attendance_chart()
+    attendance_chart = until_today(full_attendance_chart)
+    if exclude_last_day and len(attendance_chart) > 1:
+        attendance_chart = attendance_chart[:-1]
+    overtime_balance, total_workplace_times = time.get_overtime_balance(attendance_chart)
+    print(f"Monthly overtime balance: {overtime_balance}")
+    print(f"Total time per workplace:")
+    for workplace, total_work_time in total_workplace_times.items():
+        print(f"  {workplace}: {total_work_time}")
+    print(
+        f"Maximum WFH time this month: {Duration(60) * time.count_working_days(full_attendance_chart)}"
+    )
+
+    if exclude_last_day:
+        return
+
+    last_day = attendance_chart[-1]
+    print(f"\nLast day {last_day.day.text}")
+    print(f"  Clock-in: {max(entry.clock_in_time for entry in last_day.entries)}")
+    print(f"  Working hours: {get_row_work_time(last_day)}")
+
+
+def when_to_leave() -> None:
+    attendance_chart = until_today(_get_attendance_chart())
+    try:
+        leave_times = time.get_leave_time(attendance_chart)
+    except NoClockInError:
+        print("You have already clocked out.")
+        return
+
+    if len(leave_times) == 1:
+        break_msg = "(break time included)" if leave_times[0].includes_break else "(break time not included)"
+        print(f"Leave at {leave_times[0].min_time} to avoid overtime {break_msg}.")
+    else:
+        print(
+            f"Leave between {leave_times[0].min_time} and {leave_times[0].max_time}, or """
+            f"after {leave_times[1].min_time}."
+        )
+
+
+def update_config() -> None:
+    """Needs to match Config.load"""
+    recoru_contract_id = input("recoru.contractId: ")
+    recoru_auth_id = input("recoru.authId: ")
+    recoru_password = getpass("recoru.password: ")
+    config = Config(
+        recoru_contract_id=recoru_contract_id,
+        recoru_auth_id=recoru_auth_id,
+        recoru_password=recoru_password
+    )
+    config.save()
+
+
+def graph(exclude_last_day: bool) -> None:
+    attendance_chart = until_today(_get_attendance_chart())
+    if exclude_last_day and len(attendance_chart) > 1:
+        attendance_chart = attendance_chart[:-1]
+    days, history, _ = time.get_overtime_history(attendance_chart)
+    plotting.plot_overtime_balance_history(days, history)
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(prog="recolul")
+    parser.add_argument("-v", "--version", action="version", version=__version__)
+    subparsers = parser.add_subparsers(dest="command", required=True)
+
+    balance_parser = subparsers.add_parser("balance", help="Calculate overtime balance")
+    balance_parser.add_argument(
+        "--exclude-last-day",
+        action="store_true",
+        help="Exclude last/current day from the calculation"
+    )
+
+    subparsers.add_parser("when", help="Calculate at which time to leave to avoid overtime this month")
+
+    subparsers.add_parser("config", help="Init or update config")
+
+    graph_parser = subparsers.add_parser("graph", help="Display a graph of overtime balance over the month")
+    graph_parser.add_argument(
+        "--exclude-last-day",
+        action="store_true",
+        help="Exclude last/current day from the graph"
+    )
+
+    args = parser.parse_args(sys.argv[1:])
+    match args.command:
+        case "balance":
+            balance(exclude_last_day=args.exclude_last_day)
+        case "when":
+            when_to_leave()
+        case "config":
+            update_config()
+        case "graph":
+            graph(exclude_last_day=args.exclude_last_day)
+
+
+def _get_attendance_chart() -> AttendanceChart:
+    config = Config.from_env() or Config.load()
+    if not config:
+        raise RuntimeError(f"No config found")
+
+    with RecoruSession(
+        contract_id=config.recoru_contract_id,
+        auth_id=config.recoru_auth_id,
+        password=config.recoru_password
+    ) as recoru_session:
+        attendance_chart = recoru_session.get_attendance_chart()
+
+    return attendance_chart
+
+
+if __name__ == "__main__":
+    main()

recolul-1.20.0/recolul/config.py

@@ -0,0 +1,46 @@
+import configparser
+import os.path
+from dataclasses import dataclass
+
+DEFAULT_CONFIG_PATH = os.path.realpath(f"{__file__}/../config.ini")
+
+
+@dataclass
+class Config:
+    recoru_contract_id: str
+    recoru_auth_id: str
+    recoru_password: str
+
+    @classmethod
+    def from_env(cls):
+        try:
+            return cls(
+                recoru_contract_id=os.environ["RECORU_CONTRACT_ID"],
+                recoru_auth_id=os.getenv("RECORU_AUTH_ID"),
+                recoru_password=os.environ["RECORU_PASSWORD"]
+            )
+        except KeyError:
+            return None
+
+    @classmethod
+    def load(cls, path: str = DEFAULT_CONFIG_PATH):
+        if not os.path.isfile(path):
+            return None
+
+        config = configparser.ConfigParser(interpolation=None)
+        config.read(path)
+        return cls(
+            recoru_contract_id=config["recoru"]["contractId"],
+            recoru_auth_id=config["recoru"]["authId"],
+            recoru_password=config["recoru"]["password"]
+        )
+
+    def save(self, path: str = DEFAULT_CONFIG_PATH):
+        config = configparser.ConfigParser(interpolation=None)
+        config["recoru"] = {
+            "authId": self.recoru_auth_id,
+            "contractId": self.recoru_contract_id,
+            "password": self.recoru_password
+        }
+        with open(path, "w") as config_file:
+            config.write(config_file)

recolul-1.20.0/recolul/duration.py

@@ -0,0 +1,59 @@
+from datetime import datetime
+
+
+class Duration:
+    @classmethod
+    def parse(cls, duration: str):
+        if duration == "":
+            return cls(0)
+        hours, minutes = duration.split(":")
+        total_minutes = 60 * int(hours) + int(minutes)
+        return cls(total_minutes)
+
+    @classmethod
+    def now(cls):
+        return cls.parse(datetime.now().strftime("%H:%M"))
+
+    def __init__(self, minutes: int = 0):
+        self.minutes: int = minutes
+
+    def __repr__(self) -> str:
+        return f"{'-' if self.minutes < 0 else ''}{abs(self.minutes) // 60:02}:{abs(self.minutes) % 60:02}"
+
+    __str__ = __repr__
+
+    def __eq__(self, other):
+        return self.minutes == other.minutes
+
+    def __neq__(self, other):
+        return self.minutes != other.minutes
+
+    def __add__(self, other):
+        return Duration(self.minutes + other.minutes)
+
+    def __sub__(self, other):
+        return Duration(self.minutes - other.minutes)
+
+    def __neg__(self):
+        return Duration(-self.minutes)
+
+    def __mul__(self, other):
+        return Duration(other * self.minutes)
+
+    def __lt__(self, other):
+        return self.minutes < other.minutes
+
+    def __gt__(self, other):
+        return self.minutes > other.minutes
+
+    def __le__(self, other):
+        return self.minutes <= other.minutes
+
+    def __ge__(self, other):
+        return self.minutes >= other.minutes
+
+    def __abs__(self):
+        return Duration(abs(self.minutes))
+
+    def __bool__(self):
+        return self.minutes > 0

recolul-1.20.0/recolul/errors.py

@@ -0,0 +1,8 @@
+class InvalidRecoruLoginError(Exception):
+    """Invalid RecoRu login information"""
+    def __init__(self):
+        super().__init__("Invalid RecoRu login information. Run recolul config")
+
+
+class NoClockInError(Exception):
+    """A clock-in time was expected but wasn't found"""

recolul-1.20.0/recolul/plotting.py

@@ -0,0 +1,27 @@
+import plotly.graph_objects as go
+
+from recolul.duration import Duration
+
+
+def plot_overtime_balance_history(days: list[str], overtime_history: list[Duration]) -> None:
+    cumulative_overtime_history = []
+    for overtime in overtime_history:
+        last_cumulative_overtime = (
+            cumulative_overtime_history[-1] if cumulative_overtime_history
+            else Duration()
+        )
+        cumulative_overtime_history.append(last_cumulative_overtime + overtime)
+
+    fig = go.Figure(
+            data=go.Scatter(
+                x=days,
+                y=[duration.minutes for duration in cumulative_overtime_history],
+                text=[str(duration) for duration in cumulative_overtime_history],
+                hovertemplate="%{x} %{text}<extra></extra>",
+                mode="lines+markers"
+            )
+    )
+    fig.update_layout(
+        yaxis_title="Overtime balance (minutes)"
+    )
+    fig.show()

recolul-1.20.0/recolul/recoru/attendance_chart.py

@@ -0,0 +1,121 @@
+import re
+from enum import Enum
+from typing import TypeAlias
+
+from bs4 import Tag
+
+
+class ChartColumn(str, Enum):
+    DATE = "日付"
+    WORKPLACE = "作業場所"
+    CATEGORY = "勤務区分"
+    START = "開始"
+    END = "終了"
+    WORK_TIME = "労働時間"
+    MEMO = "メモ"
+
+
+class ChartHeader:
+    """Header of the attendance chart"""
+    def __init__(self, tag: Tag):
+        self._column_indices: dict[ChartColumn, int] = {
+            ChartCell(column).text.strip(): i
+            for i, column in enumerate(tag.find_all("td", recursive=False))
+        }
+
+    def get_column_index(self, column: ChartColumn) -> int:
+        return self._column_indices[column]
+
+    def has_column(self, column: ChartColumn) -> bool:
+        return column in self._column_indices
+
+
+class ChartCell:
+    """Single cell of the attendance chart"""
+    def __init__(self, tag: Tag):
+        self._tag = tag
+
+    @property
+    def text(self) -> str:
+        return self._tag.text.strip()
+
+    @property
+    def color(self) -> str:
+        label = self._tag.find("label", recursive=False)
+        if not label:
+            return ""
+        return label.attrs\
+            .get("style", "")\
+            .removeprefix("color: ")\
+            .removesuffix(";")
+
+
+class ChartRowEntry:
+    """Sub-row of the attendance chart"""
+    def __init__(self, header: ChartHeader, tag: Tag):
+        self._header = header
+        self._tag = tag
+
+    def __getitem__(self, column: ChartColumn) -> ChartCell:
+        column_index = self._header.get_column_index(column)
+        column = self._tag.select_one(f"td:nth-child({column_index + 1})", recursive=False)
+        return ChartCell(column)
+
+    @property
+    def day(self) -> ChartCell:
+        return self[ChartColumn.DATE]
+
+    @property
+    def workplace(self) -> str:
+        return self[ChartColumn.WORKPLACE].text
+
+    @property
+    def category(self) -> str:
+        return self[ChartColumn.CATEGORY].text
+
+    @property
+    def clock_in_time(self) -> str:
+        return self[ChartColumn.START].text
+
+    @property
+    def clock_out_time(self) -> str:
+        return self[ChartColumn.END].text
+
+    @property
+    def work_time(self) -> str:
+        return self[ChartColumn.WORK_TIME].text
+
+    @property
+    def memo(self) -> str:
+        return self[ChartColumn.MEMO].text
+
+
+class ChartRow:
+    """Row of the attendance chart"""
+    _date_regex = re.compile(r"^(\d{1,2})\/(\d{1,2})\(.\)$")
+
+    def __init__(self, entries: list[ChartRowEntry]):
+        assert entries, "Empty ChartRow"
+        self._entries = entries
+
+    @property
+    def entries(self) -> list[ChartRowEntry]:
+        return self._entries
+
+    @property
+    def day(self) -> ChartCell:
+        return self._entries[0][ChartColumn.DATE]
+
+    @property
+    def day_of_month(self) -> int:
+        match = ChartRow._date_regex.match(self._entries[0].day.text)
+        if not match:
+            return 0
+        return int(match.group(2))
+
+    @property
+    def memo(self) -> str:
+        return self._entries[0][ChartColumn.MEMO].text
+
+
+AttendanceChart: TypeAlias = list[ChartRow]

recolul-1.20.0/recolul/recoru/recoru_session.py

@@ -0,0 +1,81 @@
+import requests
+from bs4 import BeautifulSoup
+
+from recolul.errors import InvalidRecoruLoginError
+from recolul.recoru.attendance_chart import AttendanceChart, ChartHeader, ChartRow, ChartRowEntry
+
+
+class RecoruSession:
+    def __init__(self, contract_id: str, auth_id: str, password: str):
+        self._contract_id: str = contract_id
+        self._auth_id: str = auth_id
+        self._password: str = password
+
+        self._session: requests.Session | None = None
+
+    def __enter__(self):
+        self._session = requests.Session()
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self._session.close()
+        self._session = None
+
+    @property
+    def session(self) -> requests.Session:
+        assert self._session, "RecoruSession should be used as a context manager"
+        return self._session
+
+    def get_attendance_chart(self) -> AttendanceChart:
+        self._login()
+
+        response = self.session.post("https://app.recoru.in/ap/home/loadAttendanceChartGadget")
+        response.raise_for_status()
+        return self._parse_attendance_chart(response.text)
+
+    @classmethod
+    def read_attendance_chart_file(cls, path: str) -> AttendanceChart:
+        """Used for testing"""
+
+        with open(path, "rt", encoding="UTF-8") as attendance_chart_file:
+            text = attendance_chart_file.read()
+        return cls._parse_attendance_chart(text)
+
+    def _login(self):
+        # Get a session ID
+        self.session.get("https://app.recoru.in/ap/")
+
+        url = "https://app.recoru.in/ap/login"
+        form_data = {
+            "contractId": self._contract_id,
+            "authId": self._auth_id,
+            "password": self._password
+        }
+        response = self.session.post(url, data=form_data)
+        response.raise_for_status()
+        if "message-err" in response.text:
+            raise InvalidRecoruLoginError()
+
+    @staticmethod
+    def _parse_attendance_chart(text: str) -> AttendanceChart:
+        soup = BeautifulSoup(text, "html.parser")
+        table = soup.select_one("#ID-attendanceChartGadgetTable")
+
+        table_header = table.select_one("thead > tr", recursive=False)
+        header = ChartHeader(table_header)
+
+        chart_rows = []
+        current_row_entries = []
+        table_body = table.find("tbody", recursive=False)
+        for row in table_body.find_all("tr", recursive=False):
+            entry = ChartRowEntry(header, row)
+            if entry.day.text:  # New row
+                # Append previous row
+                if current_row_entries:
+                    chart_rows.append(ChartRow(current_row_entries))
+                current_row_entries = [entry]
+            else:  # Row with multiple entries
+                current_row_entries.append(entry)
+        if current_row_entries:
+            chart_rows.append(ChartRow(current_row_entries))
+        return chart_rows

recolul-1.20.0/recolul/time.py

@@ -0,0 +1,154 @@
+import dataclasses
+from collections import defaultdict
+from datetime import datetime
+
+from recolul.duration import Duration
+from recolul.errors import NoClockInError
+from recolul.recoru.attendance_chart import AttendanceChart, ChartRow, ChartRowEntry
+
+_MIN_HOURS_FOR_MANDATORY_BREAK = Duration(6 * 60)
+
+
+def until_today(attendance_chart: AttendanceChart) -> AttendanceChart:
+    """Return a slice of the attendance chart that only contains rows until today"""
+    current_day_of_month = datetime.now().day
+    return [
+        row for row in attendance_chart
+        if row.day_of_month <= current_day_of_month
+    ]
+
+
+def get_entry_work_time(entry: ChartRowEntry) -> Duration:
+    """
+    Get work time from the column if available,
+    else calculate it from clock-in time and current time
+    """
+    category = entry.category
+    if category.startswith(
+        ("Half Day Leave", "Flexible Holiday AM", "Flexible Holiday PM")
+    ):
+        return Duration(4 * 60)
+    if category.endswith(("Leave", "Leagve")) or category == "Flexible Holiday":
+        return Duration(8 * 60)
+
+    if not (raw_clock_in_time := entry.clock_in_time):
+        return Duration(0)
+    clock_in_time = Duration.parse(raw_clock_in_time)
+
+    if raw_clock_out_time := entry.clock_out_time:
+        clock_out_time = Duration.parse(raw_clock_out_time)
+    else:
+        # Current day
+        clock_out_time = Duration.now()
+
+    if clock_out_time < clock_in_time:
+        # After midnight
+        clock_out_time += Duration(24 * 60)
+
+    work_time = clock_out_time - clock_in_time
+    break_time = (
+        Duration(60) if work_time >= _MIN_HOURS_FOR_MANDATORY_BREAK
+        else Duration(0)
+    )
+    return work_time - break_time
+
+
+def get_row_work_time(row: ChartRow) -> Duration:
+    total_work_time = Duration()
+    for entry in row.entries:
+        total_work_time += get_entry_work_time(entry)
+    return total_work_time
+
+
+def get_overtime_history(attendance_chart: AttendanceChart) -> tuple[list[str], list[Duration], dict[str, Duration]]:
+    days = []
+    overtime_history = []
+    total_workplace_times = defaultdict(Duration)
+    for row in attendance_chart:
+        day = row.day.text
+        if _is_working_day(row) or _is_swap_day(row):
+            required_time = Duration(8 * 60)
+        else:
+            required_time = Duration(0)
+
+        row_work_time = Duration()
+        for entry in row.entries:
+            entry_work_time = get_entry_work_time(entry)
+            row_work_time += entry_work_time
+
+            workplace = entry.workplace or "HF Bldg."  # Workplace is empty for paid leaves
+            total_workplace_times[workplace] += entry_work_time
+
+        if not (required_time or row_work_time):
+            # Can have work time during holidays
+            continue
+
+        days.append(day)
+        overtime_history.append(row_work_time - required_time)
+
+    return days, overtime_history, total_workplace_times
+
+
+def get_overtime_balance(attendance_chart: AttendanceChart) -> tuple[Duration, dict[str, Duration]]:
+    _, history, total_workplace_times = get_overtime_history(attendance_chart)
+    return sum(history, Duration()), total_workplace_times
+
+
+@dataclasses.dataclass
+class LeaveTime:
+    includes_break: bool
+    min_time: Duration
+    max_time: Duration | None = None
+
+
+def get_leave_time(attendance_chart: AttendanceChart) -> list[LeaveTime]:
+    day_base_hours = Duration(8 * 60)
+    overtime_balance, _ = get_overtime_balance(attendance_chart[:-1])
+
+    last_row = attendance_chart[-1]
+    last_clock_in = None
+    for entry in last_row.entries:
+        if entry.clock_in_time and not entry.clock_out_time:
+            # In progress
+            last_clock_in = Duration.parse(entry.clock_in_time)
+        else:
+            # Complete entry
+            overtime_balance += get_entry_work_time(entry)
+    if not last_clock_in:
+        raise NoClockInError()
+
+    required_today = day_base_hours - overtime_balance
+    leave_time_without_break = last_clock_in + required_today
+    leave_time_with_break = last_clock_in + required_today + Duration(60)
+    if required_today > _MIN_HOURS_FOR_MANDATORY_BREAK:
+        # When more than 6 hours must be achieved during the day,
+        # add a mandatory 1-hour break time.
+        return [
+            LeaveTime(includes_break=True, min_time=leave_time_with_break)
+        ]
+    if required_today > _MIN_HOURS_FOR_MANDATORY_BREAK - Duration(60):
+        # When the required time is between 5 and 6 hours, there is a first interval where
+        # the overtime balance becomes positive, and then it becomes negative again when 6
+        # hours have been worked because an hour is subtracted for break time.
+        first_leave_time = LeaveTime(
+            includes_break=False,
+            min_time=leave_time_without_break,
+            max_time=last_clock_in + _MIN_HOURS_FOR_MANDATORY_BREAK
+        )
+        second_leave_time = LeaveTime(includes_break=True, min_time=leave_time_with_break)
+        return [first_leave_time, second_leave_time]
+    return [
+            LeaveTime(includes_break=False, min_time=leave_time_without_break)
+        ]
+
+
+def count_working_days(attendance_chart: AttendanceChart) -> int:
+    return sum(1 for row in attendance_chart if _is_working_day(row))
+
+
+def _is_swap_day(row: ChartRow) -> bool:
+    return "swap day" in row.memo.lower()
+
+
+def _is_working_day(row: ChartRow) -> bool:
+    return row.day.text and row.day.color not in ["blue", "red"]

recolul-1.20.0/setup.cfg

@@ -0,0 +1,42 @@
+[metadata]
+name = recolul
+version = attr: recolul.__version__
+author = Jean-Loup Roussel-Clouet
+author_email = jean-loup@cryptact.com
+description = Overtime management for RecoRu
+long_description = file: README.md
+long_description_content_type = text/markdown
+url = https://github.com/Maerig/recolul
+classifiers = 
+	Programming Language :: Python :: 3
+	Operating System :: OS Independent
+
+[options]
+packages = find:
+install_requires = 
+	beautifulsoup4~=4.11
+	plotly~=5.18
+	requests~=2.31
+python_requires = >=3.10
+
+[options.entry_points]
+console_scripts = 
+	recolul = recolul.cli:main
+
+[options.extras_require]
+dev = 
+	build~=1.0.3
+	pytest~=7.4
+	twine~=5.1.1
+gui = 
+	pyside6~=6.7.0
+
+[options.packages.find]
+include = 
+	recolul
+	recolul.*
+
+[egg_info]
+tag_build = 
+tag_date = 0
+