logos-sdk 0.0.25.dev9__tar.gz → 0.0.25.dev11__tar.gz

{logos_sdk-0.0.25.dev9 → logos_sdk-0.0.25.dev11}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.2
 Name: logos-sdk
-Version: 0.0.25.dev9
+Version: 0.0.25.dev11
 Summary: SDK for Logos platform
 Home-page: https://bitbucket.org/databy/logos-sdk-pip/src/master/
 Author: Databy.io
@@ -19,6 +19,14 @@ Requires-Dist: httplib2
 Requires-Dist: pandas
 Requires-Dist: db-dtypes
 Requires-Dist: numpy
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: requires-dist
+Dynamic: summary
 
 # Logos Software Development Kit  
   

{logos_sdk-0.0.25.dev9 → logos_sdk-0.0.25.dev11}/logos_sdk/services/CampaignManager.py

@@ -30,17 +30,20 @@ class CampaignManagerService:
         self._GET_FILE = self._URL + "/get-file"
         self._GET_FILE_MEDIA_REQUEST = self._URL + "/get-file-media-request"
         self._QUERY_DIMENSION_VALUES = self._URL + "/query-dimension-values"
+        self._GET_ACCESSIBLE_PARENT_ACCOUNTS = self._URL + "/get-parent-accounts"
+        self._GET_ACCESSIBLE_ADVERTISERS = self._URL + "/get-advertisers"
+        self._GET_ACCOUNT_ACCESSIBILITY = self._URL + "/get-account-accessibility"
 
     def create_report(
-        self,
-        account_id: str,
-        name: str,
-        start_date: str,
-        end_date: str,
-        dimensions: list,
-        metrics_names: list,
-        dimension_filters: list,
-        secret_id: str,
+            self,
+            account_id: str,
+            name: str,
+            start_date: str,
+            end_date: str,
+            dimensions: list,
+            metrics_names: list,
+            dimension_filters: list,
+            secret_id: str,
     ) -> Dict:
         """
         Method for creating a report in API and returning a dict containing its ID for further use
@@ -179,7 +182,7 @@ class CampaignManagerService:
             raise CampaignManagerServiceException(response.content)
 
     def check_report_ready_with_exponential_backoff(
-        self, report_id: str, file_id: str, secret_id: str, backoff_attempts: int = 10
+            self, report_id: str, file_id: str, secret_id: str, backoff_attempts: int = 10
     ) -> bool:
         """
         Implements exponential backoff for pooling the API for readiness of the report, suggested in
@@ -194,7 +197,7 @@ class CampaignManagerService:
             if self.check_report_ready(report_id, file_id, secret_id):
                 return True
             else:
-                time.sleep((2**attempt) + randint(1, 20))
+                time.sleep((2 ** attempt) + randint(1, 20))
 
         return False
 
@@ -288,14 +291,14 @@ class CampaignManagerService:
             raise CampaignManagerServiceException(response.content)
 
     def query_dimension_values(
-        self,
-        account_id: str,
-        secret_id: str,
-        dimension_name: str,
-        filters: List,
-        start_date: str,
-        end_date: int,
-        max_results: int = 100,
+            self,
+            account_id: str,
+            secret_id: str,
+            dimension_name: str,
+            filters: List,
+            start_date: str,
+            end_date: int,
+            max_results: int = 100,
     ) -> List[Dict]:
         """
         Retrieves values of selected dimensions for data filtered according to rules set in list of filters
@@ -346,16 +349,16 @@ class CampaignManagerService:
             yield service_response["data"]["items"]
 
     def create_and_get_report_results(
-        self,
-        account_id: str,
-        name: str,
-        start_date: str,
-        end_date: str,
-        dimensions: list,
-        metrics_names: list,
-        dimension_filters: list,
-        secret_id: str,
-        backoff_attempts: int,
+            self,
+            account_id: str,
+            name: str,
+            start_date: str,
+            end_date: str,
+            dimensions: list,
+            metrics_names: list,
+            dimension_filters: list,
+            secret_id: str,
+            backoff_attempts: int,
     ) -> Dict:
         """
         Method to create report, run it and fetch results in one go
@@ -378,10 +381,10 @@ class CampaignManagerService:
                 secret_id=secret_id,
             )
             if self.check_report_ready_with_exponential_backoff(
-                report_id=report["id"],
-                file_id=run_report["id"],
-                secret_id=secret_id,
-                backoff_attempts=backoff_attempts,
+                    report_id=report["id"],
+                    file_id=run_report["id"],
+                    secret_id=secret_id,
+                    backoff_attempts=backoff_attempts,
             ):
                 return self.get_report_results(
                     report_id=report["id"],
@@ -397,3 +400,72 @@ class CampaignManagerService:
                     report_id=report["id"],
                     secret_id=secret_id,
                 )
+
+    def get_accessible_parent_accounts(self, secret_id):
+        """
+        Returns accessible parent accounts
+        :param secret_id: The ID of the secret in secret manager
+        :return: list of parent accounts
+        """
+
+        header = get_headers(self._GET_ACCESSIBLE_PARENT_ACCOUNTS)
+        body = {"secret_id": secret_id}
+
+        response = request(
+            "post", url=self._GET_ACCESSIBLE_PARENT_ACCOUNTS, json=body, headers=header
+        )
+
+        if response.status_code == HTTPStatus.OK:
+            service_response = response.json()
+            return service_response["data"]
+        else:
+            raise CampaignManagerServiceException(response.content)
+
+    def get_accessible_advertisers(self, secret_id):
+        """
+        Returns accessible advertisers
+        :param secret_id: The ID of the secret in secret manager
+        :return: list of advertisers
+        """
+
+        header = get_headers(self._GET_ACCESSIBLE_ADVERTISERS)
+        body = {
+            "secret_id": secret_id,
+            "filters": {
+                "hide_inactive": True,
+            },
+        }
+
+        response = request(
+            "post", url=self._GET_ACCESSIBLE_ADVERTISERS, json=body, headers=header
+        )
+
+        if response.status_code == HTTPStatus.OK:
+            service_response = response.json()
+            return service_response["data"]
+        else:
+            raise CampaignManagerServiceException(response.content)
+
+    def get_account_accessibility(self, secret_id: str,account_id, advertiser_id: str) -> bool:
+        """
+        Gets account accessibility
+        :param secret_id: The ID of the secret in secret manager
+        :param account_id: Account ID
+        :param advertiser_id: The ID of the advertiser.
+        :return: True if account has access
+        """
+        body = {
+            "secret_id": secret_id,
+            "account_id": account_id,
+            "advertiser_id": advertiser_id
+        }
+        header = get_headers(self._GET_ACCOUNT_ACCESSIBILITY)
+        response = request(
+            "post", url=self._GET_ACCOUNT_ACCESSIBILITY, json=body, headers=header
+        )
+
+        if response.status_code == HTTPStatus.OK:
+            service_response = response.json()
+            return service_response["data"]
+        else:
+            raise CampaignManagerServiceException(response.content)

{logos_sdk-0.0.25.dev9 → logos_sdk-0.0.25.dev11}/logos_sdk/services/DV360.py

@@ -20,10 +20,10 @@ class DV360Service:
         self._URL = url or os.environ.get("DV360_SERVICE_PATH")
         self._LIST_LINE_ITEMS = self._URL + "/line-items"
         self._BULK_LIST_LINE_ITEM_ASSIGNED_TARGETING_OPTIONS = (
-            self._URL + "/bulk-list-line-item-assigned-targeting-options"
+                self._URL + "/bulk-list-line-item-assigned-targeting-options"
         )
         self._BULK_EDIT_LINE_ITEM_ASSIGNED_TARGETING_OPTIONS = (
-            self._URL + "/bulk-edit-line-item-assigned-targeting-options"
+                self._URL + "/bulk-edit-line-item-assigned-targeting-options"
         )
         self._CREATE_CHANNEL = self._URL + "/create-channel"
         self._LIST_CHANNELS = self._URL + "/list-channels"
@@ -34,6 +34,9 @@ class DV360Service:
         self._GET_QUERY_METADATA = self._URL + "/get-query-metadata"
         self._RUN_QUERY = self._URL + "/run-query"
         self._DELETE_QUERY = self._URL + "/delete-query"
+        self._GET_ACCESSIBLE_PARTNERS = self._URL + "/get-accessible-partners"
+        self._GET_ACCESSIBLE_ADVERTISERS = self._URL + "/get-accessible-advertisers"
+        self._GET_ACCOUNT_ACCESSIBILITY = self._URL + "/get-account-accessibility"
 
     def list_line_items(self, advertiser_id, secret_id, filter_string=None):
         """
@@ -58,11 +61,11 @@ class DV360Service:
             raise DV360ServiceException(response.content)
 
     def bulk_list_line_item_assigned_targeting_options(
-        self,
-        advertiser_id,
-        secret_id,
-        line_item_ids,
-        filter_string,
+            self,
+            advertiser_id,
+            secret_id,
+            line_item_ids,
+            filter_string,
     ):
         """
         Bulk lists targeting options under multiple line items
@@ -94,12 +97,12 @@ class DV360Service:
             raise DV360ServiceException(response.content)
 
     def bulk_edit_line_item_assigned_targeting_options(
-        self,
-        advertiser_id,
-        secret_id,
-        line_item_ids,
-        delete_requests=None,
-        create_requests=None,
+            self,
+            advertiser_id,
+            secret_id,
+            line_item_ids,
+            delete_requests=None,
+            create_requests=None,
     ):
         """
         Bulk edits targeting options under multiple line items
@@ -180,7 +183,7 @@ class DV360Service:
             raise DV360ServiceException(response.content)
 
     def list_channel_sites(
-        self, advertiser_id, secret_id, channel_id, filter_string=None
+            self, advertiser_id, secret_id, channel_id, filter_string=None
     ):
         """
         Lists channels for advertiser
@@ -211,12 +214,12 @@ class DV360Service:
             raise DV360ServiceException(response.content)
 
     def bulk_edit_channels_sites(
-        self,
-        advertiser_id,
-        secret_id,
-        channel_id,
-        deleted_sites=None,
-        created_sites=None,
+            self,
+            advertiser_id,
+            secret_id,
+            channel_id,
+            deleted_sites=None,
+            created_sites=None,
     ):
         """
         Bulk edits sites under a single channel
@@ -301,8 +304,80 @@ class DV360Service:
         else:
             raise DV360ServiceException(response.content)
 
+    def get_accessible_partners(self, secret_id):
+        """
+        Returns accessible partners
+        :param secret_id: The ID of the secret in secret manager
+        :return: list of partners
+        """
+
+        header = get_headers(self._GET_ACCESSIBLE_PARTNERS)
+        body = {
+            "secret_id": secret_id,
+            "filters": {
+                "hide_inactive": True,
+            },
+        }
+
+        response = request(
+            "post", url=self._GET_ACCESSIBLE_PARTNERS, json=body, headers=header
+        )
+
+        if response.status_code == HTTPStatus.OK:
+            service_response = response.json()
+            return service_response["data"]
+        else:
+            raise DV360ServiceException(response.content)
+
+    def get_accessible_advertisers(self, secret_id):
+        """
+        Returns accessible advertisers
+        :param secret_id: The ID of the secret in secret manager
+        :return: list of advertisers
+        """
+
+        header = get_headers(self._GET_ACCESSIBLE_ADVERTISERS)
+        body = {
+            "secret_id": secret_id,
+            "filters": {
+                "hide_inactive": True,
+            },
+        }
+
+        response = request(
+            "post", url=self._GET_ACCESSIBLE_ADVERTISERS, json=body, headers=header
+        )
+
+        if response.status_code == HTTPStatus.OK:
+            service_response = response.json()
+            return service_response["data"]
+        else:
+            raise DV360ServiceException(response.content)
+
+    def get_account_accessibility(self, secret_id: str, advertiser_id: str) -> bool:
+        """
+        Gets account accessibility
+        :param secret_id: The ID of the secret in secret manager
+        :param advertiser_id: The ID of the advertiser.
+        :return: True if account has access
+        """
+        body = {
+            "secret_id": secret_id,
+            "advertiser_id": advertiser_id
+        }
+        header = get_headers(self._GET_ACCOUNT_ACCESSIBILITY)
+        response = request(
+            "post", url=self._GET_ACCOUNT_ACCESSIBILITY, json=body, headers=header
+        )
+
+        if response.status_code == HTTPStatus.OK:
+            service_response = response.json()
+            return service_response["data"]
+        else:
+            raise DV360ServiceException(response.content)
+
     def _check_report_ready_with_exponential_backoff(
-        self, secret_id: str, query_id: str, report_id: str, backoff_attempts: int = 10
+            self, secret_id: str, query_id: str, report_id: str, backoff_attempts: int = 10
     ) -> bool:
         """
         Implements exponential backoff for pooling the API for readiness of the report, suggested in
@@ -318,7 +393,7 @@ class DV360Service:
             elif state == "FAILED":
                 raise DV360ServiceException("Report failed to generate")
             else:
-                sleep((2**attempt) + randint(1, 20))
+                sleep((2 ** attempt) + randint(1, 20))
 
         return False
 
@@ -352,7 +427,7 @@ class DV360Service:
         :return: The results
         """
         if not self._check_report_ready_with_exponential_backoff(
-            secret_id, query_id, report_id
+                secret_id, query_id, report_id
         ):
             raise DV360ServiceException("Report did not generate in time")
 
@@ -393,5 +468,5 @@ class DV360Service:
 
         if response.status_code == HTTPStatus.OK:
             return True
-        print("Query was not deleted!")
+
         return False

{logos_sdk-0.0.25.dev9 → logos_sdk-0.0.25.dev11}/logos_sdk/services/Facebook.py

@@ -27,6 +27,7 @@ class FacebookService:
         self._FEED_ERRORS = self._URL + "/feed-errors"
         self._FEED_ERRORS_REPORT_STATUS = self._URL + "/feed-errors-report-status"
         self._FEED_ERRORS_REPORT = self._URL + "/feed-errors-report"
+        self._GET_ACCOUNT_ACCESSIBILITY = self._URL + "/get-account-accessibility"
 
     def get_accessible_accounts(
         self, secret_id: str, timeout: int = None
@@ -38,7 +39,12 @@ class FacebookService:
         :return: all accessible accounts List(Dict)
         """
 
-        body = {"secret_id": secret_id}
+        body = {
+            "secret_id": secret_id,
+            "filters": {
+                "hide_inactive": True,
+            }
+        }
 
         header = get_headers(self._ACCESSIBLE_ACCOUNTS)
 
@@ -56,6 +62,27 @@ class FacebookService:
         else:
             raise FacebookServiceException(response.content)
 
+    def get_account_accessibility(self, secret_id: str, account_id: str) -> bool:
+        """
+        Gets account accessibility
+        :param secret_id: The ID of the secret in secret manager
+        :param account_id: The ID of the account.
+        :return: True if account has access
+        """
+        body = {
+            "secret_id": secret_id,
+            "account_id": account_id
+        }
+        header = get_headers(self._GET_ACCOUNT_ACCESSIBILITY)
+        response = request(
+            "post", url=self._GET_ACCOUNT_ACCESSIBILITY, json=body, headers=header
+        )
+
+        if response.status_code == HTTPStatus.OK:
+            service_response = response.json()
+            return service_response["data"]
+        else:
+            raise FacebookServiceException(response.content)
     def get_insights(
         self,
         account_id: str,

{logos_sdk-0.0.25.dev9 → logos_sdk-0.0.25.dev11}/logos_sdk/services/GoogleAds.py

@@ -21,6 +21,8 @@ class GoogleAdsService:
         self._SEARCH = self._URL + "/search"
         self._EXCLUDE_FOR_ACCOUNT = self._URL + "/exclude-for-account"
         self._EXCLUDE_FOR_AD_GROUP = self._URL + "/exclude-for-ad-group"
+        self._GET_ACCESSIBLE_ACCOUNTS = self._URL + "/list-accessible-accounts"
+        self._GET_ACCOUNT_ACCESSIBILITY = self._URL + "/get-account-accessibility"
 
     @staticmethod
     def fetch_with_retry_on_timeout(url, json, headers):
@@ -29,16 +31,18 @@ class GoogleAdsService:
                 return request("post", url, json=json, headers=headers, timeout=25)
             except Timeout:
                 delay = 2 * (2 ** attempt) + random.randint(0, 9)
-                print(f"there was a timeout when contacting the service, going to sleep for {delay} seconds")
+                print(
+                    f"there was a timeout when contacting the service, going to sleep for {delay} seconds"
+                )
                 time.sleep(delay)
 
         raise Exception("The service is not able to reply within 30 seconds.")
 
     def search_stream(
-        self,
-        query: str,
-        queried_account_id: str,
-        secret_id: str,
+            self,
+            query: str,
+            queried_account_id: str,
+            secret_id: str,
     ) -> List[Union[List, Dict]]:
         """
         :param query Sql query for google ads. Best way to build it is https://developers.google.com/google-ads/api/fields/v14/accessible_bidding_strategy_query_builder
@@ -53,7 +57,9 @@ class GoogleAdsService:
         }
 
         header = get_headers(self._SEARCH_STREAM)
-        response = self.fetch_with_retry_on_timeout(url=self._SEARCH_STREAM, json=body, headers=header)
+        response = self.fetch_with_retry_on_timeout(
+            url=self._SEARCH_STREAM, json=body, headers=header
+        )
 
         if response.status_code == HTTPStatus.OK:
             service_response = response.json()
@@ -62,11 +68,11 @@ class GoogleAdsService:
             raise GoogleAdsServiceException(response.content)
 
     def search(
-        self,
-        query: str,
-        queried_account_id: str,
-        secret_id: str,
-        page_size: int,
+            self,
+            query: str,
+            queried_account_id: str,
+            secret_id: str,
+            page_size: int,
     ) -> List[Dict]:
         """
         :param query Sql query for google ads. Best way to build it is https://developers.google.com/google-ads/api/fields/v14/accessible_bidding_strategy_query_builder
@@ -84,7 +90,9 @@ class GoogleAdsService:
         }
 
         header = get_headers(self._SEARCH)
-        response = self.fetch_with_retry_on_timeout(url=self._SEARCH, json=body, headers=header)
+        response = self.fetch_with_retry_on_timeout(
+            url=self._SEARCH, json=body, headers=header
+        )
 
         if response.status_code != HTTPStatus.OK:
             raise GoogleAdsServiceException(response.content)
@@ -104,7 +112,7 @@ class GoogleAdsService:
             yield service_response["data"]["results"]
 
     def exclude_criterion_for_account(
-        self, client_id: str, exclusion_raw: List[str], mode: str, secret_id: str = None
+            self, client_id: str, exclusion_raw: List[str], mode: str, secret_id: str = None
     ) -> None:
         """
         Excludes list of unwanted urls/YouTube channels for account with client_id
@@ -133,11 +141,11 @@ class GoogleAdsService:
             raise GoogleAdsServiceException(response.content)
 
     def exclude_criterion_for_ad_group(
-        self,
-        client_id: str,
-        ad_group_id: str,
-        exclusion_raw: List[str],
-        secret_id: str = None,
+            self,
+            client_id: str,
+            ad_group_id: str,
+            exclusion_raw: List[str],
+            secret_id: str = None,
     ) -> None:
         """
         Excludes list of unwanted urls/YouTube channels for given ad_group with client_id
@@ -163,3 +171,64 @@ class GoogleAdsService:
             return
         else:
             raise GoogleAdsServiceException(response.content)
+
+    def get_accessible_accounts(
+            self,
+            secret_id: str,
+            page_size: int = 1000,
+    ) -> List[Dict]:
+        body = {
+            "secret_id": secret_id,
+            "filters": {
+                "hide_inactive": True,
+            },
+            "page_token": None,
+            "page_size": page_size,
+        }
+
+        header = get_headers(self._GET_ACCESSIBLE_ACCOUNTS)
+        response = self.fetch_with_retry_on_timeout(
+            url=self._GET_ACCESSIBLE_ACCOUNTS, json=body, headers=header
+        )
+
+        if response.status_code != HTTPStatus.OK:
+            raise GoogleAdsServiceException(response.content)
+
+        service_response = response.json()
+        all_results = service_response["data"]["results"]
+
+        while service_response["data"]["next_page_token"]:
+            body["page_token"] = service_response["data"]["next_page_token"]
+            response = request(
+                "post", url=self._GET_ACCESSIBLE_ACCOUNTS, json=body, headers=header
+            )
+
+            if response.status_code != HTTPStatus.OK:
+                raise GoogleAdsServiceException(response.content)
+
+            service_response = response.json()
+            all_results.extend(service_response["data"]["results"])
+
+        return all_results
+
+    def get_account_accessibility(self, secret_id: str, account_id: str) -> bool:
+        """
+        Gets account accessibility
+        :param secret_id: The ID of the secret in secret manager
+        :param account_id: The ID of the account.
+        :return: True if account has access
+        """
+        body = {
+            "secret_id": secret_id,
+            "account_id": account_id
+        }
+        header = get_headers(self._GET_ACCOUNT_ACCESSIBILITY)
+        response = request(
+            "post", url=self._GET_ACCOUNT_ACCESSIBILITY, json=body, headers=header
+        )
+
+        if response.status_code == HTTPStatus.OK:
+            service_response = response.json()
+            return service_response["data"]
+        else:
+            raise GoogleAdsServiceException(response.content)

{logos_sdk-0.0.25.dev9 → logos_sdk-0.0.25.dev11}/logos_sdk/services/MerchantCenter.py

@@ -14,6 +14,8 @@ class MerchantCenterService:
         load_dotenv()
         self._URL = url or os.environ.get("MERCHANT_CENTER_SERVICE_PATH")
         self._LIST_ACCOUNTS = self._URL + "/account-service/accounts"
+        self._LIST_ACCESSIBLE_ACCOUNTS = self._URL + "/account-service/list-accessible-accounts"
+        self._GET_ACCOUNT_ACCESSIBILITY = self._URL + "/account-service/get-account-accessibility"
         self._LIST_ACCOUNT_STATUSES = self._URL + "/account-service/account-statuses"
         self._LIST_PRODUCTS = self._URL + "/product-service/products"
         self._LIST_PRODUCT_STATUSES = self._URL + "/product-service/product-statuses"
@@ -36,6 +38,22 @@ class MerchantCenterService:
         else:
             raise MerchantServiceException(response.content)
 
+    def list_accessible_accounts(self, secret_id: str):
+        """
+        Lists accessible accounts in Merchant Center
+        :param secret_id: The ID of the secret in secret manager
+        :return: List[Dict]
+        """
+        body = {"secret_id": secret_id}
+        header = get_headers(self._LIST_ACCESSIBLE_ACCOUNTS)
+        response = request("post", url=self._LIST_ACCESSIBLE_ACCOUNTS, json=body, headers=header)
+
+        if response.status_code == HTTPStatus.OK:
+            service_response = response.json()
+            return service_response["data"]
+        else:
+            raise MerchantServiceException(response.content)
+
     def list_account_statuses(
             self, merchant_account_id: str, account_id: str, secret_id: str
     ):
@@ -182,3 +200,27 @@ class MerchantCenterService:
 
             service_response = response.json()
             yield service_response["data"]["results"]
+
+    def get_account_accessibility(self, secret_id: str,merchant_account_id:str, account_id: str) -> bool:
+        """
+        Gets account accessibility
+        :param secret_id: The ID of the secret in secret manager
+        :param merchant_account_id: The ID of the managing account. This must be a multi-client account.
+        :param account_id: The ID of the account.
+        :return: True if account has access
+        """
+        body = {
+            "secret_id": secret_id,
+            "merchant_account_id": merchant_account_id,
+            "account_id": account_id
+        }
+        header = get_headers(self._GET_ACCOUNT_ACCESSIBILITY)
+        response = request(
+            "post", url=self._GET_ACCOUNT_ACCESSIBILITY, json=body, headers=header
+        )
+
+        if response.status_code == HTTPStatus.OK:
+            service_response = response.json()
+            return service_response["data"]
+        else:
+            raise MerchantServiceException(response.content)

{logos_sdk-0.0.25.dev9 → logos_sdk-0.0.25.dev11}/logos_sdk/services/MicrosoftAdvertising.py

@@ -23,6 +23,7 @@ class MicrosoftAdvertising:
         load_dotenv()
         self._URL = url or os.environ.get("MICROSOFT_ADVERTISING_PATH")
         self._GET_ACCESSIBLE_ACCOUNTS = self._URL + "/accessible-accounts"
+        self._GET_ACCOUNT_ACCESSIBILITY = self._URL + "/get-account-accessibility"
         self._GET_DESTINATION_URL_REPORT = self._URL + "/destination-url-report"
         self._GET_CAMPAIGN_PERFORMANCE_REPORT = self._URL + "/campaign-performance-report"
         self._GET_GEOGRAPHIC_PERFORMANCE_REPORT = self._URL + "/geographic-performance-report"
@@ -212,6 +213,9 @@ class MicrosoftAdvertising:
         """
         body = {
             "secret_id": secret_id,
+            "filters": {
+                "hide_inactive": True
+            }
         }
         header = get_headers(self._GET_ACCESSIBLE_ACCOUNTS)
         response = request(
@@ -223,3 +227,25 @@ class MicrosoftAdvertising:
             return service_response["data"]
         else:
             raise MicrosoftAdvertisingException(response.content)
+
+    def get_account_accessibility(self, secret_id: str, account_id: str) -> bool:
+        """
+        Gets account accessibility
+        :param secret_id: The ID of the secret in secret manager
+        :param account_id: The ID of the account in Microsoft Advertising
+        :return: True if account has access
+        """
+        body = {
+            "secret_id": secret_id,
+            "account_id": account_id
+        }
+        header = get_headers(self._GET_ACCOUNT_ACCESSIBILITY)
+        response = request(
+            "post", url=self._GET_ACCOUNT_ACCESSIBILITY, json=body, headers=header
+        )
+
+        if response.status_code == HTTPStatus.OK:
+            service_response = response.json()
+            return service_response["data"]
+        else:
+            raise MicrosoftAdvertisingException(response.content)

{logos_sdk-0.0.25.dev9 → logos_sdk-0.0.25.dev11}/logos_sdk/services/Sklik.py

@@ -46,13 +46,15 @@ def get_session_if_malformed(wrapped_function):
 
     return inner
 
+
 def get_report_results_if_expired(wrapped_function):
     @wraps(wrapped_function)
     def inner(*args, **kwargs):
         try:
             return wrapped_function(*args, **kwargs)
         except SklikServiceException as err:
-            if json.loads(err.args[0].decode("utf8")).get("detail") == "Requested report has expired. Please create a new report by calling createReport endpoint.":
+            if json.loads(err.args[0].decode("utf8")).get(
+                    "detail") == "Requested report has expired. Please create a new report by calling createReport endpoint.":
                 print("Report expired, creating new report")
                 args[0].get_session(args[0]._secret_id, args[0]._account_email)
                 return wrapped_function(*args, **kwargs)
@@ -74,6 +76,7 @@ class SklikService:
         self._LOGOUT = self._URL + "/logout"
         self._API_LIMITS = self._URL + "/api-limits"
         self._GET_SESSION = self._URL + "/get-session"
+        self._GET_SESSION_WITHOUT_ACCOUNT = self._URL + "/get-session-without-account"
         self.session = None  # dict {"sklik_session": "", "user_id": ""}
         self._secret_id = None
         self._account_email = None
@@ -99,6 +102,25 @@ class SklikService:
         else:
             raise SklikServiceException(response.content)
 
+    def get_session_without_account(self, secret_id: str) -> None:
+        """
+        Manages initial login of the sessions, returns dict with sklik session string without user id int
+        :param secret_id: The ID of the secret in secret manager
+        :return: Dict
+        """
+        body = {"secret_id": secret_id}
+        response = execute_request("post", url=self._GET_SESSION_WITHOUT_ACCOUNT, json=body)
+
+        if response.status_code == HTTPStatus.OK:
+            service_response = response.json()
+            self.session = {
+                "sklik_session": service_response["data"]["sklik_session"],
+                "user_id": None,
+            }
+            self._secret_id = secret_id
+        else:
+            raise SklikServiceException(response.content)
+
     def logout_of_current_session(self) -> None:
         """
         Attempts to log out of the current session, nothing happens if not ok
@@ -113,15 +135,15 @@ class SklikService:
     @get_session_if_malformed
     @get_report_results_if_expired
     def get_report_results(
-        self,
-        secret_id: str,
-        account_email: str,
-        report_type: str,
-        date_from: str,
-        date_to: str,
-        columns: List[str],
-        create_params: Dict[str, Union[int, str]] = None,
-        read_params: Dict[str, Union[int, str]] = None,
+            self,
+            secret_id: str,
+            account_email: str,
+            report_type: str,
+            date_from: str,
+            date_to: str,
+            columns: List[str],
+            create_params: Dict[str, Union[int, str]] = None,
+            read_params: Dict[str, Union[int, str]] = None,
     ) -> List[Dict]:
         """
         It creates sklik report with /create-report call in sklik service and reads sklik report with pagination
@@ -166,14 +188,14 @@ class SklikService:
 
     @get_session_if_malformed
     def get_streamed_report_results(
-        self,
-        secret_id: str,
-        account_email: str,
-        report_type: str,
-        date_from: str,
-        date_to: str,
-        columns: List[str],
-        create_params: Dict[str, Union[int, str]] = None,
+            self,
+            secret_id: str,
+            account_email: str,
+            report_type: str,
+            date_from: str,
+            date_to: str,
+            columns: List[str],
+            create_params: Dict[str, Union[int, str]] = None,
     ) -> List[Dict]:
         """
         It creates sklik report with /create-report call in sklik service and reads sklik report with pagination
@@ -213,13 +235,13 @@ class SklikService:
                 raise SklikServiceException(response.content)
 
     def _create_report(
-        self,
-        secret_id: str,
-        account_email: str,
-        report_type: str,
-        date_from: str,
-        date_to: str,
-        params: Dict[str, Union[int, str]] = None,
+            self,
+            secret_id: str,
+            account_email: str,
+            report_type: str,
+            date_from: str,
+            date_to: str,
+            params: Dict[str, Union[int, str]] = None,
     ) -> Dict:
         """
          Function creates sklik report with /create-report call
@@ -256,7 +278,7 @@ class SklikService:
 
     @get_session_if_malformed
     def call_api(
-        self, secret_id: str, account_email: str, method: str, params: List[Dict]
+            self, secret_id: str, account_email: str, method: str, params: List[Dict]
     ) -> Union[List, Dict]:
         """
         Function to call SklikService get-api route
@@ -310,12 +332,52 @@ class SklikService:
             return service_response["data"]
         else:
             raise SklikServiceException(response.content)
+
+    @get_session_if_malformed
+    def get_accessible_accounts(
+            self,
+            secret_id: str,
+    ) -> Union[List, Dict]:
+        """
+        Function to retrieve accessible accounts
+        :param secret_id: The ID of the secret in secret manager
+        :return:
+        """
+
+        if self.session is None:
+            self.get_session_without_account(secret_id)
+
+        response = execute_request(
+            "post",
+            url=self._GET_CLIENT,
+            json={
+                "sklik_session": self.session["sklik_session"],
+                "filters": {
+                    "hide_inactive": True
+                }
+            },
+        )
+
+        if response.status_code == HTTPStatus.OK:
+            accounts = []
+            service_response = response.json()
+            data = service_response["data"]
+            for account in data["foreignAccounts"]:
+                accounts.append({
+                    "id": account['userId'],
+                    "name": account['username'],
+                    "active": account["relationStatus"] == "live"
+                })
+            return accounts
+        else:
+            raise SklikServiceException(response.content)
+
     @get_session_if_malformed
     def check_data_ready(
-        self,
-        secret_id: str,
-        account_email: str,
-        date: str = None,
+            self,
+            secret_id: str,
+            account_email: str,
+            date: str = None,
     ) -> int:
         """
         Checks if data on server are ready
@@ -329,8 +391,8 @@ class SklikService:
             self.get_session(secret_id, account_email)
 
         date = date or (
-            datetime.now(timezone("UTC")).astimezone(timezone("Europe/Prague"))
-            - timedelta(days=1)
+                datetime.now(timezone("UTC")).astimezone(timezone("Europe/Prague"))
+                - timedelta(days=1)
         ).strftime("%Y-%m-%d")
 
         body = {"date": date}
@@ -351,9 +413,9 @@ class SklikService:
 
     @get_session_if_malformed
     def fetch_api_limits(
-        self,
-        secret_id: str,
-        account_email: str,
+            self,
+            secret_id: str,
+            account_email: str,
     ) -> Union[List, Dict]:
         """
         Function to call SklikService api/limits route
@@ -371,4 +433,19 @@ class SklikService:
             service_response = response.json()
             return service_response["data"]
         else:
-            raise SklikServiceException(response.content)
+            raise SklikServiceException(response.content)
+
+    def get_account_accessibility(self, secret_id: str, account_email: str) -> bool:
+        """
+        Gets account accessibility
+        :param secret_id: The ID of the secret in secret manager
+        :param account_email: Account email to refers to Sklik accountId
+        :return: True if account has access
+        """
+        body = {"account_email": account_email, "secret_id": secret_id}
+        response = execute_request("post", url=self._GET_SESSION, json=body)
+        if response.status_code == 200:
+            return True
+        if response.status_code == 401 or response.status_code == 403 or response.status_code == 404:
+            return False
+        raise SklikServiceException(response.content)

{logos_sdk-0.0.25.dev9 → logos_sdk-0.0.25.dev11}/logos_sdk.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.2
 Name: logos-sdk
-Version: 0.0.25.dev9
+Version: 0.0.25.dev11
 Summary: SDK for Logos platform
 Home-page: https://bitbucket.org/databy/logos-sdk-pip/src/master/
 Author: Databy.io
@@ -19,6 +19,14 @@ Requires-Dist: httplib2
 Requires-Dist: pandas
 Requires-Dist: db-dtypes
 Requires-Dist: numpy
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: requires-dist
+Dynamic: summary
 
 # Logos Software Development Kit