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

testgres/postgres_configuration/core/option/handlers/prepare_set_value/option_handler_to_prepare_set_value__std__bool.py

@@ -0,0 +1,115 @@
+# //////////////////////////////////////////////////////////////////////////////
+# Postgres Pro. PostgreSQL Configuration Python Library.
+
+from __future__ import annotations
+
+from ....raise_error import RaiseError
+
+from ....handlers import OptionHandlerToPrepareSetValue
+from ....handlers import OptionHandlerCtxToPrepareSetValue
+from ....handlers import ConfigurationDataHandler
+
+import typing
+
+# //////////////////////////////////////////////////////////////////////////////
+# OptionHandlerToPrepareSetValue__Std__Bool
+
+
+class OptionHandlerToPrepareSetValue__Std__Bool(OptionHandlerToPrepareSetValue):
+    def __init__(self):
+        super().__init__()
+
+        # check
+        assert not any(set(__class__.sm_Str_True).intersection(__class__.sm_Str_False))
+
+        # prefixes are checked
+        assert not any(
+            [
+                x1
+                for x1 in __class__.sm_Str_True
+                if any([x2 for x2 in __class__.sm_Str_False if x2.startswith(x1)])
+            ]
+        )
+        assert not any(
+            [
+                x1
+                for x1 in __class__.sm_Str_False
+                if any([x2 for x2 in __class__.sm_Str_True if x2.startswith(x1)])
+            ]
+        )
+
+    # interface ----------------------------------------------------------
+    def PrepareSetValue(self, ctx: OptionHandlerCtxToPrepareSetValue) -> any:
+        assert type(ctx) == OptionHandlerCtxToPrepareSetValue
+        assert isinstance(ctx.DataHandler, ConfigurationDataHandler)
+        assert type(ctx.OptionName) == str
+        assert ctx.OptionValue is not None
+
+        optionValue = ctx.OptionValue
+        optionValueType = type(optionValue)
+
+        if optionValueType == bool:
+            return optionValue
+
+        if optionValueType == int:
+            assert type(optionValue) == int
+
+            if optionValue == 0:
+                return False
+
+            if optionValue == 1:
+                return True
+
+            RaiseError.CantConvertOptionValue(ctx.OptionName, optionValueType, bool)
+
+        if optionValueType == str:
+            assert type(optionValue) == str
+
+            if len(optionValue) < __class__.C_MIN_STR_VALUE_LENGTH:
+                pass
+            elif len(optionValue) > __class__.C_MAX_STR_VALUE_LENGTH:
+                pass
+            else:
+                optionValue_lower = optionValue.lower()
+
+                if optionValue_lower in __class__.sm_Str_False:
+                    return False
+
+                if optionValue_lower in __class__.sm_Str_True:
+                    return True
+
+            RaiseError.CantConvertOptionValue(ctx.OptionName, optionValueType, bool)
+
+        RaiseError.BadOptionValueType(ctx.OptionName, optionValueType, bool)
+
+    # Private data -------------------------------------------------------
+    C_MIN_STR_VALUE_LENGTH = 1
+    C_MAX_STR_VALUE_LENGTH = 5
+
+    sm_Str_False: typing.List[str] = [
+        "of",
+        "off",
+        "f",
+        "fa",
+        "fal",
+        "fals",
+        "false",
+        "n",
+        "no",
+        "0",
+    ]
+
+    sm_Str_True: typing.List[str] = [
+        "on",
+        "t",
+        "tr",
+        "tru",
+        "true",
+        "y",
+        "ye",
+        "yes",
+        "1",
+    ]
+
+
+# //////////////////////////////////////////////////////////////////////////////

testgres/postgres_configuration/core/option/handlers/prepare_set_value/option_handler_to_prepare_set_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 OptionHandlerToPrepareSetValue
+from ....handlers import OptionHandlerCtxToPrepareSetValue
+from ....handlers import ConfigurationDataHandler
+
+# //////////////////////////////////////////////////////////////////////////////
+# OptionHandlerToPrepareSetValue__Std__Generic
+
+
+class OptionHandlerToPrepareSetValue__Std__Generic(OptionHandlerToPrepareSetValue):
+    def __init__(self):
+        super().__init__()
+
+    # interface ----------------------------------------------------------
+    def PrepareSetValue(self, ctx: OptionHandlerCtxToPrepareSetValue) -> any:
+        assert type(ctx) == OptionHandlerCtxToPrepareSetValue
+        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_set_value/option_handler_to_prepare_set_value__std__int.py

@@ -0,0 +1,44 @@
+# //////////////////////////////////////////////////////////////////////////////
+# Postgres Pro. PostgreSQL Configuration Python Library.
+
+from __future__ import annotations
+
+from ....raise_error import RaiseError
+
+from ....handlers import OptionHandlerToPrepareSetValue
+from ....handlers import OptionHandlerCtxToPrepareSetValue
+from ....handlers import ConfigurationDataHandler
+
+# //////////////////////////////////////////////////////////////////////////////
+# OptionHandlerToPrepareSetValue__Std__Int
+
+
+class OptionHandlerToPrepareSetValue__Std__Int(OptionHandlerToPrepareSetValue):
+    def __init__(self):
+        super().__init__()
+
+    # interface ----------------------------------------------------------
+    def PrepareSetValue(self, ctx: OptionHandlerCtxToPrepareSetValue) -> any:
+        assert type(ctx) == OptionHandlerCtxToPrepareSetValue
+        assert isinstance(ctx.DataHandler, ConfigurationDataHandler)
+        assert type(ctx.OptionName) == str
+        assert ctx.OptionValue is not None
+
+        typeOfOptionValue = type(ctx.OptionValue)
+
+        if typeOfOptionValue == int:
+            return ctx.OptionValue
+
+        optionName = ctx.OptionName
+        assert type(optionName) == str
+
+        if typeOfOptionValue == str:
+            if not str(ctx.OptionValue).isnumeric():
+                RaiseError.CantConvertOptionValue(optionName, typeOfOptionValue, int)
+
+            return int(ctx.OptionValue)
+
+        RaiseError.BadOptionValueType(optionName, typeOfOptionValue, int)
+
+
+# //////////////////////////////////////////////////////////////////////////////

testgres/postgres_configuration/core/option/handlers/prepare_set_value/option_handler_to_prepare_set_value__std__str.py

@@ -0,0 +1,37 @@
+# //////////////////////////////////////////////////////////////////////////////
+# Postgres Pro. PostgreSQL Configuration Python Library.
+
+from __future__ import annotations
+
+from ....raise_error import RaiseError
+
+from ....handlers import OptionHandlerToPrepareSetValue
+from ....handlers import OptionHandlerCtxToPrepareSetValue
+from ....handlers import ConfigurationDataHandler
+
+# //////////////////////////////////////////////////////////////////////////////
+# OptionHandlerToPrepareSetValue__Std__Str
+
+
+class OptionHandlerToPrepareSetValue__Std__Str(OptionHandlerToPrepareSetValue):
+    def __init__(self):
+        super().__init__()
+
+    # interface ----------------------------------------------------------
+    def PrepareSetValue(self, ctx: OptionHandlerCtxToPrepareSetValue) -> any:
+        assert type(ctx) == OptionHandlerCtxToPrepareSetValue
+        assert isinstance(ctx.DataHandler, ConfigurationDataHandler)
+        assert type(ctx.OptionName) == str
+        assert ctx.OptionValue is not None
+
+        typeOfOptionValue = type(ctx.OptionValue)
+
+        if typeOfOptionValue != str:
+            optionName = ctx.OptionName
+            assert type(optionName) == str
+            RaiseError.BadOptionValueType(optionName, typeOfOptionValue, str)
+
+        return ctx.OptionValue
+
+
+# //////////////////////////////////////////////////////////////////////////////

testgres/postgres_configuration/core/option/handlers/prepare_set_value/option_handler_to_prepare_set_value__std__unique_str_list.py

@@ -0,0 +1,63 @@
+# //////////////////////////////////////////////////////////////////////////////
+# Postgres Pro. PostgreSQL Configuration Python Library.
+
+from __future__ import annotations
+
+from ....raise_error import RaiseError
+
+from ....handlers import OptionHandlerToPrepareSetValue
+from ....handlers import OptionHandlerCtxToPrepareSetValue
+from ....handlers import ConfigurationDataHandler
+
+from ....read_utils import ReadUtils
+
+import typing
+
+# //////////////////////////////////////////////////////////////////////////////
+# OptionHandlerToPrepareSetValue__Std__UniqueStrList
+
+
+class OptionHandlerToPrepareSetValue__Std__UniqueStrList(
+    OptionHandlerToPrepareSetValue
+):
+    def __init__(self):
+        super().__init__()
+
+    # interface ----------------------------------------------------------
+    def PrepareSetValue(self, ctx: OptionHandlerCtxToPrepareSetValue) -> any:
+        assert type(ctx) == OptionHandlerCtxToPrepareSetValue
+        assert isinstance(ctx.DataHandler, ConfigurationDataHandler)
+        assert type(ctx.OptionName) == str
+        assert ctx.OptionValue is not None
+
+        typeOfOptionValue = type(ctx.OptionValue)
+
+        if typeOfOptionValue == str:
+            result = ReadUtils.Unpack_StrList2(ctx.OptionValue)
+            assert result is not None
+            assert type(result) == list
+            return result
+        elif typeOfOptionValue == list:
+            result: typing.List[str] = list()
+            index: typing.Set[str] = set()
+
+            for x in ctx.OptionValue:
+                if x is None:
+                    RaiseError.NoneOptionValueItemIsNotSupported(ctx.OptionName)
+
+                v = str(x)
+
+                if v in index:
+                    continue
+
+                result.append(v)
+                index.add(v)
+
+            return result
+
+        optionName = ctx.OptionName
+        assert type(optionName) == str
+        RaiseError.BadOptionValueType(optionName, typeOfOptionValue, list)
+
+
+# //////////////////////////////////////////////////////////////////////////////

testgres/postgres_configuration/core/option/handlers/prepare_set_value_item/option_handler_to_prepare_set_value_item__std__str.py

@@ -0,0 +1,37 @@
+# //////////////////////////////////////////////////////////////////////////////
+# Postgres Pro. PostgreSQL Configuration Python Library.
+
+from __future__ import annotations
+
+from ....raise_error import RaiseError
+
+from ....handlers import OptionHandlerToPrepareSetValueItem
+from ....handlers import OptionHandlerCtxToPrepareSetValueItem
+from ....handlers import ConfigurationDataHandler
+
+# //////////////////////////////////////////////////////////////////////////////
+# OptionHandlerToPrepareSetValueItem__Std__Str
+
+
+class OptionHandlerToPrepareSetValueItem__Std__Str(OptionHandlerToPrepareSetValueItem):
+    def __init__(self):
+        super().__init__()
+
+    # interface ----------------------------------------------------------
+    def PrepareSetValueItem(self, ctx: OptionHandlerCtxToPrepareSetValueItem) -> any:
+        assert type(ctx) == OptionHandlerCtxToPrepareSetValueItem
+        assert isinstance(ctx.DataHandler, ConfigurationDataHandler)
+        assert type(ctx.OptionName) == str
+        assert ctx.OptionValueItem is not None
+
+        typeOfOptionValue = type(ctx.OptionValueItem)
+
+        if typeOfOptionValue != str:
+            optionName = ctx.OptionName
+            assert type(optionName) == str
+            RaiseError.BadOptionValueItemType(optionName, typeOfOptionValue, str)
+
+        return ctx.OptionValueItem
+
+
+# //////////////////////////////////////////////////////////////////////////////

testgres/postgres_configuration/core/option/handlers/set_value/option_handler_to_set_value__std__simple.py

@@ -0,0 +1,38 @@
+# //////////////////////////////////////////////////////////////////////////////
+# Postgres Pro. PostgreSQL Configuration Python Library.
+
+from __future__ import annotations
+
+from ....handlers import OptionHandlerToSetValue
+from ....handlers import OptionHandlerCtxToSetValue
+from ....handlers import ConfigurationDataHandler
+
+from ....model import FileData
+from ....model import OptionData
+
+# //////////////////////////////////////////////////////////////////////////////
+# OptionHandlerToSetValue__Std__Simple
+
+
+class OptionHandlerToSetValue__Std__Simple(OptionHandlerToSetValue):
+    def __init__(self):
+        super().__init__()
+
+    # interface ----------------------------------------------------------
+    def SetOptionValue(self, ctx: OptionHandlerCtxToSetValue) -> any:
+        assert type(ctx) == OptionHandlerCtxToSetValue
+        assert isinstance(ctx.DataHandler, ConfigurationDataHandler)
+        assert (
+            ctx.TargetData is None
+            or type(ctx.TargetData) == FileData
+            or type(ctx.TargetData) == OptionData
+        )
+        assert ctx.OptionName is not None
+        assert ctx.OptionValue is not None
+
+        return ctx.DataHandler.DataHandler__SetOptionValue__Simple(
+            ctx.TargetData, ctx.OptionName, ctx.OptionValue
+        )
+
+
+# //////////////////////////////////////////////////////////////////////////////

testgres/postgres_configuration/core/option/handlers/set_value_item/option_handler_to_set_value_item__std__unique.py

@@ -0,0 +1,38 @@
+# //////////////////////////////////////////////////////////////////////////////
+# Postgres Pro. PostgreSQL Configuration Python Library.
+
+from __future__ import annotations
+
+from ....handlers import OptionHandlerToSetValueItem
+from ....handlers import OptionHandlerCtxToSetValueItem
+from ....handlers import ConfigurationDataHandler
+
+from ....model import FileData
+from ....model import OptionData
+
+# //////////////////////////////////////////////////////////////////////////////
+# OptionHandlerToSetValueItem__Std__Unique
+
+
+class OptionHandlerToSetValueItem__Std__Unique(OptionHandlerToSetValueItem):
+    def __init__(self):
+        super().__init__()
+
+    # interface ----------------------------------------------------------
+    def SetOptionValueItem(self, ctx: OptionHandlerCtxToSetValueItem) -> any:
+        assert type(ctx) == OptionHandlerCtxToSetValueItem
+        assert isinstance(ctx.DataHandler, ConfigurationDataHandler)
+        assert (
+            ctx.TargetData is None
+            or type(ctx.TargetData) == FileData
+            or type(ctx.TargetData) == OptionData
+        )
+        assert type(ctx.OptionName) == str
+        assert ctx.OptionValueItem is not None
+
+        return ctx.DataHandler.DataHandler__SetUniqueOptionValueItem(
+            ctx.TargetData, ctx.OptionName, ctx.OptionValueItem
+        )
+
+
+# //////////////////////////////////////////////////////////////////////////////

testgres/postgres_configuration/core/option/handlers/write/option_handler_to_write__std__bool.py

@@ -0,0 +1,42 @@
+# //////////////////////////////////////////////////////////////////////////////
+# Postgres Pro. PostgreSQL Configuration Python Library.
+
+from __future__ import annotations
+
+from ....handlers import OptionHandlerToWrite
+from ....handlers import OptionHandlerCtxToWrite
+
+from ....raise_error import RaiseError
+
+# //////////////////////////////////////////////////////////////////////////////
+# OptionHandlerToWrite__Std__Bool
+
+
+class OptionHandlerToWrite__Std__Bool(OptionHandlerToWrite):
+    def __init__(self):
+        super().__init__()
+
+    # interface ----------------------------------------------------------
+    def OptionValueToString(self, ctx: OptionHandlerCtxToWrite) -> str:
+        assert type(ctx) == OptionHandlerCtxToWrite
+        assert type(ctx.OptionName) == str
+        assert ctx.OptionValue is not None
+
+        typeOfValue = type(ctx.OptionValue)
+
+        if typeOfValue == bool:
+            typedValue = bool(ctx.OptionValue)
+        else:
+            RaiseError.BadOptionValueItemType(ctx.OptionName, typeOfValue, bool)
+
+        assert type(typedValue) == bool
+
+        if typedValue:
+            result = "on"
+        else:
+            result = "off"
+
+        return result
+
+
+# //////////////////////////////////////////////////////////////////////////////

testgres/postgres_configuration/core/option/handlers/write/option_handler_to_write__std__generic.py

@@ -0,0 +1,51 @@
+# //////////////////////////////////////////////////////////////////////////////
+# Postgres Pro. PostgreSQL Configuration Python Library.
+
+from __future__ import annotations
+
+from .option_handler_to_write__std__int import OptionHandlerToWrite__Std__Int
+from .option_handler_to_write__std__str import OptionHandlerToWrite__Std__Str
+from .option_handler_to_write__std__bool import OptionHandlerToWrite__Std__Bool
+
+from ....handlers import OptionHandlerToWrite
+from ....handlers import OptionHandlerCtxToWrite
+
+from ....bugcheck_error import BugCheckError
+
+# //////////////////////////////////////////////////////////////////////////////
+# OptionHandlerToWrite__Std__Generic
+
+
+class OptionHandlerToWrite__Std__Generic(OptionHandlerToWrite):
+    # fmt off
+    sm_Handler_For_Int = OptionHandlerToWrite__Std__Int()
+
+    sm_Handler_For_Str = OptionHandlerToWrite__Std__Str()
+
+    sm_Handler_For_Bool = OptionHandlerToWrite__Std__Bool()
+    # fmt on
+
+    # --------------------------------------------------------------------
+    def __init__(self):
+        super().__init__()
+
+    # interface ----------------------------------------------------------
+    def OptionValueToString(self, ctx: OptionHandlerCtxToWrite) -> str:
+        assert type(ctx) == OptionHandlerCtxToWrite
+        assert ctx.OptionValue is not None
+
+        typeOfOptionValue = type(ctx.OptionValue)
+
+        if typeOfOptionValue == int:
+            return __class__.sm_Handler_For_Int.OptionValueToString(ctx)
+
+        if typeOfOptionValue == str:
+            return __class__.sm_Handler_For_Str.OptionValueToString(ctx)
+
+        if typeOfOptionValue == bool:
+            return __class__.sm_Handler_For_Bool.OptionValueToString(ctx)
+
+        BugCheckError.UnknownOptionValueType(ctx.OptionName, typeOfOptionValue)
+
+
+# //////////////////////////////////////////////////////////////////////////////

testgres/postgres_configuration/core/option/handlers/write/option_handler_to_write__std__int.py

@@ -0,0 +1,27 @@
+# //////////////////////////////////////////////////////////////////////////////
+# Postgres Pro. PostgreSQL Configuration Python Library.
+
+from __future__ import annotations
+
+from ....handlers import OptionHandlerToWrite
+from ....handlers import OptionHandlerCtxToWrite
+
+# //////////////////////////////////////////////////////////////////////////////
+# OptionHandlerToWrite__Std__Int
+
+
+class OptionHandlerToWrite__Std__Int(OptionHandlerToWrite):
+    def __init__(self):
+        super().__init__()
+
+    # interface ----------------------------------------------------------
+    def OptionValueToString(self, ctx: OptionHandlerCtxToWrite) -> str:
+        assert type(ctx) == OptionHandlerCtxToWrite
+        assert ctx.OptionValue is not None
+
+        typedValue = int(ctx.OptionValue)
+
+        return str(typedValue)
+
+
+# //////////////////////////////////////////////////////////////////////////////

testgres/postgres_configuration/core/option/handlers/write/option_handler_to_write__std__str.py

@@ -0,0 +1,36 @@
+# //////////////////////////////////////////////////////////////////////////////
+# Postgres Pro. PostgreSQL Configuration Python Library.
+
+from __future__ import annotations
+
+from ....handlers import OptionHandlerToWrite
+from ....handlers import OptionHandlerCtxToWrite
+
+from ....write_utils import WriteUtils
+
+# //////////////////////////////////////////////////////////////////////////////
+# OptionHandlerToWrite__Std__Str
+
+
+class OptionHandlerToWrite__Std__Str(OptionHandlerToWrite):
+    def __init__(self):
+        super().__init__()
+
+    # interface ----------------------------------------------------------
+    def OptionValueToString(self, ctx: OptionHandlerCtxToWrite) -> str:
+        assert type(ctx) == OptionHandlerCtxToWrite
+        assert ctx.OptionValue is not None
+
+        typedValue = str(ctx.OptionValue)
+
+        result = WriteUtils.Pack_Str(typedValue)
+
+        assert type(result) == str
+        assert len(result) >= 2
+        assert result[0] == "'"
+        assert result[-1] == "'"
+
+        return result
+
+
+# //////////////////////////////////////////////////////////////////////////////

testgres/postgres_configuration/core/option/handlers/write/option_handler_to_write__std__unique_str_list.py

@@ -0,0 +1,37 @@
+# //////////////////////////////////////////////////////////////////////////////
+# Postgres Pro. PostgreSQL Configuration Python Library.
+
+from __future__ import annotations
+
+from ....handlers import OptionHandlerToWrite
+from ....handlers import OptionHandlerCtxToWrite
+
+from ....write_utils import WriteUtils
+
+# //////////////////////////////////////////////////////////////////////////////
+# OptionHandlerToWrite__Std__UniqueStrList
+
+
+class OptionHandlerToWrite__Std__UniqueStrList(OptionHandlerToWrite):
+    def __init__(self):
+        super().__init__()
+
+    # interface ----------------------------------------------------------
+    def OptionValueToString(self, ctx: OptionHandlerCtxToWrite) -> str:
+        assert type(ctx) == OptionHandlerCtxToWrite
+        assert ctx.OptionValue is not None
+        assert type(ctx.OptionValue) == list
+
+        result = WriteUtils.Pack_StrList2(ctx.OptionValue)
+        assert type(result) == str
+
+        result = WriteUtils.Pack_Str(result)
+        assert type(result) == str
+        assert len(result) >= 2
+        assert result[0] == "'"
+        assert result[-1] == "'"
+
+        return result
+
+
+# //////////////////////////////////////////////////////////////////////////////