testgres.postgres-configuration 0.1.0__py3-none-any.whl

testgres/postgres_configuration/core/model.py

@@ -0,0 +1,296 @@
+# //////////////////////////////////////////////////////////////////////////////
+# Postgres Pro. PostgreSQL Configuration Python Library.
+
+from __future__ import annotations
+
+from .raise_error import RaiseError
+
+from ..os.abstract.configuration_os_ops import ConfigurationOsOps
+
+import typing
+import enum
+import datetime
+
+# //////////////////////////////////////////////////////////////////////////////
+# ObjectData
+
+
+class ObjectData:
+    def __init__(self):
+        pass
+
+    # interface ----------------------------------------------------------
+    def get_Parent(self) -> ObjectData:
+        RaiseError.MethodIsNotImplemented(__class__, "get_Parent")
+
+    def IsAlive(self) -> bool:
+        RaiseError.MethodIsNotImplemented(__class__, "IsAlive")
+
+
+# //////////////////////////////////////////////////////////////////////////////
+# FileLineElementData
+
+
+class FileLineElementData(ObjectData):
+    m_Parent: FileLineData
+    m_Offset: typing.Optional[int]
+
+    # --------------------------------------------------------------------
+    def __init__(self, parent: FileLineData, offset: typing.Optional[int]):
+        assert type(parent) == FileLineData
+        assert offset is None or type(offset) == int
+
+        super().__init__()
+
+        self.m_Parent = parent
+        self.m_Offset = offset
+
+    # own interface ------------------------------------------------------
+    def MarkAsDeletedFrom(self, fileLineData: FileLineData) -> None:
+        assert fileLineData is not None
+        assert isinstance(fileLineData, FileLineData)
+        assert self.m_Parent is fileLineData
+        self.m_Parent = None
+
+    # Object interface ---------------------------------------------------
+    def get_Parent(self) -> FileLineData:
+        assert type(self.m_Parent) == FileLineData
+        return self.m_Parent
+
+    # --------------------------------------------------------------------
+    def IsAlive(self) -> bool:
+        if self.m_Parent is None:
+            return False
+
+        return self.m_Parent.IsAlive()
+
+
+# //////////////////////////////////////////////////////////////////////////////
+# CommentData
+
+
+class CommentData(FileLineElementData):
+    m_Text: str
+
+    # --------------------------------------------------------------------
+    def __init__(self, parent: FileLineData, offset: typing.Optional[int], text: str):
+        assert type(parent) == FileLineData
+        assert offset is None or type(offset) == int
+        assert type(text) == str
+
+        super().__init__(parent, offset)
+
+        self.m_Text = text
+
+
+# //////////////////////////////////////////////////////////////////////////////
+# OptionData
+
+
+class OptionData(FileLineElementData):
+    m_Name: str
+    m_Value: any
+
+    # --------------------------------------------------------------------
+    def __init__(
+        self, parent: FileLineData, offset: typing.Offset[int], name: str, value: any
+    ):
+        assert type(parent) == FileLineData
+        assert offset is None or type(offset) == int
+        assert type(name) == str
+        assert value is not None
+        assert name != ""
+
+        super().__init__(parent, offset)
+
+        self.m_Name = name
+        self.m_Value = value
+
+
+# //////////////////////////////////////////////////////////////////////////////
+# IncludeData
+
+
+class IncludeData(FileLineElementData):
+    m_Path: str
+    m_File: FileData
+
+    # --------------------------------------------------------------------
+    def __init__(
+        self,
+        parent: FileLineData,
+        offset: typing.Optional[int],
+        path: str,
+        fileData: FileData,
+    ):
+        assert type(parent) == FileLineData
+        assert type(path) == str
+        assert type(fileData) == FileData
+        assert offset is None or type(offset) == int
+
+        assert parent.IsAlive()
+        assert fileData.IsAlive()
+
+        assert fileData.get_Parent() is parent.get_Parent().get_Parent()
+
+        super().__init__(parent, offset)
+
+        self.m_Path = path
+        self.m_File = fileData
+
+
+# //////////////////////////////////////////////////////////////////////////////
+# FileLineData
+
+
+class FileLineData(ObjectData):
+    class tagItem:
+        m_Element: FileLineElementData
+
+        # ----------------------------------------------------------------
+        def __init__(self, element: FileLineElementData):
+            assert isinstance(element, FileLineElementData)
+
+            self.m_Element = element
+
+    # --------------------------------------------------------------------
+    m_Parent: FileData
+    m_Items: typing.List[tagItem]
+
+    # --------------------------------------------------------------------
+    def __init__(self, parent: FileData):
+        assert type(parent) == FileData
+
+        super().__init__()
+
+        self.m_Parent = parent
+        self.m_Items = list()
+
+    # own interface ------------------------------------------------------
+    def MarkAsDeletedFrom(self, fileData: FileData) -> None:
+        assert fileData is not None
+        assert isinstance(fileData, FileData)
+        assert self.m_Parent is fileData
+        self.m_Parent = None
+
+    # Object interface ---------------------------------------------------
+    def get_Parent(self) -> FileData:
+        assert type(self.m_Parent) == FileData
+        return self.m_Parent
+
+    # --------------------------------------------------------------------
+    def IsAlive(self) -> bool:
+        if self.m_Parent is None:
+            return False
+
+        return self.m_Parent.IsAlive()
+
+
+# //////////////////////////////////////////////////////////////////////////////
+# FileStatus
+
+
+class FileStatus(enum.Enum):
+    IS_NEW: int = 0
+    EXISTS: int = 1
+
+
+# //////////////////////////////////////////////////////////////////////////////
+# FileData
+
+
+class FileData(ObjectData):
+    m_Parent: ConfigurationData
+
+    m_Status: FileStatus
+    m_LastModifiedTimestamp: typing.Optional[datetime.datetime]
+
+    m_Path: str
+    m_Lines: typing.List[FileLineData]
+
+    m_OptionsByName: typing.Dict[str, OptionData]
+
+    # --------------------------------------------------------------------
+    def __init__(self, parent: ConfigurationData, path: str):
+        assert type(parent) == ConfigurationData
+        assert type(path) == str
+        assert parent.OsOps.Path_IsAbs(path)
+        assert parent.OsOps.Path_NormPath(path) == path
+        assert parent.OsOps.Path_NormCase(path) == path
+
+        super().__init__()
+
+        self.m_Parent = parent
+
+        self.m_Status = FileStatus.IS_NEW
+        self.m_LastModifiedTimestamp = None
+
+        self.m_Path = path
+        self.m_Lines = list()
+
+        self.m_OptionsByName = dict()
+        assert type(self.m_OptionsByName) == dict
+
+        assert type(self.m_Path) == str
+        assert self.m_Path != ""
+
+    # Object interface ---------------------------------------------------
+    def get_Parent(self) -> ConfigurationData:
+        assert type(self.m_Parent) == ConfigurationData
+        return self.m_Parent
+
+    # --------------------------------------------------------------------
+    def IsAlive(self) -> bool:
+        if self.m_Parent is None:
+            return False
+
+        return self.m_Parent.IsAlive()
+
+
+# //////////////////////////////////////////////////////////////////////////////
+# ConfigurationData
+
+
+class ConfigurationData(ObjectData):
+    m_DataDir: str
+    m_OsOps: ConfigurationOsOps
+
+    m_Files: typing.List[FileData]
+
+    m_AllOptionsByName: typing.Dict[str, typing.Union[OptionData, typing.List[OptionData]]]
+    m_AllFilesByName: typing.Dict[str, typing.Union[FileData, typing.List[FileData]]]
+
+    # --------------------------------------------------------------------
+    def __init__(self, data_dir: str, osOps: ConfigurationOsOps):
+        assert type(data_dir) == str
+        assert isinstance(osOps, ConfigurationOsOps)
+
+        super().__init__()
+
+        self.m_DataDir = data_dir
+        self.m_OsOps = osOps
+
+        self.m_Files = list()
+        self.m_AllOptionsByName = dict()
+        self.m_AllFilesByName = dict()
+
+        assert type(self.m_Files) == list
+        assert type(self.m_AllOptionsByName) == dict
+        assert type(self.m_AllFilesByName) == dict
+
+    # Own interface ------------------------------------------------------
+    @property
+    def OsOps(self) -> ConfigurationOsOps:
+        assert isinstance(self.m_OsOps, ConfigurationOsOps)
+        return self.m_OsOps
+
+    # Object interface ---------------------------------------------------
+    def get_Parent(self) -> FileData:
+        return None
+
+    # --------------------------------------------------------------------
+    def IsAlive(self) -> bool:
+        return True
+
+
+# //////////////////////////////////////////////////////////////////////////////

testgres/postgres_configuration/core/option/handlers/add/option_handler_to_add__std.py

@@ -0,0 +1,38 @@
+# //////////////////////////////////////////////////////////////////////////////
+# Postgres Pro. PostgreSQL Configuration Python Library.
+
+from __future__ import annotations
+
+from ....handlers import OptionHandlerToAddOption
+from ....handlers import OptionHandlerCtxToAddOption
+from ....handlers import ConfigurationDataHandler
+from ....handlers import FileData
+from ....handlers import FileLineData
+
+# //////////////////////////////////////////////////////////////////////////////
+# OptionHandlerToAddOption__Std
+
+
+class OptionHandlerToAddOption__Std(OptionHandlerToAddOption):
+    def __init__(self):
+        super().__init__()
+
+    # interface ----------------------------------------------------------
+    def AddOption(self, ctx: OptionHandlerCtxToAddOption) -> any:
+        assert type(ctx) == OptionHandlerCtxToAddOption
+        assert isinstance(ctx.DataHandler, ConfigurationDataHandler)
+        assert (
+            ctx.Target is None
+            or type(ctx.Target) == FileData
+            or type(ctx.Target) == FileLineData
+        )
+        assert ctx.OptionOffset is None or type(ctx.OptionOffset) == int
+        assert type(ctx.OptionName) == str
+        assert ctx.OptionName is not None
+
+        return ctx.DataHandler.DataHandler__AddSimpleOption(
+            ctx.Target, ctx.OptionOffset, ctx.OptionName, ctx.OptionValue
+        )
+
+
+# //////////////////////////////////////////////////////////////////////////////

testgres/postgres_configuration/core/option/handlers/get_value/option_handler_to_get_value__std__simple.py

@@ -0,0 +1,36 @@
+# //////////////////////////////////////////////////////////////////////////////
+# Postgres Pro. PostgreSQL Configuration Python Library.
+
+from __future__ import annotations
+
+from ....handlers import OptionHandlerToGetValue
+from ....handlers import OptionHandlerCtxToGetValue
+from ....handlers import ConfigurationDataHandler
+from ....handlers import FileData
+from ....handlers import OptionData
+
+# //////////////////////////////////////////////////////////////////////////////
+# OptionHandlerToGetValue__Std__Simple
+
+
+class OptionHandlerToGetValue__Std__Simple(OptionHandlerToGetValue):
+    def __init__(self):
+        super().__init__()
+
+    # interface ----------------------------------------------------------
+    def GetOptionValue(self, ctx: OptionHandlerCtxToGetValue) -> any:
+        assert type(ctx) == OptionHandlerCtxToGetValue
+        assert isinstance(ctx.DataHandler, ConfigurationDataHandler)
+        assert (
+            ctx.SourceData is None
+            or type(ctx.SourceData) == FileData
+            or type(ctx.SourceData) == OptionData
+        )
+        assert type(ctx.OptionName) == str
+
+        return ctx.DataHandler.DataHandler__GetOptionValue__Simple(
+            ctx.SourceData, ctx.OptionName
+        )
+
+
+# //////////////////////////////////////////////////////////////////////////////

testgres/postgres_configuration/core/option/handlers/get_value/option_handler_to_get_value__std__union_list.py

@@ -0,0 +1,36 @@
+# //////////////////////////////////////////////////////////////////////////////
+# Postgres Pro. PostgreSQL Configuration Python Library.
+
+from __future__ import annotations
+
+from ....handlers import OptionHandlerToGetValue
+from ....handlers import OptionHandlerCtxToGetValue
+from ....handlers import ConfigurationDataHandler
+from ....handlers import FileData
+from ....handlers import OptionData
+
+# //////////////////////////////////////////////////////////////////////////////
+# OptionHandlerToGetValue__Std__UnionList
+
+
+class OptionHandlerToGetValue__Std__UnionList(OptionHandlerToGetValue):
+    def __init__(self):
+        super().__init__()
+
+    # interface ----------------------------------------------------------
+    def GetOptionValue(self, ctx: OptionHandlerCtxToGetValue) -> any:
+        assert type(ctx) == OptionHandlerCtxToGetValue
+        assert isinstance(ctx.DataHandler, ConfigurationDataHandler)
+        assert (
+            ctx.SourceData is None
+            or type(ctx.SourceData) == FileData
+            or type(ctx.SourceData) == OptionData
+        )
+        assert type(ctx.OptionName) == str
+
+        return ctx.DataHandler.DataHandler__GetOptionValue__UnionList(
+            ctx.SourceData, ctx.OptionName
+        )
+
+
+# //////////////////////////////////////////////////////////////////////////////

testgres/postgres_configuration/core/option/handlers/prepare_get_value/option_handler_to_prepare_get_value__std__bool.py

@@ -0,0 +1,31 @@
+# //////////////////////////////////////////////////////////////////////////////
+# Postgres Pro. PostgreSQL Configuration Python Library.
+
+from __future__ import annotations
+
+from ....handlers import OptionHandlerToPrepareGetValue
+from ....handlers import OptionHandlerCtxToPrepareGetValue
+from ....handlers import ConfigurationDataHandler
+
+# //////////////////////////////////////////////////////////////////////////////
+# OptionHandlerToPrepareGetValue__Std__Bool
+
+
+class OptionHandlerToPrepareGetValue__Std__Bool(OptionHandlerToPrepareGetValue):
+    def __init__(self):
+        super().__init__()
+
+    # interface ----------------------------------------------------------
+    def PrepareGetValue(self, ctx: OptionHandlerCtxToPrepareGetValue) -> any:
+        assert type(ctx) == OptionHandlerCtxToPrepareGetValue
+        assert isinstance(ctx.DataHandler, ConfigurationDataHandler)
+        assert type(ctx.OptionName) == str
+        assert ctx.OptionValue is not None
+
+        # [2025-04-13] Research
+        assert type(ctx.OptionValue) == bool
+
+        return bool(ctx.OptionValue)
+
+
+# //////////////////////////////////////////////////////////////////////////////

testgres/postgres_configuration/core/option/handlers/prepare_get_value/option_handler_to_prepare_get_value__std__generic.py

@@ -0,0 +1,41 @@
+# //////////////////////////////////////////////////////////////////////////////
+# Postgres Pro. PostgreSQL Configuration Python Library.
+
+from __future__ import annotations
+
+from ....bugcheck_error import BugCheckError
+
+from ....handlers import OptionHandlerToPrepareGetValue
+from ....handlers import OptionHandlerCtxToPrepareGetValue
+from ....handlers import ConfigurationDataHandler
+
+# //////////////////////////////////////////////////////////////////////////////
+# OptionHandlerToPrepareGetValue__Std__Generic
+
+
+class OptionHandlerToPrepareGetValue__Std__Generic(OptionHandlerToPrepareGetValue):
+    def __init__(self):
+        super().__init__()
+
+    # interface ----------------------------------------------------------
+    def PrepareGetValue(self, ctx: OptionHandlerCtxToPrepareGetValue) -> any:
+        assert type(ctx) == OptionHandlerCtxToPrepareGetValue
+        assert isinstance(ctx.DataHandler, ConfigurationDataHandler)
+        assert type(ctx.OptionName) == str
+        assert ctx.OptionValue is not None
+
+        typeOfOptionValue = type(ctx.OptionValue)
+
+        if typeOfOptionValue == int:
+            pass  # OK
+        elif typeOfOptionValue == str:
+            pass  # OK
+        elif typeOfOptionValue == bool:
+            pass  # OK
+        else:
+            BugCheckError.UnknownOptionValueType(ctx.OptionName, typeOfOptionValue)
+
+        return ctx.OptionValue
+
+
+# //////////////////////////////////////////////////////////////////////////////

testgres/postgres_configuration/core/option/handlers/prepare_get_value/option_handler_to_prepare_get_value__std__int.py

@@ -0,0 +1,31 @@
+# //////////////////////////////////////////////////////////////////////////////
+# Postgres Pro. PostgreSQL Configuration Python Library.
+
+from __future__ import annotations
+
+from ....handlers import OptionHandlerToPrepareGetValue
+from ....handlers import OptionHandlerCtxToPrepareGetValue
+from ....handlers import ConfigurationDataHandler
+
+# //////////////////////////////////////////////////////////////////////////////
+# OptionHandlerToPrepareGetValue__Std__Int
+
+
+class OptionHandlerToPrepareGetValue__Std__Int(OptionHandlerToPrepareGetValue):
+    def __init__(self):
+        super().__init__()
+
+    # interface ----------------------------------------------------------
+    def PrepareGetValue(self, ctx: OptionHandlerCtxToPrepareGetValue) -> any:
+        assert type(ctx) == OptionHandlerCtxToPrepareGetValue
+        assert isinstance(ctx.DataHandler, ConfigurationDataHandler)
+        assert type(ctx.OptionName) == str
+        assert ctx.OptionValue is not None
+
+        # [2025-04-13] Research
+        assert type(ctx.OptionValue) == int
+
+        return int(ctx.OptionValue)
+
+
+# //////////////////////////////////////////////////////////////////////////////

testgres/postgres_configuration/core/option/handlers/prepare_get_value/option_handler_to_prepare_get_value__std__str.py

@@ -0,0 +1,31 @@
+# //////////////////////////////////////////////////////////////////////////////
+# Postgres Pro. PostgreSQL Configuration Python Library.
+
+from __future__ import annotations
+
+from ....handlers import OptionHandlerToPrepareGetValue
+from ....handlers import OptionHandlerCtxToPrepareGetValue
+from ....handlers import ConfigurationDataHandler
+
+# //////////////////////////////////////////////////////////////////////////////
+# OptionHandlerToPrepareGetValue__Std__Str
+
+
+class OptionHandlerToPrepareGetValue__Std__Str(OptionHandlerToPrepareGetValue):
+    def __init__(self):
+        super().__init__()
+
+    # interface ----------------------------------------------------------
+    def PrepareGetValue(self, ctx: OptionHandlerCtxToPrepareGetValue) -> any:
+        assert type(ctx) == OptionHandlerCtxToPrepareGetValue
+        assert isinstance(ctx.DataHandler, ConfigurationDataHandler)
+        assert type(ctx.OptionName) == str
+        assert ctx.OptionValue is not None
+
+        # [2025-04-13] Research
+        assert type(ctx.OptionValue) == str
+
+        return str(ctx.OptionValue)
+
+
+# //////////////////////////////////////////////////////////////////////////////

testgres/postgres_configuration/core/option/handlers/prepare_get_value/option_handler_to_prepare_get_value__std__unique_str_list.py

@@ -0,0 +1,46 @@
+# //////////////////////////////////////////////////////////////////////////////
+# Postgres Pro. PostgreSQL Configuration Python Library.
+
+from __future__ import annotations
+
+from ....handlers import OptionHandlerToPrepareGetValue
+from ....handlers import OptionHandlerCtxToPrepareGetValue
+from ....handlers import ConfigurationDataHandler
+
+import typing
+
+# //////////////////////////////////////////////////////////////////////////////
+# OptionHandlerToPrepareGetValue__Std__UniqueStrList
+
+
+class OptionHandlerToPrepareGetValue__Std__UniqueStrList(
+    OptionHandlerToPrepareGetValue
+):
+    def __init__(self):
+        super().__init__()
+
+    # interface ----------------------------------------------------------
+    def PrepareGetValue(self, ctx: OptionHandlerCtxToPrepareGetValue) -> any:
+        assert type(ctx) == OptionHandlerCtxToPrepareGetValue
+        assert isinstance(ctx.DataHandler, ConfigurationDataHandler)
+        assert type(ctx.OptionName) == str
+        assert ctx.OptionValue is not None
+        assert type(ctx.OptionValue) == list
+
+        result: typing.List[str] = list()
+        index: set[str] = set()
+
+        for x in ctx.OptionValue:
+            assert x is not None
+            v = str(x)
+
+            if v in index:
+                continue
+
+            result.append(v)
+            index.add(v)
+
+        return result
+
+
+# //////////////////////////////////////////////////////////////////////////////