data-transfer-lib 0.1.1__py3-none-any.whl

data_transfer_lib/__init__.py

@@ -0,0 +1,11 @@
+"""
+Data Transfer Library для трансфера данных между БД с использованием PySpark
+"""
+
+from data_transfer_lib.connections.postgres import Postgres
+from data_transfer_lib.connections.clickhouse import ClickHouse
+from data_transfer_lib.reader.reader import Reader
+from data_transfer_lib.writer.writer import Writer
+
+__version__ = "0.1.0"
+__all__ = ["Postgres", "ClickHouse", "Reader", "Writer"]

data_transfer_lib/connections/__init__.py

@@ -0,0 +1,4 @@
+from data_transfer_lib.connections.postgres import Postgres
+from data_transfer_lib.connections.clickhouse import ClickHouse
+
+__all__ = ["Postgres", "ClickHouse"]

data_transfer_lib/connections/base.py

@@ -0,0 +1,39 @@
+from abc import ABC, abstractmethod
+from typing import Optional, Dict, Any
+from pyspark.sql import SparkSession
+
+class BaseConnection(ABC):
+    def __init__(
+        self,
+        host: str,
+        port: int,
+        user: str,
+        password: str,
+        database: Optional[str] = None,
+        spark: Optional[SparkSession] = None,
+    ):
+        self.host = host
+        self.port = port
+        self.user = user
+        self.password = password
+        self.database = database
+        self.spark = spark or self._get_or_create_spark()
+    
+    @abstractmethod
+    def get_jdbc_url(self) -> str:
+        pass
+    
+    @abstractmethod
+    def get_connection_properties(self) -> Dict[str, str]:
+        pass
+    
+    @abstractmethod
+    def test_connection(self) -> bool:
+        pass
+    
+    @abstractmethod
+    def get_table_schema(self, db_name: str, table_name: str) -> Dict[str, Any]:
+        pass
+    
+    def _get_or_create_spark(self) -> SparkSession:
+        return SparkSession.builder.getOrCreate()

data_transfer_lib/connections/clickhouse.py

@@ -0,0 +1,67 @@
+from typing import Dict, Any, Optional
+from pyspark.sql import SparkSession
+from data_transfer_lib.connections.base import BaseConnection
+
+
+class ClickHouse(BaseConnection):
+    def __init__(
+        self,
+        host: str,
+        user: str,
+        password: str,
+        database: str = "default",
+        port: int = 8123,
+        spark: Optional[SparkSession] = None
+    ):
+        super().__init__(
+            host=host,
+            port=port,
+            user=user,
+            password=password,
+            database=database,
+            spark=spark,
+        )
+    
+    def get_jdbc_url(self) -> str:
+        return f"jdbc:clickhouse://{self.host}:{self.port}/{self.database}"
+    
+    def get_connection_properties(self) -> Dict[str, str]:
+        return {
+            "user": self.user,
+            "password": self.password,
+            "driver": "com.clickhouse.jdbc.ClickHouseDriver"
+        }
+    
+    def test_connection(self) -> bool:
+        return True
+    
+    def get_table_schema(self, db_name: str, table_name: str) -> Dict[str, Any]:
+        schema_query = f"""
+            SELECT 
+                name,
+                type
+            FROM system.columns
+            WHERE database = '{db_name}' 
+                AND table = '{table_name}'
+            ORDER BY position
+        """
+
+        # TODO: try -> except
+        schema_df = (
+            self.spark.read
+            .format("jdbc")
+            .option("url", self.get_jdbc_url())
+            .option("query", schema_query)
+            .option("user", self.user)
+            .option("password", self.password)
+            .option("driver", "com.clickhouse.jdbc.ClickHouseDriver")
+            .load()
+        )
+
+        schema_dict: Dict[str, str] = {}
+        for row in schema_df.collect():
+            column_name = row['name']
+            column_type = row['type']
+            schema_dict[column_name] = column_type
+        
+        return schema_dict

data_transfer_lib/connections/postgres.py

@@ -0,0 +1,82 @@
+from typing import Dict, Any, Optional
+from pyspark.sql import SparkSession
+from data_transfer_lib.connections.base import BaseConnection
+
+
+class Postgres(BaseConnection):
+    def __init__(
+        self,
+        host: str,
+        user: str,
+        password: str,
+        database: str = "postgres",
+        port: int = 5432,
+        spark: Optional[SparkSession] = None,
+    ):
+        super().__init__(
+            host=host,
+            port=port,
+            user=user,
+            password=password,
+            database=database,
+            spark=spark,
+        )
+    
+    def get_jdbc_url(self) -> str:
+        return f"jdbc:postgresql://{self.host}:{self.port}/{self.database}"
+    
+    def get_connection_properties(self) -> Dict[str, str]:
+        return {
+            "user": self.user,
+            "password": self.password,
+            "driver": "org.postgresql.Driver"
+        }
+    
+    def test_connection(self) -> bool:
+        print("Проверка подключения к PostgreSQL")
+        return True
+    
+    def get_table_schema(self, db_name: str, table_name: str) -> Dict[str, Any]:
+
+        schema_query = f"""
+            SELECT 
+                column_name,
+                data_type,
+                character_maximum_length,
+                numeric_precision,
+                numeric_scale
+            FROM information_schema.columns
+            WHERE table_schema = '{db_name}' 
+                AND table_name = '{table_name}'
+            ORDER BY ordinal_position
+        """
+
+        # TODO: try -> except 
+
+        schema_df = ( 
+            self.spark.read
+            .format("jdbc")
+            .option("url", self.get_jdbc_url())
+            .option("query", schema_query)
+            .option("user", self.user)
+            .option("password", self.password)
+            .option("driver", "org.postgresql.Driver")
+            .load()
+        )
+
+        schema_dict = {}
+        for row in schema_df.collect():
+            column_name = row['column_name']
+            data_type = row['data_type']
+            
+            # Add precision and scale
+            if data_type in ('numeric', 'decimal') and row['numeric_precision']:
+                data_type = f"{data_type}({row['numeric_precision']},{row['numeric_scale']})"
+
+            # Add max_length
+            elif data_type in ('character varying', 'varchar') and row['character_maximum_length']:
+                data_type = f"varchar({row['character_maximum_length']})"
+            
+            schema_dict[column_name] = data_type
+        
+        return schema_dict

data_transfer_lib/reader/__init__.py

@@ -0,0 +1,3 @@
+from data_transfer_lib.reader.reader import Reader
+
+__all__ = ["Reader"]

data_transfer_lib/reader/base.py

@@ -0,0 +1,25 @@
+from abc import ABC, abstractmethod
+from typing import Optional, Any
+from pyspark.sql import DataFrame
+from data_transfer_lib.connections.base import BaseConnection
+
+
+class BaseReader(ABC):
+    def __init__(
+        self,
+        connection: BaseConnection,
+        db_name: str,
+        table_name: str,
+    ):
+        self.connection = connection
+        self.db_name = db_name
+        self.table_name = table_name
+        self._prepare()
+    
+    @abstractmethod
+    def _prepare(self) -> None:
+        pass
+    
+    @abstractmethod
+    def start(self) -> DataFrame:
+        pass

data_transfer_lib/reader/reader.py

@@ -0,0 +1,43 @@
+from pyspark.sql import DataFrame
+from data_transfer_lib.reader.base import BaseReader
+from data_transfer_lib.connections.base import BaseConnection
+from data_transfer_lib.schema.validator import SchemaValidator
+
+class Reader(BaseReader):
+    def __init__(
+        self,
+        connection: BaseConnection,
+        db_name: str,
+        table_name: str,
+    ):
+        self.source_schema = None
+        super().__init__(
+            connection=connection,
+            db_name=db_name,
+            table_name=table_name,
+        )
+    
+    def _prepare(self) -> None:
+        self.source_schema = self.connection.get_table_schema(
+            self.db_name,
+            self.table_name
+        )
+        
+        SchemaValidator.validate_source_to_spark(self.source_schema)
+    
+    def start(self) -> DataFrame:
+
+        table_name = f"{self.db_name}.{self.table_name}"
+        
+        reader = (
+            self.connection
+            .spark.read
+            .format("jdbc")
+            .option("url", self.connection.get_jdbc_url())
+            .option("dbtable", table_name)
+            .option("user", self.connection.user)
+            .option("password", self.connection.password)
+            .option("driver", self.connection.get_connection_properties()["driver"])
+        )
+        df = reader.load()
+        return df

data_transfer_lib/schema/__init__.py

@@ -0,0 +1,4 @@
+from data_transfer_lib.schema.mapper import TypeMapper
+from data_transfer_lib.schema.validator import SchemaValidator
+
+__all__ = ["TypeMapper", "SchemaValidator"]

data_transfer_lib/schema/mapper.py

@@ -0,0 +1,241 @@
+from typing import Dict, Any
+from pyspark.sql.types import DataType
+
+
+class TypeMapper:
+    POSTGRES_TO_SPARK = {
+        # Boolean
+        "boolean": "BooleanType",
+        "bool": "BooleanType",
+        
+        # Integer types
+        "smallint": "ShortType",
+        "int2": "ShortType",
+        "smallserial": "ShortType",
+        "serial2": "ShortType",
+        
+        "integer": "IntegerType",
+        "int": "IntegerType",
+        "int4": "IntegerType",
+        "serial": "IntegerType",
+        "serial4": "IntegerType",
+        
+        "bigint": "LongType",
+        "int8": "LongType",
+        "bigserial": "LongType",
+        "serial8": "LongType",
+        
+        # Floating point
+        "real": "FloatType",
+        "float4": "FloatType",
+        "double precision": "DoubleType",
+        "float8": "DoubleType",
+        # float и float(p) обрабатываются отдельно
+        
+        # Numeric/Decimal
+        "numeric": "DecimalType",
+        "decimal": "DecimalType",
+        
+        # String types
+        "character varying": "StringType",  # varchar
+        "varchar": "StringType",
+        "character": "StringType",  # char
+        "char": "StringType",
+        "bpchar": "StringType",
+        "text": "StringType",
+        
+        # Binary
+        "bytea": "BinaryType",
+        
+        # Date/Time
+        "date": "DateType",
+        "timestamp": "TimestampType",
+        "timestamp without time zone": "TimestampType",
+        "timestamp with time zone": "TimestampType",
+        "timestamptz": "TimestampType",
+        "time": "TimestampType",
+        "time without time zone": "TimestampType",
+        "time with time zone": "TimestampType",
+        "timetz": "TimestampType",
+        
+        # Interval
+        "interval": "StringType",
+        
+        # Monetary
+        "money": "StringType",
+        
+        # Network Address Types
+        "inet": "StringType",
+        "cidr": "StringType",
+        "macaddr": "StringType",
+        "macaddr8": "StringType",
+        
+        # Geometric Types
+        "point": "StringType",
+        "line": "StringType",
+        "lseg": "StringType",
+        "box": "StringType",
+        "path": "StringType",
+        "polygon": "StringType",
+        "circle": "StringType",
+        
+        # Log Sequence Number
+        "pg_lsn": "StringType",
+        
+        # Bit types handled separately (bit(1) -> BooleanType, bit(>1) -> BinaryType)
+        
+        # Text Search Types
+        "tsvector": "StringType",
+        "tsquery": "StringType",
+        
+        # UUID
+        "uuid": "StringType",
+        
+        # XML
+        "xml": "StringType",
+        
+        # JSON
+        "json": "StringType",
+        "jsonb": "StringType",
+        
+        # Range Types
+        "int4range": "StringType",
+        "int8range": "StringType",
+        "numrange": "StringType",
+        "tsrange": "StringType",
+        "tstzrange": "StringType",
+        "daterange": "StringType",
+        
+        # Object Identifier Types
+        "oid": "DecimalType",
+        "regproc": "StringType",
+        "regprocedure": "StringType",
+        "regoper": "StringType",
+        "regoperator": "StringType",
+        "regclass": "StringType",
+        "regtype": "StringType",
+        "regrole": "StringType",
+        "regnamespace": "StringType",
+        "regconfig": "StringType",
+        "regdictionary": "StringType",
+        
+        # Pseudo types
+        "void": "NullType",
+        
+        # ENUM types map to StringType
+        # Array types map to ArrayType
+        # Composite types map to StringType
+    }
+    
+    SPARK_TO_CLICKHOUSE = {
+        "IntegerType": "Int32",
+        "LongType": "Int64",
+        "ShortType": "Int16",
+        "DecimalType": "Decimal",
+        "FloatType": "Float32",
+        "DoubleType": "Float64",
+        "StringType": "String",
+        "TimestampType": "DateTime",
+        "DateType": "Date",
+        "BooleanType": "UInt8",
+    }
+
+    
+    @classmethod
+    def postgres_to_spark(cls, pg_type: str) -> str:
+        base_type, params = cls._parse_pg_type(pg_type)
+        
+        # float(p) - depends on precision
+        if base_type == "float":
+            if params and len(params) > 0:
+                p = int(params[0])
+                if 1 <= p <= 24:
+                    return "FloatType"
+                elif 25 <= p <= 53:
+                    return "DoubleType"
+            return "DoubleType"
+        
+        # bit types
+        if base_type == "bit":
+            if params and len(params) > 0:
+                n = int(params[0])
+                if n == 1:
+                    return "BooleanType"
+                else:
+                    return "BinaryType"
+            else:
+                # bit(1)
+                return "BooleanType"
+        
+        if base_type == "bit varying" or base_type == "varbit":
+            return "BinaryType"
+        
+        if base_type in ("character varying", "varchar") and params:
+            return f"VarcharType({params[0]})"
+        
+        if base_type in ("character", "char") and params:
+            return f"CharType({params[0]})"
+        
+        # numeric(p, s) / decimal(p, s)
+        if base_type in ("numeric", "decimal"):
+            if params and len(params) >= 1:
+                p = int(params[0])
+                s = int(params[1]) if len(params) > 1 else 0
+                
+                # PostgreSQL 15+: if s < 0
+                if s < 0:
+                    adjusted_p = min(p - s, 38)
+                    return f"DecimalType({adjusted_p}, 0)"
+                
+                # If p > 38, the fraction part will be truncated if exceeded
+                if p > 38:
+                    # TODO: if any value of this column have an actual precision greater 38
+                    # will fail with NUMERIC_VALUE_OUT_OF_RANGE.WITHOUT_SUGGESTION error.
+                    return f"DecimalType(38, {min(s, 38)})"
+                
+                return f"DecimalType({p}, {s})"
+            else:
+                return "DecimalType(38, 0)"
+        
+        if base_type == "oid":
+            return "DecimalType(20, 0)"
+        
+        if base_type.endswith("[]"):
+            element_type = base_type[:-2]
+            element_spark_type = cls.postgres_to_spark(element_type)
+            return f"ArrayType({element_spark_type})"
+        
+        # Other mapping - OK
+        spark_type = cls.POSTGRES_TO_SPARK.get(base_type.lower())
+        
+        if spark_type:
+            return spark_type
+        
+        # TODO: Exception for inknown type of PostgreSQL -> now to StringType
+        return "StringType"
+    
+    @staticmethod
+    def _parse_pg_type(pg_type: str) -> tuple:
+        """
+        Args:
+            pg_type: For example "varchar(100)", "numeric(10,2)", "bit(5)"
+        Returns:
+            (base_type, [params]) - For example ("varchar", ["100"]), ("numeric", ["10", "2"])
+        """
+        pg_type = pg_type.strip().lower()
+        
+        if "(" in pg_type and ")" in pg_type:
+            base_type = pg_type[:pg_type.index("(")].strip()
+            params_str = pg_type[pg_type.index("(") + 1:pg_type.rindex(")")].strip()
+            params = [p.strip() for p in params_str.split(",")]
+            return base_type, params
+        else:
+            return pg_type, []
+    
+    @classmethod
+    def spark_to_clickhouse(cls, spark_type: str) -> str:
+        return cls.SPARK_TO_CLICKHOUSE.get(spark_type, "String")
+    
+    @classmethod
+    def validate_mapping(cls, source_type: str, target_type: str) -> bool:
+        return True

data_transfer_lib/schema/validator.py

@@ -0,0 +1,107 @@
+from typing import Dict, Any
+from pyspark.sql import DataFrame
+from data_transfer_lib.utils.exceptions import SchemaValidationException
+from data_transfer_lib.schema.mapper import TypeMapper
+
+
+class SchemaValidator:
+
+    @staticmethod
+    def validate_source_to_spark(source_schema: Dict[str, Any]) -> bool:    
+            
+        unsupported_types: list[str] = []
+        
+        for column, pg_type in source_schema.items():
+            base_type = pg_type.split('(')[0].strip().lower()
+            spark_type = TypeMapper.postgres_to_spark(base_type)
+            
+            # TODO: do it with flag
+            if spark_type == "StringType" and base_type not in TypeMapper.POSTGRES_TO_SPARK:
+                unsupported_types.append(f"{column}: {pg_type}")
+        
+        if unsupported_types:
+            error_msg = f"Error:\n Unsupported types detected: {', '.join(unsupported_types)}"
+            raise SchemaValidationException(error_msg)
+        
+        return True
+    
+    @staticmethod
+    def validate_spark_to_target(df_schema: Dict[str, Any], target_schema: Dict[str, Any]) -> bool:
+        
+        errors: list[str] = []
+        warnings: list[str] = []
+        
+        # Check for missing columns
+        df_columns = set(df_schema.keys())
+        target_columns = set(target_schema.keys())
+        missing_columns = df_columns - target_columns
+        if missing_columns:
+            errors.append(f"Missing columns: {missing_columns}")
+        
+        # Check type compatibility for common columns
+        for column_name in df_columns & target_columns:
+            spark_type = df_schema[column_name]
+            target_type = target_schema[column_name]
+            
+            is_compatible, message = SchemaValidator._check_type_compatibility(
+                column_name, spark_type, target_type
+            )
+            
+            if not is_compatible:
+                errors.append(message)
+            elif message:
+                warnings.append(message)
+        
+
+        for warning in warnings:
+            print(f"Warnings: {warning}")
+        
+        if errors:
+            error_msg = "Uncompatible schemas:\n" + "\n".join(errors)
+            print(f"Error: {error_msg}")
+            raise SchemaValidationException(error_msg)
+        
+        print("Validation is succed")
+        return True
+    
+    @staticmethod
+    def compare_schemas(source_schema: Dict[str, Any], target_schema: Dict[str, Any]) -> Dict[str, Any]:
+        return {}
+    
+    # TODO: it's easy type checkin, need to be customized
+    @staticmethod
+    def _check_type_compatibility(column: str, spark_type: str, target_type: str) -> tuple[bool, str]:
+
+        # Check for numeric types compatibility
+        spark_numeric_types = {
+            "IntegerType", "LongType", "ShortType",
+            "DecimalType", "FloatType", "DoubleType"
+        }
+        is_spark_type_numeric = any(t in spark_type for t in spark_numeric_types)
+
+        target_numeric_types = {
+            "Int8", "Int16", "Int32", "Int64",
+            "UInt8", "UInt16", "UInt32", "UInt64",
+            "Float32", "Float64"
+        }
+        is_target_type_numeric = any(t in target_type for t in target_numeric_types)
+        
+        if is_spark_type_numeric and is_target_type_numeric:
+            return (True, "")
+        
+        # Check for string types compatibility
+        if "String" in spark_type and "String" in target_type:
+            return (True, "")
+        
+        # Check for date types compatibility
+        if "Timestamp" in spark_type and "DateTime" in target_type:
+            return (True, "")
+        if "Date" in spark_type and "Date" in target_type:
+            return (True, "")
+        
+        # Check for decimal types compatibility
+        if "Decimal" in spark_type and "Decimal" in target_type:
+            return (True, "")
+        
+        # Types are not compatible
+        return (False, f"Column '{column}': uncompatible types ({spark_type} -> {target_type})")

data_transfer_lib/utils/__init__.py

@@ -0,0 +1,13 @@
+from data_transfer_lib.utils.exceptions import (
+    DataTransferException,
+    ConnectionException,
+    SchemaValidationException,
+    TypeMappingException
+)
+
+__all__ = [
+    "DataTransferException",
+    "ConnectionException",
+    "SchemaValidationException",
+    "TypeMappingException"
+]

data_transfer_lib/utils/exceptions.py

@@ -0,0 +1,14 @@
+class DataTransferException(Exception):
+    pass
+
+
+class ConnectionException(DataTransferException):
+    pass
+
+
+class SchemaValidationException(DataTransferException):
+    pass
+
+
+class TypeMappingException(DataTransferException):
+    pass

data_transfer_lib/writer/__init__.py

@@ -0,0 +1,3 @@
+from data_transfer_lib.writer.writer import Writer
+
+__all__ = ["Writer"]

data_transfer_lib/writer/base.py

@@ -0,0 +1,27 @@
+from abc import ABC, abstractmethod
+from pyspark.sql import DataFrame
+from data_transfer_lib.connections.base import BaseConnection
+
+
+class BaseWriter(ABC):
+    def __init__(
+        self,
+        connection: BaseConnection,
+        db_name: str,
+        table_name: str,
+        if_exists: bool = True,
+    ):
+        self.connection = connection
+        self.db_name = db_name
+        self.table_name = table_name
+        self.if_exists = if_exists
+        
+        self._prepare()
+    
+    @abstractmethod
+    def _prepare(self) -> None:
+        pass
+    
+    @abstractmethod
+    def start(self, df: DataFrame, **params) -> None:
+        pass

data_transfer_lib/writer/writer.py

@@ -0,0 +1,72 @@
+from pyspark.sql import DataFrame
+from data_transfer_lib.writer.base import BaseWriter
+from data_transfer_lib.connections.base import BaseConnection
+from data_transfer_lib.schema.validator import SchemaValidator
+
+
+class Writer(BaseWriter):
+    def __init__(
+        self,
+        connection: BaseConnection,
+        db_name: str,
+        table_name: str,
+        if_exists: bool = True,
+    ):
+        self.target_schema = None
+        super().__init__(
+            connection=connection,
+            db_name=db_name,
+            table_name=table_name,
+            if_exists=if_exists,
+        )
+    
+    def _prepare(self) -> None:
+        
+        if self.if_exists:
+            self.target_schema = self.connection.get_table_schema(
+                self.db_name,
+                self.table_name
+            )
+            print(self.target_schema)
+        else:
+            error_msg = f"{self.db_name}.{self.table_name} table does't exist"
+            raise DataTransferException(error_msg)
+    
+    def start(self, df: DataFrame, **params) -> None:
+
+        df_schema = {}
+        for field in df.schema.fields:
+            df_schema[field.name] = str(field.dataType)
+
+        try:
+            SchemaValidator.validate_spark_to_target(
+                df_schema,
+                self.target_schema
+            )
+        except SchemaValidationException as e:
+            print(f"Error: {e}")
+            raise
+        
+        try:
+            if num_partitions := params.get("num_partitions", None):
+                df = df.repartition(num_partitions)
+            
+            full_table_name = f"{self.db_name}.{self.table_name}"
+            
+            writer = (
+                df.write
+                .format("jdbc")
+                .option("url", self.connection.get_jdbc_url())
+                .option("dbtable", full_table_name)
+                .option("user", self.connection.user)
+                .option("password", self.connection.password)
+                .option("driver", self.connection.get_connection_properties()["driver"])
+                .option("batchsize", params.get("batch_size", 10000))
+                .mode(params.get("mode", "append"))
+            )
+            
+            writer.save()
+            
+        except Exception as e:
+            raise ConnectionException(f"Couldn't write int table: {e}")
+        

data_transfer_lib-0.1.1.dist-info/METADATA

@@ -0,0 +1,30 @@
+Metadata-Version: 2.4
+Name: data-transfer-lib
+Version: 0.1.1
+Summary: Library for data transfer between databases using PySpark
+Home-page: https://github.com/llirkh/data_transfer_lib
+Author: llirikh
+Author-email: zhukov.kg@phystech.edu
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Database
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: pyspark>=3.3.0
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# Project description
+
+Project description will be here

data_transfer_lib-0.1.1.dist-info/RECORD

@@ -0,0 +1,20 @@
+data_transfer_lib/__init__.py,sha256=n1XAEEQnXfoHFgAFXO_0dI7x0103G_ofnJhjrBqW4cM,431
+data_transfer_lib/connections/__init__.py,sha256=95_Il7sIDU7UIoRJ5mDLdjK1nyBkO-zva_Bfvj7AyPI,161
+data_transfer_lib/connections/base.py,sha256=j041jyzNv45WKZk5nFrJBeuJXo8aCZVwD3loZTq61XM,1016
+data_transfer_lib/connections/clickhouse.py,sha256=zL_KRUODF3FIjaZzxADWUXD_KSaxmAC41TicS_P6jAc,1941
+data_transfer_lib/connections/postgres.py,sha256=sPJM-Y_ujo5KJTDOJ6Y9ysK-J0p8CDU6k198-n8Fkxw,2570
+data_transfer_lib/reader/__init__.py,sha256=SA4HFp20RKcFy1idtPOE0a86V2wgcIP7ljzRYfnfVUc,72
+data_transfer_lib/reader/base.py,sha256=VNU4-4MoDvVui10fU6IJMI6xHl0YxXLuz5gHua82kKA,582
+data_transfer_lib/reader/reader.py,sha256=5s3PvUDakTZ6lTiUhEo8hp743ccUE3ovDHMeZj0znSo,1327
+data_transfer_lib/schema/__init__.py,sha256=kxdcCDDtDDB1YpymEzle4Yl2w3nVa6wLW7nAYGVYcpI,162
+data_transfer_lib/schema/mapper.py,sha256=lIXsa7vMP4cG5spruZNX_8sDh95h0ZO59w1j1fo0ne0,7549
+data_transfer_lib/schema/validator.py,sha256=jG4mVRHLaWEg4Ru2Gd_cT65lCRkmiRxF6OpwfF4qZek,3994
+data_transfer_lib/utils/__init__.py,sha256=B8zhVMM1pRM4oRJ1XoMgmE8I8K-0hmP0yu3ONQV1bvQ,289
+data_transfer_lib/utils/exceptions.py,sha256=zJ91uknxGHaxEMZPgjbiPoAw8Nhra3Y-r24iTe8S1J8,238
+data_transfer_lib/writer/__init__.py,sha256=OqrRHW216VAOtFzzOz7jL-H7kxYlfj--8IQs9rOyNgo,72
+data_transfer_lib/writer/base.py,sha256=0qCjWqNWluTCOWJM4xfwRy9TeFsq_LlQLjtkoeOC0Ok,645
+data_transfer_lib/writer/writer.py,sha256=o1fM2dJFExqrYI21hJUiyrHZD2ZOmhFc3kY0Q3gfh1E,2348
+data_transfer_lib-0.1.1.dist-info/METADATA,sha256=BP95JdnRPpKtFbuAg8KD6rQmKp5WLB8UFeA6KF-oYiA,900
+data_transfer_lib-0.1.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+data_transfer_lib-0.1.1.dist-info/top_level.txt,sha256=Yz0tNpzxGcQmSb1vBGHge5Ab5IoaBa_5pzSMlyxusII,18
+data_transfer_lib-0.1.1.dist-info/RECORD,,

data_transfer_lib-0.1.1.dist-info/WHEEL

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

data_transfer_lib-0.1.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+data_transfer_lib