stage-foundary 0.1.4__py3-none-any.whl

stage_foundary/__init__.py

@@ -0,0 +1,9 @@
+"""
+stage_foundary
+
+Collection of common stages used to create all kind of data analyis
+"""
+
+__version__ = "0.1.0"
+__author__ = "Reiner Jung"
+__credits__ = "Zentrale IT des Landes Schleswig-Holstein"

stage_foundary/csv_stages.py

@@ -0,0 +1,247 @@
+import csv
+import datetime
+import logging
+import sys
+
+from stage_foundary.teetime import ConsumerStage, ProducerStage, SinkStage
+
+##########################################
+# Generic functions
+##########################################
+
+
+class CsvException(Exception):
+    pass
+
+
+#
+# Abstract csv record processing
+class AbstractCsvRecordProcessing:
+    def __init__(
+        self,
+        logger: logging.Logger,
+        delimiter: str,
+        skip_header: int,
+        use_header: bool,
+        encoding: str = "utf-8",
+    ):
+        self.logger = logger
+        self.skip_header = skip_header
+        self.delimiter = delimiter
+        self.use_header = use_header
+        self.encoding = encoding
+        self.columns: dict[str, list[int]] = {}
+
+    def read_file(self, filename: str):
+        self.logger.info(f"reading {filename}")
+        self.current_filename = filename
+        with open(filename, newline="", encoding=self.encoding) as csv_file:
+            try:
+                reader = csv.reader(csv_file, delimiter=self.delimiter, quotechar='"')
+
+                self.columns = {}
+                self.process_start(filename)
+                for i, row in enumerate(reader):
+                    if self.skip_header > i:
+                        if i == 0 and self.use_header:
+                            for j, column_name in enumerate(row):
+                                column = self.columns.get(column_name)
+                                if column is None:
+                                    self.columns[column_name] = [j]
+                                else:
+                                    self.columns[column_name].append(j)
+                    else:
+                        self.process_row(row)
+
+                self.process_complete(filename)
+            except UnicodeDecodeError as e:
+                self.logger.error(
+                    f"The file '{filename}' contains an UTF error in [{i}] {e}"
+                )
+            except FileNotFoundError as e:
+                self.logger.error(f"The file '{filename}' does not exist. {e}")
+                sys.exit(-1)
+
+    def get_value(self, name: str, row: list, optional=None) -> list:
+        columns: list[int] | None = self.columns.get(name)
+        if columns is None:
+            if optional is None:
+                self.logger.error(
+                    f"Column name {name} not found in CSV file {self.current_filename}"
+                )
+                raise CsvException(
+                    f"Column name {name} not found in CSV file {self.current_filename}"
+                )
+            else:
+                return [optional]
+        result = []
+        for column in columns:
+            if len(row) > column:
+                result.append(row[column])
+        return result
+
+    def get_scalar_value(self, name: str, row: list, optional=None) -> any:
+        result = self.get_value(name, row, optional)
+        if len(result) == 1:
+            return result[0]
+        elif len(result) > 1:
+            raise CsvException("scalar expected, but list found.")
+        else:
+            return None
+
+    def get_date_value(self, name: str, row):
+        date_string = self.get_scalar_value(name, row)
+        if date_string is None or len(date_string) == 0:
+            return None
+        else:
+            return datetime.datetime.strptime(date_string, "%d.%m.%Y %H:%M")
+
+    def get_int_value(self, name: str, row: list, optional=None) -> int:
+        try:
+            return self.convert_int(self.get_scalar_value(name, row, optional))
+        except CsvException as e:
+            if optional is not None:
+                self.logger.warning(f"Error for attribute {name}: {e}")
+                return optional
+            else:
+                self.logger.error(f"Error for attribute {name}: {e}")
+                raise CsvException("Error for attribute {name}: {e}")
+        except ValueError as e:
+            if optional is not None:
+                self.logger.warning(f"Error for attribute {name}: {e}")
+                return optional
+            else:
+                self.logger.error(f"Error for attribute {name}: {e}")
+                raise CsvException("Error for attribute {name}: {e}")
+
+    def get_float_value(self, name: str, row: list, optional=None) -> float:
+        try:
+            return self.convert_float(self.get_scalar_value(name, row, optional))
+        except CsvException as e:
+            if optional is not None:
+                self.logger.warning(f"Error for attribute {name}: {e}")
+                return optional
+            else:
+                self.logger.error(f"Error for attribute {name}: {e}")
+                raise CsvException("Error for attribute {name}: {e}")
+        except ValueError as e:
+            if optional is not None:
+                self.logger.warning(f"Error for attribute {name}: {e}")
+                return optional
+            else:
+                self.logger.error(f"Error for attribute {name}: {e}")
+                raise CsvException("Error for attribute {name}: {e}")
+
+    def process_row(self, row: list) -> None:
+        pass
+
+    def process_start(self, filename: str):
+        pass
+
+    def process_complete(self, filename: str):
+        pass
+
+    def convert_int(self, value: str) -> int:
+        if value is not None and isinstance(value, str):
+            if value.strip() != "":
+                return int(value)
+            else:
+                raise CsvException("Empty value is not an integer number")
+        return 0
+
+    def convert_float(self, value: str) -> float:
+        if value is not None and isinstance(value, str):
+            if value.strip() != "":
+                return float(value)
+            else:
+                raise CsvException("Empty value is not an floating point number")
+        return 0.0
+
+
+#
+# Abstract record producer for CSV files
+#
+class AbstractCsvRecordProducer(ProducerStage, AbstractCsvRecordProcessing):
+    # @param skip_header = skip number of lines from the header
+    def __init__(
+        self,
+        logger: logging.Logger,
+        filenames,
+        delimiter: str = ";",
+        skip_header: int = 1,
+        use_header: bool = False,
+        encoding: str = "utf-8",
+    ):
+        ProducerStage.__init__(self, logger)
+        AbstractCsvRecordProcessing.__init__(
+            self,
+            logger=logger,
+            delimiter=delimiter,
+            skip_header=skip_header,
+            use_header=use_header,
+            encoding=encoding,
+        )
+        self.filenames = filenames
+        self.columns: dict[str, list[int]] = {}
+
+    def execute(self):
+        if isinstance(self.filenames, str):
+            self.read_file(filename=self.filenames)
+        else:
+            for filename in self.filenames:
+                self.read_file(filename=filename)
+        self.work_complete()
+
+
+#
+# Abstract record reader for CSV files
+#
+class AbstractCsvRecordReader(ConsumerStage, AbstractCsvRecordProcessing):
+    # @param skip_header = skip number of lines from the header
+    def __init__(
+        self,
+        logger: logging.Logger,
+        delimiter: str = ";",
+        skip_header: int = 1,
+        use_header: bool = False,
+        encoding: str = "utf-8",
+    ):
+        ConsumerStage.__init__(self, logger)
+        AbstractCsvRecordProcessing.__init__(
+            self,
+            logger=logger,
+            delimiter=delimiter,
+            skip_header=skip_header,
+            use_header=use_header,
+            encoding=encoding,
+        )
+
+    def consume(self, filename: str):
+        self.columns: dict[str, list[int]] = {}
+        self.read_file(filename=filename)
+
+
+############################################
+# Writer
+############################################
+
+
+class AbstractCsvRecordSink(SinkStage):
+    def __init__(
+        self, logger: logging.Logger, filename: str, delimiter: str, fieldnames: list
+    ):
+        super().__init__(logger)
+        with open(filename, "w", newline="") as self.output_file:
+            self.csv_writer = csv.writer(
+                self.output_file,
+                delimiter=delimiter,
+                quotechar='"',
+                quoting=csv.QUOTE_ALL,
+            )
+            self.csv_writer.writerow(fieldnames)
+
+    def consume(self, entry):
+        pass
+
+    def on_terminate(self):
+        self.output_file.close()

stage_foundary/document_structure.py

@@ -0,0 +1,146 @@
+"""
+Created on Mon Mar 30 08:32:13 2026
+
+@author: Reiner Jung
+"""
+
+from dataclasses import dataclass
+from enum import Enum
+
+
+class EHorizontalOrientation(Enum):
+    LEFT = 1
+    CENTER = 2
+    RIGHT = 3
+
+
+class EVerticalOrientation(Enum):
+    TOP = 1
+    CENTER = 2
+    BOTTOM = 3
+
+
+@dataclass
+class AbstractPageElement:
+    def print(self, indent):
+        pass
+
+
+@dataclass
+class Table(AbstractPageElement):
+    header: list  # [str]
+    orientations: list  # [EHorizontalOrientation]
+    widths: list  # [str]
+    rows: list  # [list[AbstractPageElement]]
+
+
+@dataclass
+class Container(AbstractPageElement):
+    children: list
+
+    def print(self, indent):
+        for item in self.children:
+            item.print(f"  {indent}")
+
+
+@dataclass
+class Page(Container):
+    pass
+
+
+@dataclass
+class PlainText(AbstractPageElement):
+    text: str
+
+
+@dataclass
+class Link(Container):
+    link: str
+    format: str
+
+
+@dataclass
+class Headline(Container):
+    level: int
+
+    def print(self, indent):
+        print(f"{indent}Headline {self.level}")
+        super().print(indent)
+
+
+@dataclass
+class NoFormat(Container):
+    def print(self, indent):
+        print(f"{indent}No Format")
+        super().print(indent)
+
+
+@dataclass
+class CodeLine(PlainText):
+    def print(self, indent):
+        print(f"{indent}CODE {self.text}")
+
+
+@dataclass
+class Code(Container):
+    def print(self, indent):
+        print(f"{indent}Code")
+        super().print(indent)
+
+
+@dataclass
+class Paragraph(Container):
+    def print(self, indent):
+        print(f"{indent}Paragraph")
+        super().print(indent)
+
+
+@dataclass
+class Line(Container):
+    pass
+
+
+@dataclass
+class Span(Container):
+    format: str
+
+    def print(self, indent):
+        print(f"{indent}Span {self.format}")
+        super().print(indent + "  ")
+
+
+@dataclass
+class Item(Container):
+    level: int
+
+    def print(self, indent):
+        print(f"{indent}LI {self.level}")
+        super().print(f"{indent}  ")
+
+
+@dataclass
+class Enumeration(Container):
+    level: int
+
+    def print(self, indent):
+        print(f"{indent}LI {self.level}")
+        super().print(f"{indent}  ")
+
+
+@dataclass
+class ItemList(Container):
+    def print(self, indent):
+        print(f"{indent}List")
+        super().print(indent)
+
+
+@dataclass
+class EnumerationList(Container):
+    def print(self, indent):
+        print(f"{indent}Enumeration")
+        super().print(indent)
+
+
+@dataclass
+class Newline(AbstractPageElement):
+    pass