tapdata-sdk 0.1.0__py3-none-any.whl

tapdata_sdk/__init__.py

@@ -0,0 +1,55 @@
+"""
+Tapdata Python SDK
+A Python client library for interacting with Tapdata API.
+Examples:
+    >>> from tapdata_sdk import TapdataClient, ConnectionType, Status
+    >>> 
+    >>> # Initialize client
+    >>> client = TapdataClient("http://localhost:3030")
+    >>> 
+    >>> # Login
+    >>> client.login("admin@test.com", "password")
+    >>> 
+    >>> # Query connections
+    >>> connections = client.connections.list(connection_type=ConnectionType.SOURCE)
+    >>> 
+    >>> # Query tasks
+    >>> tasks = client.tasks.list_running()
+    >>> 
+    >>> # Operate tasks
+    >>> client.tasks.stop(tasks[0].id)
+"""
+from .client import TapdataClient, ConnectionClient, TaskClient
+from .models import Connection, Task, TaskLog
+from .enums import ConnectionType, DatabaseType, Status, LogLevel
+from .exceptions import (
+    TapdataError,
+    TapdataAuthError,
+    TapdataConnectionError,
+    TapdataValidationError,
+    TapdataTimeoutError,
+)
+
+__version__ = "0.2.0"
+
+__all__ = [
+    # Client
+    "TapdataClient",
+    "ConnectionClient",
+    "TaskClient",
+    # Models
+    "Connection",
+    "Task",
+    "TaskLog",
+    # Enums
+    "ConnectionType",
+    "DatabaseType",
+    "Status",
+    "LogLevel",
+    # Exceptions
+    "TapdataError",
+    "TapdataAuthError",
+    "TapdataConnectionError",
+    "TapdataValidationError",
+    "TapdataTimeoutError",
+]

tapdata_sdk/client.py

@@ -0,0 +1,492 @@
+"""Tapdata API Client"""
+import logging
+from typing import Dict, List, Optional, Union
+from urllib.parse import urljoin
+import urllib.parse
+import json as jsonx
+import time
+
+import requests
+
+from .exceptions import (
+    TapdataAuthError,
+    TapdataConnectionError,
+    TapdataError,
+    TapdataTimeoutError,
+)
+from .models import Connection, Task, TaskDetail, TaskLog
+from .utils import rc4_encrypt, gen_sign, build_filter
+from .enums import ConnectionType, DatabaseType, Status, LogLevel
+
+
+logger = logging.getLogger(__name__)
+
+
+class TapdataClient:
+    """
+    Tapdata API Client
+    
+    Examples:
+        >>> client = TapdataClient("http://localhost:3030")
+        >>> client.login("admin@test.com", "password")
+        >>> connections = client.connections.list()
+        >>> tasks = client.tasks.list()
+    """
+    
+    DEFAULT_TIMEOUT = 30
+    DEFAULT_SECRET = "Gotapd8"
+    
+    def __init__(
+        self,
+        base_url: str,
+        access_token: Optional[str] = None,
+        timeout: int = DEFAULT_TIMEOUT,
+        verify_ssl: bool = True,
+    ):
+        """
+        Initialize client
+        
+        Args:
+            base_url: API base URL
+            access_token: Access token (optional)
+            timeout: Request timeout in seconds
+            verify_ssl: Whether to verify SSL certificate
+        """
+        self.base_url = base_url.rstrip("/")
+        self.access_token = access_token
+        self.timeout = timeout
+        self.verify_ssl = verify_ssl
+        self.session = requests.Session()
+        
+        # Initialize sub-clients
+        self.connections = ConnectionClient(self)
+        self.tasks = TaskClient(self)
+    
+    def _build_url(self, path: str) -> str:
+        """Build complete URL"""
+        return urljoin(self.base_url, path)
+    
+    def _request(
+        self,
+        method: str,
+        path: str,
+        params: Optional[dict] = None,
+        json: Optional[dict] = None,
+        **kwargs,
+    ) -> dict:
+        """
+        Send HTTP request
+        
+        Args:
+            method: HTTP method
+            path: API path
+            params: URL parameters
+            json: JSON request body
+            **kwargs: Other request parameters
+            
+        Returns:
+            Response data
+            
+        Raises:
+            TapdataError: API error
+            TapdataTimeoutError: Request timeout
+            TapdataConnectionError: Connection error
+        """
+        params = params or {}
+        
+        # Add access_token
+        url = self._build_url(path)
+        if self.access_token:
+            params["access_token"] = self.access_token
+        
+        if params.get('filter'):
+           filter_str = jsonx.dumps(params.get('filter'), separators=(',', ':'))
+           params['filter'] = filter_str
+        
+        try:
+            logger.debug(f"Request: {method} {url}")
+            
+            resp = self.session.request(
+                method=method,
+                url=url,
+                params=params,
+                json=json,
+                timeout=kwargs.get("timeout", self.timeout),
+                verify=self.verify_ssl,
+                **{k: v for k, v in kwargs.items() if k != "timeout"},
+            )
+            resp.raise_for_status()
+            
+            data = resp.json()
+            
+            # Check business status code
+            if data.get("code") != "ok":
+                error_code = data.get("code")
+                if error_code in ["UNAUTHORIZED", "FORBIDDEN"]:
+                    raise TapdataAuthError(data)
+                raise TapdataError(data)
+            
+            logger.debug(f"Response: {data.get('code')}")
+            return data
+            
+        except requests.exceptions.Timeout as e:
+            raise TapdataTimeoutError({"message": f"Request timeout: {e}"})
+        except requests.exceptions.ConnectionError as e:
+            raise TapdataConnectionError({"message": f"Connection error: {e}"})
+        except requests.exceptions.RequestException as e:
+            raise TapdataError({"message": f"Request failed: {e}"})
+    
+    def get_timestamp(self) -> int:
+        """
+        Get server timestamp
+        
+        Returns:
+            Server timestamp
+        """
+        resp = self._request("GET", "/api/timeStamp")
+        return resp["data"]
+    
+    def login(
+        self,
+        email: str,
+        password: str,
+        secret: str = DEFAULT_SECRET,
+    ) -> str:
+        """
+        User login
+        
+        Args:
+            email: Email
+            password: Password (plain text)
+            secret: Encryption secret key
+            
+        Returns:
+            Access token
+            
+        Examples:
+            >>> client = TapdataClient("http://localhost:3030")
+            >>> token = client.login("admin@test.com", "password")
+        """
+        stime = self.get_timestamp()
+        enc_pwd = rc4_encrypt(password, secret)
+        sign = gen_sign(email, enc_pwd, stime, secret)
+        
+        resp = self._request(
+            "POST",
+            "/api/users/login",
+            json={
+                "email": email,
+                "password": enc_pwd,
+                "sign": sign,
+            },
+        )
+        
+        self.access_token = resp["data"]["id"]
+        logger.info(f"Login successful: {email}")
+        
+        return self.access_token
+    
+    def logout(self) -> None:
+        """Logout"""
+        self.access_token = None
+        self.session.close()
+        self.session = requests.Session()
+        logger.info("Logged out")
+    
+    def is_authenticated(self) -> bool:
+        """Check if authenticated"""
+        return self.access_token is not None
+
+
+class ConnectionClient:
+    """Connection management client"""
+    
+    def __init__(self, client: TapdataClient):
+        self.client = client
+    
+    def list(
+        self,
+        connection_type: Optional[Union[str, ConnectionType]] = None,
+        database_type: Optional[Union[str, DatabaseType]] = None,
+        status: Optional[Union[str, Status]] = None,
+        name: Optional[str] = None,
+        skip: int = 0,
+        limit: int = 20,
+    ) -> List[Connection]:
+        """
+        Query connection list
+        
+        Args:
+            connection_type: Connection type
+            database_type: Database type
+            status: Status
+            skip: Number of records to skip
+            limit: Limit on number of results
+            
+        Returns:
+            Connection list
+            
+        Examples:
+            >>> connections = client.connections.list(
+            ...     connection_type=ConnectionType.SOURCE,
+            ...     database_type=DatabaseType.MYSQL
+            ... )
+        """
+        where = {"createType": {"$ne": "System"}}
+        order = "last_updated DESC"
+        
+        if connection_type:
+            where["connection_type"] = str(connection_type)
+        if database_type:
+            where["database_type"] = str(database_type)
+        if status:
+            where["status"] = str(status)
+        if name:
+            where["name"] = {"like":str(name),"options":"i"}
+        
+        resp = self.client._request(
+            "GET",
+            "/api/Connections",
+            params={"filter": build_filter(order=order, skip=skip, limit=limit, where=where)},
+        )
+        
+        return [Connection.from_dict(item) for item in resp["data"]["items"]]
+    
+    def get(self, connection_id: str) -> Connection:
+        """
+        Get single connection details
+        
+        Args:
+            connection_id: Connection ID
+            
+        Returns:
+            Connection object
+        """
+        resp = self.client._request("GET", f"/api/Connections/{connection_id}")
+        return Connection.from_dict(resp["data"])
+    
+    def list_source(self) -> List[Connection]:
+        """Get all source connections"""
+        return self.list(connection_type=ConnectionType.SOURCE)
+    
+    def list_target(self) -> List[Connection]:
+        """Get all target connections"""
+        return self.list(connection_type=ConnectionType.TARGET)
+    
+    def list_mysql(self) -> List[Connection]:
+        """Get all MySQL connections"""
+        return self.list(database_type=DatabaseType.MYSQL)
+    
+    def list_clickhouse(self) -> List[Connection]:
+        """Get all ClickHouse connections"""
+        return self.list(database_type=DatabaseType.CLICKHOUSE)
+    
+    def list_mongodb(self) -> List[Connection]:
+        """Get all MongoDB connections"""
+        return self.list(database_type=DatabaseType.MONGODB)
+    
+    def list_valid(self) -> List[Connection]:
+        """Get all valid connections"""
+        return self.list(status=Status.VALID)
+    
+    def list_invalid(self) -> List[Connection]:
+        """Get all invalid connections"""
+        return self.list(status=Status.INVALID)
+
+    def list_testing(self) -> List[Connection]:
+        """Get all testing connections"""
+        return self.list(status=Status.TESTING)
+
+class TaskClient:
+    """Task management client"""
+    
+    def __init__(self, client: TapdataClient):
+        self.client = client
+    
+    def list(
+        self,
+        status: Optional[Union[str, Status]] = None,
+        name: Optional[str] = None,
+        skip: int = 0,
+        limit: int = 20,
+    ) -> List[Task]:
+        """
+        Query task list
+        
+        Args:
+            status: Status filter
+            skip: Number of records to skip
+            limit: Limit on number of results
+            
+        Returns:
+            Task list
+        """
+        where = {}
+        if status:
+            where["status"] = str(status)
+
+        if name:
+            where["name"] = {"like": str(name),"options":"i"}
+        
+        fields = {
+            "id": True,
+            "name": True,
+            "type": True,
+            "status": True,
+            "taskRecordId": True,
+        }
+        
+        resp = self.client._request(
+            "GET",
+            "/api/Task",
+            params={
+                "filter": build_filter(
+                    skip=skip,
+                    limit=limit,
+                    where=where,
+                    fields=fields,
+                )
+            },
+        )
+        
+        return [Task.from_dict(item) for item in resp["data"]["items"]]
+    
+    def get(self, task_id: str) -> TaskDetail:
+        """
+        Get single task details
+        
+        Args:
+            task_id: Task ID
+            
+        Returns:
+            Task object
+        """
+        resp = self.client._request("GET", f"/api/Task/{task_id}")
+        return TaskDetail.from_dict(resp["data"])
+    
+    def list_running(self) -> List[Task]:
+        """Get all running tasks"""
+        return self.list(status=Status.RUNNING)
+
+    def list_error(self) -> List[Task]:
+        """Get all error tasks"""
+        return self.list(status=Status.ERROR)
+    
+    def start(self, task_id: str) -> dict:
+        """
+        Start task
+        
+        Args:
+            task_id: Task ID
+            
+        Returns:
+            Operation result
+        """
+        logger.info(f"Starting task: {task_id}")
+        return self.client._request(
+            "PUT",
+            "/api/Task/batchStart",
+            params={"taskIds": task_id},
+        )
+    
+    def stop(self, task_id: str) -> dict:
+        """
+        Stop task
+        
+        Args:
+            task_id: Task ID
+            
+        Returns:
+            Operation result
+        """
+        logger.info(f"Stopping task: {task_id}")
+        return self.client._request(
+            "PUT",
+            "/api/Task/batchStop",
+            params={"taskIds": task_id},
+        )
+    
+    def reset(self, task_id: str) -> dict:
+        """
+        Reset task
+        
+        Args:
+            task_id: Task ID
+            
+        Returns:
+            Operation result
+        """
+        logger.info(f"Resetting task: {task_id}")
+        return self.client._request(
+            "PATCH",
+            "/api/Task/batchRenew",
+            params={"taskIds": task_id},
+        )
+    
+    def delete(self, task_id: str) -> dict:
+        """
+        Delete task
+        
+        Args:
+            task_id: Task ID
+            
+        Returns:
+            Operation result
+        """
+        logger.warning(f"Deleting task: {task_id}")
+        return self.client._request(
+            "DELETE",
+            "/api/Task/batchDelete",
+            params={"taskIds": task_id},
+        )
+    
+    def get_logs(
+        self,
+        task_id: str,
+        task_record_id: str,
+        start: Optional[int] = None,
+        end: Optional[int] = None,
+        page: int = 1,
+        page_size: int = 20,
+        levels: Optional[List[Union[str, LogLevel]]] = None,
+    ) -> List[TaskLog]:
+        """
+        Get task logs
+        
+        Args:
+            task_id: Task ID
+            task_record_id: Task record ID
+            start: Start timestamp
+            end: End timestamp
+            page: Page number
+            page_size: Items per page
+            levels: Log level filter
+            
+        Returns:
+            Log data
+        """
+        if start is None:
+            start = int(time.time()*1000)-1000
+
+        if end is None:
+            end = start + 2000
+
+        if levels is None:
+            levels = [LogLevel.INFO, LogLevel.WARN, LogLevel.ERROR]
+        
+        resp = self.client._request(
+            "POST",
+            "/api/MonitoringLogs/query",
+            json={
+                "taskId": task_id,
+                "taskRecordId": task_record_id,
+                "start": start,
+                "end": end,
+                "page": page,
+                "pageSize": page_size,
+                "order": "asc",
+                "levels": [str(level) for level in levels],
+            },
+        )
+
+        return [TaskLog.from_dict(item) for item in resp["data"]["items"]]

tapdata_sdk/enums.py

@@ -0,0 +1,58 @@
+"""Enumeration type definitions"""
+from enum import Enum
+
+
+class ConnectionType(str, Enum):
+    """Connection type"""
+    SOURCE = "source"
+    TARGET = "target"
+    
+    def __str__(self):
+        return self.value
+
+
+class DatabaseType(str, Enum):
+    """Database type"""
+    MYSQL = "Mysql"
+    CLICKHOUSE = "Clickhouse"
+    MONGODB = "MongoDB"
+    POSTGRESQL = "PostgreSQL"
+    ORACLE = "Oracle"
+    SQLSERVER = "SQLServer"
+    
+    def __str__(self):
+        return self.value
+
+
+class Status(str, Enum):
+    """Status"""
+    EDIT = "edit"
+    WAIT_START = "wait_start"
+    WAIT_RUN = "wait_run"
+    RUNNING = "running"
+    COMPLETE = "complete"
+    STOPPING = "stopping"
+    STOP = "stop"
+    ERROR = "error"
+    RENEWING = "renewing"
+    RENEW_FAILED = "renew_failed"
+    DELETING = "deleting"
+    DELETE_FAILED = "delete_failed"
+    DELETED = "deleted"
+    VALID = "ready"
+    INVALID = "invalid"
+    TESTING = "testing"
+    
+    def __str__(self):
+        return self.value
+
+
+class LogLevel(str, Enum):
+    """Log level"""
+    INFO = "INFO"
+    WARN = "WARN"
+    ERROR = "ERROR"
+    DEBUG = "DEBUG"
+    
+    def __str__(self):
+        return self.value

tapdata_sdk/exceptions.py

@@ -0,0 +1,31 @@
+"""Exception definitions"""
+
+
+class TapdataError(Exception):
+    """Tapdata API error base class"""
+    
+    def __init__(self, resp: dict):
+        self.resp = resp
+        self.code = resp.get("code", "unknown")
+        self.message = resp.get("message", str(resp))
+        super().__init__(self.message)
+
+
+class TapdataAuthError(TapdataError):
+    """Authentication error"""
+    pass
+
+
+class TapdataConnectionError(TapdataError):
+    """Connection error"""
+    pass
+
+
+class TapdataValidationError(TapdataError):
+    """Validation error"""
+    pass
+
+
+class TapdataTimeoutError(TapdataError):
+    """Timeout error"""
+    pass

tapdata_sdk/models.py

@@ -0,0 +1,168 @@
+"""Data model definitions"""
+from dataclasses import dataclass
+from typing import Optional, List
+
+
+@dataclass
+class Connection:
+    """Connection model"""
+    id: str
+    name: str
+    connection_type: str
+    database_type: Optional[str]
+    status: str
+    endpoint: Optional[str]
+    port: Optional[str]
+    database: Optional[str]
+    user: Optional[str]
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "Connection":
+        """Create connection object from API response"""
+        config = data.get("config", {})
+        uri = config.get("uri")
+        host = config.get("host")
+        
+        return cls(
+            id=data["id"],
+            name=data["name"],
+            connection_type=data["connection_type"],
+            database_type=data.get("database_type"),
+            status=data["status"],
+            endpoint=uri or host,
+            user=config.get("user",""),
+            database=config.get("database",""),
+            port=config.get("port","")
+        )
+
+    def to_dict(self) -> dict:
+        """Convert to dictionary"""
+        return {
+            "id": self.id,
+            "name": self.name,
+            "connection_type": self.connection_type,
+            "database_type": self.database_type,
+            "status": self.status,
+            "endpoint": self.endpoint,
+            "port": self.port,
+            "database": self.database,
+            "user": self.user
+        }
+
+
+@dataclass
+class Task:
+    """Task model"""
+    id: str
+    name: str
+    type: str
+    status: str
+    task_record_id: Optional[str] = None
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "Task":
+        """Create task object from API response"""
+        return cls(
+            id=data["id"],
+            name=data["name"],
+            type=data["type"],
+            status=data["status"],
+            task_record_id=data.get("taskRecordId"),
+        )
+
+    def to_dict(self) -> dict:
+        """Convert to dictionary"""
+        return {
+            "id": self.id,
+            "name": self.name,
+            "type": self.type,
+            "status": self.status,
+            "taskRecordId": self.task_record_id,
+        }
+
+@dataclass
+class TaskDetail:
+    """Task detail model"""
+    id: str
+    name: str
+    type: str
+    status: str
+    task_record_id: str
+    nodes: List[dict]
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "TaskDetail":
+        """Create task object from API response"""
+        nodes = []
+        for node in data.get("dag",{}).get("nodes",[]):
+            attrs = node.get("attrs",{})
+            nodes.append({
+                "id": node.get("id"),
+                "name": node.get("name"),
+                "connectionId": node.get("connectionId"),
+                "connectionName": attrs.get("connectionName"),
+                "connectionType": attrs.get("__connectionType"),
+                "syncObjects": node.get("syncObjects",[])
+            })
+        return cls(
+            id=data["id"],
+            name=data["name"],
+            type=data["type"],
+            status=data["status"],
+            task_record_id=data.get("taskRecordId"),
+            nodes=nodes
+        )
+
+    def to_dict(self) -> dict:
+        """Convert to dictionary"""
+        return {
+            "id": self.id,
+            "name": self.name,
+            "type": self.type,
+            "status": self.status,
+            "taskRecordId": self.task_record_id,
+            "nodes": self.nodes
+        }
+
+
+@dataclass
+class TaskLog:
+    """Task log"""
+    task_id: str
+    task_record_id: str
+    task_name: str
+    node_id: str
+    node_name: str
+    level: str
+    message: str
+    timestamp: int
+    date: str
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "TaskLog":
+        """Create log object from API response"""
+        return cls(
+            task_id=data["taskId"],
+            task_record_id=data["taskRecordId"],
+            task_name=data["taskName"],
+            node_name=data.get("nodeName",""),
+            node_id=data.get("nodeId",""),
+            level=data["level"],
+            message=data["message"],
+            timestamp=data["timestamp"],
+            date=data["date"],
+        )
+
+    def to_dict(self) -> dict:
+        """Convert to dictionary"""
+        return {
+            "task_id": self.task_id,
+            "task_record_id": self.task_record_id,
+            "task_name": self.task_name,
+            "node_id": self.node_id,
+            "node_name": self.node_name,
+            "level": self.level,
+            "message": self.message,
+            "timestamp": self.timestap,
+            "date": self.date
+        }

tapdata_sdk/utils.py

@@ -0,0 +1,110 @@
+"""Utility functions"""
+import base64
+import hashlib
+from typing import Optional
+
+try:
+    from Crypto.Cipher import ARC4
+    from Crypto.Cipher import ARC4
+    from Crypto.Hash import MD5
+    from Crypto import Random
+except ImportError:
+    raise ImportError(
+        "pycryptodome is required. Install it with: pip install pycryptodome"
+    )
+
+
+def encrypt_rc4_cryptojs(plaintext, password):
+    """
+    Simulate CryptoJS.RC4.encrypt behavior
+    Supports OpenSSL-compatible Salted__ format
+    """
+    # 1. Generate random 8-byte salt
+    salt = Random.get_random_bytes(8)
+    
+    # 2. Simulate OpenSSL's key derivation logic (EVP_BytesToKey)
+    password_bytes = password.encode('utf-8')
+    derived_bytes = b""
+    last_hash = b""
+    while len(derived_bytes) < 32:
+        last_hash = MD5.new(last_hash + password_bytes + salt).digest()
+        derived_bytes += last_hash
+    key = derived_bytes[:32]
+    
+    # 3. Perform RC4 encryption
+    cipher = ARC4.new(key)
+    ciphertext = cipher.encrypt(plaintext.encode('utf-8'))
+    
+    # 4. Concatenate format: "Salted__" + salt + ciphertext and convert to Base64
+    final_payload = b'Salted__' + salt + ciphertext
+    return base64.b64encode(final_payload).decode('utf-8')
+
+
+def rc4_encrypt(text: str, key: str) -> str:
+    """
+    Encrypt text using RC4 algorithm
+    
+    Args:
+        text: Text to encrypt
+        key: Encryption key
+        
+    Returns:
+        Base64 encoded encrypted result
+    """
+    return encrypt_rc4_cryptojs(text, key)
+
+
+def gen_sign(email: str, password: str, stime: int, key: str) -> str:
+    """
+    Generate signature
+    
+    Args:
+        email: Email
+        password: Encrypted password
+        stime: Timestamp
+        key: Signature key
+        
+    Returns:
+        SHA1 signature (uppercase)
+    """
+    raw = f"{email}{password}{stime}{key}"
+    return hashlib.sha1(raw.encode()).hexdigest().upper()
+
+
+def build_filter(
+    skip: int = 0,
+    limit: int = 20,
+    where: Optional[dict] = None,
+    fields: Optional[dict] = None,
+    order: Optional[str] = None,
+    noSchema: Optional[int] = 1,
+) -> dict:
+    """
+    Build query filter
+    
+    Args:
+        skip: Number of records to skip
+        limit: Limit on number of results
+        where: Query conditions
+        fields: Field filter
+        order: Sort order
+        
+    Returns:
+        Filter dictionary
+    """
+    filter_dict = {
+        "skip": skip,
+        "limit": limit,
+    }
+    
+    if where:
+        filter_dict["where"] = where
+    
+    if fields:
+        filter_dict["fields"] = fields
+    
+    if order:
+        filter_dict["order"] = order
+    filter_dict["noSchema"] = 1
+    
+    return filter_dict

tapdata_sdk-0.1.0.dist-info/METADATA

@@ -0,0 +1,344 @@
+Metadata-Version: 2.4
+Name: tapdata_sdk
+Version: 0.1.0
+Summary: A Python client library for interacting with Tapdata API
+Author-email: doubled <309294891@qq.com>
+License: MIT
+Project-URL: Homepage, https://github.com/lddlww/tapdata_sdk
+Project-URL: Documentation, https://github.com/lddlww/tapdata_sdk#readme
+Project-URL: Repository, https://github.com/lddlww/tapdata_sdk
+Project-URL: Issues, https://github.com/lddlww/tapdata_sdk/issues
+Keywords: tapdata,api,client,sdk,data-integration
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests>=2.25.0
+Requires-Dist: pycryptodome>=3.10.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0.0; extra == "dev"
+Requires-Dist: pytest-cov>=3.0.0; extra == "dev"
+Requires-Dist: black>=22.0.0; extra == "dev"
+Requires-Dist: isort>=5.10.0; extra == "dev"
+Requires-Dist: flake8>=4.0.0; extra == "dev"
+Requires-Dist: mypy>=0.950; extra == "dev"
+Requires-Dist: types-requests>=2.25.0; extra == "dev"
+Dynamic: license-file
+
+# Tapdata Python SDK
+
+A Python client library for interacting with Tapdata API.
+
+## Features
+
+- 🔐 Complete authentication support
+- 📦 Type-safe data models
+- 🎯 Clean API interface
+- 🔄 Connection and task management
+- 📊 Task log queries
+- ⚠️ Detailed error handling
+- 📝 Comprehensive documentation and type hints
+
+## Installation
+
+```bash
+pip install tapdata_sdk
+```
+
+Or install from source:
+
+```bash
+git clone https://github.com/lddlww/tapdata_sdk.git
+cd tapdata-sdk
+pip install -e .
+```
+
+## Quick Start
+
+### Basic Usage
+
+```python
+from tapdata_sdk import TapdataClient
+
+# Initialize client
+client = TapdataClient("http://localhost:3030")
+
+# Login
+client.login("admin@test.com", "password")
+
+# Query connections
+connections = client.connections.list()
+for conn in connections:
+    print(f"{conn.name}: {conn.status}")
+
+# Query tasks
+tasks = client.tasks.list()
+for task in tasks:
+    print(f"{task.name}: {task.status}")
+```
+
+### Connection Management
+
+```python
+from tapdata_sdk import ConnectionType, DatabaseType, Status
+
+# Query source connections
+source_connections = client.connections.list_source()
+
+# Query MySQL connections
+mysql_connections = client.connections.list_mysql()
+
+# Query valid connections
+valid_connections = client.connections.list_valid()
+
+# Filter using enum types
+connections = client.connections.list(
+    connection_type=ConnectionType.SOURCE,
+    database_type=DatabaseType.MYSQL,
+    status=Status.COMPLETE
+)
+
+# Get single connection details
+connection = client.connections.get("connection_id")
+print(connection.endpoint)
+```
+
+### Task Management
+
+```python
+# Query running tasks
+running_tasks = client.tasks.list_running()
+
+# Query tasks with specific status
+tasks = client.tasks.list(status=Status.RUNNING)
+
+# Get task details
+task = client.tasks.get("task_id")
+
+# Start task
+client.tasks.start("task_id")
+
+# Stop task
+client.tasks.stop("task_id")
+
+# Reset task
+client.tasks.reset("task_id")
+
+# Delete task
+client.tasks.delete("task_id")
+```
+
+### Query Task Logs
+
+```python
+import time
+
+# Get logs from the last hour
+end_time = int(time.time() * 1000)
+start_time = end_time - 3600000  # One hour ago
+
+logs = client.tasks.get_logs(
+    task_id="task_id",
+    task_record_id="record_id",
+    start=start_time,
+    end=end_time,
+    page=1,
+    page_size=20
+)
+```
+
+### Error Handling
+
+```python
+from tapdata_sdk import (
+    TapdataError,
+    TapdataAuthError,
+    TapdataTimeoutError,
+    TapdataConnectionError
+)
+
+try:
+    client.login("admin@test.com", "wrong_password")
+except TapdataAuthError as e:
+    print(f"Authentication failed: {e.message}")
+except TapdataTimeoutError as e:
+    print(f"Request timeout: {e.message}")
+except TapdataConnectionError as e:
+    print(f"Connection error: {e.message}")
+except TapdataError as e:
+    print(f"API error: {e.message}")
+```
+
+### Advanced Configuration
+
+```python
+# Custom timeout and SSL verification
+client = TapdataClient(
+    base_url="https://api.tapdata.io",
+    timeout=60,  # 60 second timeout
+    verify_ssl=False  # Disable SSL verification (not recommended in production)
+)
+
+# Use existing access_token
+client = TapdataClient(
+    base_url="http://localhost:3030",
+    access_token="your-existing-token"
+)
+
+# Check authentication status
+if client.is_authenticated():
+    print("Authenticated")
+
+# Logout
+client.logout()
+```
+
+## API Reference
+
+### TapdataClient
+
+Main client class providing authentication and sub-client access.
+
+**Parameters:**
+- `base_url` (str): API base URL
+- `access_token` (str, optional): Access token
+- `timeout` (int): Request timeout in seconds, default 30
+- `verify_ssl` (bool): Whether to verify SSL certificate, default True
+
+**Methods:**
+- `login(email, password, secret)`: User login
+- `logout()`: Logout
+- `is_authenticated()`: Check if authenticated
+- `get_timestamp()`: Get server timestamp
+
+**Properties:**
+- `connections`: ConnectionClient instance
+- `tasks`: TaskClient instance
+
+### ConnectionClient
+
+Connection management client.
+
+**Methods:**
+- `list(connection_type, database_type, status, skip, limit)`: Query connection list
+- `get(connection_id)`: Get single connection
+- `list_source()`: Get all source connections
+- `list_target()`: Get all target connections
+- `list_mysql()`: Get all MySQL connections
+- `list_clickhouse()`: Get all ClickHouse connections
+- `list_mongodb()`: Get all MongoDB connections
+- `list_valid()`: Get all valid connections
+- `list_invalid()`: Get all invalid connections
+
+### TaskClient
+
+Task management client.
+
+**Methods:**
+- `list(status, skip, limit)`: Query task list
+- `get(task_id)`: Get single task
+- `list_running()`: Get all running tasks
+- `start(task_id)`: Start task
+- `stop(task_id)`: Stop task
+- `reset(task_id)`: Reset task
+- `delete(task_id)`: Delete task
+- `get_logs(task_id, task_record_id, start, end, page, page_size, levels)`: Get task logs
+
+### Enum Types
+
+```python
+from tapdata_sdk import ConnectionType, DatabaseType, Status, LogLevel
+
+# Connection types
+ConnectionType.SOURCE
+ConnectionType.TARGET
+
+# Database types
+DatabaseType.MYSQL
+DatabaseType.CLICKHOUSE
+DatabaseType.MONGODB
+DatabaseType.POSTGRESQL
+DatabaseType.ORACLE
+DatabaseType.SQLSERVER
+
+# Status
+Status.RUNNING
+Status.COMPLETE
+Status.ERROR
+# ... more statuses
+
+# Log levels
+LogLevel.INFO
+LogLevel.WARN
+LogLevel.ERROR
+LogLevel.DEBUG
+```
+
+## Development
+
+### Setup Development Environment
+
+```bash
+# Clone repository
+git clone <repository-url>
+cd tapdata-sdk
+
+# Create virtual environment
+python -m venv venv
+source venv/bin/activate  # Linux/Mac
+# or
+venv\Scripts\activate  # Windows
+
+# Install dependencies
+pip install -e ".[dev]"
+```
+
+### Run Tests
+
+```bash
+pytest tests/
+```
+
+### Code Formatting
+
+```bash
+black tapdata_sdk/
+isort tapdata_sdk/
+```
+
+## Changelog
+
+### v0.2.0 (2024-01-29)
+- ✨ Refactored code architecture with modular design
+- 📦 Added data model classes (Connection, Task, TaskLog)
+- 🎯 Improved enum types using Python Enum
+- 🔧 Optimized error handling with multiple exception types
+- 📝 Enhanced documentation and type hints
+- 🏗️ Separated client responsibilities (ConnectionClient, TaskClient)
+- 🔐 Improved authentication flow
+- 📊 Optimized logging
+
+### v0.1.0
+- 🎉 Initial release
+
+## License
+
+MIT License
+
+## Contributing
+
+Issues and Pull Requests are welcome!
+
+## Support
+
+For questions, please submit an Issue or contact the maintainers.

tapdata_sdk-0.1.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+tapdata_sdk/__init__.py,sha256=DCbgmv3TOkTHR69LFEJ3Y9Oxm9WfUBQUhyqUMyySSVk,1332
+tapdata_sdk/client.py,sha256=yx6W2iVnE_3b8ybguRevr3Oid2dUs73XPLZyu-KVyjw,13888
+tapdata_sdk/enums.py,sha256=ywCPyswMdbISvuII9Lv7QSmwHUbfqsQB3mK_UPV7C9A,1160
+tapdata_sdk/exceptions.py,sha256=Edm1P6Aghb7wJhUOubYU9JuxcQrfI_WGn3wnX4ukH7Y,627
+tapdata_sdk/models.py,sha256=elJxe-6IzSCOpSLCQroUGec4dBgjyf2PU7LHo9O_yQ8,4601
+tapdata_sdk/utils.py,sha256=ojPuW9YwW7dkb0nLJ46_IgMbOzor7DtppYDBuN4nCiY,2682
+tapdata_sdk-0.1.0.dist-info/licenses/LICENSE,sha256=g3faROod99RM6X9tAOfJ_7LsPxI1sOISYpIy2w9VexQ,1064
+tapdata_sdk-0.1.0.dist-info/METADATA,sha256=d477QW0uSb5KbHfEO99E_02ZaVTPak9M0dp-JDhDR6k,7933
+tapdata_sdk-0.1.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+tapdata_sdk-0.1.0.dist-info/top_level.txt,sha256=YNIwm3uNhULMB32qsLcj-zAoL5yYMKWJbXnstNsIYNk,12
+tapdata_sdk-0.1.0.dist-info/RECORD,,

tapdata_sdk-0.1.0.dist-info/WHEEL

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

tapdata_sdk-0.1.0.dist-info/licenses/LICENSE

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

tapdata_sdk-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+tapdata_sdk