[Build] First time build

.gitignore

@@ -0,0 +1,160 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/#use-with-ide
+.pdm.toml
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/

README.md

@@ -8,5 +8,3 @@ sdk_version: 3.28.3
 app_file: app.py
 pinned: false
 ---
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

app.py

@@ -0,0 +1,41 @@
+import tempfile
+
+import gradio as gr
+import pandas as pd
+
+from config import CONFIG
+from hr_utils.converter import get_data, make_table, parse
+from type_alias import GRADIO_OUTPUT
+
+WORKING_TIME = CONFIG.WORKING_TIME
+LATE = CONFIG.LATE
+
+
+def calculate(file: tempfile._TemporaryFileWrapper) -> GRADIO_OUTPUT:
+    filename: str = file.name
+    data: pd.DataFrame = pd.read_excel(filename)
+    data = get_data(data=data)
+    employees_list = parse(data=data)
+    table = make_table(employees=employees_list)
+    with tempfile.NamedTemporaryFile(mode="w+b", suffix=".xlsx",
+                                     delete=False) as f:
+        table.to_excel(f, index=False)
+        downloadable_filename = f.name
+    return downloadable_filename, table
+
+
+with gr.Blocks() as app:
+    with gr.Row():
+        upload_file = gr.File(label="Upload file here")
+    with gr.Row():
+        button = gr.Button(value="Calculate Working Time")
+    with gr.Row():
+        download_processed_file = gr.File()
+    with gr.Row():
+        processed_file = gr.DataFrame()
+
+    button.click(fn=calculate,
+                 inputs=[upload_file],
+                 outputs=[download_processed_file, processed_file])
+
+app.launch()

cfg/config.yml

@@ -0,0 +1,15 @@
+TIME_FORMAT: "%H:%M"
+
+WORKING_TIME:
+  TOTAL_WORKING_TIME: 480
+  MORNING_IN: "08:00"
+  MORNING_OUT: "12:00"
+  AFTERNOON_IN: "13:00"
+  AFTERNOON_OUT: "17:00"
+  ROUND_GAP: 15
+
+LATE:
+  MORNING_IN: 30
+  AFTERNOON_IN: 30
+  MORNING_OUT: 0
+  AFTERNOON_OUT: 0

config.py

@@ -0,0 +1,6 @@
+from dynaconf import Dynaconf
+
+CONFIG = Dynaconf(
+    envvar_prefix="DYNACONF",  # export envvars with `export DYNACONF_FOO=bar`.
+    settings_files=['./cfg/config.yml'],  # Load files in the given order.
+)

hr_utils/converter.py

@@ -0,0 +1,51 @@
+from typing import Dict, List
+
+import pandas as pd
+
+from config import CONFIG
+
+from .entities import Employee, WorkingTime
+
+
+def get_data(data: pd.DataFrame) -> pd.DataFrame:
+    data.columns = data.iloc[1, :]
+    data = data.iloc[2:, ]
+    data = data[['Mã N.Viên', "Tên nhân viên", "Ngày", "Vào", "Ra"]]
+    data = data.groupby(by=['Mã N.Viên', 'Ngày']).aggregate({
+        "Tên nhân viên": max,
+        "Vào": sum,
+        "Ra": sum
+    }).reset_index()
+    return data
+
+
+def parse(data: pd.DataFrame) -> List[Employee]:
+    employees: List[Employee] = []
+    for (id, name), v in data.groupby(by=['Mã N.Viên', 'Tên nhân viên']):
+        employee = Employee(id=id, name=name, workdate={})
+        for val in v.values:
+            working_time = WorkingTime(date=val[1],
+                                       checkin=val[3],
+                                       checkout=val[4],
+                                       config=CONFIG)
+            date, work_time = working_time.to_tuple()
+            employee.workdate[date] = work_time
+        employees.append(employee)
+    return employees
+
+
+def make_table(employees: List[Employee]) -> pd.DataFrame:
+    id_list: List[str] = []
+    name_list: List[str] = []
+    work_date: List[Dict] = []
+    for employee in employees:
+        id_list.append(employee.id)
+        name_list.append(employee.name)
+        work_date.append(employee.workdate)
+    work_df: pd.DataFrame = pd.DataFrame(work_date, dtype=int)
+    info_df: pd.DataFrame = pd.DataFrame({
+        'Mã nhân viên': id_list,
+        'Tên nhân viên': name_list
+    })
+    working_table: pd.DataFrame = pd.concat(objs=[info_df, work_df], axis=1)
+    return working_table

hr_utils/entities.py

@@ -0,0 +1,149 @@
+from datetime import datetime
+from typing import Dict, List
+
+import pandas as pd
+from dateutil.parser import parse
+from type_alias import EARLY_MODE, LATE_MODE
+
+
+class WorkingTime(object):
+
+    def __init__(self, date: datetime, checkin: str, checkout: str,
+                 config) -> None:
+        self.MORNING_IN = parse(config.WORKING_TIME.MORNING_IN)
+        self.MORNING_OUT = parse(config.WORKING_TIME.MORNING_OUT)
+        self.AFTERNOON_IN = parse(config.WORKING_TIME.AFTERNOON_IN)
+        self.AFTERNOON_OUT = parse(config.WORKING_TIME.AFTERNOON_OUT)
+        self.LATE_TIME: Dict[str, int] = dict(
+            morning_in=config.LATE.MORNING_IN,
+            morning_out=config.LATE.MORNING_OUT,
+            afternoon_in=config.LATE.AFTERNOON_IN,
+            afternoon_out=config.LATE.AFTERNOON_OUT)
+        self.ROUND_GAP = config.WORKING_TIME.ROUND_GAP
+
+        self.date = datetime.strftime(date, "%d/%m/%Y")
+
+        self.error: bool = False
+        if checkin == 0:
+            # self.checkin = -1
+            self.error = True
+        else:
+            self.checkin = parse(checkin)
+            if self.checkin < self.MORNING_IN:
+                self.checkin = parse("08:00")
+
+        if checkout == 0:
+            # self.checkout = -1
+            self.error = True
+        else:
+            self.checkout = parse(checkout)
+            if self.checkout > self.AFTERNOON_OUT:
+                self.checkout = parse("17:00")
+
+    def __repr__(self) -> str:
+        return "{" + ";\n".join(f"{k}={getattr(self, k)}"
+                                for k in self.__dict__) + "}"
+
+    def get_late_checkin(self, time: datetime, mode: LATE_MODE) -> int:
+        is_penalty_count: int = 0
+        if mode == 'morning_in':
+            target_time: datetime = self.MORNING_IN
+            acceptable: int = self.LATE_TIME.get('MORNING_IN', 30)
+        elif mode == 'afternoon_in':
+            target_time: datetime = self.AFTERNOON_IN
+            acceptable: int = self.LATE_TIME.get('AFTERNOON_IN', 30)
+        if time < target_time:
+            return 0
+        late_time = (time - target_time).seconds // 60
+        if late_time > acceptable:
+            is_penalty_count = 1
+        return is_penalty_count * late_time
+
+    def get_early_checkout(self, time: datetime, mode: EARLY_MODE) -> int:
+        is_penalty_count: int = 0
+        if mode == 'morning_out':
+            target_time: datetime = self.MORNING_OUT
+            acceptable: int = self.LATE_TIME.get('MORNING_OUT', 0)
+        elif mode == 'afternoon_out':
+            target_time: datetime = self.AFTERNOON_OUT
+            acceptable: int = self.LATE_TIME.get('AFTERNOON_OUT', 0)
+        if time > target_time:
+            return 0
+        early_time = (target_time - time).seconds // 60
+        if early_time > acceptable:
+            is_penalty_count = 1
+        return is_penalty_count * early_time
+
+    def morning_shift(self):
+        if self.error:
+            return -1
+        if self.checkin > self.MORNING_OUT:
+            return 0
+        late_checkin_penalty = self.get_late_checkin(time=self.checkin,
+                                                     mode='morning_in')
+        early_checkout_penalty = self.get_early_checkout(time=self.checkout,
+                                                         mode='morning_out')
+        return (self.MORNING_OUT - self.MORNING_IN
+                ).seconds // 60 - late_checkin_penalty - early_checkout_penalty
+
+    def afternoon_shift(self):
+        if self.error:
+            return -1
+        if self.checkout < self.AFTERNOON_IN:
+            return 0
+        late_checkin_penalty = self.get_late_checkin(time=self.checkin,
+                                                     mode='afternoon_in')
+        early_checkout_penalty = self.get_early_checkout(time=self.checkout,
+                                                         mode='afternoon_out')
+        return (self.AFTERNOON_OUT - self.AFTERNOON_IN
+                ).seconds // 60 - late_checkin_penalty - early_checkout_penalty
+
+    def working_time(self):
+        return self.morning_shift() + self.afternoon_shift()
+
+    def normalize(self, num: int) -> int:
+        gap = 15
+        return round(num / gap) * gap
+
+    def to_tuple(self):
+        if self.error:
+            return self.date, -1
+        return self.date, self.normalize(self.working_time())
+
+
+class Employee(object):
+
+    def __init__(self,
+                 id: str,
+                 name: str,
+                 workdate: Dict[str, int] = {}) -> None:
+        self.id = id
+        self.name = name
+        self.workdate = workdate
+
+    def __repr__(self) -> str:
+        return "{" + ";\n".join(f"{k}={getattr(self, k)}"
+                                for k in self.__dict__) + "}"
+
+
+class WorkingTable(object):
+
+    def __init__(self) -> None:
+        pass
+
+    def make_table(self, employees: List[Employee]):
+        id_list: List[str] = []
+        name_list: List[str] = []
+        work_date: List[Dict] = []
+        for employee in employees:
+            id_list.append(employee.id)
+            name_list.append(employee.name)
+            work_date.append(employee.workdate)
+        work_df: pd.DataFrame = pd.DataFrame(work_date, dtype=int)
+        info_df: pd.DataFrame = pd.DataFrame({
+            'Mã nhân viên': id_list,
+            'Tên nhân viên': name_list
+        })
+        working_table: pd.DataFrame = pd.concat(objs=[info_df, work_df],
+                                                axis=1)
+        return working_table

requirements.txt

@@ -0,0 +1,3 @@
+pandas==1.5.3
+openpyxl==3.0.10
+dynaconf==3.1.12

type_alias.py

@@ -0,0 +1,7 @@
+from typing import Literal, Tuple
+
+import pandas as pd
+
+LATE_MODE = Literal['morning_in', 'afternoon_in']
+EARLY_MODE = Literal['morning_out', 'afternoon_out']
+GRADIO_OUTPUT = Tuple[str, pd.DataFrame]