criteo / criteo-python-marketing-sdk Goto Github PK

import re
import sys
import criteo_marketing as cm
from criteo_marketing import Configuration

GRANT_TYPE = {'client_id': '##############',
               'client_secret':  '#########'}

configuration = Configuration(username='mail_address', password='password')

client = cm.ApiClient(configuration)

auth_api = cm.AuthenticationApi(client)
auth_response = auth_api.o_auth2_token_post(client_id=client.configuration.username,
                                                client_secret=client.configuration.password,
                                                grant_type=GRANT_TYPE)
token = auth_response.token_type + " " + auth_response.access_token

stats_api = cm.StatisticsApi(client)
stats_query_message = cm.StatsQueryMessageEx(
        report_type="CampaignPerformance",
        dimensions=["CampaignId"],
        metrics=["Clicks"],
        start_date="2020-01-01",
        end_date="2020-06-30",
        format="Csv")

    # Use the method with 'with_http_info' if you want to retrieve the filename
    # Otherwise, you can directly call the get_stats method and write the return value to a file
[response_content, http_code, response_headers] = stats_api.get_stats_with_http_info(token, stats_query_message)
if 200 == http_code:
    content_disposition = response_headers["Content-Disposition"]
    if content_disposition:
        filename = re.search(r'filename=[\'"]?([^\'"\s]+)[\'"]?', content_disposition).group(1)

            # $> file Extract_20190101_20190131.csv
            # Extract_20190101_20190131.csv: UTF-8 Unicode (with BOM) text, with CRLF line terminators
        with open(filename, "w+") as f:
            f.write(response_content)

---------------------------------------------------------------------------
ApiException                              Traceback (most recent call last)
 in 
     14 auth_response = auth_api.o_auth2_token_post(client_id=client.configuration.username,
     15                                                 client_secret=client.configuration.password,
---> 16                                                 grant_type=GRANT_TYPE)
     17 token = auth_response.token_type + " " + auth_response.access_token
     18 

/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/criteo_marketing/api/authentication_api.py in o_auth2_token_post(self, **kwargs)
     62         """
     63         kwargs['_return_http_data_only'] = True
---> 64         return self.o_auth2_token_post_with_http_info(**kwargs)  # noqa: E501
     65 
     66     def o_auth2_token_post_with_http_info(self, **kwargs):  # noqa: E501

/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/criteo_marketing/api/authentication_api.py in o_auth2_token_post_with_http_info(self, **kwargs)
    151             _preload_content=local_var_params.get('_preload_content', True),
    152             _request_timeout=local_var_params.get('_request_timeout'),
--> 153             collection_formats=collection_formats)

/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/criteo_marketing/api_client.py in call_api(self, resource_path, method, path_params, query_params, header_params, body, post_params, files, response_type, auth_settings, async_req, _return_http_data_only, collection_formats, _preload_content, _request_timeout, _host)
    339                                    response_type, auth_settings,
    340                                    _return_http_data_only, collection_formats,
--> 341                                    _preload_content, _request_timeout, _host)
    342         else:
    343             thread = self.pool.apply_async(self.__call_api, (resource_path,

/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/criteo_marketing/api_client.py in __call_api(self, resource_path, method, path_params, query_params, header_params, body, post_params, files, response_type, auth_settings, _return_http_data_only, collection_formats, _preload_content, _request_timeout, _host)
    170             post_params=post_params, body=body,
    171             _preload_content=_preload_content,
--> 172             _request_timeout=_request_timeout)
    173 
    174         self.last_response = response_data

/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/criteo_marketing/api_client.py in request(self, method, url, query_params, headers, post_params, body, _preload_content, _request_timeout)
    384                                          _preload_content=_preload_content,
    385                                          _request_timeout=_request_timeout,
--> 386                                          body=body)
    387         elif method == "PUT":
    388             return self.rest_client.PUT(url,

/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/criteo_marketing/rest.py in POST(self, url, headers, query_params, post_params, body, _preload_content, _request_timeout)
    284                             _preload_content=_preload_content,
    285                             _request_timeout=_request_timeout,
--> 286                             body=body)
    287 
    288     def PUT(self, url, headers=None, query_params=None, post_params=None,

/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/criteo_marketing/rest.py in request(self, method, url, query_params, headers, body, post_params, _preload_content, _request_timeout)
    237 
    238         if not 200 <= r.status <= 299:
--> 239             raise ApiException(http_resp=r)
    240 
    241         return r

ApiException: (400)
Reason: Bad Request
HTTP response headers: HTTPHeaderDict({'cache-control': 'no-cache', 'pragma': 'no-cache', 'content-length': '92', 'content-type': 'application/json;charset=UTF-8', 'expires': '-1', 'server': 'Microsoft-IIS/10.0', 'x-aspnet-version': '4.0.30319', 'x-powered-by': 'ASP.NET', 'date': 'Mon, 06 Jul 2020 13:06:09 GMT'})
HTTP response body: {"error":"invalid_grant","error_description":"The client_id or client_secret is incorrect."}

api_instance = criteo_marketing.AuthenticationApi()
api_response = api_instance.o_auth2_token_post(client_id=client_id, client_secret=client_secret, grant_type=grant_type)
authorization = "Bearer {}".format(api_response.access_token)
api_instance = criteo_marketing.StatisticsApi()
stats_query_message_ex = criteo_marketing.StatsQueryMessageEx(
        report_type="CampaignPerformance"
        , dimensions=["CampaignId"]
        , metrics=["Clicks"]
        , start_date="2019-01-01"
        , end_date="2019-01-09"
        , format="Csv")
api_instance.get_stats(authorization , stats_query_message_ex)
**in _refresh_token
    raise ValueError('client_id (username) is missing')
ValueError: client_id (username) is missing**

from __future__ import print_function
import time
import criteo_marketing
from criteo_marketing.rest import ApiException
from pprint import pprint
import json
import re


class CriteoApiHk(object):

    def __init__(self):
        # breakpoint()
        with open('auth/criteo.json','r') as authfile:
            self.auth = json.load(authfile)

        self.get_token()
        self.get_camp_data()
        self.criteo_stats()
        self.criteo_stats_2()


    def get_token(self):
        # breakpoint()
        api_instance = criteo_marketing.AuthenticationApi()
        try:
            self.auth_api_response = api_instance.o_auth2_token_post(client_id=self.auth.get("me").get("client_id"), 
                                                                        client_secret= self.auth.get("me").get("client_secret"),
                                                                        grant_type='client_credentials')
        except ApiException as e:
            print("Exception when calling AuthenticationApi->o_auth2_token_post: %s\n" % e)
        

    def get_camp_data(self):
        # breakpoint()
        #config
        configuration = criteo_marketing.Configuration()
        configuration.host = self.auth.get("host_add")

        #api
        api_instance = criteo_marketing.AdvertisersApi(criteo_marketing.ApiClient(configuration))
        advertiser_id = self.auth.get("advts_id")  
        authorization = 'Bearer {0}'.format(self.auth_api_response.to_dict().get("access_token"))

        try:
            api_response = api_instance.get_campaigns(advertiser_id, authorization)
        except ApiException as e:
            print("Exception when calling AdvertisersApi->get_campaigns: %s\n" % e)

        breakpoint()

        serialized = [camp.to_dict() for camp in api_response]
        result = {"api":serialized}

        with open('data.json', 'w') as output:
            json.dump(result, output, indent=4)


    def criteo_stats(self):
        configuration = criteo_marketing.Configuration()
        configuration.host = self.auth.get("host_add")

        #api
        api_instance = criteo_marketing.SellersV2StatsApi(criteo_marketing.ApiClient(configuration)) 
        authorization = 'Bearer {0}'.format(self.auth_api_response.to_dict().get("access_token"))

        #vars
        start_date = '2020-05-18'
        end_date = '2020-05-19'
        count = 56


        try:
            # Get stats by seller-campaign.
            api_response = api_instance.seller_campaigns(authorization, 
                                                            start_date=start_date, 
                                                            end_date=end_date, 
                                                            count=count)
            pprint(api_response)
        except ApiException as e:
            print("Exception when calling SellersV2StatsApi->seller_campaigns: %s\n" % e)


    def criteo_stats_2(self):
        # breakpoint()
        token = 'Bearer ' + self.auth_api_response.to_dict().get("access_token")

        configuration = criteo_marketing.Configuration()
        configuration.host = self.auth.get("host_add")

        stats_api = criteo_marketing.StatisticsApi(criteo_marketing.ApiClient(configuration))
        stats_query_message = criteo_marketing.StatsQueryMessageEx(
                                                                    report_type="CampaignPerformance",
                                                                    dimensions=["CampaignId"],
                                                                    metrics=["ConversionRate"],
                                                                    start_date="2020-05-01",
                                                                    end_date="2020-05-31",
                                                                    format="json"
        )

        # Use the method with 'with_http_info' if you want to retrieve the filename
        # Otherwise, you can directly call the get_stats method and write the return value to a file
        
        [response_content, http_code, response_headers] = stats_api.get_stats_with_http_info(token, stats_query_message)
        breakpoint()
        if 200 == http_code:
            content_disposition = response_headers["Content-Disposition"]
            if content_disposition:
                filename = re.search(r'filename=[\'"]?([^\'"\s]+)[\'"]?', content_disposition).group(1)

                # $> file Extract_20190101_20190131.csv
                # Extract_20190101_20190131.csv: UTF-8 Unicode (with BOM) text, with CRLF line terminators
                with open(filename, "w+") as f:
                    f.write(response_content)

if __name__ == "__main__":
    CriteoApiHk()

import criteo_marketing as cm
from criteo_marketing import Configuration
import json
from datetime import date
configuration = Configuration(username=" user_name", password="pass_word")
client = cm.ApiClient(configuration)
auth_api = cm.AuthenticationApi(client)
auth_response = auth_api.o_auth2_token_post(client_id=client.configuration.username,client_secret=client.configuration.password,grant_type="client_credentials")
token = auth_response.token_type + " " + auth_response.access_token


today = date.today().strftime("%Y-%m-%d")

stats_api = cm.StatisticsApi(client)
stats_query_message = cm.StatsQueryMessageEx(dimensions=["Hour"],
            metrics=["AdvertiserCost"],
            start_date="2018-07-10",
            end_date=today,
            currency="TRY",
            format="json")
[response_content, http_code, response_headers]=stats_api.get_stats_with_http_info(token, stats_query_message)
response_content=response_content.replace('\ufeff', '')
json1_data = json.loads(response_content)['Rows']
json1_data 

---------------------------------------------------------------------------
ApiException                              Traceback (most recent call last)
<ipython-input-27-4024c70d078d> in <module>
     19             currency="TRY",
     20             format="json")
---> 21 [response_content, http_code, response_headers]=stats_api.get_stats_with_http_info(token, stats_query_message)
     22 response_content=response_content.replace('\ufeff', '')
     23 json1_data = json.loads(response_content)['Rows']

/usr/local/lib/python3.8/site-packages/criteo_marketing/api/statistics_api.py in get_stats_with_http_info(self, authorization, stats_query, **kwargs)
    261         auth_settings = ['Authorization']  # noqa: E501
    262 
--> 263         return self.api_client.call_api(
    264             '/v1/statistics', 'POST',
    265             path_params,

/usr/local/lib/python3.8/site-packages/criteo_marketing/api_client.py in call_api(self, resource_path, method, path_params, query_params, header_params, body, post_params, files, response_type, auth_settings, async_req, _return_http_data_only, collection_formats, _preload_content, _request_timeout, _host)
    334         """
    335         if not async_req:
--> 336             return self.__call_api(resource_path, method,
    337                                    path_params, query_params, header_params,
    338                                    body, post_params, files,

/usr/local/lib/python3.8/site-packages/criteo_marketing/api_client.py in __call_api(self, resource_path, method, path_params, query_params, header_params, body, post_params, files, response_type, auth_settings, _return_http_data_only, collection_formats, _preload_content, _request_timeout, _host)
    166 
    167         # perform request and return response
--> 168         response_data = self.request(
    169             method, url, query_params=query_params, headers=header_params,
    170             post_params=post_params, body=body,

/usr/local/lib/python3.8/site-packages/criteo_marketing/api_client.py in request(self, method, url, query_params, headers, post_params, body, _preload_content, _request_timeout)
    378                                             body=body)
    379         elif method == "POST":
--> 380             return self.rest_client.POST(url,
    381                                          query_params=query_params,
    382                                          headers=headers,

/usr/local/lib/python3.8/site-packages/criteo_marketing/rest.py in POST(self, url, headers, query_params, post_params, body, _preload_content, _request_timeout)
    278     def POST(self, url, headers=None, query_params=None, post_params=None,
    279              body=None, _preload_content=True, _request_timeout=None):
--> 280         return self.request("POST", url,
    281                             headers=headers,
    282                             query_params=query_params,

/usr/local/lib/python3.8/site-packages/criteo_marketing/rest.py in request(self, method, url, query_params, headers, body, post_params, _preload_content, _request_timeout)
    237 
    238         if not 200 <= r.status <= 299:
--> 239             raise ApiException(http_resp=r)
    240 
    241         return r

ApiException: (400)
Reason: Bad Request
HTTP response headers: HTTPHeaderDict({'cache-control': 'private', 'content-length': '68', 'content-type': 'application/json; charset=utf-8', 'x-aspnet-version': '4.0.30319', 'date': 'Tue, 18 Aug 2020 06:59:55 GMT'})
HTTP response body: {"message":"The requested dimensions combination is not supported."}

def get_adset_report(self, start_date: str, end_date: str, metrics: List[str], dimensions: List[str], currency: str= 'USD') -> Result:
    """
    Calls the statistics/report endpoint, constructing a StatisticsReportQueryMessage based on the args passed

    Args:
        start_date (str): Start Date of the report
        end_date (str): End Date of the report
        metrics (List[str]): List of metrics for the report to return
        dimensions (List[str]): List of dimensions for the report to return
        currency (str): Currency code to use for values in report

    Returns:
        result (Result): result from the API call
    """
    result = Result(Status.error, '', [])
    query_message = StatisticsReportQueryMessage(
        dimensions=dimensions,
        metrics=metrics,
        start_date=datetime.strptime(start_date, '%Y-%m-%d'),
        end_date=datetime.strptime(end_date, '%Y-%m-%d'),
        currency=currency,
        format='json'
    )
    try:
        # [response_content, http_code, response_headers] = self._analytics_api.get_adset_report(query_message)
        response = self._analytics_api.get_adset_report(statistics_report_query_message=query_message)
        # decoded_data = response.encode().decode('utf-8-sig')

        result.status = Status.success
        # result.data = json.loads(decoded_data)['Rows']
        result.data = response['Rows']
        result.message = f'Fetched {len(result.data)} results from Criteo API!'
    except criteo_api_marketingsolutions_v2022_07.ApiException as e:
        print("Exception when calling AnalyticsApi->get_adset_report: %s\n" % e)
        result.message = f'Exception getting campaign report from Criteo API: {str(e)}'
    return result