testgres.postgres-configuration 0.5.0__tar.gz → 0.6.0__tar.gz

{testgres_postgres_configuration-0.5.0/testgres.postgres_configuration.egg-info → testgres_postgres_configuration-0.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: testgres.postgres_configuration
-Version: 0.5.0
+Version: 0.6.0
 Summary: PostgreSQL Configuration Python Library
 Author-email: Postgres Professional <testgres@postgrespro.ru>
 License: PostgreSQL

{testgres_postgres_configuration-0.5.0 → testgres_postgres_configuration-0.6.0}/pyproject.toml

@@ -19,7 +19,7 @@ log_file_date_format = "%Y-%m-%d %H:%M:%S"
 
 [project]
 name = "testgres.postgres_configuration"
-version = "0.5.0"
+version = "0.6.0"
 
 description = "PostgreSQL Configuration Python Library"
 readme = "README.md"

testgres_postgres_configuration-0.6.0/src/__init__.py

@@ -0,0 +1,41 @@
+# //////////////////////////////////////////////////////////////////////////////
+# Postgres Pro. PostgreSQL Configuration Python Library.
+
+# fmt: off
+from .implementation.v00.configuration_std import PostgresConfiguration_Std as PostgresConfiguration
+
+from .implementation.v00.configuration_std import PostgresConfigurationReader_Std as PostgresConfigurationReader
+
+from .implementation.v00.configuration_std import PostgresConfigurationWriter_Std as PostgresConfigurationWriter
+
+from .abstract.v00.configuration import PostgresConfigurationOption
+from .abstract.v00.configuration import PostgresConfigurationInclude
+from .abstract.v00.configuration import PostgresConfigurationIncludeIfExists
+from .abstract.v00.configuration import PostgresConfigurationComment
+from .abstract.v00.configuration import PostgresConfigurationOptions
+from .abstract.v00.configuration import PostgresConfigurationFiles
+from .abstract.v00.configuration import AddIncludeIfExistsRule
+from .abstract.v00.configuration import PostgresConfigurationSetOptionValueResult
+from .abstract.v00.configuration import PostgresConfigurationSetOptionValueEventID
+# fmt: on
+
+# //////////////////////////////////////////////////////////////////////////////
+
+
+__all__ = [
+    "PostgresConfiguration",
+    "PostgresConfigurationReader",
+    "PostgresConfigurationWriter",
+    "PostgresConfigurationOption",
+    "PostgresConfigurationInclude",
+    "PostgresConfigurationIncludeIfExists",
+    "PostgresConfigurationComment",
+    "PostgresConfigurationOptions",
+    "PostgresConfigurationFiles",
+    "AddIncludeIfExistsRule",
+    "PostgresConfigurationSetOptionValueResult",
+    "PostgresConfigurationSetOptionValueEventID",
+]
+
+
+# //////////////////////////////////////////////////////////////////////////////

{testgres_postgres_configuration-0.5.0 → testgres_postgres_configuration-0.6.0}/src/abstract/v00/configuration.py

@@ -8,6 +8,15 @@ from ...core.raise_error import RaiseError
 import typing
 import enum
 
+# //////////////////////////////////////////////////////////////////////////////
+# AddIncludeIfExistsRule
+
+
+class AddIncludeIfExistsRule(enum.Enum):
+    without_file = 0
+    with_file = 1
+
+
 # //////////////////////////////////////////////////////////////////////////////
 # class PostgresConfigurationObject
 
@@ -174,6 +183,27 @@ class PostgresConfigurationInclude(PostgresConfigurationElement):
         RaiseError.MethodIsNotImplemented(__class__, "Delete")
 
 
+# //////////////////////////////////////////////////////////////////////////////
+# class PostgresConfigurationIncludeIfExists
+
+
+class PostgresConfigurationIncludeIfExists(PostgresConfigurationElement):
+    def __init__(self):
+        super().__init__()
+
+    # interface ----------------------------------------------------------
+    def get_File(self) -> typing.Optional[PostgresConfigurationFile]:
+        RaiseError.MethodIsNotImplemented(__class__, "get_File")
+
+    # --------------------------------------------------------------------
+    def Delete(
+        self,
+        withLine: bool,
+    ) -> None:
+        assert type(withLine) is bool
+        RaiseError.MethodIsNotImplemented(__class__, "Delete")
+
+
 # //////////////////////////////////////////////////////////////////////////////
 # class PostgresConfigurationFileLine
 
@@ -220,6 +250,19 @@ class PostgresConfigurationFileLine(PostgresConfigurationObject):
         assert (offset is None) or (type(offset) is int)
         RaiseError.MethodIsNotImplemented(__class__, "AddInclude")
 
+    # --------------------------------------------------------------------
+    def AddIncludeIfExists(
+        self,
+        path: str,
+        offset: typing.Optional[int],
+        rule: AddIncludeIfExistsRule,
+    ) -> PostgresConfigurationIncludeIfExists:
+        assert type(path) is str
+        assert path != ""
+        assert (offset is None) or (type(offset) is int)
+        assert type(rule) is AddIncludeIfExistsRule
+        RaiseError.MethodIsNotImplemented(__class__, "AddIncludeIfExists")
+
     # --------------------------------------------------------------------
     def Clear(self) -> None:
         RaiseError.MethodIsNotImplemented(__class__, "Clear")
@@ -313,6 +356,17 @@ class PostgresConfigurationFile(PostgresConfigurationObject):
         assert path != ""
         RaiseError.MethodIsNotImplemented(__class__, "AddInclude")
 
+    # --------------------------------------------------------------------
+    def AddIncludeIfExists(
+        self,
+        path: str,
+        rule: AddIncludeIfExistsRule,
+    ) -> PostgresConfigurationIncludeIfExists:
+        assert type(path) is str
+        assert path != ""
+        assert type(rule) is AddIncludeIfExistsRule
+        RaiseError.MethodIsNotImplemented(__class__, "AddIncludeIfExists")
+
     # --------------------------------------------------------------------
     #
     # Method for inserting, updating and deleting of an option.

{testgres_postgres_configuration-0.5.0 → testgres_postgres_configuration-0.6.0}/src/core/bugcheck_error.py

@@ -153,6 +153,12 @@ class BugCheckError:
         errMsg = "Include is not found in file line."
         __class__.Helper__Raise(errMsg)
 
+    # --------------------------------------------------------------------
+    @staticmethod
+    def IncludeIfExistsIsNotFoundInFileLine() -> typing.NoReturn:
+        errMsg = "IncludeIfExists is not found in file line."
+        __class__.Helper__Raise(errMsg)
+
     # --------------------------------------------------------------------
     @staticmethod
     def FileLineIsNotFoundInFile() -> typing.NoReturn:
@@ -296,6 +302,18 @@ class BugCheckError:
 
         __class__.Helper__Raise(errMsg)
 
+    # --------------------------------------------------------------------
+    @staticmethod
+    def UnknownAddIncludeIfExistsRule(
+        value: typing.AnyStr,
+    ) -> typing.NoReturn:
+
+        errMsg = "Unknown AddIncludeIfExistsRule: {}.".format(
+            value,
+        )
+
+        __class__.Helper__Raise(errMsg)
+
     # --------------------------------------------------------------------
     @staticmethod
     def UnsupportedPgConfStrategy(

{testgres_postgres_configuration-0.5.0 → testgres_postgres_configuration-0.6.0}/src/core/model.py

@@ -155,6 +155,41 @@ class IncludeData(FileLineElementData):
         return
 
 
+# //////////////////////////////////////////////////////////////////////////////
+# IncludeIfExistsData
+
+
+class IncludeIfExistsData(FileLineElementData):
+    m_Path: str
+    m_File: typing.Optional[FileData]
+
+    # --------------------------------------------------------------------
+    def __init__(
+        self,
+        parent: FileLineData,
+        offset: typing.Optional[int],
+        path: str,
+        fileData: typing.Optional[FileData],
+    ):
+        assert type(parent) is FileLineData
+        assert type(path) is str
+        assert fileData is None or type(fileData) is FileData
+        assert offset is None or type(offset) is int
+
+        assert parent.IsAlive()
+
+        if fileData is not None:
+            assert fileData.IsAlive()
+            assert fileData.get_Parent() is parent.get_Parent().get_Parent()
+            pass
+
+        super().__init__(parent, offset)
+
+        self.m_Path = path
+        self.m_File = fileData
+        return
+
+
 # //////////////////////////////////////////////////////////////////////////////
 # FileLineData
 

{testgres_postgres_configuration-0.5.0 → testgres_postgres_configuration-0.6.0}/src/core/model_utils.py

@@ -10,6 +10,7 @@ from .model import FileLineElementData as PgCfgModel__FileLineElementData
 from .model import CommentData as PgCfgModel__CommentData
 from .model import OptionData as PgCfgModel__OptionData
 from .model import IncludeData as PgCfgModel__IncludeData
+from .model import IncludeIfExistsData as PgCfgModel__IncludeIfExistsData
 from .model import FileLineData as PgCfgModel__FileLineData
 from .model import FileData as PgCfgModel__FileData
 from .model import MultiIndex as PgCfgModel__MultiIndex
@@ -110,6 +111,31 @@ class ModelUtils:
         __class__.Helper__DeleteFileLine(cfgData, fileLineData)
         return
 
+    # --------------------------------------------------------------------
+    @staticmethod
+    def IncludeIfExists__delete(
+        cfgData: PgCfgModel__ConfigurationData,
+        includeIfExistsData: PgCfgModel__IncludeIfExistsData,
+        withLine: bool,
+    ) -> None:
+        assert type(cfgData) is PgCfgModel__ConfigurationData
+        assert type(includeIfExistsData) is PgCfgModel__IncludeIfExistsData
+        assert type(withLine) is bool
+
+        fileLineData = includeIfExistsData.m_Parent
+        assert fileLineData is not None
+        assert type(fileLineData) is PgCfgModel__FileLineData
+
+        __class__.Helper__DeleteIncludeIfExists(includeIfExistsData)
+
+        if not withLine:
+            return
+
+        assert not __class__.Helper__FileLineHasWorkData(fileLineData)
+
+        __class__.Helper__DeleteFileLine(cfgData, fileLineData)
+        return
+
     # --------------------------------------------------------------------
     @staticmethod
     def Comment__delete(
@@ -193,6 +219,9 @@ class ModelUtils:
         if type(lastItem.m_Element) is PgCfgModel__IncludeData:
             return
 
+        if type(lastItem.m_Element) is PgCfgModel__IncludeIfExistsData:
+            return
+
         if type(lastItem.m_Element) is PgCfgModel__CommentData:
             RaiseError.FileLineAlreadyHasComment()
 
@@ -230,7 +259,39 @@ class ModelUtils:
             fileLineDataItem,
         )
 
-        # TODO: Reg include data in a global index?
+        return includeData
+
+    # --------------------------------------------------------------------
+    @staticmethod
+    def FileLine__add_IncludeIfExists(
+        fileLineData: PgCfgModel__FileLineData,
+        filePath: str,
+        fileData: typing.Optional[PgCfgModel__FileData],
+        offset: typing.Optional[int],
+    ) -> PgCfgModel__IncludeIfExistsData:
+        assert type(fileLineData) is PgCfgModel__FileLineData
+        assert type(filePath) is str
+        assert fileData is None or type(fileData) is PgCfgModel__FileData
+        assert filePath != ""
+        assert offset is None or type(offset) is int
+
+        assert fileLineData.IsAlive()
+        assert fileData is None or fileData.IsAlive()
+
+        __class__.Helper__CheckThatWeCanAddWorkDataToFileLine(fileLineData)
+
+        includeData = PgCfgModel__IncludeIfExistsData(
+            fileLineData,
+            offset,
+            filePath,
+            fileData,
+        )
+        fileLineDataItem = PgCfgModel__FileLineData.tagItem(
+            includeData,
+        )
+        fileLineData.m_Items.append(
+            fileLineDataItem,
+        )
 
         return includeData
 
@@ -325,6 +386,9 @@ class ModelUtils:
         if type(lastItem.m_Element) is PgCfgModel__IncludeData:
             RaiseError.FileLineAlreadyHasIncludeDirective()
 
+        if type(lastItem.m_Element) is PgCfgModel__IncludeIfExistsData:
+            RaiseError.FileLineAlreadyHasIncludeIfExistsDirective()
+
         if type(lastItem.m_Element) is PgCfgModel__CommentData:
             RaiseError.FileLineAlreadyHasComment()
 
@@ -364,7 +428,10 @@ class ModelUtils:
         assert fileLineData.m_Items is not None
         assert type(fileLineData.m_Items) is list
 
-        return __class__.Helper__ClearFileLine(cfgData, fileLineData)
+        return __class__.Helper__ClearFileLine(
+            cfgData,
+            fileLineData,
+        )
 
     # --------------------------------------------------------------------
     class tagFindCtx:
@@ -460,6 +527,27 @@ class ModelUtils:
                     return firstItem.m_Element  # <--------- BINGO
 
                 if type(firstItem.m_Element) is PgCfgModel__IncludeData:
+                    assert firstItem.m_Element.m_File is not None
+                    assert type(firstItem.m_Element.m_File.m_Path) is str
+
+                    if not enterIntoIncludes:
+                        # Stop searching upwards: any option defined above an include
+                        # might be overridden by that included file.
+                        return None  # <--------- FAIL
+
+                    assert findCtx is not None
+                    if not findCtx.reg_file(firstItem.m_Element.m_File.m_Path):
+                        continue
+
+                    nextFile = firstItem.m_Element.m_File
+                    break
+
+                if type(firstItem.m_Element) is PgCfgModel__IncludeIfExistsData:
+                    if firstItem.m_Element.m_File is None:
+                        continue
+
+                    assert type(firstItem.m_Element.m_File.m_Path) is str
+
                     if not enterIntoIncludes:
                         # Stop searching upwards: any option defined above an include
                         # might be overridden by that included file.
@@ -969,7 +1057,10 @@ class ModelUtils:
             assert lastItem is not None
             assert isinstance(lastItem.m_Element, PgCfgModel__FileLineElementData)
 
-            __class__.Helper__DeleteElement(cfgData, lastItem.m_Element)
+            __class__.Helper__DeleteElement(
+                cfgData,
+                lastItem.m_Element,
+            )
 
             assert fileLineData.m_Items is not None
             assert type(fileLineData.m_Items) is list
@@ -1030,6 +1121,9 @@ class ModelUtils:
         if type(objectData) is PgCfgModel__IncludeData:
             return __class__.Helper__DeleteInclude(objectData)
 
+        if type(objectData) is PgCfgModel__IncludeIfExistsData:
+            return __class__.Helper__DeleteIncludeIfExists(objectData)
+
         BugCheckError.UnkObjectDataType(type(objectData))
 
     # --------------------------------------------------------------------
@@ -1178,6 +1272,8 @@ class ModelUtils:
 
         assert iFileLineItem >= 0
         assert iFileLineItem < len(fileLineData.m_Items)
+        assert fileLineData.m_Items[iFileLineItem] is not None
+        assert fileLineData.m_Items[iFileLineItem].m_Element is includeData
 
         # 2. Perform delete operations
 
@@ -1187,6 +1283,49 @@ class ModelUtils:
         fileLineData.m_Items.pop(iFileLineItem)
         return
 
+    # --------------------------------------------------------------------
+    @staticmethod
+    def Helper__DeleteIncludeIfExists(
+        includeIfExistsData: PgCfgModel__IncludeIfExistsData,
+    ) -> None:
+        assert type(includeIfExistsData) is PgCfgModel__IncludeIfExistsData
+        assert includeIfExistsData.IsAlive()
+
+        # 0.
+        fileLineData = None
+        iFileLineItem = None
+
+        # 1.1 Set fileLineData
+        fileLineData = includeIfExistsData.m_Parent
+        assert fileLineData is not None
+        assert type(fileLineData) is PgCfgModel__FileLineData
+        assert fileLineData.IsAlive()
+
+        # 1.2 Set iFileLineItem
+        iFileLineItem = __class__.Helper__FindIndexOfFileLineElement(
+            fileLineData,
+            includeIfExistsData,
+        )
+
+        assert iFileLineItem >= 0
+        assert iFileLineItem <= len(fileLineData.m_Items)
+
+        if iFileLineItem == len(fileLineData.m_Items):
+            BugCheckError.IncludeIfExistsIsNotFoundInFileLine()
+
+        assert iFileLineItem >= 0
+        assert iFileLineItem < len(fileLineData.m_Items)
+        assert fileLineData.m_Items[iFileLineItem] is not None
+        assert fileLineData.m_Items[iFileLineItem].m_Element is includeIfExistsData
+
+        # 2. Perform delete operations
+
+        # delete from fileLine
+        includeIfExistsData.MarkAsDeletedFrom(fileLineData)
+        assert not includeIfExistsData.IsAlive()
+        fileLineData.m_Items.pop(iFileLineItem)
+        return
+
     # --------------------------------------------------------------------
     @staticmethod
     def Helper__DeleteFileLine(

{testgres_postgres_configuration-0.5.0 → testgres_postgres_configuration-0.6.0}/src/core/raise_error.py

@@ -128,6 +128,15 @@ class RaiseError:
             errMsg,
         )
 
+    # --------------------------------------------------------------------
+    @staticmethod
+    def IncludeIfExistsObjectWasDeleted() -> typing.NoReturn:
+        errMsg = "IncludeIfExists object was deleted."
+
+        __class__.Helper__RaiseErr__PostgresConfigException(
+            errMsg,
+        )
+
     # --------------------------------------------------------------------
     @staticmethod
     def FileLineObjectWasDeleted() -> typing.NoReturn:
@@ -384,6 +393,15 @@ class RaiseError:
             errMsg,
         )
 
+    # --------------------------------------------------------------------
+    @staticmethod
+    def FileLineAlreadyHasIncludeIfExistsDirective() -> typing.NoReturn:
+        errMsg = "File line already has an include_if_exists directive."
+
+        __class__.Helper__RaiseErr__PostgresConfigException(
+            errMsg,
+        )
+
     # --------------------------------------------------------------------
     @staticmethod
     def CfgReader__UnexpectedSymbol(

{testgres_postgres_configuration-0.5.0 → testgres_postgres_configuration-0.6.0}/src/implementation/v00/configuration_base.py

@@ -11,6 +11,7 @@ from ...abstract.v00.configuration import PostgresConfigurationOption
 from ...abstract.v00.configuration import PostgresConfigurationOptions
 from ...abstract.v00.configuration import PostgresConfigurationOptionsIterator
 from ...abstract.v00.configuration import PostgresConfigurationInclude
+from ...abstract.v00.configuration import PostgresConfigurationIncludeIfExists
 from ...abstract.v00.configuration import PostgresConfigurationFileLine
 from ...abstract.v00.configuration import PostgresConfigurationFileLines
 from ...abstract.v00.configuration import PostgresConfigurationFileLinesIterator
@@ -19,12 +20,14 @@ from ...abstract.v00.configuration import PostgresConfigurationFiles
 from ...abstract.v00.configuration import PostgresConfigurationFilesIterator
 from ...abstract.v00.configuration import PostgresConfigurationSetOptionValueEventID
 from ...abstract.v00.configuration import PostgresConfigurationSetOptionValueResult
+from ...abstract.v00.configuration import AddIncludeIfExistsRule
 
 from ...core.model import ConfigurationData as PgCfgModel__ConfigurationData
 from ...core.model import ObjectData as PgCfgModel__ObjectData
 from ...core.model import CommentData as PgCfgModel__CommentData
 from ...core.model import OptionData as PgCfgModel__OptionData
 from ...core.model import IncludeData as PgCfgModel__IncludeData
+from ...core.model import IncludeIfExistsData as PgCfgModel__IncludeIfExistsData
 from ...core.model import FileLineData as PgCfgModel__FileLineData
 from ...core.model import FileData as PgCfgModel__FileData
 from ...core.model import MultiIndex as PgCfgModel__MultiIndex
@@ -304,7 +307,9 @@ class PostgresConfigurationInclude_Base(PostgresConfigurationInclude):
         return self.m_FileLine
 
     # Include interface --------------------------------------------------
-    def get_File(self) -> PostgresConfigurationIncludedFile_Base:
+    def get_File(
+        self,
+    ) -> PostgresConfigurationIncludedFile_Base:
         self.Helper__CheckAlive()
 
         return PostgresConfigurationIncludedFile_Base(
@@ -356,6 +361,99 @@ class PostgresConfigurationInclude_Base(PostgresConfigurationInclude):
         return
 
 
+# //////////////////////////////////////////////////////////////////////////////
+# class PostgresConfigurationIncludeIfExists_Base
+
+
+class PostgresConfigurationIncludeIfExists_Base(PostgresConfigurationIncludeIfExists):
+    m_FileLine: PostgresConfigurationFileLine_Base
+    m_IncludeIfExistsData: PgCfgModel__IncludeIfExistsData
+
+    # --------------------------------------------------------------------
+    def __init__(
+        self,
+        fileLine: PostgresConfigurationFileLine_Base,
+        includeIfExistsData: PgCfgModel__IncludeIfExistsData,
+    ):
+        assert type(fileLine) is PostgresConfigurationFileLine_Base
+        assert type(includeIfExistsData) is PgCfgModel__IncludeIfExistsData
+
+        super().__init__()
+
+        self.m_FileLine = fileLine
+        self.m_IncludeIfExistsData = includeIfExistsData
+        return
+
+    # Object interface ---------------------------------------------------
+    def get_Configuration(self) -> PostgresConfiguration_Base:
+        self.Helper__CheckAlive()
+        return self.m_FileLine.get_Configuration()
+
+    # --------------------------------------------------------------------
+    def get_Parent(self) -> PostgresConfigurationFileLine_Base:
+        self.Helper__CheckAlive()
+        return self.m_FileLine
+
+    # IncludeIfExists interface ------------------------------------------
+    def get_File(
+        self,
+    ) -> typing.Optional[PostgresConfigurationIncludedIfExistsFile_Base]:
+        self.Helper__CheckAlive()
+
+        if self.m_IncludeIfExistsData.m_File is None:
+            return None
+
+        return PostgresConfigurationIncludedIfExistsFile_Base(
+            self,
+            self.m_IncludeIfExistsData.m_File,
+        )
+
+    # --------------------------------------------------------------------
+    def Delete(
+        self,
+        withLine: bool,
+    ) -> None:
+        assert type(withLine) is bool
+
+        self.Helper__CheckAlive()
+        assert type(self.m_IncludeIfExistsData) is PgCfgModel__IncludeIfExistsData
+        assert type(self.m_IncludeIfExistsData.m_Parent) is PgCfgModel__FileLineData
+        assert (
+            type(self.m_IncludeIfExistsData.m_Parent.m_Parent) is PgCfgModel__FileData
+        )
+        assert (
+            type(self.m_IncludeIfExistsData.m_Parent.m_Parent.m_Parent)
+            is PgCfgModel__ConfigurationData
+        )
+
+        cfgData = self.m_IncludeIfExistsData.m_Parent.m_Parent.m_Parent
+        assert type(cfgData) is PgCfgModel__ConfigurationData
+
+        PgCfgModel__ModelUtils.IncludeIfExists__delete(
+            cfgData,
+            self.m_IncludeIfExistsData,
+            withLine,
+        )
+        return
+
+    # Private interface --------------------------------------------------
+    def Private__CheckAlive(self) -> None:
+        self.Helper__CheckAlive()
+        return
+
+    # Helper methods -----------------------------------------------------
+    def Helper__CheckAlive(self) -> None:
+        assert self.m_IncludeIfExistsData is not None
+        assert type(self.m_IncludeIfExistsData) is PgCfgModel__IncludeIfExistsData
+
+        if not self.m_IncludeIfExistsData.IsAlive():
+            RaiseError.IncludeIfExistsObjectWasDeleted()
+
+        assert type(self.m_FileLine) is PostgresConfigurationFileLine_Base
+        assert isinstance(self.m_FileLine, PostgresConfigurationFileLine)
+        return
+
+
 # //////////////////////////////////////////////////////////////////////////////
 # class PostgresConfigurationFileLine_Base
 
@@ -564,6 +662,90 @@ class PostgresConfigurationFileLine_Base(PostgresConfigurationFileLine):
 
         return include
 
+    # --------------------------------------------------------------------
+    def AddIncludeIfExists(
+        self,
+        path: str,
+        offset: typing.Optional[int],
+        rule: AddIncludeIfExistsRule,
+    ) -> PostgresConfigurationIncludeIfExists_Base:
+        assert offset is None or type(offset) is int
+        assert offset is None or offset >= 0
+        assert type(rule) is AddIncludeIfExistsRule
+
+        DataVerificator.CheckStringOfFilePath(path)
+
+        assert type(path) is str
+        assert path != ""
+
+        self.Helper__CheckAlive()
+
+        assert isinstance(self.m_Parent, PostgresConfigurationFile_Base)
+
+        cfg = self.m_Parent.m_Cfg
+        assert isinstance(cfg, PostgresConfiguration_Base)
+        assert type(cfg.m_Data) is PgCfgModel__ConfigurationData
+
+        # Add/Get file
+        # Add include element
+
+        if rule == AddIncludeIfExistsRule.without_file:
+            withFile = False
+        elif rule == AddIncludeIfExistsRule.with_file:
+            withFile = True
+        else:
+            BugCheckError.UnknownAddIncludeIfExistsRule(rule)
+
+        if not withFile:
+            fileData = None
+        else:
+            assert self.m_FileLineData.m_Parent is not None
+
+            baseFolder = cfg.m_Data.OsOps.Path_DirName(
+                self.m_FileLineData.m_Parent.m_Path,
+            )
+            assert type(baseFolder) is str
+
+            fileData = PgCfgModel__ModelUtils.Cfg__GetOrCreateFile__USER(
+                cfg.m_Data,
+                baseFolder,
+                path,
+            )
+            assert type(fileData) is PgCfgModel__FileData
+
+        try:
+            includeData = PgCfgModel__ModelUtils.FileLine__add_IncludeIfExists(
+                self.m_FileLineData,
+                path,
+                fileData,
+                offset,
+            )
+            assert includeData is not None
+            assert type(includeData) is PgCfgModel__IncludeIfExistsData
+            assert includeData.m_Path == path
+            assert includeData.m_File is fileData
+            assert includeData.m_Parent == self.m_FileLineData
+
+            try:
+                # -----------
+                include = PostgresConfigurationIncludeIfExists_Base(
+                    self,
+                    includeData,
+                )
+                assert include.m_FileLine is self
+                assert include.m_IncludeIfExistsData is includeData
+            except:  # rollback an include
+                PgCfgModel__ModelUtils.IncludeIfExists__delete(
+                    cfg.m_Data,
+                    includeData,
+                    False,
+                )
+                raise
+        except:  # TODO: rollback a file
+            raise
+
+        return include
+
     # --------------------------------------------------------------------
     def Clear(self) -> None:
         self.Helper__CheckAlive()
@@ -936,7 +1118,9 @@ class PostgresConfigurationFile_Base(PostgresConfigurationFile):
         # Add empty line
         # Add include element
 
-        baseFolder = self.m_Cfg.m_Data.OsOps.Path_DirName(self.m_FileData.m_Path)
+        baseFolder = self.m_Cfg.m_Data.OsOps.Path_DirName(
+            self.m_FileData.m_Path,
+        )
         assert type(baseFolder) is str
 
         fileData = PgCfgModel__ModelUtils.Cfg__GetOrCreateFile__USER(
@@ -1001,6 +1185,103 @@ class PostgresConfigurationFile_Base(PostgresConfigurationFile):
 
         return include
 
+    # --------------------------------------------------------------------
+    def AddIncludeIfExists(
+        self,
+        path: str,
+        rule: AddIncludeIfExistsRule,
+    ) -> PostgresConfigurationIncludeIfExists_Base:
+        DataVerificator.CheckStringOfFilePath(path)
+
+        assert type(path) is str
+        assert path != ""
+        assert type(rule) is AddIncludeIfExistsRule
+
+        self.Internal__CheckAlive()
+
+        assert self.m_Cfg is not None
+        assert isinstance(self.m_Cfg, PostgresConfiguration_Base)
+        assert type(self.m_Cfg.m_Data) is PgCfgModel__ConfigurationData
+
+        # Add/Get file
+        # Add empty line
+        # Add include element
+
+        if rule == AddIncludeIfExistsRule.without_file:
+            withFile = False
+        elif rule == AddIncludeIfExistsRule.with_file:
+            withFile = True
+        else:
+            BugCheckError.UnknownAddIncludeIfExistsRule(rule)
+
+        if not withFile:
+            fileData = None
+        else:
+            baseFolder = self.m_Cfg.m_Data.OsOps.Path_DirName(
+                self.m_FileData.m_Path,
+            )
+            assert type(baseFolder) is str
+
+            fileData = PgCfgModel__ModelUtils.Cfg__GetOrCreateFile__USER(
+                self.m_Cfg.m_Data,
+                baseFolder,
+                path,
+            )
+            assert type(fileData) is PgCfgModel__FileData
+
+        try:
+            fileLineData = PgCfgModel__ModelUtils.File__add_Line(
+                self.m_FileData,
+            )
+
+            assert self.m_FileData is not None
+            assert type(self.m_FileData) is PgCfgModel__FileData
+            assert self.m_FileData.m_Lines is not None
+            assert type(self.m_FileData.m_Lines) is list
+            assert len(self.m_FileData.m_Lines) > 0
+            assert self.m_FileData.m_Lines[-1] is fileLineData
+
+            try:
+                includeData = PgCfgModel__ModelUtils.FileLine__add_IncludeIfExists(
+                    fileLineData,
+                    path,
+                    fileData,
+                    None,
+                )
+                assert includeData is not None
+                assert type(includeData) is PgCfgModel__IncludeIfExistsData
+                assert includeData.m_Path == path
+                assert includeData.m_File is fileData
+                assert includeData.m_Parent == fileLineData
+
+                # -----------
+                fileLine = PostgresConfigurationFileLine_Base(
+                    self,
+                    fileLineData,
+                )
+                assert fileLine is not None
+                assert type(fileLine) is PostgresConfigurationFileLine_Base
+                assert fileLine.m_FileLineData is fileLineData
+                assert fileLine.m_Parent is self
+
+                # -----------
+                include = PostgresConfigurationIncludeIfExists_Base(
+                    fileLine,
+                    includeData,
+                )
+                assert include.m_FileLine is fileLine
+                assert include.m_IncludeIfExistsData is includeData
+            except:  # rollback a line
+                PgCfgModel__ModelUtils.FileLine__delete(
+                    self.m_Cfg.m_Data,
+                    fileLineData,
+                )
+                raise
+        except:  # TODO: rollback a file
+            raise
+
+        return include
+
     # --------------------------------------------------------------------
     #
     # Method for inserting, updating and deleting of an option.
@@ -1181,6 +1462,60 @@ class PostgresConfigurationIncludedFile_Base(PostgresConfigurationFile_Base):
         return
 
 
+# //////////////////////////////////////////////////////////////////////////////
+# class PostgresConfigurationIncludedIfExistsFile_Base
+
+
+class PostgresConfigurationIncludedIfExistsFile_Base(PostgresConfigurationFile_Base):
+    m_IncludeIfExists: PostgresConfigurationIncludeIfExists_Base
+
+    # --------------------------------------------------------------------
+    def __init__(
+        self,
+        include: PostgresConfigurationIncludeIfExists_Base,
+        fileData: PgCfgModel__FileData,
+    ):
+        assert type(include) is PostgresConfigurationIncludeIfExists_Base
+        assert type(fileData) is PgCfgModel__FileData
+
+        super().__init__(
+            include.get_Configuration(),
+            fileData,
+        )
+
+        self.m_IncludeIfExists = include
+        return
+
+    # Object interface ---------------------------------------------------
+    def get_Parent(self) -> PostgresConfigurationIncludeIfExists_Base:
+        self.Internal__CheckAlive()
+        assert isinstance(
+            self.m_IncludeIfExists,
+            PostgresConfigurationIncludeIfExists_Base,
+        )
+        assert isinstance(
+            self.m_IncludeIfExists,
+            PostgresConfigurationIncludeIfExists,
+        )
+        return self.m_IncludeIfExists
+
+    # Internal interface -------------------------------------------------
+    def Internal__CheckAlive(self) -> None:
+        assert self.m_FileData is not None
+        assert self.m_IncludeIfExists is not None
+        assert type(self.m_FileData) is PgCfgModel__FileData
+        assert type(self.m_IncludeIfExists) is PostgresConfigurationIncludeIfExists_Base
+
+        if not self.m_FileData.IsAlive():
+            RaiseError.FileObjectWasDeleted()
+
+        self.m_IncludeIfExists.Private__CheckAlive()
+
+        assert isinstance(self.m_Cfg, PostgresConfiguration_Base)
+        assert isinstance(self.m_Cfg, PostgresConfiguration)
+        return
+
+
 # //////////////////////////////////////////////////////////////////////////////
 # class PostgresConfigurationSetOptionValueResult_Base
 

{testgres_postgres_configuration-0.5.0 → testgres_postgres_configuration-0.6.0}/src/implementation/v00/configuration_base_r.py

@@ -9,10 +9,12 @@ from .configuration_base import PostgresConfigurationFileLine_Base
 from .configuration_base import PostgresConfigurationFile_Base
 from .configuration_base import PostgresConfigurationTopLevelFile_Base
 from .configuration_base import PostgresConfigurationFactory_Base
+from .configuration_base import AddIncludeIfExistsRule
 
 from ...core.model import CommentData as PgCfgModel__CommentData
 from ...core.model import OptionData as PgCfgModel__OptionData
 from ...core.model import IncludeData as PgCfgModel__IncludeData
+from ...core.model import IncludeIfExistsData as PgCfgModel__IncludeIfExistsData
 from ...core.model import FileLineData as PgCfgModel__FileLineData
 from ...core.model import FileData as PgCfgModel__FileData
 from ...core.model import FileStatus as PgCfgModel__FileStatus
@@ -148,6 +150,33 @@ class PostgresConfigurationReader_Base:
                         queuedFileDatas.add(includeData.m_File)
                         continue
 
+                    if type(fileLineElementData) is PgCfgModel__IncludeIfExistsData:
+                        # look at existFileDatas
+                        includeIfExistsData = fileLineElementData
+
+                        if includeIfExistsData.m_File is None:
+                            continue
+
+                        assert type(includeIfExistsData.m_File) is PgCfgModel__FileData
+                        assert type(includeIfExistsData.m_File.m_Path) is str
+
+                        if includeIfExistsData.m_File.m_Path in existFileDatas:
+                            continue  # it is an old file
+
+                        assert (
+                            includeIfExistsData.m_File.m_Status
+                            == PgCfgModel__FileStatus.IS_NEW
+                        )
+                        assert (
+                            includeIfExistsData.m_File.m_LastModifiedTimestamp is None
+                        )
+
+                        if includeIfExistsData.m_File in queuedFileDatas:
+                            continue  # already in queue
+
+                        queuedFileDatas.add(includeIfExistsData.m_File)
+                        continue
+
                     BugCheckError.UnkObjectDataType(type(fileLineElementData))
                 continue
             continue  # while queuedFileDatas
@@ -272,6 +301,17 @@ class PostgresConfigurationReader_Base:
                     )
                     continue
 
+                if sequence.lower() == "include_if_exists":
+                    if ch is not None:
+                        lineReader.StepBack()
+
+                    __class__.Helper__ProcessLineData__IncludeIfExists(
+                        fileLine,
+                        lineReader,
+                        sequenceOffset,
+                    )
+                    continue
+
                 if ch is not None:
                     lineReader.StepBack()
 
@@ -333,6 +373,69 @@ class PostgresConfigurationReader_Base:
         assert type(includeOffset) is int
         assert includeOffset >= 0
 
+        filePath = __class__.Helper__ProcessFilePath(
+            fileLine,
+            lineReader,
+        )
+
+        fileLine.AddInclude(
+            filePath,
+            includeOffset,
+        )
+        return
+
+    # --------------------------------------------------------------------
+    @staticmethod
+    def Helper__ProcessLineData__IncludeIfExists(
+        fileLine: PostgresConfigurationFileLine_Base,
+        lineReader: ReadUtils__LineReader,
+        includeOffset: int,
+    ) -> None:
+        assert type(fileLine) is PostgresConfigurationFileLine_Base
+        assert type(lineReader) is ReadUtils__LineReader
+        assert type(includeOffset) is int
+        assert includeOffset >= 0
+        assert fileLine.m_Parent is not None
+        assert fileLine.m_Parent.m_FileData is not None
+        assert fileLine.m_Parent.m_FileData.m_Parent is not None
+
+        filePath = __class__.Helper__ProcessFilePath(
+            fileLine,
+            lineReader,
+        )
+
+        osOps = fileLine.m_Parent.m_FileData.m_Parent.m_OsOps
+        assert osOps is not None
+
+        normFilePath = Helpers.NormalizeFilePath(
+            osOps,
+            osOps.Path_DirName(fileLine.m_Parent.m_FileData.m_Path),
+            filePath,
+        )
+        assert type(normFilePath) is str
+        assert normFilePath != ""
+
+        if osOps.Path_IsExists(normFilePath):
+            rule = AddIncludeIfExistsRule.with_file
+        else:
+            rule = AddIncludeIfExistsRule.without_file
+
+        fileLine.AddIncludeIfExists(
+            filePath,
+            includeOffset,
+            rule=rule,
+        )
+        return
+
+    # --------------------------------------------------------------------
+    @staticmethod
+    def Helper__ProcessFilePath(
+        fileLine: PostgresConfigurationFileLine_Base,
+        lineReader: ReadUtils__LineReader,
+    ) -> str:
+        assert type(fileLine) is PostgresConfigurationFileLine_Base
+        assert type(lineReader) is ReadUtils__LineReader
+
         # find first quote
         while True:
             ch = lineReader.ReadSymbol()
@@ -452,11 +555,7 @@ class PostgresConfigurationReader_Base:
                 lineReader.GetLineNum(),
             )
 
-        fileLine.AddInclude(
-            filePath,
-            includeOffset,
-        )
-        return
+        return filePath
 
     # --------------------------------------------------------------------
     @staticmethod

{testgres_postgres_configuration-0.5.0 → testgres_postgres_configuration-0.6.0}/src/implementation/v00/configuration_base_w.py

@@ -11,6 +11,7 @@ from ...core.model import FileLineElementData as PgCfgModel__FileLineElementData
 from ...core.model import CommentData as PgCfgModel__CommentData
 from ...core.model import OptionData as PgCfgModel__OptionData
 from ...core.model import IncludeData as PgCfgModel__IncludeData
+from ...core.model import IncludeIfExistsData as PgCfgModel__IncludeIfExistsData
 from ...core.model import FileLineData as PgCfgModel__FileLineData
 from ...core.model import FileData as PgCfgModel__FileData
 from ...core.model import FileStatus as PgCfgModel__FileStatus
@@ -475,6 +476,12 @@ class PostgresConfigurationWriter_Base:
                 elementData,
             )
 
+        if type(elementData) is PgCfgModel__IncludeIfExistsData:
+            return __class__.Helper__IncludeIfExistsToString(
+                ctx,
+                elementData,
+            )
+
         BugCheckError.UnkObjectDataType(type(elementData))
 
     # --------------------------------------------------------------------
@@ -552,5 +559,25 @@ class PostgresConfigurationWriter_Base:
         assert result != ""
         return result
 
+    # --------------------------------------------------------------------
+    @staticmethod
+    def Helper__IncludeIfExistsToString(
+        ctx: PostgresConfigurationWriterCtx_Base,
+        includeIfExistsData: PgCfgModel__IncludeIfExistsData,
+    ) -> str:
+        assert type(ctx) is PostgresConfigurationWriterCtx_Base
+        assert ctx.Cfg is not None
+        assert isinstance(ctx.Cfg, PostgresConfiguration_Base)
+        assert type(includeIfExistsData) is PgCfgModel__IncludeIfExistsData
+        assert includeIfExistsData.m_Path is not None
+        assert type(includeIfExistsData.m_Path) is str
+        assert includeIfExistsData.m_Path != ""
+
+        result = "include_if_exists " + WriteUtils.Pack_Str(includeIfExistsData.m_Path)
+
+        assert type(result) is str
+        assert result != ""
+        return result
+
 
 # //////////////////////////////////////////////////////////////////////////////

{testgres_postgres_configuration-0.5.0 → testgres_postgres_configuration-0.6.0}/src/os/abstract/configuration_os_ops.py

@@ -55,6 +55,10 @@ class ConfigurationOsFile(ConfigurationFileReader):
 
 
 class ConfigurationOsOps:
+    def Path_IsExists(self, a: str) -> bool:
+        assert type(a) is str
+        RaiseError.MethodIsNotImplemented(__class__, "Path_IsExists")
+
     def Path_IsAbs(self, a: str) -> bool:
         assert type(a) is str
         RaiseError.MethodIsNotImplemented(__class__, "Path_IsAbs")

{testgres_postgres_configuration-0.5.0 → testgres_postgres_configuration-0.6.0}/src/os/local/configuration_os_ops.py

@@ -97,6 +97,10 @@ class ConfigurationOsFile(abstract.ConfigurationOsFile):
 
 
 class ConfigurationOsOps(abstract.ConfigurationOsOps):
+    def Path_IsExists(self, a: str) -> bool:
+        assert type(a) is str
+        return os.path.exists(a)
+
     def Path_IsAbs(self, a: str) -> bool:
         assert type(a) is str
         return os.path.isabs(a)

{testgres_postgres_configuration-0.5.0 → testgres_postgres_configuration-0.6.0/testgres.postgres_configuration.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: testgres.postgres_configuration
-Version: 0.5.0
+Version: 0.6.0
 Summary: PostgreSQL Configuration Python Library
 Author-email: Postgres Professional <testgres@postgrespro.ru>
 License: PostgreSQL

testgres_postgres_configuration-0.5.0/src/__init__.py

@@ -1,22 +0,0 @@
-# //////////////////////////////////////////////////////////////////////////////
-# Postgres Pro. PostgreSQL Configuration Python Library.
-
-# fmt: off
-from .implementation.v00.configuration_std import PostgresConfiguration_Std as PostgresConfiguration
-
-from .implementation.v00.configuration_std import PostgresConfigurationReader_Std as PostgresConfigurationReader
-
-from .implementation.v00.configuration_std import PostgresConfigurationWriter_Std as PostgresConfigurationWriter
-# fmt: on
-
-# //////////////////////////////////////////////////////////////////////////////
-
-
-__all__ = [
-    "PostgresConfiguration",
-    "PostgresConfigurationReader",
-    "PostgresConfigurationWriter",
-]
-
-
-# //////////////////////////////////////////////////////////////////////////////