pyTigerGraph 2.0.2__tar.gz → 2.0.3__tar.gz

{pytigergraph-2.0.2 → pytigergraph-2.0.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyTigerGraph
-Version: 2.0.2
+Version: 2.0.3
 Summary: Library to connect to TigerGraph databases
 Author-email: "TigerGraph Inc." <support@tigergraph.com>
 License-Expression: Apache-2.0

{pytigergraph-2.0.2 → pytigergraph-2.0.3}/pyTigerGraph/common/base.py

@@ -108,7 +108,14 @@ class PyTigerGraphCore(object):
         # Extract port from URL if present (e.g. http://192.168.11.11:14240)
         # Use hostname (without port) to avoid double-port URLs later.
         hostOnly = inputHost.hostname
-        hostPort = inputHost.port  # int or None
+        if not hostOnly:
+            raise TigerGraphException(
+                "Invalid or empty hostname in host URL: " + host)
+        try:
+            hostPort = inputHost.port  # int or None
+        except ValueError:
+            raise TigerGraphException(
+                "Invalid port in host URL: " + host)
         if hostPort is not None:
             _hp = str(hostPort)
             _restpp_explicit = restppPort is not None
@@ -420,14 +427,14 @@ class PyTigerGraphCore(object):
         # _refresh_auth_headers() keeps these current after every getToken() call.
         _headers = dict(self._cached_auth)
 
+        if self.responseConfigHeader:
+            _headers.update(self.responseConfigHeader)
         if headers:
             _headers.update(headers)
         if self.awsIamHeaders:
             # version >=4.1 has removed /gsqlserver/
             if url.startswith(self.gsUrl + "/gsqlserver/") or (self._versionGreaterThan4_0() and url.startswith(self.gsUrl)):
                 _headers.update(self.awsIamHeaders)
-        if self.responseConfigHeader:
-            _headers.update(self.responseConfigHeader)
         if method == "POST" or method == "PUT" or method == "DELETE":
             _data = data
         else:

{pytigergraph-2.0.2 → pytigergraph-2.0.3}/pyTigerGraph/pyTigerGraphBase.py

@@ -209,10 +209,10 @@ class pyTigerGraphBase(PyTigerGraphCore, object):
         """
         _headers, _data, _ = self._prep_req(authMode, headers, url, method, data)
 
-        if "GSQL-TIMEOUT" in _headers:
-            http_timeout = (30, int(int(_headers["GSQL-TIMEOUT"])/1000) + 30)
+        if "GSQL-TIMEOUT" in _headers and int(_headers["GSQL-TIMEOUT"]) > 0:
+            http_timeout = int(int(_headers["GSQL-TIMEOUT"])/1000) + 30
         else:
-            http_timeout = (30, None)
+            http_timeout = None
 
         conn_err = None
         try:

{pytigergraph-2.0.2 → pytigergraph-2.0.3}/pyTigerGraph/pyTigerGraphLoading.py

@@ -38,7 +38,7 @@ logger = logging.getLogger(__name__)
 class pyTigerGraphLoading(pyTigerGraphBase):
 
     def runLoadingJobWithDataFrame(self, df: 'pd.DataFrame', fileTag: str, jobName: str, sep: str = None,
-                                   eol: str = None, timeout: int = 16000, sizeLimit: int = 128000000, columns: list = None) -> Union[dict, None]:
+                                   eol: str = None, timeout: int = 0, sizeLimit: int = 128000000, columns: list = None) -> Union[dict, None]:
         """Execute a loading job with the given pandas DataFrame with optional column list.
 
         The data string will be posted to the TigerGraph server and the value of the appropriate
@@ -87,7 +87,7 @@ class pyTigerGraphLoading(pyTigerGraphBase):
         return res
 
     def runLoadingJobWithFile(self, filePath: str, fileTag: str, jobName: str, sep: str = None,
-                              eol: str = None, timeout: int = 16000, sizeLimit: int = 128000000) -> Union[dict, None]:
+                              eol: str = None, timeout: int = 0, sizeLimit: int = 128000000) -> Union[dict, None]:
         """Execute a loading job with the referenced file.
 
         The file will first be uploaded to the TigerGraph server and the value of the appropriate
@@ -130,7 +130,7 @@ class pyTigerGraphLoading(pyTigerGraphBase):
         return res
 
     def runLoadingJobWithData(self, data: str, fileTag: str, jobName: str, sep: str = None,
-                              eol: str = None, timeout: int = 16000, sizeLimit: int = 128000000) -> Union[dict, None]:
+                              eol: str = None, timeout: int = 0, sizeLimit: int = 128000000) -> Union[dict, None]:
         """Execute a loading job with the given data string.
 
         The data string will be posted to the TigerGraph server and the value of the appropriate
@@ -193,7 +193,7 @@ class pyTigerGraphLoading(pyTigerGraphBase):
 
         return res
 
-    def uploadFile(self, filePath, fileTag, jobName="", sep=None, eol=None, timeout=16000,
+    def uploadFile(self, filePath, fileTag, jobName="", sep=None, eol=None, timeout=0,
                    sizeLimit=128000000) -> dict:
         """DEPRECATED
 

{pytigergraph-2.0.2 → pytigergraph-2.0.3}/pyTigerGraph/pyTigerGraphSchema.py

@@ -540,12 +540,16 @@ class pyTigerGraphSchema(pyTigerGraphBase):
 
         return res
 
-    def dropGraph(self, graphName: str) -> dict:
+    def dropGraph(self, graphName: str, cascade: bool = False) -> dict:
         """Drops a graph and all its data.
 
         Args:
             graphName:
                 Name of the graph to drop.
+            cascade:
+                When True, automatically removes associated queries and loading jobs.
+                When False (default), the operation fails if related queries or loading
+                jobs exist.
 
         Returns:
             A dict with at least a ``"message"`` key describing the outcome.
@@ -557,12 +561,15 @@ class pyTigerGraphSchema(pyTigerGraphBase):
         logger.debug("entry: dropGraph")
 
         if self._version_greater_than_4_0():
+            params = {"cascade": str(cascade).lower()} if cascade else None
             res = self._delete(self.gsUrl + "/gsql/v1/schema/graphs/" + graphName,
-                              authMode="pwd", resKey=None,
+                              authMode="pwd", resKey=None, params=params,
                               headers={'Content-Type': 'application/json'})
         else:
-            res = _wrap_gsql_result(
-                self.gsql(f"DROP GRAPH {graphName}"))
+            cmd = f"DROP GRAPH {graphName}"
+            if cascade:
+                cmd += " CASCADE"
+            res = _wrap_gsql_result(self.gsql(cmd))
 
         if logger.level == logging.DEBUG:
             logger.debug("return: " + str(res))

{pytigergraph-2.0.2 → pytigergraph-2.0.3}/pyTigerGraph/pytgasync/pyTigerGraphBase.py

@@ -148,13 +148,11 @@ class AsyncPyTigerGraphBase(PyTigerGraphCore):
 
         _headers, _data, _ = self._prep_req(authMode, headers, url, method, data)
 
-        if "GSQL-TIMEOUT" in _headers:
-            http_timeout = aiohttp.ClientTimeout(
-                sock_connect=30,
-                total=int(int(_headers["GSQL-TIMEOUT"]) / 1000) + 30,
-            )
+        if "GSQL-TIMEOUT" in _headers and int(_headers["GSQL-TIMEOUT"]) > 0:
+            _total = int(int(_headers["GSQL-TIMEOUT"]) / 1000) + 30
+            http_timeout = aiohttp.ClientTimeout(total=_total)
         else:
-            http_timeout = aiohttp.ClientTimeout(sock_connect=30, total=None)
+            http_timeout = aiohttp.ClientTimeout(total=None)
 
         conn_err = None
         try:

{pytigergraph-2.0.2 → pytigergraph-2.0.3}/pyTigerGraph/pytgasync/pyTigerGraphLoading.py

@@ -37,7 +37,7 @@ logger = logging.getLogger(__name__)
 class AsyncPyTigerGraphLoading(AsyncPyTigerGraphBase):
 
     async def runLoadingJobWithDataFrame(self, df: 'pd.DataFrame', fileTag: str, jobName: str, sep: str = None,
-                                         eol: str = None, timeout: int = 16000, sizeLimit: int = 128000000, columns: list = None) -> Union[dict, None]:
+                                         eol: str = None, timeout: int = 0, sizeLimit: int = 128000000, columns: list = None) -> Union[dict, None]:
         """Execute a loading job with the given pandas DataFrame with optional column list.
 
         The data string will be posted to the TigerGraph server and the value of the appropriate
@@ -86,7 +86,7 @@ class AsyncPyTigerGraphLoading(AsyncPyTigerGraphBase):
         return res
 
     async def runLoadingJobWithFile(self, filePath: str, fileTag: str, jobName: str, sep: str = None,
-                                    eol: str = None, timeout: int = 16000, sizeLimit: int = 128000000) -> Union[dict, None]:
+                                    eol: str = None, timeout: int = 0, sizeLimit: int = 128000000) -> Union[dict, None]:
         """Execute a loading job with the referenced file.
 
         The file will first be uploaded to the TigerGraph server and the value of the appropriate
@@ -129,7 +129,7 @@ class AsyncPyTigerGraphLoading(AsyncPyTigerGraphBase):
         return res
 
     async def runLoadingJobWithData(self, data: str, fileTag: str, jobName: str, sep: str = None,
-                                    eol: str = None, timeout: int = 16000, sizeLimit: int = 128000000) -> Union[dict, None]:
+                                    eol: str = None, timeout: int = 0, sizeLimit: int = 128000000) -> Union[dict, None]:
         """Execute a loading job with the given data string.
 
         The data string will be posted to the TigerGraph server and the value of the appropriate
@@ -193,7 +193,7 @@ class AsyncPyTigerGraphLoading(AsyncPyTigerGraphBase):
 
         return res
 
-    async def uploadFile(self, filePath, fileTag, jobName="", sep=None, eol=None, timeout=16000,
+    async def uploadFile(self, filePath, fileTag, jobName="", sep=None, eol=None, timeout=0,
                          sizeLimit=128000000) -> dict:
         """DEPRECATED
 

{pytigergraph-2.0.2 → pytigergraph-2.0.3}/pyTigerGraph/pytgasync/pyTigerGraphSchema.py

@@ -541,12 +541,16 @@ class AsyncPyTigerGraphSchema(AsyncPyTigerGraphBase):
 
         return res
 
-    async def dropGraph(self, graphName: str) -> dict:
+    async def dropGraph(self, graphName: str, cascade: bool = False) -> dict:
         """Drops a graph and all its data.
 
         Args:
             graphName:
                 Name of the graph to drop.
+            cascade:
+                When True, automatically removes associated queries and loading jobs.
+                When False (default), the operation fails if related queries or loading
+                jobs exist.
 
         Returns:
             A dict with at least a ``"message"`` key describing the outcome.
@@ -558,12 +562,15 @@ class AsyncPyTigerGraphSchema(AsyncPyTigerGraphBase):
         logger.debug("entry: dropGraph")
 
         if await self._version_greater_than_4_0():
+            params = {"cascade": str(cascade).lower()} if cascade else None
             res = await self._req("DELETE", self.gsUrl + "/gsql/v1/schema/graphs/" + graphName,
-                                 authMode="pwd", resKey=None,
+                                 authMode="pwd", resKey=None, params=params,
                                  headers={'Content-Type': 'application/json'})
         else:
-            res = _wrap_gsql_result(
-                await self.gsql(f"DROP GRAPH {graphName}"))
+            cmd = f"DROP GRAPH {graphName}"
+            if cascade:
+                cmd += " CASCADE"
+            res = _wrap_gsql_result(await self.gsql(cmd))
 
         if logger.level == logging.DEBUG:
             logger.debug("return: " + str(res))

{pytigergraph-2.0.2 → pytigergraph-2.0.3}/pyTigerGraph.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyTigerGraph
-Version: 2.0.2
+Version: 2.0.3
 Summary: Library to connect to TigerGraph databases
 Author-email: "TigerGraph Inc." <support@tigergraph.com>
 License-Expression: Apache-2.0

{pytigergraph-2.0.2 → pytigergraph-2.0.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "pyTigerGraph"
-version = "2.0.2"
+version = "2.0.3"
 description = "Library to connect to TigerGraph databases"
 readme = "README.md"
 license = "Apache-2.0"

{pytigergraph-2.0.2 → pytigergraph-2.0.3}/tests/test_v202_changes.py

@@ -932,5 +932,120 @@ class TestHostPortExtraction(unittest.TestCase):
         self.assertEqual(conn.host, "https://myserver.tgcloud.io")
 
 
+class TestHttpTimeoutFromGsqlTimeout(unittest.TestCase):
+    """Tests for HTTP timeout derivation from GSQL-TIMEOUT header.
+
+    Verifies that:
+    - GSQL-TIMEOUT > 0 sets both connect and read timeouts to the same value
+      (so large uploads don't hit a 30s socket timeout during sendall).
+    - GSQL-TIMEOUT = 0 uses no client-side timeout (server-wide timeout).
+    - Per-request headers override responseConfigHeader.
+    """
+
+    def _capture_timeout(self, conn, gsql_timeout):
+        """Call _req with a given GSQL-TIMEOUT and return the timeout passed to _do_request."""
+        captured = {}
+
+        def fake_do_request(method, url, headers, data, jsonData, params, timeout):
+            captured["timeout"] = timeout
+            resp = MagicMock()
+            resp.status_code = 200
+            resp.content = b'{"results": []}'
+            resp.json.return_value = {"results": []}
+            return resp
+
+        with patch.object(conn, "_do_request", side_effect=fake_do_request):
+            conn._req("POST", conn.restppUrl + "/ddl/testgraph",
+                       headers={"GSQL-TIMEOUT": str(gsql_timeout),
+                                "RESPONSE-LIMIT": "128000000"})
+        return captured["timeout"]
+
+    def test_gsql_timeout_positive_sets_timeout(self):
+        """GSQL-TIMEOUT=600000 should give 630."""
+        conn = _make_conn()
+        timeout = self._capture_timeout(conn, 600000)
+        self.assertEqual(timeout, 630)
+
+    def test_gsql_timeout_zero_gives_no_timeout(self):
+        """GSQL-TIMEOUT=0 should give None (no client-side limit)."""
+        conn = _make_conn()
+        timeout = self._capture_timeout(conn, 0)
+        self.assertIsNone(timeout)
+
+    def test_gsql_timeout_small_value(self):
+        """GSQL-TIMEOUT=16000 should give 46."""
+        conn = _make_conn()
+        timeout = self._capture_timeout(conn, 16000)
+        self.assertEqual(timeout, 46)
+
+    def test_per_request_header_overrides_response_config(self):
+        """Per-request GSQL-TIMEOUT should override responseConfigHeader."""
+        conn = _make_conn()
+        conn.customizeHeader(timeout=300000)  # responseConfigHeader: 300000
+        # Per-request header: 600000 should win
+        timeout = self._capture_timeout(conn, 600000)
+        self.assertEqual(timeout, 630)
+
+    def test_response_config_header_used_when_no_per_request(self):
+        """responseConfigHeader GSQL-TIMEOUT used when no per-request header."""
+        conn = _make_conn()
+        conn.customizeHeader(timeout=300000)
+
+        captured = {}
+        def fake_do_request(method, url, headers, data, jsonData, params, timeout):
+            captured["timeout"] = timeout
+            resp = MagicMock()
+            resp.status_code = 200
+            resp.content = b'{"results": []}'
+            resp.json.return_value = {"results": []}
+            return resp
+
+        with patch.object(conn, "_do_request", side_effect=fake_do_request):
+            conn._req("GET", conn.restppUrl + "/some/endpoint")
+        # responseConfigHeader sets GSQL-TIMEOUT=300000 → 330
+        self.assertEqual(captured["timeout"], 330)
+
+    def test_loading_job_timeout_passed_correctly(self):
+        """runLoadingJobWithData with timeout=600000 should use 630."""
+        conn = _make_conn()
+        conn.customizeHeader(timeout=300000)
+
+        captured = {}
+        def fake_do_request(method, url, headers, data, jsonData, params, timeout):
+            captured["timeout"] = timeout
+            captured["headers"] = headers
+            resp = MagicMock()
+            resp.status_code = 200
+            resp.content = b'{"results": []}'
+            resp.json.return_value = {"results": []}
+            return resp
+
+        with patch.object(conn, "_do_request", side_effect=fake_do_request):
+            conn.runLoadingJobWithData("line1\nline2\n", "f1", "job1",
+                                       timeout=600000)
+        # Per-request GSQL-TIMEOUT=600000 overrides responseConfigHeader=300000
+        self.assertEqual(captured["headers"]["GSQL-TIMEOUT"], "600000")
+        self.assertEqual(captured["timeout"], 630)
+
+    def test_loading_job_default_timeout_zero(self):
+        """runLoadingJobWithData default timeout=0 should use no client limit."""
+        conn = _make_conn()
+
+        captured = {}
+        def fake_do_request(method, url, headers, data, jsonData, params, timeout):
+            captured["timeout"] = timeout
+            captured["headers"] = headers
+            resp = MagicMock()
+            resp.status_code = 200
+            resp.content = b'{"results": []}'
+            resp.json.return_value = {"results": []}
+            return resp
+
+        with patch.object(conn, "_do_request", side_effect=fake_do_request):
+            conn.runLoadingJobWithData("line1\nline2\n", "f1", "job1")
+        self.assertEqual(captured["headers"]["GSQL-TIMEOUT"], "0")
+        self.assertIsNone(captured["timeout"])
+
+
 if __name__ == "__main__":
     unittest.main(verbosity=2)