cloudpub 1.5.0__py3-none-any.whl → 1.7.0__py3-none-any.whl

cloudpub/error.py

@@ -21,5 +21,9 @@ class NotFoundError(ValueError):
     """Represent a missing resource."""
 
 
+class ConflictError(RuntimeError):
+    """Report a submission conflict error."""
+
+
 class Timeout(Exception):
     """Represent a missing resource."""

cloudpub/models/ms_azure.py

@@ -711,11 +711,21 @@ class ProductProperty(AzureProductLinkedResource):
     `Schema definition for ProductProperty <https://schema.mp.microsoft.com/schema/property/2022-03-01-preview2>`_
     """  # noqa E501
 
+    schema: str = field(
+        validator=instance_of(str),
+        metadata={
+            "alias": MS_SCHEMA,
+            "const": "https://schema.mp.microsoft.com/schema/property/2022-03-01-preview2",
+        },
+    )
+    """
+    The `resource schema`_ for Graph API."""
+
     kind: str
     """Expected to be ``azureVM``"""
 
     terms_of_use: Optional[str] = field(
-        validator=optional(instance_of(str)), metadata={"alias": "termsOfUse"}
+        validator=optional(instance_of(str)), metadata={"alias": "termsOfUseUrl"}
     )
     """The product terms of use."""
 

cloudpub/ms_azure/service.py

@@ -2,22 +2,24 @@
 import json
 import logging
 import os
+from enum import IntEnum
 from typing import Any, Dict, Iterator, List, Optional, Tuple, Union, cast
 
 from deepdiff import DeepDiff
 from requests import HTTPError
-from tenacity import retry
-from tenacity.retry import retry_if_result
+from tenacity import RetryError, Retrying, retry
+from tenacity.retry import retry_if_exception_type, retry_if_result
 from tenacity.stop import stop_after_attempt, stop_after_delay
-from tenacity.wait import wait_chain, wait_fixed
+from tenacity.wait import wait_fixed
 
 from cloudpub.common import BaseService
-from cloudpub.error import InvalidStateError, NotFoundError
+from cloudpub.error import ConflictError, InvalidStateError, NotFoundError, Timeout
 from cloudpub.models.ms_azure import (
     RESOURCE_MAPING,
     AzureResource,
     ConfigureStatus,
     CustomerLeads,
+    DiskVersion,
     Listing,
     ListingAsset,
     ListingTrailer,
@@ -38,6 +40,7 @@ from cloudpub.models.ms_azure import (
 from cloudpub.ms_azure.session import PartnerPortalSession
 from cloudpub.ms_azure.utils import (
     AzurePublishingMetadata,
+    TechnicalConfigLookUpData,
     create_disk_version_from_scratch,
     is_azure_job_not_complete,
     is_sas_present,
@@ -69,6 +72,15 @@ AZURE_PRODUCT_RESOURCES = Union[
 ]
 
 
+class SasFoundStatus(IntEnum):
+    """Represent the submission target level of SAS found in a given product."""
+
+    missing = 0
+    draft = 1
+    preview = 2
+    live = 3
+
+
 class AzureService(BaseService[AzurePublishingMetadata]):
     """Service provider for Microsoft Azure using the Product Ingestion API."""
 
@@ -80,18 +92,31 @@ class AzureService(BaseService[AzurePublishingMetadata]):
     CONFIGURE_SCHEMA = "https://schema.mp.microsoft.com/schema/configure/{AZURE_API_VERSION}"
     DIFF_EXCLUDES = [r"root\['resources'\]\[[0-9]+\]\['url'\]"]
 
-    def __init__(self, credentials: Dict[str, str]):
+    def __init__(
+        self,
+        credentials: Dict[str, str],
+        retry_interval: Union[int, float] = 300,
+        retry_timeout: Union[int, float] = 3600 * 24 * 7,
+    ):
         """
         Create a new AuzureService object.
 
         Args:
             credentials (dict)
                 Dictionary with Azure credentials to authenticate on Product Ingestion API.
+            retry_interval (int, float)
+                The wait time interval in seconds for retrying jobs.
+                Defaults to 300
+            retry_timeout (int, float)
+                The max time in seconds to attempt retries.
+                Defaults to 7 days.
         """
         self.session = PartnerPortalSession.make_graph_api_session(
             auth_keys=credentials, schema_version=self.AZURE_SCHEMA_VERSION
         )
         self._products: List[ProductSummary] = []
+        self.retry_interval = retry_interval
+        self.retry_timeout = retry_timeout
 
     def _configure(self, data: Dict[str, Any]) -> ConfigureStatus:
         """
@@ -103,7 +128,10 @@ class AzureService(BaseService[AzurePublishingMetadata]):
         Returns:
             The job ID to track its status alongside the initial status.
         """
-        log.debug("Received the following data to create/modify: %s" % json.dumps(data, indent=2))
+        if log.isEnabledFor(logging.DEBUG):
+            log.debug(
+                "Received the following data to create/modify: %s", json.dumps(data, indent=2)
+            )
         resp = self.session.post(path="configure", json=data)
         self._raise_for_status(response=resp)
         rsp_data = resp.json()
@@ -121,7 +149,7 @@ class AzureService(BaseService[AzurePublishingMetadata]):
         Returns:
             The updated job status.
         """
-        log.debug(f"Query job details for \"{job_id}\"")
+        log.debug("Query job details for \"%s\"", job_id)
         resp = self.session.get(path=f"configure/{job_id}/status")
 
         # We don't want to fail if there's a server error thus we make a fake
@@ -129,9 +157,11 @@ class AzureService(BaseService[AzurePublishingMetadata]):
         if resp.status_code >= 500:
             log.warning(
                 (
-                    f"Got HTTP {resp.status_code} from server when querying job {job_id} status."
-                    " Considering the job_status as \"pending\"."
-                )
+                    "Got HTTP %s from server when querying job %s status."
+                    " Considering the job_status as \"pending\".",
+                ),
+                resp.status_code,
+                job_id,
             )
             return ConfigureStatus.from_json(
                 {
@@ -145,15 +175,27 @@ class AzureService(BaseService[AzurePublishingMetadata]):
         log.debug("Query Job details response: %s", parsed_resp)
         return parsed_resp
 
-    @retry(
-        retry=retry_if_result(predicate=is_azure_job_not_complete),
-        wait=wait_chain(
-            *[wait_fixed(wait=60)]  # First wait for 1 minute  # noqa: W503
-            + [wait_fixed(wait=10 * 60)]  # Then wait for 10 minutes  # noqa: W503
-            + [wait_fixed(wait=30 * 60)]  # Finally wait each 30 minutes  # noqa: W503
-        ),
-        stop=stop_after_delay(max_delay=60 * 60 * 24 * 7),  # Give up after retrying for 7 days
-    )
+    def query_job_status(self, job_id: str) -> ConfigureStatus:
+        """Query the job status for a given Job ID.
+
+        It will raise error if any invalid state is detected.
+
+        Args:
+            job_id (str): The job ID to query details from.
+
+        Returns:
+            ConfigureStatus: The ConfigureStatus from JobID
+        Raises:
+            InvalidStateError: If the job has failed.
+        """
+        job_details = self._query_job_details(job_id=job_id)
+        if job_details.job_result == "failed":
+            error_message = f"Job {job_id} failed: \n{job_details.errors}"
+            self._raise_error(InvalidStateError, error_message)
+        elif job_details.job_result == "succeeded":
+            log.debug("Job %s succeeded", job_id)
+        return job_details
+
     def _wait_for_job_completion(self, job_id: str) -> ConfigureStatus:
         """
         Wait until the specified job ID is complete.
@@ -172,29 +214,32 @@ class AzureService(BaseService[AzurePublishingMetadata]):
         Raises:
             InvalidStateError if the job failed
         """
-        job_details = self._query_job_details(job_id=job_id)
-        if job_details.job_result == "failed":
-            error_message = f"Job {job_id} failed: \n{job_details.errors}"
-            self._raise_error(InvalidStateError, error_message)
-        elif job_details.job_result == "succeeded":
-            log.debug(f"Job {job_id} succeeded")
-        return job_details
+        r = Retrying(
+            retry=retry_if_result(predicate=is_azure_job_not_complete),
+            wait=wait_fixed(self.retry_interval),
+            stop=stop_after_delay(max_delay=self.retry_timeout),
+        )
+        try:
+            return r(self.query_job_status, job_id)
+        except RetryError:
+            self._raise_error(Timeout, f"Time out waiting for job {job_id}")
 
-    def configure(self, resource: AzureResource) -> ConfigureStatus:
+    def configure(self, resources: List[AzureResource]) -> ConfigureStatus:
         """
         Create or update a resource and wait until it's done.
 
         Args:
-            resource (AzureResource):
-                The resource to create/modify in Azure.
+            resources (List[AzureResource]):
+                The list of resources to create/modify in Azure.
         Returns:
             dict: The result of job execution
         """
         data = {
             "$schema": self.CONFIGURE_SCHEMA.format(AZURE_API_VERSION=self.AZURE_API_VERSION),
-            "resources": [resource.to_json()],
+            "resources": [x.to_json() for x in resources],
         }
-        log.info("Data to configure: %s", json.dumps(data, indent=2))
+        if log.isEnabledFor(logging.DEBUG):
+            log.debug("Data to configure: %s", json.dumps(data, indent=2))
         res = self._configure(data=data)
         return self._wait_for_job_completion(job_id=res.job_id)
 
@@ -205,7 +250,7 @@ class AzureService(BaseService[AzurePublishingMetadata]):
         params: Dict[str, str] = {}
 
         while has_next:
-            log.debug("Requesting the products list.")
+            log.info("Requesting the products list.")
             resp = self.session.get(path="/product", params=params)
             data = self._assert_dict(resp)
 
@@ -230,11 +275,26 @@ class AzureService(BaseService[AzurePublishingMetadata]):
         Returns:
             list: A list with ProductSummary for all products in Azure.
         """
+        log.info("Listing the products on Azure server.")
         if not self._products:
             self._products = [p for p in self.products]
         return self._products
 
-    def get_product(self, product_id: str, first_target: str = "preview") -> Product:
+    def get_productid(self, product_name: str) -> str:
+        """Retrieve the desired product ID for the requested product name.
+
+        Args:
+            product_name (str): the product's name to retrieve its product ID.
+        Returns:
+            The requested product ID when found.
+        Raises NotFoundError when the product was not found.
+        """
+        for product in self.list_products():
+            if product.identity.name == product_name:
+                return product.id
+        raise NotFoundError(f"No such product with name {product_name}")
+
+    def get_product(self, product_id: str, target: str) -> Product:
         """
         Return the requested Product by its ID.
 
@@ -246,37 +306,31 @@ class AzureService(BaseService[AzurePublishingMetadata]):
         Args:
             product_durable_id (str)
                 The product UUID
-            first_target (str, optional)
-                The first target to lookup into. Defaults to ``preview``.
+            target (str)
+                The submission target to retrieve the product from.
         Returns:
             Product: the requested product
         """
-        targets = [first_target]
-        for tgt in ["preview", "draft", "live"]:
-            if tgt not in targets:
-                targets.append(tgt)
-
-        for t in targets:
-            log.debug("Requesting the product ID \"%s\" with state \"%s\".", product_id, t)
-            try:
-                resp = self.session.get(
-                    path=f"/resource-tree/product/{product_id}", params={"targetType": t}
-                )
-                data = self._assert_dict(resp)
-                return Product.from_json(data)
-            except (ValueError, HTTPError):
-                log.debug("Couldn't find the product \"%s\" with state \"%s\"", product_id, t)
+        log.info("Requesting the product ID \"%s\" with state \"%s\".", product_id, target)
+        try:
+            resp = self.session.get(
+                path=f"/resource-tree/product/{product_id}", params={"targetType": target}
+            )
+            data = self._assert_dict(resp)
+            return Product.from_json(data)
+        except (ValueError, HTTPError):
+            log.debug("Couldn't find the product \"%s\" with state \"%s\"", product_id, target)
         self._raise_error(NotFoundError, f"No such product with id \"{product_id}\"")
 
-    def get_product_by_name(self, product_name: str, first_target: str = "preview") -> Product:
+    def get_product_by_name(self, product_name: str, target: str) -> Product:
         """
         Return the requested Product by its name from Legacy CPP API.
 
         Args:
             product_name (str)
                 The product name according to Legacy CPP API.
-            first_target (str, optional)
-                The first target to lookup into. Defaults to ``preview``.
+            target (str, optional)
+                The submission target to retrieve the product from.
         Returns:
             Product: the requested product when found
         Raises:
@@ -285,7 +339,7 @@ class AzureService(BaseService[AzurePublishingMetadata]):
         for product in self.products:
             if product.identity.name == product_name:
                 log.debug("Product alias \"%s\" has the ID \"%s\"", product_name, product.id)
-                return self.get_product(product.id, first_target=first_target)
+                return self.get_product(product.id, target=target)
         self._raise_error(NotFoundError, f"No such product with name \"{product_name}\"")
 
     def get_submissions(self, product_id: str) -> List[ProductSubmission]:
@@ -314,6 +368,7 @@ class AzureService(BaseService[AzurePublishingMetadata]):
         Returns:
             Optional[ProductSubmission]: The requested submission when found.
         """
+        log.info("Looking up for submission in state \"%s\" for \"%s\"", state, product_id)
         submissions = self.get_submissions(product_id)
         for sub in submissions:
             if sub.target.targetType == state:
@@ -369,47 +424,64 @@ class AzureService(BaseService[AzurePublishingMetadata]):
         self._raise_error(NotFoundError, f"No such plan with name \"{plan_name}\"")
 
     def get_product_plan_by_name(
-        self, product_name: str, plan_name: str
+        self,
+        product_name: str,
+        plan_name: str,
+        target: str,
     ) -> Tuple[Product, PlanSummary]:
         """Return a tuple with the desired Product and Plan after iterating over all targets.
 
         Args:
             product_name (str): The name of the product to search for
             plan_name (str): The name of the plan to search for
-
+            target (str)
+                The submission target to retrieve the product/plan from.
         Returns:
             Tuple[Product, PlanSummary]: The Product and PlanSummary when fonud
         Raises:
-            NotFoundError whenever all targets are exhausted and no information was found
-        """
-        targets = ["preview", "draft", "live"]
-
-        for tgt in targets:
-            try:
-                product = self.get_product_by_name(product_name, first_target=tgt)
-                plan = self.get_plan_by_name(product, plan_name)
-                return product, plan
-            except NotFoundError:
-                continue
-        self._raise_error(
-            NotFoundError, f"No such plan with name \"{plan_name} for {product_name}\""
-        )
+            NotFoundError whenever no information was found in the respective submission target.
+        """
+        try:
+            product = self.get_product_by_name(product_name, target=target)
+            plan = self.get_plan_by_name(product, plan_name)
+            return product, plan
+        except NotFoundError:
+            self._raise_error(
+                NotFoundError, f"No such plan with name \"{plan_name} for {product_name}\""
+            )
 
-    def diff_offer(self, product: Product, first_target="preview") -> DeepDiff:
+    def diff_offer(self, product: Product, target: str) -> DeepDiff:
         """Compute the difference between the provided product and the one in the remote.
 
         Args:
             product (Product)
                 The local product to diff with the remote one.
-            first_target (str)
-                The first target to lookup into. Defaults to ``preview``.
+            target (str)
+                The submission target to retrieve the product from.
         Returns:
             DeepDiff: The diff data.
         """
-        remote = self.get_product(product.id, first_target=first_target)
+        remote = self.get_product(product.id, target=target)
         return DeepDiff(remote.to_json(), product.to_json(), exclude_regex_paths=self.DIFF_EXCLUDES)
 
-    def submit_to_status(self, product_id: str, status: str) -> ConfigureStatus:
+    def diff_two_offers(self, last_offer: Product, prev_offer: Product) -> DeepDiff:
+        """Compute the difference between two provided products.
+
+        Args:
+            last_offer (Product)
+                The lastest offer state to diff
+            prev_offer (Product)
+                The previous offer state to diff
+        Returns:
+            DeepDiff: The diff data.
+        """
+        return DeepDiff(
+            prev_offer.to_json(), last_offer.to_json(), exclude_regex_paths=self.DIFF_EXCLUDES
+        )
+
+    def submit_to_status(
+        self, product_id: str, status: str, resources: Optional[List[AzureResource]] = None
+    ) -> ConfigureStatus:
         """
         Send a submission request to Microsoft with a new Product status.
 
@@ -418,9 +490,12 @@ class AzureService(BaseService[AzurePublishingMetadata]):
                 The product ID to submit the new status.
             status (str)
                 The new status: 'preview' or 'live'
+            resources (optional(list(AzureRerouce)))
+                Additional resources for modular push.
         Returns:
             The response from configure request.
         """
+        log.info("Submitting the status of \"%s\" to \"%s\"", product_id, status)
         # We need to get the previous state of the given one to request the submission
         prev_state_mapping = {
             "preview": "draft",
@@ -437,34 +512,55 @@ class AzureService(BaseService[AzurePublishingMetadata]):
 
         # Update the status with the expected one
         submission.target.targetType = status
+        cfg_res: List[AzureResource] = [submission]
+        if resources:
+            log.info("Performing a modular push to \"%s\" for \"%s\"", status, product_id)
+            cfg_res = resources + cfg_res
         log.debug("Set the status \"%s\" to submission.", status)
+        return self.configure(resources=cfg_res)
 
-        return self.configure(resource=submission)
-
-    @retry(
-        wait=wait_fixed(300),
-        stop=stop_after_delay(max_delay=60 * 60 * 24 * 7),  # Give up after retrying for 7 days,
-        reraise=True,
-    )
     def ensure_can_publish(self, product_id: str) -> None:
         """
         Ensure the offer is not already being published.
 
-        It will wait for up to 7 days retrying to make sure it's possible to publish before
-        giving up and raising.
+        It will raise ConflictError if a publish is already in progress in any submission target.
 
         Args:
             product_id (str)
                 The product ID to check the offer's publishing status
         Raises:
-            RuntimeError: whenever a publishing is already in progress.
+            ConflictError: whenever a publishing is already in progress for any submission target.
         """
-        submission_targets = ["preview", "live"]
+        log.info("Ensuring no other publishing jobs are in progress for \"%s\"", product_id)
 
-        for target in submission_targets:
-            sub = self.get_submission_state(product_id, state=target)
-            if sub and sub.status and sub.status == "running":
-                raise RuntimeError(f"The offer {product_id} is already being published to {target}")
+        for sub in self.get_submissions(product_id):
+            if sub and sub.status and sub.status != "completed":
+                msg = (
+                    f"The offer {product_id} is already being published to "
+                    f"{sub.target.targetType}: {sub.status}/{sub.result}"
+                )
+                log.error(msg)
+                raise ConflictError(msg)
+
+    def wait_active_publishing(self, product_id: str) -> None:
+        """
+        Wait when there's an existing submission in progress.
+
+        Args:
+            product_id (str)
+                The product ID of to verify the submissions state.
+        """
+        r = Retrying(
+            retry=retry_if_exception_type(ConflictError),
+            wait=wait_fixed(self.retry_interval),
+            stop=stop_after_delay(max_delay=self.retry_timeout),
+        )
+        log.info("Checking for active changes on %s.", product_id)
+
+        try:
+            r(self.ensure_can_publish, product_id)
+        except RetryError:
+            self._raise_error(Timeout, f"Timed out waiting for {product_id} to be unlocked")
 
     def get_plan_tech_config(self, product: Product, plan: PlanSummary) -> VMIPlanTechConfig:
         """
@@ -491,6 +587,86 @@ class AzureService(BaseService[AzurePublishingMetadata]):
         )
         return tconfigs[0]  # It should have only one VMIPlanTechConfig per plan.
 
+    def get_modular_resources_to_publish(
+        self, product: Product, tech_config: VMIPlanTechConfig
+    ) -> List[AzureResource]:
+        """Return the required resources for a modular publishing.
+
+        According to Microsoft docs:
+        "For a modular publish, all resources are required except for the product level details
+        (for example, listing, availability, packages, reseller) as applicable to your
+        product type."
+
+        Args:
+            product (Product): The original product to filter the resources from
+            tech_config (VMIPlanTechConfig): The updated tech config to publish
+
+        Returns:
+            List[AzureResource]: _description_
+        """
+        # The following resources shouldn't be required:
+        # -> customer-leads
+        # -> test-drive
+        # -> *listing*
+        # -> reseller
+        # -> price-and-availability-*
+        # NOTE: The "submission" resource will be already added by the "submit_to_status" method
+        #
+        # With that it needs only the related "product", "property" and "plan" resources alongisde
+        # the updated tech_config
+        product_id = tech_config.product_id
+        plan_id = tech_config.plan_id
+        prod_res = cast(
+            List[ProductSummary],
+            [
+                prd
+                for prd in self.filter_product_resources(product=product, resource="product")
+                if prd.id == product_id
+            ],
+        )[0]
+        property = cast(
+            List[ProductProperty],
+            [
+                prop
+                for prop in self.filter_product_resources(product=product, resource="property")
+                if prop.product_id == product_id  # type: ignore [union-attr]
+            ],
+        )[0]
+        plan_res = cast(
+            List[PlanSummary],
+            [
+                pln
+                for pln in self.filter_product_resources(product=product, resource="plan")
+                if pln.id == plan_id
+            ],
+        )[0]
+        return [prod_res, property, plan_res, tech_config]
+
+    def compute_targets(self, product_id: str) -> List[str]:
+        """List all the possible publishing targets order to seek data from Azure.
+
+        It also returns the ordered list of targets with the following precedence:
+        ``live`` -> ``preview`` -> ``draft``
+
+        Args:
+            product_id (str)
+                The product_id to retrieve all existing submission targets.
+
+        Returns:
+            List[Str]: The ordered list with targets to lookup.
+        """
+        all_targets = ["live", "preview", "draft"]
+        computed_targets = []
+
+        # We cannot simply return all targets above because the existing product might
+        # lack one of them. So now we need to filter out unexisting targets.
+        product_submissions = self.get_submissions(product_id)
+        product_targets = [s.target.targetType for s in product_submissions]
+        for t in all_targets:
+            if t in product_targets:
+                computed_targets.append(t)
+        return computed_targets
+
     def _is_submission_in_preview(self, current: ProductSubmission) -> bool:
         """Return True if the latest submission state is "preview", False otherwise.
 
@@ -518,42 +694,33 @@ class AzureService(BaseService[AzurePublishingMetadata]):
         stop=stop_after_attempt(3),
         reraise=True,
     )
-    def _publish_preview(self, product: Product, product_name: str) -> None:
+    def _publish_preview(
+        self, product: Product, product_name: str, resources: Optional[List[AzureResource]] = None
+    ) -> None:
         """
-        Submit the product to 'preview'  if it's not already in this state.
+        Submit the product to 'preview' after going through Azure Marketplace Validatoin.
 
         This is required to execute the validation pipeline on Azure side.
 
         Args:
             product
-                The product with changes to publish live
+                The product with changes to publish to preview
             product_name
                 The product name to display in logs.
+            resources:
+                Additional resources for modular push.
         """
-        # We just want to set the ProductSubmission to 'preview' if it's not in this status.
-        #
-        # The `preview` stage runs the Azure pipeline which takes up to 4 days.
-        # Meanwhile the `submit_for_status` will be blocked querying the `job_status`until
-        # all the Azure verification pipeline finishes.
-        submission: ProductSubmission = cast(
-            List[ProductSubmission],
-            self.filter_product_resources(product=product, resource="submission"),
-        )[0]
-        if not self._is_submission_in_preview(submission):
-            log.info(
-                "Submitting the product \"%s (%s)\" to \"preview\"." % (product_name, product.id)
+        res = self.submit_to_status(product_id=product.id, status='preview', resources=resources)
+
+        if res.job_result != 'succeeded' or not self.get_submission_state(
+            product.id, state="preview"
+        ):
+            errors = "\n".join(res.errors)
+            failure_msg = (
+                f"Failed to submit the product {product_name} ({product.id}) to preview. "
+                f"Status: {res.job_result} Errors: {errors}"
             )
-            res = self.submit_to_status(product_id=product.id, status='preview')
-
-            if res.job_result != 'succeeded' or not self.get_submission_state(
-                product.id, state="preview"
-            ):
-                errors = "\n".join(res.errors)
-                failure_msg = (
-                    f"Failed to submit the product {product.id} to preview. "
-                    f"Status: {res.job_result} Errors: {errors}"
-                )
-                raise RuntimeError(failure_msg)
+            raise RuntimeError(failure_msg)
 
     @retry(
         wait=wait_fixed(wait=60),
@@ -572,17 +739,133 @@ class AzureService(BaseService[AzurePublishingMetadata]):
         """
         # Note: the offer can only go `live` after successfully being changed to `preview`
         # which takes up to 4 days.
-        log.info("Submitting the product \"%s (%s)\" to \"live\"." % (product_name, product.id))
         res = self.submit_to_status(product_id=product.id, status='live')
 
         if res.job_result != 'succeeded' or not self.get_submission_state(product.id, state="live"):
             errors = "\n".join(res.errors)
             failure_msg = (
-                f"Failed to submit the product {product.id} to live. "
+                f"Failed to submit the product {product_name} ({product.id}) to live. "
                 f"Status: {res.job_result} Errors: {errors}"
             )
             raise RuntimeError(failure_msg)
 
+    def _overwrite_disk_version(
+        self,
+        metadata: AzurePublishingMetadata,
+        product_name: str,
+        plan_name: str,
+        source: VMImageSource,
+        target: str,
+    ) -> TechnicalConfigLookUpData:
+        """Private method to overwrite the technical config with a new DiskVersion.
+
+        Args:
+            metadata (AzurePublishingMetadata): the incoming publishing metadata
+            product_name (str): the product (offer) name
+            plan_name (str): the plan name
+            source (VMImageSource): the source VMI to create and overwrite the new DiskVersion
+            target (str): the submission target.
+
+        Returns:
+            TechnicalConfigLookUpData: The overwritten tech_config for the product/plan
+        """
+        product, plan = self.get_product_plan_by_name(product_name, plan_name, target)
+        log.warning(
+            "Overwriting the plan \"%s\" on \"%s\" with the given image: \"%s\".",
+            plan_name,
+            target,
+            metadata.image_path,
+        )
+        tech_config = self.get_plan_tech_config(product, plan)
+        disk_version = create_disk_version_from_scratch(metadata, source)
+        tech_config.disk_versions = [disk_version]
+        return {
+            "metadata": metadata,
+            "tech_config": tech_config,
+            "sas_found": False,
+            "product": product,
+            "plan": plan,
+            "target": target,
+        }
+
+    def _look_up_sas_on_technical_config(
+        self, metadata: AzurePublishingMetadata, product_name: str, plan_name: str, target: str
+    ) -> TechnicalConfigLookUpData:
+        """Private method to lookup for the TechnicalConfig of a given target.
+
+        Args:
+            metadata (AzurePublishingMetadata): the incoming publishing metadata.
+            product_name (str): the product (offer) name
+            plan_name (str): the plan name
+            target (str): the submission target to look up the TechnicalConfig object
+
+        Returns:
+            TechnicalConfigLookUpData: The data retrieved for the given submission target.
+        """
+        product, plan = self.get_product_plan_by_name(product_name, plan_name, target)
+        log.info(
+            "Retrieving the technical config for \"%s\" on \"%s\".",
+            metadata.destination,
+            target,
+        )
+        tech_config = self.get_plan_tech_config(product, plan)
+        sas_found = False
+
+        if is_sas_present(tech_config, metadata.image_path, metadata.check_base_sas_only):
+            log.info(
+                "The destination \"%s\" on \"%s\" already contains the SAS URI: \"%s\".",
+                metadata.destination,
+                target,
+                metadata.image_path,
+            )
+            sas_found = True
+        return {
+            "metadata": metadata,
+            "tech_config": tech_config,
+            "sas_found": sas_found,
+            "product": product,
+            "plan": plan,
+            "target": target,
+        }
+
+    def _create_or_update_disk_version(
+        self,
+        tech_config_lookup: TechnicalConfigLookUpData,
+        source: VMImageSource,
+        disk_version: Optional[DiskVersion],
+    ) -> DiskVersion:
+        """Private method to create/update the DiskVersion of a given TechnicalConfig object.
+
+        Args:
+            tech_config_lookup (TechnicalConfigLookUpData): the incoming data to process
+            source (VMImageSource): the new VMI source to attach
+            disk_version (Optional[DiskVersion]): the disk version if it exists (for updates).
+
+        Returns:
+            DiskVersion: The updated DiskVersion
+        """
+        metadata = tech_config_lookup["metadata"]
+        target = tech_config_lookup["target"]
+        tech_config = tech_config_lookup["tech_config"]
+
+        # Check the images of the selected DiskVersion if it exists
+        if disk_version:
+            log.info(
+                "DiskVersion \"%s\" exists in \"%s\" on \"%s\" for the image \"%s\".",
+                disk_version.version_number,
+                metadata.destination,
+                target,
+                metadata.image_path,
+            )
+            # Update the disk version with the new SAS
+            disk_version = set_new_sas_disk_version(disk_version, metadata, source)
+            return disk_version
+        # The disk version doesn't exist, we need to create one from scratch
+        log.info("The DiskVersion doesn't exist, creating one from scratch.")
+        disk_version = create_disk_version_from_scratch(metadata, source)
+        tech_config.disk_versions.append(disk_version)
+        return disk_version
+
     def publish(self, metadata: AzurePublishingMetadata) -> None:
         """
         Associate a VM image with a given product listing (destination) and publish it if required.
@@ -596,71 +879,103 @@ class AzureService(BaseService[AzurePublishingMetadata]):
         #   "product-name/plan-name"
         product_name = metadata.destination.split("/")[0]
         plan_name = metadata.destination.split("/")[-1]
-        product, plan = self.get_product_plan_by_name(product_name, plan_name)
+        product_id = self.get_productid(product_name)
+        sas_in_target = SasFoundStatus.missing
+        self.wait_active_publishing(product_id=product_id)
         log.info(
-            "Preparing to associate the image with the plan \"%s\" from product \"%s\""
-            % (plan_name, product_name)
+            "Preparing to associate the image \"%s\" with the plan \"%s\" from product \"%s\"",
+            metadata.image_path,
+            plan_name,
+            product_name,
         )
 
-        # 2. Retrieve the VM Technical configuration for the given plan
-        log.debug("Retrieving the technical config for \"%s\"." % metadata.destination)
-        tech_config = self.get_plan_tech_config(product, plan)
-
-        # 3. Prepare the Disk Version
-        log.debug("Creating the VMImageResource with SAS: \"%s\"" % metadata.image_path)
+        # 2. Prepare the Disk Version
+        log.info("Creating the VMImageResource with SAS for image: \"%s\"", metadata.image_path)
         sas = OSDiskURI(uri=metadata.image_path)
         source = VMImageSource(source_type="sasUri", os_disk=sas.to_json(), data_disks=[])
 
+        # 3. Set the new Disk Version into the product/plan if required
+        #
         # Note: If `overwrite` is True it means we can set this VM image as the only one in the
         # plan's technical config and discard all other VM images which may've been present.
-        disk_version = None  # just to make mypy happy
         if metadata.overwrite is True:
-            log.warning("Overwriting the plan %s with the given image.", plan_name)
-            disk_version = create_disk_version_from_scratch(metadata, source)
-            tech_config.disk_versions = [disk_version]
-
-        # We just want to append a new image if the SAS is not already present.
-        elif not is_sas_present(tech_config, metadata.image_path, metadata.check_base_sas_only):
-            # Here we can have the metadata.disk_version set or empty.
-            # When set we want to get the existing disk_version which matches its value.
-            log.debug("Scanning the disk versions from %s" % metadata.destination)
-            disk_version = seek_disk_version(tech_config, metadata.disk_version)
-
-            # Check the images of the selected DiskVersion if it exists
-            if disk_version:
-                log.debug(
-                    "DiskVersion \"%s\" exists in \"%s\"."
-                    % (disk_version.version_number, metadata.destination)
-                )
-                disk_version = set_new_sas_disk_version(disk_version, metadata, source)
-
-            else:  # The disk version doesn't exist, we need to create one from scratch
-                log.debug("The DiskVersion doesn't exist, creating one from scratch.")
-                disk_version = create_disk_version_from_scratch(metadata, source)
-                tech_config.disk_versions.append(disk_version)
+            target = "draft"  # It's expected to exist for whenever product.
+            res = self._overwrite_disk_version(metadata, product_name, plan_name, source, target)
+            tech_config = res["tech_config"]
         else:
-            log.info(
-                "The destination \"%s\" already contains the SAS URI: \"%s\"."
-                % (metadata.destination, metadata.image_path)
-            )
+            # Otherwise we need to check whether SAS isn't already present
+            # in any of the targets "preview", "live" or "draft" and if not attach and publish it.
+            for target in self.compute_targets(product_id):
+                res = self._look_up_sas_on_technical_config(
+                    metadata, product_name, plan_name, target
+                )
+                tech_config = res["tech_config"]
+                # We don't want to seek for SAS anymore as it was already found
+                if res["sas_found"]:
+                    sas_in_target = SasFoundStatus[target]
+                    break
+            else:
+                # At this point there's no SAS URI in any target so we can safely add it
+
+                # Here we can have the metadata.disk_version set or empty.
+                # When set we want to get the existing disk_version which matches its value.
+                log.info(
+                    "Scanning the disk versions from \"%s\" on \"%s\" for the image \"%s\"",
+                    metadata.destination,
+                    target,
+                    metadata.image_path,
+                )
+                dv = seek_disk_version(tech_config, metadata.disk_version)
+                self._create_or_update_disk_version(res, source, dv)
 
         # 4. With the updated disk_version we should adjust the SKUs and submit the changes
-        if disk_version:
-            log.debug("Updating SKUs for \"%s\"." % metadata.destination)
+        if sas_in_target == SasFoundStatus.missing:
+            log.info("Updating SKUs for \"%s\" on \"%s\".", metadata.destination, target)
             tech_config.skus = update_skus(
                 disk_versions=tech_config.disk_versions,
                 generation=metadata.generation,
                 plan_name=plan_name,
                 old_skus=tech_config.skus,
             )
-            log.debug("Updating the technical configuration for \"%s\"." % metadata.destination)
-            self.configure(resource=tech_config)
+            log.info(
+                "Updating the technical configuration for \"%s\" on \"%s\".",
+                metadata.destination,
+                target,
+            )
+            self.configure(resources=[tech_config])
 
         # 5. Proceed to publishing if it was requested.
         # Note: The publishing will only occur if it made changes in disk_version.
-        if disk_version and not metadata.keepdraft:
-            logdiff(self.diff_offer(product))
-            self.ensure_can_publish(product.id)
+        if not metadata.keepdraft:
+            product = res["product"]
+            # Get the submission state
+            submission: ProductSubmission = cast(
+                List[ProductSubmission],
+                self.filter_product_resources(product=product, resource="submission"),
+            )[0]
+
+            # We should only publish if there are new changes OR
+            # the existing offer was already in preview
+            if sas_in_target <= SasFoundStatus.draft or self._is_submission_in_preview(submission):
+                log.info(
+                    "Publishing the new changes for \"%s\" on plan \"%s\"", product_name, plan_name
+                )
+                logdiff(self.diff_offer(product, target))
+                self.ensure_can_publish(product.id)
+
+                # According to the documentation we only need to pass the
+                # required resources for modular publish on "preview"
+                # https://learn.microsoft.com/en-us/partner-center/marketplace-offers/product-ingestion-api#method-2-publish-specific-draft-resources-also-known-as-modular-publish  # noqa: E501
+                modular_resources = None
+                if metadata.modular_push:
+                    modular_resources = self.get_modular_resources_to_publish(product, tech_config)
+                if sas_in_target < SasFoundStatus.preview:
+                    self._publish_preview(product, product_name, resources=modular_resources)
+                if sas_in_target < SasFoundStatus.live:
+                    self._publish_live(product, product_name)
 
-            self._publish_preview(product, product_name)
-            self._publish_live(product, product_name)
+        log.info(
+            "Finished publishing the image \"%s\" to \"%s\"",
+            metadata.image_path,
+            metadata.destination,
+        )

cloudpub/ms_azure/session.py

@@ -24,7 +24,7 @@ class AccessToken:
         """
         self.expires_on = datetime.fromtimestamp(int(json["expires_on"]))
         self.access_token = json["access_token"]
-        log.debug(f"Obtained token with expiration date on {self.expires_on}")
+        log.debug("Obtained token with expiration date on %s", self.expires_on)
 
     def is_expired(self) -> bool:
         """Return True if the token is expired and False otherwise."""
@@ -108,7 +108,7 @@ class PartnerPortalSession:
             "AZURE_API_SECRET",
         ]
         for key in mandatory_keys:
-            log.debug(f"Validating mandatory key \"{key}\"")
+            log.debug("Validating mandatory key \"%s\"", key)
             if key not in auth_keys.keys() or not auth_keys.get(key):
                 err_msg = f'The key/value for "{key}" must be set.'
                 log.error(err_msg)
@@ -117,7 +117,7 @@ class PartnerPortalSession:
 
     def _login(self) -> AccessToken:
         """Retrieve the authentication token from Microsoft."""
-        log.info("Retrieving the bearer token from Microsoft")
+        log.debug("Retrieving the bearer token from Microsoft")
         url = self.LOGIN_URL_TMPL.format(**self.auth_keys)
 
         headers = {
@@ -156,7 +156,7 @@ class PartnerPortalSession:
                 params = {}
             params.update(self._mandatory_params)
 
-        log.info(f"Sending a {method} request to {path}")
+        log.debug("Sending a %s request to %s", method, path)
         formatted_url = self._prefix_url.format(**self.auth_keys)
         url = join_url(formatted_url, path)
         return self.session.request(method, url=url, params=params, headers=headers, **kwargs)

cloudpub/ms_azure/utils.py

@@ -1,7 +1,7 @@
 # SPDX-License-Identifier: GPL-3.0-or-later
 import logging
 from operator import attrgetter
-from typing import Any, Dict, List, Optional, Tuple
+from typing import Any, Dict, List, Optional, TypedDict
 
 from deepdiff import DeepDiff
 
@@ -9,6 +9,8 @@ from cloudpub.common import PublishingMetadata  # Cannot circular import AzurePu
 from cloudpub.models.ms_azure import (
     ConfigureStatus,
     DiskVersion,
+    PlanSummary,
+    Product,
     VMImageDefinition,
     VMImageSource,
     VMIPlanTechConfig,
@@ -54,6 +56,11 @@ class AzurePublishingMetadata(PublishingMetadata):
             check_base_sas_only (bool, optional):
                 Indicates to skip checking SAS parameters when set as ``True``.
                 Default to ``False``
+            modular_push (bool, optional):
+                Indicate whether to perform a modular push or not.
+                The modular push causes the effect to only publish
+                the changed plan instead of the whole offer to preview/live.
+                Default to ``False``.
             **kwargs
                 Arguments for :class:`~cloudpub.common.PublishingMetadata`.
         """
@@ -64,6 +71,7 @@ class AzurePublishingMetadata(PublishingMetadata):
         self.recommended_sizes = recommended_sizes or []
         self.legacy_sku_id = kwargs.pop("legacy_sku_id", None)
         self.check_base_sas_only = kwargs.pop("check_base_sas_only", False)
+        self.modular_push = kwargs.pop("modular_push", None) or False
 
         if generation == "V1" or not support_legacy:
             self.legacy_sku_id = None
@@ -107,6 +115,17 @@ class AzurePublishingMetadata(PublishingMetadata):
             raise ValueError(f"Invalid SAS URI \"{self.image_path}\". Expected: http/https URL.")
 
 
+class TechnicalConfigLookUpData(TypedDict):
+    """A typed dict to be used for private methods data exchange."""
+
+    metadata: AzurePublishingMetadata
+    tech_config: VMIPlanTechConfig
+    sas_found: bool
+    product: Product
+    plan: PlanSummary
+    target: str
+
+
 def get_image_type_mapping(architecture: str, generation: str) -> str:
     """Return the image type required by VMImageDefinition."""
     gen_map = {
@@ -150,22 +169,23 @@ def is_sas_eq(sas1: str, sas2: str, base_only=False) -> bool:
 
     # Base URL differs
     if base_sas1 != base_sas2:
-        log.debug("Got different base SAS: %s - Expected: %s" % (base_sas1, base_sas2))
+        log.debug("Got different base SAS: %s - Expected: %s", base_sas1, base_sas2)
         return False
 
     if not base_only:
         # Parameters lengh differs
         if len(params_sas1) != len(params_sas2):
             log.debug(
-                "Got different lengh of SAS parameters: len(%s) - Expected len(%s)"
-                % (params_sas1, params_sas2)
+                "Got different lengh of SAS parameters: len(%s) - Expected len(%s)",
+                params_sas1,
+                params_sas2,
             )
             return False
 
         # Parameters values differs
         for k, v in params_sas1.items():
             if v != params_sas2.get(k, None):
-                log.debug("The SAS parameter %s doesn't match %s." % (v, params_sas2.get(k, None)))
+                log.debug("The SAS parameter %s doesn't match %s.", v, params_sas2.get(k, None))
                 return False
 
     # Equivalent SAS
@@ -203,8 +223,8 @@ def is_azure_job_not_complete(job_details: ConfigureStatus) -> bool:
     Returns:
         bool: False if job completed, True otherwise
     """
-    log.debug(f"Checking if the job \"{job_details.job_id}\" is still running")
-    log.debug(f"job {job_details.job_id} is in {job_details.job_status} state")
+    log.debug("Checking if the job \"%s\" is still running", job_details.job_id)
+    log.debug("job %s is in %s state", job_details.job_id, job_details.job_status)
     if job_details.job_status != "completed":
         return True
     return False
@@ -221,56 +241,6 @@ def is_legacy_gen_supported(metadata: AzurePublishingMetadata) -> bool:
     return metadata.architecture == "x64" and metadata.support_legacy
 
 
-def prepare_vm_images(
-    metadata: AzurePublishingMetadata,
-    gen1: Optional[VMImageDefinition],
-    gen2: Optional[VMImageDefinition],
-    source: VMImageSource,
-) -> List[VMImageDefinition]:
-    """
-    Update the vm_images list with the proper SAS based in existing generation(s).
-
-    Args:
-        metadata (AzurePublishingMetadata)
-            The VHD publishing metadata.
-        gen1 (VMImageDefinition, optional)
-            The VMImageDefinition for Gen1 VHD.
-            If not set the argument `gen2` must be set.
-        gen2 (VMImageDefinition, optional)
-            The VMImageDefinition for Gen2 VHD.
-            If not set the argument `gen1` must be set.
-        source (VMImageSource):
-            The VMImageSource with the updated SAS URI.
-    Returns:
-        list: A new list containing the expected VMImageDefinition(s)
-    """
-    if not gen1 and not gen2:
-        msg = "At least one argument of \"gen1\" or \"gen2\" must be set."
-        log.error(msg)
-        raise ValueError(msg)
-
-    raw_source = source.to_json()
-    json_gen1 = {
-        "imageType": get_image_type_mapping(metadata.architecture, "V1"),
-        "source": raw_source,
-    }
-    json_gen2 = {
-        "imageType": get_image_type_mapping(metadata.architecture, "V2"),
-        "source": raw_source,
-    }
-
-    if metadata.generation == "V2":
-        # In this case we need to set a V2 SAS URI
-        gen2_new = VMImageDefinition.from_json(json_gen2)
-        if is_legacy_gen_supported(metadata):  # and in this case a V1 as well
-            gen1_new = VMImageDefinition.from_json(json_gen1)
-            return [gen2_new, gen1_new]
-        return [gen2_new]
-    else:
-        # It's expected to be a Gen1 only, let's get rid of Gen2
-        return [VMImageDefinition.from_json(json_gen1)]
-
-
 def _all_skus_present(old_skus: List[VMISku], disk_versions: List[DiskVersion]) -> bool:
     image_types = set()
     for sku in old_skus:
@@ -465,47 +435,6 @@ def seek_disk_version(
     return None
 
 
-def vm_images_by_generation(
-    disk_version: DiskVersion, architecture: str
-) -> Tuple[Optional[VMImageDefinition], ...]:
-    """
-    Return a tuple containing the Gen1 and Gen2 VHD images in this order.
-
-    If one of the images doesn't exist it will return None in the expected tuple position.
-
-    Args:
-        disk_version
-            The disk version to retrieve the VMImageDefinitions from
-        architecture
-            The expected architecture for the VMImageDefinition.
-    Returns:
-        Gen1 and Gen2 VMImageDefinitions when they exist.
-    """
-    log.debug("Sorting the VMImageDefinition by generation.")
-    # Here we have 3 possibilities:
-    # 1. vm_images => "Gen1" only
-    # 2. vm_images => "Gen2" only
-    # 3. vm_images => "Gen1" and "Gen2"
-
-    # So let's get the first image whatever it is
-    img = disk_version.vm_images.pop(0)
-
-    # If first `img` is Gen2 we set the other one as `img_legacy`
-    if img.image_type == get_image_type_mapping(architecture, "V2"):
-        img_legacy = disk_version.vm_images.pop(0) if len(disk_version.vm_images) > 0 else None
-
-    else:  # Otherwise we set it as `img_legacy` and get the gen2
-        img_legacy = img
-        img = (
-            disk_version.vm_images.pop(0)  # type: ignore
-            if len(disk_version.vm_images) > 0
-            else None
-        )
-    log.debug("Image for current generation: %s", img)
-    log.debug("Image for legacy generation: %s", img_legacy)
-    return img, img_legacy
-
-
 def create_vm_image_definitions(
     metadata: AzurePublishingMetadata, source: VMImageSource
 ) -> List[VMImageDefinition]:
@@ -556,32 +485,55 @@ def set_new_sas_disk_version(
     Returns:
         The changed disk version with the given source.
     """
+    log.info("Setting up a new SAS disk version for \"%s\"", metadata.image_path)
     # If we already have a VMImageDefinition let's use it
     if disk_version.vm_images:
-        log.debug("The DiskVersion \"%s\" contains inner images." % disk_version.version_number)
-        img, img_legacy = vm_images_by_generation(disk_version, metadata.architecture)
-
-        # Now we replace the SAS URI for the vm_images
-        log.debug(
+        log.debug("The DiskVersion \"%s\" contains inner images.", disk_version.version_number)
+        log.info(
             "Adjusting the VMImages from existing DiskVersion \"%s\""
-            "to fit the new image with SAS \"%s\"."
-            % (disk_version.version_number, metadata.image_path)
-        )
-        disk_version.vm_images = prepare_vm_images(
-            metadata=metadata,
-            gen1=img_legacy,
-            gen2=img,
-            source=source,
+            " to fit the new image with SAS \"%s\".",
+            disk_version.version_number,
+            metadata.image_path,
         )
+        # Verify whether the arch is present for the new image
+        is_arch_present = False
+        # If the arch is present, update the SAS URI
+        for img in disk_version.vm_images:
+            if (
+                img.image_type == get_image_type_mapping(metadata.architecture, metadata.generation)
+            ) or (
+                metadata.support_legacy
+                and img.image_type == get_image_type_mapping(metadata.architecture, "V1")  # noqa
+            ):
+                is_arch_present = True
+                img.source.os_disk.uri = source.os_disk.uri
+
+        # If the arch is not present, add it to the DiskVersion
+        if not is_arch_present:
+            if metadata.support_legacy:
+                disk_version.vm_images.append(
+                    VMImageDefinition(
+                        image_type=get_image_type_mapping(metadata.architecture, "V1"),
+                        source=source.to_json(),
+                    )
+                )
+            disk_version.vm_images.append(
+                VMImageDefinition(
+                    image_type=get_image_type_mapping(metadata.architecture, metadata.generation),
+                    source=source.to_json(),
+                )
+            )
+        return disk_version
 
     # If no VMImages, we need to create them from scratch
     else:
         log.debug(
-            "The DiskVersion \"%s\" does not contain inner images." % disk_version.version_number
+            "The DiskVersion \"%s\" does not contain inner images.", disk_version.version_number
         )
-        log.debug(
-            "Setting the new image \"%s\" on DiskVersion \"%s\"."
-            % (metadata.image_path, disk_version.version_number)
+        log.info(
+            "Setting the new image \"%s\" on DiskVersion \"%s\".",
+            metadata.image_path,
+            disk_version.version_number,
         )
         disk_version.vm_images = create_vm_image_definitions(metadata, source)
 
@@ -591,4 +543,4 @@ def set_new_sas_disk_version(
 def logdiff(diff: DeepDiff) -> None:
     """Log the offer diff if it exists."""
     if diff:
-        log.warning(f"Found the following offer diff before publishing:\n{diff.pretty()}")
+        log.warning("Found the following offer diff before publishing:\n%s", diff.pretty())

{cloudpub-1.5.0.dist-info → cloudpub-1.7.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: cloudpub
-Version: 1.5.0
+Version: 1.7.0
 Summary: Services for publishing products in cloud environments
 Home-page: https://github.com/release-engineering/cloudpub
 Author: Jonathan Gangi
@@ -19,4 +19,12 @@ Requires-Dist: requests
 Requires-Dist: tenacity
 Requires-Dist: packaging
 Requires-Dist: boto3>=1.34.117
-
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: license
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: summary

{cloudpub-1.5.0.dist-info → cloudpub-1.7.0.dist-info}/RECORD

@@ -1,6 +1,6 @@
 cloudpub/__init__.py,sha256=OcXNPwjDybWtcxAL0IhFtKiMErHP4xugUgpMKPbpYGM,44
 cloudpub/common.py,sha256=fnMEVyf4M4hV2MGFKv59wy4C591jp6kji_sq0T6MRlA,3990
-cloudpub/error.py,sha256=5rMBJ3pPcbG92swnDlMtIKDVw60FeW37vFHcu58trcI,578
+cloudpub/error.py,sha256=Tof439r4Ei2mM-BnP1zI1sC2IBzUpbhFd2xIZdyg_k8,661
 cloudpub/utils.py,sha256=HTFVlYOb7nTw6BTTv_migod7cQMXzpSlBzsC8aCfQdQ,1097
 cloudpub/aws/__init__.py,sha256=bQbgPTq-S3IrUkZpBNAZ6-2FQ3KiRg87Al5muXh8pmc,117
 cloudpub/aws/service.py,sha256=h-nsTE1mldjQD1nqlUCX0OQiAwnDTVJlI92X13fK8GU,19337
@@ -8,13 +8,13 @@ cloudpub/aws/utils.py,sha256=qlZ9R7J8AArR3tFYW47cJ0dgdqYc7kPJUEn24HtzeGI,6453
 cloudpub/models/__init__.py,sha256=OcXNPwjDybWtcxAL0IhFtKiMErHP4xugUgpMKPbpYGM,44
 cloudpub/models/aws.py,sha256=arzFqLmFw8O9Otk_VatLR5dmQ9FsdWT3f0Ibap7EW0o,42850
 cloudpub/models/common.py,sha256=iZ503VVFL9y0P_wXiK0f3flXV32VWBs9i-9NoYfJZUg,4970
-cloudpub/models/ms_azure.py,sha256=nzTp9IvAW-WEJuN20IAc93yY6YPHCTE0j116EfQUsPg,55974
+cloudpub/models/ms_azure.py,sha256=f-r6Fic5zFyOGIZHUe1BK2iK7dzjXK1rqsZjn3Xvr5M,56252
 cloudpub/ms_azure/__init__.py,sha256=eeYXPd_wzDBmh0Hmzd5o4yzocFzM6n4r8qpCDy00kYk,117
-cloudpub/ms_azure/service.py,sha256=cMgKcOfgW0UwPPSGGH6Iiyqz2JidrEeowiY-SHq1mSU,26589
-cloudpub/ms_azure/session.py,sha256=7ZjBLBX4XSzx60Bxhn96kh64RJ3oQs734Tw3ZVSnFrU,6349
-cloudpub/ms_azure/utils.py,sha256=h6bEtMrlPsbayR-SlVEzlzxEC1i4fdSqH8Fn-m_xaMQ,20730
-cloudpub-1.5.0.dist-info/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-cloudpub-1.5.0.dist-info/METADATA,sha256=06r2pdV_DeEMDPue5D5iQ3rrmQe5fsEHF21zvlEFdFo,754
-cloudpub-1.5.0.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
-cloudpub-1.5.0.dist-info/top_level.txt,sha256=YnnJuTiWBpRI9zMkYUVcZNuvjzzJYblASj-7Q8m3Gzg,9
-cloudpub-1.5.0.dist-info/RECORD,,
+cloudpub/ms_azure/service.py,sha256=izO6vrC-xEYpnUrxMDmMo9ZKlUoAGtK4EmN6o_2dPWc,38634
+cloudpub/ms_azure/session.py,sha256=PXCSJ1dFkx43lQV0WFPnRxbpyOBccdtrMiWGPORT3Ro,6356
+cloudpub/ms_azure/utils.py,sha256=pYDcpSuL-FDLbXANakTY7M70hARGAjQ3rVPLZbCRjo4,19180
+cloudpub-1.7.0.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+cloudpub-1.7.0.dist-info/METADATA,sha256=ObxvkEd-CxzYbntbKDR2vW9hfgLntBxNtZWj3uHAJZY,927
+cloudpub-1.7.0.dist-info/WHEEL,sha256=SmOxYU7pzNKBqASvQJ7DjX3XGUF92lrGhMb3R6_iiqI,91
+cloudpub-1.7.0.dist-info/top_level.txt,sha256=YnnJuTiWBpRI9zMkYUVcZNuvjzzJYblASj-7Q8m3Gzg,9
+cloudpub-1.7.0.dist-info/RECORD,,

{cloudpub-1.5.0.dist-info → cloudpub-1.7.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.45.1)
+Generator: setuptools (79.0.1)
 Root-Is-Purelib: true
 Tag: py3-none-any