pgmonkey 0.0.1__tar.gz

pgmonkey-0.0.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 RexBytes
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

pgmonkey-0.0.1/PKG-INFO

@@ -0,0 +1,42 @@
+Metadata-Version: 2.1
+Name: pgmonkey
+Version: 0.0.1
+Summary: A tool to assist with postgresql database connections
+Author-email: Good Boy <pythonic@rexbytes.com>
+License: MIT License
+        
+        Copyright (c) 2024 RexBytes
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+        
+Project-URL: Homepage, https://github.com/RexBytes/pgmonkey
+Project-URL: Bug Tracker, https://github.com/RexBytes/pgmonkey
+Classifier: Programming Language :: Python :: 3.12
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Database
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: psycopg[binary]>=3.2.1
+Requires-Dist: psycopg_pool>=3.2.2
+Requires-Dist: PyYAML>=6.0.2
+
+# pgmonkey

pgmonkey-0.0.1/README.md

@@ -0,0 +1 @@
+# pgmonkey

pgmonkey-0.0.1/pyproject.toml

@@ -0,0 +1,38 @@
+[build-system]
+requires = ["setuptools>=65.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "pgmonkey"
+version = "0.0.1"
+authors = [
+  { name="Good Boy", email="pythonic@rexbytes.com" },
+]
+description = "A tool to assist with postgresql database connections"
+readme = "README.md"
+license = { file="LICENSE" }
+requires-python = ">=3.12"
+classifiers = [
+    "Programming Language :: Python :: 3.12",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+    "Topic :: Database",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+]
+
+dependencies = [
+    "psycopg[binary]>=3.2.1",
+    "psycopg_pool>=3.2.2",
+    "PyYAML>=6.0.2",
+]
+
+[tool.setuptools.package-data]
+pglinker = ["app_settings.yaml", "common/templates/*"]
+
+[project.urls]
+"Homepage" = "https://github.com/RexBytes/pgmonkey"
+"Bug Tracker" = "https://github.com/RexBytes/pgmonkey"
+
+[project.scripts]
+pgmonkey="cli.cli:main"
+

pgmonkey-0.0.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

pgmonkey-0.0.1/src/cli/cli.py

@@ -0,0 +1,44 @@
+from .cli_toplevel_parser import cli_toplevel_parser
+from .cli_settings_subparser import cli_settings_subparser
+from .cli_pgconfig_subparser import cli_pgconfig_subparser
+from .cli_pg_server_config_subparser import  cli_pg_server_config_subparser
+
+
+class CLI:
+    def __init__(self):
+        # We need the main top level parser.
+        self.parser = cli_toplevel_parser()
+        # We attach a 'sub-parser container' to hold all subparsers, e.g. the subparser that handles settings.
+        self.subparsers = self.parser.add_subparsers(title="commands", dest="command", help="Available commands")
+        # We start populating the 'sub-parser container' with subparsers.
+        cli_settings_subparser(self.subparsers)
+        cli_pgconfig_subparser(self.subparsers)
+        cli_pg_server_config_subparser(self.subparsers)
+
+    def run(self):
+        # Parse all arguments from the command line into argparse.
+        args = self.parser.parse_args()
+        # This bit here feels like magic, let me explain.
+        # You already have defined parser and subparser logic which the argparse module understands.
+        # If you give it say "pgmonkey settings --helloworld" it knows it needs to looks at your
+        # settings subparser, and it knows you have given it --helloworld argument.
+        # It looks at all the arguments you have given, and the associated default
+        # arguments, in this case func=settings_subparser_handle.
+        #
+        # The following if statement merely checks if the argument func has been populated,
+        # it then calls the function and passes in all the other arguments.
+        # The argument helloworld is detected and acted on by the function settings_subparser_handle()
+        # This is a very flexible implementation, which is why it feels like magic.
+        if hasattr(args, 'func'):
+            args.func(args)
+        else:
+            self.parser.print_help()
+
+
+def main():
+    cli = CLI()
+    cli.run()
+
+
+if __name__ == "__main__":
+    main()

pgmonkey-0.0.1/src/cli/cli_pg_server_config_subparser.py

@@ -0,0 +1,20 @@
+from pgmonkey.managers.pg_server_config_manager import PGServerConfigManager
+
+
+def cli_pg_server_config_subparser(subparsers):
+    pg_server_config_manager = PGServerConfigManager()
+
+    pg_server_config_parser = subparsers.add_parser('pgserverconfig',
+                                                    help='Generate suggested server configuration entries')
+
+    pg_server_config_parser.add_argument('--filepath', required=True,
+                                         help='Path to the config you want settings generated.')
+    pg_server_config_parser.set_defaults(func=pg_server_config_create_handler,
+                                         pg_server_config_manager=pg_server_config_manager)
+
+
+def pg_server_config_create_handler(args):
+    pg_server_config_manager = args.pg_server_config_manager
+
+    if args.filepath:
+        pg_server_config_manager.get_server_config(args.filepath)

pgmonkey-0.0.1/src/cli/cli_pgconfig_subparser.py

@@ -0,0 +1,41 @@
+from pgmonkey.managers.pgconfig_manager import PGConfigManager
+from pathlib import Path
+
+
+def cli_pgconfig_subparser(subparsers):
+    pgconfig_manager = PGConfigManager()
+
+
+    pgconfig_parser = subparsers.add_parser('pgconfig', help='Manage database configurations')
+    # Note, the following line is adding a subparser to this subparser which is allowed.
+    pgconfig_subparsers = pgconfig_parser.add_subparsers(dest='pgconfig_command', help='pgconfig commands')
+
+    # The "create" subcommand
+    create_parser = pgconfig_subparsers.add_parser('create', help='Create a new database configuration file.')
+    create_parser.add_argument('--type', choices=['pg'], default='pg', required=False,
+                               help='Database type for the configuration template. Default is "pg".')
+    create_parser.add_argument('--filepath', required=True,
+                               help='Path to where you want your configuration file created.')
+    create_parser.set_defaults(func=pgconfig_create_handler, pgconfig_manager=pgconfig_manager)
+
+    # The "test" subcommand
+    test_parser = pgconfig_subparsers.add_parser('test',
+                                                 help='Test the database connection using a configuration file.')
+    test_parser.add_argument('--filepath', required=True, help='Path to the configuration file you want to test.')
+    test_parser.set_defaults(func=pgconfig_test_handler, pgconfig_manager=pgconfig_manager)
+
+
+
+def pgconfig_create_handler(args):
+    pgconfig_manager = args.pgconfig_manager
+    filepath = Path(args.filepath)
+    if filepath.exists():
+        print(f'Configuration file already exists: {filepath}\nEdit this file to update settings.')
+    else:
+        config_template_text = pgconfig_manager.get_config_template_text(args.type)
+        pgconfig_manager.write_config_template_text(filepath, config_template_text)
+
+
+def pgconfig_test_handler(args):
+    pgconfig_manager = args.pgconfig_manager
+    pgconfig_manager.test_connection(args.filepath)

pgmonkey-0.0.1/src/cli/cli_settings_subparser.py

@@ -0,0 +1,20 @@
+import argparse
+from pgmonkey.managers.settings_manager import SettingsManager
+
+
+def cli_settings_subparser(subparsers):
+    # Create a subparser for the settings command
+    subparser = subparsers.add_parser('settings', help='Manage application settings.')
+
+    # Add arguments specific to the settings management
+    subparser.add_argument("--helloworld", type=str, help="Place holder for settings subparser")
+
+    # Set the default function to call with parsed arguments
+    subparser.set_defaults(func=settings_subparser_handle)
+
+
+def settings_subparser_handle(args):
+    settings_manager = SettingsManager()
+
+    if args.helloworld:
+        settings_manager.print_hello_world()

pgmonkey-0.0.1/src/cli/cli_toplevel_parser.py

@@ -0,0 +1,35 @@
+import argparse
+from pgmonkey.managers.toplevel_manager import ToplevelManager
+
+
+def cli_toplevel_parser():
+    parser = top_level_parser_init()
+    parser = top_level_parser_arguments(parser)
+    return parser
+
+
+def top_level_parser_init():
+    # Let's create the main top-level parser,
+    parser = argparse.ArgumentParser(
+        # prog: whenever the automatically generated help messages are displayed it will
+        #       use the string value to refer to the application.
+        prog='pgmonkey',
+        # description: this is the description of your application.
+        description="pgmonkey: A tool to assist with database connections and manage data."
+    )
+
+    return parser
+
+
+def top_level_parser_arguments(parser):
+    parser.add_argument(
+        # add --version argument to the top level parser.
+        '--version',
+        # The 'version' action is a builtin argparse action specific for versioning info.
+        action='version',
+        # Construct a string with version information that will be returned.
+        # Here we use the VersionManager class.
+        # We also use the prog string we defined in the top-level parser creation above.
+        version=f"%(prog)s {ToplevelManager.get_package_version('pgmonkey')}"
+    )
+    return parser

pgmonkey-0.0.1/src/pgmonkey/__init__.py

@@ -0,0 +1 @@
+from .managers.pgconnection_manager import PGConnectionManager

pgmonkey-0.0.1/src/pgmonkey/common/utils/pathutils.py

@@ -0,0 +1,83 @@
+import os
+from pathlib import Path
+
+
+class PathUtils:
+    @staticmethod
+    def construct_path(path_elements):
+        """Construct a path from a list of elements, handling '~', '', '/', and '\\'."""
+        if not path_elements:
+            return Path()
+
+        # Start with handling the first element specially if it indicates a root or home directory
+        first_elem = path_elements[0]
+        if first_elem in ['~', '', '/', '\\']:
+            if first_elem == '~':
+                # Path relative to user's home directory
+                base_path = Path.home()
+            elif first_elem in ['', '/', '\\']:
+                # Absolute path starting from root
+                base_path = Path('/')
+            return base_path.joinpath(*path_elements[1:])
+        elif ':' in first_elem and len(first_elem) == 2 and first_elem[1] == ':':
+            # Windows-specific: path starts with a drive letter
+            return Path(first_elem).joinpath(*path_elements[1:])
+        else:
+            # Normal path construction
+            return Path(*path_elements)
+
+    @staticmethod
+    def deconstruct_path(path):
+        """Deconstruct a Path object into a list of its components, considering special cases."""
+        components = []
+
+        # Handle absolute paths, including Windows-specific drive letters
+        if path.is_absolute():
+            if path.drive:
+                components.append(path.drive)
+            else:
+                components.append('')
+            components.extend(path.parts[1:])
+        elif path.home() in path.parents:
+            # Handle paths relative to the home directory
+            components.append('~')
+            components.extend(path.relative_to(Path.home()).parts)
+        else:
+            # Handle relative paths
+            components.extend(path.parts)
+
+        return components
+
+
+# Example Usage:
+if __name__ == "__main__":
+    # Test cases for constructing paths
+    print("Testing Path Construction:")
+    test_elements = [
+        (['~', 'projects', 'example'], "Home directory relative"),
+        (['/', 'usr', 'bin'], "Root directory"),
+        (['', 'usr', 'bin'], "Absolute path from root"),
+        (['C:', 'Users', 'example'], "Windows drive letter"),
+        (['..', 'another_folder'], "Relative path"),
+        (['usr', 'bin'], "Additional relative path"),
+        (['~', '.rexdblinker', 'connectionconfigs'], "RexPath")
+    ]
+    for elements, description in test_elements:
+        path = PathUtils.construct_path(elements)
+        print(f"{description} Path: {path}")
+
+    # Test cases for deconstructing paths
+    print("\nTesting Path Deconstruction:")
+    test_paths = [
+        (Path.home().joinpath('projects', 'example'), "Home directory relative"),
+        (Path('/usr/bin'), "Root directory"),
+        (Path('usr/bin'), "Relative path from current directory"),  # Corrected description
+        (Path('C:/Users/example'), "Windows drive letter"),
+        (Path('../another_folder'), "Relative path")
+    ]
+    for path, description in test_paths:
+        path_list = PathUtils.deconstruct_path(path)
+        print(f"{description} Path List: {path_list}")
+
+
+

pgmonkey-0.0.1/src/pgmonkey/connections/base.py

@@ -0,0 +1,17 @@
+from abc import ABC, abstractmethod
+
+class BaseConnection(ABC):
+    @abstractmethod
+    def connect(self):
+        """Establish a database connection."""
+        pass
+
+    @abstractmethod
+    def test_connection(self):
+        """Test the database connection."""
+        pass
+
+    @abstractmethod
+    def disconnect(self):
+        """Close the database connection."""
+        pass

pgmonkey-0.0.1/src/pgmonkey/connections/postgres/__init__.py

@@ -0,0 +1 @@
+from .postgres_connection_factory import PostgresConnectionFactory

pgmonkey-0.0.1/src/pgmonkey/connections/postgres/async_connection.py

@@ -0,0 +1,47 @@
+from psycopg import AsyncConnection, OperationalError
+from .base_connection import BaseConnection
+
+
+class PGAsyncConnection(BaseConnection):
+    def __init__(self, config, post_connect_async_settings=None):
+        super().__init__()
+        self.config = config
+        # This dictionary can contain settings to be applied after the connection is established
+        self.post_connect_async_settings = post_connect_async_settings or {}
+        self.connection: AsyncConnection = None
+
+    async def connect(self):
+        """Establishes an asynchronous database connection."""
+        if self.connection is None or self.connection.closed:
+            self.connection = await AsyncConnection.connect(**self.config)
+            await self.apply_post_connect_settings()
+
+    async def apply_post_connect_settings(self):
+        """Applies any settings that need to be set after the connection is established."""
+        for setting, value in self.post_connect_async_settings.items():
+            # This example assumes settings can be applied directly as attributes
+            # Adjust this method based on the actual async settings and their required handling
+            setattr(self.connection, setting, value)
+
+    async def __aenter__(self):
+        if self.connection is None or self.connection.closed:
+            await self.connect()
+        return self
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        await self.disconnect()
+
+    async def test_connection(self):
+        """Tests the asynchronous database connection."""
+        if self.connection is None or self.connection.closed:
+            await self.connect()
+        async with self.connection.cursor() as cur:
+            await cur.execute('SELECT 1;')
+            result = await cur.fetchone()
+            print("Async connection successful: ", result)
+
+    async def disconnect(self):
+        """Closes the asynchronous database connection."""
+        if self.connection and not self.connection.closed:
+            await self.connection.close()
+            self.connection = None

pgmonkey-0.0.1/src/pgmonkey/connections/postgres/async_pool_connection.py

@@ -0,0 +1,43 @@
+from psycopg_pool import AsyncConnectionPool
+from .base_connection import PostgresBaseConnection
+
+
+class PGAsyncPoolConnection(PostgresBaseConnection):
+    def __init__(self, config, pool_settings=None):
+        super().__init__()  # Call super if the base class has an __init__ method
+        self.config = config
+        self.pool_settings = pool_settings or {}
+        self.pool = None
+
+    def construct_dsn(self):
+        """Assuming self.config directly contains connection info as a dict."""
+        # This assumes all keys in self.config are for the connection,
+        # adjust if your config includes other types of settings.
+        return " ".join([f"{k}={v}" for k, v in self.config.items()])
+
+    async def connect(self):
+        dsn = self.construct_dsn()
+        # Initialize AsyncConnectionPool with DSN and any pool-specific settings
+        self.pool = AsyncConnectionPool(conninfo=dsn, **self.pool_settings)
+        await self.pool.open()
+
+    async def __aenter__(self):
+        if not self.pool:
+            await self.connect()
+        return self
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        await self.disconnect()
+
+    async def test_connection(self):
+        if not self.pool:
+            await self.connect()
+        async with self.pool.connection() as conn:
+            async with conn.cursor() as cur:
+                await cur.execute('SELECT 1;')
+                print("Async pool connection successful: ", await cur.fetchone())
+
+    async def disconnect(self):
+        if self.pool:
+            await self.pool.close()
+            self.pool = None

pgmonkey-0.0.1/src/pgmonkey/connections/postgres/base_connection.py

@@ -0,0 +1,7 @@
+from abc import ABC, abstractmethod
+from ..base import BaseConnection  # Assuming base.py contains BaseConnection and is in the same directory level
+
+
+class PostgresBaseConnection(BaseConnection, ABC):
+    # PostgreSQL-specific shared behavior (if any)
+    pass

pgmonkey-0.0.1/src/pgmonkey/connections/postgres/normal_connection.py

@@ -0,0 +1,38 @@
+from psycopg import connect, OperationalError  # This imports psycopg3, assuming you have installed 'psycopg' version 3+
+from .base_connection import PostgresBaseConnection
+
+
+class PGNormalConnection(PostgresBaseConnection):
+    def __init__(self, config):
+        # The configuration dict should contain connection parameters like dbname, user, password, etc.
+        self.config = config
+        self.connection = None
+
+    def connect(self):
+        # Establishes a synchronous connection to the PostgreSQL server.
+        # The 'connect' function is used both in psycopg2 and psycopg3 for this purpose.
+        self.connection = connect(**self.config)
+
+
+    def test_connection(self):
+        try:
+            with self.connection.cursor() as cur:
+                cur.execute('SELECT 1;')  # Execute a simple query to test the connection.
+                print("Connection successful: ", cur.fetchone())
+        except OperationalError as e:
+            print(f"Connection failed: {e}")
+
+    def disconnect(self):
+        # Closes the connection to the database.
+        if self.connection:
+            self.connection.close()
+
+    def __enter__(self):
+        # Ensures the connection is established when entering the context.
+        if not self.connection:
+            self.connect()
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        # Closes the connection when exiting the context.
+        self.disconnect()

pgmonkey-0.0.1/src/pgmonkey/connections/postgres/pool_connection.py

@@ -0,0 +1,52 @@
+from psycopg_pool import ConnectionPool
+from psycopg import OperationalError
+# Assuming PostgresBaseConnection is correctly implemented elsewhere
+from .base_connection import PostgresBaseConnection
+
+
+class PGPoolConnection(PostgresBaseConnection):
+    def __init__(self, config, pool_settings=None):
+        super().__init__()  # Initialize the base class, if necessary
+        self.config = config
+        self.pool_settings = pool_settings or {}
+        # Directly pass connection parameters and pool settings to ConnectionPool
+        self.pool = ConnectionPool(conninfo=self.construct_conninfo(self.config), **self.pool_settings)
+
+    @staticmethod
+    def construct_conninfo(config):
+        """Constructs a connection info string from the config dictionary, excluding pool settings."""
+        # Filter out 'pool_settings' and any other non-connection parameters
+        conn_params = {k: v for k, v in config.items() if k not in ['pool_settings'] and v is not None}
+        # Construct and return the connection info string
+        return " ".join([f"{k}={v}" for k, v in conn_params.items()])
+
+
+    def test_connection(self):
+        """Tests a connection from the pool."""
+        try:
+            with self.pool.connection() as conn:
+                with conn.cursor() as cur:
+                    cur.execute('SELECT 1;')
+                    result = cur.fetchone()
+                    print("Pool connection successful: ", result)
+        except OperationalError as e:
+            print(f"Connection failed: {e}")
+
+    def disconnect(self):
+        """Closes all connections in the pool."""
+        if self.pool:
+            self.pool.close()
+            self.pool = None
+
+    def connect(self):
+        # This method is implemented to satisfy the interface of the abstract base class.
+        # The connection pool is initialized in the constructor, so no action is needed here.
+        pass
+
+    def __enter__(self):
+        # Return self to make it possible to use 'with PGPoolConnection(config) as conn:'
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        # Ensure the pool is properly closed when exiting the context
+        self.disconnect()

pgmonkey-0.0.1/src/pgmonkey/connections/postgres/postgres_connection_factory.py

@@ -0,0 +1,41 @@
+from pgmonkey.connections.postgres.normal_connection import PGNormalConnection
+from pgmonkey.connections.postgres.pool_connection import PGPoolConnection
+from pgmonkey.connections.postgres.async_connection import PGAsyncConnection
+from pgmonkey.connections.postgres.async_pool_connection import PGAsyncPoolConnection
+
+
+class PostgresConnectionFactory:
+    def __init__(self, config):
+        self.connection_type = config['postgresql']['connection_type']
+        self.config = self.filter_config(config['postgresql']['connection_settings'])
+        self.pool_settings = config['postgresql'].get('pool_settings', {})
+        self.async_settings = config['postgresql'].get('async_settings', {})
+        self.async_pool_settings = config['postgresql'].get('async_pool_settings', {})
+
+    @staticmethod
+    def filter_config(config):
+        # List of valid psycopg connection parameters
+        valid_keys = ['user', 'password', 'host', 'port', 'dbname', 'sslmode', 'sslcert', 'sslkey', 'sslrootcert',
+                      'connect_timeout', 'application_name', 'keepalives', 'keepalives_idle', 'keepalives_interval',
+                      'keepalives_count']
+        # Filter the config dictionary to include only the valid keys
+        return {key: config[key] for key in valid_keys if key in config}
+
+    def get_connection(self):
+        # print(self.config)
+        connection_type = self.connection_type
+
+        if connection_type == 'normal':
+            # Only connection_settings are needed for a normal connection
+            return PGNormalConnection(self.config)
+        elif connection_type == 'pool':
+            # Merge connection_settings with pool_settings
+            return PGPoolConnection(self.config, self.pool_settings)
+        elif connection_type == 'async':
+            # Merge connection_settings with async_settings
+            return PGAsyncConnection(self.config, post_connect_async_settings=self.async_settings)
+        elif connection_type == 'async_pool':
+            # Merge connection_settings with async_pool_settings
+            return PGAsyncPoolConnection(config=self.config, pool_settings=self.async_pool_settings)
+        else:
+            raise ValueError(f"Unsupported connection type: {connection_type}")

pgmonkey-0.0.1/src/pgmonkey/managers/pg_server_config_manager.py

@@ -0,0 +1,24 @@
+import yaml
+from pgmonkey.serversettings.postgres_server_config_generator import PostgresServerConfigGenerator
+
+class PGServerConfigManager:
+    def __init__(self):
+        pass
+
+    def get_server_config(self, config_file_path):
+        # Need to detect the database type from the config file.
+        with open(config_file_path, 'r') as f:
+            config_data_dictionary = yaml.safe_load(f)
+        database_type = next(iter(config_data_dictionary))
+
+        if database_type == 'postgresql':
+            #print("postgres detected")
+            self.get_postgres_server_config(config_file_path)
+        else:
+            raise ValueError(f"Unsupported database type: {database_type}")
+
+    def get_postgres_server_config(self, config_file_path):
+        postgresconfiggenerator = PostgresServerConfigGenerator(config_file_path)
+        postgresconfiggenerator.generate_pg_hba_entry()
+        postgresconfiggenerator.generate_pg_hba_entry()
+        postgresconfiggenerator.print_configurations()

pgmonkey-0.0.1/src/pgmonkey/managers/pgconfig_manager.py

@@ -0,0 +1,72 @@
+from pathlib import Path
+import yaml
+from importlib import resources
+from tests.database_integration_test import DatabaseIntegrationTest
+import asyncio
+from .settings_manager import SettingsManager
+from pgmonkey.common.utils.pathutils import PathUtils
+
+
+class PGConfigManager:
+    def __init__(self):
+        self.path_utils = PathUtils()
+        self.settings_manager = SettingsManager()
+        self.templates = {'pg': 'postgres.yaml'}
+
+    def load_template(self, template_filename):
+        """Load a YAML configuration template from a file within the package."""
+        with resources.files(f"{self.settings_manager.settings['appPackageName']}.common.templates").joinpath(
+                template_filename) as path, \
+                resources.as_file(path) as config_file, \
+                open(config_file, 'r') as file:
+            return yaml.safe_load(file)
+
+    def get_config_template(self, database_type):
+        """Retrieve the configuration template based on the database type."""
+        if database_type in self.templates:
+            return self.load_template(self.templates[database_type])
+        else:
+            raise ValueError(f'Unsupported database type. Supported types are: {", ".join(self.templates.keys())}')
+
+    def get_config_template_text(self, database_type):
+        """Retrieve the configuration template as raw text based on the database type."""
+        if database_type in self.templates:
+            template_filename = self.templates[database_type]
+            package_path = f"{self.settings_manager.settings['appPackageName']}.common.templates"
+            with resources.files(package_path).joinpath(template_filename) as path, \
+                    resources.as_file(path) as config_file:
+                with open(config_file, 'r') as file:
+                    return file.read()
+        else:
+            raise ValueError(f'Unsupported database type. Supported types are: {", ".join(self.templates.keys())}')
+
+    def write_config_template(self, file_path, config_data):
+        """Write the configuration template data to a file."""
+        file_path.parent.mkdir(parents=True, exist_ok=True)
+        with open(file_path, 'w') as f:
+            yaml.dump(config_data, f, sort_keys=False, default_flow_style=False, width=1000)
+        print(f'New configuration template created: {file_path}')
+
+    def write_config_template_text(self, file_path, config_text):
+        """Write the configuration template text to a file, preserving all formatting."""
+        file_path.parent.mkdir(parents=True, exist_ok=True)
+        with open(file_path, 'w') as f:
+            f.write(config_text)
+        print(f'New configuration template created: {file_path}')
+
+    def test_connection(self, config_file_path):
+        """Test database connection using a configuration file."""
+
+        # Step 1: Determine the database type.
+        with open(config_file_path, 'r') as config_file:
+            config_data = yaml.safe_load(config_file)
+        database_type = next(iter(config_data))
+        print(f"{database_type} database config file has been detected...")
+
+        # Step 2:
+        integration_tester = DatabaseIntegrationTest()
+
+        if database_type == 'postgresql':
+            asyncio.run(integration_tester.test_postgresql_connection(config_file_path))
+        else:
+            print(f"Unsupported database type: {database_type}")

pgmonkey-0.0.1/src/pgmonkey/managers/pgconnection_manager.py

@@ -0,0 +1,34 @@
+import yaml
+from pgmonkey.connections.postgres.postgres_connection_factory import PostgresConnectionFactory
+
+
+class PGConnectionManager:
+    def __init__(self):
+        pass
+
+    async def get_database_connection(self, config_file_path):
+        """Establish a database connection using a configuration file."""
+        with open(config_file_path, 'r') as f:
+            config_data_dictionary = yaml.safe_load(f)
+        database_type = next(iter(config_data_dictionary))
+
+        if database_type == 'postgresql':
+            return await self.get_postgresql_connection(config_data_dictionary)
+        else:
+            raise ValueError(f"Unsupported database type: {database_type}")
+
+    async def get_postgresql_connection(self, config_data_dictionary):
+        """Create and return PostgreSQL connection based on the configuration."""
+        factory = PostgresConnectionFactory(config_data_dictionary)
+        connection = factory.get_connection()
+        #print(connection.__dict__)
+
+        if config_data_dictionary['postgresql']['connection_type'] in ['normal', 'pool']:
+            connection.connect()
+            return connection
+        elif config_data_dictionary['postgresql']['connection_type'] in ['async', 'async_pool']:
+            await connection.connect()
+            #print(connection.__dict__)
+            return connection
+
+

pgmonkey-0.0.1/src/pgmonkey/managers/settings_manager.py

@@ -0,0 +1,22 @@
+import yaml
+from pathlib import Path
+
+
+class SettingsManager:
+    def __init__(self, settings_filename='app_settings.yaml'):
+        # Path to the default settings file, it's in the package structure.
+        self.settings_file = Path(__file__).resolve().parents[2] / 'settings' / settings_filename
+        # Load settings from the default settings file from package structure
+        self.settings = self.load_initial_settings()
+        # Use the package name from the settings
+        self.package_name = self.settings.get('appPackageName')
+
+    def load_initial_settings(self):
+        """Load initial settings from app_settings.yaml located in the same directory as this class."""
+        if not self.settings_file.exists():
+            raise FileNotFoundError(f"Could not find the settings file {self.settings_file}")
+        with open(self.settings_file, "r") as file:
+            return yaml.safe_load(file)
+
+    def print_hello_world(self):
+        print(f"{self.package_name} says \"Hello World\" - This is a place holder for the settings cli class.")

pgmonkey-0.0.1/src/pgmonkey/managers/toplevel_manager.py

@@ -0,0 +1,13 @@
+from importlib.metadata import version, PackageNotFoundError
+
+
+class ToplevelManager:
+    @staticmethod
+    def get_package_version(package_name: str) -> str:
+        """Fetch the package version using the package name."""
+        try:
+            return version(package_name)
+        except PackageNotFoundError:
+            return "Package version not found"
+
+    # You can add more top-level management methods here

pgmonkey-0.0.1/src/pgmonkey/serversettings/postgres_server_config_generator.py

@@ -0,0 +1,103 @@
+import yaml
+
+class PostgresServerConfigGenerator:
+    def __init__(self, yaml_file_path):
+        self.yaml_file_path = yaml_file_path
+        self.config = self.read_yaml()  # Read the configuration file upon instantiation
+
+    def read_yaml(self):
+        """Reads the YAML configuration file."""
+        try:
+            with open(self.yaml_file_path, 'r') as file:
+                return yaml.safe_load(file)
+        except FileNotFoundError:
+            print(f"Error: File not found - {self.yaml_file_path}")
+        except yaml.YAMLError as e:
+            print(f"Error reading YAML file: {e}")
+        except Exception as e:
+            print(f"An error occurred: {e}")
+
+    def generate_pg_hba_entry(self):
+        """Generates entries for pg_hba.conf based on the SSL settings, with headers for each column."""
+        host = self.config['postgresql']['connection_settings']['host']
+        sslmode = self.config['postgresql']['connection_settings'].get('sslmode', 'prefer')
+        entries = []
+        header = "TYPE  DATABASE  USER  ADDRESS          METHOD  OPTIONS"
+        entries.append(header)
+        if sslmode in ['verify-ca', 'verify-full']:
+            clientcert = 'verify-full' if sslmode == 'verify-full' else 'verify-ca'
+            ip_subnet = '.'.join(host.split('.')[:-1]) + '.0/24'  # Assuming a /24 subnet
+            entry = f"hostssl all     all   {ip_subnet}    md5     clientcert={clientcert}"
+            entries.append(entry)
+        elif sslmode != 'disable':
+            ip_subnet = '.'.join(host.split('.')[:-1]) + '.0/24'  # Assuming a /24 subnet
+            entry = f"host    all     all   {ip_subnet}    reject"
+            entries.append(entry)
+        return entries
+
+    def generate_postgresql_conf(self):
+        """Generates minimal entries for postgresql.conf to ensure compatibility based on connection pooling settings."""
+        settings = []
+        connection_type = self.config['postgresql']['connection_type']
+        if connection_type in ['pool', 'async_pool']:
+            pool_settings = self.config['postgresql'].get('pool_settings', {})
+            max_size = pool_settings.get('max_size', 100)
+            max_connections = int(max_size * 1.1)
+            settings.append(f"max_connections = {max_connections}")
+        else:
+            settings.append("max_connections = 20")
+
+        # Generate SSL settings
+        settings.extend(self.generate_ssl_settings())
+        return settings
+
+    def generate_ssl_settings(self):
+        """Generates SSL configuration entries for postgresql.conf based on client settings."""
+        ssl_settings = []
+        if 'sslmode' in self.config['postgresql']['connection_settings'] and self.config['postgresql']['connection_settings']['sslmode'] != 'disable':
+            ssl_settings.append("ssl = on")
+            ssl_settings.append(f"ssl_cert_file = 'server.crt'")
+            ssl_settings.append(f"ssl_key_file = 'server.key'")
+            ssl_settings.append(f"ssl_ca_file = 'ca.crt'")
+        return ssl_settings
+
+    def print_configurations(self):
+        """Prints the generated server configurations and provides final instructions if configurations are suggested."""
+        if self.config:
+            pg_hba_entries = self.generate_pg_hba_entry()
+            postgresql_conf_entries = self.generate_postgresql_conf()
+            print("1) Database type detected: PostgreSQL\n")
+            print("2) Minimal database server settings needed for this config file:\n")
+
+            # Print pg_hba.conf configurations if they exist
+            if len(pg_hba_entries) > 1:  # More than just the header
+                print("   a) pg_hba.conf:" + "\n")
+                print('\n'.join(pg_hba_entries) + "\n")
+            else:
+                print("   a) No entries needed for pg_hba.conf.\n")
+
+            # Print postgresql.conf configurations if they exist
+            if postgresql_conf_entries:
+                print("   b) postgresql.conf:" + "\n")
+                print('\n'.join(postgresql_conf_entries))
+            else:
+                print("   b) No entries needed for postgresql.conf.\n")
+
+            # Add a newline before final instructions
+            print()  # This adds the desired newline
+
+            # Determine which configuration files had suggestions and list them appropriately
+            files_to_check = []
+            if len(pg_hba_entries) > 1:
+                files_to_check.append("pg_hba.conf")
+            if postgresql_conf_entries:
+                files_to_check.append("postgresql.conf")
+
+            if files_to_check:
+                print(f"Please check the following files on your system and ensure that the appropriate settings are applied: {', '.join(files_to_check)}.")
+                print("Ensure that the network ADDRESS matches your network subnet and review all configurations.")
+        else:
+            print("Configuration data is not available. Please check the file path and contents.")
+
+
+

pgmonkey-0.0.1/src/pgmonkey.egg-info/PKG-INFO

@@ -0,0 +1,42 @@
+Metadata-Version: 2.1
+Name: pgmonkey
+Version: 0.0.1
+Summary: A tool to assist with postgresql database connections
+Author-email: Good Boy <pythonic@rexbytes.com>
+License: MIT License
+        
+        Copyright (c) 2024 RexBytes
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+        
+Project-URL: Homepage, https://github.com/RexBytes/pgmonkey
+Project-URL: Bug Tracker, https://github.com/RexBytes/pgmonkey
+Classifier: Programming Language :: Python :: 3.12
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Database
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: psycopg[binary]>=3.2.1
+Requires-Dist: psycopg_pool>=3.2.2
+Requires-Dist: PyYAML>=6.0.2
+
+# pgmonkey

pgmonkey-0.0.1/src/pgmonkey.egg-info/SOURCES.txt

@@ -0,0 +1,38 @@
+LICENSE
+README.md
+pyproject.toml
+src/cli/__init__.py
+src/cli/cli.py
+src/cli/cli_pg_server_config_subparser.py
+src/cli/cli_pgconfig_subparser.py
+src/cli/cli_settings_subparser.py
+src/cli/cli_toplevel_parser.py
+src/pgmonkey/__init__.py
+src/pgmonkey.egg-info/PKG-INFO
+src/pgmonkey.egg-info/SOURCES.txt
+src/pgmonkey.egg-info/dependency_links.txt
+src/pgmonkey.egg-info/entry_points.txt
+src/pgmonkey.egg-info/requires.txt
+src/pgmonkey.egg-info/top_level.txt
+src/pgmonkey/common/__init__.py
+src/pgmonkey/common/config/__init__.py
+src/pgmonkey/common/utils/__init__.py
+src/pgmonkey/common/utils/pathutils.py
+src/pgmonkey/connections/__init__.py
+src/pgmonkey/connections/base.py
+src/pgmonkey/connections/postgres/__init__.py
+src/pgmonkey/connections/postgres/async_connection.py
+src/pgmonkey/connections/postgres/async_pool_connection.py
+src/pgmonkey/connections/postgres/base_connection.py
+src/pgmonkey/connections/postgres/normal_connection.py
+src/pgmonkey/connections/postgres/pool_connection.py
+src/pgmonkey/connections/postgres/postgres_connection_factory.py
+src/pgmonkey/managers/__init__.py
+src/pgmonkey/managers/pg_server_config_manager.py
+src/pgmonkey/managers/pgconfig_manager.py
+src/pgmonkey/managers/pgconnection_manager.py
+src/pgmonkey/managers/settings_manager.py
+src/pgmonkey/managers/toplevel_manager.py
+src/pgmonkey/serversettings/postgres_server_config_generator.py
+src/tests/__init__.py
+src/tests/database_integration_test.py

pgmonkey-0.0.1/src/pgmonkey.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

pgmonkey-0.0.1/src/pgmonkey.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+pgmonkey = cli.cli:main

pgmonkey-0.0.1/src/pgmonkey.egg-info/requires.txt

@@ -0,0 +1,3 @@
+psycopg[binary]>=3.2.1
+psycopg_pool>=3.2.2
+PyYAML>=6.0.2

pgmonkey-0.0.1/src/pgmonkey.egg-info/top_level.txt

@@ -0,0 +1,4 @@
+cli
+pgmonkey
+settings
+tests

pgmonkey-0.0.1/src/tests/database_integration_test.py

@@ -0,0 +1,26 @@
+from pgmonkey.managers.pgconnection_manager import PGConnectionManager
+import yaml
+
+
+class DatabaseIntegrationTest:
+    def __init__(self):
+        self.pgconnection_manager = PGConnectionManager()
+
+    async def test_postgresql_connection(self, config_file_path):
+        try:
+            # Retrieve the database connection; assume it's already prepared to be used as an async context manager
+            connection = await self.pgconnection_manager.get_database_connection(config_file_path)
+
+            # Read the configuration file to determine the connection type
+            with open(config_file_path, 'r') as config_file:
+                config = yaml.safe_load(config_file)
+
+            if config['postgresql']['connection_type'] in ['normal', 'pool']:
+                with connection as sync_connection:
+                    sync_connection.test_connection()
+            elif config['postgresql']['connection_type'] in ['async', 'async_pool']:
+                async with connection as async_connection:
+                    await async_connection.test_connection()
+
+        except Exception as e:
+            print(f"An error occurred while testing the connection: {e}")