neo4j-etl-lib 0.1.1__py3-none-any.whl → 0.2.0__py3-none-any.whl

etl_lib/__init__.py

@@ -1,4 +1,4 @@
 """
 Building blocks for ETL pipelines.
 """
-__version__ = "0.1.1"
+__version__ = "0.2.0"

etl_lib/cli/run_tools.py

@@ -67,7 +67,7 @@ def __driver(ctx):
 @click.pass_context
 def cli(ctx, neo4j_uri, neo4j_user, neo4j_password, log_file, database_name):
     """
-        Command-line tool to process files in INPUT_DIRECTORY.
+        Command-line tool for ETL pipelines.
 
         Environment variables can be configured via a .env file or overridden via CLI options:
 

etl_lib/core/ClosedLoopBatchProcessor.py

@@ -1,7 +1,7 @@
 from typing import Generator
 
-from etl_lib.core.ETLContext import ETLContext
 from etl_lib.core.BatchProcessor import BatchProcessor, BatchResults, append_result
+from etl_lib.core.ETLContext import ETLContext
 from etl_lib.core.Task import Task
 
 
@@ -24,7 +24,13 @@ class ClosedLoopBatchProcessor(BatchProcessor):
         for batch in self.predecessor.get_batch(max_batch__size):
             result = append_result(result, batch.statistics)
             batch_cnt += 1
-            self.context.reporter.report_progress(self.task, batch_cnt, self.expected_rows, result.statistics)
+            self.context.reporter.report_progress(self.task, batch_cnt, self._safe_calculate_count(max_batch__size),
+                                                  result.statistics)
 
         self.logger.debug(result.statistics)
         yield result
+
+    def _safe_calculate_count(self, batch_size: int | None) -> int:
+        if not self.expected_rows or not batch_size:
+            return 0
+        return (self.expected_rows + batch_size - 1) // batch_size  # ceiling division

etl_lib/core/ETLContext.py

@@ -1,9 +1,26 @@
 import logging
 from typing import NamedTuple, Any
 
-from graphdatascience import GraphDataScience
+try:
+    from graphdatascience import GraphDataScience
+    gds_available = False
+except ImportError:
+    gds_available = False
+    logging.info("Graph Data Science not installed, skipping")
+    GraphDataScience = None
+
 from neo4j import GraphDatabase, WRITE_ACCESS, SummaryCounters
 
+try:
+    from sqlalchemy import create_engine
+    from sqlalchemy.engine import Engine
+    sqlalchemy_available = True
+except ImportError:
+    sqlalchemy_available = False
+    logging.info("SQL Alchemy not installed, skipping")
+    create_engine = None  # this and next line needed to prevent PyCharm warning
+    Engine = None
+
 from etl_lib.core.ProgressReporter import get_reporter
 
 
@@ -99,22 +116,6 @@ class Neo4jContext:
         else:
             return self.driver.session(database=database, default_access_mode=WRITE_ACCESS)
 
-    def gds(self, database=None) -> GraphDataScience:
-        """
-        Creates a new GraphDataScience client.
-
-        Args:
-            database: Name of the database to use for this dgs client.
-                If not provided, the database name provided during construction will be used.
-
-        Returns:
-            gds client.
-        """
-        if database is None:
-            return GraphDataScience.from_neo4j_driver(driver=self.driver, database=self.database)
-        else:
-            return GraphDataScience.from_neo4j_driver(driver=self.driver, database=database)
-
     def __neo4j_connect(self):
         self.driver = GraphDatabase.driver(uri=self.uri, auth=self.auth,
                                            notifications_min_severity="OFF")
@@ -122,6 +123,32 @@ class Neo4jContext:
         self.logger.info(
             f"driver connected to instance at {self.uri} with username {self.auth[0]} and database {self.database}")
 
+def gds(neo4j_context) -> GraphDataScience:
+    """
+    Creates a new GraphDataScience client.
+
+    Args:
+        neo4j_context: Neo4j context containing driver and database name.
+
+    Returns:
+        gds client.
+    """
+    return GraphDataScience.from_neo4j_driver(driver=neo4j_context.driver, database=neo4j_context.database)
+
+
+if sqlalchemy_available:
+    class SQLContext:
+        def __init__(self, database_url: str, pool_size: int = 10, max_overflow: int = 20):
+            """
+            Initializes the SQL context with an SQLAlchemy engine.
+
+            Args:
+                database_url (str): SQLAlchemy connection URL.
+                pool_size (int): Number of connections to maintain in the pool.
+                max_overflow (int): Additional connections allowed beyond pool_size.
+            """
+            self.engine: Engine = create_engine(database_url, pool_size=pool_size, max_overflow=max_overflow)
+
 
 class ETLContext:
     """
@@ -145,6 +172,11 @@ class ETLContext:
         self.neo4j = Neo4jContext(env_vars)
         self.__env_vars = env_vars
         self.reporter = get_reporter(self)
+        sql_uri = self.env("SQLALCHEMY_URI")
+        if sql_uri is not None and sqlalchemy_available:
+            self.sql = SQLContext(sql_uri)
+        if gds_available:
+            self.gds =gds(self.neo4j)
 
     def env(self, key: str) -> Any:
         """
@@ -154,7 +186,7 @@ class ETLContext:
             key: name of the entry to read.
 
         Returns:
-            va  lue of the entry, or None if the key is not in the dict.
+            value of the entry, or None if the key is not in the dict.
         """
         if key in self.__env_vars:
             return self.__env_vars[key]

etl_lib/core/ProgressReporter.py

@@ -64,7 +64,7 @@ class ProgressReporter:
         task.success = result.success
         task.summery = result.summery
 
-        report = f"{'\t' * task.depth} finished {task.task_name()} in {task.end_time - task.start_time} with success: {result.success}"
+        report = f"finished {task.task_name()} in {task.end_time - task.start_time} with status: {'success' if result.success else 'failed'}"
         if result.error is not None:
             report += f", error: \n{result.error}"
         else:
@@ -85,7 +85,7 @@ class ProgressReporter:
             task: Task reporting updates.
             batches: Number of batches processed so far.
             expected_batches: Number of expected batches. Can be `None` if the overall number of
-                batches is not know before execution.
+                batches is not known before execution.
             stats: dict of statistics so far (such as `nodes_created`).
         """
         pass

etl_lib/data_sink/CypherBatchSink.py

@@ -10,7 +10,7 @@ class CypherBatchSink(BatchProcessor):
     BatchProcessor to write batches of data to a Neo4j database.
     """
 
-    def __init__(self, context: ETLContext, task: Task, predecessor: BatchProcessor, query: str):
+    def __init__(self, context: ETLContext, task: Task, predecessor: BatchProcessor, query: str, **kwargs):
         """
         Constructs a new CypherBatchSink.
 
@@ -20,16 +20,17 @@ class CypherBatchSink(BatchProcessor):
             predecessor: BatchProcessor which :func:`~get_batch` function will be called to receive batches to process.
             query: Cypher to write the query to Neo4j.
                 Data will be passed as `batch` parameter.
-                Therefor, the query should start with a `UNWIND $batch AS row`.
+                Therefore, the query should start with a `UNWIND $batch AS row`.
         """
         super().__init__(context, task, predecessor)
         self.query = query
         self.neo4j = context.neo4j
+        self.kwargs = kwargs
 
     def get_batch(self, batch_size: int) -> Generator[BatchResults, None, None]:
         assert self.predecessor is not None
 
         with self.neo4j.session() as session:
             for batch_result in self.predecessor.get_batch(batch_size):
-                result = self.neo4j.query_database(session=session, query=self.query, batch=batch_result.chunk)
+                result = self.neo4j.query_database(session=session, query=self.query, batch=batch_result.chunk, **self.kwargs)
                 yield append_result(batch_result, result.summery)

etl_lib/data_sink/SQLBatchSink.py

@@ -0,0 +1,36 @@
+from typing import Generator
+from sqlalchemy import text
+from etl_lib.core.ETLContext import ETLContext
+from etl_lib.core.BatchProcessor import BatchProcessor, BatchResults, append_result
+from etl_lib.core.Task import Task
+
+
+class SQLBatchSink(BatchProcessor):
+    """
+    BatchProcessor to write batches of data to an SQL database.
+    """
+
+    def __init__(self, context: ETLContext, task: Task, predecessor: BatchProcessor, query: str):
+        """
+        Constructs a new SQLBatchSink.
+
+        Args:
+            context: ETLContext instance.
+            task: Task instance owning this batchProcessor.
+            predecessor: BatchProcessor which `get_batch` function will be called to receive batches to process.
+            query: SQL query to write data.
+                Data will be passed as a batch using parameterized statements (`:param_name` syntax).
+        """
+        super().__init__(context, task, predecessor)
+        self.query = query
+        self.engine = context.sql.engine
+
+    def get_batch(self, batch_size: int) -> Generator[BatchResults, None, None]:
+        assert self.predecessor is not None
+
+        with self.engine.connect() as conn:
+            with conn.begin():
+                for batch_result in self.predecessor.get_batch(batch_size):
+                    conn.execute(text(self.query), batch_result.chunk)
+                    yield append_result(batch_result, {"sql_rows_written": len(batch_result.chunk)})
+

etl_lib/data_source/SQLBatchSource.py

@@ -0,0 +1,60 @@
+from typing import Generator, Callable, Optional
+from sqlalchemy import text
+from etl_lib.core.BatchProcessor import BatchResults, BatchProcessor
+from etl_lib.core.ETLContext import ETLContext
+from etl_lib.core.Task import Task
+
+
+class SQLBatchSource(BatchProcessor):
+    def __init__(
+            self,
+            context: ETLContext,
+            task: Task,
+            query: str,
+            record_transformer: Optional[Callable[[dict], dict]] = None,
+            **kwargs
+    ):
+        """
+        Constructs a new SQLBatchSource.
+
+        Args:
+            context: :class:`etl_lib.core.ETLContext.ETLContext` instance.
+            task: :class:`etl_lib.core.Task.Task` instance owning this batchProcessor.
+            query: SQL query to execute.
+            record_transformer: Optional function to transform each row (dict format).
+            kwargs: Arguments passed as parameters with the query.
+        """
+        super().__init__(context, task)
+        self.query = query
+        self.record_transformer = record_transformer
+        self.kwargs = kwargs  # Query parameters
+
+    def __read_records(self, conn, batch_size: int):
+        batch_ = []
+        result = conn.execute(text(self.query), self.kwargs)  # Safe execution with bound parameters
+
+        for row in result.mappings():  # Returns row as dict (like Neo4j's `record.data()`)
+            data = dict(row)  # Convert to dictionary
+            if self.record_transformer:
+                data = self.record_transformer(data)
+            batch_.append(data)
+
+            if len(batch_) == batch_size:
+                yield batch_
+                batch_ = []  # Reset batch
+
+        if batch_:
+            yield batch_
+
+    def get_batch(self, max_batch_size: int) -> Generator[BatchResults, None, None]:
+        """
+        Fetches data in batches using an open transaction, similar to Neo4j's approach.
+        """
+        with self.context.sql.engine.connect() as conn:  # Keep transaction open
+            with conn.begin():  # Ensures rollback on failure
+                for chunk in self.__read_records(conn, max_batch_size):
+                    yield BatchResults(
+                        chunk=chunk,
+                        statistics={"sql_rows_read": len(chunk)},
+                        batch_size=len(chunk)
+                    )

etl_lib/task/CreateReportingConstraintsTask.py

@@ -4,8 +4,8 @@ from etl_lib.core.Task import Task, TaskReturn
 class CreateReportingConstraintsTask(Task):
     """Creates the constraint in the REPORTER_DATABASE database."""
 
-    def __init__(self, config):
-        super().__init__(config)
+    def __init__(self, context):
+        super().__init__(context)
 
     def run_internal(self, **kwargs) -> TaskReturn:
         database = self.context.env("REPORTER_DATABASE")

etl_lib/task/data_loading/CSVLoad2Neo4jTask.py

@@ -14,19 +14,55 @@ from etl_lib.data_source.CSVBatchSource import CSVBatchSource
 
 
 class CSVLoad2Neo4jTask(Task):
-    """
+    '''
     Loads the specified CSV file to Neo4j.
 
     Uses BatchProcessors to read, validate and write to Neo4j.
     The validation step is using pydantic, hence a Pydantic model needs to be provided.
-    Rows that fail the validation, will be written to en error file. The location of the error file is determined as
+    Rows with fail validation will be written to en error file. The location of the error file is determined as
     follows:
 
-    If the context env vars hold an entry `ETL_ERROR_PATH` the file will be place there, with the name set to name
+    If the context env vars hold an entry `ETL_ERROR_PATH` the file will be placed there, with the name set to name
     of the provided filename appended with `.error.json`
 
-    If  `ETL_ERROR_PATH` is not set, the file will be placed in the same directory as the CSV file.
-    """
+    If `ETL_ERROR_PATH` is not set, the file will be placed in the same directory as the CSV file.
+
+    Example usage: (from the gtfs demo)
+
+    .. code-block:: python
+
+        class LoadStopsTask(CSVLoad2Neo4jTask):
+            class Stop(BaseModel):
+                id: str = Field(alias="stop_id")
+                name: str = Field(alias="stop_name")
+                latitude: float = Field(alias="stop_lat")
+                longitude: float = Field(alias="stop_lon")
+                platform_code: Optional[str] = None
+                parent_station: Optional[str] = None
+                type: Optional[str] = Field(alias="location_type", default=None)
+                timezone: Optional[str] = Field(alias="stop_timezone", default=None)
+                code: Optional[str] = Field(alias="stop_code", default=None)
+
+            def __init__(self, context: ETLContext, file: Path):
+                super().__init__(context, LoadStopsTask.Stop, file)
+
+            def task_name(self) -> str:
+                return f"{self.__class__.__name__}('{self.file}')"
+
+            def _query(self):
+                return """
+                       UNWIND $batch AS row
+                       MERGE (s:Stop {id: row.id})
+                         SET s.name = row.name,
+                             s.location= point({latitude: row.latitude, longitude: row.longitude}),
+                             s.platformCode= row.platform_code,
+                             s.parentStation= row.parent_station,
+                             s.type= row.type,
+                             s.timezone= row.timezone,
+                             s.code= row.code
+                      """
+
+    '''
     def __init__(self, context: ETLContext, model: Type[BaseModel], file: Path, batch_size: int = 5000):
         super().__init__(context)
         self.batch_size = batch_size

etl_lib/task/data_loading/SQLLoad2Neo4jTask.py

@@ -0,0 +1,90 @@
+from abc import abstractmethod
+
+from sqlalchemy import text
+
+from etl_lib.core import ETLContext
+from etl_lib.core.ClosedLoopBatchProcessor import ClosedLoopBatchProcessor
+from etl_lib.core.Task import Task, TaskReturn
+from etl_lib.data_sink.CypherBatchSink import CypherBatchSink
+from etl_lib.data_source.SQLBatchSource import SQLBatchSource
+
+
+class SQLLoad2Neo4jTask(Task):
+    '''
+    Load the output of the specified SQL query to Neo4j.
+
+    Uses BatchProcessors to read and write data.
+    Subclasses must implement the methods returning the SQL and Cypher queries.
+
+    Example usage: (from the MusicBrainz example)
+
+    .. code-block:: python
+
+
+        class LoadArtistCreditTask(SQLLoad2Neo4jTask):
+            def _sql_query(self) -> str:
+                return """
+                    SELECT ac.id AS artist_credit_id, ac.name AS credit_name
+                    FROM artist_credit ac;
+                    """
+
+            def _cypher_query(self) -> str:
+                return """
+                       UNWIND $batch AS row
+                       MERGE (ac:ArtistCredit {id: row.artist_credit_id})
+                       SET ac.name = row.credit_name
+                      """
+
+            def _count_query(self) -> str | None:
+                return "SELECT COUNT(*) FROM artist_credit;"
+
+    '''
+
+    def __init__(self, context: ETLContext, batch_size: int = 5000):
+        super().__init__(context)
+        self.context = context
+        self.batch_size = batch_size
+
+    @abstractmethod
+    def _sql_query(self) -> str:
+        """
+        Return the SQL query to load the source data.
+        """
+        pass
+
+    @abstractmethod
+    def _cypher_query(self) -> str:
+        """
+        Return the Cypher query to write the data in batches to Neo4j.
+        """
+        pass
+
+    def _count_query(self) -> str | None:
+        """
+        Return the SQL query to count the number of rows returned from :func:`_sql_query`.
+
+        Optional. If provided, it will run once at the beginning of the task and
+        provide the :class:`etl_lib.core.ClosedLoopBatchProcessor` with the total number of rows.
+        """
+        return None
+
+    def run_internal(self) -> TaskReturn:
+        total_count = self.__get_source_count()
+        source = SQLBatchSource(self.context, self, self._sql_query())
+        sink = CypherBatchSink(self.context, self, source, self._cypher_query())
+
+        end = ClosedLoopBatchProcessor(self.context, self, sink, total_count)
+
+        result = next(end.get_batch(self.batch_size))
+        return TaskReturn(True, result.statistics)
+
+    def __get_source_count(self):
+        count_query = self._count_query()
+        if count_query is None:
+            return None
+
+        with self.context.sql.engine.connect() as conn:
+            with conn.begin():
+                result = conn.execute(text(count_query))
+                row = result.fetchone()
+                return row[0] if row else None

etl_lib/test_utils/utils.py

@@ -7,7 +7,7 @@ from _pytest.tmpdir import tmp_path
 from neo4j import Driver
 from neo4j.time import Date
 
-from etl_lib.core.ETLContext import QueryResult, Neo4jContext, ETLContext
+from etl_lib.core.ETLContext import QueryResult, Neo4jContext, ETLContext, SQLContext, gds
 from etl_lib.core.Task import Task
 
 
@@ -102,6 +102,7 @@ class TestNeo4jContext(Neo4jContext):
         self.logger = logging.getLogger(self.__class__.__name__)
         self.driver = driver
         self.database = get_database_name()
+        self.gds = gds(self)
 
 
 class TestETLContext(ETLContext):
@@ -116,6 +117,16 @@ class TestETLContext(ETLContext):
         if key in self.__env_vars:
             return self.__env_vars[key]
 
+class TestSQLETLContext(ETLContext):
+
+    def __init__(self, sql_uri):
+        self.logger = logging.getLogger(self.__class__.__name__)
+        self.reporter = DummyReporter()
+        self.sql = SQLContext(sql_uri)
+
+    def env(self, key: str) -> Any:
+        if key in self.__env_vars:
+            return self.__env_vars[key]
 
 class DummyReporter:
 
@@ -151,3 +162,10 @@ class DummyContext:
 
     def env(self, key: str) -> Any:
         pass
+
+class DummyPredecessor:
+    def __init__(self, batches):
+        self.batches = batches
+
+    def get_batch(self, batch_size):
+        yield from self.batches

{neo4j_etl_lib-0.1.1.dist-info → neo4j_etl_lib-0.2.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: neo4j-etl-lib
-Version: 0.1.1
+Version: 0.2.0
 Summary: Building blocks for ETL pipelines.
 Keywords: etl,graph,database
 Author-email: Bert Radke <bert.radke@pm.me>
@@ -19,6 +19,7 @@ Requires-Dist: neo4j>=5.27.0; python_version >= '3.7'
 Requires-Dist: python-dotenv>=1.0.1; python_version >= '3.8'
 Requires-Dist: tabulate>=0.9.0; python_version >= '3.7'
 Requires-Dist: click>=8.1.8; python_version >= '3.7'
+Requires-Dist: pydantic[email-validator]
 Requires-Dist: pytest>=8.3.0 ; extra == "dev" and ( python_version >= '3.8')
 Requires-Dist: testcontainers[neo4j]==4.9.0 ; extra == "dev" and ( python_version >= '3.9' and python_version < '4.0')
 Requires-Dist: pytest-cov ; extra == "dev"
@@ -31,11 +32,15 @@ Requires-Dist: pydata-sphinx-theme ; extra == "dev"
 Requires-Dist: sphinx-autodoc-typehints ; extra == "dev"
 Requires-Dist: sphinxcontrib-napoleon ; extra == "dev"
 Requires-Dist: sphinx-autoapi ; extra == "dev"
+Requires-Dist: sqlalchemy ; extra == "dev"
+Requires-Dist: psycopg2-binary ; extra == "dev"
 Requires-Dist: graphdatascience>=1.13 ; extra == "gds" and ( python_version >= '3.9')
+Requires-Dist: sqlalchemy ; extra == "sql"
 Project-URL: Documentation, https://neo-technology-field.github.io/python-etl-lib/index.html
 Project-URL: Home, https://github.com/neo-technology-field/python-etl-lib
 Provides-Extra: dev
 Provides-Extra: gds
+Provides-Extra: sql
 
 # Neo4j ETL Toolbox
 
@@ -43,7 +48,13 @@ A Python library of building blocks to assemble etl pipelines.
 
 Complete documentation can be found on https://neo-technology-field.github.io/python-etl-lib/index.html
 
-See https://github.com/neo-technology-field/python-etl-lib/tree/main/examples/gtfs for an example project.
+See https://github.com/neo-technology-field/python-etl-lib/tree/main/examples/gtfs 
+
+or 
+
+https://github.com/neo-technology-field/python-etl-lib/tree/main/examples/musicbrainz
+
+for example projects.
 
 
 The library can be installed via 

{neo4j_etl_lib-0.1.1.dist-info → neo4j_etl_lib-0.2.0.dist-info}/RECORD

@@ -1,29 +1,32 @@
-etl_lib/__init__.py,sha256=sxY6lj4IZU25bZRF4lb6N5nn6yH1W4S1Qqysw-NzcXI,65
+etl_lib/__init__.py,sha256=m8CiP9nDQUZCy4l5Crx09vtYrpAtqWkstIOj_Wlp1K8,65
 etl_lib/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-etl_lib/cli/run_tools.py,sha256=KAm6XRz5audOP_PhMVozEckvdeMJ0HfyleEFc5jAalc,8579
+etl_lib/cli/run_tools.py,sha256=KIar-y22P4kKm-yoJjecYsPwqC7U76M71dEgFO5-ZBo,8561
 etl_lib/core/BatchProcessor.py,sha256=6quNPE9Dp8hYJDQDTqxQtxbQ3KCmb56Mko34EIsNhyI,3352
-etl_lib/core/ClosedLoopBatchProcessor.py,sha256=unlx_A339oi2nOOXF0irrVf8j_GFhwcTuk_w5liqbWc,1321
-etl_lib/core/ETLContext.py,sha256=ZTk_IDILpjUji0DphPUzTNx8k_2hZRxy37mqIcEA-kM,5641
-etl_lib/core/ProgressReporter.py,sha256=QR9ZwwyHEEBYa8i3Udc5J68Ir1bsPIM1fFyt0n_lqFU,8407
+etl_lib/core/ClosedLoopBatchProcessor.py,sha256=WzML1nldhZRbP8fhlD6utuK5SBYRl1cJgEobVDIdBP4,1626
+etl_lib/core/ETLContext.py,sha256=CHRNfjTmIIrPUp2F7l4MJlTsRLwfuBsNJdF_SEeShvI,6695
+etl_lib/core/ProgressReporter.py,sha256=FNmunA8q1vkAcmDF5z8ExH-mTotQMX0fyf2VAz-zI8o,8414
 etl_lib/core/Task.py,sha256=3e8iVXSfXaeBecvgTcs2LiIf2JwpKETRFhH4ig6lock,9202
 etl_lib/core/ValidationBatchProcessor.py,sha256=EhO6PFQB-4PZgIOTXP4PwkbAl5HRK0zgTeKMseRU5QU,3261
 etl_lib/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 etl_lib/core/utils.py,sha256=wwfyvy78fL6sqHdV0IFqAVyEkp6vo5Yo8gRZua2dulw,816
 etl_lib/data_sink/CSVBatchSink.py,sha256=oq4VJwnA4WSyJzdvwstGv73vOEuWmPSfCynhVmxBByU,2204
-etl_lib/data_sink/CypherBatchSink.py,sha256=RMuelUat55ojLQMRYmoiXG0D_fgWH0RLbmUd01UMv_c,1511
+etl_lib/data_sink/CypherBatchSink.py,sha256=nBH4bzN1IvdSFcKgiAIrAY5IauB565sdyVrnRc1hg_4,1566
+etl_lib/data_sink/SQLBatchSink.py,sha256=vyGrrxpdmCLUZMI2_W2ORej3FLGbwN9-b2GMYHd-k9g,1451
 etl_lib/data_sink/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 etl_lib/data_source/CSVBatchSource.py,sha256=HILkaQAFua1OM7xgSNKY6teXpcJjWUPaS4Aol-GLYL8,2767
 etl_lib/data_source/CypherBatchSource.py,sha256=06WuW11BqYjAXBZqL96Qr9MR8JrcjujDpxXe8cI-SYY,2238
+etl_lib/data_source/SQLBatchSource.py,sha256=rfIpzMU9IG5xrftZss7W-KpSIINCUdPfJBEXa5QDFts,2323
 etl_lib/data_source/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-etl_lib/task/CreateReportingConstraintsTask.py,sha256=aV5i1EwjfuG-eEGoNaB-NcaPhyu0NgdVhmZr5MIv8ak,760
+etl_lib/task/CreateReportingConstraintsTask.py,sha256=nTcHLBIgXz_h2OQg-SHjQr68bhH974u0MwrtWPnVwng,762
 etl_lib/task/ExecuteCypherTask.py,sha256=thE8YTZzv1abxNhhDcb4p4ke6qmI6kWR4XQ-GrCBBBU,1284
 etl_lib/task/GDSTask.py,sha256=X1E83wYa-N7AXy43WPEqIy77d__z-2wpBjWNhGNXJzA,1781
 etl_lib/task/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-etl_lib/task/data_loading/CSVLoad2Neo4jTask.py,sha256=US9Sa6ytPPEa6BSVUBttlWdKzqyxlF-09If5XCf-LIE,2277
+etl_lib/task/data_loading/CSVLoad2Neo4jTask.py,sha256=bD1dWX3guY0f_lFqQP_pzPa03AYveLhjDQzOqkyJVQc,3840
+etl_lib/task/data_loading/SQLLoad2Neo4jTask.py,sha256=N8pQFx5vYKJ3UDn6sw7yBmCJao_b5vBOT3tJ8pWVVLk,2942
 etl_lib/task/data_loading/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 etl_lib/test_utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-etl_lib/test_utils/utils.py,sha256=j7RMhT5Q69-5EAVwB1hePPJobq69_uYxuMTfd6gnbbc,5109
-neo4j_etl_lib-0.1.1.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-neo4j_etl_lib-0.1.1.dist-info/WHEEL,sha256=_2ozNFCLWc93bK4WKHCO-eDUENDlo-dgc9cU3qokYO4,82
-neo4j_etl_lib-0.1.1.dist-info/METADATA,sha256=LG9xc0NIjBUtdRZwLl9O8WpSXjJqCWLIWf0m8j0iZHQ,2210
-neo4j_etl_lib-0.1.1.dist-info/RECORD,,
+etl_lib/test_utils/utils.py,sha256=kxWJqdRf1pg-4ByMfrtW3HDbgXIvyVtLndGDVvMCmoI,5641
+neo4j_etl_lib-0.2.0.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+neo4j_etl_lib-0.2.0.dist-info/WHEEL,sha256=G2gURzTEtmeR8nrdXUJfNiB3VYVxigPQ-bEQujpNiNs,82
+neo4j_etl_lib-0.2.0.dist-info/METADATA,sha256=FISyLgs53iHj3Uun7RgGFVtltLus_FiCkU591q9fJ3o,2497
+neo4j_etl_lib-0.2.0.dist-info/RECORD,,

{neo4j_etl_lib-0.1.1.dist-info → neo4j_etl_lib-0.2.0.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: flit 3.11.0
+Generator: flit 3.12.0
 Root-Is-Purelib: true
 Tag: py3-none-any