Merge pull request #147 from giomf/main

Add alarm 0003 & 0004

Author: giomf

assets/img/einsaetze/2025/0003.jpg

@@ -31,17 +31,75 @@
 _INDEX_TEMPLATE_SHORTCODE_SNIPPET = '\n{{< image src="img01" >}}'
 
 
+def get_latest_year() -> str:
+    """
+    Get the latest year from the content directory.
+    
+    Returns:
+        str: The latest year found in the content directory, or the current year if none found
+    """
+    years = []
+    for path in _TARGET_BASE_PATH.iterdir():
+        if path.is_dir() and path.name.isdigit():
+            years.append(path.name)
+
+    if not years:
+        return str(datetime.now().year)
+
+    return max(years)
+
+
+def get_next_id(year: str) -> str:
+    """
+    Get the next available ID for a given year.
+    
+    Args:
+        year (str): The year to check for existing IDs
+        
+    Returns:
+        str: The next available ID formatted as a 4-digit string
+    """
+    year_path = _TARGET_BASE_PATH.joinpath(year)
+    if not year_path.exists():
+        return "0000"
+
+    ids = []
+    for path in year_path.iterdir():
+        if path.is_dir() and path.name.isdigit():
+            ids.append(int(path.name))
+
+    if not ids:
+        return "0000"
+
+    return f"{max(ids) + 1:04d}"
+
+
 def parse_arguments():
+    """
+    Parse command line arguments for the script.
+    
+    Sets up the argument parser with three subcommands:
+    - create: Creates a new content page with either a template or from input
+    - remove: Removes an existing content page
+    - print: Prints the content of an existing page
+    
+    Returns:
+        argparse.Namespace: The parsed command line arguments
+    """
     parser = argparse.ArgumentParser(description="Parse arguments for template, name, and year.")
     subparsers = parser.add_subparsers(dest='command', required=True, help="Subcommands")
 
+    # Get default values for create command
+    default_year = get_latest_year()
+    default_id = get_next_id(default_year)
+
     remove_parser = subparsers.add_parser('remove', help='Removes a content page')
     remove_parser.add_argument('--year', type=str, required=True, help='The year')
     remove_parser.add_argument('--id', type=str, required=True, help='The content id')
 
     create_parser = subparsers.add_parser('create', help='Creates a content page')
-    create_parser.add_argument('--year', type=str, required=True, help='The year')
-    create_parser.add_argument('--id', type=str, required=True, help='The content id')
+    create_parser.add_argument('--year', type=str, default=default_year, help=f'The year (default: {default_year})')
+    create_parser.add_argument('--id', type=str, default=default_id, help=f'The content id (default: {default_id})')
     create_parser_group = create_parser.add_mutually_exclusive_group(required=True)
     create_parser_group.add_argument('--template', action='store_true')
     create_parser_group.add_argument('--input', type=str)
@@ -56,6 +114,18 @@ def parse_arguments():
 
 
 def create_base_paths(year: str, index: str):
+    """
+    Create the base directory structure for a new content page.
+    
+    Creates the content directory and an img subdirectory for storing images.
+    
+    Args:
+        year (str): The year for the content
+        index (str): The ID for the content
+        
+    Raises:
+        FileExistsError: If the content path already exists
+    """
     content_path = _TARGET_BASE_PATH.joinpath(year).joinpath(index)
     image_path = content_path.joinpath('img')
 
@@ -64,10 +134,18 @@ def create_base_paths(year: str, index: str):
 
     os.mkdir(content_path)
     os.mkdir(image_path)
+    print(f'Using year: {year} and id: {index}')
     print(f'Created {content_path}')
 
 
 def print_content(year: str, content_id: str):
+    """
+    Print the contents of an index.md file for a specific content page.
+    
+    Args:
+        year (str): The year of the content
+        content_id (str): The ID of the content
+    """
     content_path = _TARGET_BASE_PATH.joinpath(year).joinpath(content_id)
     index_file = content_path.joinpath('index.md')
     with open(index_file, 'r') as file:
@@ -76,6 +154,15 @@ def print_content(year: str, content_id: str):
 
 
 def remove_content(year: str, content_id: str):
+    """
+    Remove a content page and its associated thumbnail.
+    
+    Deletes both the content directory and the thumbnail image.
+    
+    Args:
+        year (str): The year of the content to remove
+        content_id (str): The ID of the content to remove
+    """
     content_path = _TARGET_BASE_PATH.joinpath(year).joinpath(content_id)
     thumbnail_path = _THUMBNAIL_FULL_BASE_PATH.joinpath(year).joinpath(f'{content_id}.jpg')
     shutil.rmtree(content_path)
@@ -85,25 +172,71 @@ def remove_content(year: str, content_id: str):
 
 
 def parse_date_from_path(path: Path) -> datetime:
+    """
+    Extract and parse a date from a directory path name.
+    
+    Expects the directory name to start with a date in the format defined by _DATE_INPUT_FORMAT.
+    
+    Args:
+        path (Path): The path object containing the date in its name
+        
+    Returns:
+        datetime: The parsed datetime object
+    """
     date_time: str = path.name.split(' ')[0]
     date_time: datetime = datetime.strptime(date_time, _DATE_INPUT_FORMAT)
     print(f'Parsing date "{date_time}" from "{path.name}"')
     return date_time
 
 
 def parse_tag_from_path(path: Path) -> str:
+    """
+    Extract a tag from a directory path name.
+    
+    Expects the directory name to have a tag as the second element when split by spaces.
+    
+    Args:
+        path (Path): The path object containing the tag in its name
+        
+    Returns:
+        str: The extracted tag
+    """
     tag = path.name.split(' ')[1]
     print(f'Parsing tag "{tag}" from "{path.name}"')
     return tag
 
 
 def copy_images(year: str, content_id: str, input_path: Path):
+    """
+    Copy JPEG images from an input directory to the content directory.
+    
+    The first image found is also copied as a thumbnail.
+    All images are renamed according to the pattern: year-contentId-counter.jpg
+    Searches recursively through all subdirectories.
+    
+    Args:
+        year (str): The year for the content
+        content_id (str): The ID for the content
+        input_path (Path): The path to the directory containing source images
+        
+    Raises:
+        FileNotFoundError: If no JPEG images are found in the input directory
+    """
     content_path = _TARGET_BASE_PATH.joinpath(year).joinpath(content_id)
     image_path = content_path.joinpath('img')
     counter = 1
 
-    # Iterate through all files in the directory
-    for file_path in sorted(input_path.iterdir()):
+    # Get all files recursively
+    all_files = []
+    for root, _, files in os.walk(input_path):
+        for file in files:
+            all_files.append(Path(root) / file)
+
+    # Sort files to ensure consistent ordering
+    all_files.sort()
+
+    # Process all image files
+    for file_path in all_files:
         if file_path.is_file():
             mime_type, _ = mimetypes.guess_type(file_path)
             if mime_type and mime_type == 'image/jpeg':
@@ -116,11 +249,24 @@ def copy_images(year: str, content_id: str, input_path: Path):
                 shutil.copy(file_path, new_image)
                 print(f'Copy {file_path.name} to {new_image}')
                 counter = counter + 1
+
     if counter == 1:
         raise FileNotFoundError(f'No JPG images found in {input_path}')
 
 
 def get_images_snippet(year: str, content_id: str) -> (str, str):
+    """
+    Generate resources and shortcodes snippets for all images in the content directory.
+    
+    Creates Hugo resource declarations and image shortcodes for each image file.
+    
+    Args:
+        year (str): The year of the content
+        content_id (str): The ID of the content
+        
+    Returns:
+        tuple: A tuple containing (resources_string, shortcodes_string)
+    """
     content_path = _TARGET_BASE_PATH.joinpath(year).joinpath(content_id)
     image_path = content_path.joinpath('img')
     index_file = content_path.joinpath('index.md')
@@ -135,10 +281,21 @@ def get_images_snippet(year: str, content_id: str) -> (str, str):
 
 
 def find_markdown_content(input_path: Path) -> str:
-    """Find and read the content of a markdown file in the given directory."""
+    """
+    Find and read the content of a markdown file in the given directory.
+    
+    Searches for any .md file in the input directory and returns its contents.
+    If multiple markdown files exist, only the first one found will be used.
+    
+    Args:
+        input_path (Path): The directory to search for markdown files
+        
+    Returns:
+        str: The content of the markdown file, or an empty string if none found
+    """
     for file_path in input_path.iterdir():
         if file_path.is_file() and file_path.suffix == '.md':
-            print(f'Use markdown file: {file_path.name}')
+            print(f'Use markdown file: {file_path}')
             with open(file_path, 'r') as md_file:
                 content = md_file.read()
                 return content
@@ -155,6 +312,21 @@ def create_index_file(year: str,
                       resources: str,
                       shortcodes: str,
                       markdown_content: str = ''):
+    """
+    Create an index.md file for a content page using the template.
+    
+    Formats the provided parameters into the index template and writes it to disk.
+    
+    Args:
+        year (str): The year of the content
+        content_id (str): The ID of the content
+        date (datetime): The date for the content
+        thumbnail (str): Path to the thumbnail image
+        tag (str): The tag for the content
+        resources (str): The resources section for Hugo
+        shortcodes (str): The image shortcodes
+        markdown_content (str, optional): Additional markdown content. Defaults to ''.
+    """
     content_path = _TARGET_BASE_PATH.joinpath(year).joinpath(content_id)
     index_file = content_path.joinpath('index.md')
 

assets/img/einsaetze/2025/0004.jpg

@@ -0,0 +1,46 @@
+---
+title: Feuer 3. Alarm brennt Dach - Einsatz Cobra-System
+date: 2025-03-06 15:17:00
+description: Feuer 3. Alarm brennt Dach - Einsatz Cobra-System
+thumbnail: img/einsaetze/2025/0003.jpg
+tag: FEU3NOTF
+resources:
+- name: img01
+  src: img/2025-0003-01.jpg
+- name: img02
+  src: img/2025-0003-02.jpg
+- name: img03
+  src: img/2025-0003-03.jpg
+- name: img04
+  src: img/2025-0003-04.jpg
+- name: img05
+  src: img/2025-0003-05.jpg
+---
+
+Feuer 3. Alarm brennt Dach - Einsatz Cobra-System
+  
+Am Donnerstagnachmittag, den 06.03.2025 gegen 15:30 Uhr wurde die FF Eppendorf zusammen mit weiteren Einsatzkräften aufgrund des Alarmierungstichwortes FEU2 brennt Dach mit dem Einsatzmodul Cobra zu einem ausgedehnten Dachstuhlbrand in den Stadtteil Rotherbaum alarmiert.
+Aufgrund des Flammenschlages und der starken Rauchentwicklung wurde zügig von den Einsatzkräften auf 3. Alarm erhöht.
+Nach Dacharbeiten standen Teile des Dachgeschosses, sowie des Daches eines fünfgeschossigen Wohngebäudes im Vollbrand.
+Das Feuer hatte sich bis in die Dachzwischenräume ausgebreitet. 
+
+Unser primärer Einsatzauftrag, zusammen mit den Kräften der Technik- und Umweltschutzwache F32, bestand darin, die unzugänglichen Bereiche des Dachgeschosses zu erkunden und mittels des Cobra Cold Cut Lösch- und Schneidsystems gezielt zu löschen.
+Das Cobra-Cold-Cut-System wurde dabei über die DLK 11 nach oben verbracht.
+Unsere speziell ausgebildeten Atemschutztrupps gingen hierbei zusammen mit unserem Einheitsführer Cobra über das Baugerüst bis ins eingerüstete Dachgeschoss vor.
+Durch den taktische Einsatz in Verbindung mit der Wärmebildkamera konnten mehere HotSpots kurzfristig identifiziert und abgelöscht werden.
+Das Cobra-System bietet die Möglichkeit mittels 300bar Wasserdruck mit beigemischtem Abrasivstoff z.B. durch Wände oder die Dachhaut zu schießen und dahinterliegende Räume zu kühlen bzw.
+Glutnester in Zwischenräumen zu löschen. Ein geringer Wasserdurchsatz lässt dadurch Schäden minimieren.
+
+Der Technische Zug war mit 2 Fahrzeugen und 15 Einsatzkräften darunter 11 AGT mehrere Stunden im Einsatz.
+Eine umfangreiche Einsatzhygiene konnte bereits vor Ort durchgeführt werden.
+
+
+[Offizieller Pressebericht](https://www.presseportal.de/blaulicht/pm/82522/5985473)
+
+Bilder mit freundlicher Genehmigung: Michael Arning
+
+{{< image src="img01" >}}  
+{{< image src="img02" >}}  
+{{< image src="img03" >}}  
+{{< image src="img04" >}}  
+{{< image src="img05" >}}