sync_amz_data/sync_amz_data/public/amz_ad_client.py

import requests
from urllib3.util.retry import Retry
from requests.adapters import HTTPAdapter
import json
import time
from cachetools import TTLCache
from urllib.parse import urljoin
from typing import List, Literal, Iterable, Iterator
import gzip
from pathlib import Path
import s3fs
from s3fs import S3FileSystem

import logging

URL_AUTH = "https://api.amazon.com/auth/o2/token"
URL_AD_API = "https://advertising-api.amazon.com"

cache = TTLCache(maxsize=10, ttl=3200)

logger = logging.getLogger(__name__)


class RateLimitError(Exception):
    def __init__(self, retry_after: str = None):
        self.retry_after = retry_after


def gz_decompress(file_path: str, chunk_size: int = 1024 * 1024):
    decompressed_file = file_path.rstrip(".gz")
    with open(decompressed_file, "wb") as pw:
        zf = gzip.open(file_path, mode='rb')
        while True:
            chunk = zf.read(size=chunk_size)
            if not chunk:
                break
            pw.write(chunk)
    return decompressed_file


class BaseClient:
    def __init__(
            self, lwa_client_id: str, lwa_client_secret: str, refresh_token: str = None, profile_id: str = None,
            data_path: str = "./"
    ):
        self.lwa_client_id = lwa_client_id
        self.lwa_client_secret = lwa_client_secret
        self.refresh_token = refresh_token
        self.profile_id = profile_id
        self.data_path = Path(data_path)
        if not self.data_path.exists():
            self.data_path.mkdir(parents=True)

        retry_strategy = Retry(
            total=5,  # 重试次数
            allowed_methods=["GET", "POST"],
            # 强制重试的状态码，在method_whitelist中的请求方法才会重试
            status_forcelist=[429, 500, 502, 503, 504],
            raise_on_status=False,  # 在status_forcelist中的状态码达到重试次数后是否抛出异常
            # backoff_factor * (2 ** (retry_time-1))， 即间隔1s, 2s, 4s, 8s, ...
            backoff_factor=2,
        )
        adapter = HTTPAdapter(max_retries=retry_strategy)
        self.session = requests.session()
        self.session.mount("https://", adapter)

    @property
    def access_token(self) -> str:
        try:
            return cache[self.refresh_token]
        except KeyError:
            resp = requests.post(URL_AUTH, data={
                "grant_type": "refresh_token",
                "client_id": self.lwa_client_id,
                "refresh_token": self.refresh_token,
                "client_secret": self.lwa_client_secret,
            })
            if resp.status_code != 200:
                raise Exception(resp.text)
            js = resp.json()
            cache[self.refresh_token] = js["access_token"]
            self.refresh_token = js["refresh_token"]
            return js["access_token"]

    @property
    def auth_headers(self):
        return {
            "Amazon-Advertising-API-ClientId": self.lwa_client_id,
            "Amazon-Advertising-API-Scope": self.profile_id,
            "Authorization": f"Bearer {self.access_token}",
        }

    def _request(self, url_path: str, method: str = "GET", headers: dict = None, params: dict = None,
                 body: dict = None):
        head = self.auth_headers
        if headers:
            head.update(headers)
        resp = self.session.request(
            method=method,
            url=urljoin(URL_AD_API, url_path),
            headers=head,
            params=params,
            json=body,
        )
        if resp.status_code == 429:
            raise RateLimitError(resp.headers.get("Retry-After"))
        if resp.status_code >= 400:
            raise Exception(resp.text)

        return resp.json()

    def get_profilesInfo(self):
        url_path = "/v2/profiles"
        return self._request(url_path)

class SPClient(BaseClient):

    def get_campaigns(self, **body):
        url_path = "/sp/campaigns/list"
        headers = {
            "Accept": "application/vnd.spcampaign.v3+json",
            "Content-Type": "application/vnd.spcampaign.v3+json"
        }
        return self._request(url_path, method="POST", headers=headers, body=body)

    def iter_campaigns(self, **body) -> Iterator[dict]:
        if "maxResults" not in body:
            body["maxResults"] = 100
        while True:
            info: dict = self.get_campaigns(**body)
            yield from info["campaigns"]
            if not info.get("nextToken"):
                break
            body["nextToken"] = info["nextToken"]
        logger.info(f"总共数量：{info['totalResults']}")

    def get_ad_groups(self, **body):
        url_path = "/sp/adGroups/list"
        headers = {
            "Accept": "application/vnd.spadGroup.v3+json",
            "Content-Type": "application/vnd.spadGroup.v3+json"
        }
        return self._request(url_path, method="POST", body=body, headers=headers)

    def iter_adGroups(self, **body) -> Iterator[dict]:
        if "maxResults" not in body:
            body["maxResults"] = 100
        while True:
            info: dict = self.get_ad_groups(**body)
            yield from info["adGroups"]
            if not info.get("nextToken"):
                break
            body["nextToken"] = info["nextToken"]
        logger.info(f"总共数量：{info['totalResults']}")

    def get_ads(self, **body):
        url_path = "/sp/productAds/list"
        headers = {
            "Accept": "application/vnd.spproductAd.v3+json",
            "Content-Type": "application/vnd.spproductAd.v3+json"
        }
        return self._request(url_path, method="POST", body=body, headers=headers)

    def iter_ads(self, **body) -> Iterator[dict]:
        if "maxResults" not in body:
            body["maxResults"] = 100
        while True:
            info: dict = self.get_ads(**body)
            yield from info["productAds"]
            if not info.get("nextToken"):
                break
            body["nextToken"] = info["nextToken"]
        logger.info(f"总共数量：{info['totalResults']}")

    def get_keywords(self, **body):
        url_path = "/sp/keywords/list"
        headers = {
            "Accept": "application/vnd.spKeyword.v3+json",
            "Content-Type": "application/vnd.spKeyword.v3+json"
        }
        return self._request(url_path, method="POST", body=body, headers=headers)

    def iter_keywords(self, **body) -> Iterator[dict]:
        if "maxResults" not in body:
            body["maxResults"] = 100
        while True:
            info: dict = self.get_keywords(**body)
            yield from info["keywords"]
            if not info.get("nextToken"):
                break
            body["nextToken"] = info["nextToken"]
        logger.info(f"总共数量：{info['totalResults']}")

    def get_targets(self, **body):
        url_path = "/sp/targets/list"
        headers = {
            "Accept": "application/vnd.sptargetingClause.v3+json",
            "Content-Type": "application/vnd.sptargetingClause.v3+json"
        }
        return self._request(url_path, method="POST", body=body, headers=headers)

    def iter_targets(self, **body) -> Iterator[dict]:
        if "maxResults" not in body:
            body["maxResults"] = 100
        while True:
            info: dict = self.get_targets(**body)
            yield from info["targetingClauses"]
            if not info.get("nextToken"):
                break
            body["nextToken"] = info["nextToken"]
        logger.info(f"总共数量：{info['totalResults']}")

    def get_budget(self, campaign_ids: list):
        url_path = "/sp/campaigns/budget/usage"
        body = {
            "campaignIds": campaign_ids
        }
        return self._request(url_path, method="POST", body=body)

    def get_adgroup_bidrecommendation(
            self, campaignId: str, adGroupId: str, targetingExpressions: list,
            recommendationType: str = "BIDS_FOR_EXISTING_AD_GROUP"):
        url_path = "/sp/targets/bid/recommendations"
        headers = {
            "Accept": "application/vnd.spthemebasedbidrecommendation.v3+json",
            "Content-Type": "application/vnd.spthemebasedbidrecommendation.v3+json"
        }
        body = {
            "campaignId": campaignId,
            "adGroupId": adGroupId,
            "recommendationType": recommendationType,
            "targetingExpressions": targetingExpressions
        }
        return self._request(url_path, method="POST", body=body, headers=headers)

    def get_keyword_bidrecommendation(self, adGroupId: str, keyword: list, matchType: list):
        keywords = list(map(lambda x: {"keyword": x[0], "matchType": x[1]}, list(zip(keyword, matchType))))
        url_path = "/v2/sp/keywords/bidRecommendations"
        body = {"adGroupId": adGroupId,
                "keywords": keywords}
        return self._request(url_path, method="POST", body=body)
    def get_v3_report(self,
                      groupby:list,
                      columns:list,
                      startDate:str,
                      endDate:str,
                      reportType: Literal['spCampaigns','spAdvertisedProduct' ,'spPurchasedProduct', 'spTargeting', 'spSearchTerm'],
                      timeUnit="DAILY",
                      download=True):
        """
        @param groupby: 聚合条件,[campaign,adGroup, searchTerm,purchasedAsin,campaignPlacement,targeting,searchTerm,advertiser,asin]
        columns: 需要获取的字段
        """
        url_path = "/reporting/reports"
        headers = {
            "Content-Type":"application/vnd.createasyncreportrequest.v3+json"
            }
        body = {
                "name":"SP campaigns report",
                "startDate":startDate,
                "endDate":endDate,
                "configuration":{
                    "adProduct":"SPONSORED_PRODUCTS",
                    "groupBy":groupby,
                    "columns":columns,
                    "reportTypeId":reportType,
                    "timeUnit":timeUnit,
                    "format":"GZIP_JSON"
                }
            }
        ret = self._request(url_path,method="POST",headers=headers,body=body)
        # print(ret)
        report_id = ret["reportId"]
        status = ret["status"]
        if status == "FAILURE":
            raise Exception(ret)
        logger.info(f"创建报告成功：{ret}")
        while status in ["PROCESSING","PENDING"]:
            logger.debug(f"报告{report_id}正在处理中...")
            time.sleep(3)
            ret = self._request(f"/reporting/reports/{report_id}")
            print(ret)
            status = ret["status"]
            if status == "FAILURE":
                raise Exception(ret)
        logger.info(f"报告处理完成：{ret}")
        if download:
            pid = self.profile_id
            reportrel= self.download_v3_report(ret['url'],f"s3://reportforspsbsd/zosi/us/sp/{str(groupby)}_{startDate}_{endDate}_{reportType}_{str(pid)}.json.gz")
            return reportrel
        else:
            return ret

    def download_v3_report(self, url, file_path: str, decompress: bool = True) -> str:
        resp = requests.get(url, stream=True, allow_redirects=True)
        print(resp)
        kwargs = {'region_name': 'us-east-1', 'endpoint_url': "https://s3.amazonaws.com",
                  'aws_access_key_id': 'AKIARBAGHTGORIFN44VQ',
                  'aws_secret_access_key': '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'}
        s3_ = S3FileSystem(client_kwargs=kwargs)
        # print()
        with s3_.open(file_path, 'wb') as f:
            for data in resp.iter_content(chunk_size=10 * 1024):
                f.write(data)
        if not decompress:
            return file_path
        with s3_.open(file_path, 'rb') as f:  # 读取s3数据
            data = gzip.GzipFile(fileobj=f, mode='rb')
            de_file = json.load(data)
        logger.info(f"解压完成：{de_file}")
        # print(de_file)
        return de_file

class SBClient(BaseClient):
    def get_campaigns(self, **body):
        url_path = "/sb/v4/campaigns/list"
        headers = {
            "Accept": "application/vnd.sbcampaignresouce.v4+json",
            "Content-Type": "application/vnd.sbcampaignresouce.v4+json"
        }
        return self._request(url_path, method="POST", body=body, headers=headers)

    def iter_campaigns(self, **body) -> Iterator[dict]:
        if "maxResults" not in body:
            body["maxResults"] = 100
        while True:
            info: dict = self.get_campaigns(**body)
            yield from info["campaigns"]
            if not info.get("nextToken"):
                break
            body["nextToken"] = info["nextToken"]
        # logger.info(f"总共数量：{info['totalResults']}")

    def get_ad_groups(self, **body):
        url_path = "/sb/v4/adGroups/list"
        headers = {
            'Content-Type': "application/vnd.sbadgroupresource.v4+json",
            'Accept': "application/vnd.sbadgroupresource.v4+json"
        }
        return self._request(url_path, method="POST", headers=headers, body=body)

    def iter_adGroups(self, **body) -> Iterator[dict]:
        if "maxResults" not in body:
            body["maxResults"] = 100
        while True:
            info: dict = self.get_ad_groups(**body)
            # print(info)
            yield from info["adGroups"]
            if not info.get("nextToken"):
                break
            body["nextToken"] = info["nextToken"]

    def get_ads(self, **body):
        url_path = "/sb/v4/ads/list"
        headers = {
            'Content-Type': "application/vnd.sbadresource.v4+json",
            'Accept': "application/vnd.sbadresource.v4+json"
        }
        return self._request(url_path, method="POST", headers=headers, body=body)

    def iter_ads(self, **body):
        if "maxResults" not in body:
            body["maxResults"] = 100
        while True:
            info: dict = self.get_ads(**body)
            print(info)
            yield from info["ads"]
            if not info.get("nextToken"):
                break
            body["nextToken"] = info["nextToken"]

    def get_keywords(self,**param):
        url_path = "/sb/keywords"
        return self._request(url_path, method="GET",params=param)

    def iter_keywords(self,**param):
        if "startIndex" not in param:
            param["startIndex"] = 0
            param["count"] = 5000
        while True:
            info:list = self.get_keywords(**param)
            # print(info)
            if len(info) == 0:
                break
            param["startIndex"] += 5000
            yield info

    def get_targets(self, **body):
        url_path = "/sb/targets/list"
        return self._request(url_path, method="POST", body=body)

    def iter_targets(self, **body):
        if "maxResults" not in body:
            body["maxResults"] = 100
        while True:
            info: dict = self.get_targets(**body)
            # print(info)
            yield from info["targets"]
            if not info.get("nextToken"):
                break
            body["nextToken"] = info["nextToken"]

    def get_budget(self, campaignIds: list):
        url_path = "/sb/campaigns/budget/usage"
        body = {"campaignIds": campaignIds}
        return self._request(url_path, method="POST", body=body)

    def get_keyword_bidrecommendation(self, **body):
        url_path = "/sb/recommendations/bids"
        return self._request(url_path, method="POST", body=body)

    def get_v3_report(self,
                      groupby:list,
                      columns:list,
                      startDate:str,
                      endDate:str,
                      reportType: Literal['sbCampaigns', 'sbPurchasedProduct', 'sbTargeting', 'sbSearchTerm'],
                      timeUnit="DAILY",
                      download=True):
        """
        Now about reportType is only sbPurchasedProduct available.
        @param groupby: 聚合条件
        @param columns: 需要获取的字段[campaign,purchasedAsin,targeting,searchTerm]
        @param startDate: 请求开始的日期
        @param endDate: 请求结束的日期
        @param reportType: 广告类型
        @param timeUnit: 时间指标-[DAILY, SUMMARY]
        @param download: 下载报告
        """
        url_path = "/reporting/reports"
        headers = {
            "Content-Type":"application/vnd.createasyncreportrequest.v3+json"
            }
        body = {
                "name":"SB campaigns report",
                "startDate":startDate,
                "endDate":endDate,
                "configuration":{
                    "adProduct":"SPONSORED_BRANDS",
                    "groupBy":groupby,
                    "columns":columns,
                    "reportTypeId":reportType,
                    "timeUnit":timeUnit,
                    "format":"GZIP_JSON"
                }
            }
        ret = self._request(url_path,method="POST",headers=headers,body=body)
        # print(ret)
        report_id = ret["reportId"]
        status = ret["status"]
        if status == "FAILURE":
            raise Exception(ret)
        logger.info(f"创建报告成功：{ret}")
        while status in ["PROCESSING","PENDING"]:
            logger.debug(f"报告{report_id}正在处理中...")
            time.sleep(3)
            ret = self._request(f"/reporting/reports/{report_id}")
            print(ret)
            status = ret["status"]
            if status == "FAILURE":
                raise Exception(ret)
        logger.info(f"报告处理完成：{ret}")
        if download:
            pid = self.profile_id
            reportrel= self.download_v3_report(ret['url'],f"s3://reportforspsbsd/zosi/us/sb/{startDate}_{endDate}_{reportType}_{str(groupby)}_{str(pid)}.json.gz")
            return reportrel
        else:
            return ret

    def download_v3_report(self, url, file_path: str, decompress: bool = True) -> str:
        resp = requests.get(url, stream=True, allow_redirects=True)
        print(resp)
        kwargs = {'region_name': 'us-east-1', 'endpoint_url': "https://s3.amazonaws.com",
                  'aws_access_key_id': 'AKIARBAGHTGORIFN44VQ',
                  'aws_secret_access_key': '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'}
        s3_ = S3FileSystem(client_kwargs=kwargs)
        # print()
        with s3_.open(file_path, 'wb') as f:
            for data in resp.iter_content(chunk_size=10 * 1024):
                f.write(data)
        if not decompress:
            return file_path
        with s3_.open(file_path, 'rb') as f:  # 读取s3数据
            data = gzip.GzipFile(fileobj=f, mode='rb')
            de_file = json.load(data)
        logger.info(f"解压完成：{de_file}")
        # print(de_file)
        return de_file

    def get_v2_report(
            self,
            record_type: Literal['campaigns', 'adGroups', 'ads', 'targets', 'keywords'],
            report_date: str,
            metrics: List[str],
            segment: Literal['placement', 'query'] = None,
            creative_type: Literal['video', 'all'] = "all",
            download: bool = True
    ):
        """
        @param download: 是否下载文件
        @param record_type:
        @param report_date: 格式为YYYYMMDD，以请求的卖家市场所对应的时区为准，超过60天的报告不可用
        @param metrics:
        @param segment:
        @param creative_type:
            None：仅包含非视频广告
            'video'：仅包含视频广告
            'all'：包含视频和非视频广告
        @return:
        """
        url = f"/v2/hsa/{record_type}/report"
        body = {
            "reportDate": report_date,
            "metrics": ",".join(metrics),
            "creativeType": creative_type,
            "segment": segment
        }
        if record_type == "ads":
            body["creativeType"] = "all"
        ret = self._request(url, method="POST", body=body)
        report_id = ret["reportId"]
        status = ret["status"]
        if status == "FAILURE":
            raise Exception(ret)
        logger.info(f"创建报告成功：{ret}")
        while status == "IN_PROGRESS":
            logger.debug(f"报告{report_id}正在处理中...")
            time.sleep(3)
            ret = self._request(f"/v2/reports/{report_id}")
            print(ret)
            status = ret["status"]
            if status == "FAILURE":
                raise Exception(ret)
        logger.info(f"报告处理完成：{ret}")
        if download:
            pid = self.profile_id
            reportrel= self.download_v2_report(report_id, f"s3://reportforspsbsd/zosi/us/sb/{str(report_date)}_{record_type}_{creative_type}_{segment}_{str(pid)}.gz")
            return reportrel
        else:
            return ret

    def download_v2_report(self, report_id: str, file_path: str, decompress: bool = True) -> str:
        url = urljoin(URL_AD_API, f"/v2/reports/{report_id}/download")
        resp = requests.get(url, headers=self.auth_headers, stream=True, allow_redirects=True)
        logger.info(f"开始下载报告：{report_id}")
        kwargs = {'region_name': 'us-east-1', 'endpoint_url': "https://s3.amazonaws.com",
                  'aws_access_key_id': 'AKIARBAGHTGORIFN44VQ',
                  'aws_secret_access_key': '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'}
        s3_ = S3FileSystem(client_kwargs=kwargs)
        # print()
        with s3_.open(file_path, 'wb') as f:
            for data in resp.iter_content(chunk_size=10 * 1024):
                f.write(data)

        logger.info(f"报告{report_id}下载完成：{file_path}")
        if not decompress:
            return file_path
        with s3_.open(file_path, 'rb') as f:  # 读取s3数据
            data = gzip.GzipFile(fileobj=f, mode='rb')
            de_file = json.load(data)
        logger.info(f"解压完成：{de_file}")
        # print(de_file)
        return de_file

class SDClient(BaseClient):
    def get_campaigns(self, **params) -> List[dict]:
        url_path = "/sd/campaigns"
        return self._request(url_path, params=params)

    def get_adGroups(self,**params):
        url_path = '/sd/adGroups'
        return self._request(url_path, params=params)

    def iter_adGroups(self,**param):
        if "startIndex" not in param:
            param["startIndex"] = 0
            param["count"] = 5000
        while True:
            info:list = self.get_adGroups(**param)
            # print(info)
            if len(info) == 0:
                break
            param["startIndex"] += 5000
            yield info

    def get_ads(self,**params):
        url_path = '/sd/productAds'
        return self._request(url_path, params=params)

    def iter_ads(self,**param):
        if "startIndex" not in param:
            param["startIndex"] = 0
            param["count"] = 5000
        while True:
            info:list = self.get_ads(**param)
            # print(info)
            if len(info) == 0:
                break
            param["startIndex"] += 5000
            yield info

    def get_targets(self,**params):
        url_path = '/sd/targets'
        return self._request(url_path, params=params)

    def iter_targets(self,**param):
        if "startIndex" not in param:
            param["startIndex"] = 0
            param["count"] = 5000
        while True:
            info:list = self.get_targets(**param)
            # print(info)
            if len(info) == 0:
                break
            param["startIndex"] += 5000
            yield info

    def get_budget(self, campaignIds: list):
        url_path = "/sd/campaigns/budget/usage"
        body = {"campaignIds": campaignIds}
        return self._request(url_path, method="POST", body=body)

    def get_target_bidrecommendation(self,tactic:str,products:list,typeFilter:list,themes:dict,locale:str='en_US'):#
        url_path = '/sd/targets/recommendations'
        headers ={
            'Content-Type':"application/vnd.sdtargetingrecommendations.v3.3+json",
            'Accept':"application/vnd.sdtargetingrecommendations.v3.3+json"
        }
        # "tactic":"T00020",
        # "products":[{"asin":"B00MP57IOY"}],
        # "typeFilter":["PRODUCT"],
        # "themes":{"product":[{"name":"TEST","expression":[{"type":"asinBrandSameAs"}]}]}
        body = {
            "tactic":tactic,
            "products":products,
            "typeFilter":typeFilter,
            "themes":themes
                 }

        return self._request(url_path, method="POST", headers=headers,body=body,params={"locale":locale})

    def get_v2_report(
            self,
            record_type: Literal['campaigns', 'adGroups', 'productAds', 'targets', 'asins'],
            report_date: str,
            metrics: List[str],
            segment: Literal['matchedTarget'] = None,
            tactic: Literal['T00020', 'T00030'] = None,
            download: bool = True
    ):
        """
        @param download: 是否下载文件
        @param record_type:
        @param report_date: 格式为YYYYMMDD，以请求的卖家市场所对应的时区为准，超过60天的报告不可用
        @param metrics:
        @param segment:
        @param tactic:
            T00020: contextual targeting
            T00030: audience targeting
        @return:
        """
        url = f"/sd/{record_type}/report"
        body = {
            "reportDate": report_date,
            "metrics": ",".join(metrics),
            "tactic": tactic,
            "segment": segment
        }
        ret = self._request(url, method="POST", body=body)
        report_id = ret["reportId"]
        status = ret["status"]
        print(ret)
        if status == "FAILURE":
            raise Exception(ret)
        logger.info(f"创建报告成功：{ret}")
        while status == "IN_PROGRESS":
            logger.debug(f"报告{report_id}正在处理中...")
            time.sleep(3)
            ret = self._request(f"/v2/reports/{report_id}")
            print(ret)
            status = ret["status"]
            if status == "FAILURE":
                raise Exception(ret)
        logger.info(f"报告处理完成：{ret}")
        if download:
            pid = self.profile_id
            reportrel= self.download_v2_report(report_id, f"s3://reportforspsbsd/zosi/us/sd/{str(report_date)}_{record_type}_{tactic}_{segment}_{str(pid)}.gz")
            return reportrel
        else:
            return ret

    def download_v2_report(self, report_id: str, file_path: str, decompress: bool = True) -> str:
        url = urljoin(URL_AD_API, f"/v2/reports/{report_id}/download")
        resp = requests.get(url, headers=self.auth_headers, stream=True, allow_redirects=True)
        logger.info(f"开始下载报告：{report_id}")
        kwargs = {'region_name': 'us-east-1', 'endpoint_url': "https://s3.amazonaws.com",
                  'aws_access_key_id': 'AKIARBAGHTGORIFN44VQ',
                  'aws_secret_access_key': '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'}
        s3_ = S3FileSystem(client_kwargs=kwargs)
        # print()
        with s3_.open(file_path, 'wb') as f:
            for data in resp.iter_content(chunk_size=10 * 1024):
                f.write(data)

        logger.info(f"报告{report_id}下载完成：{file_path}")
        if not decompress:
            return file_path
        with s3_.open(file_path, 'rb') as f:  # 读取s3数据
            data = gzip.GzipFile(fileobj=f, mode='rb')
            de_file = json.load(data)
        logger.info(f"解压完成：{de_file}")
        # print(de_file)
        return de_file

class Account(BaseClient):
    def get_portfolios(self):
        url_path = "/v2/portfolios/extended"
        return self._request(url_path)

    def iter_portfolios(self):
        yield from self.get_portfolios()




AccountClient = Account

if __name__ == '__main__':
    AWS_CREDENTIALS = {
        'lwa_client_id': 'amzn1.application-oa2-client.ebd701cd07854fb38c37ee49ec4ba109',
        'refresh_token': "Atzr|IwEBIL4ur8kbcwRyxVu_srprAAoTYzujnBvA6jU-0SMxkRgOhGjYJSUNGKvw24EQwJa1jG5RM76mQD2P22AKSq8qSD94LddoXGdKDO74eQVYl0RhuqOMFqdrEZpp1p4bIR6_N8VeSJDHr7UCuo8FiabkSHrkq7tsNvRP-yI-bnpQv4EayPBh7YwHVX3hYdRbhxaBvgJENgCuiEPb35Q2-Z6w6ujjiKUAK2VSbCFpENlEfcHNsjDeY7RCvFlwlCoHj1IeiNIaFTE9yXFu3aEWlExe3LzHv6PZyunEi88QJSXKSh56Um0e0eEg05rMv-VBM83cAqc5POmZnTP1vUdZO8fQv3NFLZ-xU6e1WQVxVPi5Cyqk4jYhGf1Y9t98N654y0tVvw74qNIsTrB-8bGS0Uhfe24oBEWmzObvBY3zhtT1d42myGUJv4pMTU6yPoS83zhPKm3LbUDEpBA1hvvc_09jHk7vUEAuFB-UAZzlht2C1yklzQ",
        'lwa_client_secret': 'cbf0514186db4df91e04a8905f0a91b605eae4201254ced879d8bb90df4b474d',
        'profile_id': "3006125408623189"
    }
    # sp = SPClient(**AWS_CREDENTIALS)
    # print(sp.get_keyword_bidrecommendation(
    # adGroupId="119753215871672",
    # keyword=["8mp security camera system","8mp security camera system"],
    # matchType=["broad","exact"]))

    sd = Account(**AWS_CREDENTIALS)
    print(sd.get_profilesInfo())

    # print(sb.get_keyword_bidrecommendation(**{'campaignId': 27333596383941, 'keywords': [
    #     {"matchType": 'broad', "keywordText": "4k security camera system"}]}))
    # a = list(sd.iter_targets(**{"campaignIdFilter":"257424912382921"})) #list(sd.iter_targets())#
    # print(a,len(a))

    # sb = SBClient(**AWS_CREDENTIALS)

    # print(sd.get_v2_report(record_type="campaigns",report_date="20231020",tactic="T00030",metrics=['impressions']))