datasourcelib 0.1.4__py3-none-any.whl → 0.1.6__py3-none-any.whl

datasourcelib/core/sync_manager.py

@@ -10,6 +10,7 @@ from ..datasources.sql_source import SQLDataSource
 from ..datasources.azure_devops_source import AzureDevOpsSource
 from ..datasources.sharepoint_source import SharePointSource
 from ..datasources.blob_source import BlobStorageSource
+from ..datasources.dataverse_source import DataverseSource
 
 # concrete strategies
 from datasourcelib.strategies.full_load import FullLoadStrategy
@@ -35,7 +36,8 @@ class SyncManager:
         DataSourceType.SQL: SQLDataSource,
         DataSourceType.AZURE_DEVOPS: AzureDevOpsSource, 
         DataSourceType.SHAREPOINT: SharePointSource,
-        DataSourceType.BLOB_STORAGE: BlobStorageSource
+        DataSourceType.BLOB_STORAGE: BlobStorageSource,
+        DataSourceType.Dataverse: DataverseSource
     }
 
     def execute_sync(self, sync_type: SyncType, 

datasourcelib/datasources/azure_devops_source copy.py

@@ -0,0 +1,126 @@
+from typing import Any, Dict, List, Optional
+from datasourcelib.datasources.datasource_base import DataSourceBase
+from datasourcelib.utils.logger import get_logger
+from datasourcelib.utils.validators import require_keys
+import base64
+import json
+from bs4 import BeautifulSoup
+
+logger = get_logger(__name__)
+
+try:
+    import requests  # type: ignore
+except Exception:
+    requests = None  # lazy import handled at runtime
+
+class AzureDevOpsSource(DataSourceBase):
+   
+    def validate_config(self) -> bool:
+        try:
+            require_keys(self.config, ["ado_organization", "ado_personal_access_token","ado_project","ado_query_id"])
+            return True
+        except Exception as ex:
+            logger.error("AzureDevOpsSource.validate_config: %s", ex)
+            return False
+
+    def connect(self) -> bool:
+        if requests is None:
+            raise RuntimeError("requests package is required for AzureDevOpsSource")
+        # No persistent connection; store auth header
+        pat = self.config.get("ado_personal_access_token")
+        token = pat
+        token_b64 = base64.b64encode(token.encode("utf-8")).decode("utf-8")
+        self._headers = {"Authorization": f"Bearer {token}", "Content-Type": "application/json"}
+        self._connected = True
+        logger.info("AzureDevOpsSource ready (no persistent connection required)")
+        return True
+
+    def disconnect(self) -> None:
+        self._headers = {}
+        self._connected = False
+        logger.info("AzureDevOpsSource cleared")
+
+    def fetch_data(self, query: Optional[str] = None, **kwargs) -> List[Dict[str, Any]]:
+        if requests is None:
+            raise RuntimeError("requests package is required for AzureDevOpsSource")
+        if not getattr(self, "_connected", False):
+            self.connect()
+
+        org = self.config.get("ado_organization")
+        project = self.config.get("ado_project")
+        query_id = self.config.get("ado_query_id")
+        api_version = self.config.get("api_version", "7.1")
+        #path = self.config.get("query_path", query or "")
+        if not query_id:
+            raise ValueError("AzureDevOpsSource.fetch_data requires 'query_id' or query argument")
+
+        base = f"https://dev.azure.com/{org}/"
+        if project:
+            base = f"{base}{project}/"
+        url = f"{base}_apis/wit/wiql/{query_id}"
+        params = {"api-version": api_version}
+        method = self.config.get("method", "GET").upper()
+        query_response = requests.request(method, url, headers=getattr(self, "_headers", {}), params=params) #, json=self.config.get("payload")
+        query_response.raise_for_status()
+        #data = resp.json()
+        # Check if the request was successful
+        if query_response.status_code == 200:
+            work_items = query_response.json()['workItems']
+            work_item_details = []
+
+            # Loop through each work item ID to get detailed information
+            for item in work_items:
+                work_item_id = item['id']
+                work_item_url = f'https://dev.azure.com/{org}/{project}/_apis/wit/workitems/{work_item_id}?api-version=7.1'
+                work_item_response = requests.get(work_item_url, headers=getattr(self, "_headers", {}))
+
+                if work_item_response.status_code == 200:
+                    logger.info(f"Current Item: {work_item_id}")
+                    text = work_item_response.json()['fields']['System.Description']
+                    c_desc=BeautifulSoup(text, "html.parser").get_text()
+                    c_changedate = work_item_response.json()['fields']['System.ChangedDate']
+                    c_title = work_item_response.json()['fields']['System.Title'] 
+                    c_status = work_item_response.json()['fields']['System.State']
+                    c_type = work_item_response.json()['fields']['System.WorkItemType']
+                    c_created = work_item_response.json()['fields']['System.CreatedDate']
+                    
+                    default_value = "-VALUE NOT ASSIGNED-"
+                    c_assigned = work_item_response.json()['fields'].get('System.AssignedTo',{}).get('displayName',default_value) 
+                    logger.info(c_assigned)
+                    c_tags = work_item_response.json()['fields'].get('System.Tags',default_value)
+                    c_project = work_item_response.json()['fields'].get('Custom.ProjectName',default_value)
+                    c_rtype = work_item_response.json()['fields'].get('Custom.Releasetype',default_value)
+                    c_rdate = work_item_response.json()['fields'].get('Microsoft.VSTS.Scheduling.TargetDate',default_value)
+                                    
+                    #fullfeature = f"{c_type} ID {work_item_id} was created on {c_created} for a {c_rtype} release of Project '{c_project}' with target date '{c_rdate}' and has given Title as '{c_title}'. {c_type} ID {work_item_id} is currently in {c_status} state. {c_type} ID {work_item_id} is assigned to {c_assigned} and last modified on {c_changedate}.Tags Applied to {c_type} ID {work_item_id} are {c_tags}. Full Description of {c_type} ID {work_item_id} is [{c_desc}]."
+                    fullfeature = f"{c_type} ID {work_item_id} was created on {c_created}. {c_type} ID {work_item_id}  is a {c_rtype} release of Project '{c_project}'. {c_type} ID {work_item_id} Release has target date '{c_rdate}'.{c_type} ID {work_item_id} has given Title as '{c_title}'. {c_type} ID {work_item_id} is currently in {c_status} state. {c_type} ID {work_item_id} is assigned to {c_assigned}. {c_type} ID {work_item_id} is last modified on {c_changedate}. Tags Applied to {c_type} ID {work_item_id} are {c_tags}. Full Description of {c_type} ID {work_item_id} is [{c_desc}]."
+                    # Ensure work_item_details is a list and append a dict for this work item
+                    
+                    work_item_details.append({
+                        "id": work_item_id,
+                        "type": c_type,
+                        "title": c_title,
+                        "status": c_status,
+                        "assigned_to": c_assigned,
+                        "created": c_created,
+                        "changed_date": c_changedate,
+                        "tags": c_tags,
+                        "release_type": c_rtype,
+                        "target_date": c_rdate,
+                        "project": c_project,
+                        "description": c_desc,
+                        "full": fullfeature
+                    })
+                else:
+                    logger.error(f"Error fetching details for work item ID {work_item_id}: {work_item_response.status_code}")
+            
+            #work_item_desc = []
+            #for desc in work_item_details:
+            #    work_item_desc.append(desc['fields']['System.Description'])
+                
+                
+            return work_item_details  #[{"response": json.dumps(work_item_details)}]
+        else:
+            raise RuntimeError(f"Error: {query_response.status_code}")
+        # Caller decides how to interpret the payload; default: return raw json in a single-item list
+        

datasourcelib/datasources/azure_devops_source.py

@@ -50,77 +50,135 @@ class AzureDevOpsSource(DataSourceBase):
         project = self.config.get("ado_project")
         query_id = self.config.get("ado_query_id")
         api_version = self.config.get("api_version", "7.1")
-        #path = self.config.get("query_path", query or "")
         if not query_id:
             raise ValueError("AzureDevOpsSource.fetch_data requires 'query_id' or query argument")
 
         base = f"https://dev.azure.com/{org}/"
         if project:
             base = f"{base}{project}/"
-        url = f"{base}_apis/wit/wiql/{query_id}"
+        # WIQL query by id (returns list of work item refs)
+        wiql_url = f"{base}_apis/wit/wiql/{query_id}"
         params = {"api-version": api_version}
         method = self.config.get("method", "GET").upper()
-        query_response = requests.request(method, url, headers=getattr(self, "_headers", {}), params=params) #, json=self.config.get("payload")
+        query_response = requests.request(method, wiql_url, headers=getattr(self, "_headers", {}), params=params)
         query_response.raise_for_status()
-        #data = resp.json()
-        # Check if the request was successful
-        if query_response.status_code == 200:
-            work_items = query_response.json()['workItems']
-            work_item_details = []
-
-            # Loop through each work item ID to get detailed information
-            for item in work_items:
-                work_item_id = item['id']
-                work_item_url = f'https://dev.azure.com/{org}/{project}/_apis/wit/workitems/{work_item_id}?api-version=7.1'
-                work_item_response = requests.get(work_item_url, headers=getattr(self, "_headers", {}))
-
-                if work_item_response.status_code == 200:
-                    logger.info(f"Current Item: {work_item_id}")
-                    text = work_item_response.json()['fields']['System.Description']
-                    c_desc=BeautifulSoup(text, "html.parser").get_text()
-                    c_changedate = work_item_response.json()['fields']['System.ChangedDate']
-                    c_title = work_item_response.json()['fields']['System.Title'] 
-                    c_status = work_item_response.json()['fields']['System.State']
-                    c_type = work_item_response.json()['fields']['System.WorkItemType']
-                    c_created = work_item_response.json()['fields']['System.CreatedDate']
-                    
-                    default_value = "-VALUE NOT ASSIGNED-"
-                    c_assigned = work_item_response.json()['fields'].get('System.AssignedTo',{}).get('displayName',default_value) 
-                    logger.info(c_assigned)
-                    c_tags = work_item_response.json()['fields'].get('System.Tags',default_value)
-                    c_project = work_item_response.json()['fields'].get('Custom.ProjectName',default_value)
-                    c_rtype = work_item_response.json()['fields'].get('Custom.Releasetype',default_value)
-                    c_rdate = work_item_response.json()['fields'].get('Microsoft.VSTS.Scheduling.TargetDate',default_value)
-                                    
-                    #fullfeature = f"{c_type} ID {work_item_id} was created on {c_created} for a {c_rtype} release of Project '{c_project}' with target date '{c_rdate}' and has given Title as '{c_title}'. {c_type} ID {work_item_id} is currently in {c_status} state. {c_type} ID {work_item_id} is assigned to {c_assigned} and last modified on {c_changedate}.Tags Applied to {c_type} ID {work_item_id} are {c_tags}. Full Description of {c_type} ID {work_item_id} is [{c_desc}]."
-                    fullfeature = f"{c_type} ID {work_item_id} was created on {c_created}. {c_type} ID {work_item_id}  is a {c_rtype} release of Project '{c_project}'. {c_type} ID {work_item_id} Release has target date '{c_rdate}'.{c_type} ID {work_item_id} has given Title as '{c_title}'. {c_type} ID {work_item_id} is currently in {c_status} state. {c_type} ID {work_item_id} is assigned to {c_assigned}. {c_type} ID {work_item_id} is last modified on {c_changedate}. Tags Applied to {c_type} ID {work_item_id} are {c_tags}. Full Description of {c_type} ID {work_item_id} is [{c_desc}]."
-                    # Ensure work_item_details is a list and append a dict for this work item
-                    
-                    work_item_details.append({
-                        "id": work_item_id,
-                        "type": c_type,
-                        "title": c_title,
-                        "status": c_status,
-                        "assigned_to": c_assigned,
-                        "created": c_created,
-                        "changed_date": c_changedate,
-                        "tags": c_tags,
-                        "release_type": c_rtype,
-                        "target_date": c_rdate,
-                        "project": c_project,
-                        "description": c_desc,
-                        "full": fullfeature
-                    })
-                else:
-                    logger.error(f"Error fetching details for work item ID {work_item_id}: {work_item_response.status_code}")
-            
-            #work_item_desc = []
-            #for desc in work_item_details:
-            #    work_item_desc.append(desc['fields']['System.Description'])
-                
-                
-            return work_item_details  #[{"response": json.dumps(work_item_details)}]
-        else:
+
+        if query_response.status_code != 200:
             raise RuntimeError(f"Error: {query_response.status_code}")
-        # Caller decides how to interpret the payload; default: return raw json in a single-item list
-        
+
+        work_items_refs = query_response.json().get('workItems', []) or []
+        if not work_items_refs:
+            return []
+
+        # collect ids and fetch details in batch to get all fields for all work item types
+        ids = [str(item.get('id')) for item in work_items_refs if item.get('id')]
+        if not ids:
+            return []
+
+        details_url = f"https://dev.azure.com/{org}/{project}/_apis/wit/workitems"
+        # expand=all to include fields, relations, and attachments
+        params = {
+            "ids": ",".join(ids),
+            "api-version": api_version,
+            "$expand": "all"
+        }
+        details_resp = requests.get(details_url, headers=getattr(self, "_headers", {}), params=params)
+        details_resp.raise_for_status()
+        items = details_resp.json().get("value", [])
+
+        work_item_details: List[Dict[str, Any]] = []
+        for item in items:
+            item_id = item.get("id")
+            fields = item.get("fields", {}) or {}
+
+            # Normalize field keys to safe snake_case-like keys
+            norm_fields: Dict[str, Any] = {}
+            for k, v in fields.items():
+                nk = k.replace(".", "_")
+                nk = nk.lower()
+                norm_fields[nk] = v
+
+            # Helper to safely extract nested displayName for assigned to
+            assigned = norm_fields.get("system_assignedto")
+            if isinstance(assigned, dict):
+                assigned_to = assigned.get("displayName") or assigned.get("uniqueName") or str(assigned)
+            else:
+                assigned_to = assigned
+
+            # find a description-like field (some types use different field names)
+            desc = ""
+            for fk in ["system_description", "microsoft_vsts_createdby", "html_description"]:
+                if fk in norm_fields:
+                    desc = norm_fields.get(fk) or ""
+                    break
+            if not desc:
+                # fallback: first field key that contains 'description'
+                for kf, vf in norm_fields.items():
+                    if "description" in kf and vf:
+                        desc = vf
+                        break
+
+            # clean HTML description to text
+            try:
+                c_desc = BeautifulSoup(desc or "", "html.parser").get_text()
+            except Exception:
+                c_desc = desc or ""
+
+            # Build common convenience values (use available fields)
+            wi_type = norm_fields.get("system_workitemtype") or norm_fields.get("system_witype") or ""
+            title = norm_fields.get("system_title") or ""
+            status = norm_fields.get("system_state") or ""
+            created = norm_fields.get("system_createddate") or norm_fields.get("system_created") or ""
+            changed = norm_fields.get("system_changeddate") or norm_fields.get("system_changed") or ""
+            tags = norm_fields.get("system_tags", "")
+            project_name = norm_fields.get("custom.projectname") or norm_fields.get("system_teamproject") or ""
+
+            rtype = norm_fields.get("custom.releasetype") or norm_fields.get("custom_releasetype") or ""
+            target_date = norm_fields.get("microsoft_vsts_scheduling_targetdate") or norm_fields.get("microsoft.vsts.scheduling.targetdate") or ""
+
+            # Construct a 'full' description string using available pieces
+            parts = []
+            if wi_type:
+                parts.append(f"{wi_type} ID {item_id}")
+            else:
+                parts.append(f"WorkItem {item_id}")
+            if created:
+                parts.append(f"was created on {created}")
+            if title:
+                parts.append(f"and has Title '{title}'")
+            if status:
+                parts.append(f"is currently in {status} state")
+            if assigned_to:
+                parts.append(f"is assigned to {assigned_to}")
+            if project_name:
+                parts.append(f"for Project '{project_name}'")
+            if rtype:
+                parts.append(f"release type '{rtype}'")
+            if target_date:
+                parts.append(f"with target date '{target_date}'")
+            if tags:
+                parts.append(f"Tags: {tags}")
+            if c_desc:
+                parts.append(f"Description: [{c_desc}]")
+            fullfeature = ". ".join(parts)
+
+            # include all normalized fields in the returned object for completeness
+            entry = {
+                "id": item_id,
+                "type": wi_type,
+                "title": title,
+                "status": status,
+                "assigned_to": assigned_to,
+                "created": created,
+                "changed_date": changed,
+                "tags": tags,
+                "project": project_name,
+                "release_type": rtype,
+                "target_date": target_date,
+                "description": c_desc,
+                "full": fullfeature,
+                "fields": norm_fields  # full field set for this work item
+            }
+            work_item_details.append(entry)
+
+        return work_item_details

datasourcelib/datasources/datasource_types.py

@@ -4,4 +4,5 @@ class DataSourceType(str, Enum):
     SQL = "sql"
     AZURE_DEVOPS = "azure_devops"
     SHAREPOINT = "sharepoint" 
-    BLOB_STORAGE = "blob_storage"
+    BLOB_STORAGE = "blob_storage"
+    Dataverse = "Dataverse"

datasourcelib/datasources/dataverse_source.py

@@ -0,0 +1,291 @@
+from typing import Any, Dict, List, Optional, Tuple
+from datasourcelib.datasources.datasource_base import DataSourceBase
+from datasourcelib.utils.logger import get_logger
+from datasourcelib.utils.validators import require_keys
+import pyodbc
+import time
+import pandas as pd
+
+# optional requests import (webapi mode)
+try:
+    import requests  # type: ignore
+except Exception:
+    requests = None  # lazy import
+
+logger = get_logger(__name__)
+
+class DataverseSource(DataSourceBase):
+    
+    def __init__(self, config: Dict[str, Any]):
+        super().__init__(config)
+        self._conn = None
+        self._mode = (self.config.get("dv_mode") or "tds").lower()  # "tds" or "webapi"
+        self._access_token: Optional[str] = None
+        self._headers: Dict[str, str] = {}
+        self._max_retries = int(self.config.get("dv_max_retries", 3))
+
+    def validate_config(self) -> bool:
+        """
+        Validate required keys depending on selected dv_mode.
+        - tds: requires either 'tds_connection_string' OR ('dataverse_server' and 'dataverse_database')
+        - webapi: requires 'webapi_url','client_id','client_secret','tenant_id' (or 'resource')
+        """
+        try:
+            if self._mode == "webapi":
+                require_keys(self.config, ["dv_webapi_url", "dv_webapi_client_id", "dv_webapi_client_secret", "dv_webapi_tenant_id"])
+            else:
+                # TDS mode (ODBC)
+                if "dv_tds_connection_string" in self.config:
+                    return True
+                # otherwise require components
+                require_keys(self.config, ["dv_tds_server", "dv_tds_database"])
+                # if not using integrated auth require creds
+                if not bool(self.config.get("dv_tds_windows_auth", False)):
+                    require_keys(self.config, ["dv_tds_username", "dv_tds_password"])
+            return True
+        except Exception as ex:
+            logger.error("DataverseSource.validate_config failed: %s", ex)
+            return False
+
+    # -------------------------
+    # Connection helpers
+    # -------------------------
+    def _get_available_driver(self) -> str:
+        """Return first suitable ODBC driver for SQL/Dataverse TDS access."""
+        preferred_drivers = [
+            "ODBC Driver 18 for SQL Server",
+            "ODBC Driver 17 for SQL Server",
+            "SQL Server Native Client 11.0",
+            "SQL Server"
+        ]
+        try:
+            drivers = pyodbc.drivers()
+            logger.info("Available ODBC drivers: %s", drivers)
+            
+            for d in preferred_drivers:
+                if d in drivers:
+                    logger.info("Using ODBC driver: %s", d)
+                    return d
+            
+            # fallback to first available
+            if drivers:
+                logger.warning("No preferred driver found. Using: %s", drivers[0])
+                return drivers[0]
+            raise RuntimeError("No ODBC drivers available")
+        except Exception as ex:
+            logger.error("DataverseSource._get_available_driver failed: %s", ex)
+            raise
+
+    def _build_tds_conn_str(self) -> str:
+        """Build valid connection string with proper parameter names."""
+        if "dv_tds_connection_string" in self.config:
+            return self.config["dv_tds_connection_string"]
+        
+        driver = self._get_available_driver()
+        # Fix: use correct config key names (dv_tds_server, not dv_tds_dataverse_server)
+        server = self.config.get("dv_tds_server", "").strip()
+        database = self.config.get("dv_tds_database", "").strip()
+        
+        if not server:
+            raise ValueError("dv_tds_server are required")
+        
+        logger.info("Building TDS connection (driver=%s, server=%s, database=%s)", driver, server, database)
+        
+        # Use curly braces for driver name (handles spaces in driver names)
+        parts = [f"DRIVER={{{driver}}}"]
+        parts.append(f"Server={server}")
+        parts.append(f"Database={database}")
+        password = None
+        if bool(self.config.get("dv_tds_windows_auth", False)):
+            parts.append("Trusted_Connection=yes")
+            logger.info("Using Windows authentication")
+        else:
+            username = self.config.get("dv_tds_username", "").strip()
+            password = self.config.get("dv_tds_password", "").strip()
+            
+            if not username or not password:
+                raise ValueError("dv_tds_username and dv_tds_password required when Windows auth disabled")
+            
+            parts.append(f"UID={username}")
+            parts.append(f"PWD={password}")
+            parts.append("Authentication=ActiveDirectoryInteractive")
+        # Encryption settings
+        if not bool(self.config.get("dv_tds_is_onprem", False)):
+            parts.append("Encrypt=yes")
+            parts.append("TrustServerCertificate=no")
+        else:
+            parts.append("Encrypt=optional")
+            parts.append("TrustServerCertificate=yes")
+        
+        conn_str = ";".join(parts)
+        logger.debug("Connection string: %s", conn_str.replace(password or "", "***") if password else conn_str)
+        return conn_str
+
+    def _obtain_webapi_token(self) -> Tuple[str, Dict[str, str]]:
+        """
+        Acquire OAuth2 token using client credentials flow.
+        Returns (access_token, headers)
+        Config expected keys: tenant_id, client_id, client_secret, optional resource
+        """
+        if requests is None:
+            raise RuntimeError("requests package required for Dataverse Web API mode")
+        tenant = self.config["dv_webapi_tenant_id"]
+        client_id = self.config["dv_webapi_client_id"]
+        client_secret = self.config["dv_webapi_client_secret"]
+        # resource or scope: prefer explicit resource, else fallback to webapi_url host
+        resource = self.config.get("dv_webapi_resource")
+        if not resource:
+            # infer resource from webapi_url e.g. https://<org>.crm.dynamics.com
+            webapi_url = self.config["dv_webapi_url"].rstrip("/")
+            resource = webapi_url.split("://")[-1]
+            resource = f"https://{resource}"  # as resource
+        token_url = f"https://login.microsoftonline.com/{tenant}/oauth2/v2.0/token"
+        data = {
+            "grant_type": "client_credentials",
+            "client_id": client_id,
+            "client_secret": client_secret,
+            "scope": f"{resource}/.default"
+        }
+        resp = requests.post(token_url, data=data, timeout=30)
+        resp.raise_for_status()
+        j = resp.json()
+        token = j.get("access_token")
+        if not token:
+            raise RuntimeError("Failed to obtain access token for Dataverse webapi")
+        headers = {"Authorization": f"Bearer {token}", "Accept": "application/json", "OData-MaxVersion": "4.0", "OData-Version": "4.0"}
+        return token, headers
+
+    # -------------------------
+    # Public connection API
+    # -------------------------
+    def connect(self) -> bool:
+        try:
+            if self._mode == "webapi":
+                token, headers = self._obtain_webapi_token()
+                self._access_token = token
+                self._headers = headers
+                self._connected = True
+                logger.info("DataverseSource connected (webapi mode) to %s", self.config.get("dv_webapi_url"))
+                return True
+            # else TDS mode
+            conn_str = self._build_tds_conn_str()
+            self._conn = pyodbc.connect(conn_str, timeout=int(self.config.get("dv_tds_timeout", 30)))
+            self._connected = True
+            logger.info("DataverseSource connected (dv_tds mode) to %s/%s", self.config.get("dv_server"), self.config.get("dv_database"))
+            return True
+        except pyodbc.Error as ex:
+            logger.error("DataverseSource.connect failed - ODBC Error: %s", ex)
+            self._connected = False
+            return False
+        except requests.RequestException as ex:
+            logger.error("DataverseSource.connect failed - HTTP Error: %s", ex)
+            self._connected = False
+            return False
+        except Exception as ex:
+            logger.exception("DataverseSource.connect failed")
+            self._connected = False
+            return False
+
+    def disconnect(self) -> None:
+        try:
+            if self._conn:
+                try:
+                    self._conn.close()
+                except Exception:
+                    pass
+            self._conn = None
+            self._access_token = None
+            self._headers = {}
+        finally:
+            self._connected = False
+            logger.info("DataverseSource disconnected")
+
+    # -------------------------
+    # Data fetch
+    # -------------------------
+    def fetch_data(self, query: Optional[str] = None, **kwargs) -> List[Dict[str, Any]]:
+        """
+        Fetch rows from Dataverse.
+        - TDS mode: executes SQL query (config key 'tds_query' or provided 'query')
+        - WebAPI mode: calls Dataverse Web API path fragment (e.g. 'accounts?$select=name') or uses 'entity_set' + query params
+        Returns list[dict].
+        """
+        attempt = 0
+        while attempt < self._max_retries:
+            try:
+                if not getattr(self, "_connected", False):
+                    ok = self.connect()
+                    if not ok:
+                        raise RuntimeError("DataverseSource: cannot connect")
+
+                if self._mode == "webapi":
+                    if requests is None:
+                        raise RuntimeError("requests package required for webapi mode")
+                    webapi_url = self.config["dv_webapi_url"].rstrip("/")
+                    # if query provided, treat it as path fragment; else use entity_set from config
+                    path_fragment = query or self.config.get("dv_webapi_entity_set")
+                    if not path_fragment:
+                        raise ValueError("DataverseSource.fetch_data requires a webapi 'query' or 'entity_set' in config")
+                    url = f"{webapi_url}/api/data/v9.1/{path_fragment.lstrip('/')}"
+                    params = kwargs.get("params")
+                    resp = requests.get(url, headers=self._headers, params=params, timeout=60)
+                    resp.raise_for_status()
+                    j = resp.json()
+                    items: Any = []
+                    # Dataverse OData responses typically use 'value' for collections
+                    if isinstance(j, dict) and "value" in j:
+                        items = j["value"]
+                    # otherwise return the raw json wrapped in a list or as-is
+                    elif isinstance(j, list):
+                        items= j
+                    else:
+                        items= [j]
+
+                    df = pd.DataFrame(items)
+                    # filter columns if configured
+                    keep = self.config.get("dv_webapi_columns_to_keep")
+                    if isinstance(keep, list) and keep:
+                        cols_to_keep = [c for c in df.columns if c in keep]
+                    else:
+                        # exclude SharePoint metadata columns (start with '__' or prefixed with '@')
+                        cols_to_keep = [c for c in df.columns if not str(c).startswith("__") and not str(c).startswith("@")]
+                    df = df[cols_to_keep]
+                    results = df.to_dict("records")
+                    return results
+                # else TDS mode
+                sql = query or self.config.get("dv_tds_query") or self.config.get("dv_sql_query")
+                if not sql:
+                    raise ValueError("DataverseSource.fetch_data requires a SQL query (tds mode)")
+
+                cur = self._conn.cursor()
+                try:
+                    cur.execute(sql)
+                    cols = [c[0] for c in (cur.description or [])]
+                    rows = cur.fetchall()
+                    results: List[Dict[str, Any]] = []
+                    for r in rows:
+                        results.append({cols[i]: r[i] for i in range(len(cols))})
+                    return results
+                finally:
+                    try:
+                        cur.close()
+                    except Exception:
+                        pass
+
+            except Exception as ex:
+                attempt += 1
+                logger.warning("DataverseSource.fetch_data attempt %d/%d failed: %s", attempt, self._max_retries, ex)
+                # transient retry for network/connection errors
+                if attempt >= self._max_retries:
+                    logger.exception("DataverseSource.fetch_data final failure")
+                    raise
+                # backoff
+                time.sleep(min(2 ** attempt, 10))
+                # try reconnect for next attempt
+                try:
+                    self.disconnect()
+                except Exception:
+                    pass
+
+        # unreachable; defensive
+        return []

datasourcelib/datasources/sharepoint_source.py

@@ -7,6 +7,7 @@ import requests
 import pandas as pd
 import os
 from uuid import uuid4
+from datetime import datetime, timedelta
 
 logger = get_logger(__name__)
 reader = ByteReader()
@@ -114,50 +115,86 @@ class SharePointSource(DataSourceBase):
         self._drive_id = drives[0].get("id")
         logger.info("Resolved SharePoint drive ID: %s", self._drive_id)
 
+    def _get_client_credentials(self) -> Tuple[str, str]:
+        """Retrieve client credentials in order of priority: sp_download_config, sp_client_config, sp_master_config."""
+        # Fallback to sp_client_config
+        sp_client_config = self.config.get("sp_client_config", {})
+        client_id = sp_client_config.get("sp_client_id")
+        client_secret = sp_client_config.get("sp_client_secret")
+
+        if not client_id or not client_secret:
+            # Fallback to sp_master_config
+            sp_master_config = self.config.get("sp_master_config", {})
+            client_id = client_id or sp_master_config.get("sp_client_id")
+            client_secret = client_secret or sp_master_config.get("sp_client_secret")
+
+        if not client_id or not client_secret:
+            raise ValueError("Client ID and Client Secret must be provided in the configuration.")
+
+        return client_id, client_secret
+
+    def _get_download_credentials(self) -> Tuple[str, str]:
+        """Retrieve client credentials in order of priority: sp_download_config, sp_client_config, sp_master_config."""
+        # Check sp_download_config first
+        sp_download_config = self.config.get("sp_client_config", {}).get("sp_download_config", {})
+        client_id = sp_download_config.get("sp_client_id")
+        client_secret = sp_download_config.get("sp_client_secret")
+
+        if not client_id or not client_secret:
+            # Fallback to sp_client_config
+            sp_client_config = self.config.get("sp_client_config", {})
+            client_id = client_id or sp_client_config.get("sp_client_id")
+            client_secret = client_secret or sp_client_config.get("sp_client_secret")
+
+            if not client_id or not client_secret:
+                # Fallback to sp_master_config
+                sp_master_config = self.config.get("sp_master_config", {})
+                client_id = client_id or sp_master_config.get("sp_client_id")
+                client_secret = client_secret or sp_master_config.get("sp_client_secret")
+
+        if not client_id or not client_secret:
+            raise ValueError("Client ID and Client Secret must be provided in the configuration.")
+
+        return client_id, client_secret
+
+
     def connect(self) -> bool:
         try:
             # basic values
             self._site_url = self.config["sp_site_url"]
-            client_config = self.config["sp_client_config"]
             master_config = self.config["sp_master_config"]
 
             # get master token (Sites.Read.All)
             try:
-                self._master_token = self._get_token(
-                    master_config["sp_client_id"], master_config["sp_client_secret"], master_config["sp_tenant_id"]
-                )
+                master_client_id = master_config["sp_client_id"]
+                master_client_secret = master_config["sp_client_secret"]
+                self._master_token = self._get_token(master_client_id, master_client_secret, master_config["sp_tenant_id"])
                 logger.info("$$$ - Obtained master access token for SharePoint - $$$")
             except Exception as ex:
                 logger.info("$$$ - Failed to obtain master token - $$$")
 
             # resolve site and drive ids
             try:
-                self._resolve_site_and_drive(
-                    self.config['sp_site_display_name']
-                )
+                self._resolve_site_and_drive(self.config['sp_site_display_name'])
             except Exception:
                 logger.info("$$$ - Failed to resolve site/drive - $$$")
-                
+
             # get client token (Site.Selected) for download operations
             try:
-                # use master tenant id for tenant
-                self._access_token = self._get_token(
-                    client_config["sp_client_id"], client_config["sp_client_secret"], master_config["sp_tenant_id"]
-                )
+                client_id, client_secret = self._get_client_credentials()
+                self._access_token = self._get_token(client_id, client_secret, master_config["sp_tenant_id"])
                 logger.info("$$$ - Obtained client access token for SharePoint downloads - $$$")
             except Exception:
                 logger.info("$$$ - Failed to obtain client access token - $$$")
-                    
+
             # get list client token (Site.Selected) for list operations
             try:
-                # use master tenant id for tenant
-                self._list_token = self._get_list_token(
-                    client_config["sp_client_id"], client_config["sp_client_secret"], master_config["sp_tenant_id"],master_config["sp_domain_name"]
-                )
+                client_id, client_secret = self._get_client_credentials()
+                self._list_token = self._get_list_token(client_id, client_secret, master_config["sp_tenant_id"], master_config["sp_domain_name"])
                 logger.info("$$$ - Obtained client list token for SharePoint list operations - $$$")
             except Exception:
                 logger.info("$$$ - Failed to obtain client list token - $$$")
-             
+
             self._connected = True
             logger.info("SharePointSource connected for site: %s", self._site_url)
             return True
@@ -324,10 +361,9 @@ class SharePointSource(DataSourceBase):
                     results = []
                     items = self._fetch_list_items_via_rest(relative_path)
 
-                    if str(self.config.get("sp_client_config",{}).get("sp_download_config",{})["sp_client_id"]):
-                        self._access_token = self._get_token(
-                                self.config.get("sp_client_config",{}).get("sp_download_config",{})["sp_client_id"], self.config.get("sp_client_config",{}).get("sp_download_config",{})["sp_client_secret"], self.config.get("sp_master_config",{})["sp_tenant_id"]
-                            )
+                    client_id, client_secret = self._get_download_credentials()
+
+                    self._access_token = self._get_token(client_id, client_secret, self.config.get("sp_master_config",{})["sp_tenant_id"])
                     #test running with hardcoded items
                     if False:
                         items = []
@@ -350,12 +386,29 @@ class SharePointSource(DataSourceBase):
                         })
 
                     for item in items:
-                        item_name = item.get("Title")
-                        item_display_name = item.get("SiteDisplayName")
+                        #the path after [Shared Documents/] in relative path                      
+                        item_relative_path = item.get("RelativePath") or item.get("relativepath") or item.get("relativePath")
+                        item_name = item.get("Title") or item.get("title")
+                        item_display_name = item.get("SiteDisplayName") or item.get("sitedisplayname") or item.get("siteDisplayName")
+                        
+                        # Check ModifiedDate filter 
+                        # "2024-01-15" → 10 chars || "20240115" → 8 chars
+                        modified_date_str = item.get("ModifiedDate") or item.get("modifieddate") or item.get("modifiedDate")
+                        if modified_date_str:
+                            try:
+                                modified_date = datetime.fromisoformat(modified_date_str.replace('Z', '+00:00'))
+                                if datetime.now(modified_date.tzinfo) - modified_date < timedelta(days=1):
+                                    continue
+                            except Exception:
+                                pass
+                        
+                        if not item_relative_path:
+                            logger.warning("Item missing RelativePath: %s", item)
+                            continue
+
                         #get site id and drive id for this item
                         self._resolve_site_and_drive(item_display_name)  
-                        #the path after [Shared Documents/] in relative path                      
-                        item_relative_path = item.get("RelativePath")
+ 
                         try:
                             content, filename = self._download_file_bytes(item_relative_path)
                             saved = self._save_file_if_requested(content, filename, save_path)

datasourcelib/datasources/sql_source.py

@@ -16,8 +16,16 @@ class SQLDataSource(DataSourceBase):
         self._is_sqlite = False
 
     def validate_config(self) -> bool:
+        """
+        Validate config. If sql_windows_auth is True then sql_username/sql_password are optional.
+        Otherwise require sql_username and sql_password.
+        """
         try:
-            require_keys(self.config, ["sql_server","sql_database","sql_username","sql_password","sql_is_onprem"])
+            # Always require server/database at minimum
+            require_keys(self.config, ["sql_server", "sql_database"])
+            # If not using Windows authentication, require credentials
+            if not bool(self.config.get("sql_windows_auth", False)):
+                require_keys(self.config, ["sql_username", "sql_password"])
             return True
         except Exception as ex:
             logger.error("SQLDataSource.validate_config: %s", ex)
@@ -27,22 +35,31 @@ class SQLDataSource(DataSourceBase):
         try:
             sql_server = self.config.get("sql_server", "")
             sql_database = self.config.get("sql_database", "")
-            sql_username = self.config.get("sql_username", "")
-            sql_password = self.config.get("sql_password", "")
             sql_is_onprem = self.config.get("sql_is_onprem", False)
-            
+
+            # Determine auth mode: sql_windows_auth (Trusted Connection) overrides username/password
+            sql_windows_auth = bool(self.config.get("sql_windows_auth", False))
+
             # Get available driver
             sql_driver = self._get_available_driver()
-            
-            # Build connection string with appropriate encryption settings
+
+            # Build connection string
             conn_params = [
                 f'DRIVER={sql_driver}',
                 f'SERVER={sql_server}',
                 f'DATABASE={sql_database}',
-                f'UID={sql_username}',
-                f'PWD={sql_password}'
             ]
-            
+
+            if sql_windows_auth:
+                # Use integrated Windows authentication (Trusted Connection)
+                # This will use the current process credentials / kerberos ticket.
+                conn_params.append('Trusted_Connection=yes')
+                logger.info("SQLDataSource using Windows (integrated) authentication")
+            else:
+                sql_username = self.config.get("sql_username", "")
+                sql_password = self.config.get("sql_password", "")
+                conn_params.extend([f'UID={sql_username}', f'PWD={sql_password}'])
+
             # Add encryption settings based on environment
             if not sql_is_onprem:
                 conn_params.extend([
@@ -56,13 +73,13 @@ class SQLDataSource(DataSourceBase):
                 ])
 
             conn_str = ';'.join(conn_params)
-            
+
             # Attempt connection with timeout
             self._conn = pyodbc.connect(conn_str, timeout=30)
             self._connected = True
-            logger.info("SQLDataSource connected to %s using driver %s", sql_server, sql_driver)
+            logger.info("SQLDataSource connected to %s using driver %s (sql_windows_auth=%s)", sql_server, sql_driver, sql_windows_auth)
             return True
-            
+
         except pyodbc.Error as ex:
             logger.error("SQLDataSource.connect failed - ODBC Error: %s", ex)
             self._connected = False

datasourcelib/datasources/sql_source_bkup.py

@@ -0,0 +1,159 @@
+from typing import Any, Dict, List, Optional
+from datasourcelib.datasources.datasource_base import DataSourceBase
+from datasourcelib.utils.logger import get_logger
+from datasourcelib.utils.validators import require_keys
+import os
+import pyodbc
+
+
+logger = get_logger(__name__)
+
+class SQLDataSource(DataSourceBase):
+    
+    def __init__(self, config: Dict[str, Any]):
+        super().__init__(config)
+        self._conn = None
+        self._is_sqlite = False
+
+    def validate_config(self) -> bool:
+        """
+        Validate config. If sql_windows_auth is True then sql_username/sql_password are optional.
+        Otherwise require sql_username and sql_password.
+        """
+        try:
+            # Always require server/database at minimum
+            require_keys(self.config, ["sql_server", "sql_database"])
+            # If not using Windows authentication, require credentials
+            if not bool(self.config.get("sql_windows_auth", False)):
+                require_keys(self.config, ["sql_username", "sql_password"])
+            return True
+        except Exception as ex:
+            logger.error("SQLDataSource.validate_config: %s", ex)
+            return False
+
+    def connect(self) -> bool:
+        try:
+            sql_server = self.config.get("sql_server", "")
+            sql_database = self.config.get("sql_database", "")
+            sql_is_onprem = self.config.get("sql_is_onprem", False)
+
+            # Determine auth mode: sql_windows_auth (Trusted Connection) overrides username/password
+            sql_windows_auth = bool(self.config.get("sql_windows_auth", False))
+
+            # Get available driver
+            sql_driver = self._get_available_driver()
+
+            # Build connection string
+            conn_params = [
+                f'DRIVER={sql_driver}',
+                f'SERVER={sql_server}',
+                f'DATABASE={sql_database}',
+            ]
+
+            if sql_windows_auth:
+                # Use integrated Windows authentication (Trusted Connection)
+                # This will use the current process credentials / kerberos ticket.
+                conn_params.append('Trusted_Connection=yes')
+                logger.info("SQLDataSource using Windows (integrated) authentication")
+            else:
+                sql_username = self.config.get("sql_username", "")
+                sql_password = self.config.get("sql_password", "")
+                conn_params.extend([f'UID={sql_username}', f'PWD={sql_password}'])
+
+            # Add encryption settings based on environment
+            if not sql_is_onprem:
+                conn_params.extend([
+                    'Encrypt=yes',
+                    'TrustServerCertificate=no'
+                ])
+            else:
+                conn_params.extend([
+                    'Encrypt=optional',
+                    'TrustServerCertificate=yes'
+                ])
+
+            conn_str = ';'.join(conn_params)
+
+            # Attempt connection with timeout
+            self._conn = pyodbc.connect(conn_str, timeout=30)
+            self._connected = True
+            logger.info("SQLDataSource connected to %s using driver %s (sql_windows_auth=%s)", sql_server, sql_driver, sql_windows_auth)
+            return True
+
+        except pyodbc.Error as ex:
+            logger.error("SQLDataSource.connect failed - ODBC Error: %s", ex)
+            self._connected = False
+            return False
+        except Exception as ex:
+            logger.error("SQLDataSource.connect failed - Unexpected Error: %s", ex)
+            self._connected = False
+            return False
+
+    def disconnect(self) -> None:
+        try:
+            if self._conn:
+                self._conn.close()
+        finally:
+            self._conn = None
+            self._connected = False
+            logger.info("SQLDataSource disconnected")
+
+    def fetch_data(self, query: Optional[str] = None, **kwargs) -> List[Dict[str, Any]]:
+        max_retries = 3
+        retry_count = 0
+        
+        while retry_count < max_retries:
+            try:
+                if not self._connected:
+                    ok = self.connect()
+                    if not ok:
+                        raise RuntimeError("SQLDataSource: not connected and cannot connect")
+
+                query = self.config.get("sql_query")
+                if not query:
+                    raise ValueError("SQLDataSource.fetch_data requires a query")
+
+                cur = self._conn.cursor()
+                try:
+                    cur.execute(query)
+                    cols = [d[0] if hasattr(d, "__len__") else d[0] for d in (cur.description or [])]
+                    rows = cur.fetchall()
+                    results: List[Dict[str, Any]] = []
+                    for r in rows:
+                        results.append({cols[i]: r[i] for i in range(len(cols))})
+                    return results
+                finally:
+                    try:
+                        cur.close()
+                    except Exception:
+                        pass
+                        
+            except pyodbc.OperationalError as ex:
+                # Handle connection lost
+                retry_count += 1
+                logger.warning("Connection lost, attempt %d of %d: %s", retry_count, max_retries, ex)
+                self.disconnect()
+                if retry_count >= max_retries:
+                    raise
+            except Exception as ex:
+                logger.error("Query execution failed: %s", ex)
+                raise
+
+    def _get_available_driver(self) -> str:
+        """Get first available SQL Server driver from preferred list."""
+        preferred_drivers = [
+            'ODBC Driver 18 for SQL Server',
+            'ODBC Driver 17 for SQL Server',
+            'SQL Server Native Client 11.0',
+            'SQL Server'
+        ]
+        
+        try:
+            available_drivers = pyodbc.drivers()
+            for driver in preferred_drivers:
+                if driver in available_drivers:
+                    return driver
+            raise RuntimeError(f"No suitable SQL Server driver found. Available drivers: {available_drivers}")
+        except Exception as ex:
+            logger.error("Failed to get SQL drivers: %s", ex)
+            raise

{datasourcelib-0.1.4.dist-info → datasourcelib-0.1.6.dist-info}/METADATA

@@ -1,10 +1,10 @@
 Metadata-Version: 2.4
 Name: datasourcelib
-Version: 0.1.4
+Version: 0.1.6
 Summary: Data source sync strategies for vector DBs
-Home-page: https://github.com/jaiprakash0217/datasourcelib
-Author: Jai Prakash
-Author-email: jai.prakash@jai12ka4.com
+Home-page: https://github.com/akashmaurya0217/datasourcelib
+Author: Akash Kumar Maurya
+Author-email: mrelectronicsarduino@gmail.com
 Classifier: Development Status :: 3 - Alpha
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License

{datasourcelib-0.1.4.dist-info → datasourcelib-0.1.6.dist-info}/RECORD

@@ -1,16 +1,19 @@
 datasourcelib/__init__.py,sha256=I7JTSZ1J6ULg_TfdMEgFcd1regkCHuyKdZT4DcPtoyQ,78
 datasourcelib/core/__init__.py,sha256=nsXojDd97T7eMqqtCsZr1qSYLBitvKydSZRb9Dg7hqU,462
 datasourcelib/core/sync_base.py,sha256=AfwwaV3rJOFKVmKKpSj-BwznnCDCaeuT4LLNDfA3NAY,716
-datasourcelib/core/sync_manager.py,sha256=lj070S3PwSNcB0UL_ZDzDAm6uJ9G38TY491vQZ1dL3o,3849
+datasourcelib/core/sync_manager.py,sha256=pep3lS9GINzhOnwrMSPnOh5rfIsMbu8a0TEkTyq4yRk,3961
 datasourcelib/core/sync_types.py,sha256=KVZB7PkfkFTzghoe--U8jLeAU8XAfba9qMRIVcUjuMc,297
 datasourcelib/datasources/__init__.py,sha256=lZtgs0vT-2gub5UZo8BUnREZl3K_-_xYqUP8mjf8vhM,436
-datasourcelib/datasources/azure_devops_source.py,sha256=g-IOCq5vGwwteU21jZPWW_GggMu1_myVJkP0_BmSdGY,7282
+datasourcelib/datasources/azure_devops_source copy.py,sha256=g-IOCq5vGwwteU21jZPWW_GggMu1_myVJkP0_BmSdGY,7282
+datasourcelib/datasources/azure_devops_source.py,sha256=3hyZIrUdgwZEQNjb2iZGDMJcAw3Z6r7oV0hWAq_zMsg,8005
 datasourcelib/datasources/blob_source.py,sha256=Qk61_ulqUSPYDaiMzqgvJAu43c4AjTlDRdfFg4VwgDU,3574
 datasourcelib/datasources/datasource_base.py,sha256=N8fOGvTl8oWWAiydLI0Joz66luq73a5yovO0XA9Q3jk,1068
-datasourcelib/datasources/datasource_types.py,sha256=eEiWymYS05X_TxwuB7P3MpphPG1En67h3kRiSGeHjQ0,176
+datasourcelib/datasources/datasource_types.py,sha256=jpm4f9n1l7X9aBD58Pbr9evXiCHHEhRCLojGwchUD7A,205
+datasourcelib/datasources/dataverse_source.py,sha256=8qScGvTvMOVeDc_ODYtBmx97L9AIlokz3wkzioT_ovw,13296
 datasourcelib/datasources/sharepoint_source - Copy.py,sha256=7V1c-zyvTo4IuPN_YMrKwLZFgbtipbP-mtunmXjOLJQ,17664
-datasourcelib/datasources/sharepoint_source.py,sha256=Pv9735Gu2FylVeeT9e_cZlCvgGUwxn-pVRRZQe2PHU8,20196
-datasourcelib/datasources/sql_source.py,sha256=sCYHrmeD82fQVcdQjL9Y2TTTjaqlv2v8B5noAng3Bl4,5450
+datasourcelib/datasources/sharepoint_source.py,sha256=t3rly2mVEI2qEDuUVqstck5ktkZW0BnF16Bke_NjPLI,23126
+datasourcelib/datasources/sql_source.py,sha256=ntZjiFXpa7V797x7mAATJV0LH-g878VHuRw-QTxEe28,6372
+datasourcelib/datasources/sql_source_bkup.py,sha256=ntZjiFXpa7V797x7mAATJV0LH-g878VHuRw-QTxEe28,6372
 datasourcelib/indexes/__init__.py,sha256=S8dz-lyxy1BTuDuLGRJNLrZD_1ku_FIUnDEm6HhMyT0,94
 datasourcelib/indexes/azure_search_index.py,sha256=kznAz06UXgyT1Clqj6gRhnBQ5HFw40ZQHJElRFIcbRo,22115
 datasourcelib/strategies/__init__.py,sha256=kot3u62KIAqYBg9M-KRE4mkMII_zwrDBZNf8Dj1vmX8,399
@@ -25,8 +28,8 @@ datasourcelib/utils/exceptions.py,sha256=mgcDaW1k3VndgpMOwSm7NqgyRTvvE2a5ehn3x4f
 datasourcelib/utils/file_reader.py,sha256=Zr0rwNTRWE6KeVJEXgTOPS1_JI74LiUSiX5-6qojmN0,7301
 datasourcelib/utils/logger.py,sha256=Sl6lNlvubxtK9ztzyq7vjGVyA8_-pZ_ixpk5jfVsh6U,424
 datasourcelib/utils/validators.py,sha256=fLgmRAb5OZSdMVlHu_n0RKJUDl-G8dI8JsRSfxIquh8,205
-datasourcelib-0.1.4.dist-info/licenses/LICENSE,sha256=9S0AcKETmp9XOcC73jEjN7WSkuSWGFGreiBat6ONClo,1087
-datasourcelib-0.1.4.dist-info/METADATA,sha256=LR3db7O_rnbTmF_owLl-lH06xAfP-iZu4aXPtmjVtRo,1185
-datasourcelib-0.1.4.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-datasourcelib-0.1.4.dist-info/top_level.txt,sha256=wIwiwdIj8T9pAvE2TkGLUvT2oIi43C2vkkTKibUlv3U,14
-datasourcelib-0.1.4.dist-info/RECORD,,
+datasourcelib-0.1.6.dist-info/licenses/LICENSE,sha256=9S0AcKETmp9XOcC73jEjN7WSkuSWGFGreiBat6ONClo,1087
+datasourcelib-0.1.6.dist-info/METADATA,sha256=5lpuBdVreQu7PHsMoD9RWsnSx2cZjpKLEjFhclwO5oA,1199
+datasourcelib-0.1.6.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+datasourcelib-0.1.6.dist-info/top_level.txt,sha256=wIwiwdIj8T9pAvE2TkGLUvT2oIi43C2vkkTKibUlv3U,14
+datasourcelib-0.1.6.dist-info/RECORD,,