pgmonkey 3.2.0__tar.gz → 3.3.0__tar.gz

{pgmonkey-3.2.0/src/pgmonkey.egg-info → pgmonkey-3.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pgmonkey
-Version: 3.2.0
+Version: 3.3.0
 Summary: A tool to assist with postgresql database connections
 Author-email: Good Boy <pythonic@rexbytes.com>
 License: MIT

{pgmonkey-3.2.0 → pgmonkey-3.3.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "pgmonkey"
-version = "3.2.0"
+version = "3.3.0"
 authors = [
   { name="Good Boy", email="pythonic@rexbytes.com" },
 ]

{pgmonkey-3.2.0 → pgmonkey-3.3.0}/src/pgmonkey/managers/pgexport_manager.py

@@ -1,4 +1,3 @@
-import asyncio
 from pgmonkey.tools.csv_data_exporter import CSVDataExporter
 from pathlib import Path
 
@@ -22,5 +21,5 @@ class PGExportManager:
         exporter = CSVDataExporter(str(connection_config), table_name, str(csv_file), str(export_config_file))
 
         # Run the export process
-        asyncio.run(exporter.run())
+        exporter.run()
 

{pgmonkey-3.2.0 → pgmonkey-3.3.0}/src/pgmonkey/managers/pgimport_manager.py

@@ -1,4 +1,3 @@
-import asyncio
 from pgmonkey.tools.csv_data_importer import CSVDataImporter
 from pathlib import Path
 
@@ -19,4 +18,4 @@ class PGImportManager:
         importer = CSVDataImporter(str(connection_config), str(csv_file), table_name, str(import_config_file))
 
         # Run the import process
-        asyncio.run(importer.run())
+        importer.run()

{pgmonkey-3.2.0 → pgmonkey-3.3.0}/src/pgmonkey/tests/unit/test_csv_data_exporter.py

@@ -130,3 +130,12 @@ class TestResolveConnectionType:
 
     def test_async_pool_type_becomes_normal(self):
         assert CSVDataExporter._resolve_export_connection_type({'connection_type': 'async_pool'}) == 'normal'
+
+
+class TestRunIsSync:
+    """run() should be a regular sync method, not async."""
+
+    def test_run_is_not_coroutine(self):
+        """run() should not be a coroutine function."""
+        import inspect
+        assert not inspect.iscoroutinefunction(CSVDataExporter.run)

{pgmonkey-3.2.0 → pgmonkey-3.3.0}/src/pgmonkey/tests/unit/test_csv_data_importer.py

@@ -191,3 +191,121 @@ class TestResolveConnectionType:
 
     def test_async_pool_type_becomes_normal(self):
         assert CSVDataImporter._resolve_import_connection_type({'connection_type': 'async_pool'}) == 'normal'
+
+
+class _PastSamplingPhase(Exception):
+    """Sentinel exception to prove we got past phase 1 sampling."""
+
+
+class TestSmallFileSampling:
+    """Phase 1 sampling must not crash on CSV files with fewer than 5 rows."""
+
+    def _make_importer(self, tmp_path, csv_content):
+        csv_file = tmp_path / "data.csv"
+        csv_file.write_text(csv_content)
+        config_file = tmp_path / "data.yaml"
+        config_file.write_text(yaml.dump({
+            'has_headers': True, 'auto_create_table': True,
+            'enforce_lowercase': True, 'delimiter': ',',
+            'quotechar': '"', 'encoding': 'utf-8',
+        }))
+        return CSVDataImporter(
+            str(tmp_path / "conn.yaml"), str(csv_file),
+            "mytable", str(config_file),
+        )
+
+    @patch('pgmonkey.tools.csv_data_importer.CSVDataImporter._check_table_exists_sync',
+           side_effect=_PastSamplingPhase("reached table check"))
+    def test_single_row_csv_does_not_crash(self, mock_check, tmp_path):
+        """A CSV with only a header row (1 line) must not raise StopIteration."""
+        importer = self._make_importer(tmp_path, "col1,col2\n")
+        mock_conn = MagicMock()
+        mock_cursor = MagicMock()
+        mock_cursor.__enter__ = MagicMock(return_value=mock_cursor)
+        mock_cursor.__exit__ = MagicMock(return_value=False)
+        mock_conn.cursor.return_value = mock_cursor
+        # If we get _PastSamplingPhase, sampling succeeded. StopIteration = bug.
+        with pytest.raises(_PastSamplingPhase):
+            importer._sync_ingest(mock_conn)
+
+    @patch('pgmonkey.tools.csv_data_importer.CSVDataImporter._check_table_exists_sync',
+           side_effect=_PastSamplingPhase("reached table check"))
+    def test_two_row_csv_does_not_crash(self, mock_check, tmp_path):
+        """A CSV with a header and one data row (2 lines) must not crash."""
+        importer = self._make_importer(tmp_path, "col1,col2\na,b\n")
+        mock_conn = MagicMock()
+        mock_cursor = MagicMock()
+        mock_cursor.__enter__ = MagicMock(return_value=mock_cursor)
+        mock_cursor.__exit__ = MagicMock(return_value=False)
+        mock_conn.cursor.return_value = mock_cursor
+        with pytest.raises(_PastSamplingPhase):
+            importer._sync_ingest(mock_conn)
+
+    @patch('pgmonkey.tools.csv_data_importer.CSVDataImporter._check_table_exists_sync',
+           side_effect=_PastSamplingPhase("reached table check"))
+    def test_three_row_csv_does_not_crash(self, mock_check, tmp_path):
+        """A CSV with 3 lines must not crash in phase 1 sampling."""
+        importer = self._make_importer(tmp_path, "col1,col2\na,b\nc,d\n")
+        mock_conn = MagicMock()
+        mock_cursor = MagicMock()
+        mock_cursor.__enter__ = MagicMock(return_value=mock_cursor)
+        mock_cursor.__exit__ = MagicMock(return_value=False)
+        mock_conn.cursor.return_value = mock_cursor
+        with pytest.raises(_PastSamplingPhase):
+            importer._sync_ingest(mock_conn)
+
+
+class TestAutoCreateTable:
+    """auto_create_table=False should prevent table creation and raise ValueError."""
+
+    def _make_importer(self, tmp_path, auto_create=True):
+        csv_file = tmp_path / "data.csv"
+        csv_file.write_text("col1,col2\na,b\n")
+        config_file = tmp_path / "data.yaml"
+        config_file.write_text(yaml.dump({
+            'has_headers': True, 'auto_create_table': auto_create,
+            'enforce_lowercase': True, 'delimiter': ',',
+            'quotechar': '"', 'encoding': 'utf-8',
+        }))
+        return CSVDataImporter(
+            str(tmp_path / "conn.yaml"), str(csv_file),
+            "mytable", str(config_file),
+        )
+
+    @patch('pgmonkey.tools.csv_data_importer.CSVDataImporter._check_table_exists_sync', return_value=False)
+    def test_auto_create_disabled_raises_when_table_missing(self, mock_check, tmp_path):
+        """When auto_create_table is False and table doesn't exist, should raise ValueError."""
+        importer = self._make_importer(tmp_path, auto_create=False)
+        mock_conn = MagicMock()
+        mock_cursor = MagicMock()
+        mock_cursor.__enter__ = MagicMock(return_value=mock_cursor)
+        mock_cursor.__exit__ = MagicMock(return_value=False)
+        mock_conn.cursor.return_value = mock_cursor
+
+        with pytest.raises(ValueError, match="auto_create_table is disabled"):
+            importer._sync_ingest(mock_conn)
+
+    @patch('pgmonkey.tools.csv_data_importer.CSVDataImporter._create_table_sync',
+           side_effect=_PastSamplingPhase("table created"))
+    @patch('pgmonkey.tools.csv_data_importer.CSVDataImporter._check_table_exists_sync', return_value=False)
+    def test_auto_create_enabled_creates_table(self, mock_check, mock_create, tmp_path):
+        """When auto_create_table is True and table doesn't exist, should call _create_table_sync."""
+        importer = self._make_importer(tmp_path, auto_create=True)
+        mock_conn = MagicMock()
+        mock_cursor = MagicMock()
+        mock_cursor.__enter__ = MagicMock(return_value=mock_cursor)
+        mock_cursor.__exit__ = MagicMock(return_value=False)
+        mock_conn.cursor.return_value = mock_cursor
+
+        with pytest.raises(_PastSamplingPhase):
+            importer._sync_ingest(mock_conn)
+        mock_create.assert_called_once()
+
+
+class TestRunIsSync:
+    """run() should be a regular sync method, not async."""
+
+    def test_run_is_not_coroutine(self):
+        """run() should not be a coroutine function."""
+        import inspect
+        assert not inspect.iscoroutinefunction(CSVDataImporter.run)

{pgmonkey-3.2.0 → pgmonkey-3.3.0}/src/pgmonkey/tools/csv_data_exporter.py

@@ -179,7 +179,7 @@ class CSVDataExporter:
                 # Restore the original client encoding
                 self._restore_client_encoding(cur, original_encoding)
 
-    async def run(self):
+    def run(self):
         """Main method to start the export using a normal sync connection for best COPY TO performance."""
         with open(self.config_file, 'r') as f:
             connection_config = yaml.safe_load(f)

{pgmonkey-3.2.0 → pgmonkey-3.3.0}/src/pgmonkey/tools/csv_data_importer.py

@@ -249,7 +249,9 @@ class CSVDataImporter:
         with connection.cursor() as cur:
             # Phase 1: Detect column structure from a small sample
             with open(self.csv_file, 'r', encoding=self.encoding, newline='') as file:
-                sample_rows = [next(file).strip() for _ in range(5)]  # Read first 5 rows
+                sample_rows = []
+                for _, line in zip(range(5), file):
+                    sample_rows.append(line.strip())
                 sample_splits = [row.split(self.delimiter) for row in sample_rows]
                 column_counts = [len(split) for split in sample_splits if any(split)]  # Ignore empty lines
 
@@ -312,6 +314,11 @@ class CSVDataImporter:
             print(f"\nStarting import for file: {self.csv_file} into table: {self.schema_name}.{self.table_name}")
 
             if not self._check_table_exists_sync(connection):
+                if not self.auto_create_table:
+                    raise ValueError(
+                        f"Table {self.schema_name}.{self.table_name} does not exist and "
+                        "auto_create_table is disabled in the import configuration."
+                    )
                 self._create_table_sync(connection, formatted_headers)
                 print(f"\nTable {self.schema_name}.{self.table_name} created successfully.")
             else:
@@ -389,7 +396,7 @@ class CSVDataImporter:
             )
             return cur.fetchone()[0]
 
-    async def run(self):
+    def run(self):
         """Main method to start the ingestion using a normal sync connection for best COPY performance."""
         with open(self.config_file, 'r') as f:
             connection_config = yaml.safe_load(f)

{pgmonkey-3.2.0 → pgmonkey-3.3.0/src/pgmonkey.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pgmonkey
-Version: 3.2.0
+Version: 3.3.0
 Summary: A tool to assist with postgresql database connections
 Author-email: Good Boy <pythonic@rexbytes.com>
 License: MIT