illumio-pylo 0.3.10__tar.gz → 0.3.12__tar.gz

{illumio_pylo-0.3.10 → illumio_pylo-0.3.12}/.github/workflows/make-binaries.yml

@@ -20,6 +20,7 @@ jobs:
       - name: Change Pylo Version if this is a DEV build
         if: github.ref == 'refs/heads/dev' && github.event_name == 'push'
         run: |
+          pwd
           echo "Update version to append '-dev-' and current date ISO format:"
           # for double quoted strings version
           sed -i -E "s/__version__ = \"([0-9]+\.[0-9]+\.[0-9]+)\"/__version__ = '\\1-dev-$(date +'%Y%m%d')'/" illumio_pylo/__init__.py
@@ -28,12 +29,49 @@ jobs:
           grep __version__ illumio_pylo/__init__.py
           
 
+      - name: copy scripts and pkg to build folder
+        run: |
+          # build the package
+          pip install build
+          python -m build
+          echo "current working directory:"
+          pwd
+          # get package whl filename for later use, it is in dist/
+          package_filename=$(find dist/ -name "illumio_pylo-*.whl" | sed 's|dist/||')
+          echo "*** Package filename is: $package_filename"
+          mkdir cli-build
+          # move package to cli-build
+          mv "dist/$package_filename" cli-build/
+          
+          # create requirements.txt that points to the local package
+          echo "illumio_pylo@file:./cli-build/$package_filename" > cli-build/requirements.txt
+          #echo "pyinstaller==6.16.0" >> cli-build/requirements.txt
+          echo "*** Created cli-build/requirements.txt with contents:"
+          cat cli-build/requirements.txt
+          
+          # copy cli.py removing any sys.path.insert lines
+          grep -v 'sys.path.insert' illumio_pylo/utilities/cli.py > cli-build/cli.py
+          mv illumio_pylo/utilities/health_monitoring.py cli-build/
+          
+          # delete illumio_pylo to avoid confusion
+          rm -rf illumio_pylo/
+          
+          echo "*** Contents of cli-build/:"
+          find cli-build/
+
       - name: Make executables
         uses: cpainchaud/pyinstaller-action-windows@main
         with:
           path: ./
-          spec: illumio_pylo/utilities/
-          extra_python_paths: Z:\\github\\workspace\\;Z:\\github\\workspace\\pylo;C:\\Windows\\System32\\downlevel
+          spec: ./cli-build/
+          requirements: ./cli-build/requirements.txt
+          collect_data: illumio_pylo
+          extra_python_paths: Z:\\github\\workspace\\;C:\\Windows\\System32\\downlevel
+
+      - name: show spec files
+        run: |
+          echo "Showing the spec files created by PyInstaller:"
+          find ../ -name "*.spec" -exec cat {} \;
 
       - name: rename executables
         run: |

{illumio_pylo-0.3.10 → illumio_pylo-0.3.12}/.github/workflows/python-publish.yml

@@ -26,10 +26,10 @@ jobs:
         python-version: '3.11'
     - name: Install dependencies
       run: |
-        python -m pip install --upgrade pip
+        python -m pip install --upgrade pip setuptools wheel twine pkginfo
         pip install build
     - name: Build package
       run: python -m build
     - name: Publish package
-      uses: pypa/gh-action-pypi-publish@81e9d935c883d0b210363ab89cf05f3894778450 # v1.8.14
+      uses: pypa/gh-action-pypi-publish@ed0c53931b1dc9bd32cbe73a98c7f6766f8a527e # v1.13.0
 

{illumio_pylo-0.3.10/illumio_pylo.egg-info → illumio_pylo-0.3.12}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: illumio_pylo
-Version: 0.3.10
+Version: 0.3.12
 Summary: A set of tools and library for working with Illumio PCE
 Home-page: https://github.com/cpainchaud/pylo
 Author: Christophe Painchaud
@@ -187,11 +187,18 @@ Requires-Python: >=3.11
 License-File: LICENSE
 Requires-Dist: click==8.1.7
 Requires-Dist: colorama~=0.4.4
-Requires-Dist: cryptography==43.0.1
+Requires-Dist: cryptography==44.0.1
 Requires-Dist: openpyxl~=3.1.3
 Requires-Dist: paramiko~=3.4.0
 Requires-Dist: prettytable~=3.10.0
 Requires-Dist: requests~=2.32.0
 Requires-Dist: xlsxwriter~=3.2.0
+Requires-Dist: flask~=2.2.0
+Dynamic: author
+Dynamic: author-email
+Dynamic: description
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: requires-python
 
 README.md

{illumio_pylo-0.3.10 → illumio_pylo-0.3.12}/examples/extend_cli.py

@@ -23,6 +23,7 @@ class MyBuiltInParser:  # optional, if you want to use built-in parsers
                                    label_type='env',  # optional, it will ensure that selected labels are of a specified type
                                    is_required=False, allow_multiple=True)
 
+
 def fill_parser(parser: argparse.ArgumentParser):
     """ This function will be called by the CLI to fill the parser with the arguments of your command """
     parser.add_argument('--sort-by-name', '-s', action='store_true',

{illumio_pylo-0.3.10 → illumio_pylo-0.3.12}/illumio_pylo/API/APIConnector.py

@@ -28,9 +28,13 @@ from typing import Union, Dict, Any, List, Optional, Literal
 
 requests.packages.urllib3.disable_warnings()
 
+objects_types_strings = Literal[
+    'workloads', 'virtual_services', 'labels', 'labelgroups', 'iplists', 'services',
+    'rulesets', 'security_principals', 'label_dimensions']
+
 default_retry_count_if_api_call_limit_reached = 3
 default_retry_wait_time_if_api_call_limit_reached = 10
-default_max_objects_for_sync_calls = 99999
+default_max_objects_for_sync_calls = 200000
 
 
 def get_field_or_die(field_name: str, data):
@@ -69,14 +73,14 @@ class APIConnector:
         if type(port) is int:
             port = str(port)
         self.port: int = port
-        self._api_key: str = api_key
-        self._decrypted_api_key: Optional[str] = None
         self.api_user: str = api_user
+        self._api_key: str = api_key
+        self._decrypted_api_key: Optional[str] = None  # if api_key is encrypted, this will hold the decrypted value after first use
         self.org_id: int = org_id
         self.skipSSLCertCheck: bool = skip_ssl_cert_check
         self.version: Optional['pylo.SoftwareVersion'] = None
         self.version_string: str = "Not Defined"
-        self._cached_session = requests.session()
+        self._cached_session = requests.sessions.Session()
 
     @property
     def api_key(self):
@@ -153,6 +157,33 @@ class APIConnector:
 
         return url
 
+    def _get_objects_auto_switch_async(self, path: str, data: Dict[str, Any], async_mode: bool, max_results: Optional[int]) -> Any:
+        # use a copy of data to not modify the original
+        data_copy = data.copy()
+
+        if async_mode:
+            if max_results is not None:
+                data_copy['max_results'] = max_results
+            return self.do_get_call(path=path, async_call=True, params=data_copy)
+
+        if max_results is not None:
+            data_copy['max_results'] = max_results
+            return self.do_get_call(path=path, async_call=False, params=data_copy)
+
+        # We will grab the maximum allowed with sync mode (variable default_max_objects_for_sync_calls) and switch to async if it's higher
+        data_copy['max_results'] = default_max_objects_for_sync_calls
+        results = self.do_get_call(path=path, async_call=False, params=data_copy, return_headers=True)
+        total_count = results[1].get('x-total-count')
+        if total_count is None:
+            raise pylo.PyloApiEx('API didnt provide field "x-total-count" in headers')
+        if not total_count.isdigit():
+            raise pylo.PyloApiEx('API returned invalid value for "x-total-count": {}'.format(total_count))
+        if int(total_count) > default_max_objects_for_sync_calls:
+            # remove the max_results from data
+            del data_copy['max_results']
+            return self.do_get_call(path=path, async_call=True, params=data_copy)
+        return results[0]
+
     def do_get_call(self, path, json_arguments=None, include_org_id=True, json_output_expected=True, async_call=False, params=None, skip_product_version_check=False,
                     retry_count_if_api_call_limit_reached=default_retry_count_if_api_call_limit_reached,
                     retry_wait_time_if_api_call_limit_reached=default_retry_wait_time_if_api_call_limit_reached,
@@ -275,7 +306,7 @@ class APIConnector:
                     log.info("Job status is " + job_poll_status)
 
                 log.info("Job is done, we will now download the resulting dataset")
-                dataset = self.do_get_call(result_href, include_org_id=False)
+                dataset = self.do_get_call(result_href, include_org_id=False, return_headers=return_headers)
 
                 return dataset
 
@@ -313,9 +344,6 @@ class APIConnector:
                 raise pylo.PyloApiEx('API returned error status "' + str(req.status_code) + ' ' + req.reason
                                      + '" and error message: ' + req.text)
 
-            if return_headers:
-                return req.headers
-
             if json_output_expected:
                 log.info("Parsing API answer to JSON (with a size of " + str(int(answer_size)) + "KB)")
                 json_out = req.json()
@@ -325,8 +353,12 @@ class APIConnector:
                     log.info(json.dumps(json_out, indent=2, sort_keys=True))
                 else:
                     log.info("Answer is too large to be printed")
+                if return_headers:
+                    return json_out, req.headers
                 return json_out
 
+            if return_headers:
+                return req.text, req.headers
             return req.text
 
         raise pylo.PyloApiEx("Unexpected API output or race condition")
@@ -339,33 +371,39 @@ class APIConnector:
         self.collect_pce_infos()
         return self.version_string
 
-    def get_objects_count_by_type(self, object_type: str) -> int:
+    def get_objects_count_by_type(self, object_type: objects_types_strings) -> int:
 
         def extract_count(headers):
             count = headers.get('x-total-count')
             if count is None:
                 raise pylo.PyloApiEx('API didnt provide field "x-total-count"')
 
+            # count should be an integer
+            if not count.isdigit():
+                raise pylo.PyloApiEx('API returned invalid value for "x-total-count": {}'.format(count))
+
             return int(count)
 
+        params = {'max_results': 1}
+
         if object_type == 'workloads':
-            return extract_count(self.do_get_call('/workloads', async_call=False, return_headers=True))
+            return extract_count(self.do_get_call('/workloads', async_call=False, return_headers=True, params=params)[1])
         elif object_type == 'virtual_services':
-            return extract_count(self.do_get_call('/sec_policy/draft/virtual_services', async_call=False, return_headers=True))
+            return extract_count(self.do_get_call('/sec_policy/draft/virtual_services', async_call=False, return_headers=True, params=params)[1])
         elif object_type == 'labels':
-            return extract_count(self.do_get_call('/labels', async_call=False, return_headers=True))
+            return extract_count(self.do_get_call('/labels', async_call=False, return_headers=True, params=params)[1])
         elif object_type == 'labelgroups':
-            return extract_count(self.do_get_call('/sec_policy/draft/label_groups', async_call=False, return_headers=True))
+            return extract_count(self.do_get_call('/sec_policy/draft/label_groups', async_call=False, return_headers=True, params=params)[1])
         elif object_type == 'iplists':
-            return extract_count(self.do_get_call('/sec_policy/draft/ip_lists', async_call=False, return_headers=True))
+            return extract_count(self.do_get_call('/sec_policy/draft/ip_lists', async_call=False, return_headers=True, params=params)[1])
         elif object_type == 'services':
-            return extract_count(self.do_get_call('/sec_policy/draft/services', async_call=False, return_headers=True))
+            return extract_count(self.do_get_call('/sec_policy/draft/services', async_call=False, return_headers=True, params=params)[1])
         elif object_type == 'rulesets':
-            return extract_count(self.do_get_call('/sec_policy/draft/rule_sets', async_call=False, return_headers=True))
+            return extract_count(self.do_get_call('/sec_policy/draft/rule_sets', async_call=False, return_headers=True, params=params)[1])
         elif object_type == 'security_principals':
-            return extract_count(self.do_get_call('/security_principals', async_call=False, return_headers=True))
+            return extract_count(self.do_get_call('/security_principals', async_call=False, return_headers=True, params=params)[1])
         elif object_type == 'label_dimensions':
-            return extract_count(self.do_get_call('/label_dimensions', async_call=False, return_headers=True))
+            return extract_count(self.do_get_call('/label_dimensions', async_call=False, return_headers=True, params=params)[1])
         else:
             raise pylo.PyloEx("Unsupported object type '{}'".format(object_type))
 
@@ -403,57 +441,32 @@ class APIConnector:
                         q.task_done()
                         continue
                     if object_type == 'workloads':
-                        if self.get_objects_count_by_type(object_type) > default_max_objects_for_sync_calls or force_async_mode:
-                            data['workloads'] = self.objects_workload_get(include_deleted=include_deleted_workloads)
-                        else:
-                            data['workloads'] = self.objects_workload_get(include_deleted=include_deleted_workloads, async_mode=False, max_results=default_max_objects_for_sync_calls)
+                        data['workloads'] = self.objects_workload_get(include_deleted=include_deleted_workloads, async_mode=force_async_mode)
 
                     elif object_type == 'virtual_services':
-                        if self.get_objects_count_by_type(object_type) > default_max_objects_for_sync_calls:
-                            data['virtual_services'] = self.objects_virtual_service_get()
-                        else:
-                            data['virtual_services'] = self.objects_virtual_service_get(async_mode=False, max_results=default_max_objects_for_sync_calls)
+                        data['virtual_services'] = self.objects_virtual_service_get(async_mode=force_async_mode)
 
                     elif object_type == 'labels':
-                        if self.get_objects_count_by_type(object_type) > default_max_objects_for_sync_calls:
-                            data['labels'] = self.objects_label_get()
-                        else:
-                            data['labels'] = self.objects_label_get(async_mode=False, max_results=default_max_objects_for_sync_calls)
+                        data['labels'] = self.objects_label_get(async_mode=force_async_mode)
 
                     elif object_type == 'labelgroups':
-                        if self.get_objects_count_by_type(object_type) > default_max_objects_for_sync_calls:
-                            data['labelgroups'] = self.objects_labelgroup_get()
-                        else:
-                            data['labelgroups'] = self.objects_labelgroup_get(async_mode=False, max_results=default_max_objects_for_sync_calls)
+                        data['labelgroups'] = self.objects_labelgroup_get(async_mode=force_async_mode)
 
                     elif object_type == 'iplists':
-                        if self.get_objects_count_by_type(object_type) > default_max_objects_for_sync_calls:
-                            data['iplists'] = self.objects_iplist_get()
-                        else:
-                            data['iplists'] = self.objects_iplist_get(async_mode=False, max_results=default_max_objects_for_sync_calls)
+                        data['iplists'] = self.objects_iplist_get(async_mode=force_async_mode)
 
                     elif object_type == 'services':
-                        if self.get_objects_count_by_type(object_type) > default_max_objects_for_sync_calls:
-                            data['services'] = self.objects_service_get()
-                        else:
-                            data['services'] = self.objects_service_get(async_mode=False, max_results=default_max_objects_for_sync_calls)
+                        data['services'] = self.objects_service_get(async_mode=force_async_mode)
 
                     elif object_type == 'rulesets':
-                        if self.get_objects_count_by_type(object_type) > default_max_objects_for_sync_calls:
-                            data['rulesets'] = self.objects_ruleset_get()
-                        else:
-                            data['rulesets'] = self.objects_ruleset_get(async_mode=False, max_results=default_max_objects_for_sync_calls)
+                        data['rulesets'] = self.objects_ruleset_get(async_mode=force_async_mode)
 
                     elif object_type == 'security_principals':
-                        if self.get_objects_count_by_type(object_type) > default_max_objects_for_sync_calls:
-                            data['security_principals'] = self.objects_securityprincipal_get()
-                        else:
-                            data['security_principals'] = self.objects_securityprincipal_get(async_mode=False, max_results=default_max_objects_for_sync_calls)
+                        data['security_principals'] = self.objects_securityprincipal_get(async_mode=force_async_mode)
+
                     elif object_type == 'label_dimensions':
-                        if self.get_objects_count_by_type(object_type) > default_max_objects_for_sync_calls:
-                            data['label_dimensions'] = self.objects_label_dimension_get()
-                        else:
-                            data['label_dimensions'] = self.objects_label_dimension_get(async_mode=False, max_results=default_max_objects_for_sync_calls)
+                        data['label_dimensions'] = self.objects_label_dimension_get()
+
                     else:
                         raise pylo.PyloEx("Unsupported object type '{}'".format(object_type))
                 except Exception as e:
@@ -533,14 +546,17 @@ class APIConnector:
             params = {'include_deny_rules': include_boundary_rules}
         return self.do_post_call(path='/sec_policy/draft/rule_coverage', json_arguments=data, include_org_id=True, json_output_expected=True, async_call=False, params=params)
 
-    def objects_label_get(self, max_results: int = None, async_mode=True) -> List[LabelObjectJsonStructure]:
+    def objects_label_get(self, max_results: int = None, async_mode=False, get_usage: bool = False, get_deleted: bool = False) -> List[LabelObjectJsonStructure]:
         path = '/labels'
         data = {}
 
-        if max_results is not None:
-            data['max_results'] = max_results
+        if get_usage:
+            data['usage'] = 'true'
+
+        if get_deleted:
+            data['includeDeleted'] = 'true'
 
-        return self.do_get_call(path=path, async_call=async_mode, params=data)
+        return self._get_objects_auto_switch_async(path=path, data=data, async_mode=async_mode, max_results=max_results)
 
     def objects_label_update(self, href: str, data: LabelObjectUpdateJsonStructure):
         path = href
@@ -553,19 +569,70 @@ class APIConnector:
 
         return self.do_delete_call(path=path, json_output_expected=False, include_org_id=False)
 
+    class LabelMultiDeleteTracker:
+        _errors: Dict[str, str]
+        _hrefs: Dict[str, bool]
+        _labels: Dict[str, 'pylo.Label']  # dict of workloads by HREF
+        connector: 'pylo.APIConnector'
+
+        def __init__(self, connector: 'pylo.APIConnector'):
+            self.connector = connector
+            self._errors: Dict[str, Union[bool, str]] = {}
+            self._hrefs: Dict[str, str] = {}
+            self._labels: Dict[str, 'pylo.Label'] = {}
+
+        def add_label(self, label_or_href: Union['pylo.Label', str]):
+            if type(label_or_href) is str:
+                self._hrefs[label_or_href] = True
+                return
+            self._labels[label_or_href.href] = label_or_href
+            self._hrefs[label_or_href.href] = True
+
+        def execute_deletion(self):
+            for href in self._hrefs.keys():
+                try:
+                    self.connector.objects_label_delete(href)
+                    self._errors[href] = False
+                except Exception as e:
+                    self._errors[href] = str(e)
+
+            return self._errors
+
+        def has_errors(self) -> bool:
+            for href in self._errors.keys():
+                if self._errors[href] is not False:
+                    return True
+            return False
+
+        def get_errors_count(self) -> int:
+            count = 0
+            for href in self._errors.keys():
+                if self._errors[href] is not False:
+                    count += 1
+            return count
+
+        def get_error(self, label_or_href: Union['pylo.Label', str]) -> Optional[str]:
+            href = label_or_href
+            if type(label_or_href) is pylo.Label:
+                href = label_or_href.href
+            error = self._errors.get(href, None)
+            if error is None or error is False:
+                return None
+            return error
+
+    def new_tracker_for_label_multi_deletion(self) -> 'pylo.APIConnector.LabelMultiDeleteTracker':
+        return pylo.APIConnector.LabelMultiDeleteTracker(self)
+
     def objects_label_create(self, label_name: str, label_type: str):
         path = '/labels'
         data: LabelObjectCreationJsonStructure = {'key': label_type, 'value': label_name}
         return self.do_post_call(path=path, json_arguments=data)
 
-    def objects_labelgroup_get(self, max_results: int = None, async_mode=True) -> List[LabelGroupObjectJsonStructure]:
+    def objects_labelgroup_get(self, max_results: int = None, async_mode=False) -> List[LabelGroupObjectJsonStructure]:
         path = '/sec_policy/draft/label_groups'
         data = {}
 
-        if max_results is not None:
-            data['max_results'] = max_results
-
-        return self.do_get_call(path=path, async_call=async_mode, params=data)
+        return self._get_objects_auto_switch_async(path=path, data=data, async_mode=async_mode, max_results=max_results)
 
     def objects_labelgroup_update(self, href: str, data: LabelGroupObjectUpdateJsonStructure):
         path = href
@@ -575,34 +642,26 @@ class APIConnector:
         path = '/label_dimensions'
         data = {}
 
-        if max_results is not None:
-            data['max_results'] = max_results
-        return self.do_get_call(path=path, async_call=async_mode, params=data)
+        return self._get_objects_auto_switch_async(path=path, data=data, async_mode=async_mode, max_results=max_results)
 
-    def objects_virtual_service_get(self, max_results: int = None, async_mode=True) -> List[VirtualServiceObjectJsonStructure]:
+    def objects_virtual_service_get(self, max_results: int = None, async_mode=False) -> List[VirtualServiceObjectJsonStructure]:
         path = '/sec_policy/draft/virtual_services'
         data = {}
 
-        if max_results is not None:
-            data['max_results'] = max_results
-
-        results = self.do_get_call(path=path, async_call=async_mode, params=data)
+        results = self._get_objects_auto_switch_async(path=path, data=data, async_mode=async_mode, max_results=max_results)
         # check type
         if type(results) is list:
             return results
         raise pylo.PyloEx("Unexpected result type '{}' while expecting an array of Virtual Service objects".format(type(results)), results)
 
-    def objects_iplist_get(self, max_results: int = None, async_mode=True, search_name: str = None) -> List[IPListObjectJsonStructure]:
+    def objects_iplist_get(self, max_results: int = None, async_mode=False, search_name: str = None) -> List[IPListObjectJsonStructure]:
         path = '/sec_policy/draft/ip_lists'
         data = {}
 
         if search_name is not None:
             data['name'] = search_name
 
-        if max_results is not None:
-            data['max_results'] = max_results
-
-        results: List[IPListObjectJsonStructure] = self.do_get_call(path=path, async_call=async_mode, params=data)
+        results: List[IPListObjectJsonStructure] = self._get_objects_auto_switch_async(path=path, data=data, async_mode=async_mode, max_results=max_results)
         # check type
         if type(results) is list:
             return results
@@ -654,10 +713,7 @@ class APIConnector:
         if representation is not None:
             data['representation'] = representation
 
-        if max_results is not None:
-            data['max_results'] = max_results
-
-        return self.do_get_call(path=path, async_call=async_mode, params=data)
+        return self._get_objects_auto_switch_async(path=path, data=data, async_mode=async_mode, max_results=max_results)
 
     def objects_workload_get(self,
                              include_deleted=False,
@@ -667,7 +723,7 @@ class APIConnector:
                              filter_by_managed: bool = None,
                              filer_by_policy_health: Literal['active', 'warning', 'error'] = None,
                              max_results: int = None,
-                             async_mode=True) -> List[WorkloadObjectJsonStructure]:
+                             async_mode=False) -> List[WorkloadObjectJsonStructure]:
         path = '/workloads'
         data = {}
 
@@ -690,10 +746,8 @@ class APIConnector:
         if filer_by_policy_health is not None:
             data['policy_health'] = filer_by_policy_health
 
-        if max_results is not None:
-            data['max_results'] = max_results
+        return self._get_objects_auto_switch_async(path=path, data=data, async_mode=async_mode, max_results=max_results)
 
-        return self.do_get_call(path=path, async_call=async_mode, params=data)
 
     def objects_workload_agent_upgrade(self, workload_href: str, target_version: str):
         path = '{}/upgrade'.format(workload_href)
@@ -941,14 +995,11 @@ class APIConnector:
         path = '/workloads/bulk_create'
         return self.do_put_call(path=path, json_arguments=workloads_json_payload)
 
-    def objects_service_get(self, max_results: int = None, async_mode=True):
+    def objects_service_get(self, max_results: int = None, async_mode=False):
         path = '/sec_policy/draft/services'
         data = {}
 
-        if max_results is not None:
-            data['max_results'] = max_results
-
-        return self.do_get_call(path=path, async_call=async_mode, params=data)
+        return self._get_objects_auto_switch_async(path=path, data=data, async_mode=async_mode, max_results=max_results)
 
     def objects_service_delete(self, href):
         """
@@ -990,14 +1041,11 @@ class APIConnector:
 
         return self.do_post_call(path=path, async_call=False, include_org_id=False, json_arguments=data, json_output_expected=True)
 
-    def objects_ruleset_get(self, max_results: int = None, async_mode=True) -> List[RulesetObjectJsonStructure]:
+    def objects_ruleset_get(self, max_results: int = None, async_mode=False) -> List[RulesetObjectJsonStructure]:
         path = '/sec_policy/draft/rule_sets'
         data = {}
 
-        if max_results is not None:
-            data['max_results'] = max_results
-
-        return self.do_get_call(path=path, async_call=async_mode, params=data)
+        return self._get_objects_auto_switch_async(path=path, data=data, async_mode=async_mode, max_results=max_results)
 
     def objects_ruleset_create(self, name: str,
                                scope_app: 'pylo.Label' = None,
@@ -1116,14 +1164,11 @@ class APIConnector:
 
         return self.do_post_call(path, json_arguments=data, json_output_expected=True, include_org_id=False)
 
-    def objects_securityprincipal_get(self, max_results: int = None, async_mode=True) -> List[SecurityPrincipalObjectJsonStructure]:
+    def objects_securityprincipal_get(self, max_results: int = None, async_mode=False) -> List[SecurityPrincipalObjectJsonStructure]:
         path = '/security_principals'
         data = {}
 
-        if max_results is not None:
-            data['max_results'] = max_results
-
-        return self.do_get_call(path=path, async_call=async_mode, params=data)
+        return self._get_objects_auto_switch_async(path=path, data=data, async_mode=async_mode, max_results=max_results)
 
     def objects_securityprincipal_create(self, name: str = None, sid: str = None, json_data=None) -> str:
         """
@@ -1378,7 +1423,4 @@ class APIConnector:
     def get_pce_ui_workload_url(self, href: str) -> str:
         # extract UUID from workload HREF:
         uuid = href.split('/')[-1]
-        return self._make_base_url('/#/workloads/' + uuid )
-
-
-
+        return self._make_base_url('/#/workloads/' + uuid)

{illumio_pylo-0.3.10 → illumio_pylo-0.3.12}/illumio_pylo/API/CredentialsManager.py

@@ -199,6 +199,44 @@ def create_credential_in_file(file_full_path: str, data: CredentialFileEntry, ov
     return file_full_path
 
 
+def delete_credential_from_file(profile_name: str, file_path: str) -> bool:
+    """
+    Delete a credential from a file by profile name.
+    :param profile_name: Name of the profile to delete
+    :param file_path: Path to the credential file
+    :return: True if deleted successfully
+    """
+    if not os.path.exists(file_path):
+        raise PyloEx("Credential file does not exist: {}".format(file_path))
+
+    with open(file_path, 'r') as f:
+        credentials: CredentialsFileType = json.load(f)
+
+    if isinstance(credentials, list):
+        original_len = len(credentials)
+        credentials = [c for c in credentials if c['name'].lower() != profile_name.lower()]
+        if len(credentials) == original_len:
+            raise PyloEx("Profile '{}' not found in file '{}'".format(profile_name, file_path))
+
+        if len(credentials) == 0:
+            # If no credentials left, delete the file
+            os.remove(file_path)
+            return True
+    else:
+        if credentials['name'].lower() == profile_name.lower():
+            # Single credential in file, delete the file
+            os.remove(file_path)
+            return True
+        else:
+            raise PyloEx("Profile '{}' not found in file '{}'".format(profile_name, file_path))
+
+    # Write the updated credentials back to the file
+    with open(file_path, 'w') as f:
+        json.dump(credentials, f, indent=4)
+
+    return True
+
+
 def create_credential_in_default_file(data: CredentialFileEntry) -> str:
     """
     Create a credential in the default credential file and return the full path to the file