cgcsdk 1.0.6__py3-none-any.whl → 1.0.9__py3-none-any.whl

cgc/sdk/mongodb.py

@@ -1,204 +0,0 @@
-from pymongo.errors import ConnectionFailure
-from pymongo import MongoClient, DESCENDING, ASCENDING
-from cgc.sdk.handlers import exception_handler
-
-
-class MongoConnector:
-    """
-    :param database_name: Database name
-    :type database_name: str
-    :param hosts: Host address defined as IP or DNS Name with port ex. db.example.com:27017
-    :type hosts: list
-    :param username: Username used for connection, not required, defaults to None
-    :type username: str | None
-    :param password: Password for Username, used with Username, defaults to None
-    :type password: str | None
-    :param authsource: Database to authenticate user with, defaults to admin
-    :type authsource: str
-    """
-
-    def __init__(
-        self,
-        database_name: str,
-        hosts: str,
-        username: str = None,
-        password: str = None,
-        authsource: str = "admin",
-        replica_set: str = None,
-    ) -> None:
-        self._database_name = database_name
-        self._hosts = hosts
-        assert type(hosts) is str
-        'hosts must be a str of host addresses ex. "db.example.com:27017,db2.example.com:27017"'
-        self._username = username
-        self._password = password
-        self._authsource = authsource
-        _extra_args = []
-        if replica_set:
-            _extra_args.append(f"replicaSet={replica_set}")
-        if authsource:
-            _extra_args.append(f"authSource={authsource}")
-        _extra_args.append("readPreference=primaryPreferred")
-        _extra_args.append("ssl=false")
-        self._extra_args = "&".join(_extra_args)
-        print(self._extra_args)
-        self.connect()
-
-    def disconnect(self):
-        print(f"Disconnecting from MongoDB: {self._hosts}")
-        self._mongo_client.close()
-        print(f"Disconnected from MongoDB")
-
-    def connect(self):
-        _credentials = (
-            ":".join([self._username, self._password]) if self._username else ""
-        )
-        _host_connection_string = (
-            "@".join([_credentials, self._hosts]) if _credentials else self._hosts
-        )
-        while True:
-            try:
-                self._mongo_client = MongoClient(
-                    "mongodb://{}/{}?{}".format(
-                        _host_connection_string, self._database_name, self._extra_args
-                    )
-                )
-                self._mongo_client_server_info = self._mongo_client.server_info()
-                print(f"Connected to MongoDB ({self._database_name}): {self._hosts}")
-                self._db = self._mongo_client[self._database_name]
-                break
-            except (ConnectionFailure,) as e:
-                print(f"MongoDB connection error: {e}")
-                print(f"retrying to connect...")
-
-    def _select_collection(self, collection_name: str):
-        return self._db[collection_name]
-
-    def get_pymongo_client(self):
-        return self._mongo_client
-
-    @staticmethod
-    def _ascending():
-        return ASCENDING
-
-    @staticmethod
-    def _descending():
-        return DESCENDING
-
-    @exception_handler
-    def find(self, collection_name: str, query: dict, session=None):
-        collection = self._select_collection(collection_name)
-        return collection.find(query, session=session)
-
-    @exception_handler
-    def find_one(self, collection_name: str, query: dict, session=None):
-        collection = self._select_collection(collection_name)
-        return collection.find_one(query, session=session)
-
-    @exception_handler
-    def insert_one(self, collection_name: str, query: dict, session=None):
-        collection = self._select_collection(collection_name)
-        return collection.insert_one(query, session=session)
-
-    @exception_handler
-    def delete_one(self, collection_name: str, query: dict, session=None):
-        collection = self._select_collection(collection_name)
-        return collection.delete_one(query, session=session)
-
-    @exception_handler
-    def aggregate(self, collection_name: str, pipeline, session=None):
-        collection = self._select_collection(collection_name)
-        return collection.aggregate(pipeline=pipeline, session=session)
-
-    @exception_handler
-    def count_documents(self, collection_name: str, query: dict, session=None):
-        collection = self._select_collection(collection_name)
-        return collection.count_documents(query, session=session)
-
-    @exception_handler
-    def update_one(
-        self,
-        collection_name: str,
-        query: dict,
-        update: dict,
-        upsert: bool = False,
-        session=None,
-    ):
-        collection = self._select_collection(collection_name)
-        return collection.update_one(query, update, upsert=upsert, session=session)
-
-    @exception_handler
-    def watch(
-        self,
-        collection_name: str,
-        operation_before_watch,
-        operation_on_event,
-        first_operation_kwargs={},
-        second_operation_kwargs={},
-    ):
-        """Function to watch for changes in a collection. Preferred to run over threading as daemon.
-
-        :param collection_name: Name of the collection to watch
-        :type collection_name: str
-        :param operation_on_event: Function to run on event
-        :type operation_on_event: function
-        """
-        operation_before_watch(**first_operation_kwargs)
-        while True:
-            print("Creating new watch cursor")
-            watch_cursor = self._select_collection(
-                collection_name=collection_name
-            ).watch()
-            print("Watching: {}.{}\n".format(self._database_name, collection_name))
-            for d in watch_cursor:
-                if d["operationType"] == "invalidate":
-                    print(
-                        "Watch cursor invalidated (deleted collection: {}?)".format(
-                            collection_name
-                        )
-                    )
-                    print("Closing watch cursor")
-                    watch_cursor.close()
-                    break
-                else:
-                    operation_on_event(d, **second_operation_kwargs)
-                    watch_cursor.close()
-                    return d
-            else:
-                continue
-            break
-
-    @staticmethod
-    def example_operation_for_watch(d):
-        print(d)
-        # del d["fullDocument"]["_id"]
-        # print("local time   : {}".format(datetime.utcnow()))
-        # print("cluster time : {}".format(d["clusterTime"].as_datetime()))
-        # print("collection   : {}.{}".format(d["ns"]["db"], d["ns"]["coll"]))
-        # try:
-        #     print("doc          : {}".format(d["fullDocument"]))
-        # except KeyError:
-        #     pass
-
-
-def get_mongo_access(
-    app_name: str, password: str, database: str = "db", restart: bool = False
-):
-    global _mongo_access
-
-    def init_access():
-        global _mongo_access
-        _mongo_access = MongoConnector(
-            database_name=database,
-            hosts=f"{app_name}:27017",
-            username="admin",
-            password=password,
-        )
-
-    try:
-        if not isinstance(_mongo_access, MongoConnector) or restart:
-            init_access()
-    except NameError:
-        init_access()
-        pass
-    return _mongo_access

cgc/sdk/redis.py

@@ -1,91 +0,0 @@
-import redis.asyncio as redis_async
-import redis
-
-
-class RedisConnector:
-    redis_client_async = None
-    redis_client = None
-
-    def __init__(
-        self, host: str, password: str = None, decode_responses: bool = False
-    ) -> None:
-        self._host = host
-        assert type(host) is str
-        "host must be a str containing redis app name"
-        self._password = password
-        self._decode_responses = decode_responses
-
-    def connect(self, async_client: bool = False):
-        while True:
-            try:
-                if not async_client:
-                    self.redis_client = redis.Redis(
-                        host=self._host,
-                        port=6379,
-                        password=self._password,
-                        decode_responses=self._decode_responses,
-                    )
-                else:
-                    self.redis_client_async = redis_async.Redis(
-                        host=self._host,
-                        port=6379,
-                        password=self._password,
-                        decode_responses=self._decode_responses,
-                    )
-                print(f"Connected to Redis: {self._host}")
-                break
-            except (redis.ConnectionError,) as e:
-                print(f"Redis connection error: {e}")
-                print(f"retrying to connect...")
-
-    def get_redis_client(self):
-        if self.redis_client is None:
-            self.connect()
-        return self.redis_client
-
-    def get_redis_client_async(self):
-        if self.redis_client_async is None:
-            self.connect(async_client=True)
-        return self.redis_client_async
-
-
-def get_redis_access(
-    app_name: str,
-    password: str,
-    decode_responses: bool = False,
-    restart: bool = False,
-    async_client=False,
-):
-    global _redis_access
-    global _redis_access_async
-
-    def init_access(async_client=False):
-        global _redis_access
-        global _redis_access_async
-
-        _redis_access = None
-        _redis_access_async = None
-
-        if not async_client:
-            _redis_access = RedisConnector(
-                host=app_name, password=password, decode_responses=decode_responses
-            )
-        else:
-            _redis_access_async = RedisConnector(
-                host=app_name, password=password, decode_responses=decode_responses
-            )
-
-    try:
-        if not async_client:
-            if not isinstance(_redis_access, RedisConnector) or restart:
-                init_access()
-        else:
-            if not isinstance(_redis_access_async, RedisConnector) or restart:
-                init_access(True)
-    except NameError:
-        if not async_client:
-            init_access()
-        else:
-            init_access(True)
-        pass
-    return _redis_access if not async_client else _redis_access_async

cgcsdk-1.0.6.dist-info/METADATA

@@ -1,39 +0,0 @@
-Metadata-Version: 2.1
-Name: cgcsdk
-Version: 1.0.6
-Summary: Comtegra GPU Cloud REST API client
-Author: Comtegra AI Team
-Author-email: ai@comtegra.pl
-License: BSD 2-clause
-Project-URL: Documentation, https://example.com/documentation/
-Project-URL: GitHub, https://github.com/foobar/foobar/
-Project-URL: Changelog, https://github.com/foobar/foobar/blob/master/CHANGELOG.md
-Keywords: cloud,sdk,orchestrator,kubernetes,jupyter-notebook
-Classifier: Development Status :: 1 - Planning
-Classifier: Intended Audience :: Science/Research
-Classifier: License :: OSI Approved :: BSD License
-Classifier: Operating System :: POSIX :: Linux
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.4
-Classifier: Programming Language :: Python :: 3.5
-Classifier: Programming Language :: Python :: 3.8
-Classifier: Programming Language :: Python :: 3.9
-Classifier: Programming Language :: Python :: 3.10
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: click
-Requires-Dist: python-dotenv
-Requires-Dist: tabulate
-Requires-Dist: pycryptodomex
-Requires-Dist: paramiko >=2.11
-Requires-Dist: statsd
-Requires-Dist: requests
-Requires-Dist: setuptools
-Requires-Dist: colorama
-Requires-Dist: redis
-Requires-Dist: pymongo
-Requires-Dist: psycopg2-binary
-
-# CGC Client - K8s Cloud
-
-cgc command line client for k8s Comtegra cloud environment.