streamsets 6.5.0__tar.gz → 6.6.0.dev0__tar.gz

{streamsets-6.5.0 → streamsets-6.6.0.dev0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: streamsets
-Version: 6.5.0
+Version: 6.6.0.dev0
 Summary: A Python SDK for StreamSets
 Author: StreamSets Inc
 Classifier: Development Status :: 5 - Production/Stable

{streamsets-6.5.0 → streamsets-6.6.0.dev0}/streamsets/sdk/__version__.py

@@ -2,4 +2,4 @@
 #  PID 5900-BAF
 #  Copyright StreamSets Inc., an IBM Company 2024
 
-__version__ = "6.5.0"
+__version__ = "6.6.0-dev"

{streamsets-6.5.0 → streamsets-6.6.0.dev0}/streamsets/sdk/sch.py

@@ -40,11 +40,12 @@ from .sch_models import (
     Environments, GCEDeployment, GCPEnvironment, GroupBuilder, Groups, Job, JobBuilder, Jobs, JobSequence,
     JobSequenceBuilder, JobSequences, KubernetesDeployment, KubernetesEnvironment, LegacyDeploymentBuilder,
     LegacyDeployments, LoginAudits, MeteringUsage, NotImplementedDeployment, NotImplementedEnvironment,
-    OrganizationBuilder, Organizations, Pipeline, PipelineBuilder, PipelineLabels, Pipelines, ProtectionMethodBuilder,
-    ProtectionPolicies, ProtectionPolicy, ProtectionPolicyBuilder, ProvisioningAgents, ReportDefinitions, SAQLSearch,
-    SAQLSearchBuilder, SAQLSearches, ScheduledTask, ScheduledTaskActions, ScheduledTaskBuilder, ScheduledTasks,
-    SelfManagedDeployment, SelfManagedEnvironment, StPipelineBuilder, SubscriptionAudit, SubscriptionBuilder,
-    Subscriptions, Topologies, Topology, TopologyBuilder, UserBuilder, Users,
+    OrganizationBuilder, Organizations, Pipeline, PipelineBuilder, PipelineLabels, Pipelines, Project, ProjectBuilder,
+    Projects, ProtectionMethodBuilder, ProtectionPolicies, ProtectionPolicy, ProtectionPolicyBuilder,
+    ProvisioningAgents, SAQLSearch, SAQLSearchBuilder, SAQLSearches, ScheduledTask, ScheduledTaskActions,
+    ScheduledTaskBuilder, ScheduledTasks, SelfManagedDeployment, SelfManagedEnvironment,
+    StPipelineBuilder, SubscriptionAudit, SubscriptionBuilder, Subscriptions, Topologies, Topology, TopologyBuilder,
+    UserBuilder, Users,
 )
 from .utils import (
     SDC_DEFAULT_EXECUTION_MODE, TRANSFORMER_EXECUTION_MODES, SeekableList, get_stage_library_display_name_from_library,
@@ -181,6 +182,9 @@ class ControlHub:
 
         self._en_translations = self.api_client.get_translations_json()
 
+        # store which project we are running in, if any
+        self._current_project = None
+
         self._data_collectors = {}
         self._transformers = {}
         thread = threading.Thread(target=self._call_data_collectors)
@@ -403,6 +407,124 @@ class ControlHub:
             engine_start_up_time=authoring_engine._data["startUpTime"] if authoring_engine else 0,
         )
 
+    def get_snowflake_pipeline_user_defined_functions(self, pipeline, filter_text=None, tunneling=False):
+        """Return user defined functions for the pipeline
+
+        Args:
+            pipeline (:py:class:`streamsets.sdk.sch_models.Pipeline`): Pipeline object.
+            filter_text (:obj:`str`: optional): Filter response text. Default: ``None``.
+            tunneling (:obj:`bool`: optional): Enable tunneling for hosted instances. Default: ``False``.
+
+        Rreturns:
+            An instance of :py:class:`streamsets.sdk.sch_api.Command`.
+        """
+        engine_id = None
+        tunneling_instance_id = None
+        if tunneling:
+            engine_id = pipeline.engine_id
+            tunneling_instance_id_request = self.api_client.get_tunneling_instance_id(engine_id)
+            tunneling_instance_id = tunneling_instance_id_request.response.json().get('instanceId')
+
+        pipeline_fqn = f'{pipeline.pipeline_id.split(":")[0]}__{pipeline.organization}__{pipeline.committer}'
+        response = self.api_client.post_snowflake_pipeline_user_defined_functions_search_start(
+            pipeline_id=pipeline_fqn,
+            engine_id=engine_id,
+            rev=pipeline.commit_id,
+            filter_text=filter_text,
+            tunneling_instance_id=tunneling_instance_id,
+        )
+        id = response.response.json().get('id', '')
+        responses = []
+
+        def failure(timeout=None, exception=False):
+            self.api_client.delete_snowflake_pipeline_user_defined_fucntions_search_cancel(
+                pipeline_id=pipeline_fqn,
+                engine_id=engine_id,
+                id=id,
+                rev=pipeline.commit_id,
+                tunneling_instance_id=tunneling_instance_id,
+            )
+            if exception:
+                raise ValueError('An ERROR status was reached before retrieving UDFs.')
+            else:
+                raise TimeoutError(f'Timeout reached after {timeout} seconds while searching for UDFs.')
+
+        def condition(responses=[]):
+            response = self.api_client.get_snowflake_pipeline_user_defined_functions_search_status(
+                pipeline_id=pipeline_fqn,
+                id=id,
+                engine_id=engine_id,
+                rev=pipeline.commit_id,
+                tunneling_instance_id=tunneling_instance_id,
+            )
+            status = response.response.json().get('status', '')
+            responses.append(response)
+            if status == 'ERROR':
+                failure(exception=True)
+            return status == 'FINISHED'
+
+        wait_for_condition(condition, condition_kwargs={'responses': responses}, failure=failure, timeout=600)
+        return responses[-1]
+
+    def get_snowflake_pipeline_procedures(self, pipeline, filter_text=None, tunneling=False):
+        """Return procedures for the pipeline
+
+        Args:
+            pipeline (:py:class:`streamsets.sdk.sch_models.Pipeline`): Pipeline object.
+            filter_text (:obj:`str`: optional): Filter response text. Default: ``None``.
+            tunneling (:obj:`bool`: optional): Enable tunneling for hosted instances. Default: ``False``.
+
+        Rreturns:
+            An instance of :py:class:`streamsets.sdk.sch_api.Command`.
+        """
+        engine_id = None
+        tunneling_instance_id = None
+        if tunneling:
+            engine_id = pipeline.engine_id
+            tunneling_instance_id_request = self.api_client.get_tunneling_instance_id(engine_id)
+            tunneling_instance_id = tunneling_instance_id_request.response.json().get('instanceId')
+
+        pipeline_fqn = f'{pipeline.pipeline_id.split(":")[0]}__{pipeline.organization}__{pipeline.committer}'
+        response = self.api_client.post_snowflake_pipeline_procedures_search_start(
+            pipeline_id=pipeline_fqn,
+            engine_id=engine_id,
+            rev=pipeline.commit_id,
+            fitler_text=filter_text,
+            tunneling_instance_id=tunneling_instance_id,
+        )
+        id = response.response.json().get('id', '')
+        responses = []
+
+        def failure(timeout=None, exception=False):
+            self.api_client.delete_snowflake_pipeline_procedures_search_cancel(
+                pipeline_id=pipeline_fqn,
+                id=id,
+                engine_id=engine_id,
+                rev=pipeline.commit_id,
+                tunneling_instance_id=tunneling_instance_id,
+            )
+            if exception:
+                raise ValueError('An ERROR status was reached before retrieving the pipeline procedures.')
+            else:
+                raise TimeoutError(f'Timeout reached after {timeout} seconds while searching for pipeline procedures.')
+
+        def condition(responses=[]):
+            response = self.api_client.get_snowflake_pipeline_procedures_search_status(
+                pipeline_id=pipeline_fqn,
+                engine_id=engine_id,
+                id=id,
+                rev=pipeline.commit_id,
+                tunneling_instance_id=tunneling_instance_id,
+            )
+            status = response.response.json().get('status', '')
+            if status == 'ERROR':
+                failure(exception=True)
+            responses.append(response)
+            return status == 'FINISHED'
+
+        wait_for_condition(condition, condition_kwargs={'responses': responses}, failure=failure, timeout=600)
+        return responses[-1]
+
     def publish_pipeline(self, pipeline, commit_message='New pipeline', draft=False, validate=False):
         """Publish a pipeline.
 
@@ -3423,54 +3545,6 @@ class ControlHub:
 
         return response
 
-    @property
-    def report_definitions(self):
-        """Report Definitions.
-
-        Returns:
-            An instance of :py:class:`streamsets.sdk.sch_models.ReportDefinitions`.
-        """
-        return ReportDefinitions(self)
-
-    def add_report_definition(self, report_definition):
-        """Add Report Definition to ControlHub.
-
-        Args:
-            report_definition (:py:class:`streamsets.sdk.sch_models.ReportDefinition`): Report Definition instance.
-
-        Returns:
-            An instance of :py:class:`streamsets.sdk.sch_api.Command`.
-        """
-        create_report_definition_command = self.api_client.create_new_report_definition(report_definition._data)
-        report_definition._data = create_report_definition_command.response.json()
-        return create_report_definition_command
-
-    def update_report_definition(self, report_definition):
-        """Update an existing Report Definition.
-
-        Args:
-            report_definition (:py:class:`streamsets.sdk.sch_models.ReportDefinition`): Report Definition instance.
-
-        Returns:
-            An instance of :py:class:`streamsets.sdk.sch_api.Command`.
-        """
-        update_report_definition_command = self.api_client.update_report_definition(
-            report_definition.id, report_definition._data
-        )
-        report_definition._data = update_report_definition_command.response.json()
-        return update_report_definition_command
-
-    def delete_report_definition(self, report_definition):
-        """Delete an existing Report Definition.
-
-        Args:
-            report_definition (:py:class:`streamsets.sdk.sch_models.ReportDefinition`): Report Definition instance.
-
-        Returns:
-            An instance of :py:class:`streamsets.sdk.sch_api.Command`.
-        """
-        return self.api_client.delete_report_definition(report_definition.id)
-
     def get_connection_builder(self):
         """Get a connection builder instance with which a connection can be created.
 
@@ -4750,3 +4824,103 @@ class ControlHub:
             'username': username,
         }
         return self.api_client.validate_snowflake_account(body=validate_snowflake_account_json)
+
+    @property
+    def projects(self):
+        """Projects.
+
+        Returns:
+            An instance of :py:class:`streamsets.sdk.sch_models.Projects`.
+        """
+        return Projects(self)
+
+    @property
+    def current_project(self):
+        """Which project we are currently running in.
+
+        Returns:
+            An instance of :py:class:`streamsets.sdk.sch_models.Project` or :obj:`None`.
+        """
+        return self._current_project
+
+    @current_project.setter
+    def current_project(self, val):
+        if val is not None:
+            if not isinstance(val, Project):
+                raise TypeError(
+                    "current_project should be of type :py:class:`streamsets.sdk.sch_models.Project` or `None`"
+                )
+            if val.id is None:
+                raise ValueError(
+                    "ID of the project passed is not set. " "Set it by adding it to platform via `add_project`"
+                )
+        self._current_project = val
+
+        # set the appropriate project ID in the API client. This will consumed while making calls to platform.
+        self.api_client.current_project_id = self.current_project.id if self.current_project else None
+
+    def add_project(self, project):
+        """Add a project to Control Hub.
+
+        Args:
+            project (:py:class:`streamsets.sdk.sch_models.Project`): An instance of the project to be added.
+
+        Returns:
+            An instance of :py:class:`streamsets.sdk.sch_api.Command`.
+        """
+        if not isinstance(project, Project):
+            raise TypeError("project should be of type Project.")
+
+        request_body = {'name': project.name, 'description': project.description}
+        command = self.api_client.create_project(body=request_body)
+
+        # overwrite the data into the same object.
+        project._data = command.response.json()
+
+        return command
+
+    def update_project(self, project):
+        """Update an existing project.
+
+        Args:
+            project (:py:class:`streamsets.sdk.sch_models.Project`): An instance of the project to be updated.
+
+        Returns:
+            An instance of :py:class:`streamsets.sdk.sch_api.Command`.
+        """
+        if not isinstance(project, Project):
+            raise TypeError("project should be of type Project.")
+
+        if project.id is None:
+            raise ValueError("project is not initialized. Add it to Control Hub using the `add_project` method.")
+
+        command = self.api_client.update_project(data=project._data, project_id=project.id)
+        return command
+
+    def delete_project(self, *projects):
+        """Delete one or more projects from Control Hub
+
+        Args: projects (:py:class:`streamsets.sdk.sch_models.Project`): One or more instances of
+                                                                        :py:class:`streamsets.sdk.sch_models.Project`.
+
+        Returns:
+            An instance of :py:class:`streamsets.sdk.sch_api.Command`.
+        """
+        if not all([isinstance(project, Project) for project in projects]):
+            raise TypeError("project should be of type Project.")
+
+        request_body = {'projectIds': [project.id for project in projects]}
+        command = self.api_client.delete_projects(body=request_body)
+
+        return command
+
+    def get_project_builder(self):
+        """Get a ProjectBuilder instance to create a project.
+
+        Returns:
+            An instance of :py:class:`streamsets.sdk.sch_models.ProjectBuilder`.
+        """
+        project_properties = self._security_api['definitions']['ProjectJson']['properties']
+        project = {property_: None for property_ in project_properties}
+
+        return ProjectBuilder(project=project, control_hub=self)

{streamsets-6.5.0 → streamsets-6.6.0.dev0}/streamsets/sdk/sch_api.py

@@ -35,6 +35,19 @@ from .utils import (
 
 logger = logging.getLogger(__name__)
 
+APPS_REQUIRING_PROJECT_ID = [
+    'connection',
+    'jobrunner',
+    'notification',
+    'pipeline',
+    'pipelinestore',
+    'provisioning',
+    'scheduler',
+    'sequencing',
+    'sla',
+    'topology',
+]
+
 # The `#:` constructs at the end of assignments are part of Sphinx's autodoc functionality.
 DEFAULT_BANNER_API_VERSION = 1  #:
 DEFAULT_EXPLORER_API_VERSION = 1
@@ -130,6 +143,9 @@ class ApiClient(object):
             # If we disable SSL cert verification, we should disable warnings about having disabled it.
             urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
 
+        # store the ID of the project we are running in, if any
+        self.current_project_id = None
+
     def update_session_headers_with_analytics_data(self):
         analytics_instance = AnalyticsHeaders.get_instance()
         self.session.headers.update(analytics_instance.headers)
@@ -6220,7 +6236,7 @@ class ApiClient(object):
         Args:
             job_id (:obj:`str`)
             sdc_id (:obj:`str`, optional): Default: ``None``.
-            ime_filter_condition (:obj:`str`, optional): Default: ``'LAST_5M'``.
+            time_filter_condition (:obj:`str`, optional): Default: ``'LAST_5M'``.
             limit (:obj:`str`, optional): Default: ``None``.
             start_time (:obj:`int`, optional): Default: ``None``.
             end_time (:obj:`int`, optional): Default: ``None``.
@@ -6242,7 +6258,7 @@ class ApiClient(object):
         Args:
             job_id (:obj:`str`)
             sdc_id (:obj:`str`, optional): Default: ``None``.
-            ime_filter_condition (:obj:`str`, optional): Default: ``'LAST_5M'``.
+            time_filter_condition (:obj:`str`, optional): Default: ``'LAST_5M'``.
             limit (:obj:`str`, optional): Default: ``None``.
             start_time (:obj:`int`, optional): Default: ``None``.
             end_time (:obj:`int`, optional): Default: ``None``.
@@ -8888,6 +8904,129 @@ class ApiClient(object):
 
         return Command(self, response)
 
+    def create_project(self, body):
+        """Create a Project in the organization.
+
+        Args:
+            body (:obj:`dict`): Request body conforming to the Swagger API definition.
+
+        Returns:
+            An instance of :py:class:`streamsets.sdk.sch_api.Command`.
+        """
+        response = self._post(app="security", endpoint=f"/v{self.api_version}/projects", data=body)
+        return Command(self, response)
+
+    def delete_projects(self, body):
+        """Delete one or more Projects.
+
+        Args:
+            body (:obj:`dict`): Request body conforming to the Swagger API definition.
+
+        Returns:
+            An instance of :py:class:`streamsets.sdk.sch_api.Command`.
+        """
+        response = self._put(app="security", endpoint=f"/v{self.api_version}/projects", data=body)
+        return Command(self, response)
+
+    def get_project_by_id(self, project_id):
+        """Get a Project by ID.
+
+        Args:
+            project_id (:obj:`str`): ID of the Project to get.
+
+        Returns:
+            An instance of :py:class:`streamsets.sdk.sch_api.Command`.
+        """
+        response = self._get(app="security", endpoint=f"/v{self.api_version}/project/{project_id}")
+        return Command(self, response)
+
+    def update_project(self, data, project_id):
+        """Update an existing project.
+
+        Args:
+            data (:obj:`dict`): Request body conforming to Swagger API definition.
+            project_id (:obj:`str`): Project ID of the project to update.
+        """
+
+        response = self._post(app="security", endpoint=f"v{self.api_version}/project/{project_id}", data=data)
+        return Command(self, response)
+
+    def get_all_projects_in_org(self, len=None, offset=None, order_by=None, search=None):
+        """Gets all the Projects in an organization.
+
+        Args:
+            len (:obj:`int`, optional): The size of the page to be returned. Default: ``None``
+            offset (:obj:`int`, optional): Zero Based Offset Index. Default: ``None``.
+            order_by (:obj:`str`, optional): The order in which the results should be returned.
+            search (:obj:`str`, optional): The SAQL search query. Default: ``None``.
+
+        Returns:
+            An instance of :py:class:`streamsets.sdk.sch_api.Command`.
+        """
+        params = get_params(locals(), exclusions=(self,))
+        response = self._get(app="security", endpoint=f"/v{self.api_version}/projects/search", params=params)
+        return Command(self, response)
+
+    def get_all_projects_available_to_user(self, offset=None, len=None):
+        """Gets all the Projects the current user is part of.
+
+        Returns:
+            An instance of :py:class:`streamsets.sdk.sch_api.Command`.
+        """
+        params = get_params(locals(), exclusions=(self,))
+        response = self._get(app="security", endpoint=f"/v{self.api_version}/projects", params=params)
+        return Command(self, response)
+
+    def get_all_users_in_project(self, project_id):
+        """Get all users in a given Project.
+
+        Args:
+            project_id (:obj:`str`): ID of the Project to get.
+
+        Returns:
+            An instance of :py:class:`streamsets.sdk.sch_api.Command`.
+        """
+        response = self._get(app="security", endpoint=f"/v{self.api_version}/project/{project_id}/getAllUsers")
+        return Command(self, response)
+
+    def get_all_groups_in_project(self, project_id):
+        """Get all groups in a given Project.
+
+        Args:
+            project_id (:obj:`str`): ID of the Project to get.
+
+        Returns:
+            An instance of :py:class:`streamsets.sdk.sch_api.Command`.
+        """
+        response = self._get(app="security", endpoint=f"/v{self.api_version}/project/{project_id}/getAllGroups")
+        return Command(self, response)
+
+    def update_users_in_project(self, project_id, body):
+        """Update users in a given Project.
+
+        Args:
+            project_id (:obj:`str`): ID of the Project to get.
+            body (:obj:`dict`):  Request body conforming to the Swagger API definition.
+
+        Returns:
+            An instance of :py:class:`streamsets.sdk.sch_api.Command`.
+        """
+        response = self._put(app="security", endpoint=f"/v{self.api_version}/project/{project_id}/users", data=body)
+        return Command(self, response)
+
+    def update_groups_in_project(self, project_id, body):
+        """Update groups in a given Project.
+
+        Args:
+            project_id (:obj:`str`): ID of the Project to get.
+            body (:obj:`dict`):  Request body conforming to the Swagger API definition.
+
+        Returns:
+            An instance of :py:class:`streamsets.sdk.sch_api.Command`.
+        """
+        response = self._put(app="security", endpoint=f"/v{self.api_version}/project/{project_id}/groups", data=body)
+        return Command(self, response)
+
     def get_banner_api(self):
         try:
             response = self._get(app='banner', endpoint='swagger.json')
@@ -8943,11 +9082,28 @@ class ApiClient(object):
             return None
 
     # Internal functions only below.
+    def _update_project_param_based_on_app(self, app, params):
+        """Updates the query string params to pass the project ID based on which app is being called.
+
+        Args:
+            app (:obj:`str`): App for which the endpoint being called.
+            params (:obj:`dict`): A dictionary with the query string params being passed to the endpoint.
+        """
+        if not isinstance(params, dict):
+            raise TypeError("Params should be of type dict.")
+
+        if app in APPS_REQUIRING_PROJECT_ID:
+            params.update(get_params({'project': self.current_project_id}))
+
     @retry_on_connection_error
     def _delete(self, app, endpoint, rest='rest', params=None):
+        # update params with which project we are running in
+        params = params or {}
+        self._update_project_param_based_on_app(app=app, params=params)
+
         self.update_session_headers_with_analytics_data()
         url = join_url_parts(self.base_url, app, '/{}'.format(rest), endpoint)
-        response = self.session.delete(url, params=params or {})
+        response = self.session.delete(url, params=params)
         self._handle_http_error(response)
         return response
 
@@ -8955,6 +9111,11 @@ class ApiClient(object):
     def _delete_via_tunneling(
         self, endpoint, tunneling_instance_id, rest='rest', tunneling='tunneling', engine_id=None, params=None
     ):
+        params = params or {}
+        # Platform's APIs use an unconventional parameter for tunneling instance ID that doesn't conform to the
+        # same naming convention as other parameters, thus we have to set it manually here
+        params.update({'TUNNELING_INSTANCE_ID': tunneling_instance_id})
+
         self.update_session_headers_with_analytics_data()
         url = join_url_parts(
             self.base_url,
@@ -8964,20 +9125,19 @@ class ApiClient(object):
             '/{}'.format(rest),
             endpoint,
         )
-        if params is None:
-            params = {}
-        # Platform's APIs use an unconventional parameter for tunneling instance ID that doesn't conform to the
-        # same naming convention as other parameters, thus we have to set it manually here
-        params.update({'TUNNELING_INSTANCE_ID': tunneling_instance_id})
         response = self.session.delete(url, params=params)
         self._handle_http_error(response)
         return response
 
     @retry_on_connection_error
     def _get(self, endpoint, app=None, rest='rest', params=None, headers=None, absolute_endpoint=False):
+        # update params with which project we are running in
+        params = params or {}
+        self._update_project_param_based_on_app(app=app, params=params)
+
         self.update_session_headers_with_analytics_data()
         url = endpoint if absolute_endpoint else join_url_parts(self.base_url, app, '/{}'.format(rest), endpoint)
-        response = self.session.get(url, params=params or {}, headers=headers)
+        response = self.session.get(url, params=params, headers=headers)
         self._handle_http_error(response)
         return response
 
@@ -8985,6 +9145,11 @@ class ApiClient(object):
     def _get_via_tunneling(
         self, endpoint, tunneling_instance_id, rest='rest', tunneling='tunneling', engine_id=None, params=None
     ):
+        params = params or {}
+        # Platform's APIs use an unconventional parameter for tunneling instance ID that doesn't conform to the
+        # same naming convention as other parameters, thus we have to set it manually here
+        params.update({'TUNNELING_INSTANCE_ID': tunneling_instance_id})
+
         self.update_session_headers_with_analytics_data()
         url = join_url_parts(
             self.base_url,
@@ -8994,11 +9159,6 @@ class ApiClient(object):
             '/{}'.format(rest),
             endpoint,
         )
-        if params is None:
-            params = {}
-        # Platform's APIs use an unconventional parameter for tunneling instance ID that doesn't conform to the
-        # same naming convention as other parameters, thus we have to set it manually here
-        params.update({'TUNNELING_INSTANCE_ID': tunneling_instance_id})
         response = self.session.get(url, params=params)
         self._handle_http_error(response)
         return response
@@ -9007,13 +9167,17 @@ class ApiClient(object):
     def _post(
         self, endpoint, app=None, rest='rest', params=None, data=None, files=None, headers=None, absolute_endpoint=False
     ):
+        # update params with which project we are running in
+        params = params or {}
+        self._update_project_param_based_on_app(app=app, params=params)
+
         self.update_session_headers_with_analytics_data()
         url = endpoint if absolute_endpoint else join_url_parts(self.base_url, app, '/{}'.format(rest), endpoint)
         if not data:
             data = None
         else:
             data = data if isinstance(data, str) else json.dumps(data)
-        response = self.session.post(url, params=params or {}, data=data, files=files, headers=headers)
+        response = self.session.post(url, params=params, data=data, files=files, headers=headers)
         self._handle_http_error(response)
         return response
 
@@ -9031,13 +9195,13 @@ class ApiClient(object):
         headers=None,
         engine_id=None,
     ):
-        self.update_session_headers_with_analytics_data()
-        url = join_url_parts(self.base_url, tunneling, rest, form_data, engine_id, rest, endpoint)
-        if params is None:
-            params = {}
+        params = params or {}
         # Platform's APIs use an unconventional parameter for tunneling instance ID that doesn't conform to the
         # same naming convention as other parameters, thus we have to set it manually here
         params.update({'TUNNELING_INSTANCE_ID': tunneling_instance_id})
+
+        self.update_session_headers_with_analytics_data()
+        url = join_url_parts(self.base_url, tunneling, rest, form_data, engine_id, rest, endpoint)
         if data:
             data = data if isinstance(data, str) else json.dumps(data)
         response = self.session.post(url, params=params, data=data, files=files, headers=headers)
@@ -9046,9 +9210,13 @@ class ApiClient(object):
 
     @retry_on_connection_error
     def _put(self, app, endpoint, rest='rest', params=None, data=None):
+        # update params with which project we are running in
+        params = params or {}
+        self._update_project_param_based_on_app(app=app, params=params)
+
         self.update_session_headers_with_analytics_data()
         url = join_url_parts(self.base_url, app, '/{}'.format(rest), endpoint)
-        response = self.session.put(url, params=params or {}, data=json.dumps(data or {}))
+        response = self.session.put(url, params=params, data=json.dumps(data or {}))
         self._handle_http_error(response)
         return response
 
@@ -9063,6 +9231,11 @@ class ApiClient(object):
         params=None,
         data=None,
     ):
+        params = params or {}
+        # Platform's APIs use an unconventional parameter for tunneling instance ID that doesn't conform to the
+        # same naming convention as other parameters, thus we have to set it manually here
+        params.update({'TUNNELING_INSTANCE_ID': tunneling_instance_id})
+
         self.update_session_headers_with_analytics_data()
         url = join_url_parts(
             self.base_url,
@@ -9072,11 +9245,6 @@ class ApiClient(object):
             '/{}'.format(rest),
             endpoint,
         )
-        if params is None:
-            params = {}
-        # Platform's APIs use an unconventional parameter for tunneling instance ID that doesn't conform to the
-        # same naming convention as other parameters, thus we have to set it manually here
-        params.update({'TUNNELING_INSTANCE_ID': tunneling_instance_id})
         response = self.session.put(url, params=params, data=json.dumps(data or {}))
         self._handle_http_error(response)
         return response