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

etl_lib/__init__.py

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

etl_lib/cli/run_tools.py

@@ -55,7 +55,7 @@ def __driver(ctx):
     database_name = ctx.obj["database_name"]
     neo4j_password = ctx.obj["neo4j_password"]
     return GraphDatabase.driver(neo4j_uri, auth=(neo4j_user, neo4j_password), database=database_name,
-                                notifications_min_severity="OFF", user_agent="ETL CLI 0.1")
+                                notifications_min_severity="OFF", user_agent="ETL CLI")
 
 
 @click.group()
@@ -98,7 +98,7 @@ def cli(ctx, neo4j_uri, neo4j_user, neo4j_password, log_file, database_name):
 @click.pass_context
 def query(ctx, number_runs):
     """
-    Retrieve the list of the last x etl runs from the database and display them.
+    Retrieve the list of the last x ETL runs from the database and display them.
     """
     print(f"Listing runs in database '{ctx.obj['database_name']}'")
     with __driver(ctx) as driver:
@@ -165,25 +165,57 @@ def detail(ctx, run_id, details):
             __print_details(driver, run_id)
 
 
+# noinspection PyTypeChecker
 @cli.command()
-@click.option('--run-id', required=False, help='Run ID to delete')
-@click.option('--since', help='Delete runs since a specific date')
-@click.option('--older', help='Delete runs older than a specific date')
+@click.option('--run-id', required=False, type=str, help='Run IDs to delete, works with comma separated list')
+@click.option('--before', type=click.DateTime(formats=["%Y-%m-%d"]), help='Delete runs before a specific date in format YYYY-MM-DD')
+@click.option('--older', help='Delete runs older than x days', type=int)
 @click.pass_context
-def delete(ctx, run_id, since, older):
+def delete(ctx, run_id, before, older):
     """
-    Delete runs based on run ID, date, or age. One and only one of --run-id, --since, or --older must be provided.
+    Delete runs based on run ID, date, or age. One and only one of --run-id, --before, or --older must be provided.
     """
     # Ensure mutual exclusivity
-    options = [run_id, since, older]
+    options = [run_id, before, older]
     if sum(bool(opt) for opt in options) != 1:
-        print("You must specify exactly one of --run-id, --since, or --older.")
+        print("You must specify exactly one of --run-id, --before, or --older.")
         return
 
     if run_id:
-        print(f"Deleting run ID: {run_id}")
-    elif since:
-        print(f"Deleting runs since: {since}")
+        ids = run_id.split(',')
+        delete_runs(ctx, ids)
+    elif before:
+        print(f"Deleting runs before: {before}")
+        with __driver(ctx) as driver:
+            record= driver.execute_query(
+                """MATCH (r:ETLRun) WHERE date(r.startTime) < date($before) 
+                RETURN collect(r.uuid) AS ids
+                """,
+                result_transformer_=neo4j.Result.single,
+                before=before)
+            ids = record[0]
+            delete_runs(ctx, ids)
+
     elif older:
         print(f"Deleting runs older than: {older}")
-    # Implement delete logic here
+        with __driver(ctx) as driver:
+            record = driver.execute_query(
+                """MATCH (r:ETLRun) WHERE date(r.startTime) < (date() - duration({days: $days})) 
+                RETURN collect(r.uuid) AS ids
+                """,
+                result_transformer_=neo4j.Result.single,
+                days=older)
+            ids = record[0]
+            delete_runs(ctx, ids)
+
+
+def delete_runs(ctx, ids):
+    print(f"Deleting run IDs: {ids}")
+    with __driver(ctx) as driver:
+        records, _, _ = driver.execute_query(
+            """
+            MATCH (r:ETLRun)-[*]->(n) WHERE r.uuid IN $ids
+            DETACH DELETE n
+            DETACH DELETE r
+            """, ids=ids, routing_=neo4j.RoutingControl.WRITE)
+    print(f"Deleted run IDs: {ids}  successfully")

etl_lib/core/ETLContext.py

@@ -130,8 +130,6 @@ class ETLContext:
     Will be passed to all :py:class:`etl_lib.core.Task` to provide access to environment variables and functionally
     deemed general enough that all parts of the ETL pipeline would need it.
     """
-    neo4j: Neo4jContext
-    __env_vars: dict
 
     def __init__(self, env_vars: dict):
         """

etl_lib/core/ProgressReporter.py

@@ -3,7 +3,7 @@ from datetime import datetime
 
 from tabulate import tabulate
 
-from etl_lib.core.Task import Task, TaskGroup
+from etl_lib.core.Task import Task, TaskGroup, TaskReturn
 
 
 class ProgressReporter:
@@ -47,7 +47,7 @@ class ProgressReporter:
         self.logger.info(f"{'\t' * task.depth}starting {task.task_name()}")
         return task
 
-    def finished_task(self, task: Task, success: bool, summery: dict, error: str = None) -> Task:
+    def finished_task(self, task: Task, result: TaskReturn) -> Task:
         """
         Marks the task as finished.
 
@@ -55,23 +55,21 @@ class ProgressReporter:
 
         Args:
             task: Task to be marked as finished.
-            success: True if the task has successfully finished.
-            summery: statistics for this task (such as `nodes_created`)
-            error: If an exception occurred, the exception text should be provided here.
+            result: result of the task execution, such as status and summery information.
 
         Returns:
             Task to be marked as started.
         """
         task.end_time = datetime.now()
-        task.success = success
-        task.summery = summery
+        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: {success}"
-        if error is not None:
-            report += f", error: \n{error}"
+        report = f"{'\t' * task.depth} finished {task.task_name()} in {task.end_time - task.start_time} with success: {result.success}"
+        if result.error is not None:
+            report += f", error: \n{result.error}"
         else:
             # for the logger, remove entries with 0, but keep them in the original for reporting
-            cleaned_summery = {key: value for key, value in summery.items() if value != 0}
+            cleaned_summery = {key: value for key, value in result.summery.items() if value != 0}
             if len(cleaned_summery) > 0:
                 report += f"\n{tabulate([cleaned_summery], headers='keys', tablefmt='psql')}"
         self.logger.info(report)
@@ -168,9 +166,9 @@ class Neo4jProgressReporter(ProgressReporter):
                         start_time=task.start_time)
         return task
 
-    def finished_task(self, task: Task, success: bool, summery: dict, error: str = None) -> Task:
-        super().finished_task(task=task, success=success, summery=summery, error=error)
-        if success:
+    def finished_task(self, task: Task,  result: TaskReturn) -> Task:
+        super().finished_task(task=task, result=result)
+        if result.success:
             status = "success"
         else:
             status = "failure"
@@ -179,7 +177,7 @@ class Neo4jProgressReporter(ProgressReporter):
             MATCH (t:ETLTask {uuid:$id}) SET t.endTime = $end_time, t.status = $status, t.error = $error
             CREATE (s:ETLStats) SET s=$summery
             CREATE (t)-[:HAS_STATS]->(s)
-            """, id=task.uuid, end_time=task.end_time, summery=summery, status=status, error=error)
+            """, id=task.uuid, end_time=task.end_time, summery=result.summery, status=status, error=result.error)
         return task
 
     def __create_constraints(self):

etl_lib/core/Task.py

@@ -46,7 +46,8 @@ class TaskReturn:
 
         # Combine success values and errors
         combined_success = self.success and other.success
-        combined_error = f"{self.error or ''} | {other.error or ''}".strip(" |")
+        combined_error = None if not (self.error or other.error) \
+            else f"{self.error or ''} | {other.error or ''}".strip(" |")
 
         return TaskReturn(
             success=combined_success, summery=merged_summery, error=combined_error
@@ -99,12 +100,7 @@ class Task:
         except Exception as e:
             result = TaskReturn(success=False, summery={}, error=str(e))
 
-        self.context.reporter.finished_task(
-            task=self,
-            success=result.success,
-            summery=result.summery,
-            error=result.error,
-        )
+        self.context.reporter.finished_task(task=self,result=result)
 
         return result
 

etl_lib/core/ValidationBatchProcessor.py

@@ -47,7 +47,7 @@ class ValidationBatchProcessor(BatchProcessor):
             for row in batch.chunk:
                 try:
                     # Validate and transform the row
-                    validated_row = self.model(**row).model_dump()
+                    validated_row = json.loads(self.model(**row).model_dump_json())
                     valid_rows.append(validated_row)
                 except ValidationError as e:
                     # Collect invalid rows with errors

etl_lib/data_sink/CSVBatchSink.py

@@ -0,0 +1,57 @@
+import csv
+from pathlib import Path
+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.Task import Task
+
+
+class CSVBatchSink(BatchProcessor):
+    """
+    BatchProcessor to write batches of data to a CSV file.
+    """
+
+    def __init__(self, context: ETLContext, task: Task, predecessor: BatchProcessor, file_path: Path, **kwargs):
+        """
+        Constructs a new CSVBatchSink.
+
+        Args:
+            context: :class:`etl_lib.core.ETLContext.ETLContext` instance.
+            task: :class:`etl_lib.core.Task.Task` instance owning this batchProcessor.
+            predecessor: BatchProcessor which :func:`~get_batch` function will be called to receive batches to process.
+            file_path: Path to the CSV file where data will be written. If the file exists, data will be appended.
+            **kwargs: Additional arguments passed to `csv.DictWriter` to allow tuning the csv creation.
+        """
+        super().__init__(context, task, predecessor)
+        self.file_path = file_path
+        self.file_initialized = False
+        self.csv_kwargs = kwargs
+
+    def get_batch(self, batch_size: int) -> Generator[BatchResults, None, None]:
+        assert self.predecessor is not None
+
+        for batch_result in self.predecessor.get_batch(batch_size):
+            self._write_to_csv(batch_result.chunk)
+            yield append_result(batch_result, {"rows_written": len(batch_result.chunk)})
+
+    def _write_to_csv(self, data: list[dict]):
+        """
+        Writes a batch of data to the CSV file.
+
+        Args:
+            data: A list of dictionaries representing rows of data.
+        """
+        if not data:
+            return
+
+        fieldnames = data[0].keys()
+        write_header = not self.file_initialized or not self.file_path.exists()
+
+        with self.file_path.open(mode="a", newline="", encoding="utf-8") as csvfile:
+            writer = csv.DictWriter(csvfile, fieldnames=fieldnames, **self.csv_kwargs)
+            if write_header:
+                writer.writeheader()
+            writer.writerows(data)
+
+        self.file_initialized = True

etl_lib/data_sink/{CypherBatchProcessor.py → CypherBatchSink.py}

@@ -5,19 +5,19 @@ from etl_lib.core.BatchProcessor import BatchProcessor, BatchResults, append_res
 from etl_lib.core.Task import Task
 
 
-class CypherBatchProcessor(BatchProcessor):
+class CypherBatchSink(BatchProcessor):
     """
     BatchProcessor to write batches of data to a Neo4j database.
     """
 
     def __init__(self, context: ETLContext, task: Task, predecessor: BatchProcessor, query: str):
         """
-        Constructs a new CypherBatchProcessor.
+        Constructs a new CypherBatchSink.
 
         Args:
-            context: :py:class:`etl_lib.core.ETLContext.ETLContext` instance.
-            task: :py:class:`etl_lib.core.Task.Task` instance owning this batchProcessor.
-            predecessor: BatchProcessor which :py:func:`~get_batch` function will be called to receive batches to process.
+            context: :class:`etl_lib.core.ETLContext.ETLContext` instance.
+            task: :class:`etl_lib.core.Task.Task` instance owning this 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`.

etl_lib/data_source/{CSVBatchProcessor.py → CSVBatchSource.py}

@@ -7,7 +7,7 @@ from etl_lib.core.BatchProcessor import BatchProcessor, BatchResults
 from etl_lib.core.Task import Task
 
 
-class CSVBatchProcessor(BatchProcessor):
+class CSVBatchSource(BatchProcessor):
     """
     BatchProcessor that reads a CSV file using the `csv` package.
 
@@ -18,11 +18,11 @@ class CSVBatchProcessor(BatchProcessor):
 
     def __init__(self, csv_file: Path, context, task: Task = None, **kwargs):
         """
-        Constructs a new CSVBatchProcessor.
+        Constructs a new CSVBatchSource.
 
         Args:
             csv_file: Path to the CSV file.
-            context: :py:class:`etl_lib.core.ETLContext.ETLContext` instance.
+            context: :class:`etl_lib.core.ETLContext.ETLContext` instance.
             kwargs: Will be passed on to the `csv.DictReader` providing a way to customise the reading to different
                 csv formats.
         """

etl_lib/data_source/CypherBatchSource.py

@@ -0,0 +1,62 @@
+from typing import Generator, Callable, Optional
+
+from neo4j import Record
+
+from etl_lib.core.BatchProcessor import BatchResults, BatchProcessor
+from etl_lib.core.ETLContext import ETLContext
+from etl_lib.core.Task import Task
+
+
+class CypherBatchSource(BatchProcessor):
+
+    def __init__(
+            self,
+            context: ETLContext,
+            task: Task,
+            query: str,
+            record_transformer: Optional[Callable[[Record], dict]] = None,
+            **kwargs
+    ):
+        """
+       Constructs a new CypherBatchSource.
+
+       Args:
+           context: :class:`etl_lib.core.ETLContext.ETLContext` instance.
+           task: :class:`etl_lib.core.Task.Task` instance owning this batchProcessor.
+           query: Cypher query to execute.
+           record_transformer: Optional function to transform each record. See Neo4j API documentation on `result_transformer_`
+           kwargs: Arguments passed as parameters with the query.
+       """
+        super().__init__(context, task)
+        self.query = query
+        self.record_transformer = record_transformer
+        self.kwargs = kwargs
+
+    def __read_records(self, tx, batch_size):
+        batch_ = []
+        result = tx.run(self.query, **self.kwargs)
+
+        for record in result:
+            data = record.data()
+            if self.record_transformer:
+                data = self.record_transformer(data)
+            batch_.append(data)
+
+            if len(batch_) == batch_size:
+                yield batch_
+                batch_ = []
+
+        if batch_:
+            yield batch_
+
+    def get_batch(self, max_batch_size: int) -> Generator[BatchResults, None, None]:
+        # not using managed tx on purpose. First of, we want to keep the tx open while delivering batches
+        # automatic retry logic would help, as we do not want to start the query again
+        with self.context.neo4j.session() as session:
+            with session.begin_transaction() as tx:
+                for chunk in self.__read_records(tx, max_batch_size):
+                    yield BatchResults(
+                        chunk=chunk,
+                        statistics={"cypher_rows_read": len(chunk)},
+                        batch_size=len(chunk)
+                    )

etl_lib/task/ExecuteCypherTask.py

@@ -24,10 +24,10 @@ class ExecuteCypherTask(Task):
                 for query in self._query():
                     result = self.context.neo4j.query_database(session=session, query=query, **kwargs)
                     stats = merge_summery(stats, result.summery)
-                return TaskReturn(True, stats)
+                return TaskReturn(success=True, summery=stats)
             else:
                 result = self.context.neo4j.query_database(session=session, query=self._query(), **kwargs)
-                return TaskReturn(True, result.summery)
+                return TaskReturn(success=True, summery=result.summery)
 
     @abc.abstractmethod
     def _query(self) -> str | list[str]:

etl_lib/task/data_loading/CSVLoad2Neo4jTask.py

@@ -9,12 +9,24 @@ from etl_lib.core.ETLContext import ETLContext
 from etl_lib.core.ClosedLoopBatchProcessor import ClosedLoopBatchProcessor
 from etl_lib.core.Task import Task, TaskReturn
 from etl_lib.core.ValidationBatchProcessor import ValidationBatchProcessor
-from etl_lib.data_sink.CypherBatchProcessor import CypherBatchProcessor
-from etl_lib.data_source.CSVBatchProcessor import CSVBatchProcessor
+from etl_lib.data_sink.CypherBatchSink import CypherBatchSink
+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
+    follows:
+
+    If the context env vars hold an entry `ETL_ERROR_PATH` the file will be place 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.
+    """
     def __init__(self, context: ETLContext, model: Type[BaseModel], file: Path, batch_size: int = 5000):
         super().__init__(context)
         self.batch_size = batch_size
@@ -23,11 +35,15 @@ class CSVLoad2Neo4jTask(Task):
         self.file = file
 
     def run_internal(self, **kwargs) -> TaskReturn:
-        error_file = self.file.with_suffix(".error.json")
+        error_path = self.context.env("ETL_ERROR_PATH")
+        if error_path is None:
+            error_file = self.file.with_suffix(".error.json")
+        else:
+            error_file = error_path / self.file.with_name(self.file.stem + ".error.json").name
 
-        csv = CSVBatchProcessor(self.file, self.context, self)
+        csv = CSVBatchSource(self.file, self.context, self)
         validator = ValidationBatchProcessor(self.context, self, csv, self.model, error_file)
-        cypher = CypherBatchProcessor(self.context, self, validator, self._query())
+        cypher = CypherBatchSink(self.context, self, validator, self._query())
         end = ClosedLoopBatchProcessor(self.context, self, cypher)
         result = next(end.get_batch(self.batch_size))
 

etl_lib/test_utils/utils.py

@@ -0,0 +1,153 @@
+import logging
+import os
+from pathlib import Path
+from typing import Any
+
+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.Task import Task
+
+
+def run_query(driver, query, data):
+    with driver.session(database=get_database_name()) as session:
+        result = session.run(query, data=data)
+        return result.data()
+
+
+def get_node_count(driver, label: str) -> int:
+    """Get the count of nodes with the specified label"""
+    query = f"MATCH (n:{label}) RETURN COUNT(n) AS count"
+    with driver.session(database=get_database_name()) as session:
+        result = session.run(query)
+        return result.single()["count"]
+
+
+def get_relationship_count(driver, rel_type: str) -> int:
+    """Get the count of relationships with the specified type"""
+    query = f"MATCH ()-[r:{rel_type}]->() RETURN COUNT(r) AS count"
+    with driver.session(database=get_database_name()) as session:
+        result = session.run(query)
+        return result.single()["count"]
+
+
+def check_property_exists(driver, label: str, property_name: str) -> bool:
+    """
+    Checks if all nodes with the given label have the given property.
+    :return:
+    """
+    with driver.session(database=get_database_name()) as session:
+        result = session.run(f"MATCH (n:{label}) WHERE n.{property_name} IS NULL"
+                             f" RETURN COUNT(n) = 0 AS exists")
+        return result.single()["exists"]
+
+
+def get_graph(driver):
+    """
+    Return a grap representation of all data in the database.
+    The returned structure is an array of dicts. Each dict has the following keys:
+    `start`, `end`, and `rel` representing each relationship found in the graph.
+    Use the following query to generate this structure from a known good graph:
+
+        MATCH (s)-[r]->(e)
+        WITH {labels:labels(s), props:properties(s)} AS start, {type:type(r), props:properties(r)} AS rel, {labels:labels(e), props:properties(e)} AS end
+        RETURN {start:start, rel:rel, end:end}
+    """
+    with  driver.session(database=get_database_name()) as session:
+        records = session.run(
+            """
+            MATCH (s)-[r]->(e)
+            WITH {labels:labels(s), props:properties(s)} AS start, 
+                {type:type(r), props:properties(r)} AS rel, 
+                {labels:labels(e), props:properties(e)} AS end 
+            RETURN {start:start, rel:rel, end:end} AS graph
+            """
+        )
+        data = [record.data()["graph"] for record in records]
+        return convert_neo4j_date_to_string(data, "%Y-%m-%d")
+
+
+def convert_neo4j_date_to_string(data, date_format):
+    """
+    Recursively converts all neo4j.time.Date instances in a dictionary into strings using the provided format.
+
+    :param data: The input dictionary or list to process.
+    :param date_format: A format string compatible with Python's strftime.
+    :return: The processed dictionary or list with dates converted to strings.
+    """
+    if isinstance(data, dict):
+        return {key: convert_neo4j_date_to_string(value, date_format) for key, value in data.items()}
+    elif isinstance(data, list):
+        return [convert_neo4j_date_to_string(item, date_format) for item in data]
+    elif isinstance(data, Date):
+        return data.to_native().strftime(date_format)
+    else:
+        return data
+
+
+def get_database_name():
+    if os.getenv("NEO4J_TEST_CONTAINER") is None:
+        # not running with test containers. expect test db to be set
+        if os.getenv("NEO4J_TEST_DATABASE") is not None:
+            return os.getenv("NEO4J_TEST_DATABASE")
+        else:
+            raise Exception("define NEO4J_TEST_DATABASE environment variable")
+
+
+class TestNeo4jContext(Neo4jContext):
+
+    def __init__(self, driver: Driver):
+        self.logger = logging.getLogger(self.__class__.__name__)
+        self.driver = driver
+        self.database = get_database_name()
+
+
+class TestETLContext(ETLContext):
+
+    def __init__(self, driver: Driver, tmp_path):
+        self.logger = logging.getLogger(self.__class__.__name__)
+        self.__env_vars = {"ETL_ERROR_PATH": tmp_path}
+        self.neo4j = TestNeo4jContext(driver)
+        self.reporter = DummyReporter()
+
+    def env(self, key: str) -> Any:
+        if key in self.__env_vars:
+            return self.__env_vars[key]
+
+
+class DummyReporter:
+
+    def register_tasks(self, main: Task):
+        pass
+
+    def started_task(self, task: Task) -> Task:
+        pass
+
+    def finished_task(self, task, result) -> Task:
+        pass
+
+    def report_progress(self, task, batches: int, expected_batches: int, stats: dict) -> None:
+        pass
+
+
+class DummyNeo4jContext:
+
+    def query_database(self, session, query, **kwargs) -> QueryResult:
+        return QueryResult([], {})
+
+    def session(self, database=None):
+        return None
+
+
+class DummyContext:
+    neo4j: DummyNeo4jContext
+    __env_vars: dict
+    path_error: Path
+    path_import: Path
+    path_processed: Path
+    reporter = DummyReporter()
+
+    def env(self, key: str) -> Any:
+        pass

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

@@ -1,6 +1,6 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.4
 Name: neo4j-etl-lib
-Version: 0.0.3
+Version: 0.1.1
 Summary: Building blocks for ETL pipelines.
 Keywords: etl,graph,database
 Author-email: Bert Radke <bert.radke@pm.me>
@@ -13,6 +13,7 @@ Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Programming Language :: Python :: 3
 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: python-dotenv>=1.0.1; python_version >= '3.8'

neo4j_etl_lib-0.1.1.dist-info/RECORD

@@ -0,0 +1,29 @@
+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,,

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

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

neo4j_etl_lib-0.0.3.dist-info/RECORD

@@ -1,25 +0,0 @@
-etl_lib/__init__.py,sha256=uowSzShO11zBjnhp9t67CQUAe0Z9PFA3kpVEM-T4gfM,65
-etl_lib/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-etl_lib/cli/run_tools.py,sha256=ZXqXcCv9IBjMVED9KwwEMm9ti7xZ9MM-4P_-RcLY_gg,7292
-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=RdJr7GlNtoGz246XNdbq8YvTzgw4KWOQ6i3RjTH2b88,5686
-etl_lib/core/ProgressReporter.py,sha256=z5aVBjDJZSNGr6zmY8DsMC6dzEcnhAV7RboHWJdl49g,8557
-etl_lib/core/Task.py,sha256=qhCRYEJciYdaYzMurUTTzGQgm7UeKe0Ik37Fp-qAgr8,9256
-etl_lib/core/ValidationBatchProcessor.py,sha256=23uYtIVAtR755h34vkrN_QepFJnYroFKVO4xuHF922Y,3244
-etl_lib/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-etl_lib/core/utils.py,sha256=wwfyvy78fL6sqHdV0IFqAVyEkp6vo5Yo8gRZua2dulw,816
-etl_lib/data_sink/CypherBatchProcessor.py,sha256=VrnTOoMJMEjy0CeMPm-Q5p0mMlc4JnwrLDK-QrvEj9U,1530
-etl_lib/data_sink/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-etl_lib/data_source/CSVBatchProcessor.py,sha256=FaerMVPXqDmxAfxIO0Mot0IEuYyQ2lXxnm7hzcE0Oug,2776
-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=wpPF-bbawRiNS1cCXLhIwuXROAcXsv3OfdKc6DH5q2o,1252
-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=GxMfRRcrdFtGNkJ_-_bxRybKf9AoRCTg5_iAkVVjSyg,1487
-etl_lib/task/data_loading/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-neo4j_etl_lib-0.0.3.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-neo4j_etl_lib-0.0.3.dist-info/WHEEL,sha256=CpUCUxeHQbRN5UGRQHYRJorO5Af-Qy_fHMctcQ8DSGI,82
-neo4j_etl_lib-0.0.3.dist-info/METADATA,sha256=YIjIIJkmZ_WDPmQA78_IdzH7Q1XcS0w_GpBoPKZHvoQ,2188
-neo4j_etl_lib-0.0.3.dist-info/RECORD,,