tessl/pypi-google-ads

Client library for the Google Ads API providing comprehensive access to advertising management, reporting, and analytics capabilities.

—

Pending

Overview

Eval results

Files

Ad Management

Name: tessl/pypi-google-ads
Author: tessl

Comprehensive ad group and advertisement management including ad group creation, ad creation and modification, ad group targeting, and performance optimization at the ad level. The Google Ads API provides extensive capabilities for managing ads across all ad formats and advertising networks.

Capabilities

Ad Group Operations

Core ad group management operations for creating, updating, and managing ad groups within campaigns including targeting and bidding configurations.

def mutate_ad_groups(
    self,
    request: Optional[MutateAdGroupsRequest] = None,
    customer_id: Optional[str] = None,
    operations: Optional[Sequence[AdGroupOperation]] = None,
    partial_failure: bool = False,
    validate_only: bool = False,
    response_content_type: Optional[ResponseContentTypeEnum.ResponseContentType] = None
) -> MutateAdGroupsResponse:
    """
    Create, update, or remove ad groups.

    Args:
        request: The request object containing all parameters
        customer_id: Required customer ID for the account
        operations: List of ad group operations to perform
        partial_failure: Continue processing on individual failures
        validate_only: Validate operations without executing
        response_content_type: Type of response content to return

    Returns:
        MutateAdGroupsResponse with operation results
    """

def get_ad_group(
    self,
    request: Optional[GetAdGroupRequest] = None,
    resource_name: Optional[str] = None
) -> AdGroup:
    """
    Retrieve a single ad group by resource name.

    Args:
        request: The request object
        resource_name: Ad group resource name (customers/{customer_id}/adGroups/{ad_group_id})

    Returns:
        AdGroup resource object
    """

Ad Group Ad Operations

Advertisement management operations for creating and managing ads within ad groups including responsive search ads, expanded text ads, and display ads.

def mutate_ad_group_ads(
    self,
    request: Optional[MutateAdGroupAdsRequest] = None,
    customer_id: Optional[str] = None,
    operations: Optional[Sequence[AdGroupAdOperation]] = None,
    partial_failure: bool = False,
    validate_only: bool = False,
    response_content_type: Optional[ResponseContentTypeEnum.ResponseContentType] = None
) -> MutateAdGroupAdsResponse:
    """
    Create, update, or remove ads in ad groups.

    Args:
        request: The request object
        customer_id: Required customer ID
        operations: List of ad operations
        partial_failure: Continue on individual failures
        validate_only: Validate without executing
        response_content_type: Response content type

    Returns:
        MutateAdGroupAdsResponse with results
    """

def get_ad_group_ad(
    self,
    request: Optional[GetAdGroupAdRequest] = None,
    resource_name: Optional[str] = None
) -> AdGroupAd:
    """
    Retrieve an ad group ad by resource name.

    Args:
        request: The request object
        resource_name: Ad group ad resource name

    Returns:
        AdGroupAd resource object
    """

Ad Group Criterion Operations

Ad group level targeting and keyword management including keyword bidding, negative keywords, and audience targeting at the ad group level.

def mutate_ad_group_criteria(
    self,
    request: Optional[MutateAdGroupCriteriaRequest] = None,
    customer_id: Optional[str] = None,
    operations: Optional[Sequence[AdGroupCriterionOperation]] = None,
    partial_failure: bool = False,
    validate_only: bool = False,
    response_content_type: Optional[ResponseContentTypeEnum.ResponseContentType] = None
) -> MutateAdGroupCriteriaResponse:
    """
    Create, update, or remove ad group criteria.

    Args:
        request: The request object
        customer_id: Required customer ID
        operations: List of criterion operations
        partial_failure: Continue on individual failures
        validate_only: Validate without executing
        response_content_type: Response content type

    Returns:
        MutateAdGroupCriteriaResponse with results
    """

Ad Group Bid Modifier Operations

Bid modifier management for adjusting bids based on targeting criteria like device, location, and audience at the ad group level.

def mutate_ad_group_bid_modifiers(
    self,
    request: Optional[MutateAdGroupBidModifiersRequest] = None,
    customer_id: Optional[str] = None,
    operations: Optional[Sequence[AdGroupBidModifierOperation]] = None,
    partial_failure: bool = False,
    validate_only: bool = False,
    response_content_type: Optional[ResponseContentTypeEnum.ResponseContentType] = None
) -> MutateAdGroupBidModifiersResponse:
    """
    Create, update, or remove ad group bid modifiers.

    Args:
        request: The request object
        customer_id: Required customer ID
        operations: List of bid modifier operations
        partial_failure: Continue on individual failures
        validate_only: Validate without executing
        response_content_type: Response content type

    Returns:
        MutateAdGroupBidModifiersResponse with results
    """

Ad Group Creation Examples

Basic Search Ad Group

from google.ads.googleads.client import GoogleAdsClient
from google.ads.googleads.errors import GoogleAdsException

def create_search_ad_group(client, customer_id, campaign_resource_name, ad_group_name, cpc_bid_micros):
    """Create a search ad group with manual CPC bidding."""
    
    ad_group_service = client.get_service("AdGroupService")
    
    # Create ad group operation
    operation = client.get_type("AdGroupOperation")
    ad_group = operation.create
    ad_group.name = ad_group_name
    ad_group.campaign = campaign_resource_name
    ad_group.status = client.enums.AdGroupStatusEnum.ENABLED
    ad_group.type_ = client.enums.AdGroupTypeEnum.SEARCH_STANDARD
    ad_group.cpc_bid_micros = cpc_bid_micros
    
    try:
        response = ad_group_service.mutate_ad_groups(
            customer_id=customer_id,
            operations=[operation]
        )
        
        ad_group_resource_name = response.results[0].resource_name
        print(f"Created ad group: {ad_group_resource_name}")
        return ad_group_resource_name
        
    except GoogleAdsException as ex:
        print(f"Request failed with status {ex.error.code().name}")
        for error in ex.failure.errors:
            print(f"Error: {error.message}")
        return None

Shopping Ad Group

def create_shopping_ad_group(client, customer_id, campaign_resource_name, ad_group_name):
    """Create a shopping ad group for product listing ads."""
    
    ad_group_service = client.get_service("AdGroupService")
    
    operation = client.get_type("AdGroupOperation")
    ad_group = operation.create
    ad_group.name = ad_group_name
    ad_group.campaign = campaign_resource_name
    ad_group.status = client.enums.AdGroupStatusEnum.ENABLED
    ad_group.type_ = client.enums.AdGroupTypeEnum.SHOPPING_PRODUCT_ADS
    
    # Shopping ad groups use campaign-level bidding
    # No CPC bid set at ad group level
    
    response = ad_group_service.mutate_ad_groups(
        customer_id=customer_id,
        operations=[operation]
    )
    
    return response.results[0].resource_name

Display Ad Group

def create_display_ad_group(client, customer_id, campaign_resource_name, ad_group_name, cpm_bid_micros):
    """Create a display ad group with CPM bidding."""
    
    ad_group_service = client.get_service("AdGroupService")
    
    operation = client.get_type("AdGroupOperation")
    ad_group = operation.create
    ad_group.name = ad_group_name
    ad_group.campaign = campaign_resource_name
    ad_group.status = client.enums.AdGroupStatusEnum.ENABLED
    ad_group.type_ = client.enums.AdGroupTypeEnum.DISPLAY_STANDARD
    ad_group.cpm_bid_micros = cpm_bid_micros
    
    # Display settings
    ad_group.display_custom_bid_dimension = client.enums.TargetingDimensionEnum.AUDIENCE
    
    response = ad_group_service.mutate_ad_groups(
        customer_id=customer_id,
        operations=[operation]
    )
    
    return response.results[0].resource_name

Ad Creation Examples

Responsive Search Ad

def create_responsive_search_ad(client, customer_id, ad_group_resource_name, headlines, descriptions, final_urls):
    """Create a responsive search ad with multiple headlines and descriptions."""
    
    ad_group_ad_service = client.get_service("AdGroupAdService")
    
    # Create ad operation
    operation = client.get_type("AdGroupAdOperation")
    ad_group_ad = operation.create
    ad_group_ad.ad_group = ad_group_resource_name
    ad_group_ad.status = client.enums.AdGroupAdStatusEnum.ENABLED
    
    # Configure responsive search ad
    ad = ad_group_ad.ad
    ad.type_ = client.enums.AdTypeEnum.RESPONSIVE_SEARCH_AD
    ad.final_urls.extend(final_urls)
    
    # Add headlines (3-15 required)
    for i, headline_text in enumerate(headlines):
        headline = client.get_type("AdTextAsset")
        headline.text = headline_text
        if i < 3:  # Pin first 3 headlines to position 1
            headline.pinned_field = client.enums.ServedAssetFieldTypeEnum.HEADLINE_1
        ad.responsive_search_ad.headlines.append(headline)
    
    # Add descriptions (2-4 required)
    for description_text in descriptions:
        description = client.get_type("AdTextAsset")
        description.text = description_text
        ad.responsive_search_ad.descriptions.append(description)
    
    # Add path fields for display
    ad.responsive_search_ad.path1 = "shop"
    ad.responsive_search_ad.path2 = "deals"
    
    try:
        response = ad_group_ad_service.mutate_ad_group_ads(
            customer_id=customer_id,
            operations=[operation]
        )
        
        ad_resource_name = response.results[0].resource_name
        print(f"Created responsive search ad: {ad_resource_name}")
        return ad_resource_name
        
    except GoogleAdsException as ex:
        print(f"Request failed with status {ex.error.code().name}")
        for error in ex.failure.errors:
            print(f"Error: {error.message}")
        return None

# Example usage
headlines = [
    "High Quality Products",
    "Best Deals Online", 
    "Free Shipping Available",
    "Shop Now and Save",
    "Premium Quality Guaranteed"
]

descriptions = [
    "Discover amazing deals on high-quality products with fast, free shipping.",
    "Shop our wide selection of premium products at unbeatable prices."
]

final_urls = ["https://www.example.com"]

create_responsive_search_ad(client, customer_id, ad_group_resource_name, headlines, descriptions, final_urls)

Expanded Text Ad

def create_expanded_text_ad(client, customer_id, ad_group_resource_name, headline1, headline2, description, final_url):
    """Create an expanded text ad (legacy ad format)."""
    
    ad_group_ad_service = client.get_service("AdGroupAdService")
    
    operation = client.get_type("AdGroupAdOperation")
    ad_group_ad = operation.create
    ad_group_ad.ad_group = ad_group_resource_name
    ad_group_ad.status = client.enums.AdGroupAdStatusEnum.ENABLED
    
    # Configure expanded text ad
    ad = ad_group_ad.ad
    ad.type_ = client.enums.AdTypeEnum.EXPANDED_TEXT_AD
    ad.final_urls.append(final_url)
    
    ad.expanded_text_ad.headline_part1 = headline1
    ad.expanded_text_ad.headline_part2 = headline2
    ad.expanded_text_ad.description = description
    ad.expanded_text_ad.path1 = "products"
    ad.expanded_text_ad.path2 = "sale"
    
    response = ad_group_ad_service.mutate_ad_group_ads(
        customer_id=customer_id,
        operations=[operation]
    )
    
    return response.results[0].resource_name

Display Image Ad

def create_display_image_ad(client, customer_id, ad_group_resource_name, image_asset_resource_name, final_url):
    """Create a display image ad using an existing image asset."""
    
    ad_group_ad_service = client.get_service("AdGroupAdService")
    
    operation = client.get_type("AdGroupAdOperation")
    ad_group_ad = operation.create
    ad_group_ad.ad_group = ad_group_resource_name
    ad_group_ad.status = client.enums.AdGroupAdStatusEnum.ENABLED
    
    # Configure image ad
    ad = ad_group_ad.ad
    ad.type_ = client.enums.AdTypeEnum.IMAGE_AD
    ad.final_urls.append(final_url)
    
    ad.image_ad.image_asset = image_asset_resource_name
    ad.image_ad.name = "Display Image Ad"
    
    response = ad_group_ad_service.mutate_ad_group_ads(
        customer_id=customer_id,
        operations=[operation]
    )
    
    return response.results[0].resource_name

Keyword Management Examples

Add Keywords to Ad Group

def add_keywords_to_ad_group(client, customer_id, ad_group_resource_name, keywords_data):
    """Add keywords to an ad group with different match types and bids."""
    
    ad_group_criterion_service = client.get_service("AdGroupCriterionService")
    
    operations = []
    
    for keyword_data in keywords_data:
        operation = client.get_type("AdGroupCriterionOperation")
        criterion = operation.create
        criterion.ad_group = ad_group_resource_name
        criterion.status = client.enums.AdGroupCriterionStatusEnum.ENABLED
        criterion.type_ = client.enums.CriterionTypeEnum.KEYWORD
        
        # Set keyword details
        criterion.keyword.text = keyword_data['text']
        criterion.keyword.match_type = keyword_data['match_type']
        
        # Set keyword bid if provided
        if 'cpc_bid_micros' in keyword_data:
            criterion.cpc_bid_micros = keyword_data['cpc_bid_micros']
        
        # Set final URL override if provided
        if 'final_url' in keyword_data:
            criterion.final_urls.append(keyword_data['final_url'])
        
        operations.append(operation)
    
    try:
        response = ad_group_criterion_service.mutate_ad_group_criteria(
            customer_id=customer_id,
            operations=operations
        )
        
        print(f"Added {len(response.results)} keywords")
        return [result.resource_name for result in response.results]
        
    except GoogleAdsException as ex:
        print(f"Request failed with status {ex.error.code().name}")
        for error in ex.failure.errors:
            print(f"Error: {error.message}")
        return []

# Example usage
keywords_data = [
    {
        'text': 'running shoes',
        'match_type': client.enums.KeywordMatchTypeEnum.EXACT,
        'cpc_bid_micros': 2000000,  # $2.00 
        'final_url': 'https://www.example.com/running-shoes'
    },
    {
        'text': 'athletic footwear',
        'match_type': client.enums.KeywordMatchTypeEnum.PHRASE,
        'cpc_bid_micros': 1500000   # $1.50
    },
    {
        'text': 'sports shoes',
        'match_type': client.enums.KeywordMatchTypeEnum.BROAD,
        'cpc_bid_micros': 1000000   # $1.00
    }
]

add_keywords_to_ad_group(client, customer_id, ad_group_resource_name, keywords_data)

Add Negative Keywords

def add_negative_keywords(client, customer_id, ad_group_resource_name, negative_keywords):
    """Add negative keywords to an ad group."""
    
    ad_group_criterion_service = client.get_service("AdGroupCriterionService")
    
    operations = []
    
    for keyword_text in negative_keywords:
        operation = client.get_type("AdGroupCriterionOperation")
        criterion = operation.create
        criterion.ad_group = ad_group_resource_name
        criterion.negative = True  # Mark as negative
        criterion.type_ = client.enums.CriterionTypeEnum.KEYWORD
        
        criterion.keyword.text = keyword_text
        criterion.keyword.match_type = client.enums.KeywordMatchTypeEnum.BROAD
        
        operations.append(operation)
    
    response = ad_group_criterion_service.mutate_ad_group_criteria(
        customer_id=customer_id,
        operations=operations
    )
    
    return response.results

Ad Group Targeting Examples

Audience Targeting

def add_audience_targeting(client, customer_id, ad_group_resource_name, audience_resource_names):
    """Add audience targeting to an ad group."""
    
    ad_group_criterion_service = client.get_service("AdGroupCriterionService")
    
    operations = []
    
    for audience_resource_name in audience_resource_names:
        operation = client.get_type("AdGroupCriterionOperation")
        criterion = operation.create
        criterion.ad_group = ad_group_resource_name
        criterion.status = client.enums.AdGroupCriterionStatusEnum.ENABLED
        criterion.type_ = client.enums.CriterionTypeEnum.USER_LIST
        
        criterion.user_list.user_list = audience_resource_name
        
        operations.append(operation)
    
    response = ad_group_criterion_service.mutate_ad_group_criteria(
        customer_id=customer_id,
        operations=operations
    )
    
    return response.results

Demographics Targeting

def add_demographics_targeting(client, customer_id, ad_group_resource_name):
    """Add demographic targeting to an ad group."""
    
    ad_group_criterion_service = client.get_service("AdGroupCriterionService")
    
    operations = []
    
    # Add age range targeting
    age_operation = client.get_type("AdGroupCriterionOperation")
    age_criterion = age_operation.create
    age_criterion.ad_group = ad_group_resource_name
    age_criterion.status = client.enums.AdGroupCriterionStatusEnum.ENABLED
    age_criterion.type_ = client.enums.CriterionTypeEnum.AGE_RANGE
    age_criterion.age_range.type_ = client.enums.AgeRangeTypeEnum.AGE_RANGE_25_34
    age_criterion.bid_modifier = 1.2  # +20% bid adjustment
    operations.append(age_operation)
    
    # Add gender targeting  
    gender_operation = client.get_type("AdGroupCriterionOperation")
    gender_criterion = gender_operation.create
    gender_criterion.ad_group = ad_group_resource_name
    gender_criterion.status = client.enums.AdGroupCriterionStatusEnum.ENABLED
    gender_criterion.type_ = client.enums.CriterionTypeEnum.GENDER
    gender_criterion.gender.type_ = client.enums.GenderTypeEnum.FEMALE
    operations.append(gender_operation)
    
    response = ad_group_criterion_service.mutate_ad_group_criteria(
        customer_id=customer_id,
        operations=operations
    )
    
    return response.results

Types

# Core ad group types
class AdGroup:
    resource_name: str
    id: Optional[int]
    name: Optional[str]
    status: AdGroupStatusEnum.AdGroupStatus
    type_: AdGroupTypeEnum.AdGroupType
    ad_rotation_mode: AdGroupAdRotationModeEnum.AdGroupAdRotationMode
    tracking_url_template: Optional[str]
    url_custom_parameters: List[CustomParameter]
    campaign: Optional[str]
    cpc_bid_micros: Optional[int]
    effective_cpc_bid_micros: Optional[int]
    cpm_bid_micros: Optional[int]
    target_cpa_micros: Optional[int]
    cpv_bid_micros: Optional[int]
    target_cpm_micros: Optional[int]
    target_roas: Optional[float]
    percent_cpc_bid_micros: Optional[int]
    explorer_auto_optimizer_setting: ExplorerAutoOptimizerSetting
    display_custom_bid_dimension: TargetingDimensionEnum.TargetingDimension
    final_url_suffix: Optional[str]
    targeting_setting: TargetingSetting
    audience_setting: AudienceSetting
    effective_target_cpa_micros: Optional[int]
    effective_target_roas: Optional[float]
    labels: List[str]
    excluded_parent_asset_field_types: List[AssetFieldTypeEnum.AssetFieldType]
    excluded_parent_asset_set_types: List[AssetSetTypeEnum.AssetSetType]

class AdGroupAd:
    resource_name: str
    status: AdGroupAdStatusEnum.AdGroupAdStatus
    ad_group: Optional[str]
    ad: Ad
    policy_summary: PolicySummary
    ad_strength: AdStrengthEnum.AdStrength
    action_items: List[str]
    labels: List[str]

class Ad:
    resource_name: str
    id: Optional[int]
    final_urls: List[str]
    final_app_urls: List[FinalAppUrl]
    final_mobile_urls: List[str]
    tracking_url_template: Optional[str]
    final_url_suffix: Optional[str]
    url_custom_parameters: List[CustomParameter]
    display_url: Optional[str]
    type_: AdTypeEnum.AdType
    added_by_google_ads: Optional[bool]
    device_preference: DeviceEnum.Device
    url_collections: List[UrlCollection]
    name: Optional[str]
    system_managed_resource_source: SystemManagedResourceSourceEnum.SystemManagedResourceSource
    
    # Ad types (one of the following)
    text_ad: TextAdInfo
    expanded_text_ad: ExpandedTextAdInfo
    call_ad: CallAdInfo
    expanded_dynamic_search_ad: ExpandedDynamicSearchAdInfo
    hotel_ad: HotelAdInfo
    shopping_smart_ad: ShoppingSmartAdInfo
    shopping_product_ad: ShoppingProductAdInfo
    image_ad: ImageAdInfo
    video_ad: VideoAdInfo
    responsive_search_ad: ResponsiveSearchAdInfo
    legacy_responsive_display_ad: LegacyResponsiveDisplayAdInfo
    app_ad: AppAdInfo
    legacy_app_install_ad: LegacyAppInstallAdInfo
    responsive_display_ad: ResponsiveDisplayAdInfo
    local_ad: LocalAdInfo
    display_upload_ad: DisplayUploadAdInfo
    app_engagement_ad: AppEngagementAdInfo
    shopping_comparison_listing_ad: ShoppingComparisonListingAdInfo
    video_responsive_ad: VideoResponsiveAdInfo
    video_bumper_ad: VideoBumperAdInfo
    video_non_skippable_in_stream_ad: VideoNonSkippableInStreamAdInfo
    video_true_view_in_stream_ad: VideoTrueViewInStreamAdInfo
    video_true_view_discovery_ad: VideoTrueViewDiscoveryAdInfo
    video_outstream_ad: VideoOutstreamAdInfo
    video_true_view_for_action_ad: VideoTrueViewForActionAdInfo
    smart_campaign_ad: SmartCampaignAdInfo
    call_only_ad: CallOnlyAdInfo
    discovery_multi_asset_ad: DiscoveryMultiAssetAdInfo
    discovery_carousel_ad: DiscoveryCarouselAdInfo
    travel_ad: TravelAdInfo
    discovery_video_responsive_ad: DiscoveryVideoResponsiveAdInfo

class AdGroupCriterion:
    resource_name: str
    criterion_id: Optional[int]
    status: AdGroupCriterionStatusEnum.AdGroupCriterionStatus
    quality_info: QualityInfo
    ad_group: Optional[str]
    type_: CriterionTypeEnum.CriterionType
    negative: Optional[bool]
    system_serving_status: CriterionSystemServingStatusEnum.CriterionSystemServingStatus
    approval_status: AdGroupCriterionApprovalStatusEnum.AdGroupCriterionApprovalStatus
    disapproval_reasons: List[str]
    labels: List[str]
    bid_modifier: Optional[float]
    cpc_bid_micros: Optional[int]
    cpm_bid_micros: Optional[int]
    cpv_bid_micros: Optional[int]
    percent_cpc_bid_micros: Optional[int]
    effective_cpc_bid_micros: Optional[int]
    effective_cpm_bid_micros: Optional[int]
    effective_cpv_bid_micros: Optional[int]
    effective_percent_cpc_bid_micros: Optional[int]
    effective_cpc_bid_source: BiddingSourceEnum.BiddingSource
    effective_cpm_bid_source: BiddingSourceEnum.BiddingSource
    effective_cpv_bid_source: BiddingSourceEnum.BiddingSource
    effective_percent_cpc_bid_source: BiddingSourceEnum.BiddingSource
    final_urls: List[str]
    final_mobile_urls: List[str]
    final_url_suffix: Optional[str]
    tracking_url_template: Optional[str]
    url_custom_parameters: List[CustomParameter]
    position_estimates: KeywordPositionEstimates
    
    # Criterion types (same as CampaignCriterion)
    keyword: KeywordInfo
    placement: PlacementInfo
    mobile_app_category: MobileAppCategoryInfo
    mobile_application: MobileApplicationInfo
    location: LocationInfo
    device: DeviceInfo
    ad_schedule: AdScheduleInfo
    age_range: AgeRangeInfo
    gender: GenderInfo
    income_range: IncomeRangeInfo
    parental_status: ParentalStatusInfo
    user_list: UserListInfo
    youtube_video: YouTubeVideoInfo
    youtube_channel: YouTubeChannelInfo
    topic: TopicInfo
    user_interest: UserInterestInfo
    webpage: WebpageInfo
    app_payment_model: AppPaymentModelInfo
    custom_affinity: CustomAffinityInfo
    custom_intent: CustomIntentInfo
    custom_audience: CustomAudienceInfo
    combined_audience: CombinedAudienceInfo
    listing_group: ListingGroupInfo

# Specific ad type info classes
class ResponsiveSearchAdInfo:
    headlines: List[AdTextAsset]
    descriptions: List[AdTextAsset]
    path1: Optional[str]
    path2: Optional[str]

class ExpandedTextAdInfo:
    headline_part1: Optional[str]
    headline_part2: Optional[str]
    headline_part3: Optional[str]
    description: Optional[str]
    description2: Optional[str]
    path1: Optional[str]
    path2: Optional[str]

class ImageAdInfo:
    pixel_width: Optional[int]
    pixel_height: Optional[int]
    image_url: Optional[str]
    preview_pixel_width: Optional[int]
    preview_pixel_height: Optional[int]
    preview_image_url: Optional[str]
    mime_type: MimeTypeEnum.MimeType
    name: Optional[str]
    image_asset: Optional[str]

class AdTextAsset:
    text: Optional[str]
    pinned_field: ServedAssetFieldTypeEnum.ServedAssetFieldType
    asset_performance_label: AssetPerformanceLabelEnum.AssetPerformanceLabel

# Operation types
class AdGroupOperation:
    update_mask: FieldMask
    create: AdGroup
    update: AdGroup
    remove: str

class AdGroupAdOperation:
    update_mask: FieldMask
    create: AdGroupAd
    update: AdGroupAd
    remove: str

class AdGroupCriterionOperation:
    update_mask: FieldMask
    create: AdGroupCriterion
    update: AdGroupCriterion
    remove: str

class AdGroupBidModifierOperation:
    update_mask: FieldMask
    create: AdGroupBidModifier
    update: AdGroupBidModifier
    remove: str

# Response types
class MutateAdGroupsResponse:
    partial_failure_error: Status
    results: List[MutateAdGroupResult]

class MutateAdGroupResult:
    resource_name: str
    ad_group: AdGroup

class MutateAdGroupAdsResponse:
    partial_failure_error: Status
    results: List[MutateAdGroupAdResult]

class MutateAdGroupAdResult:
    resource_name: str
    ad_group_ad: AdGroupAd

class MutateAdGroupCriteriaResponse:
    partial_failure_error: Status
    results: List[MutateAdGroupCriterionResult]

class MutateAdGroupCriterionResult:
    resource_name: str
    ad_group_criterion: AdGroupCriterion

Install with Tessl CLI