core: use class based code

src/main.py

@@ -1,13 +1,10 @@
 import sys
 import os
 from progress.bar import Bar
-from jinja2 import Environment, FileSystemLoader
-import subprocess
-import time
-import markdown
 
-env = Environment(loader=FileSystemLoader('src/templates'))
+from path import Path
-page_template = env.get_template('page.jinja')
+from picture import Picture
+from page import Page
 
 def argument_parsing():
     if (len(sys.argv) < 2):
@@ -15,94 +12,37 @@ def argument_parsing():
         exit(1)
     return sys.argv[1]
 
-def get_exif(folder: str, raw: str):
+def scan_pages(folders: list[Path]) -> list[Page]:
-    absolut_path = os.path.join(folder, "exif.txt")
+    pages: list[Page] = []
-    if os.path.exists(absolut_path):
+    prev: Page = None
-        return absolut_path
+    with Bar("scaning...", max=len(folders)) as bar:
-    if os.system(f"exiftool {raw} > {absolut_path} 2>/dev/null") == 0:
-        return absolut_path
-    os.remove(absolut_path)
-    return None
-
-def get_images(folder: str, files: list[str]):
-    length: int = len(folder) + 1
-    images_datas: list[str] = []
-    images: list[str] = [file for file in files if os.path.isfile(file) and file.endswith(".png")]
-    for image in images:
-        export_data_file: str = image + ".out.pp3"
-        if (os.path.exists(export_data_file) and os.path.isfile(export_data_file)):
-            images_datas.append((image[length:], export_data_file[length:]))
-        else:
-            images_datas.append((image[length:],))
-    return images_datas
-
-def get_updated_folders(path: str):
-    updated_folders: list[str] = []
-    for element_name in os.listdir(path):
-        absolut_path: str = os.path.join(path, element_name)
-        if not os.path.isdir(absolut_path):
-            continue
-        (mode, ino, dev, nlink, uid, gid, size, atime, mtime, ctime) = os.stat(absolut_path)
-        folder_modified_date = time.ctime(mtime)
-        html_path: str = os.path.join(absolut_path, f"{element_name}.html")
-        if not os.path.exists(html_path):
-            updated_folders.append(absolut_path)
-            continue
-        (mode, ino, dev, nlink, uid, gid, size, atime, mtime, ctime) = os.stat(absolut_path)
-        html_modified_date = time.ctime(mtime)
-        if (html_modified_date < folder_modified_date):
-            updated_folders.append(absolut_path)
-            continue
-    
-    return updated_folders
-
-def get_readme(folder):
-    absolut_path: str = os.path.join(folder, "readme.md")
-    if (os.path.exists(absolut_path)):
-        return absolut_path
-    return None
-
-def get_raw(folder, files: list[str]):
-    raws: list[str] = [file for file in files if file.endswith(".NEF")]
-    raw: str = raws[0] if len(raws) > 0 else None
-    return raw[len(folder) + 1:]
-
-def get_html_readme(readme_path: str):
-    if readme_path is None:
-        return None
-    with open(readme_path, 'r') as f:
-        text = f.read()
-        html = markdown.markdown(text)
-    return html
-
-def gen_pages(folders: list[str]):
-    with Bar("generating...", max=len(folders)) as bar:
         for folder in folders:
+            files: list[Path] = folder.get_files()
 
-            files: list[str] = [os.path.join(folder, file) for file in os.listdir(folder)]
+            prev: Page = Page(folder.get_absolute_path(), folder.get_name(), None, None, None)
-            images: list[str] = get_images(folder, files)
+
-            raw: str = get_raw(folder, files)
+            raw: Path = Path(folder.get_absolute_path(), folder.get_name() + ".NEF")
+            images: list[Path] = [Picture(file, page=prev, raw=raw) for file in files if file.get_name().endswith(".png")]
+
+            prev.images = images
 
             if len(images) == 0:
                 bar.next()
                 continue
+            pages.append(prev)
+            bar.next()
+    return pages
 
-            exif: str = get_exif(folder, raw)
+def create_pages(pages: list[Page]) -> None:
-            readme: str = get_readme(folder)
+    with Bar("generating...", max=len(pages)) as bar:
-            readme_html: str = get_html_readme(readme)
+        for page in pages:
-
+            page.create()
-            html_rendered = page_template.render(exif=exif, raw=raw, images=images, readme=readme_html)
-
-            with open(os.path.join(folder, "page.html"), "w") as f:
-                f.write(html_rendered)
-
             bar.next()
 
 def main():
-    site_path: str = argument_parsing()
+    site_path: Path = Path(argument_parsing())
-    folders = get_updated_folders(site_path)
+    pages: list[Page] = scan_pages(site_path.get_dirs())
-    gen_pages(folders)
+    create_pages(pages)
-
 
 if __name__ == "__main__":
     main()

src/page.py

@@ -0,0 +1,65 @@
+from __future__ import annotations
+
+from jinja2 import Environment, FileSystemLoader
+import markdown
+import os
+
+from path import Path
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from page import Page 
+    from picture import Picture
+
+env = Environment(loader=FileSystemLoader('src/templates'))
+page_template = env.get_template('page.jinja')
+
+class Page():
+
+    def __init__(self, path: Path, name: str, images: list[Picture], prev: Page|None, next: Page|None):
+        self.name: str = name
+        self.path: Path = path
+        self.images: list[Picture] = images
+        self._exif: Path = Path(self.path, "exif.txt")
+        self._readme: Path = Path(self.path, "readme.md")
+        self._raw: Path = Path(self.path, name + ".NEF")
+        self._html: Path = Path(self.path, "page.html")
+    
+    def _render_raw(self):
+        if not self._raw.exist():
+            return None
+        return self._raw.get_name()
+    
+    def _to_html(self) -> str|None:
+        html_rendered = page_template.render(exif=self._render_exif(), raw=self._render_raw(), images=self._render_images(), readme=self._render_readme())
+        return html_rendered
+    
+    def create(self) -> Path:
+        with open(self._html.get_absolute_path(), "w") as f:
+            f.write(self._to_html())
+        self.created = True
+
+    def _render_readme(self) -> str|None:
+        if not self._readme.exist():
+            return None
+        with open(self._readme.get_absolute_path(), 'r') as f:
+            text = f.read()
+            html = markdown.markdown(text)
+        return html
+
+    def _render_images(self):
+        return [image.render() for image in self.images]
+
+    def _gen_exif(self):
+        if self._raw.exist():
+            if os.system(f"exiftool {self._raw.get_absolute_path()} > {self._exif.get_absolute_path()} 2>/dev/null") == 0:
+                return 0
+            os.remove(self._raw.get_absolute_path())
+        return 1
+
+    def _render_exif(self) -> Path | None:
+        if not self._exif.exist():
+            if (self._gen_exif()):
+                return None
+        return self._exif.get_name()

src/path.py

@@ -0,0 +1,42 @@
+from __future__ import annotations
+
+import os
+
+class Path():
+
+    def __init__(self, *paths: str | Path):
+        self._absolute_path: str = ""
+        for path in paths:
+            self._absolute_path = os.path.join(self._absolute_path, path._absolute_path if isinstance(path, Path) else path)
+        self._name: str = os.path.basename(self._absolute_path)
+        self._dirpath: str = os.path.dirname(self._absolute_path)
+    
+    def get_dirpath(self):
+        return self._dirpath
+
+    def get_absolute_path(self):
+        return self._absolute_path
+    
+    def get_name(self):
+        if not self.exist():
+            return None
+        return self._name
+
+    def exist(self) -> bool:
+        return os.path.exists(self.get_absolute_path())
+    
+    def get_dirs(self) -> list[Path]:
+        dirs: list[Path] = []
+        for element in os.listdir(self.get_absolute_path()):
+            path: Path = Path(self._absolute_path, element)
+            if (os.path.isdir(path.get_absolute_path())):
+                dirs.append(path)
+        return dirs
+
+    def get_files(self) -> list[Path]:
+        files: list[Path] = []
+        for element in os.listdir(self.get_absolute_path()):
+            path: Path = Path(self._absolute_path, element)
+            if (os.path.isfile(path.get_absolute_path())):
+                files.append(path)
+        return files

src/picture.py

@@ -0,0 +1,28 @@
+from PIL import Image 
+import os
+
+from path import Path
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from page import Page 
+
+class Picture():
+    def __init__(self, picture_path: Path, page = None, raw: Path|None = None):
+        self.large: Path = picture_path
+        self.small: Path = Path(picture_path.get_dirpath(), picture_path.get_name()[:-4] + "_small.jpg")
+        self.export_file: Path = Path(picture_path, ".out.pp3")
+        self.raw: Path|None = raw
+        self.page: Page = page
+
+    def render(self) -> tuple[str, str, str]:
+        if not self.small.exist():
+            self.gen_small()
+        return self.large.get_name(), self.small.get_name(), self.export_file.get_name() if self.export_file.exist() else None
+    
+    def gen_small(self):
+        im = Image.open(self.large.get_absolute_path()).convert("RGB")
+        im.save(self.small.get_absolute_path(), quality=95, optimize=True)
+
+        

src/templates/page.jinja

@@ -14,9 +14,10 @@
         {% for image in images %}
             <div class="image-container">
                 <div class="image-container-element">
-                    <img src='{{ image[0] }}'>
+                    <img src='{{ image[1] }}'>
-                    {% if image | length > 1 %}
+                    <a href="{{ image[0] }}">Large</a>
-                        <a class="export" href="{{ image[1] }}">export file</a>
+                    {% if image|length > 2 %}
+                        <a class="export" href="{{ image[2] }}">export file</a>
                     {% endif %}
                 </div>
             </div>