Add files using upload-large-folder tool

.gitattributes

@@ -3414,3 +3414,31 @@ platform/dataops/dto/.venv/lib/python3.12/site-packages/pymdownx/__pycache__/twe
 platform/dataops/dto/.venv/lib/python3.12/site-packages/jinja2/__pycache__/compiler.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
 platform/dataops/dto/.venv/lib/python3.12/site-packages/cassandra/__pycache__/cluster.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
 platform/dataops/dto/.venv/lib/python3.12/site-packages/cassandra/__pycache__/metadata.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
+platform/dataops/dto/.venv/lib/python3.12/site-packages/rich/__pycache__/_emoji_codes.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
+platform/dataops/dto/.venv/lib/python3.12/site-packages/rich/__pycache__/console.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
+platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/_libs/index.cpython-312-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/_libs/testing.cpython-312-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/_libs/internals.cpython-312-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/_libs/reshape.cpython-312-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/_libs/interval.cpython-312-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/_libs/lib.cpython-312-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/_libs/parsers.cpython-312-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/_libs/ops.cpython-312-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/_libs/hashing.cpython-312-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/_libs/missing.cpython-312-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/_libs/sas.cpython-312-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/_libs/hashtable.cpython-312-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/_libs/join.cpython-312-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/_libs/writers.cpython-312-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/_libs/sparse.cpython-312-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/_libs/algos.cpython-312-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/_libs/groupby.cpython-312-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/_libs/tslib.cpython-312-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/core/__pycache__/frame.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
+platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/core/__pycache__/generic.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
+platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/core/__pycache__/indexing.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
+platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/core/__pycache__/series.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
+platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/core/indexes/__pycache__/base.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
+platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/core/indexes/__pycache__/multi.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
+platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/core/groupby/__pycache__/generic.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
+platform/dataops/dto/.venv/lib/python3.12/site-packages/pandas/core/groupby/__pycache__/groupby.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text

platform/dataops/dto/.venv/lib/python3.12/site-packages/cassandra/datastax/cloud/__init__.py

@@ -0,0 +1,193 @@
+# Copyright DataStax, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import os
+import logging
+import json
+import sys
+import tempfile
+import shutil
+from urllib.request import urlopen
+
+_HAS_SSL = True
+try:
+    from ssl import SSLContext, PROTOCOL_TLS, CERT_REQUIRED
+except:
+    _HAS_SSL = False
+
+from zipfile import ZipFile
+
+# 2.7 vs 3.x
+try:
+    from zipfile import BadZipFile
+except:
+    from zipfile import BadZipfile as BadZipFile
+
+from cassandra import DriverException
+
+log = logging.getLogger(__name__)
+
+__all__ = ['get_cloud_config']
+
+DATASTAX_CLOUD_PRODUCT_TYPE = "DATASTAX_APOLLO"
+
+
+class CloudConfig(object):
+
+    username = None
+    password = None
+    host = None
+    port = None
+    keyspace = None
+    local_dc = None
+    ssl_context = None
+
+    sni_host = None
+    sni_port = None
+    host_ids = None
+
+    @classmethod
+    def from_dict(cls, d):
+        c = cls()
+
+        c.port = d.get('port', None)
+        try:
+            c.port = int(d['port'])
+        except:
+            pass
+
+        c.username = d.get('username', None)
+        c.password = d.get('password', None)
+        c.host = d.get('host', None)
+        c.keyspace = d.get('keyspace', None)
+        c.local_dc = d.get('localDC', None)
+
+        return c
+
+
+def get_cloud_config(cloud_config, create_pyopenssl_context=False):
+    if not _HAS_SSL:
+        raise DriverException("A Python installation with SSL is required to connect to a cloud cluster.")
+
+    if 'secure_connect_bundle' not in cloud_config:
+        raise ValueError("The cloud config doesn't have a secure_connect_bundle specified.")
+
+    try:
+        config = read_cloud_config_from_zip(cloud_config, create_pyopenssl_context)
+    except BadZipFile:
+        raise ValueError("Unable to open the zip file for the cloud config. Check your secure connect bundle.")
+
+    config = read_metadata_info(config, cloud_config)
+    if create_pyopenssl_context:
+        config.ssl_context = config.pyopenssl_context
+    return config
+
+
+def read_cloud_config_from_zip(cloud_config, create_pyopenssl_context):
+    secure_bundle = cloud_config['secure_connect_bundle']
+    use_default_tempdir = cloud_config.get('use_default_tempdir', None)
+    with ZipFile(secure_bundle) as zipfile:
+        base_dir = tempfile.gettempdir() if use_default_tempdir else os.path.dirname(secure_bundle)
+        tmp_dir = tempfile.mkdtemp(dir=base_dir)
+        try:
+            zipfile.extractall(path=tmp_dir)
+            return parse_cloud_config(os.path.join(tmp_dir, 'config.json'), cloud_config, create_pyopenssl_context)
+        finally:
+            shutil.rmtree(tmp_dir)
+
+
+def parse_cloud_config(path, cloud_config, create_pyopenssl_context):
+    with open(path, 'r') as stream:
+        data = json.load(stream)
+
+    config = CloudConfig.from_dict(data)
+    config_dir = os.path.dirname(path)
+
+    if 'ssl_context' in cloud_config:
+        config.ssl_context = cloud_config['ssl_context']
+    else:
+        # Load the ssl_context before we delete the temporary directory
+        ca_cert_location = os.path.join(config_dir, 'ca.crt')
+        cert_location = os.path.join(config_dir, 'cert')
+        key_location = os.path.join(config_dir, 'key')
+        # Regardless of if we create a pyopenssl context, we still need the builtin one
+        # to connect to the metadata service
+        config.ssl_context = _ssl_context_from_cert(ca_cert_location, cert_location, key_location)
+        if create_pyopenssl_context:
+            config.pyopenssl_context = _pyopenssl_context_from_cert(ca_cert_location, cert_location, key_location)
+
+    return config
+
+
+def read_metadata_info(config, cloud_config):
+    url = "https://{}:{}/metadata".format(config.host, config.port)
+    timeout = cloud_config['connect_timeout'] if 'connect_timeout' in cloud_config else 5
+    try:
+        response = urlopen(url, context=config.ssl_context, timeout=timeout)
+    except Exception as e:
+        log.exception(e)
+        raise DriverException("Unable to connect to the metadata service at %s. "
+                              "Check the cluster status in the cloud console. " % url)
+
+    if response.code != 200:
+        raise DriverException(("Error while fetching the metadata at: %s. "
+                               "The service returned error code %d." % (url, response.code)))
+    return parse_metadata_info(config, response.read().decode('utf-8'))
+
+
+def parse_metadata_info(config, http_data):
+    try:
+        data = json.loads(http_data)
+    except:
+        msg = "Failed to load cluster metadata"
+        raise DriverException(msg)
+
+    contact_info = data['contact_info']
+    config.local_dc = contact_info['local_dc']
+
+    proxy_info = contact_info['sni_proxy_address'].split(':')
+    config.sni_host = proxy_info[0]
+    try:
+        config.sni_port = int(proxy_info[1])
+    except:
+        config.sni_port = 9042
+
+    config.host_ids = [host_id for host_id in contact_info['contact_points']]
+
+    return config
+
+
+def _ssl_context_from_cert(ca_cert_location, cert_location, key_location):
+    ssl_context = SSLContext(PROTOCOL_TLS)
+    ssl_context.load_verify_locations(ca_cert_location)
+    ssl_context.verify_mode = CERT_REQUIRED
+    ssl_context.load_cert_chain(certfile=cert_location, keyfile=key_location)
+
+    return ssl_context
+
+
+def _pyopenssl_context_from_cert(ca_cert_location, cert_location, key_location):
+    try:
+        from OpenSSL import SSL
+    except ImportError as e:
+        raise ImportError(
+            "PyOpenSSL must be installed to connect to Astra with the Eventlet or Twisted event loops")\
+            .with_traceback(e.__traceback__)
+    ssl_context = SSL.Context(SSL.TLSv1_METHOD)
+    ssl_context.set_verify(SSL.VERIFY_PEER, callback=lambda _1, _2, _3, _4, ok: ok)
+    ssl_context.use_certificate_file(cert_location)
+    ssl_context.use_privatekey_file(key_location)
+    ssl_context.load_verify_locations(ca_cert_location)
+
+    return ssl_context

platform/dataops/dto/.venv/lib/python3.12/site-packages/cassandra/datastax/graph/__init__.py

@@ -0,0 +1,23 @@
+# Copyright DataStax, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+from cassandra.datastax.graph.types import Element, Vertex, VertexProperty, Edge, Path, T
+from cassandra.datastax.graph.query import (
+    GraphOptions, GraphProtocol, GraphStatement, SimpleGraphStatement, Result,
+    graph_object_row_factory, single_object_row_factory,
+    graph_result_row_factory, graph_graphson2_row_factory,
+    graph_graphson3_row_factory
+)
+from cassandra.datastax.graph.graphson import *

platform/dataops/dto/.venv/lib/python3.12/site-packages/cassandra/datastax/graph/fluent/__init__.py

@@ -0,0 +1,303 @@
+# Copyright DataStax, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import logging
+import copy
+
+from concurrent.futures import Future
+
+HAVE_GREMLIN = False
+try:
+    import gremlin_python
+    HAVE_GREMLIN = True
+except ImportError:
+    # gremlinpython is not installed.
+    pass
+
+if HAVE_GREMLIN:
+    from gremlin_python.structure.graph import Graph
+    from gremlin_python.driver.remote_connection import RemoteConnection, RemoteTraversal
+    from gremlin_python.process.traversal import Traverser, TraversalSideEffects
+    from gremlin_python.process.graph_traversal import GraphTraversal
+
+    from cassandra.cluster import Session, GraphExecutionProfile, EXEC_PROFILE_GRAPH_DEFAULT
+    from cassandra.datastax.graph import GraphOptions, GraphProtocol
+    from cassandra.datastax.graph.query import _GraphSONContextRowFactory
+
+    from cassandra.datastax.graph.fluent.serializers import (
+        GremlinGraphSONReaderV2,
+        GremlinGraphSONReaderV3,
+        dse_graphson2_deserializers,
+        gremlin_graphson2_deserializers,
+        dse_graphson3_deserializers,
+        gremlin_graphson3_deserializers
+    )
+    from cassandra.datastax.graph.fluent.query import _DefaultTraversalBatch, _query_from_traversal
+
+    log = logging.getLogger(__name__)
+
+    __all__ = ['BaseGraphRowFactory', 'graph_traversal_row_factory',
+               'graph_traversal_dse_object_row_factory', 'DSESessionRemoteGraphConnection', 'DseGraph']
+
+    # Traversal result keys
+    _bulk_key = 'bulk'
+    _result_key = 'result'
+
+
+    class BaseGraphRowFactory(_GraphSONContextRowFactory):
+        """
+        Base row factory for graph traversal. This class basically wraps a
+        graphson reader function to handle additional features of Gremlin/DSE
+        and is callable as a normal row factory.
+
+        Currently supported:
+          - bulk results
+        """
+
+        def __call__(self, column_names, rows):
+            for row in rows:
+                parsed_row = self.graphson_reader.readObject(row[0])
+                yield parsed_row[_result_key]
+                bulk = parsed_row.get(_bulk_key, 1)
+                for _ in range(bulk - 1):
+                    yield copy.deepcopy(parsed_row[_result_key])
+
+
+    class _GremlinGraphSON2RowFactory(BaseGraphRowFactory):
+        """Row Factory that returns the decoded graphson2."""
+        graphson_reader_class = GremlinGraphSONReaderV2
+        graphson_reader_kwargs = {'deserializer_map': gremlin_graphson2_deserializers}
+
+
+    class _DseGraphSON2RowFactory(BaseGraphRowFactory):
+        """Row Factory that returns the decoded graphson2 as DSE types."""
+        graphson_reader_class = GremlinGraphSONReaderV2
+        graphson_reader_kwargs = {'deserializer_map': dse_graphson2_deserializers}
+
+    gremlin_graphson2_traversal_row_factory = _GremlinGraphSON2RowFactory
+    # TODO remove in next major
+    graph_traversal_row_factory = gremlin_graphson2_traversal_row_factory
+
+    dse_graphson2_traversal_row_factory = _DseGraphSON2RowFactory
+    # TODO remove in next major
+    graph_traversal_dse_object_row_factory = dse_graphson2_traversal_row_factory
+
+
+    class _GremlinGraphSON3RowFactory(BaseGraphRowFactory):
+        """Row Factory that returns the decoded graphson2."""
+        graphson_reader_class = GremlinGraphSONReaderV3
+        graphson_reader_kwargs = {'deserializer_map': gremlin_graphson3_deserializers}
+
+
+    class _DseGraphSON3RowFactory(BaseGraphRowFactory):
+        """Row Factory that returns the decoded graphson3 as DSE types."""
+        graphson_reader_class = GremlinGraphSONReaderV3
+        graphson_reader_kwargs = {'deserializer_map': dse_graphson3_deserializers}
+
+
+    gremlin_graphson3_traversal_row_factory = _GremlinGraphSON3RowFactory
+    dse_graphson3_traversal_row_factory = _DseGraphSON3RowFactory
+
+
+    class DSESessionRemoteGraphConnection(RemoteConnection):
+        """
+        A Tinkerpop RemoteConnection to execute traversal queries on DSE.
+
+        :param session: A DSE session
+        :param graph_name: (Optional) DSE Graph name.
+        :param execution_profile: (Optional) Execution profile for traversal queries. Default is set to `EXEC_PROFILE_GRAPH_DEFAULT`.
+        """
+
+        session = None
+        graph_name = None
+        execution_profile = None
+
+        def __init__(self, session, graph_name=None, execution_profile=EXEC_PROFILE_GRAPH_DEFAULT):
+            super(DSESessionRemoteGraphConnection, self).__init__(None, None)
+
+            if not isinstance(session, Session):
+                raise ValueError('A DSE Session must be provided to execute graph traversal queries.')
+
+            self.session = session
+            self.graph_name = graph_name
+            self.execution_profile = execution_profile
+
+        @staticmethod
+        def _traversers_generator(traversers):
+            for t in traversers:
+                yield Traverser(t)
+
+        def _prepare_query(self, bytecode):
+            ep = self.session.execution_profile_clone_update(self.execution_profile)
+            graph_options = ep.graph_options
+            graph_options.graph_name = self.graph_name or graph_options.graph_name
+            graph_options.graph_language = DseGraph.DSE_GRAPH_QUERY_LANGUAGE
+            # We resolve the execution profile options here , to know how what gremlin factory to set
+            self.session._resolve_execution_profile_options(ep)
+
+            context = None
+            if graph_options.graph_protocol == GraphProtocol.GRAPHSON_2_0:
+                row_factory = gremlin_graphson2_traversal_row_factory
+            elif graph_options.graph_protocol == GraphProtocol.GRAPHSON_3_0:
+                row_factory = gremlin_graphson3_traversal_row_factory
+                context = {
+                    'cluster': self.session.cluster,
+                    'graph_name': graph_options.graph_name.decode('utf-8')
+                }
+            else:
+                raise ValueError('Unknown graph protocol: {}'.format(graph_options.graph_protocol))
+
+            ep.row_factory = row_factory
+            query = DseGraph.query_from_traversal(bytecode, graph_options.graph_protocol, context)
+
+            return query, ep
+
+        @staticmethod
+        def _handle_query_results(result_set, gremlin_future):
+            try:
+                gremlin_future.set_result(
+                    RemoteTraversal(DSESessionRemoteGraphConnection._traversers_generator(result_set), TraversalSideEffects())
+                )
+            except Exception as e:
+                gremlin_future.set_exception(e)
+
+        @staticmethod
+        def _handle_query_error(response, gremlin_future):
+            gremlin_future.set_exception(response)
+
+        def submit(self, bytecode):
+            # the only reason I don't use submitAsync here
+            # is to avoid an unuseful future wrap
+            query, ep = self._prepare_query(bytecode)
+
+            traversers = self.session.execute_graph(query, execution_profile=ep)
+            return RemoteTraversal(self._traversers_generator(traversers), TraversalSideEffects())
+
+        def submitAsync(self, bytecode):
+            query, ep = self._prepare_query(bytecode)
+
+            # to be compatible with gremlinpython, we need to return a concurrent.futures.Future
+            gremlin_future = Future()
+            response_future = self.session.execute_graph_async(query, execution_profile=ep)
+            response_future.add_callback(self._handle_query_results, gremlin_future)
+            response_future.add_errback(self._handle_query_error, gremlin_future)
+
+            return gremlin_future
+
+        def __str__(self):
+            return "<DSESessionRemoteGraphConnection: graph_name='{0}'>".format(self.graph_name)
+
+        __repr__ = __str__
+
+
+    class DseGraph(object):
+        """
+        Dse Graph utility class for GraphTraversal construction and execution.
+        """
+
+        DSE_GRAPH_QUERY_LANGUAGE = 'bytecode-json'
+        """
+        Graph query language, Default is 'bytecode-json' (GraphSON).
+        """
+
+        DSE_GRAPH_QUERY_PROTOCOL = GraphProtocol.GRAPHSON_2_0
+        """
+        Graph query language, Default is GraphProtocol.GRAPHSON_2_0.
+        """
+
+        @staticmethod
+        def query_from_traversal(traversal, graph_protocol=DSE_GRAPH_QUERY_PROTOCOL, context=None):
+            """
+            From a GraphTraversal, return a query string based on the language specified in `DseGraph.DSE_GRAPH_QUERY_LANGUAGE`.
+
+            :param traversal: The GraphTraversal object
+            :param graph_protocol: The graph protocol. Default is `DseGraph.DSE_GRAPH_QUERY_PROTOCOL`.
+            :param context: The dict of the serialization context, needed for GraphSON3 (tuple, udt).
+                            e.g: {'cluster': cluster, 'graph_name': name}
+            """
+
+            if isinstance(traversal, GraphTraversal):
+                for strategy in traversal.traversal_strategies.traversal_strategies:
+                    rc = strategy.remote_connection
+                    if (isinstance(rc, DSESessionRemoteGraphConnection) and
+                            rc.session or rc.graph_name or rc.execution_profile):
+                        log.warning("GraphTraversal session, graph_name and execution_profile are "
+                                    "only taken into account when executed with TinkerPop.")
+
+            return _query_from_traversal(traversal, graph_protocol, context)
+
+        @staticmethod
+        def traversal_source(session=None, graph_name=None, execution_profile=EXEC_PROFILE_GRAPH_DEFAULT,
+                             traversal_class=None):
+            """
+            Returns a TinkerPop GraphTraversalSource binded to the session and graph_name if provided.
+
+            :param session: (Optional) A DSE session
+            :param graph_name: (Optional) DSE Graph name
+            :param execution_profile: (Optional) Execution profile for traversal queries. Default is set to `EXEC_PROFILE_GRAPH_DEFAULT`.
+            :param traversal_class: (Optional) The GraphTraversalSource class to use (DSL).
+
+            .. code-block:: python
+
+                from cassandra.cluster import Cluster
+                from cassandra.datastax.graph.fluent import DseGraph
+
+                c = Cluster()
+                session = c.connect()
+
+                g = DseGraph.traversal_source(session, 'my_graph')
+                print(g.V().valueMap().toList())
+
+            """
+
+            graph = Graph()
+            traversal_source = graph.traversal(traversal_class)
+
+            if session:
+                traversal_source = traversal_source.withRemote(
+                    DSESessionRemoteGraphConnection(session, graph_name, execution_profile))
+
+            return traversal_source
+
+        @staticmethod
+        def create_execution_profile(graph_name, graph_protocol=DSE_GRAPH_QUERY_PROTOCOL, **kwargs):
+            """
+            Creates an ExecutionProfile for GraphTraversal execution. You need to register that execution profile to the
+            cluster by using `cluster.add_execution_profile`.
+
+            :param graph_name: The graph name
+            :param graph_protocol: (Optional) The graph protocol, default is `DSE_GRAPH_QUERY_PROTOCOL`.
+            """
+
+            if graph_protocol == GraphProtocol.GRAPHSON_2_0:
+                row_factory = dse_graphson2_traversal_row_factory
+            elif graph_protocol == GraphProtocol.GRAPHSON_3_0:
+                row_factory = dse_graphson3_traversal_row_factory
+            else:
+                raise ValueError('Unknown graph protocol: {}'.format(graph_protocol))
+
+            ep = GraphExecutionProfile(row_factory=row_factory,
+                                       graph_options=GraphOptions(graph_name=graph_name,
+                                                                  graph_language=DseGraph.DSE_GRAPH_QUERY_LANGUAGE,
+                                                                  graph_protocol=graph_protocol),
+                                       **kwargs)
+            return ep
+
+        @staticmethod
+        def batch(*args, **kwargs):
+            """
+            Returns the :class:`cassandra.datastax.graph.fluent.query.TraversalBatch` object allowing to
+            execute multiple traversals in the same transaction.
+            """
+            return _DefaultTraversalBatch(*args, **kwargs)

platform/dataops/dto/.venv/lib/python3.12/site-packages/cassandra/datastax/graph/fluent/_predicates.py

@@ -0,0 +1,202 @@
+# Copyright DataStax, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import math
+
+from gremlin_python.process.traversal import P
+
+from cassandra.util import Distance
+
+__all__ = ['GeoP', 'TextDistanceP', 'Search', 'GeoUnit', 'Geo', 'CqlCollection']
+
+
+class GeoP(object):
+
+    def __init__(self, operator, value, other=None):
+        self.operator = operator
+        self.value = value
+        self.other = other
+
+    @staticmethod
+    def inside(*args, **kwargs):
+        return GeoP("inside", *args, **kwargs)
+
+    def __eq__(self, other):
+        return isinstance(other,
+                          self.__class__) and self.operator == other.operator and self.value == other.value and self.other == other.other
+
+    def __repr__(self):
+        return self.operator + "(" + str(self.value) + ")" if self.other is None else self.operator + "(" + str(
+            self.value) + "," + str(self.other) + ")"
+
+
+class TextDistanceP(object):
+
+    def __init__(self, operator, value, distance):
+        self.operator = operator
+        self.value = value
+        self.distance = distance
+
+    @staticmethod
+    def fuzzy(*args):
+        return TextDistanceP("fuzzy", *args)
+
+    @staticmethod
+    def token_fuzzy(*args):
+        return TextDistanceP("tokenFuzzy", *args)
+
+    @staticmethod
+    def phrase(*args):
+        return TextDistanceP("phrase", *args)
+
+    def __eq__(self, other):
+        return isinstance(other,
+                          self.__class__) and self.operator == other.operator and self.value == other.value and self.distance == other.distance
+
+    def __repr__(self):
+        return self.operator + "(" + str(self.value) + "," + str(self.distance) + ")"
+
+
+class Search(object):
+
+    @staticmethod
+    def token(value):
+        """
+        Search any instance of a certain token within the text property targeted.
+        :param value: the value to look for.
+        """
+        return P('token', value)
+
+    @staticmethod
+    def token_prefix(value):
+        """
+        Search any instance of a certain token prefix withing the text property targeted.
+        :param value: the value to look for.
+        """
+        return P('tokenPrefix', value)
+
+    @staticmethod
+    def token_regex(value):
+        """
+        Search any instance of the provided regular expression for the targeted property.
+        :param value: the value to look for.
+        """
+        return P('tokenRegex', value)
+
+    @staticmethod
+    def prefix(value):
+        """
+        Search for a specific prefix at the beginning of the text property targeted.
+        :param value: the value to look for.
+        """
+        return P('prefix', value)
+
+    @staticmethod
+    def regex(value):
+        """
+        Search for this regular expression inside the text property targeted.
+        :param value: the value to look for.
+        """
+        return P('regex', value)
+
+    @staticmethod
+    def fuzzy(value, distance):
+        """
+        Search for a fuzzy string inside the text property targeted.
+        :param value: the value to look for.
+        :param distance: The distance for the fuzzy search. ie. 1, to allow a one-letter misspellings.
+        """
+        return TextDistanceP.fuzzy(value, distance)
+
+    @staticmethod
+    def token_fuzzy(value, distance):
+        """
+        Search for a token fuzzy inside the text property targeted.
+        :param value: the value to look for.
+        :param distance: The distance for the token fuzzy search. ie. 1, to allow a one-letter misspellings.
+        """
+        return TextDistanceP.token_fuzzy(value, distance)
+
+    @staticmethod
+    def phrase(value, proximity):
+        """
+        Search for a phrase inside the text property targeted.
+        :param value: the value to look for.
+        :param proximity: The proximity for the phrase search. ie. phrase('David Felcey', 2).. to find 'David Felcey' with up to two middle names.
+        """
+        return TextDistanceP.phrase(value, proximity)
+
+
+class CqlCollection(object):
+
+    @staticmethod
+    def contains(value):
+        """
+        Search for a value inside a cql list/set column.
+        :param value: the value to look for.
+        """
+        return P('contains', value)
+
+    @staticmethod
+    def contains_value(value):
+        """
+        Search for a map value.
+        :param value: the value to look for.
+        """
+        return P('containsValue', value)
+
+    @staticmethod
+    def contains_key(value):
+        """
+        Search for a map key.
+        :param value: the value to look for.
+        """
+        return P('containsKey', value)
+
+    @staticmethod
+    def entry_eq(value):
+        """
+        Search for a map entry.
+        :param value: the value to look for.
+        """
+        return P('entryEq', value)
+
+
+class GeoUnit(object):
+    _EARTH_MEAN_RADIUS_KM = 6371.0087714
+    _DEGREES_TO_RADIANS = math.pi / 180
+    _DEG_TO_KM = _DEGREES_TO_RADIANS * _EARTH_MEAN_RADIUS_KM
+    _KM_TO_DEG = 1 / _DEG_TO_KM
+    _MILES_TO_KM = 1.609344001
+
+    MILES = _MILES_TO_KM * _KM_TO_DEG
+    KILOMETERS = _KM_TO_DEG
+    METERS = _KM_TO_DEG / 1000.0
+    DEGREES = 1
+
+
+class Geo(object):
+
+    @staticmethod
+    def inside(value, units=GeoUnit.DEGREES):
+        """
+        Search any instance of geometry inside the Distance targeted.
+        :param value: A Distance to look for.
+        :param units: The units for ``value``. See GeoUnit enum. (Can also
+        provide an integer to use as a multiplier to convert ``value`` to
+        degrees.)
+        """
+        return GeoP.inside(
+            value=Distance(x=value.x, y=value.y, radius=value.radius * units)
+        )

platform/dataops/dto/.venv/lib/python3.12/site-packages/cassandra/datastax/graph/fluent/_query.py

@@ -0,0 +1,228 @@
+# Copyright DataStax, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import logging
+
+from cassandra.graph import SimpleGraphStatement, GraphProtocol
+from cassandra.cluster import EXEC_PROFILE_GRAPH_DEFAULT
+
+from gremlin_python.process.graph_traversal import GraphTraversal
+from gremlin_python.structure.io.graphsonV2d0 import GraphSONWriter as GraphSONWriterV2
+from gremlin_python.structure.io.graphsonV3d0 import GraphSONWriter as GraphSONWriterV3
+
+from cassandra.datastax.graph.fluent.serializers import GremlinUserTypeIO, \
+    dse_graphson2_serializers, dse_graphson3_serializers
+
+log = logging.getLogger(__name__)
+
+
+__all__ = ['TraversalBatch', '_query_from_traversal', '_DefaultTraversalBatch']
+
+
+class _GremlinGraphSONWriterAdapter(object):
+
+    def __init__(self, context, **kwargs):
+        super(_GremlinGraphSONWriterAdapter, self).__init__(**kwargs)
+        self.context = context
+        self.user_types = None
+
+    def serialize(self, value, _):
+        return self.toDict(value)
+
+    def get_serializer(self, value):
+        serializer = None
+        try:
+            serializer = self.serializers[type(value)]
+        except KeyError:
+            for key, ser in self.serializers.items():
+                if isinstance(value, key):
+                    serializer = ser
+
+        if self.context:
+            # Check if UDT
+            if self.user_types is None:
+                try:
+                    user_types = self.context['cluster']._user_types[self.context['graph_name']]
+                    self.user_types = dict(map(reversed, user_types.items()))
+                except KeyError:
+                    self.user_types = {}
+
+            # Custom detection to map a namedtuple to udt
+            if (tuple in self.serializers and serializer is self.serializers[tuple] and hasattr(value, '_fields') or
+                (not serializer and type(value) in self.user_types)):
+                serializer = GremlinUserTypeIO
+
+        if serializer:
+            try:
+                # A serializer can have specialized serializers (e.g for Int32 and Int64, so value dependant)
+                serializer = serializer.get_specialized_serializer(value)
+            except AttributeError:
+                pass
+
+        return serializer
+
+    def toDict(self, obj):
+        serializer = self.get_serializer(obj)
+        return serializer.dictify(obj, self) if serializer else obj
+
+    def definition(self, value):
+        serializer = self.get_serializer(value)
+        return serializer.definition(value, self)
+
+
+class GremlinGraphSON2Writer(_GremlinGraphSONWriterAdapter, GraphSONWriterV2):
+    pass
+
+
+class GremlinGraphSON3Writer(_GremlinGraphSONWriterAdapter, GraphSONWriterV3):
+    pass
+
+
+graphson2_writer = GremlinGraphSON2Writer
+graphson3_writer = GremlinGraphSON3Writer
+
+
+def _query_from_traversal(traversal, graph_protocol, context=None):
+    """
+    From a GraphTraversal, return a query string.
+
+    :param traversal: The GraphTraversal object
+    :param graphson_protocol: The graph protocol to determine the output format.
+    """
+    if graph_protocol == GraphProtocol.GRAPHSON_2_0:
+        graphson_writer = graphson2_writer(context, serializer_map=dse_graphson2_serializers)
+    elif graph_protocol == GraphProtocol.GRAPHSON_3_0:
+        if context is None:
+            raise ValueError('Missing context for GraphSON3 serialization requires.')
+        graphson_writer = graphson3_writer(context, serializer_map=dse_graphson3_serializers)
+    else:
+        raise ValueError('Unknown graph protocol: {}'.format(graph_protocol))
+
+    try:
+        query = graphson_writer.writeObject(traversal)
+    except Exception:
+        log.exception("Error preparing graphson traversal query:")
+        raise
+
+    return query
+
+
+class TraversalBatch(object):
+    """
+    A `TraversalBatch` is used to execute multiple graph traversals in a
+    single transaction. If any traversal in the batch fails, the entire
+    batch will fail to apply.
+
+    If a TraversalBatch is bounded to a DSE session, it can be executed using
+    `traversal_batch.execute()`.
+    """
+
+    _session = None
+    _execution_profile = None
+
+    def __init__(self, session=None, execution_profile=None):
+        """
+        :param session: (Optional) A DSE session
+        :param execution_profile: (Optional) The execution profile to use for the batch execution
+        """
+        self._session = session
+        self._execution_profile = execution_profile
+
+    def add(self, traversal):
+        """
+        Add a traversal to the batch.
+
+        :param traversal: A gremlin GraphTraversal
+        """
+        raise NotImplementedError()
+
+    def add_all(self, traversals):
+        """
+        Adds a sequence of traversals to the batch.
+
+        :param traversals: A sequence of gremlin GraphTraversal
+        """
+        raise NotImplementedError()
+
+    def execute(self):
+        """
+        Execute the traversal batch if bounded to a `DSE Session`.
+        """
+        raise NotImplementedError()
+
+    def as_graph_statement(self, graph_protocol=GraphProtocol.GRAPHSON_2_0):
+        """
+        Return the traversal batch as GraphStatement.
+
+        :param graph_protocol: The graph protocol for the GraphSONWriter. Default is GraphProtocol.GRAPHSON_2_0.
+        """
+        raise NotImplementedError()
+
+    def clear(self):
+        """
+        Clear a traversal batch for reuse.
+        """
+        raise NotImplementedError()
+
+    def __len__(self):
+        raise NotImplementedError()
+
+    def __str__(self):
+        return u'<TraversalBatch traversals={0}>'.format(len(self))
+    __repr__ = __str__
+
+
+class _DefaultTraversalBatch(TraversalBatch):
+
+    _traversals = None
+
+    def __init__(self, *args, **kwargs):
+        super(_DefaultTraversalBatch, self).__init__(*args, **kwargs)
+        self._traversals = []
+
+    def add(self, traversal):
+        if not isinstance(traversal, GraphTraversal):
+            raise ValueError('traversal should be a gremlin GraphTraversal')
+
+        self._traversals.append(traversal)
+        return self
+
+    def add_all(self, traversals):
+        for traversal in traversals:
+            self.add(traversal)
+
+    def as_graph_statement(self, graph_protocol=GraphProtocol.GRAPHSON_2_0, context=None):
+        statements = [_query_from_traversal(t, graph_protocol, context) for t in self._traversals]
+        query = u"[{0}]".format(','.join(statements))
+        return SimpleGraphStatement(query)
+
+    def execute(self):
+        if self._session is None:
+            raise ValueError('A DSE Session must be provided to execute the traversal batch.')
+
+        execution_profile = self._execution_profile if self._execution_profile else EXEC_PROFILE_GRAPH_DEFAULT
+        graph_options = self._session.get_execution_profile(execution_profile).graph_options
+        context = {
+            'cluster': self._session.cluster,
+            'graph_name': graph_options.graph_name
+        }
+        statement = self.as_graph_statement(graph_options.graph_protocol, context=context) \
+            if graph_options.graph_protocol else self.as_graph_statement(context=context)
+        return self._session.execute_graph(statement, execution_profile=execution_profile)
+
+    def clear(self):
+        del self._traversals[:]
+
+    def __len__(self):
+        return len(self._traversals)

platform/dataops/dto/.venv/lib/python3.12/site-packages/cassandra/datastax/graph/fluent/_serializers.py

@@ -0,0 +1,260 @@
+# Copyright DataStax, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from collections import OrderedDict
+
+from gremlin_python.structure.io.graphsonV2d0 import (
+    GraphSONReader as GraphSONReaderV2,
+    GraphSONUtil as GraphSONUtil,  # no difference between v2 and v3
+    VertexDeserializer as VertexDeserializerV2,
+    VertexPropertyDeserializer as VertexPropertyDeserializerV2,
+    PropertyDeserializer as PropertyDeserializerV2,
+    EdgeDeserializer as EdgeDeserializerV2,
+    PathDeserializer as PathDeserializerV2
+)
+
+from gremlin_python.structure.io.graphsonV3d0 import (
+    GraphSONReader as GraphSONReaderV3,
+    VertexDeserializer as VertexDeserializerV3,
+    VertexPropertyDeserializer as VertexPropertyDeserializerV3,
+    PropertyDeserializer as PropertyDeserializerV3,
+    EdgeDeserializer as EdgeDeserializerV3,
+    PathDeserializer as PathDeserializerV3
+)
+
+try:
+    from gremlin_python.structure.io.graphsonV2d0 import (
+        TraversalMetricsDeserializer as TraversalMetricsDeserializerV2,
+        MetricsDeserializer as MetricsDeserializerV2
+    )
+    from gremlin_python.structure.io.graphsonV3d0 import (
+        TraversalMetricsDeserializer as TraversalMetricsDeserializerV3,
+        MetricsDeserializer as MetricsDeserializerV3
+    )
+except ImportError:
+    TraversalMetricsDeserializerV2 = MetricsDeserializerV2 = None
+    TraversalMetricsDeserializerV3 = MetricsDeserializerV3 = None
+
+from cassandra.graph import (
+    GraphSON2Serializer,
+    GraphSON2Deserializer,
+    GraphSON3Serializer,
+    GraphSON3Deserializer
+)
+from cassandra.graph.graphson import UserTypeIO, TypeWrapperTypeIO
+from cassandra.datastax.graph.fluent.predicates import GeoP, TextDistanceP
+from cassandra.util import Distance
+
+
+__all__ = ['GremlinGraphSONReader', 'GeoPSerializer', 'TextDistancePSerializer',
+           'DistanceIO', 'gremlin_deserializers', 'deserializers', 'serializers',
+           'GremlinGraphSONReaderV2', 'GremlinGraphSONReaderV3', 'dse_graphson2_serializers',
+           'dse_graphson2_deserializers', 'dse_graphson3_serializers', 'dse_graphson3_deserializers',
+           'gremlin_graphson2_deserializers', 'gremlin_graphson3_deserializers', 'GremlinUserTypeIO']
+
+
+class _GremlinGraphSONTypeSerializer(object):
+    TYPE_KEY = "@type"
+    VALUE_KEY = "@value"
+    serializer = None
+
+    def __init__(self, serializer):
+        self.serializer = serializer
+
+    def dictify(self, v, writer):
+        value = self.serializer.serialize(v, writer)
+        if self.serializer is TypeWrapperTypeIO:
+            graphson_base_type = v.type_io.graphson_base_type
+            graphson_type = v.type_io.graphson_type
+        else:
+            graphson_base_type = self.serializer.graphson_base_type
+            graphson_type = self.serializer.graphson_type
+
+        if graphson_base_type is None:
+            out = value
+        else:
+            out = {self.TYPE_KEY: graphson_type}
+            if value is not None:
+                out[self.VALUE_KEY] = value
+
+        return out
+
+    def definition(self, value, writer=None):
+        return self.serializer.definition(value, writer)
+
+    def get_specialized_serializer(self, value):
+        ser = self.serializer.get_specialized_serializer(value)
+        if ser is not self.serializer:
+            return _GremlinGraphSONTypeSerializer(ser)
+        return self
+
+
+class _GremlinGraphSONTypeDeserializer(object):
+
+    deserializer = None
+
+    def __init__(self, deserializer):
+        self.deserializer = deserializer
+
+    def objectify(self, v, reader):
+        return self.deserializer.deserialize(v, reader)
+
+
+def _make_gremlin_graphson2_deserializer(graphson_type):
+    return _GremlinGraphSONTypeDeserializer(
+        GraphSON2Deserializer.get_deserializer(graphson_type.graphson_type)
+    )
+
+
+def _make_gremlin_graphson3_deserializer(graphson_type):
+    return _GremlinGraphSONTypeDeserializer(
+        GraphSON3Deserializer.get_deserializer(graphson_type.graphson_type)
+    )
+
+
+class _GremlinGraphSONReader(object):
+    """Gremlin GraphSONReader Adapter, required to use gremlin types"""
+
+    context = None
+
+    def __init__(self, context, deserializer_map=None):
+        self.context = context
+        super(_GremlinGraphSONReader, self).__init__(deserializer_map)
+
+    def deserialize(self, obj):
+        return self.toObject(obj)
+
+
+class GremlinGraphSONReaderV2(_GremlinGraphSONReader, GraphSONReaderV2):
+    pass
+
+# TODO remove next major
+GremlinGraphSONReader = GremlinGraphSONReaderV2
+
+class GremlinGraphSONReaderV3(_GremlinGraphSONReader, GraphSONReaderV3):
+    pass
+
+
+class GeoPSerializer(object):
+    @classmethod
+    def dictify(cls, p, writer):
+        out = {
+            "predicateType": "Geo",
+            "predicate": p.operator,
+            "value": [writer.toDict(p.value), writer.toDict(p.other)] if p.other is not None else writer.toDict(p.value)
+        }
+        return GraphSONUtil.typedValue("P", out, prefix='dse')
+
+
+class TextDistancePSerializer(object):
+    @classmethod
+    def dictify(cls, p, writer):
+        out = {
+            "predicate": p.operator,
+            "value": {
+                'query': writer.toDict(p.value),
+                'distance': writer.toDict(p.distance)
+            }
+        }
+        return GraphSONUtil.typedValue("P", out)
+
+
+class DistanceIO(object):
+    @classmethod
+    def dictify(cls, v, _):
+        return GraphSONUtil.typedValue('Distance', str(v), prefix='dse')
+
+
+GremlinUserTypeIO = _GremlinGraphSONTypeSerializer(UserTypeIO)
+
+# GraphSON2
+dse_graphson2_serializers = OrderedDict([
+    (t, _GremlinGraphSONTypeSerializer(s))
+    for t, s in GraphSON2Serializer.get_type_definitions().items()
+])
+
+dse_graphson2_serializers.update(OrderedDict([
+    (Distance, DistanceIO),
+    (GeoP, GeoPSerializer),
+    (TextDistanceP, TextDistancePSerializer)
+]))
+
+# TODO remove next major, this is just in case someone was using it
+serializers = dse_graphson2_serializers
+
+dse_graphson2_deserializers = {
+    k: _make_gremlin_graphson2_deserializer(v)
+    for k, v in GraphSON2Deserializer.get_type_definitions().items()
+}
+
+dse_graphson2_deserializers.update({
+    "dse:Distance": DistanceIO,
+})
+
+# TODO remove next major, this is just in case someone was using it
+deserializers = dse_graphson2_deserializers
+
+gremlin_graphson2_deserializers = dse_graphson2_deserializers.copy()
+gremlin_graphson2_deserializers.update({
+    'g:Vertex': VertexDeserializerV2,
+    'g:VertexProperty': VertexPropertyDeserializerV2,
+    'g:Edge': EdgeDeserializerV2,
+    'g:Property': PropertyDeserializerV2,
+    'g:Path': PathDeserializerV2
+})
+
+if TraversalMetricsDeserializerV2:
+    gremlin_graphson2_deserializers.update({
+        'g:TraversalMetrics': TraversalMetricsDeserializerV2,
+        'g:lMetrics': MetricsDeserializerV2
+    })
+
+# TODO remove next major, this is just in case someone was using it
+gremlin_deserializers = gremlin_graphson2_deserializers
+
+# GraphSON3
+dse_graphson3_serializers = OrderedDict([
+    (t, _GremlinGraphSONTypeSerializer(s))
+    for t, s in GraphSON3Serializer.get_type_definitions().items()
+])
+
+dse_graphson3_serializers.update(OrderedDict([
+    (Distance, DistanceIO),
+    (GeoP, GeoPSerializer),
+    (TextDistanceP, TextDistancePSerializer)
+]))
+
+dse_graphson3_deserializers = {
+    k: _make_gremlin_graphson3_deserializer(v)
+    for k, v in GraphSON3Deserializer.get_type_definitions().items()
+}
+
+dse_graphson3_deserializers.update({
+    "dse:Distance": DistanceIO
+})
+
+gremlin_graphson3_deserializers = dse_graphson3_deserializers.copy()
+gremlin_graphson3_deserializers.update({
+    'g:Vertex': VertexDeserializerV3,
+    'g:VertexProperty': VertexPropertyDeserializerV3,
+    'g:Edge': EdgeDeserializerV3,
+    'g:Property': PropertyDeserializerV3,
+    'g:Path': PathDeserializerV3
+})
+
+if TraversalMetricsDeserializerV3:
+    gremlin_graphson3_deserializers.update({
+        'g:TraversalMetrics': TraversalMetricsDeserializerV3,
+        'g:Metrics': MetricsDeserializerV3
+    })

platform/dataops/dto/.venv/lib/python3.12/site-packages/cassandra/datastax/graph/fluent/predicates.py

@@ -0,0 +1,20 @@
+# Copyright DataStax, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+try:
+    import gremlin_python
+    from cassandra.datastax.graph.fluent._predicates import *
+except ImportError:
+    # gremlinpython is not installed.
+    pass

platform/dataops/dto/.venv/lib/python3.12/site-packages/cassandra/datastax/graph/fluent/query.py

@@ -0,0 +1,20 @@
+# Copyright DataStax, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+try:
+    import gremlin_python
+    from cassandra.datastax.graph.fluent._query import *
+except ImportError:
+    # gremlinpython is not installed.
+    pass

platform/dataops/dto/.venv/lib/python3.12/site-packages/cassandra/datastax/graph/fluent/serializers.py

@@ -0,0 +1,20 @@
+# Copyright DataStax, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+try:
+    import gremlin_python
+    from cassandra.datastax.graph.fluent._serializers import *
+except ImportError:
+    # gremlinpython is not installed.
+    pass

platform/dataops/dto/.venv/lib/python3.12/site-packages/cassandra/datastax/insights/__init__.py

@@ -0,0 +1,13 @@
+# Copyright DataStax, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.

platform/dataops/dto/.venv/lib/python3.12/site-packages/cassandra/datastax/insights/registry.py

@@ -0,0 +1,122 @@
+# Copyright DataStax, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from collections import OrderedDict
+from warnings import warn
+
+from cassandra.datastax.insights.util import namespace
+
+_NOT_SET = object()
+
+
+def _default_serializer_for_object(obj, policy):
+    # the insights server expects an 'options' dict for policy
+    # objects, but not for other objects
+    if policy:
+        return {'type': obj.__class__.__name__,
+                'namespace': namespace(obj.__class__),
+                'options': {}}
+    else:
+        return {'type': obj.__class__.__name__,
+                'namespace': namespace(obj.__class__)}
+
+
+class InsightsSerializerRegistry(object):
+
+    initialized = False
+
+    def __init__(self, mapping_dict=None):
+        mapping_dict = mapping_dict or {}
+        class_order = self._class_topological_sort(mapping_dict)
+        self._mapping_dict = OrderedDict(
+            ((cls, mapping_dict[cls]) for cls in class_order)
+        )
+
+    def serialize(self, obj, policy=False, default=_NOT_SET, cls=None):
+        try:
+            return self._get_serializer(cls if cls is not None else obj.__class__)(obj)
+        except Exception:
+            if default is _NOT_SET:
+                result = _default_serializer_for_object(obj, policy)
+            else:
+                result = default
+
+            return result
+
+    def _get_serializer(self, cls):
+        try:
+            return self._mapping_dict[cls]
+        except KeyError:
+            for registered_cls, serializer in self._mapping_dict.items():
+                if issubclass(cls, registered_cls):
+                    return self._mapping_dict[registered_cls]
+        raise ValueError
+
+    def register(self, cls, serializer):
+        self._mapping_dict[cls] = serializer
+        self._mapping_dict = OrderedDict(
+            ((cls, self._mapping_dict[cls])
+             for cls in self._class_topological_sort(self._mapping_dict))
+        )
+
+    def register_serializer_for(self, cls):
+        """
+        Parameterized registration helper decorator. Given a class `cls`,
+        produces a function that registers the decorated function as a
+        serializer for it.
+        """
+        def decorator(serializer):
+            self.register(cls, serializer)
+            return serializer
+
+        return decorator
+
+    @staticmethod
+    def _class_topological_sort(classes):
+        """
+        A simple topological sort for classes. Takes an iterable of class objects
+        and returns a list A of those classes, ordered such that A[X] is never a
+        superclass of A[Y] for X < Y.
+
+        This is an inefficient sort, but that's ok because classes are infrequently
+        registered. It's more important that this be maintainable than fast.
+
+        We can't use `.sort()` or `sorted()` with a custom `key` -- those assume
+        a total ordering, which we don't have.
+        """
+        unsorted, sorted_ = list(classes), []
+        while unsorted:
+            head, tail = unsorted[0], unsorted[1:]
+
+            # if head has no subclasses remaining, it can safely go in the list
+            if not any(issubclass(x, head) for x in tail):
+                sorted_.append(head)
+            else:
+                # move to the back -- head has to wait until all its subclasses
+                # are sorted into the list
+                tail.append(head)
+
+            unsorted = tail
+
+        # check that sort is valid
+        for i, head in enumerate(sorted_):
+            for after_head_value in sorted_[(i + 1):]:
+                if issubclass(after_head_value, head):
+                    warn('Sorting classes produced an invalid ordering.\n'
+                         'In:  {classes}\n'
+                         'Out: {sorted_}'.format(classes=classes, sorted_=sorted_))
+        return sorted_
+
+
+insights_registry = InsightsSerializerRegistry()

platform/dataops/dto/.venv/lib/python3.12/site-packages/cassandra/datastax/insights/reporter.py

@@ -0,0 +1,221 @@
+# Copyright DataStax, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from collections import Counter
+import datetime
+import json
+import logging
+import multiprocessing
+import random
+import platform
+import socket
+import ssl
+import sys
+from threading import Event, Thread
+import time
+
+from cassandra.policies import HostDistance
+from cassandra.util import ms_timestamp_from_datetime
+from cassandra.datastax.insights.registry import insights_registry
+from cassandra.datastax.insights.serializers  import initialize_registry
+
+log = logging.getLogger(__name__)
+
+
+class MonitorReporter(Thread):
+
+    def __init__(self, interval_sec, session):
+        """
+        takes an int indicating interval between requests, a function returning
+        the connection to be used, and the timeout per request
+        """
+        # Thread is an old-style class so we can't super()
+        Thread.__init__(self, name='monitor_reporter')
+
+        initialize_registry(insights_registry)
+
+        self._interval, self._session = interval_sec, session
+
+        self._shutdown_event = Event()
+        self.daemon = True
+        self.start()
+
+    def run(self):
+        self._send_via_rpc(self._get_startup_data())
+
+        # introduce some jitter -- send up to 1/10 of _interval early
+        self._shutdown_event.wait(self._interval * random.uniform(.9, 1))
+
+        while not self._shutdown_event.is_set():
+            start_time = time.time()
+
+            self._send_via_rpc(self._get_status_data())
+
+            elapsed = time.time() - start_time
+            self._shutdown_event.wait(max(self._interval - elapsed, 0.01))
+
+    # TODO: redundant with ConnectionHeartbeat.ShutdownException
+    class ShutDownException(Exception):
+        pass
+
+    def _send_via_rpc(self, data):
+        try:
+            self._session.execute(
+                "CALL InsightsRpc.reportInsight(%s)", (json.dumps(data),)
+            )
+            log.debug('Insights RPC data: {}'.format(data))
+        except Exception as e:
+            log.debug('Insights RPC send failed with {}'.format(e))
+            log.debug('Insights RPC data: {}'.format(data))
+
+    def _get_status_data(self):
+        cc = self._session.cluster.control_connection
+
+        connected_nodes = {
+            host.address: {
+                'connections': state['open_count'],
+                'inFlightQueries': state['in_flights']
+            }
+            for (host, state) in self._session.get_pool_state().items()
+        }
+
+        return {
+            'metadata': {
+                # shared across drivers; never change
+                'name': 'driver.status',
+                # format version
+                'insightMappingId': 'v1',
+                'insightType': 'EVENT',
+                # since epoch
+                'timestamp': ms_timestamp_from_datetime(datetime.datetime.utcnow()),
+                'tags': {
+                    'language': 'python'
+                }
+            },
+            # // 'clientId', 'sessionId' and 'controlConnection' are mandatory
+            # // the rest of the properties are optional
+            'data': {
+                # // 'clientId' must be the same as the one provided in the startup message
+                'clientId': str(self._session.cluster.client_id),
+                # // 'sessionId' must be the same as the one provided in the startup message
+                'sessionId': str(self._session.session_id),
+                'controlConnection': cc._connection.host if cc._connection else None,
+                'connectedNodes': connected_nodes
+            }
+        }
+
+    def _get_startup_data(self):
+        cc = self._session.cluster.control_connection
+        try:
+            local_ipaddr = cc._connection._socket.getsockname()[0]
+        except Exception as e:
+            local_ipaddr = None
+            log.debug('Unable to get local socket addr from {}: {}'.format(cc._connection, e))
+        hostname = socket.getfqdn()
+
+        host_distances_counter = Counter(
+            self._session.cluster.profile_manager.distance(host)
+            for host in self._session.hosts
+        )
+        host_distances_dict = {
+            'local': host_distances_counter[HostDistance.LOCAL],
+            'remote': host_distances_counter[HostDistance.REMOTE],
+            'ignored': host_distances_counter[HostDistance.IGNORED]
+        }
+
+        try:
+            compression_type = cc._connection._compression_type
+        except AttributeError:
+            compression_type = 'NONE'
+
+        cert_validation = None
+        try:
+            if self._session.cluster.ssl_context:
+                if isinstance(self._session.cluster.ssl_context, ssl.SSLContext):
+                    cert_validation = self._session.cluster.ssl_context.verify_mode == ssl.CERT_REQUIRED
+                else:  # pyopenssl
+                    from OpenSSL import SSL
+                    cert_validation = self._session.cluster.ssl_context.get_verify_mode() != SSL.VERIFY_NONE
+            elif self._session.cluster.ssl_options:
+                cert_validation = self._session.cluster.ssl_options.get('cert_reqs') == ssl.CERT_REQUIRED
+        except Exception as e:
+            log.debug('Unable to get the cert validation: {}'.format(e))
+
+        uname_info = platform.uname()
+
+        return {
+            'metadata': {
+                'name': 'driver.startup',
+                'insightMappingId': 'v1',
+                'insightType': 'EVENT',
+                'timestamp': ms_timestamp_from_datetime(datetime.datetime.utcnow()),
+                'tags': {
+                    'language': 'python'
+                },
+            },
+            'data': {
+                'driverName': 'DataStax Python Driver',
+                'driverVersion': sys.modules['cassandra'].__version__,
+                'clientId': str(self._session.cluster.client_id),
+                'sessionId': str(self._session.session_id),
+                'applicationName': self._session.cluster.application_name or 'python',
+                'applicationNameWasGenerated': not self._session.cluster.application_name,
+                'applicationVersion': self._session.cluster.application_version,
+                'contactPoints': self._session.cluster._endpoint_map_for_insights,
+                'dataCenters': list(set(h.datacenter for h in self._session.cluster.metadata.all_hosts()
+                                        if (h.datacenter and
+                                            self._session.cluster.profile_manager.distance(h) == HostDistance.LOCAL))),
+                'initialControlConnection': cc._connection.host if cc._connection else None,
+                'protocolVersion': self._session.cluster.protocol_version,
+                'localAddress': local_ipaddr,
+                'hostName': hostname,
+                'executionProfiles': insights_registry.serialize(self._session.cluster.profile_manager),
+                'configuredConnectionLength': host_distances_dict,
+                'heartbeatInterval': self._session.cluster.idle_heartbeat_interval,
+                'compression': compression_type.upper() if compression_type else 'NONE',
+                'reconnectionPolicy': insights_registry.serialize(self._session.cluster.reconnection_policy),
+                'sslConfigured': {
+                    'enabled': bool(self._session.cluster.ssl_options or self._session.cluster.ssl_context),
+                    'certValidation': cert_validation
+                },
+                'authProvider': {
+                    'type': (self._session.cluster.auth_provider.__class__.__name__
+                             if self._session.cluster.auth_provider else
+                             None)
+                },
+                'otherOptions': {
+                },
+                'platformInfo': {
+                    'os': {
+                        'name': uname_info.system,
+                        'version': uname_info.release,
+                        'arch': uname_info.machine
+                    },
+                    'cpus': {
+                        'length': multiprocessing.cpu_count(),
+                        'model': platform.processor()
+                    },
+                    'runtime': {
+                        'python': sys.version,
+                        'event_loop': self._session.cluster.connection_class.__name__
+                    }
+                },
+                'periodicStatusInterval': self._interval
+            }
+        }
+
+    def stop(self):
+        log.debug("Shutting down Monitor Reporter")
+        self._shutdown_event.set()
+        self.join()

platform/dataops/dto/.venv/lib/python3.12/site-packages/cassandra/datastax/insights/serializers.py

@@ -0,0 +1,219 @@
+# Copyright DataStax, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+def initialize_registry(insights_registry):
+    # This will be called from the cluster module, so we put all this behavior
+    # in a function to avoid circular imports
+
+    if insights_registry.initialized:
+        return False
+
+    from cassandra import ConsistencyLevel
+    from cassandra.cluster import (
+        ExecutionProfile, GraphExecutionProfile,
+        ProfileManager, ContinuousPagingOptions,
+        EXEC_PROFILE_DEFAULT, EXEC_PROFILE_GRAPH_DEFAULT,
+        EXEC_PROFILE_GRAPH_ANALYTICS_DEFAULT,
+        EXEC_PROFILE_GRAPH_SYSTEM_DEFAULT,
+        _NOT_SET
+    )
+    from cassandra.datastax.graph import GraphOptions
+    from cassandra.datastax.insights.registry import insights_registry
+    from cassandra.datastax.insights.util import namespace
+    from cassandra.policies import (
+        RoundRobinPolicy,
+        DCAwareRoundRobinPolicy,
+        TokenAwarePolicy,
+        WhiteListRoundRobinPolicy,
+        HostFilterPolicy,
+        ConstantReconnectionPolicy,
+        ExponentialReconnectionPolicy,
+        RetryPolicy,
+        SpeculativeExecutionPolicy,
+        ConstantSpeculativeExecutionPolicy,
+        WrapperPolicy
+    )
+
+    import logging
+
+    log = logging.getLogger(__name__)
+
+    @insights_registry.register_serializer_for(RoundRobinPolicy)
+    def round_robin_policy_insights_serializer(policy):
+        return {'type': policy.__class__.__name__,
+                'namespace': namespace(policy.__class__),
+                'options': {}}
+
+    @insights_registry.register_serializer_for(DCAwareRoundRobinPolicy)
+    def dc_aware_round_robin_policy_insights_serializer(policy):
+        return {'type': policy.__class__.__name__,
+                'namespace': namespace(policy.__class__),
+                'options': {'local_dc': policy.local_dc,
+                            'used_hosts_per_remote_dc': policy.used_hosts_per_remote_dc}
+                }
+
+    @insights_registry.register_serializer_for(TokenAwarePolicy)
+    def token_aware_policy_insights_serializer(policy):
+        return {'type': policy.__class__.__name__,
+                'namespace': namespace(policy.__class__),
+                'options': {'child_policy': insights_registry.serialize(policy._child_policy,
+                                                                        policy=True),
+                            'shuffle_replicas': policy.shuffle_replicas}
+                }
+
+    @insights_registry.register_serializer_for(WhiteListRoundRobinPolicy)
+    def whitelist_round_robin_policy_insights_serializer(policy):
+        return {'type': policy.__class__.__name__,
+                'namespace': namespace(policy.__class__),
+                'options': {'allowed_hosts': policy._allowed_hosts}
+                }
+
+    @insights_registry.register_serializer_for(HostFilterPolicy)
+    def host_filter_policy_insights_serializer(policy):
+        return {
+            'type': policy.__class__.__name__,
+            'namespace': namespace(policy.__class__),
+            'options': {'child_policy': insights_registry.serialize(policy._child_policy,
+                                                                    policy=True),
+                        'predicate': policy.predicate.__name__}
+        }
+
+    @insights_registry.register_serializer_for(ConstantReconnectionPolicy)
+    def constant_reconnection_policy_insights_serializer(policy):
+        return {'type': policy.__class__.__name__,
+                'namespace': namespace(policy.__class__),
+                'options': {'delay': policy.delay,
+                            'max_attempts': policy.max_attempts}
+                }
+
+    @insights_registry.register_serializer_for(ExponentialReconnectionPolicy)
+    def exponential_reconnection_policy_insights_serializer(policy):
+        return {'type': policy.__class__.__name__,
+                'namespace': namespace(policy.__class__),
+                'options': {'base_delay': policy.base_delay,
+                            'max_delay': policy.max_delay,
+                            'max_attempts': policy.max_attempts}
+                }
+
+    @insights_registry.register_serializer_for(RetryPolicy)
+    def retry_policy_insights_serializer(policy):
+        return {'type': policy.__class__.__name__,
+                'namespace': namespace(policy.__class__),
+                'options': {}}
+
+    @insights_registry.register_serializer_for(SpeculativeExecutionPolicy)
+    def speculative_execution_policy_insights_serializer(policy):
+        return {'type': policy.__class__.__name__,
+                'namespace': namespace(policy.__class__),
+                'options': {}}
+
+    @insights_registry.register_serializer_for(ConstantSpeculativeExecutionPolicy)
+    def constant_speculative_execution_policy_insights_serializer(policy):
+        return {'type': policy.__class__.__name__,
+                'namespace': namespace(policy.__class__),
+                    'options': {'delay': policy.delay,
+                                'max_attempts': policy.max_attempts}
+                }
+
+    @insights_registry.register_serializer_for(WrapperPolicy)
+    def wrapper_policy_insights_serializer(policy):
+        return {'type': policy.__class__.__name__,
+                'namespace': namespace(policy.__class__),
+                'options': {
+                    'child_policy': insights_registry.serialize(policy._child_policy,
+                                                                policy=True)
+                }}
+
+    @insights_registry.register_serializer_for(ExecutionProfile)
+    def execution_profile_insights_serializer(profile):
+        return {
+            'loadBalancing': insights_registry.serialize(profile.load_balancing_policy,
+                                                         policy=True),
+            'retry': insights_registry.serialize(profile.retry_policy,
+                                                 policy=True),
+            'readTimeout': profile.request_timeout,
+            'consistency': ConsistencyLevel.value_to_name.get(profile.consistency_level, None),
+            'serialConsistency': ConsistencyLevel.value_to_name.get(profile.serial_consistency_level, None),
+            'continuousPagingOptions': (insights_registry.serialize(profile.continuous_paging_options)
+                                        if (profile.continuous_paging_options is not None and
+                                           profile.continuous_paging_options is not _NOT_SET) else
+                                        None),
+            'speculativeExecution': insights_registry.serialize(profile.speculative_execution_policy),
+            'graphOptions': None
+        }
+
+    @insights_registry.register_serializer_for(GraphExecutionProfile)
+    def graph_execution_profile_insights_serializer(profile):
+        rv = insights_registry.serialize(profile, cls=ExecutionProfile)
+        rv['graphOptions'] = insights_registry.serialize(profile.graph_options)
+        return rv
+
+    _EXEC_PROFILE_DEFAULT_KEYS = (EXEC_PROFILE_DEFAULT,
+                                  EXEC_PROFILE_GRAPH_DEFAULT,
+                                  EXEC_PROFILE_GRAPH_SYSTEM_DEFAULT,
+                                  EXEC_PROFILE_GRAPH_ANALYTICS_DEFAULT)
+
+    @insights_registry.register_serializer_for(ProfileManager)
+    def profile_manager_insights_serializer(manager):
+        defaults = {
+            # Insights's expected default
+            'default': insights_registry.serialize(manager.profiles[EXEC_PROFILE_DEFAULT]),
+            # remaining named defaults for driver's defaults, including duplicated default
+            'EXEC_PROFILE_DEFAULT': insights_registry.serialize(manager.profiles[EXEC_PROFILE_DEFAULT]),
+            'EXEC_PROFILE_GRAPH_DEFAULT': insights_registry.serialize(manager.profiles[EXEC_PROFILE_GRAPH_DEFAULT]),
+            'EXEC_PROFILE_GRAPH_SYSTEM_DEFAULT': insights_registry.serialize(
+                manager.profiles[EXEC_PROFILE_GRAPH_SYSTEM_DEFAULT]
+            ),
+            'EXEC_PROFILE_GRAPH_ANALYTICS_DEFAULT': insights_registry.serialize(
+                manager.profiles[EXEC_PROFILE_GRAPH_ANALYTICS_DEFAULT]
+            )
+        }
+        other = {
+            key: insights_registry.serialize(value)
+            for key, value in manager.profiles.items()
+            if key not in _EXEC_PROFILE_DEFAULT_KEYS
+        }
+        overlapping_keys = set(defaults) & set(other)
+        if overlapping_keys:
+            log.debug('The following key names overlap default key sentinel keys '
+                      'and these non-default EPs will not be displayed in Insights '
+                      ': {}'.format(list(overlapping_keys)))
+
+        other.update(defaults)
+        return other
+
+    @insights_registry.register_serializer_for(GraphOptions)
+    def graph_options_insights_serializer(options):
+        rv = {
+            'source': options.graph_source,
+            'language': options.graph_language,
+            'graphProtocol': options.graph_protocol
+        }
+        updates = {k: v.decode('utf-8') for k, v in rv.items()
+                   if isinstance(v, bytes)}
+        rv.update(updates)
+        return rv
+
+    @insights_registry.register_serializer_for(ContinuousPagingOptions)
+    def continuous_paging_options_insights_serializer(paging_options):
+        return {
+                'page_unit': paging_options.page_unit,
+                'max_pages': paging_options.max_pages,
+                'max_pages_per_second': paging_options.max_pages_per_second,
+                'max_queue_size': paging_options.max_queue_size
+        }
+
+    insights_registry.initialized = True
+    return True

platform/dataops/dto/.venv/lib/python3.12/site-packages/cassandra/datastax/insights/util.py

@@ -0,0 +1,75 @@
+# Copyright DataStax, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import logging
+import traceback
+from warnings import warn
+
+from cassandra.util import Version
+
+
+DSE_60 = Version('6.0.0')
+DSE_51_MIN_SUPPORTED = Version('5.1.13')
+DSE_60_MIN_SUPPORTED = Version('6.0.5')
+
+
+log = logging.getLogger(__name__)
+
+
+def namespace(cls):
+    """
+    Best-effort method for getting the namespace in which a class is defined.
+    """
+    try:
+        # __module__ can be None
+        module = cls.__module__ or ''
+    except Exception:
+        warn("Unable to obtain namespace for {cls} for Insights, returning ''. "
+             "Exception: \n{e}".format(e=traceback.format_exc(), cls=cls))
+        module = ''
+
+    module_internal_namespace = _module_internal_namespace_or_emtpy_string(cls)
+    if module_internal_namespace:
+        return '.'.join((module, module_internal_namespace))
+    return module
+
+
+def _module_internal_namespace_or_emtpy_string(cls):
+    """
+    Best-effort method for getting the module-internal namespace in which a
+    class is defined -- i.e. the namespace _inside_ the module.
+    """
+    try:
+        qualname = cls.__qualname__
+    except AttributeError:
+        return ''
+
+    return '.'.join(
+        # the last segment is the name of the class -- use everything else
+        qualname.split('.')[:-1]
+    )
+
+
+def version_supports_insights(dse_version):
+    if dse_version:
+        try:
+            dse_version = Version(dse_version)
+            return (DSE_51_MIN_SUPPORTED <= dse_version < DSE_60
+                    or
+                    DSE_60_MIN_SUPPORTED <= dse_version)
+        except Exception:
+            warn("Unable to check version {v} for Insights compatibility, returning False. "
+                 "Exception: \n{e}".format(e=traceback.format_exc(), v=dse_version))
+
+    return False