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

etl_lib/task/data_loading/ParallelCSVLoad2Neo4jTask.py

@@ -0,0 +1,98 @@
+import abc
+from pathlib import Path
+from typing import Type
+
+
+from etl_lib.core.ClosedLoopBatchProcessor import ClosedLoopBatchProcessor
+from etl_lib.core.ETLContext import ETLContext
+from etl_lib.core.ParallelBatchProcessor import ParallelBatchProcessor
+from etl_lib.core.SplittingBatchProcessor import SplittingBatchProcessor, dict_id_extractor
+from etl_lib.core.Task import Task, TaskReturn
+from etl_lib.core.ValidationBatchProcessor import ValidationBatchProcessor
+from etl_lib.data_sink.CypherBatchSink import CypherBatchSink
+from etl_lib.data_source.CSVBatchSource import CSVBatchSource
+from pydantic import BaseModel
+
+class ParallelCSVLoad2Neo4jTask(Task):
+    """
+    Parallel CSV → Neo4j load using the mix-and-batch strategy.
+
+    Wires a CSV reader, optional Pydantic validation, a diagonal splitter
+    (to avoid overlapping node locks), and a Cypher sink. Rows are
+    distributed into (row, col) partitions and processed in non-overlapping groups.
+
+    Args:
+        context: Shared ETL context.
+        file: CSV file to load.
+        model: Optional Pydantic model for row validation; invalid rows go to `error_file`.
+        error_file: Output for invalid rows. Required when `model` is set.
+        table_size: Bucketing grid size for the splitter.
+        batch_size: Per-cell target batch size from the splitter.
+        max_workers: Worker threads per wave.
+        prefetch: Number of waves to prefetch from the splitter.
+        **csv_reader_kwargs: Forwarded to :py:class:`etl_lib.data_source.CSVBatchSource.CSVBatchSource`.
+
+    Returns:
+        :py:class:`~etl_lib.core.Task.TaskReturn` with merged validation and Neo4j counters.
+
+    Notes:
+        - `_query()` must return Cypher that starts with ``UNWIND $batch AS row``.
+        - Override `_id_extractor()` if your CSV schema doesn’t expose ``start``/``end``; the default uses
+          :py:func:`etl_lib.core.SplittingBatchProcessor.dict_id_extractor`.
+        - See the nyc-taxi example for a working subclass.
+    """
+    def __init__(self,
+                 context: ETLContext,
+                 file: Path,
+                 model: Type[BaseModel] | None = None,
+                 error_file: Path | None = None,
+                 table_size: int = 10,
+                 batch_size: int = 5000,
+                 max_workers: int | None = None,
+                 prefetch: int = 4,
+                 **csv_reader_kwargs):
+        super().__init__(context)
+        self.file = file
+        self.model = model
+        if model is not None and error_file is None:
+            raise ValueError('you must provide error file if the model is specified')
+        self.error_file = error_file
+        self.table_size = table_size
+        self.batch_size = batch_size
+        self.max_workers = max_workers or table_size
+        self.prefetch = prefetch
+        self.csv_reader_kwargs = csv_reader_kwargs
+
+    def run_internal(self) -> TaskReturn:
+        csv = CSVBatchSource(self.file, self.context, self, **self.csv_reader_kwargs)
+        predecessor = csv
+        if self.model is not None:
+            predecessor = ValidationBatchProcessor(self.context, self, csv, self.model, self.error_file)
+
+        splitter = SplittingBatchProcessor(
+            context=self.context,
+            task=self,
+            predecessor=predecessor,
+            table_size=self.table_size,
+            id_extractor=self._id_extractor()
+        )
+
+        parallel = ParallelBatchProcessor(
+            context=self.context,
+            task=self,
+            predecessor=splitter,
+            worker_factory=lambda: CypherBatchSink(self.context, self, None, self._query()),
+            max_workers=self.max_workers,
+            prefetch=self.prefetch
+        )
+
+        closing = ClosedLoopBatchProcessor(self.context, self, parallel)
+        result = next(closing.get_batch(self.batch_size))
+        return TaskReturn(True, result.statistics)
+
+    def _id_extractor(self):
+        return dict_id_extractor()
+
+    @abc.abstractmethod
+    def _query(self):
+        pass

etl_lib/task/data_loading/ParallelSQLLoad2Neo4jTask.py

@@ -0,0 +1,122 @@
+from abc import ABC, abstractmethod
+from typing import Callable, Union
+
+from etl_lib.core.ClosedLoopBatchProcessor import ClosedLoopBatchProcessor
+from etl_lib.core.ETLContext import ETLContext
+from etl_lib.core.ParallelBatchProcessor import ParallelBatchProcessor
+from etl_lib.core.SplittingBatchProcessor import SplittingBatchProcessor, dict_id_extractor
+from etl_lib.core.Task import Task, TaskReturn
+from etl_lib.data_sink.CypherBatchSink import CypherBatchSink
+from etl_lib.data_source.SQLBatchSource import SQLBatchSource
+from sqlalchemy import text
+
+
+class ParallelSQLLoad2Neo4jTask(Task, ABC):
+    """
+    Parallelized version of SQLLoad2Neo4jTask: reads via SQLBatchSource,
+    splits into non-overlapping partitions (grid), processes each partition
+    in parallel through a CypherBatchSink, and closes the loop.
+
+    Subclasses must implement:
+        - _sql_query()
+        - _cypher_query()
+        - optionally override _count_query() and _id_extractor().
+
+    Control parameters:
+        batch_size: max items per partition batch
+        table_size: dimension of the splitting grid
+        max_workers: parallel threads per partition group (defaults to table_size)
+        prefetch: number of partition-groups to prefetch
+    """
+
+    def __init__(
+            self,
+            context: ETLContext,
+            batch_size: int = 5000,
+            table_size: int = 10,
+            max_workers: int = None,
+            prefetch: int = 4
+    ):
+        super().__init__(context)
+        self.context = context
+        self.batch_size = batch_size
+        self.table_size = table_size
+        # default max_workers to table_size for full parallelism
+        self.max_workers = max_workers or table_size
+        self.prefetch = prefetch
+
+    @abstractmethod
+    def _sql_query(self) -> str:
+        """
+        Return the SQL query to load source rows.
+        """
+        pass
+
+    @abstractmethod
+    def _cypher_query(self) -> str:
+        """
+        Return the Cypher query to write rows into Neo4j.
+        """
+        pass
+
+    def _count_query(self) -> Union[str, None]:
+        """
+        Optional SQL to count source rows for progress reporting.
+        """
+        return None
+
+    def _id_extractor(self) -> Callable:
+        """
+        Extractor mapping each row item to a (row,col) partition index.
+        Default expects dict rows with 'start' and 'end' keys.
+        Override to customize.
+        """
+        return dict_id_extractor()
+
+    def run_internal(self) -> TaskReturn:
+        # total count for ClosedLoopBatchProcessor
+        total_count = self.__get_source_count()
+        # source of raw rows
+        source = SQLBatchSource(self.context, self, self._sql_query())
+
+        # splitter: non-overlapping partitions as defined by the id_extractor
+        splitter = SplittingBatchProcessor(
+            context=self.context,
+            task=self,
+            predecessor=source,
+            table_size=self.table_size,
+            id_extractor=self._id_extractor()
+        )
+
+        # parallel processor: runs CypherBatchSink on each partition concurrently
+        parallel = ParallelBatchProcessor(
+            context=self.context,
+            task=self,
+            worker_factory=lambda: CypherBatchSink(context=self.context, task=self, predecessor=None,
+                                                   query=self._cypher_query()),
+            predecessor=splitter,
+            max_workers=self.max_workers,
+            prefetch=self.prefetch
+        )
+
+        # close loop: drives the pipeline and reports progress
+        closing = ClosedLoopBatchProcessor(
+            context=self.context,
+            task=self,
+            predecessor=parallel,
+            expected_rows=total_count
+        )
+
+        # run once to completion and return aggregated stats
+        result = next(closing.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/task/data_loading/SQLLoad2Neo4jTask.py

@@ -0,0 +1,90 @@
+from abc import abstractmethod
+
+from etl_lib.core.ETLContext import ETLContext
+from sqlalchemy import text
+
+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.3.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: neo4j-etl-lib
-Version: 0.1.1
+Version: 0.3.0
 Summary: Building blocks for ETL pipelines.
 Keywords: etl,graph,database
 Author-email: Bert Radke <bert.radke@pm.me>
@@ -15,10 +15,11 @@ Classifier: Topic :: Database
 Classifier: Development Status :: 4 - Beta
 License-File: LICENSE
 Requires-Dist: pydantic>=2.10.5; python_version >= '3.8'
-Requires-Dist: neo4j>=5.27.0; python_version >= '3.7'
+Requires-Dist: neo4j-rust-ext>=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.3.0.dist-info/RECORD

@@ -0,0 +1,36 @@
+etl_lib/__init__.py,sha256=FyaTAuElsn3y3j1g15X141PnLTYxPrSUVU_YaVmiyPs,65
+etl_lib/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+etl_lib/cli/run_tools.py,sha256=KIar-y22P4kKm-yoJjecYsPwqC7U76M71dEgFO5-ZBo,8561
+etl_lib/core/BatchProcessor.py,sha256=mRpdxZ6ZMKI8XsY3TPuy4dVcvRqLKCO-p63KeOhFyKE,3417
+etl_lib/core/ClosedLoopBatchProcessor.py,sha256=WzML1nldhZRbP8fhlD6utuK5SBYRl1cJgEobVDIdBP4,1626
+etl_lib/core/ETLContext.py,sha256=wmEnbs3n_80B6La9Py_-MHG8BN0FajE9MjGPej0A3To,8045
+etl_lib/core/ParallelBatchProcessor.py,sha256=jNo1Xv1Ts34UZIseoQLDZOhHOVeEr8dUibKUt0FJ4Hw,7318
+etl_lib/core/ProgressReporter.py,sha256=UvWAPCuOrqyUcb5_kosIsCg1dyVQL-tnjgqnzs2cwZA,9372
+etl_lib/core/SplittingBatchProcessor.py,sha256=OIRMUVFpUoZc0w__JJjUr7B9QC3sBlqQp41xghrQzC0,11616
+etl_lib/core/Task.py,sha256=muQFY5qj2n-ZVV8F6vlHqo2lVSvB3wtGdIgkSXVpOFM,9365
+etl_lib/core/ValidationBatchProcessor.py,sha256=U1M2Qp9Ledt8qFiHAg8zMxE9lLRkBrr51NKs_Y8skK8,3400
+etl_lib/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+etl_lib/core/utils.py,sha256=9gezAateAmtWZ5lr6ZWYlTtgrj4-CUKJSGz7g1upnRg,2293
+etl_lib/data_sink/CSVBatchSink.py,sha256=oq4VJwnA4WSyJzdvwstGv73vOEuWmPSfCynhVmxBByU,2204
+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=O3ZA2GXvo5j_KGwOILzguYZMPY_FJkV5j8FIa3-d9oM,4067
+etl_lib/data_source/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+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=9XiVdJHpABE-Hx1bsvTKLJWtChc8XMwXeO5RicaHDUo,3873
+etl_lib/task/data_loading/ParallelCSVLoad2Neo4jTask.py,sha256=2xN-5bHV9XgoaJLbbTEBuJFoZHV_CYi_hg6M1HQ-ffA,4030
+etl_lib/task/data_loading/ParallelSQLLoad2Neo4jTask.py,sha256=9xpCW5i8yGnUHyg475Z8rjN2P5NDshJGUEgTU6sm2Bs,4286
+etl_lib/task/data_loading/SQLLoad2Neo4jTask.py,sha256=HR3DcjOUkQN4SbCkgQYzljQCYhOcb-x2-DR5dBdapzU,2953
+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=kxWJqdRf1pg-4ByMfrtW3HDbgXIvyVtLndGDVvMCmoI,5641
+neo4j_etl_lib-0.3.0.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+neo4j_etl_lib-0.3.0.dist-info/WHEEL,sha256=G2gURzTEtmeR8nrdXUJfNiB3VYVxigPQ-bEQujpNiNs,82
+neo4j_etl_lib-0.3.0.dist-info/METADATA,sha256=GJcjdPvmzjEUq0pLndSSVzOg3c7CR6bIWz3sB_9tkVY,2506
+neo4j_etl_lib-0.3.0.dist-info/RECORD,,

{neo4j_etl_lib-0.1.1.dist-info → neo4j_etl_lib-0.3.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

neo4j_etl_lib-0.1.1.dist-info/RECORD

@@ -1,29 +0,0 @@
-etl_lib/__init__.py,sha256=sxY6lj4IZU25bZRF4lb6N5nn6yH1W4S1Qqysw-NzcXI,65
-etl_lib/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-etl_lib/cli/run_tools.py,sha256=KAm6XRz5audOP_PhMVozEckvdeMJ0HfyleEFc5jAalc,8579
-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/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/__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/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-etl_lib/task/CreateReportingConstraintsTask.py,sha256=aV5i1EwjfuG-eEGoNaB-NcaPhyu0NgdVhmZr5MIv8ak,760
-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/__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,,