easy-data-loader 0.1.0__py3-none-any.whl

easy_data_loader/models.py

@@ -0,0 +1,168 @@
+from pydantic import BaseModel, Field, ValidationError, model_validator, ConfigDict
+from pydantic_settings import BaseSettings, SettingsConfigDict
+from typing import Optional, TypeAlias, Annotated
+from typing_extensions import Annotated, Any, Union, Dict, List
+import pandas as pd
+from pathlib import Path
+from sqlalchemy.types import TypeEngine
+from enum import Enum
+
+
+class ServerType(Enum):
+	MSSQL = 'MSSQL'
+	POSTGRESQL = 'POSTGRESQL'
+	SQLITE = 'SQLITE'
+
+class FileType(Enum):
+	CSV = 'CSV'
+	EXCEL = 'EXCEL'
+	ORC = 'ORC'
+	PARQUET = 'PARQUET'
+
+class ConnectionSettings(BaseSettings):
+	"""Default model for all database connections"""
+	conn_server_type : ServerType = ServerType.MSSQL
+	conn_server: str = "."
+	conn_database: str
+	conn_username: str | None = None
+	conn_password: str | None = None
+	conn_port: Annotated[int, Field(default=1433, ge=1, le=65535)]
+
+	model_config = SettingsConfigDict(
+		extra='ignore')
+
+	@model_validator(mode='after')
+	def check_auth(self) -> 'ConnectionSettings':
+		if(self.conn_username and not self.conn_password) or (self.conn_password and not self.conn_username):
+			raise ValueError("Both username and password must be provided for authentication")
+		return self
+
+class FileSettings(BaseSettings):
+	"""default model for all source file settings"""
+	file_type: FileType = FileType.CSV
+	folder_path: Path
+	file_name: Optional[str] = None
+	file_pattern: Optional[str] = None
+
+	@model_validator(mode='after')
+	def validate_model(self) -> 'FileSettings':
+		if not self.folder_path.exists():
+			raise ValueError(f'Root folder path: {self.folder_path} - does not exist')
+
+		# model needs to accept a file_name (we know the exact file name) or
+		# a file_pattern (we know part of the file name)
+		if self.file_pattern and self.file_name:
+			raise ValueError(f'Please define a specific file name or a file pattern, not both.')
+		return self
+
+class ColumnDefinition(BaseModel):
+	"""Default model representing a column in a database table"""
+	model_config = ConfigDict(arbitrary_types_allowed=True)
+
+	target_name: Optional[str] = None # name of the column in the Sql table
+	data_type: Optional[TypeEngine] = None # the SqlAlchemy data type
+
+
+class BasePipelineDefinition(BaseModel):
+	"""Base pipeline definition. Used for user defined pipelines but also autogenerated"""
+
+	model_config = ConfigDict(
+		arbitrary_types_allowed=True,
+		extra='allow'
+	)
+	pipeline_name: str = 'generic_pipeline'
+
+	source: str
+	source_sql: Optional[str] = None # can be a table name or a sql query
+	destination: str
+	destination_table: Optional[str] = None
+	audit: Optional[str] = None # resource name for the audit database
+	validator: Optional[Any] = None # pydantic model class for validation
+
+	# mapping of source columns to destination columns together with datatypes
+	columns: Dict[str, ColumnDefinition] = Field(default_factory=dict)
+
+	read_parameters: Dict[str, Any] = Field(default_factory=dict)
+	write_parameters: Dict[str, Any] = Field(default_factory=dict)
+
+	def file_pre_process(self, file_path: Path) -> Path:
+		"""
+		Hook for preprocessing the file before reading.
+		Ex: extract archive, rename file etc.
+		"""
+		return file_path
+
+	def transform(self, df: pd.DataFrame) -> pd.DataFrame:
+		"""
+		Hook method that allows data transformation before upload.
+		Can be overwritten by user in manual defined schema
+		"""
+		return df
+
+	def get_sql_columns(self) -> Dict[str, ColumnDefinition]:
+		"""
+		Return the sql column definition from the pipeline.
+		If there is no column mapping defined then the values must be populated
+		by reading the sql table columns.
+		"""
+		return self.columns
+
+	# Helper for getting the columns to rename in pandas if any
+	def get_rename_map(self) -> Dict[str, str]:
+		rename_map = {}
+		for source, col_def in self.columns.items():
+			if col_def.target_name:
+				rename_map[source] = col_def.target_name
+		return rename_map
+
+	# Helper to get the sql columns data type
+	def get_dtype_map(self) -> Dict[str, TypeEngine]:
+		dtype_map = {}
+		for source, col_def in self.columns.items():
+			if col_def.data_type:
+				key = col_def.target_name or source
+				dtype_map[key] = col_def.data_type
+		return dtype_map
+
+
+ResourceConfig: TypeAlias = Annotated[
+	Union[ConnectionSettings, FileSettings],
+	'Hybrid resource configuration: it can be a file or database to serve as a source or destination'
+]
+
+
+class ProcedureDefinition(BaseModel):
+	"""Model representing a pipeline that executes stored procedures"""
+	pipeline_name: str
+	audit: Optional[str] = None
+	resource: str # database resource name
+	# List of (procedure_name, parameter_dict)
+	procedures: List[tuple[str, Optional[Dict[str, Any]]]]
+
+
+class AuditEntry(BaseModel):
+	"""Model representing an entry in the audit table"""
+	execution_id: str
+	pipeline_name: str
+	status: str
+	input_rows: int = 0
+	output_rows: int = 0
+	source_name: Optional[str] = None
+	destination_name: Optional[str] = None
+	file_name: Optional[str] = None
+	file_path: Optional[str] = None
+	file_size_bytes: Optional[int] = None
+	file_last_modified: Optional[pd.Timestamp] = None
+	error_details: Optional[str] = None
+	sp_name: Optional[str] = None
+	sp_parameters: Optional[Dict[str, Any]] = None
+	timestamp: pd.Timestamp = Field(default_factory=pd.Timestamp.now)
+
+	model_config = ConfigDict(arbitrary_types_allowed=True)
+
+
+class OrchestratorDefinition(BaseModel):
+	"""Model representing an orchestrator that chains multiple pipelines"""
+	orchestrator_name: str
+	pipelines: List[str] # List of pipeline names to run in sequence
+	fail_fast: bool = True # Stop execution if a pipeline fails

easy_data_loader/orchestrator.py

@@ -0,0 +1,59 @@
+from typing import List
+from .log import LoggedComponent
+from .models import OrchestratorDefinition, BasePipelineDefinition, ProcedureDefinition
+from .config_loader import Configuration
+from .pipeline import LoadPipeline
+from .procedure_pipeline import ProcedurePipeline
+import uuid
+
+class OrchestratorPipeline(LoggedComponent):
+    """Executes a chain of pipelines defined by an OrchestratorDefinition"""
+
+    def __init__(self, orchestrator_name: str):
+        super().__init__()
+        self.config = Configuration()
+        definition = self.config.get_pipeline(orchestrator_name)
+        
+        if not isinstance(definition, OrchestratorDefinition):
+            self.log_and_raise(ValueError, f"'{orchestrator_name}' is not an orchestrator.")
+            
+        self.definition: OrchestratorDefinition = definition
+        self.batch_id = str(uuid.uuid4())
+
+    def run(self) -> bool:
+        self.logger.info(f"=== Starting Orchestrator: {self.definition.orchestrator_name} (Batch: {self.batch_id}) ===")
+        
+        success = True
+        for pipeline_name in self.definition.pipelines:
+            self.logger.info(f"[{self.definition.orchestrator_name}] -> Triggering pipeline: {pipeline_name}")
+            
+            p_def = self.config.get_pipeline(pipeline_name)
+            p_success = False
+            
+            # Instantiate and run
+            if isinstance(p_def, BasePipelineDefinition):
+                pipeline = LoadPipeline(pipeline_name)
+                # optionally pass batch_id down if we update BasePipeline later
+                p_success = pipeline.run()
+            elif isinstance(p_def, ProcedureDefinition):
+                pipeline = ProcedurePipeline(pipeline_name)
+                p_success = pipeline.run()
+            elif isinstance(p_def, OrchestratorDefinition):
+                self.logger.error(f"[{self.definition.orchestrator_name}] -> Nested orchestrators are not supported.")
+                p_success = False
+            else:
+                self.logger.error(f"[{self.definition.orchestrator_name}] -> Unknown pipeline type for '{pipeline_name}'")
+                p_success = False
+
+            if not p_success:
+                success = False
+                self.logger.error(f"[{self.definition.orchestrator_name}] -> Pipeline failed: {pipeline_name}")
+                if self.definition.fail_fast:
+                    self.logger.error(f"[{self.definition.orchestrator_name}] -> Fail fast enabled. Stopping orchestrator.")
+                    break
+            else:
+                self.logger.info(f"[{self.definition.orchestrator_name}] -> Pipeline succeeded: {pipeline_name}")
+                
+        status = "SUCCESS" if success else "FAILED"
+        self.logger.info(f"=== Orchestrator {self.definition.orchestrator_name} finished with status: {status} ===")
+        return success

easy_data_loader/pipeline.py

@@ -0,0 +1,169 @@
+from typing import Optional, List, Any
+import pandas as pd
+from pathlib import Path
+from pydantic import BaseModel
+
+from .pipeline_base import BasePipeline
+from .models import ConnectionSettings, FileSettings, BasePipelineDefinition
+from .file_operations import FileOperations
+from .database_operations import DatabaseOperations
+from .config_loader import Configuration
+
+class LoadPipeline(BasePipeline):
+	"""
+	Main orchestrator responsible for executing a specific ETL pipeline by name.
+	It retrieves definitions and resources from the Configuration instance.
+	Inherits shared logic from BasePipeline.
+	"""
+
+	def __init__(self, pipeline_name: str):
+		# Load definition from config
+		definition = Configuration().get_pipeline(pipeline_name)
+		if not isinstance(definition, BasePipelineDefinition):
+			raise ValueError(f"Pipeline '{pipeline_name}' is not a LoadPipeline definition.")
+
+		super().__init__(definition)
+		self.definition: BasePipelineDefinition = definition
+
+		# initialize components
+		self.src_db_ops: Optional[DatabaseOperations] = None
+		self.dst_db_ops: Optional[DatabaseOperations] = None
+		self.src_file_ops: Optional[FileOperations] = None
+		self.dst_file_ops: Optional[FileOperations] = None
+		self.source_file_path: Optional[Path] = None # For auditing
+
+		self._initialize_components()
+
+	def _initialize_components(self):
+		"""Dynamically initialize the components based on their type and definition"""
+
+		source_resource = self.config.get_resource(self.definition.source)
+		destination_resource = self.config.get_resource(self.definition.destination)
+
+		# initialize source file
+		if isinstance(source_resource, FileSettings):
+			self.src_file_ops = FileOperations(source_resource)
+			# Store resource names for auditing
+			self.source_name = source_resource.folder_path.name
+		elif isinstance(source_resource, ConnectionSettings):
+			self.src_db_ops = self._setup_db_operations(source_resource)
+			self.source_name = source_resource.conn_database
+
+		# initialize destination file
+		if isinstance(destination_resource, FileSettings):
+			self.dst_file_ops = FileOperations(destination_resource)
+			self.destination_name = destination_resource.folder_path.name
+		elif isinstance(destination_resource, ConnectionSettings):
+			self.dst_db_ops = self._setup_db_operations(destination_resource)
+			self.destination_name = destination_resource.conn_database
+
+	def run(self) -> bool:
+		"""Executes the entire ETL flow"""
+		self.logger.info(f">>> Starting Load Pipeline: {self.definition.pipeline_name} <<<")
+
+		try:
+			# 1. EXTRACT
+			df = self._extract_step()
+			if df.empty:
+				self.logger.warning("No data found! Pipeline will stop!")
+				return False
+
+			self.input_rows = len(df)
+
+			# 2. TRANSFORM & VALIDATE
+			df = self._transform_step(df)
+			self.output_rows = len(df)
+
+			# 3. LOAD
+			load_success = self._load_step(df)
+			if not load_success:
+				self.logger.error(f'>>> Pipeline {self.definition.pipeline_name} failed to load during the LOAD step.')
+				self._log_audit("FAILED")
+				return False
+
+			self._log_audit("SUCCESS")
+			self.logger.info(f">>> Pipeline {self.definition.pipeline_name} finished successfully <<<")
+			return True
+
+		except Exception as e:
+			self.error_details = str(e)
+			self.log_exception(e, f"Critical pipeline error - {self.definition.pipeline_name}")
+			self._log_audit("FAILED")
+			return False
+		finally:
+			self._cleanup()
+
+	def _extract_step(self) -> pd.DataFrame:
+		"""Handles extraction logic based on source type."""
+		try:
+			if self.src_db_ops: # DB source
+				if self.definition.source_sql:
+					return self.src_db_ops.read_data(self.definition.source_sql, **self.definition.read_parameters)
+
+			if self.src_file_ops: # File source
+				self.src_file_ops._apply_file_preprocessor(self.definition.file_pre_process)
+				df = self.src_file_ops.read_file(**self.definition.read_parameters)
+				self.source_file_path = self.src_file_ops.file_path # Ensure we have the path for auditing
+				return df
+
+			self.logger.error('No valid source configured for the Pipeline')
+
+		except Exception as e:
+			self.log_exception(e, 'Extraction step failed')
+			raise
+
+		return pd.DataFrame()
+
+	def _transform_step(self, df: pd.DataFrame) -> pd.DataFrame:
+		"""Applies transformations and optional Pydantic validation."""
+
+		# 1. Pipeline hook transformation
+		df = self.definition.transform(df)
+
+		# 2. Renaming columns (can also be handled by Pydantic aliases)
+		rename_map = self.definition.get_rename_map()
+		if rename_map:
+			df.rename(columns=rename_map, inplace=True)
+			self.logger.info(f"Columns renamed: {list(rename_map.values())}")
+
+		# 3. Optional Pydantic Validation
+		if self.definition.validator:
+			self.logger.info(f"Starting data validation against model: {self.definition.validator.__name__}")
+			validated_rows = []
+
+			# Optimization: iterrows is slow because it creates a Series for each row.
+			# Converting to a list of dicts first is much faster for iteration.
+			records = df.to_dict(orient='records')
+
+			for i, record in enumerate(records):
+				try:
+					# Use model_validate for individual row validation
+					model_inst = self.definition.validator.model_validate(record)
+					validated_rows.append(model_inst.model_dump())
+				except Exception as e:
+					self.logger.warning(f"Row {i} failed validation: {str(e)}")
+
+			df = pd.DataFrame(validated_rows)
+
+		return df
+
+	def _load_step(self, df: pd.DataFrame) -> bool:
+		"""Handles loading logic based on destination type."""
+		try:
+			if self.dst_db_ops and self.definition.destination_table: #DB destination
+				dtype_map = self.definition.get_dtype_map()
+				self.dst_db_ops.write_to_table(
+					table_name=self.definition.destination_table,
+					df=df,
+					dtype=dtype_map,
+					**self.definition.write_parameters,
+				)
+				return True
+			elif self.dst_file_ops: # File destination
+				self.dst_file_ops.write_file(df, **self.definition.write_parameters)
+				return True
+			return False
+		except Exception as e:
+			self.log_exception(e, 'Error writing to destination')
+			return False
+

easy_data_loader/pipeline_base.py

@@ -0,0 +1,121 @@
+import uuid
+from datetime import datetime
+import pandas as pd
+from abc import ABC, abstractmethod
+from typing import List, Optional, Union
+
+from .log import LoggedComponent
+from .models import ConnectionSettings, AuditEntry, BasePipelineDefinition, ProcedureDefinition, ServerType
+from .database_connector import DatabaseConnector, CONNECTOR_FACTORY
+from .database_operations import DatabaseOperations
+from .config_loader import Configuration
+
+class BasePipeline(LoggedComponent, ABC):
+	"""
+	Abstract base class for all pipeline types.
+	Handles:
+	- Execution ID generation
+	- Audit resource initialization
+	- Shared resource cleanup
+	"""
+
+	def __init__(self, definition: Union[BasePipelineDefinition, ProcedureDefinition]):
+		super().__init__()
+		self.definition = definition
+		self.execution_id = str(uuid.uuid4())
+		self.config = Configuration()
+
+		self._active_connectors: List[DatabaseConnector] = []
+		self.audit_db_ops: Optional[DatabaseOperations] = None
+
+		# Metadata for auditing
+		self.input_rows = 0
+		self.output_rows = 0
+		self.error_details: Optional[str] = None
+		self.start_time = pd.Timestamp.now()
+
+		self._initialize_audit_resource()
+
+	def _initialize_audit_resource(self):
+		"""Initialize the database operations for auditing."""
+		audit_resource_name = self.definition.audit
+
+		if audit_resource_name:
+			# External audit database
+			resource = self.config.get_resource(audit_resource_name)
+			if not isinstance(resource, ConnectionSettings):
+				self.log_and_raise(ValueError, f"Audit resource '{audit_resource_name}' must be a database connection.")
+			self.audit_db_ops = self._setup_db_operations(resource)
+		else:
+			# SQLite Fallback
+			self.logger.info("No audit resource defined. Falling back to SQLite audit_logs.db")
+			sqlite_settings = ConnectionSettings(
+				conn_server_type=ServerType.SQLITE,
+				conn_server="audit_logs.db",
+				conn_database="audit_logs" # Not used by SQLite but required by model
+			)
+			self.audit_db_ops = self._setup_db_operations(sqlite_settings)
+
+	def _setup_db_operations(self, settings: ConnectionSettings) -> DatabaseOperations:
+		"""Helper to create the connector, store it for cleanup, and return the Ops."""
+		server_type = settings.conn_server_type
+
+		if server_type not in CONNECTOR_FACTORY:
+			self.log_and_raise(ValueError, f"Unsupported server type: {server_type}")
+
+		connector = CONNECTOR_FACTORY[server_type](settings)
+		self._active_connectors.append(connector)
+		return DatabaseOperations(connector.get_engine())
+
+	def _cleanup(self):
+		"""Dispose of all active database connectors."""
+		for connector in self._active_connectors:
+			connector._dispose_engine()
+		self.logger.debug("Pipeline cleanup completed.")
+
+	def _log_audit(self, status: str):
+		"""Write the execution audit entry to the audit database."""
+		if not self.audit_db_ops:
+			return
+
+		# Build file metadata dict before constructing the entry.
+		# Pydantic v2 models are immutable by default, so we must pass
+		# all fields at construction time rather than mutating afterward.
+		file_meta = {}
+		source_file = getattr(self, 'source_file_path', None)
+		if source_file:
+			try:
+				stat = source_file.stat()
+				file_meta = {
+					"file_name": source_file.name,
+					"file_path": str(source_file),
+					"file_size_bytes": stat.st_size,
+					"file_last_modified": pd.Timestamp(stat.st_mtime, unit='s'),
+				}
+			except OSError as e:
+				self.logger.warning(f"Could not read file metadata for audit: {e}")
+
+		entry = AuditEntry(
+			execution_id=self.execution_id,
+			pipeline_name=self.definition.pipeline_name,
+			status=status,
+			input_rows=self.input_rows,
+			output_rows=self.output_rows,
+			source_name=getattr(self, 'source_name', None),
+			destination_name=getattr(self, 'destination_name', None),
+			sp_name=getattr(self, 'sp_name', None),
+			sp_parameters=getattr(self, 'sp_parameters', None),
+			timestamp=pd.Timestamp.now(),
+			error_details=self.error_details,
+			**file_meta,
+		)
+
+		try:
+			self.audit_db_ops.write_audit("execution_audit", entry)
+		except Exception as e:
+			self.logger.error(f"Failed to write audit log: {str(e)}")
+
+	@abstractmethod
+	def run(self) -> bool:
+		"""Main execution logic to be implemented by child classes."""
+		pass

easy_data_loader/procedure_pipeline.py

@@ -0,0 +1,56 @@
+from typing import Dict, Any
+from .pipeline_base import BasePipeline
+from .models import ProcedureDefinition, ConnectionSettings
+from .config_loader import Configuration
+
+class ProcedurePipeline(BasePipeline):
+	"""
+	Pipeline specialized in executing database stored procedures.
+	"""
+
+	def __init__(self, pipeline_name: str):
+		# Load definition from config
+		definition = Configuration().get_pipeline(pipeline_name)
+		if not isinstance(definition, ProcedureDefinition):
+			raise ValueError(f"Pipeline '{pipeline_name}' is not a ProcedureDefinition.")
+
+		super().__init__(definition)
+		self.definition: ProcedureDefinition = definition
+
+		# Set up primary database connection
+		resource = self.config.get_resource(self.definition.resource)
+		if not isinstance(resource, ConnectionSettings):
+			self.log_and_raise(ValueError, f"Resource '{self.definition.resource}' must be a database connection.")
+
+		self.db_ops = self._setup_db_operations(resource)
+
+	def run(self) -> bool:
+		"""Execute all procedures in the definition."""
+		self.logger.info(f">>> Starting Procedure Pipeline: {self.definition.pipeline_name} <<<")
+
+		try:
+			for proc_name, params in self.definition.procedures:
+				params = params or {}
+				self.logger.info(f"Running procedure: {proc_name} with params: {params}")
+				self.db_ops.execute_stored_procedure(proc_name, **params)
+
+			# Set audit details
+			self.sp_name = ", ".join([p[0] for p in self.definition.procedures])
+			self.sp_parameters = {p[0]: p[1] for p in self.definition.procedures}
+
+			self._log_audit("SUCCESS")
+			self.logger.info(f">>> Procedure Pipeline {self.definition.pipeline_name} finished successfully <<<")
+			return True
+
+		except Exception as e:
+			self.error_details = str(e)
+			self.log_exception(e, f"Error in Procedure Pipeline: {self.definition.pipeline_name}")
+
+			# Set audit details for failure too
+			self.sp_name = ", ".join([p[0] for p in self.definition.procedures])
+			self.sp_parameters = {p[0]: p[1] for p in self.definition.procedures}
+
+			self._log_audit("FAILED")
+			return False
+		finally:
+			self._cleanup()

easy_data_loader-0.1.0.dist-info/METADATA

@@ -0,0 +1,52 @@
+Metadata-Version: 2.4
+Name: easy_data_loader
+Version: 0.1.0
+Summary: Data transfer utilities between files and databases
+Author-email: Bojoi Gabriel <bojoigabriel@gmail.com>
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: click>=8.3.0
+Requires-Dist: ipykernel
+Requires-Dist: openpyxl>=3.1.5
+Requires-Dist: pandas>=2.3.3
+Requires-Dist: pyarrow>=22.0.0
+Requires-Dist: pydantic>=2.12.5
+Requires-Dist: pydantic-settings>=2.12.0
+Requires-Dist: pyodbc>=5.2.0
+Requires-Dist: python-dotenv>=1.1.1
+Requires-Dist: sqlalchemy>=2.0.43
+Dynamic: license-file
+
+# Easy Data Loader 🚀
+
+**Easy Data Loader** is a flexible, modular Python library designed to streamline ETL (Extract, Transform, Load) processes between various data sources (CSV, Excel, Parquet) and SQL databases (MSSQL, PostgreSQL, and others).
+
+## ✨ Key Features
+- **Declarative Configuration**: Manage connections and pipelines through simple python files and `.env` resources.
+- **Integrated CLI**: Initialize a standardized project structure with a single command.
+- **Custom Transformation Hooks**: Inject your own Pandas transformation logic directly into the pipeline execution.
+- **Performance Optimized**: Built-in support for chunked loading and writing to handle large datasets efficiently.
+- **Extensible Architecture**: Uses a Factory Pattern for database connectors, making it easy to support new drivers.
+
+---
+
+## 📦 Installation
+
+Install directly via `pip` or `uv`:
+
+```bash
+pip install easy_data_loader
+```
+
+## 🚀 Getting Started
+
+1. Initialize a new project structure to generate template configurations:
+   ```bash
+   easy-loader init
+   ```
+2. Review the generated `config/` folders for sample resources and pipelines.
+3. Run all discovered pipelines across the active configurations:
+   ```bash
+   easy-loader run_all
+   ```

easy_data_loader-0.1.0.dist-info/RECORD

@@ -0,0 +1,20 @@
+easy_data_loader/__init__.py,sha256=kUkTXzuQYPFTU3pBvGODVgYrF6V6XGiXrSHpEQ81uZY,439
+easy_data_loader/cli.py,sha256=W-JIEMB3abQpD5N8vvOd8LB3_Jd-N_tyooRGku_qNmE,9893
+easy_data_loader/config_loader.py,sha256=KsXNN5UHr6GA8oxu_sJ0K3mHCI5UOuulQat3Jt-o0vk,7254
+easy_data_loader/custom_exceptions.py,sha256=nF-0ENJOPTtyrv_UO_kHSvVM3tfFXQmLHqXvADTzW8E,735
+easy_data_loader/database_connector.py,sha256=K879FpeIrcdE_NCcA44rW6CDMgB3tPbp_t6V_aFdKlI,6784
+easy_data_loader/database_operations.py,sha256=oAm4LRC84KLqeFlzHz0OdsS32y-TVad2x_UHMGCMI0o,5280
+easy_data_loader/driver_detector.py,sha256=L8H7IPEvDD7eb183wQH2eFwcmOuW_oxy7tNxGH-Kmlo,1280
+easy_data_loader/file_operations.py,sha256=Eu4H6q6CLAQe-zE12ZBJ1m_A9zp9m1UDKYGChwGBD-s,5820
+easy_data_loader/log.py,sha256=yIfvOhqnHzq8TogdvK6Si1LVsbI9QXsw0EDRIdEluS4,2825
+easy_data_loader/models.py,sha256=yY1z6WcWqKyBefO4br9f88WeiNdKQEbBUqWDNr2sUok,5551
+easy_data_loader/orchestrator.py,sha256=myDCM1Jmd1Soj_AvIuCZgi_uPAZvSpyJMKROb2u2tVc,2861
+easy_data_loader/pipeline.py,sha256=UxjpZ9Q4F1uzlUIoO9r5a4y6B6lexhVKWwHorbRSenQ,6020
+easy_data_loader/pipeline_base.py,sha256=qnb8dFEgQThFPT6rF9ywFzhdtFs1tB9wy7H6VDPBoRA,4201
+easy_data_loader/procedure_pipeline.py,sha256=vYtYaIshnr34KSF_PeraUM1bWHFUYVcT9L2s2gLTMIQ,2075
+easy_data_loader-0.1.0.dist-info/licenses/LICENSE,sha256=zMCK-7LtJpSF-qQw0A1-t9a6N3F49e36vI3bh1Klvlk,1070
+easy_data_loader-0.1.0.dist-info/METADATA,sha256=sv99uwRor2gXojTwrUvH1dWNuQR_gLuO12Bq_HOcl54,1856
+easy_data_loader-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+easy_data_loader-0.1.0.dist-info/entry_points.txt,sha256=o0rWYa-lvUmVnX_rBRTcr1UQRG8aJWDdA_BdDhX-pug,58
+easy_data_loader-0.1.0.dist-info/top_level.txt,sha256=YsMeo8e9snRg9aEw7rSdLL0zFuaGCJOEzAh7TiJkloc,17
+easy_data_loader-0.1.0.dist-info/RECORD,,

easy_data_loader-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

easy_data_loader-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+easy-loader = easy_data_loader.cli:main

easy_data_loader-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Bojoi Gabriel
+
+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.

easy_data_loader-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+easy_data_loader