cid-cmd 4.0.2__tar.gz → 4.0.4__tar.gz

{cid_cmd-4.0.2/cid_cmd.egg-info → cid_cmd-4.0.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: cid-cmd
-Version: 4.0.2
+Version: 4.0.4
 Summary: Cloud Intelligence Dashboards deployment helper tool
 Home-page: https://github.com/aws-samples/aws-cudos-framework-deployment
 Author: AWS CUDOS Team

cid_cmd-4.0.4/cid/_version.py

@@ -0,0 +1,2 @@
+__version__ = '4.0.4'
+

{cid_cmd-4.0.2 → cid_cmd-4.0.4}/cid/common.py

@@ -300,7 +300,7 @@ class Cid():
             logger.debug(f"Issue logging action {action}  for dashboard {dashboard_id} , due to a urllib3 exception {str(e)} . This issue will be ignored")
 
     def get_page(self, source):
-        resp = requests.get(source, timeout=10)
+        resp = requests.get(source, timeout=10, headers={'User-Agent': 'cid'})
         resp.raise_for_status()
         return resp
 
@@ -435,7 +435,7 @@ class Cid():
 
         # In case if we cannot discover datasets, we need to discover dashboards
         # TODO: check if datasets returns explicit permission denied and only then discover dashboards as a workaround
-        self.qs.discover_dashboards()
+        self.qs.dashboards
 
         dashboard_id = dashboard_id or get_parameters().get('dashboard-id')
         category_filter = [cat for cat in get_parameters().get('category', '').upper().split(',') if cat]
@@ -782,8 +782,7 @@ class Cid():
                 # Check if dataset is used in some other dashboard
                 for dashboard in (self.qs.dashboards or {}).values():
                     if dataset.id in dashboard.datasets.values():
-                        logger.info(f'Dataset {dataset.name} ({dataset.id}) is still used by dashboard "{dashboard.id}". Skipping.')
-                        print      (f'Dataset {dataset.name} ({dataset.id}) is still used by dashboard "{dashboard.id}". Skipping.')
+                        cid_print(f'Dataset {dataset.name} ({dataset.id}) is still used by dashboard "{dashboard.id}". Skipping.')
                         return False
                 else: #not used
 
@@ -1073,13 +1072,13 @@ class Cid():
 
         if dashboard.latest:
             cid_print("You are up to date!")
-            cid_print(f"  Version    {str(dashboard.cid_version)}")
+            cid_print(f"  Version    {dashboard.cid_version}")
         else:
             cid_print(f"An update is available:")
-            cid_print(f"  Version    {str(dashboard.cid_version): <9} ->  {str(dashboard.cid_version_latest): <9}")
+            cid_print(f"  Version    {dashboard.cid_version} ->  {dashboard.latest_available_cid_version}")
 
         try:
-            return dashboard.cid_version.compatible_versions(dashboard.cid_version_latest)
+            return dashboard.cid_version.compatible_versions(dashboard.latest_available_cid_version)
         except ValueError as exc:
             logger.info(exc)
         return None
@@ -1094,10 +1093,10 @@ class Cid():
         if isinstance(dashboard.deployedTemplate, CidQsTemplate):
             print(f'Deployed template: {dashboard.deployedTemplate.arn}')
         if isinstance(dashboard.sourceTemplate, CidQsTemplate):
-            print(f"Latest template:   {dashboard.sourceTemplate.arn}/version/{dashboard.latest_version}")
+            print(f"Latest template:   {dashboard.sourceTemplate.arn}/version/{dashboard.sourceTemplate.version}")
 
         try:
-            cid_print(f'\nUpdating {dashboard_id} from <BOLD>{dashboard.cid_version}<END> to <BOLD>{dashboard.cid_version_latest}<END>')
+            cid_print(f'\nUpdating {dashboard_id} from <BOLD>{dashboard.cid_version}<END> to <BOLD>{dashboard.latest_available_cid_version}<END>')
         except:
             cid_print(f'\nUpdating {dashboard_id}')
             logger.debug('Failed to define versions. Still continue.')

{cid_cmd-4.0.2 → cid_cmd-4.0.4}/cid/helpers/cur_proxy.py

@@ -491,7 +491,7 @@ class ProxyView():
             if not self.cur.column_exists(requirement):
                 missing_requirements.append(requirement)
 
-        if missing_requirements:
+        if missing_requirements and field_type.lower() in empty:
             logger.trace(f'field {field} cannot be present as prereqs are missing in source cur: {missing_requirements}')
             return empty[field_type.lower()]
 
@@ -508,10 +508,10 @@ class ProxyView():
                 keys_set = set(self.exposed_maps.get(field, set()))
                 keys_set.update(self.fields_to_expose_in_maps.get(map_field, set()))
                 for key in keys_set:
-                    if f'{map_field}_{key}' in self.cur.fields:
+                    if self.cur.column_exists(f'{map_field}_{key}'):
                         map_mapping[key] = f'{map_field}_{key}'
                     else:
-                        map_mapping[key] = 'CAST(NULL as VARCHAR)'
+                        map_mapping[key] = empty['string'] # all known maps have string vaules for now
                 if not map_mapping:
                     return 'cast(NULL AS MAP<VARCHAR, VARCHAR>)'
                 map_mapping = dict(sorted(map_mapping.items())) # ordered dict

{cid_cmd-4.0.2 → cid_cmd-4.0.4}/cid/helpers/quicksight/__init__.py

@@ -166,11 +166,11 @@ class QuickSight(CidBase):
         return self._datasources
 
     def ensure_subscription(self) -> None:
-        """Ensure that the QuickSight subscription is active"""
+        """Ensure that the Amazon QuickSight subscription is active"""
         if not self.edition(fresh=True):
-            raise CidCritical('QuickSight is not activated. Please run `cid-cmd initqs` command, or activate QuickSight Enterprise Edition from the console.')
+            raise CidCritical('Amazon QuickSight is not activated. Please run `cid-cmd initqs` command, or activate QuickSight Enterprise Edition from the console.')
         if self.edition() == 'STANDARD':
-            raise CidCritical(f'QuickSight Enterprise edition is required, you have {self.edition}.')
+            raise CidCritical(f'Amazon QuickSight Enterprise edition is required, you have {self.edition}.')
         logger.info(f'QuickSight subscription: {self._subscription_info}')
 
     def describe_account_subscription(self) -> dict:
@@ -809,7 +809,7 @@ class QuickSight(CidBase):
 
 
     def describe_dashboard(self, poll: bool=False, **kwargs) -> Union[None, Dashboard]:
-        """ Describes an AWS QuickSight dashboard
+        """ Describes an Amazon QuickSight dashboard
         Keyword arguments:
             DashboardId
             poll_interval
@@ -842,14 +842,14 @@ class QuickSight(CidBase):
         except self.client.exceptions.ResourceNotFoundException:
             return None
         except self.client.exceptions.UnsupportedUserEditionException as exc:
-            raise CidCritical('Error: AWS QuickSight Enterprise Edition is required') from exc
+            raise CidCritical('Error: Amazon QuickSight Enterprise Edition is required') from exc
         except Exception as exc:
             logger.error(f'Error in describe_dashboard: {exc}')
             raise
     
     # Create a method to retrieve the definition for a given dashboard
     def describe_dashboard_definition(self, dashboard_id: str, refresh: bool = False) -> CidQsDefinition:
-        """ Describes an AWS QuickSight dashboard definition """
+        """ Describes an Amazon QuickSight dashboard definition """
         if refresh or not self._definitions.get(f'{self.account_id}:{self.identityRegion}:{dashboard_id}'):
             try:
                 parameters = {
@@ -860,7 +860,7 @@ class QuickSight(CidBase):
                 self._definitions.update({f'{self.account_id}:{self.identityRegion}:{dashboard_id}': CidQsDefinition(result.get('Definition'))})
                 logger.debug(result)
             except self.client.exceptions.UnsupportedUserEditionException as exc:
-                raise CidCritical('AWS QuickSight Enterprise Edition is required') from exc
+                raise CidCritical('Amazon QuickSight Enterprise Edition is required') from exc
             except self.client.exceptions.ResourceNotFoundException as exc:
                 raise CidError(f'Error: Definition for dashboard with ID {dashboard_id} is not available in account {self.account_id} and region {self.identityRegion}') from exc
             except Exception as exc:
@@ -869,7 +869,7 @@ class QuickSight(CidBase):
         return self._definitions.get(f'{self.account_id}:{self.identityRegion}:{dashboard_id}')
 
     def delete_dashboard(self, dashboard_id):
-        """ Deletes an AWS QuickSight dashboard """
+        """ Deletes an Amazon QuickSight dashboard """
         params = {
             'AwsAccountId': self.account_id,
             'DashboardId': dashboard_id
@@ -880,7 +880,7 @@ class QuickSight(CidBase):
         return result
 
     def delete_data_source(self, datasource_id):
-        """ Deletes an AWS QuickSight dashboard """
+        """ Deletes an Amazon QuickSight dashboard """
         params = {
             'AwsAccountId': self.account_id,
             'DataSourceId': datasource_id
@@ -896,7 +896,7 @@ class QuickSight(CidBase):
         return result
 
     def delete_dataset(self, id: str) -> bool:
-        """ Deletes an AWS QuickSight dataset """
+        """ Deletes an Amazon QuickSight dataset """
 
         logger.info(f'Deleting dataset {id}')
         try:
@@ -949,7 +949,7 @@ class QuickSight(CidBase):
 
 
     def describe_dataset(self, id, timeout: int=1) -> Dataset:
-        """ Describes an AWS QuickSight dataset """
+        """ Describes an Amazon QuickSight dataset """
         if self._datasets and id in self._datasets:
             return self._datasets.get(id)
         self._datasets = self._datasets or {}
@@ -1048,7 +1048,7 @@ class QuickSight(CidBase):
         return mode, status
 
     def describe_data_source(self, id: str, update: bool=False) -> Datasource:
-        """ Describes an AWS QuickSight DataSource """
+        """ Describes an Amazon QuickSight DataSource """
         if not update and self.datasources and id in self.datasources:
             return self.datasources.get(id)
         try:
@@ -1073,7 +1073,7 @@ class QuickSight(CidBase):
 
 
     def describe_template(self, template_id: str, version_number: int=None, account_id: str=None, region: str='us-east-1') -> CidQsTemplate:
-        """ Describes an AWS QuickSight template """
+        """ Describes an Amazon QuickSight template """
         if not account_id:
             account_id=self.cidAccountId
         if not self._templates.get(f'{account_id}:{region}:{template_id}:{version_number}'):
@@ -1089,7 +1089,7 @@ class QuickSight(CidBase):
                 self._templates.update({f'{account_id}:{region}:{template_id}:{version_number}': CidQsTemplate(result.get('Template'))})
                 logger.debug(result)
             except self.client.exceptions.UnsupportedUserEditionException as exc:
-                raise CidCritical('AWS QuickSight Enterprise Edition is required') from exc
+                raise CidCritical('Amazon QuickSight Enterprise Edition is required') from exc
             except self.client.exceptions.ResourceNotFoundException as exc:
                 raise CidError(f'Error: Template {template_id} is not available in account {account_id} and region {region}') from exc
             except Exception as exc:
@@ -1098,7 +1098,7 @@ class QuickSight(CidBase):
         return self._templates.get(f'{account_id}:{region}:{template_id}:{version_number}')
 
     def describe_user(self, username: str) -> dict:
-        """ Describes an AWS QuickSight user """
+        """ Describes an Amazon QuickSight user """
         parameters = {
             'AwsAccountId': self.account_id,
             'UserName': username,
@@ -1122,7 +1122,7 @@ class QuickSight(CidBase):
             return None
 
     def describe_group(self, groupname: str) -> dict:
-        """ Describes an AWS QuickSight Group """
+        """ Describes an Amazon QuickSight Group """
         try:
             result = self.identityClient.describe_group(**{
                 'AwsAccountId': self.account_id,
@@ -1140,7 +1140,7 @@ class QuickSight(CidBase):
 
 
     def create_dataset(self, definition: dict) -> str:
-        """ Creates an AWS QuickSight dataset """
+        """ Creates an Amazon QuickSight dataset """
         poll_interval = 1
         max_timeout = 60
         columns_tpl = {
@@ -1167,7 +1167,8 @@ class QuickSight(CidBase):
             dataset_id = definition.get("DataSetId")
             logger.info(f'Dataset {definition.get("Name")} already exists with DataSetId={dataset_id}')
         except self.client.exceptions.LimitExceededException as exc:
-            raise CidCritical('Not enough AWS QuickSight SPICE capacity. Add SPICE here https://quicksight.aws.amazon.com/sn/admin#capacity .') from exc
+            logger.error(exc)
+            raise CidCritical(f'Not enough Amazon QuickSight SPICE capacity in {self.region}. Add SPICE here https://quicksight.aws.amazon.com/sn/admin#capacity .') from exc
 
         logger.info(f'Waiting for {definition.get("Name")} to be created')
         deadline = time.time() + max_timeout
@@ -1185,7 +1186,7 @@ class QuickSight(CidBase):
 
 
     def update_dataset(self, definition: dict) -> Dataset:
-        """ Update an AWS QuickSight dataset """
+        """ Update an Amazon QuickSight dataset """
         definition.update({'AwsAccountId': self.account_id})
         logger.info(f'Updating dataset {definition.get("Name")}')
 
@@ -1338,7 +1339,7 @@ class QuickSight(CidBase):
             pass
 
     def create_dashboard(self, definition: dict) -> Dashboard:
-        """ Creates an AWS QuickSight dashboard """
+        """ Creates an Amazon QuickSight dashboard """
 
         create_parameters = self._build_params_for_create_update_dash(definition)
 
@@ -1430,7 +1431,7 @@ class QuickSight(CidBase):
         return create_parameters
 
     def update_dashboard(self, dashboard: Dashboard, definition):
-        """ Updates an AWS QuickSight dashboard """
+        """ Updates an Amazon QuickSight dashboard """
         update_parameters = self._build_params_for_create_update_dash(definition)
         logger.info(f'Updating dashboard "{dashboard.name}"')
         logger.debug(f"Update parameters: {update_parameters}")
@@ -1457,7 +1458,7 @@ class QuickSight(CidBase):
 
 
     def update_dashboard_permissions(self, **update_parameters):
-        """ Updates an AWS QuickSight dashboard permissions """
+        """ Updates an Amazon QuickSight dashboard permissions """
         logger.debug(f"Updating Dashboard permissions: {update_parameters}")
         update_parameters.update({'AwsAccountId': self.account_id})
         update_status = self.client.update_dashboard_permissions(**update_parameters)
@@ -1466,7 +1467,7 @@ class QuickSight(CidBase):
 
 
     def update_data_set_permissions(self, **update_parameters):
-        """ Updates an AWS QuickSight dataset permissions """
+        """ Updates an Amazon QuickSight dataset permissions """
         logger.debug(f"Updating DataSet permissions: {update_parameters}")
         update_parameters.update({'AwsAccountId': self.account_id})
         update_status = self.client.update_data_set_permissions(**update_parameters)
@@ -1475,7 +1476,7 @@ class QuickSight(CidBase):
 
 
     def update_data_source_permissions(self, **update_parameters):
-        """ Updates an AWS QuickSight data source permissions """
+        """ Updates an Amazon QuickSight data source permissions """
         logger.debug(f"Updating DataSource permissions: {update_parameters}")
         update_parameters.update({'AwsAccountId': self.account_id})
         update_status = self.client.update_data_source_permissions(**update_parameters)
@@ -1484,7 +1485,7 @@ class QuickSight(CidBase):
 
 
     def update_template_permissions(self, **update_parameters):
-        """ Updates an AWS QuickSight template permissions """
+        """ Updates an Amazon QuickSight template permissions """
         logger.debug(f"Updating Template permissions: {update_parameters}")
         update_parameters.update({'AwsAccountId': self.account_id})
         update_status = self.client.update_template_permissions(**update_parameters)

{cid_cmd-4.0.2 → cid_cmd-4.0.4}/cid/helpers/quicksight/dashboard.py

@@ -64,26 +64,17 @@ class Dashboard(CidQsResource):
         return None
 
     @property
-    def deployed_version(self) -> int:
+    def deployed_cid_version(self) -> int:
         if isinstance(self.deployedTemplate, CidQsTemplate):
-            return self.deployedTemplate.version
+            return self.deployedTemplate.cid_version
         elif isinstance(self.deployedDefinition, CidQsDefinition):
             return self.deployedDefinition.cid_version
         else:
-            return -1
+            return None
 
     @property
     def latest(self) -> bool:
-        return self.latest_version == self.deployed_version
-
-    @property
-    def latest_version(self) -> int:
-        if isinstance(self.sourceTemplate, CidQsTemplate):
-            return self.sourceTemplate.version
-        elif isinstance(self.sourceDefinition, CidQsDefinition):
-            return self.sourceDefinition.cid_version
-        else:
-            return -1
+        return self.latest_available_cid_version == self.deployed_cid_version
 
     @property
     def health(self) -> bool:
@@ -98,6 +89,7 @@ class Dashboard(CidQsResource):
         else:
             return "UNKNOWN"
     
+
     @property
     def cid_version(self) -> int:
         if self.origin_type == "TEMPLATE":
@@ -108,7 +100,7 @@ class Dashboard(CidQsResource):
             return None
     
     @property
-    def cid_version_latest(self) -> int:
+    def latest_available_cid_version(self) -> int:
         if self.origin_type == "TEMPLATE":
             return self.sourceTemplate.cid_version
         elif self.origin_type == "DEFINITION":
@@ -136,11 +128,11 @@ class Dashboard(CidQsResource):
             # Source Template has changed
             elif self.deployedTemplate and self.sourceTemplate and self.deployedTemplate.arn and self.sourceTemplate.arn and not self.deployedTemplate.arn.startswith(self.sourceTemplate.arn):
                 self._status = 'legacy'
-            elif self.latest_version is None or self.deployed_version is None:
+            elif not self.latest_available_cid_version or not self.deployed_cid_version:
                 self._status = 'undetermined'
             else:
-                if self.latest_version > self.deployed_version:
-                    self._status = f'update available {self.deployed_version}->{self.latest_version}'
+                if self.latest_available_cid_version > self.deployed_cid_version:
+                    self._status = f'update available {self.deployed_cid_version}->{self.latest_available_cid_version}'
                 elif self.latest:
                     self._status = 'up to date'
         return self._status
@@ -157,22 +149,18 @@ class Dashboard(CidQsResource):
         if self.status_detail:
             cid_print(f"  <BOLD>Status detail:<END> {self.status_detail}")
 
-        cid_version = "N/A"
-        cid_version_latest =  "N/A"
-
-        cid_version = self.cid_version
-        if cid_version is None:
+        if not self.cid_version:
             logger.debug("The cid version of the deployed dashboard could not be retrieved")
 
-        cid_version_latest = self.cid_version_latest
-        if cid_version_latest is None:
+        if not self.latest_available_cid_version:
             logger.debug("The latest version of the dashboard could not be retrieved")
-
-        if self.latest:
-            cid_print(f"  <BOLD>Version:<END>   <GREEN>{cid_version}<END> (latest)")
+            cid_print(f"  <BOLD>Version:<END>   <YELLOW>{self.cid_version or 'N/A'}<END> (unable to find latest)")
         else:
-            logger.debug("An update is available")
-            cid_print(f"  <BOLD>Version:<END>   <YELLOW>{str(cid_version): <8} --> {str(cid_version_latest): <8}<END>")
+            if self.latest:
+                cid_print(f"  <BOLD>Version:<END>   <GREEN>{self.cid_version or 'N/A'}<END> (latest)")
+            else:
+                logger.debug("An update is available")
+                cid_print(f"  <BOLD>Version:<END>   <YELLOW>{self.cid_version or 'N/A'} --> {self.latest_available_cid_version or 'N/A'}<END>")
 
         cid_print('  <BOLD>Owners:<END>')
         try:

{cid_cmd-4.0.2 → cid_cmd-4.0.4/cid_cmd.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: cid-cmd
-Version: 4.0.2
+Version: 4.0.4
 Summary: Cloud Intelligence Dashboards deployment helper tool
 Home-page: https://github.com/aws-samples/aws-cudos-framework-deployment
 Author: AWS CUDOS Team

cid_cmd-4.0.2/cid/_version.py

@@ -1,2 +0,0 @@
-__version__ = '4.0.2'
-