renaming of kubikle

Author: FChataigner

dataikuapi/dss/admin.py

@@ -1274,15 +1274,15 @@ def total_active_with_trigger_scenarios_count(self):
         return self.data["scenarios"]["activeWithTriggers"]
 
 
-class DSSKubikleTemplateListItem(object):
-    """An item in a list of kubikle templates. Do not instantiate this class, use :meth:`dataikuapi.DSSClient.list_kubikle_templates`"""
+class DSSCodeStudioTemplateListItem(object):
+    """An item in a list of code studio templates. Do not instantiate this class, use :meth:`dataikuapi.DSSClient.list_code_studio_templates`"""
     def __init__(self, client, data):
         self.client = client
         self._data = data
 
-    def to_kubikle_template(self):
-        """Gets the :class:`DSSKubikleTemplate` corresponding to this kubikle template """
-        return DSSKubikleTemplate(self.client, self._data["id"])
+    def to_code_studio_template(self):
+        """Gets the :class:`DSSCodeStudioTemplate` corresponding to this code studio template """
+        return DSSCodeStudioTemplate(self.client, self._data["id"])
 
     @property
     def name(self):
@@ -1310,12 +1310,12 @@ def last_built(self):
         else:
             return None
 
-class DSSKubikleTemplate(object):
+class DSSCodeStudioTemplate(object):
     """
-    A handle to interact with a kubikle template on the DSS instance
+    A handle to interact with a code studio template on the DSS instance
     """
     def __init__(self, client, template_id):
-        """Do not call that directly, use :meth:`dataikuapi.DSSClient.get_kubikle_template`"""
+        """Do not call that directly, use :meth:`dataikuapi.DSSClient.get_code_studio_template`"""
         self.client = client
         self.template_id = template_id
 
@@ -1327,18 +1327,18 @@ def get_settings(self):
         """
         Get the template's settings. 
 
-        :returns: a :class:`DSSKubikleTemplateSettings` object to interact with kubikle template settings
-        :rtype: :class:`DSSKubikleTemplateSettings`
+        :returns: a :class:`DSSCodeStudioTemplateSettings` object to interact with code studio template settings
+        :rtype: :class:`DSSCodeStudioTemplateSettings`
         """
-        settings = self.client._perform_json("GET", "/admin/kubikles/%s" % (self.template_id))
-        return DSSKubikleTemplateSettings(self.client, self.template_id, settings)
+        settings = self.client._perform_json("GET", "/admin/code-studios/%s" % (self.template_id))
+        return DSSCodeStudioTemplateSettings(self.client, self.template_id, settings)
 
-class DSSKubikleTemplateSettings(object):
+class DSSCodeStudioTemplateSettings(object):
     """
-    The settings of a kubikle template
+    The settings of a code studio template
     """
     def __init__(self, client, template_id, settings):
-        """Do not call directly, use :meth:`DSSKubikleTemplate.get_settings`"""
+        """Do not call directly, use :meth:`DSSCodeStudioTemplate.get_settings`"""
         self.client = client
         self.template_id = template_id
         self.settings = settings

dataikuapi/dss/kubikle.py dataikuapi/dss/codestudio.pydataikuapi/dss/kubikle.py renamed to dataikuapi/dss/codestudio.py

@@ -2,16 +2,16 @@
 import json
 from datetime import datetime
 
-class DSSKubikleObjectListItem(object):
-    """An item in a list of kubikles. Do not instantiate this class, use :meth:`dataikuapi.dss.project.DSSProject.list_kubikle_objects`"""
+class DSSCodeStudioObjectListItem(object):
+    """An item in a list of code studios. Do not instantiate this class, use :meth:`dataikuapi.dss.project.DSSProject.list_code_studio_objects`"""
     def __init__(self, client, project_key, data):
         self.client = client
         self.project_key = project_key
         self._data = data
 
-    def to_kubikle_object(self):
-        """Gets the :class:`DSSKubikleTemplate` corresponding to this kubikle object """
-        return DSSKubikleObject(self.client, self.project_key, self._data["id"])
+    def to_code_studio_object(self):
+        """Gets the :class:`DSSCodeStudioObject` corresponding to this code studio object """
+        return DSSCodeStudioObject(self.client, self.project_key, self._data["id"])
 
     @property
     def name(self):
@@ -33,77 +33,77 @@ def template_description(self):
         return self._data.get('desc', {}).get('shortDesc', '')
 
 
-class DSSKubikleObject(object):
+class DSSCodeStudioObject(object):
     """
-    A handle to manage a kubikle object of a project
+    A handle to manage a code studio object of a project
     """
-    def __init__(self, client, project_key, kubikle_object_id):
-        """Do not call directly, use :meth:`dataikuapi.dss.project.DSSProject.get_kubikle_object`"""
+    def __init__(self, client, project_key, code_studio_object_id):
+        """Do not call directly, use :meth:`dataikuapi.dss.project.DSSProject.get_code_studio_object`"""
         self.client = client
         self.project_key = project_key
-        self.kubikle_object_id = kubikle_object_id
+        self.code_studio_object_id = code_studio_object_id
 
     def delete(self):
         """
-        Delete the kubikle
+        Delete the code studio
         """
-        self.client._perform_empty("DELETE", "/projects/%s/kubikles/%s" % (self.project_key, self.kubikle_object_id))
+        self.client._perform_empty("DELETE", "/projects/%s/code-studios/%s" % (self.project_key, self.code_studio_object_id))
 
     def get_settings(self):
         """
-        Get the kubikle object's settings
+        Get the code studio object's settings
 
-        :returns: a handle to manage the kubikle settings
-        :rtype: :class:`dataikuapi.dss.kubikle.DSSKubikleObjectSettings`
+        :returns: a handle to manage the code studio settings
+        :rtype: :class:`dataikuapi.dss.codestudio.DSSCodeStudioObjectSettings`
         """
-        settings = self.client._perform_json("GET", "/projects/%s/kubikles/%s" % (self.project_key, self.kubikle_object_id))
-        return DSSKubikleObjectSettings(self.client, self.project_key, self.kubikle_object_id, settings)
+        settings = self.client._perform_json("GET", "/projects/%s/code-studios/%s" % (self.project_key, self.code_studio_object_id))
+        return DSSCodeStudioObjectSettings(self.client, self.project_key, self.code_studio_object_id, settings)
 
     def get_status(self):
         """
-        Get the kubikle object's state
+        Get the code studio object's state
 
-        :returns: a handle to inspect the kubikle state
-        :rtype: :class:`dataikuapi.dss.kubikle.DSSKubikleObjectStatus`
+        :returns: a handle to inspect the code studio state
+        :rtype: :class:`dataikuapi.dss.codestudio.DSSCodeStudioObjectStatus`
         """
-        status = self.client._perform_json("GET", "/projects/%s/kubikles/%s/status" % (self.project_key, self.kubikle_object_id))
-        return DSSKubikleObjectStatus(self.client, self.project_key, self.kubikle_object_id, status)
+        status = self.client._perform_json("GET", "/projects/%s/code-studios/%s/status" % (self.project_key, self.code_studio_object_id))
+        return DSSCodeStudioObjectStatus(self.client, self.project_key, self.code_studio_object_id, status)
 
     def stop(self):
         """
-        Stop a running kubikle
+        Stop a running code studio
 
         :returns: a future to wait on the stop, or None if already stopped
         :rtype: :class:`dataikuapi.dss.future.DSSFuture`
         """
-        ret = self.client._perform_json("POST", "/projects/%s/kubikles/%s/stop" % (self.project_key, self.kubikle_object_id))
+        ret = self.client._perform_json("POST", "/projects/%s/code-studios/%s/stop" % (self.project_key, self.code_studio_object_id))
         if 'jobId' in ret:
             return self.client.get_future(ret["jobId"])
         else:
             return None
 
     def restart(self):
         """
-        Restart a kubikle
+        Restart a code studio
 
         :returns: a future to wait on the start
         :rtype: :class:`dataikuapi.dss.future.DSSFuture`
         """
-        ret = self.client._perform_json("POST", "/projects/%s/kubikles/%s/restart" % (self.project_key, self.kubikle_object_id))
+        ret = self.client._perform_json("POST", "/projects/%s/code-studios/%s/restart" % (self.project_key, self.code_studio_object_id))
         if 'jobId' in ret:
             return self.client.get_future(ret["jobId"])
         else:
             return None
 
-class DSSKubikleObjectSettings(object):
+class DSSCodeStudioObjectSettings(object):
     """
-    Settings for the kubikle object
+    Settings for the code studio object
     """
-    def __init__(self, client, project_key, kubikle_object_id, settings):
-        """Do not call directly, use :meth:`dataikuapi.dss.kubikle.DSSKubikleObject.get_settings`"""
+    def __init__(self, client, project_key, code_studio_object_id, settings):
+        """Do not call directly, use :meth:`dataikuapi.dss.codestudio.DSSCodeStudioObject.get_settings`"""
         self.client = client
         self.project_key = project_key
-        self.kubikle_object_id = kubikle_object_id
+        self.code_studio_object_id = code_studio_object_id
         self.settings = settings
 
     def get_raw(self):
@@ -112,15 +112,15 @@ def get_raw(self):
         """
         return self.settings
 
-class DSSKubikleObjectStatus(object):
+class DSSCodeStudioObjectStatus(object):
     """
-    Status of a kubikle object
+    Status of a code studio object
     """
-    def __init__(self, client, project_key, kubikle_object_id, status):
-        """Do not call directly, use :meth:`dataikuapi.dss.kubikle.DSSKubikleObject.get_state`"""
+    def __init__(self, client, project_key, code_studio_object_id, status):
+        """Do not call directly, use :meth:`dataikuapi.dss.codestudio.DSSCodeStudioObject.get_state`"""
         self.client = client
         self.project_key = project_key
-        self.kubikle_object_id = kubikle_object_id
+        self.code_studio_object_id = code_studio_object_id
         self.status = status
 
     def get_raw(self):

dataikuapi/dss/project.py

@@ -25,7 +25,7 @@
 from .analysis import DSSAnalysis
 from .flow import DSSProjectFlow
 from .app import DSSAppManifest
-from .kubikle import DSSKubikleObject, DSSKubikleObjectListItem
+from .codestudio import DSSCodeStudioObject, DSSCodeStudioObjectListItem
 
 class DSSProject(object):
     """
@@ -1632,55 +1632,55 @@ def get_mlflow_extension(self):
 
 
     ########################################################
-    # Kubikles
+    # Code studios
     ########################################################
-    def list_kubikle_objects(self, as_type="listitems"):
+    def list_code_studio_objects(self, as_type="listitems"):
         """
-        List the kubikle objects in this project
+        List the code studio objects in this project
         
         Returns:
-            the list of the kubikle objects, each one as a JSON object
+            the list of the code studio objects, each one as a JSON object
         """
         items = self.client._perform_json(
-            "GET", "/projects/%s/kubikles/" % self.project_key)
+            "GET", "/projects/%s/code-studios/" % self.project_key)
         if as_type == "listitems" or as_type == "listitem":
-            return [DSSKubikleObjectListItem(self.client, self.project_key, item) for item in items]
+            return [DSSCodeStudioObjectListItem(self.client, self.project_key, item) for item in items]
         elif as_type == "objects" or as_type == "object":
-            return [DSSKubikleObject(self.client, self.project_key, item["id"]) for item in items]
+            return [DSSCodeStudioObject(self.client, self.project_key, item["id"]) for item in items]
         else:
             raise ValueError("Unknown as_type") 
 
-    def get_kubikle_object(self, kubikle_object_id):
+    def get_code_studio_object(self, code_studio_object_id):
         """
-        Get a handle to interact with a specific kubikle object
+        Get a handle to interact with a specific code studio object
        
         Args:
-            kubikle_object_id: the identifier of the desired kubikle object
+            code_studio_object_id: the identifier of the desired code studio object
         
         Returns:
-            A :class:`dataikuapi.dss.kubikle.DSSKubikleObject` kubikle object handle
+            A :class:`dataikuapi.dss.codestudio.DSSCodeStudioObject` code studio object handle
         """
-        return DSSKubikleObject(self.client, self.project_key, kubikle_object_id)
+        return DSSCodeStudioObject(self.client, self.project_key, code_studio_object_id)
 
-    def create_kubikle_object(self, name, template_id):
+    def create_code_studio_object(self, name, template_id):
         """
-        Create a new kubikle object in the project, and return a handle to interact with it
+        Create a new code studio object in the project, and return a handle to interact with it
         
         Args:
-            name: the name of the kubikle object
-            template_id: the identifier of a kubikle template
+            name: the name of the code studio object
+            template_id: the identifier of a code studio template
         
         Returns:
-            A :class:`dataikuapi.dss.kubikle.DSSKubikleObject` kubikle object handle
+            A :class:`dataikuapi.dss.codestudio.DSSCodeStudioObject` code studio object handle
         """
         obj = {
             "name" : name,
             "projectKey" : self.project_key,
             "templateId" : template_id
         }
-        res = self.client._perform_json("POST", "/projects/%s/kubikles/" % self.project_key, body = obj)
-        kubikle_object_id = res['id']
-        return DSSKubikleObject(self.client, self.project_key, kubikle_object_id)
+        res = self.client._perform_json("POST", "/projects/%s/code-studios/" % self.project_key, body = obj)
+        code_studio_object_id = res['codeStudio']['id']
+        return DSSCodeStudioObject(self.client, self.project_key, code_studio_object_id)
 
 
 

dataikuapi/dssclient.py

@@ -11,7 +11,7 @@
 from .dss.project import DSSProject
 from .dss.app import DSSApp
 from .dss.plugin import DSSPlugin
-from .dss.admin import DSSUser, DSSOwnUser, DSSGroup, DSSConnection, DSSGeneralSettings, DSSCodeEnv, DSSGlobalApiKey, DSSCluster, DSSKubikleTemplate, DSSKubikleTemplateListItem, DSSGlobalUsageSummary, DSSInstanceVariables
+from .dss.admin import DSSUser, DSSOwnUser, DSSGroup, DSSConnection, DSSGeneralSettings, DSSCodeEnv, DSSGlobalApiKey, DSSCluster, DSSCodeStudioTemplate, DSSCodeStudioTemplateListItem, DSSGlobalUsageSummary, DSSInstanceVariables
 from .dss.meaning import DSSMeaning
 from .dss.sqlquery import DSSSQLQuery
 from .dss.discussion import DSSObjectDiscussions
@@ -595,35 +595,35 @@ def create_cluster(self, cluster_name, cluster_type='manual', params=None):
 
 
     ########################################################
-    # Kubikle templates
+    # Code studio templates
     ########################################################
 
-    def list_kubikle_templates(self, as_type='listitems'):
+    def list_code_studio_templates(self, as_type='listitems'):
         """
-        List all kubikle templates on the DSS instance
+        List all code studio templates on the DSS instance
 
         Returns:
             List of templates (name, type)
         """
-        items = self._perform_json("GET", "/admin/kubikles/")
+        items = self._perform_json("GET", "/admin/code-studios/")
         if as_type == "listitems" or as_type == "listitem":
-            return [DSSKubikleTemplateListItem(self, item) for item in items]
+            return [DSSCodeStudioTemplateListItem(self, item) for item in items]
         elif as_type == "objects" or as_type == "object":
-            return [DSSKubikleTemplate(self, item["id"]) for item in items]
+            return [DSSCodeStudioTemplate(self, item["id"]) for item in items]
         else:
             raise ValueError("Unknown as_type") 
 
-    def get_kubikle_template(self, template_id):
+    def get_code_studio_template(self, template_id):
         """
-        Get a handle to interact with a specific kubikle template
+        Get a handle to interact with a specific code studio template
         
         Args:
-            template_id: the template id of the desired kubikle template
+            template_id: the template id of the desired code studio template
         
         Returns:
-            A :class:`dataikuapi.dss.admin.DSSKubikleTemplate` kubikle template handle
+            A :class:`dataikuapi.dss.admin.DSSCodeStudioTemplate` code studio template handle
         """
-        return DSSKubikleTemplate(self, template_id)
+        return DSSCodeStudioTemplate(self, template_id)
 
 
     ########################################################