diff --git a/.release-please-manifest.json b/.release-please-manifest.json index caf1487..de0960a 100644 --- a/.release-please-manifest.json +++ b/.release-please-manifest.json @@ -1,3 +1,3 @@ { - ".": "1.11.0" + ".": "1.12.0" } \ No newline at end of file diff --git a/.stats.yml b/.stats.yml index 8e1aa70..56c8a72 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ -configured_endpoints: 9 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/brand-dev%2Fbrand.dev-a41dc66f0aa3dbc9e8fe1da75f1101cbcb2fac79f728de42e4877cfe1bde3b6e.yml -openapi_spec_hash: 63c1a53e0899fb63a514dad395fd48f9 -config_hash: 4b10254ea5b8e26ce632222b94a918aa +configured_endpoints: 8 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/brand-dev%2Fbrand.dev-0758a435064bd016fe211989cb7f6a3441460664aead5870777f8a662aa69794.yml +openapi_spec_hash: d646572eb126d1d18327240959fc96af +config_hash: a7a306a1c85eef178e7989e0ce5979c6 diff --git a/CHANGELOG.md b/CHANGELOG.md index bcf33fb..75d7513 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,5 +1,23 @@ # Changelog +## 1.12.0 (2025-08-19) + +Full Changelog: [v1.11.0...v1.12.0](https://github.com/brand-dot-dev/python-sdk/compare/v1.11.0...v1.12.0) + +### Features + +* **api:** api update ([f91ea74](https://github.com/brand-dot-dev/python-sdk/commit/f91ea744a88f266bc754d3225fbeb90e01d8c759)) +* **api:** api update ([ed3e4c7](https://github.com/brand-dot-dev/python-sdk/commit/ed3e4c7f6f4d0e23f1879959ac1cc534454ff8d8)) +* **api:** api update ([eb66567](https://github.com/brand-dot-dev/python-sdk/commit/eb66567eee137fe637b6629a0113b3af26eae9e9)) + + +### Chores + +* **internal:** codegen related update ([2b591ec](https://github.com/brand-dot-dev/python-sdk/commit/2b591ec1951445ed47e3c7d5e2f129e04133b42e)) +* **internal:** fix ruff target version ([8674d17](https://github.com/brand-dot-dev/python-sdk/commit/8674d1739383a872081dbc40b3726572654a5800)) +* **internal:** update comment in script ([59767cf](https://github.com/brand-dot-dev/python-sdk/commit/59767cfff3a11d740c30d764b566730551b1e259)) +* update @stainless-api/prism-cli to v5.15.0 ([c3e909c](https://github.com/brand-dot-dev/python-sdk/commit/c3e909c65e6d21d669321ac53dbb7ac84a5d9afc)) + ## 1.11.0 (2025-07-31) Full Changelog: [v1.10.1...v1.11.0](https://github.com/brand-dot-dev/python-sdk/compare/v1.10.1...v1.11.0) diff --git a/api.md b/api.md index ef7c6cc..4c1102e 100644 --- a/api.md +++ b/api.md @@ -8,7 +8,6 @@ from brand.dev.types import ( BrandAIQueryResponse, BrandIdentifyFromTransactionResponse, BrandPrefetchResponse, - BrandRetrieveByTickerResponse, BrandRetrieveNaicsResponse, BrandRetrieveSimplifiedResponse, BrandScreenshotResponse, @@ -22,7 +21,6 @@ Methods: - client.brand.ai_query(\*\*params) -> BrandAIQueryResponse - client.brand.identify_from_transaction(\*\*params) -> BrandIdentifyFromTransactionResponse - client.brand.prefetch(\*\*params) -> BrandPrefetchResponse -- client.brand.retrieve_by_ticker(\*\*params) -> BrandRetrieveByTickerResponse - client.brand.retrieve_naics(\*\*params) -> BrandRetrieveNaicsResponse - client.brand.retrieve_simplified(\*\*params) -> BrandRetrieveSimplifiedResponse - client.brand.screenshot(\*\*params) -> BrandScreenshotResponse diff --git a/pyproject.toml b/pyproject.toml index 2fa0621..1e84b49 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -1,6 +1,6 @@ [project] name = "brand.dev" -version = "1.11.0" +version = "1.12.0" description = "The official Python library for the brand.dev API" dynamic = ["readme"] license = "Apache-2.0" @@ -159,7 +159,7 @@ reportPrivateUsage = false [tool.ruff] line-length = 120 output-format = "grouped" -target-version = "py37" +target-version = "py38" [tool.ruff.format] docstring-code-format = true diff --git a/scripts/mock b/scripts/mock index d2814ae..0b28f6e 100755 --- a/scripts/mock +++ b/scripts/mock @@ -21,7 +21,7 @@ echo "==> Starting mock server with URL ${URL}" # Run prism mock on the given spec if [ "$1" == "--daemon" ]; then - npm exec --package=@stainless-api/prism-cli@5.8.5 -- prism mock "$URL" &> .prism.log & + npm exec --package=@stainless-api/prism-cli@5.15.0 -- prism mock "$URL" &> .prism.log & # Wait for server to come online echo -n "Waiting for server" @@ -37,5 +37,5 @@ if [ "$1" == "--daemon" ]; then echo else - npm exec --package=@stainless-api/prism-cli@5.8.5 -- prism mock "$URL" + npm exec --package=@stainless-api/prism-cli@5.15.0 -- prism mock "$URL" fi diff --git a/scripts/test b/scripts/test index 2b87845..dbeda2d 100755 --- a/scripts/test +++ b/scripts/test @@ -43,7 +43,7 @@ elif ! prism_is_running ; then echo -e "To run the server, pass in the path or url of your OpenAPI" echo -e "spec to the prism command:" echo - echo -e " \$ ${YELLOW}npm exec --package=@stoplight/prism-cli@~5.3.2 -- prism mock path/to/your.openapi.yml${NC}" + echo -e " \$ ${YELLOW}npm exec --package=@stainless-api/prism-cli@5.15.0 -- prism mock path/to/your.openapi.yml${NC}" echo exit 1 diff --git a/src/brand/dev/_version.py b/src/brand/dev/_version.py index 641ac2a..d9b854c 100644 --- a/src/brand/dev/_version.py +++ b/src/brand/dev/_version.py @@ -1,4 +1,4 @@ # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. __title__ = "brand.dev" -__version__ = "1.11.0" # x-release-please-version +__version__ = "1.12.0" # x-release-please-version diff --git a/src/brand/dev/resources/brand.py b/src/brand/dev/resources/brand.py index 58a3116..2cee6bb 100644 --- a/src/brand/dev/resources/brand.py +++ b/src/brand/dev/resources/brand.py @@ -14,7 +14,6 @@ brand_screenshot_params, brand_styleguide_params, brand_retrieve_naics_params, - brand_retrieve_by_ticker_params, brand_retrieve_simplified_params, brand_identify_from_transaction_params, ) @@ -35,7 +34,6 @@ from ..types.brand_screenshot_response import BrandScreenshotResponse from ..types.brand_styleguide_response import BrandStyleguideResponse from ..types.brand_retrieve_naics_response import BrandRetrieveNaicsResponse -from ..types.brand_retrieve_by_ticker_response import BrandRetrieveByTickerResponse from ..types.brand_retrieve_simplified_response import BrandRetrieveSimplifiedResponse from ..types.brand_identify_from_transaction_response import BrandIdentifyFromTransactionResponse @@ -65,7 +63,7 @@ def with_streaming_response(self) -> BrandResourceWithStreamingResponse: def retrieve( self, *, - domain: str, + domain: str | NotGiven = NOT_GIVEN, force_language: Literal[ "albanian", "arabic", @@ -122,6 +120,8 @@ def retrieve( ] | NotGiven = NOT_GIVEN, max_speed: bool | NotGiven = NOT_GIVEN, + name: str | NotGiven = NOT_GIVEN, + ticker: str | NotGiven = NOT_GIVEN, timeout_ms: int | NotGiven = NOT_GIVEN, # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs. # The extra values given here take precedence over values defined on the client or passed to this method. @@ -131,16 +131,27 @@ def retrieve( timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, ) -> BrandRetrieveResponse: """ - Retrieve brand data by domain + Retrieve brand information using one of three methods: domain name, company + name, or stock ticker symbol. Exactly one of these parameters must be provided. Args: - domain: Domain name to retrieve brand data for + domain: Domain name to retrieve brand data for (e.g., 'example.com', 'google.com'). + Cannot be used with name or ticker parameters. - force_language: Optional parameter to force the language of the retrieved brand data + force_language: Optional parameter to force the language of the retrieved brand data. Works with + all three lookup methods. max_speed: Optional parameter to optimize the API call for maximum speed. When set to true, the API will skip time-consuming operations for faster response at the cost of - less comprehensive data. + less comprehensive data. Works with all three lookup methods. + + name: Company name to retrieve brand data for (e.g., 'Apple Inc', 'Microsoft + Corporation'). Must be 3-30 characters. Cannot be used with domain or ticker + parameters. + + ticker: Stock ticker symbol to retrieve brand data for (e.g., 'AAPL', 'GOOGL', 'BRK.A'). + Must be 1-6 characters, letters/numbers/dots only. Cannot be used with domain or + name parameters. timeout_ms: Optional timeout in milliseconds for the request. If the request takes longer than this value, it will be aborted with a 408 status code. Maximum allowed @@ -166,6 +177,8 @@ def retrieve( "domain": domain, "force_language": force_language, "max_speed": max_speed, + "name": name, + "ticker": ticker, "timeout_ms": timeout_ms, }, brand_retrieve_params.BrandRetrieveParams, @@ -327,55 +340,6 @@ def prefetch( cast_to=BrandPrefetchResponse, ) - def retrieve_by_ticker( - self, - *, - ticker: str, - timeout_ms: int | NotGiven = NOT_GIVEN, - # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs. - # The extra values given here take precedence over values defined on the client or passed to this method. - extra_headers: Headers | None = None, - extra_query: Query | None = None, - extra_body: Body | None = None, - timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> BrandRetrieveByTickerResponse: - """Retrieve brand data by stock ticker (e.g. - - AAPL, TSLA, etc.) - - Args: - ticker: Stock ticker symbol to retrieve brand data for (e.g. AAPL, TSLA, etc.) - - timeout_ms: Optional timeout in milliseconds for the request. If the request takes longer - than this value, it will be aborted with a 408 status code. Maximum allowed - value is 300000ms (5 minutes). - - extra_headers: Send extra headers - - extra_query: Add additional query parameters to the request - - extra_body: Add additional JSON properties to the request - - timeout: Override the client-level default timeout for this request, in seconds - """ - return self._get( - "/brand/retrieve-by-ticker", - options=make_request_options( - extra_headers=extra_headers, - extra_query=extra_query, - extra_body=extra_body, - timeout=timeout, - query=maybe_transform( - { - "ticker": ticker, - "timeout_ms": timeout_ms, - }, - brand_retrieve_by_ticker_params.BrandRetrieveByTickerParams, - ), - ), - cast_to=BrandRetrieveByTickerResponse, - ) - def retrieve_naics( self, *, @@ -603,7 +567,7 @@ def with_streaming_response(self) -> AsyncBrandResourceWithStreamingResponse: async def retrieve( self, *, - domain: str, + domain: str | NotGiven = NOT_GIVEN, force_language: Literal[ "albanian", "arabic", @@ -660,6 +624,8 @@ async def retrieve( ] | NotGiven = NOT_GIVEN, max_speed: bool | NotGiven = NOT_GIVEN, + name: str | NotGiven = NOT_GIVEN, + ticker: str | NotGiven = NOT_GIVEN, timeout_ms: int | NotGiven = NOT_GIVEN, # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs. # The extra values given here take precedence over values defined on the client or passed to this method. @@ -669,16 +635,27 @@ async def retrieve( timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, ) -> BrandRetrieveResponse: """ - Retrieve brand data by domain + Retrieve brand information using one of three methods: domain name, company + name, or stock ticker symbol. Exactly one of these parameters must be provided. Args: - domain: Domain name to retrieve brand data for + domain: Domain name to retrieve brand data for (e.g., 'example.com', 'google.com'). + Cannot be used with name or ticker parameters. - force_language: Optional parameter to force the language of the retrieved brand data + force_language: Optional parameter to force the language of the retrieved brand data. Works with + all three lookup methods. max_speed: Optional parameter to optimize the API call for maximum speed. When set to true, the API will skip time-consuming operations for faster response at the cost of - less comprehensive data. + less comprehensive data. Works with all three lookup methods. + + name: Company name to retrieve brand data for (e.g., 'Apple Inc', 'Microsoft + Corporation'). Must be 3-30 characters. Cannot be used with domain or ticker + parameters. + + ticker: Stock ticker symbol to retrieve brand data for (e.g., 'AAPL', 'GOOGL', 'BRK.A'). + Must be 1-6 characters, letters/numbers/dots only. Cannot be used with domain or + name parameters. timeout_ms: Optional timeout in milliseconds for the request. If the request takes longer than this value, it will be aborted with a 408 status code. Maximum allowed @@ -704,6 +681,8 @@ async def retrieve( "domain": domain, "force_language": force_language, "max_speed": max_speed, + "name": name, + "ticker": ticker, "timeout_ms": timeout_ms, }, brand_retrieve_params.BrandRetrieveParams, @@ -865,55 +844,6 @@ async def prefetch( cast_to=BrandPrefetchResponse, ) - async def retrieve_by_ticker( - self, - *, - ticker: str, - timeout_ms: int | NotGiven = NOT_GIVEN, - # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs. - # The extra values given here take precedence over values defined on the client or passed to this method. - extra_headers: Headers | None = None, - extra_query: Query | None = None, - extra_body: Body | None = None, - timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> BrandRetrieveByTickerResponse: - """Retrieve brand data by stock ticker (e.g. - - AAPL, TSLA, etc.) - - Args: - ticker: Stock ticker symbol to retrieve brand data for (e.g. AAPL, TSLA, etc.) - - timeout_ms: Optional timeout in milliseconds for the request. If the request takes longer - than this value, it will be aborted with a 408 status code. Maximum allowed - value is 300000ms (5 minutes). - - extra_headers: Send extra headers - - extra_query: Add additional query parameters to the request - - extra_body: Add additional JSON properties to the request - - timeout: Override the client-level default timeout for this request, in seconds - """ - return await self._get( - "/brand/retrieve-by-ticker", - options=make_request_options( - extra_headers=extra_headers, - extra_query=extra_query, - extra_body=extra_body, - timeout=timeout, - query=await async_maybe_transform( - { - "ticker": ticker, - "timeout_ms": timeout_ms, - }, - brand_retrieve_by_ticker_params.BrandRetrieveByTickerParams, - ), - ), - cast_to=BrandRetrieveByTickerResponse, - ) - async def retrieve_naics( self, *, @@ -1134,9 +1064,6 @@ def __init__(self, brand: BrandResource) -> None: self.prefetch = to_raw_response_wrapper( brand.prefetch, ) - self.retrieve_by_ticker = to_raw_response_wrapper( - brand.retrieve_by_ticker, - ) self.retrieve_naics = to_raw_response_wrapper( brand.retrieve_naics, ) @@ -1167,9 +1094,6 @@ def __init__(self, brand: AsyncBrandResource) -> None: self.prefetch = async_to_raw_response_wrapper( brand.prefetch, ) - self.retrieve_by_ticker = async_to_raw_response_wrapper( - brand.retrieve_by_ticker, - ) self.retrieve_naics = async_to_raw_response_wrapper( brand.retrieve_naics, ) @@ -1200,9 +1124,6 @@ def __init__(self, brand: BrandResource) -> None: self.prefetch = to_streamed_response_wrapper( brand.prefetch, ) - self.retrieve_by_ticker = to_streamed_response_wrapper( - brand.retrieve_by_ticker, - ) self.retrieve_naics = to_streamed_response_wrapper( brand.retrieve_naics, ) @@ -1233,9 +1154,6 @@ def __init__(self, brand: AsyncBrandResource) -> None: self.prefetch = async_to_streamed_response_wrapper( brand.prefetch, ) - self.retrieve_by_ticker = async_to_streamed_response_wrapper( - brand.retrieve_by_ticker, - ) self.retrieve_naics = async_to_streamed_response_wrapper( brand.retrieve_naics, ) diff --git a/src/brand/dev/types/__init__.py b/src/brand/dev/types/__init__.py index 35536b0..a4dff66 100644 --- a/src/brand/dev/types/__init__.py +++ b/src/brand/dev/types/__init__.py @@ -14,9 +14,7 @@ from .brand_styleguide_response import BrandStyleguideResponse as BrandStyleguideResponse from .brand_retrieve_naics_params import BrandRetrieveNaicsParams as BrandRetrieveNaicsParams from .brand_retrieve_naics_response import BrandRetrieveNaicsResponse as BrandRetrieveNaicsResponse -from .brand_retrieve_by_ticker_params import BrandRetrieveByTickerParams as BrandRetrieveByTickerParams from .brand_retrieve_simplified_params import BrandRetrieveSimplifiedParams as BrandRetrieveSimplifiedParams -from .brand_retrieve_by_ticker_response import BrandRetrieveByTickerResponse as BrandRetrieveByTickerResponse from .brand_retrieve_simplified_response import BrandRetrieveSimplifiedResponse as BrandRetrieveSimplifiedResponse from .brand_identify_from_transaction_params import ( BrandIdentifyFromTransactionParams as BrandIdentifyFromTransactionParams, diff --git a/src/brand/dev/types/brand_identify_from_transaction_response.py b/src/brand/dev/types/brand_identify_from_transaction_response.py index a4ca52c..d59f558 100644 --- a/src/brand/dev/types/brand_identify_from_transaction_response.py +++ b/src/brand/dev/types/brand_identify_from_transaction_response.py @@ -13,6 +13,8 @@ "BrandBackdropColor", "BrandBackdropResolution", "BrandColor", + "BrandIndustries", + "BrandIndustriesEic", "BrandLogo", "BrandLogoColor", "BrandLogoResolution", @@ -82,6 +84,265 @@ class BrandColor(BaseModel): """Name of the color""" +class BrandIndustriesEic(BaseModel): + industry: Literal[ + "Aerospace & Defense", + "Technology", + "Finance", + "Healthcare", + "Retail & E-commerce", + "Entertainment", + "Education", + "Government & Nonprofit", + "Industrial & Energy", + "Automotive & Transportation", + "Lifestyle & Leisure", + "Luxury & Fashion", + "News & Media", + "Sports", + "Real Estate & PropTech", + "Legal & Compliance", + "Telecommunications", + "Agriculture & Food", + "Professional Services & Agencies", + "Chemicals & Materials", + "Logistics & Supply Chain", + "Hospitality & Tourism", + "Construction & Built Environment", + "Consumer Packaged Goods (CPG)", + ] + """Industry classification enum""" + + subindustry: Literal[ + "Defense Systems & Military Hardware", + "Aerospace Manufacturing", + "Avionics & Navigation Technology", + "Subsea & Naval Defense Systems", + "Space & Satellite Technology", + "Defense IT & Systems Integration", + "Software (B2B)", + "Software (B2C)", + "Cloud Infrastructure & DevOps", + "Cybersecurity", + "Artificial Intelligence & Machine Learning", + "Data Infrastructure & Analytics", + "Hardware & Semiconductors", + "Fintech Infrastructure", + "eCommerce & Marketplace Platforms", + "Developer Tools & APIs", + "Web3 & Blockchain", + "XR & Spatial Computing", + "Banking & Lending", + "Investment Management & WealthTech", + "Insurance & InsurTech", + "Payments & Money Movement", + "Accounting, Tax & Financial Planning Tools", + "Capital Markets & Trading Platforms", + "Financial Infrastructure & APIs", + "Credit Scoring & Risk Management", + "Cryptocurrency & Digital Assets", + "BNPL & Alternative Financing", + "Healthcare Providers & Services", + "Pharmaceuticals & Drug Development", + "Medical Devices & Diagnostics", + "Biotechnology & Genomics", + "Digital Health & Telemedicine", + "Health Insurance & Benefits Tech", + "Clinical Trials & Research Platforms", + "Mental Health & Wellness", + "Healthcare IT & EHR Systems", + "Consumer Health & Wellness Products", + "Online Marketplaces", + "Direct-to-Consumer (DTC) Brands", + "Retail Tech & Point-of-Sale Systems", + "Omnichannel & In-Store Retail", + "E-commerce Enablement & Infrastructure", + "Subscription & Membership Commerce", + "Social Commerce & Influencer Platforms", + "Fashion & Apparel Retail", + "Food, Beverage & Grocery E-commerce", + "Streaming Platforms (Video, Music, Audio)", + "Gaming & Interactive Entertainment", + "Creator Economy & Influencer Platforms", + "Advertising, Adtech & Media Buying", + "Film, TV & Production Studios", + "Events, Venues & Live Entertainment", + "Virtual Worlds & Metaverse Experiences", + "K-12 Education Platforms & Tools", + "Higher Education & University Tech", + "Online Learning & MOOCs", + "Test Prep & Certification", + "Corporate Training & Upskilling", + "Tutoring & Supplemental Learning", + "Education Management Systems (LMS/SIS)", + "Language Learning", + "Creator-Led & Cohort-Based Courses", + "Special Education & Accessibility Tools", + "Government Technology & Digital Services", + "Civic Engagement & Policy Platforms", + "International Development & Humanitarian Aid", + "Philanthropy & Grantmaking", + "Nonprofit Operations & Fundraising Tools", + "Public Health & Social Services", + "Education & Youth Development Programs", + "Environmental & Climate Action Organizations", + "Legal Aid & Social Justice Advocacy", + "Municipal & Infrastructure Services", + "Manufacturing & Industrial Automation", + "Energy Production (Oil, Gas, Nuclear)", + "Renewable Energy & Cleantech", + "Utilities & Grid Infrastructure", + "Industrial IoT & Monitoring Systems", + "Construction & Heavy Equipment", + "Mining & Natural Resources", + "Environmental Engineering & Sustainability", + "Energy Storage & Battery Technology", + "Automotive OEMs & Vehicle Manufacturing", + "Electric Vehicles (EVs) & Charging Infrastructure", + "Mobility-as-a-Service (MaaS)", + "Fleet Management", + "Public Transit & Urban Mobility", + "Autonomous Vehicles & ADAS", + "Aftermarket Parts & Services", + "Telematics & Vehicle Connectivity", + "Aviation & Aerospace Transport", + "Maritime Shipping", + "Fitness & Wellness", + "Beauty & Personal Care", + "Home & Living", + "Dating & Relationships", + "Hobbies, Crafts & DIY", + "Outdoor & Recreational Gear", + "Events, Experiences & Ticketing Platforms", + "Designer & Luxury Apparel", + "Accessories, Jewelry & Watches", + "Footwear & Leather Goods", + "Beauty, Fragrance & Skincare", + "Fashion Marketplaces & Retail Platforms", + "Sustainable & Ethical Fashion", + "Resale, Vintage & Circular Fashion", + "Fashion Tech & Virtual Try-Ons", + "Streetwear & Emerging Luxury", + "Couture & Made-to-Measure", + "News Publishing & Journalism", + "Digital Media & Content Platforms", + "Broadcasting (TV & Radio)", + "Podcasting & Audio Media", + "News Aggregators & Curation Tools", + "Independent & Creator-Led Media", + "Newsletters & Substack-Style Platforms", + "Political & Investigative Media", + "Trade & Niche Publications", + "Media Monitoring & Analytics", + "Professional Teams & Leagues", + "Sports Media & Broadcasting", + "Sports Betting & Fantasy Sports", + "Fitness & Athletic Training Platforms", + "Sportswear & Equipment", + "Esports & Competitive Gaming", + "Sports Venues & Event Management", + "Athlete Management & Talent Agencies", + "Sports Tech & Performance Analytics", + "Youth, Amateur & Collegiate Sports", + "Real Estate Marketplaces", + "Property Management Software", + "Rental Platforms", + "Mortgage & Lending Tech", + "Real Estate Investment Platforms", + "Law Firms & Legal Services", + "Legal Tech & Automation", + "Regulatory Compliance", + "E-Discovery & Litigation Tools", + "Contract Management", + "Governance, Risk & Compliance (GRC)", + "IP & Trademark Management", + "Legal Research & Intelligence", + "Compliance Training & Certification", + "Whistleblower & Ethics Reporting", + "Mobile & Wireless Networks (3G/4G/5G)", + "Broadband & Fiber Internet", + "Satellite & Space-Based Communications", + "Network Equipment & Infrastructure", + "Telecom Billing & OSS/BSS Systems", + "VoIP & Unified Communications", + "Internet Service Providers (ISPs)", + "Edge Computing & Network Virtualization", + "IoT Connectivity Platforms", + "Precision Agriculture & AgTech", + "Crop & Livestock Production", + "Food & Beverage Manufacturing & Processing", + "Food Distribution", + "Restaurants & Food Service", + "Agricultural Inputs & Equipment", + "Sustainable & Regenerative Agriculture", + "Seafood & Aquaculture", + "Management Consulting", + "Marketing & Advertising Agencies", + "Design, Branding & Creative Studios", + "IT Services & Managed Services", + "Staffing, Recruiting & Talent", + "Accounting & Tax Firms", + "Public Relations & Communications", + "Business Process Outsourcing (BPO)", + "Professional Training & Coaching", + "Specialty Chemicals", + "Commodity & Petrochemicals", + "Polymers, Plastics & Rubber", + "Coatings, Adhesives & Sealants", + "Industrial Gases", + "Advanced Materials & Composites", + "Battery Materials & Energy Storage", + "Electronic Materials & Semiconductor Chemicals", + "Agrochemicals & Fertilizers", + "Freight & Transportation Tech", + "Last-Mile Delivery", + "Warehouse Automation", + "Supply Chain Visibility Platforms", + "Logistics Marketplaces", + "Shipping & Freight Forwarding", + "Cold Chain Logistics", + "Reverse Logistics & Returns", + "Cross-Border Trade Tech", + "Transportation Management Systems (TMS)", + "Hotels & Accommodation", + "Vacation Rentals & Short-Term Stays", + "Restaurant Tech & Management", + "Travel Booking Platforms", + "Tourism Experiences & Activities", + "Cruise Lines & Marine Tourism", + "Hospitality Management Systems", + "Event & Venue Management", + "Corporate Travel Management", + "Travel Insurance & Protection", + "Construction Management Software", + "BIM/CAD & Design Tools", + "Construction Marketplaces", + "Equipment Rental & Management", + "Building Materials & Procurement", + "Construction Workforce Management", + "Project Estimation & Bidding", + "Modular & Prefab Construction", + "Construction Safety & Compliance", + "Smart Building Technology", + "Food & Beverage CPG", + "Home & Personal Care CPG", + "CPG Analytics & Insights", + "Direct-to-Consumer CPG Brands", + "CPG Supply Chain & Distribution", + "Private Label Manufacturing", + "CPG Retail Intelligence", + "Sustainable CPG & Packaging", + "Beauty & Cosmetics CPG", + "Health & Wellness CPG", + ] + """Subindustry classification enum""" + + +class BrandIndustries(BaseModel): + eic: Optional[List[BrandIndustriesEic]] = None + """Easy Industry Classification - array of industry and subindustry pairs""" + + class BrandLogoColor(BaseModel): hex: Optional[str] = None """Color in hexadecimal format""" @@ -157,6 +418,9 @@ class Brand(BaseModel): email: Optional[str] = None """Company email address""" + industries: Optional[BrandIndustries] = None + """Industry classification information for the brand""" + is_nsfw: Optional[bool] = None """Indicates whether the brand content is not safe for work (NSFW)""" diff --git a/src/brand/dev/types/brand_retrieve_by_ticker_params.py b/src/brand/dev/types/brand_retrieve_by_ticker_params.py deleted file mode 100644 index 05d7c79..0000000 --- a/src/brand/dev/types/brand_retrieve_by_ticker_params.py +++ /dev/null @@ -1,21 +0,0 @@ -# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. - -from __future__ import annotations - -from typing_extensions import Required, Annotated, TypedDict - -from .._utils import PropertyInfo - -__all__ = ["BrandRetrieveByTickerParams"] - - -class BrandRetrieveByTickerParams(TypedDict, total=False): - ticker: Required[str] - """Stock ticker symbol to retrieve brand data for (e.g. AAPL, TSLA, etc.)""" - - timeout_ms: Annotated[int, PropertyInfo(alias="timeoutMS")] - """Optional timeout in milliseconds for the request. - - If the request takes longer than this value, it will be aborted with a 408 - status code. Maximum allowed value is 300000ms (5 minutes). - """ diff --git a/src/brand/dev/types/brand_retrieve_by_ticker_response.py b/src/brand/dev/types/brand_retrieve_by_ticker_response.py deleted file mode 100644 index 918b67c..0000000 --- a/src/brand/dev/types/brand_retrieve_by_ticker_response.py +++ /dev/null @@ -1,193 +0,0 @@ -# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. - -from typing import List, Optional -from typing_extensions import Literal - -from .._models import BaseModel - -__all__ = [ - "BrandRetrieveByTickerResponse", - "Brand", - "BrandAddress", - "BrandBackdrop", - "BrandBackdropColor", - "BrandBackdropResolution", - "BrandColor", - "BrandLogo", - "BrandLogoColor", - "BrandLogoResolution", - "BrandSocial", - "BrandStock", -] - - -class BrandAddress(BaseModel): - city: Optional[str] = None - """City name""" - - country: Optional[str] = None - """Country name""" - - country_code: Optional[str] = None - """Country code""" - - postal_code: Optional[str] = None - """Postal or ZIP code""" - - state_code: Optional[str] = None - """State or province code""" - - state_province: Optional[str] = None - """State or province name""" - - street: Optional[str] = None - """Street address""" - - -class BrandBackdropColor(BaseModel): - hex: Optional[str] = None - """Color in hexadecimal format""" - - name: Optional[str] = None - """Name of the color""" - - -class BrandBackdropResolution(BaseModel): - aspect_ratio: Optional[float] = None - """Aspect ratio of the image (width/height)""" - - height: Optional[int] = None - """Height of the image in pixels""" - - width: Optional[int] = None - """Width of the image in pixels""" - - -class BrandBackdrop(BaseModel): - colors: Optional[List[BrandBackdropColor]] = None - """Array of colors in the backdrop image""" - - resolution: Optional[BrandBackdropResolution] = None - """Resolution of the backdrop image""" - - url: Optional[str] = None - """URL of the backdrop image""" - - -class BrandColor(BaseModel): - hex: Optional[str] = None - """Color in hexadecimal format""" - - name: Optional[str] = None - """Name of the color""" - - -class BrandLogoColor(BaseModel): - hex: Optional[str] = None - """Color in hexadecimal format""" - - name: Optional[str] = None - """Name of the color""" - - -class BrandLogoResolution(BaseModel): - aspect_ratio: Optional[float] = None - """Aspect ratio of the image (width/height)""" - - height: Optional[int] = None - """Height of the image in pixels""" - - width: Optional[int] = None - """Width of the image in pixels""" - - -class BrandLogo(BaseModel): - colors: Optional[List[BrandLogoColor]] = None - """Array of colors in the logo""" - - mode: Optional[Literal["light", "dark", "has_opaque_background"]] = None - """ - Indicates when this logo is best used: 'light' = best for light mode, 'dark' = - best for dark mode, 'has_opaque_background' = can be used for either as image - has its own background - """ - - resolution: Optional[BrandLogoResolution] = None - """Resolution of the logo image""" - - type: Optional[Literal["icon", "logo"]] = None - """Type of the logo based on resolution (e.g., 'icon', 'logo')""" - - url: Optional[str] = None - """CDN hosted url of the logo (ready for display)""" - - -class BrandSocial(BaseModel): - type: Optional[str] = None - """Type of social media, e.g., 'facebook', 'twitter'""" - - url: Optional[str] = None - """URL of the social media page""" - - -class BrandStock(BaseModel): - exchange: Optional[str] = None - """Stock exchange name""" - - ticker: Optional[str] = None - """Stock ticker symbol""" - - -class Brand(BaseModel): - address: Optional[BrandAddress] = None - """Physical address of the brand""" - - backdrops: Optional[List[BrandBackdrop]] = None - """An array of backdrop images for the brand""" - - colors: Optional[List[BrandColor]] = None - """An array of brand colors""" - - description: Optional[str] = None - """A brief description of the brand""" - - domain: Optional[str] = None - """The domain name of the brand""" - - email: Optional[str] = None - """Company email address""" - - is_nsfw: Optional[bool] = None - """Indicates whether the brand content is not safe for work (NSFW)""" - - logos: Optional[List[BrandLogo]] = None - """An array of logos associated with the brand""" - - phone: Optional[str] = None - """Company phone number""" - - slogan: Optional[str] = None - """The brand's slogan""" - - socials: Optional[List[BrandSocial]] = None - """An array of social media links for the brand""" - - stock: Optional[BrandStock] = None - """ - Stock market information for this brand (will be null if not a publicly traded - company) - """ - - title: Optional[str] = None - """The title or name of the brand""" - - -class BrandRetrieveByTickerResponse(BaseModel): - brand: Optional[Brand] = None - """Detailed brand information""" - - code: Optional[int] = None - """HTTP status code""" - - status: Optional[str] = None - """Status of the response, e.g., 'ok'""" diff --git a/src/brand/dev/types/brand_retrieve_params.py b/src/brand/dev/types/brand_retrieve_params.py index e5e8555..8092de7 100644 --- a/src/brand/dev/types/brand_retrieve_params.py +++ b/src/brand/dev/types/brand_retrieve_params.py @@ -2,7 +2,7 @@ from __future__ import annotations -from typing_extensions import Literal, Required, Annotated, TypedDict +from typing_extensions import Literal, Annotated, TypedDict from .._utils import PropertyInfo @@ -10,8 +10,11 @@ class BrandRetrieveParams(TypedDict, total=False): - domain: Required[str] - """Domain name to retrieve brand data for""" + domain: str + """Domain name to retrieve brand data for (e.g., 'example.com', 'google.com'). + + Cannot be used with name or ticker parameters. + """ force_language: Literal[ "albanian", @@ -67,13 +70,31 @@ class BrandRetrieveParams(TypedDict, total=False): "vietnamese", "welsh", ] - """Optional parameter to force the language of the retrieved brand data""" + """Optional parameter to force the language of the retrieved brand data. + + Works with all three lookup methods. + """ max_speed: Annotated[bool, PropertyInfo(alias="maxSpeed")] """Optional parameter to optimize the API call for maximum speed. When set to true, the API will skip time-consuming operations for faster - response at the cost of less comprehensive data. + response at the cost of less comprehensive data. Works with all three lookup + methods. + """ + + name: str + """ + Company name to retrieve brand data for (e.g., 'Apple Inc', 'Microsoft + Corporation'). Must be 3-30 characters. Cannot be used with domain or ticker + parameters. + """ + + ticker: str + """Stock ticker symbol to retrieve brand data for (e.g., 'AAPL', 'GOOGL', 'BRK.A'). + + Must be 1-6 characters, letters/numbers/dots only. Cannot be used with domain or + name parameters. """ timeout_ms: Annotated[int, PropertyInfo(alias="timeoutMS")] diff --git a/src/brand/dev/types/brand_retrieve_response.py b/src/brand/dev/types/brand_retrieve_response.py index a684da9..6f927d4 100644 --- a/src/brand/dev/types/brand_retrieve_response.py +++ b/src/brand/dev/types/brand_retrieve_response.py @@ -13,6 +13,8 @@ "BrandBackdropColor", "BrandBackdropResolution", "BrandColor", + "BrandIndustries", + "BrandIndustriesEic", "BrandLogo", "BrandLogoColor", "BrandLogoResolution", @@ -82,6 +84,265 @@ class BrandColor(BaseModel): """Name of the color""" +class BrandIndustriesEic(BaseModel): + industry: Literal[ + "Aerospace & Defense", + "Technology", + "Finance", + "Healthcare", + "Retail & E-commerce", + "Entertainment", + "Education", + "Government & Nonprofit", + "Industrial & Energy", + "Automotive & Transportation", + "Lifestyle & Leisure", + "Luxury & Fashion", + "News & Media", + "Sports", + "Real Estate & PropTech", + "Legal & Compliance", + "Telecommunications", + "Agriculture & Food", + "Professional Services & Agencies", + "Chemicals & Materials", + "Logistics & Supply Chain", + "Hospitality & Tourism", + "Construction & Built Environment", + "Consumer Packaged Goods (CPG)", + ] + """Industry classification enum""" + + subindustry: Literal[ + "Defense Systems & Military Hardware", + "Aerospace Manufacturing", + "Avionics & Navigation Technology", + "Subsea & Naval Defense Systems", + "Space & Satellite Technology", + "Defense IT & Systems Integration", + "Software (B2B)", + "Software (B2C)", + "Cloud Infrastructure & DevOps", + "Cybersecurity", + "Artificial Intelligence & Machine Learning", + "Data Infrastructure & Analytics", + "Hardware & Semiconductors", + "Fintech Infrastructure", + "eCommerce & Marketplace Platforms", + "Developer Tools & APIs", + "Web3 & Blockchain", + "XR & Spatial Computing", + "Banking & Lending", + "Investment Management & WealthTech", + "Insurance & InsurTech", + "Payments & Money Movement", + "Accounting, Tax & Financial Planning Tools", + "Capital Markets & Trading Platforms", + "Financial Infrastructure & APIs", + "Credit Scoring & Risk Management", + "Cryptocurrency & Digital Assets", + "BNPL & Alternative Financing", + "Healthcare Providers & Services", + "Pharmaceuticals & Drug Development", + "Medical Devices & Diagnostics", + "Biotechnology & Genomics", + "Digital Health & Telemedicine", + "Health Insurance & Benefits Tech", + "Clinical Trials & Research Platforms", + "Mental Health & Wellness", + "Healthcare IT & EHR Systems", + "Consumer Health & Wellness Products", + "Online Marketplaces", + "Direct-to-Consumer (DTC) Brands", + "Retail Tech & Point-of-Sale Systems", + "Omnichannel & In-Store Retail", + "E-commerce Enablement & Infrastructure", + "Subscription & Membership Commerce", + "Social Commerce & Influencer Platforms", + "Fashion & Apparel Retail", + "Food, Beverage & Grocery E-commerce", + "Streaming Platforms (Video, Music, Audio)", + "Gaming & Interactive Entertainment", + "Creator Economy & Influencer Platforms", + "Advertising, Adtech & Media Buying", + "Film, TV & Production Studios", + "Events, Venues & Live Entertainment", + "Virtual Worlds & Metaverse Experiences", + "K-12 Education Platforms & Tools", + "Higher Education & University Tech", + "Online Learning & MOOCs", + "Test Prep & Certification", + "Corporate Training & Upskilling", + "Tutoring & Supplemental Learning", + "Education Management Systems (LMS/SIS)", + "Language Learning", + "Creator-Led & Cohort-Based Courses", + "Special Education & Accessibility Tools", + "Government Technology & Digital Services", + "Civic Engagement & Policy Platforms", + "International Development & Humanitarian Aid", + "Philanthropy & Grantmaking", + "Nonprofit Operations & Fundraising Tools", + "Public Health & Social Services", + "Education & Youth Development Programs", + "Environmental & Climate Action Organizations", + "Legal Aid & Social Justice Advocacy", + "Municipal & Infrastructure Services", + "Manufacturing & Industrial Automation", + "Energy Production (Oil, Gas, Nuclear)", + "Renewable Energy & Cleantech", + "Utilities & Grid Infrastructure", + "Industrial IoT & Monitoring Systems", + "Construction & Heavy Equipment", + "Mining & Natural Resources", + "Environmental Engineering & Sustainability", + "Energy Storage & Battery Technology", + "Automotive OEMs & Vehicle Manufacturing", + "Electric Vehicles (EVs) & Charging Infrastructure", + "Mobility-as-a-Service (MaaS)", + "Fleet Management", + "Public Transit & Urban Mobility", + "Autonomous Vehicles & ADAS", + "Aftermarket Parts & Services", + "Telematics & Vehicle Connectivity", + "Aviation & Aerospace Transport", + "Maritime Shipping", + "Fitness & Wellness", + "Beauty & Personal Care", + "Home & Living", + "Dating & Relationships", + "Hobbies, Crafts & DIY", + "Outdoor & Recreational Gear", + "Events, Experiences & Ticketing Platforms", + "Designer & Luxury Apparel", + "Accessories, Jewelry & Watches", + "Footwear & Leather Goods", + "Beauty, Fragrance & Skincare", + "Fashion Marketplaces & Retail Platforms", + "Sustainable & Ethical Fashion", + "Resale, Vintage & Circular Fashion", + "Fashion Tech & Virtual Try-Ons", + "Streetwear & Emerging Luxury", + "Couture & Made-to-Measure", + "News Publishing & Journalism", + "Digital Media & Content Platforms", + "Broadcasting (TV & Radio)", + "Podcasting & Audio Media", + "News Aggregators & Curation Tools", + "Independent & Creator-Led Media", + "Newsletters & Substack-Style Platforms", + "Political & Investigative Media", + "Trade & Niche Publications", + "Media Monitoring & Analytics", + "Professional Teams & Leagues", + "Sports Media & Broadcasting", + "Sports Betting & Fantasy Sports", + "Fitness & Athletic Training Platforms", + "Sportswear & Equipment", + "Esports & Competitive Gaming", + "Sports Venues & Event Management", + "Athlete Management & Talent Agencies", + "Sports Tech & Performance Analytics", + "Youth, Amateur & Collegiate Sports", + "Real Estate Marketplaces", + "Property Management Software", + "Rental Platforms", + "Mortgage & Lending Tech", + "Real Estate Investment Platforms", + "Law Firms & Legal Services", + "Legal Tech & Automation", + "Regulatory Compliance", + "E-Discovery & Litigation Tools", + "Contract Management", + "Governance, Risk & Compliance (GRC)", + "IP & Trademark Management", + "Legal Research & Intelligence", + "Compliance Training & Certification", + "Whistleblower & Ethics Reporting", + "Mobile & Wireless Networks (3G/4G/5G)", + "Broadband & Fiber Internet", + "Satellite & Space-Based Communications", + "Network Equipment & Infrastructure", + "Telecom Billing & OSS/BSS Systems", + "VoIP & Unified Communications", + "Internet Service Providers (ISPs)", + "Edge Computing & Network Virtualization", + "IoT Connectivity Platforms", + "Precision Agriculture & AgTech", + "Crop & Livestock Production", + "Food & Beverage Manufacturing & Processing", + "Food Distribution", + "Restaurants & Food Service", + "Agricultural Inputs & Equipment", + "Sustainable & Regenerative Agriculture", + "Seafood & Aquaculture", + "Management Consulting", + "Marketing & Advertising Agencies", + "Design, Branding & Creative Studios", + "IT Services & Managed Services", + "Staffing, Recruiting & Talent", + "Accounting & Tax Firms", + "Public Relations & Communications", + "Business Process Outsourcing (BPO)", + "Professional Training & Coaching", + "Specialty Chemicals", + "Commodity & Petrochemicals", + "Polymers, Plastics & Rubber", + "Coatings, Adhesives & Sealants", + "Industrial Gases", + "Advanced Materials & Composites", + "Battery Materials & Energy Storage", + "Electronic Materials & Semiconductor Chemicals", + "Agrochemicals & Fertilizers", + "Freight & Transportation Tech", + "Last-Mile Delivery", + "Warehouse Automation", + "Supply Chain Visibility Platforms", + "Logistics Marketplaces", + "Shipping & Freight Forwarding", + "Cold Chain Logistics", + "Reverse Logistics & Returns", + "Cross-Border Trade Tech", + "Transportation Management Systems (TMS)", + "Hotels & Accommodation", + "Vacation Rentals & Short-Term Stays", + "Restaurant Tech & Management", + "Travel Booking Platforms", + "Tourism Experiences & Activities", + "Cruise Lines & Marine Tourism", + "Hospitality Management Systems", + "Event & Venue Management", + "Corporate Travel Management", + "Travel Insurance & Protection", + "Construction Management Software", + "BIM/CAD & Design Tools", + "Construction Marketplaces", + "Equipment Rental & Management", + "Building Materials & Procurement", + "Construction Workforce Management", + "Project Estimation & Bidding", + "Modular & Prefab Construction", + "Construction Safety & Compliance", + "Smart Building Technology", + "Food & Beverage CPG", + "Home & Personal Care CPG", + "CPG Analytics & Insights", + "Direct-to-Consumer CPG Brands", + "CPG Supply Chain & Distribution", + "Private Label Manufacturing", + "CPG Retail Intelligence", + "Sustainable CPG & Packaging", + "Beauty & Cosmetics CPG", + "Health & Wellness CPG", + ] + """Subindustry classification enum""" + + +class BrandIndustries(BaseModel): + eic: Optional[List[BrandIndustriesEic]] = None + """Easy Industry Classification - array of industry and subindustry pairs""" + + class BrandLogoColor(BaseModel): hex: Optional[str] = None """Color in hexadecimal format""" @@ -157,6 +418,9 @@ class Brand(BaseModel): email: Optional[str] = None """Company email address""" + industries: Optional[BrandIndustries] = None + """Industry classification information for the brand""" + is_nsfw: Optional[bool] = None """Indicates whether the brand content is not safe for work (NSFW)""" diff --git a/tests/api_resources/test_brand.py b/tests/api_resources/test_brand.py index 571963c..d1dfb61 100644 --- a/tests/api_resources/test_brand.py +++ b/tests/api_resources/test_brand.py @@ -16,7 +16,6 @@ BrandScreenshotResponse, BrandStyleguideResponse, BrandRetrieveNaicsResponse, - BrandRetrieveByTickerResponse, BrandRetrieveSimplifiedResponse, BrandIdentifyFromTransactionResponse, ) @@ -27,43 +26,39 @@ class TestBrand: parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize def test_method_retrieve(self, client: BrandDev) -> None: - brand = client.brand.retrieve( - domain="domain", - ) + brand = client.brand.retrieve() assert_matches_type(BrandRetrieveResponse, brand, path=["response"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize def test_method_retrieve_with_all_params(self, client: BrandDev) -> None: brand = client.brand.retrieve( domain="domain", force_language="albanian", max_speed=True, + name="xxx", + ticker="ticker", timeout_ms=1, ) assert_matches_type(BrandRetrieveResponse, brand, path=["response"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize def test_raw_response_retrieve(self, client: BrandDev) -> None: - response = client.brand.with_raw_response.retrieve( - domain="domain", - ) + response = client.brand.with_raw_response.retrieve() assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" brand = response.parse() assert_matches_type(BrandRetrieveResponse, brand, path=["response"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize def test_streaming_response_retrieve(self, client: BrandDev) -> None: - with client.brand.with_streaming_response.retrieve( - domain="domain", - ) as response: + with client.brand.with_streaming_response.retrieve() as response: assert not response.is_closed assert response.http_request.headers.get("X-Stainless-Lang") == "python" @@ -72,7 +67,7 @@ def test_streaming_response_retrieve(self, client: BrandDev) -> None: assert cast(Any, response.is_closed) is True - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize def test_method_ai_query(self, client: BrandDev) -> None: brand = client.brand.ai_query( @@ -88,7 +83,7 @@ def test_method_ai_query(self, client: BrandDev) -> None: ) assert_matches_type(BrandAIQueryResponse, brand, path=["response"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize def test_method_ai_query_with_all_params(self, client: BrandDev) -> None: brand = client.brand.ai_query( @@ -115,7 +110,7 @@ def test_method_ai_query_with_all_params(self, client: BrandDev) -> None: ) assert_matches_type(BrandAIQueryResponse, brand, path=["response"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize def test_raw_response_ai_query(self, client: BrandDev) -> None: response = client.brand.with_raw_response.ai_query( @@ -135,7 +130,7 @@ def test_raw_response_ai_query(self, client: BrandDev) -> None: brand = response.parse() assert_matches_type(BrandAIQueryResponse, brand, path=["response"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize def test_streaming_response_ai_query(self, client: BrandDev) -> None: with client.brand.with_streaming_response.ai_query( @@ -157,7 +152,7 @@ def test_streaming_response_ai_query(self, client: BrandDev) -> None: assert cast(Any, response.is_closed) is True - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize def test_method_identify_from_transaction(self, client: BrandDev) -> None: brand = client.brand.identify_from_transaction( @@ -165,7 +160,7 @@ def test_method_identify_from_transaction(self, client: BrandDev) -> None: ) assert_matches_type(BrandIdentifyFromTransactionResponse, brand, path=["response"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize def test_method_identify_from_transaction_with_all_params(self, client: BrandDev) -> None: brand = client.brand.identify_from_transaction( @@ -174,7 +169,7 @@ def test_method_identify_from_transaction_with_all_params(self, client: BrandDev ) assert_matches_type(BrandIdentifyFromTransactionResponse, brand, path=["response"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize def test_raw_response_identify_from_transaction(self, client: BrandDev) -> None: response = client.brand.with_raw_response.identify_from_transaction( @@ -186,7 +181,7 @@ def test_raw_response_identify_from_transaction(self, client: BrandDev) -> None: brand = response.parse() assert_matches_type(BrandIdentifyFromTransactionResponse, brand, path=["response"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize def test_streaming_response_identify_from_transaction(self, client: BrandDev) -> None: with client.brand.with_streaming_response.identify_from_transaction( @@ -200,7 +195,7 @@ def test_streaming_response_identify_from_transaction(self, client: BrandDev) -> assert cast(Any, response.is_closed) is True - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize def test_method_prefetch(self, client: BrandDev) -> None: brand = client.brand.prefetch( @@ -208,7 +203,7 @@ def test_method_prefetch(self, client: BrandDev) -> None: ) assert_matches_type(BrandPrefetchResponse, brand, path=["response"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize def test_method_prefetch_with_all_params(self, client: BrandDev) -> None: brand = client.brand.prefetch( @@ -217,7 +212,7 @@ def test_method_prefetch_with_all_params(self, client: BrandDev) -> None: ) assert_matches_type(BrandPrefetchResponse, brand, path=["response"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize def test_raw_response_prefetch(self, client: BrandDev) -> None: response = client.brand.with_raw_response.prefetch( @@ -229,7 +224,7 @@ def test_raw_response_prefetch(self, client: BrandDev) -> None: brand = response.parse() assert_matches_type(BrandPrefetchResponse, brand, path=["response"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize def test_streaming_response_prefetch(self, client: BrandDev) -> None: with client.brand.with_streaming_response.prefetch( @@ -243,50 +238,7 @@ def test_streaming_response_prefetch(self, client: BrandDev) -> None: assert cast(Any, response.is_closed) is True - @pytest.mark.skip() - @parametrize - def test_method_retrieve_by_ticker(self, client: BrandDev) -> None: - brand = client.brand.retrieve_by_ticker( - ticker="ticker", - ) - assert_matches_type(BrandRetrieveByTickerResponse, brand, path=["response"]) - - @pytest.mark.skip() - @parametrize - def test_method_retrieve_by_ticker_with_all_params(self, client: BrandDev) -> None: - brand = client.brand.retrieve_by_ticker( - ticker="ticker", - timeout_ms=1, - ) - assert_matches_type(BrandRetrieveByTickerResponse, brand, path=["response"]) - - @pytest.mark.skip() - @parametrize - def test_raw_response_retrieve_by_ticker(self, client: BrandDev) -> None: - response = client.brand.with_raw_response.retrieve_by_ticker( - ticker="ticker", - ) - - assert response.is_closed is True - assert response.http_request.headers.get("X-Stainless-Lang") == "python" - brand = response.parse() - assert_matches_type(BrandRetrieveByTickerResponse, brand, path=["response"]) - - @pytest.mark.skip() - @parametrize - def test_streaming_response_retrieve_by_ticker(self, client: BrandDev) -> None: - with client.brand.with_streaming_response.retrieve_by_ticker( - ticker="ticker", - ) as response: - assert not response.is_closed - assert response.http_request.headers.get("X-Stainless-Lang") == "python" - - brand = response.parse() - assert_matches_type(BrandRetrieveByTickerResponse, brand, path=["response"]) - - assert cast(Any, response.is_closed) is True - - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize def test_method_retrieve_naics(self, client: BrandDev) -> None: brand = client.brand.retrieve_naics( @@ -294,7 +246,7 @@ def test_method_retrieve_naics(self, client: BrandDev) -> None: ) assert_matches_type(BrandRetrieveNaicsResponse, brand, path=["response"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize def test_method_retrieve_naics_with_all_params(self, client: BrandDev) -> None: brand = client.brand.retrieve_naics( @@ -303,7 +255,7 @@ def test_method_retrieve_naics_with_all_params(self, client: BrandDev) -> None: ) assert_matches_type(BrandRetrieveNaicsResponse, brand, path=["response"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize def test_raw_response_retrieve_naics(self, client: BrandDev) -> None: response = client.brand.with_raw_response.retrieve_naics( @@ -315,7 +267,7 @@ def test_raw_response_retrieve_naics(self, client: BrandDev) -> None: brand = response.parse() assert_matches_type(BrandRetrieveNaicsResponse, brand, path=["response"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize def test_streaming_response_retrieve_naics(self, client: BrandDev) -> None: with client.brand.with_streaming_response.retrieve_naics( @@ -329,7 +281,7 @@ def test_streaming_response_retrieve_naics(self, client: BrandDev) -> None: assert cast(Any, response.is_closed) is True - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize def test_method_retrieve_simplified(self, client: BrandDev) -> None: brand = client.brand.retrieve_simplified( @@ -337,7 +289,7 @@ def test_method_retrieve_simplified(self, client: BrandDev) -> None: ) assert_matches_type(BrandRetrieveSimplifiedResponse, brand, path=["response"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize def test_method_retrieve_simplified_with_all_params(self, client: BrandDev) -> None: brand = client.brand.retrieve_simplified( @@ -346,7 +298,7 @@ def test_method_retrieve_simplified_with_all_params(self, client: BrandDev) -> N ) assert_matches_type(BrandRetrieveSimplifiedResponse, brand, path=["response"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize def test_raw_response_retrieve_simplified(self, client: BrandDev) -> None: response = client.brand.with_raw_response.retrieve_simplified( @@ -358,7 +310,7 @@ def test_raw_response_retrieve_simplified(self, client: BrandDev) -> None: brand = response.parse() assert_matches_type(BrandRetrieveSimplifiedResponse, brand, path=["response"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize def test_streaming_response_retrieve_simplified(self, client: BrandDev) -> None: with client.brand.with_streaming_response.retrieve_simplified( @@ -372,7 +324,7 @@ def test_streaming_response_retrieve_simplified(self, client: BrandDev) -> None: assert cast(Any, response.is_closed) is True - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize def test_method_screenshot(self, client: BrandDev) -> None: brand = client.brand.screenshot( @@ -380,7 +332,7 @@ def test_method_screenshot(self, client: BrandDev) -> None: ) assert_matches_type(BrandScreenshotResponse, brand, path=["response"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize def test_method_screenshot_with_all_params(self, client: BrandDev) -> None: brand = client.brand.screenshot( @@ -389,7 +341,7 @@ def test_method_screenshot_with_all_params(self, client: BrandDev) -> None: ) assert_matches_type(BrandScreenshotResponse, brand, path=["response"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize def test_raw_response_screenshot(self, client: BrandDev) -> None: response = client.brand.with_raw_response.screenshot( @@ -401,7 +353,7 @@ def test_raw_response_screenshot(self, client: BrandDev) -> None: brand = response.parse() assert_matches_type(BrandScreenshotResponse, brand, path=["response"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize def test_streaming_response_screenshot(self, client: BrandDev) -> None: with client.brand.with_streaming_response.screenshot( @@ -415,7 +367,7 @@ def test_streaming_response_screenshot(self, client: BrandDev) -> None: assert cast(Any, response.is_closed) is True - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize def test_method_styleguide(self, client: BrandDev) -> None: brand = client.brand.styleguide( @@ -423,7 +375,7 @@ def test_method_styleguide(self, client: BrandDev) -> None: ) assert_matches_type(BrandStyleguideResponse, brand, path=["response"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize def test_method_styleguide_with_all_params(self, client: BrandDev) -> None: brand = client.brand.styleguide( @@ -432,7 +384,7 @@ def test_method_styleguide_with_all_params(self, client: BrandDev) -> None: ) assert_matches_type(BrandStyleguideResponse, brand, path=["response"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize def test_raw_response_styleguide(self, client: BrandDev) -> None: response = client.brand.with_raw_response.styleguide( @@ -444,7 +396,7 @@ def test_raw_response_styleguide(self, client: BrandDev) -> None: brand = response.parse() assert_matches_type(BrandStyleguideResponse, brand, path=["response"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize def test_streaming_response_styleguide(self, client: BrandDev) -> None: with client.brand.with_streaming_response.styleguide( @@ -464,43 +416,39 @@ class TestAsyncBrand: "async_client", [False, True, {"http_client": "aiohttp"}], indirect=True, ids=["loose", "strict", "aiohttp"] ) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize async def test_method_retrieve(self, async_client: AsyncBrandDev) -> None: - brand = await async_client.brand.retrieve( - domain="domain", - ) + brand = await async_client.brand.retrieve() assert_matches_type(BrandRetrieveResponse, brand, path=["response"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize async def test_method_retrieve_with_all_params(self, async_client: AsyncBrandDev) -> None: brand = await async_client.brand.retrieve( domain="domain", force_language="albanian", max_speed=True, + name="xxx", + ticker="ticker", timeout_ms=1, ) assert_matches_type(BrandRetrieveResponse, brand, path=["response"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize async def test_raw_response_retrieve(self, async_client: AsyncBrandDev) -> None: - response = await async_client.brand.with_raw_response.retrieve( - domain="domain", - ) + response = await async_client.brand.with_raw_response.retrieve() assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" brand = await response.parse() assert_matches_type(BrandRetrieveResponse, brand, path=["response"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize async def test_streaming_response_retrieve(self, async_client: AsyncBrandDev) -> None: - async with async_client.brand.with_streaming_response.retrieve( - domain="domain", - ) as response: + async with async_client.brand.with_streaming_response.retrieve() as response: assert not response.is_closed assert response.http_request.headers.get("X-Stainless-Lang") == "python" @@ -509,7 +457,7 @@ async def test_streaming_response_retrieve(self, async_client: AsyncBrandDev) -> assert cast(Any, response.is_closed) is True - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize async def test_method_ai_query(self, async_client: AsyncBrandDev) -> None: brand = await async_client.brand.ai_query( @@ -525,7 +473,7 @@ async def test_method_ai_query(self, async_client: AsyncBrandDev) -> None: ) assert_matches_type(BrandAIQueryResponse, brand, path=["response"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize async def test_method_ai_query_with_all_params(self, async_client: AsyncBrandDev) -> None: brand = await async_client.brand.ai_query( @@ -552,7 +500,7 @@ async def test_method_ai_query_with_all_params(self, async_client: AsyncBrandDev ) assert_matches_type(BrandAIQueryResponse, brand, path=["response"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize async def test_raw_response_ai_query(self, async_client: AsyncBrandDev) -> None: response = await async_client.brand.with_raw_response.ai_query( @@ -572,7 +520,7 @@ async def test_raw_response_ai_query(self, async_client: AsyncBrandDev) -> None: brand = await response.parse() assert_matches_type(BrandAIQueryResponse, brand, path=["response"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize async def test_streaming_response_ai_query(self, async_client: AsyncBrandDev) -> None: async with async_client.brand.with_streaming_response.ai_query( @@ -594,7 +542,7 @@ async def test_streaming_response_ai_query(self, async_client: AsyncBrandDev) -> assert cast(Any, response.is_closed) is True - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize async def test_method_identify_from_transaction(self, async_client: AsyncBrandDev) -> None: brand = await async_client.brand.identify_from_transaction( @@ -602,7 +550,7 @@ async def test_method_identify_from_transaction(self, async_client: AsyncBrandDe ) assert_matches_type(BrandIdentifyFromTransactionResponse, brand, path=["response"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize async def test_method_identify_from_transaction_with_all_params(self, async_client: AsyncBrandDev) -> None: brand = await async_client.brand.identify_from_transaction( @@ -611,7 +559,7 @@ async def test_method_identify_from_transaction_with_all_params(self, async_clie ) assert_matches_type(BrandIdentifyFromTransactionResponse, brand, path=["response"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize async def test_raw_response_identify_from_transaction(self, async_client: AsyncBrandDev) -> None: response = await async_client.brand.with_raw_response.identify_from_transaction( @@ -623,7 +571,7 @@ async def test_raw_response_identify_from_transaction(self, async_client: AsyncB brand = await response.parse() assert_matches_type(BrandIdentifyFromTransactionResponse, brand, path=["response"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize async def test_streaming_response_identify_from_transaction(self, async_client: AsyncBrandDev) -> None: async with async_client.brand.with_streaming_response.identify_from_transaction( @@ -637,7 +585,7 @@ async def test_streaming_response_identify_from_transaction(self, async_client: assert cast(Any, response.is_closed) is True - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize async def test_method_prefetch(self, async_client: AsyncBrandDev) -> None: brand = await async_client.brand.prefetch( @@ -645,7 +593,7 @@ async def test_method_prefetch(self, async_client: AsyncBrandDev) -> None: ) assert_matches_type(BrandPrefetchResponse, brand, path=["response"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize async def test_method_prefetch_with_all_params(self, async_client: AsyncBrandDev) -> None: brand = await async_client.brand.prefetch( @@ -654,7 +602,7 @@ async def test_method_prefetch_with_all_params(self, async_client: AsyncBrandDev ) assert_matches_type(BrandPrefetchResponse, brand, path=["response"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize async def test_raw_response_prefetch(self, async_client: AsyncBrandDev) -> None: response = await async_client.brand.with_raw_response.prefetch( @@ -666,7 +614,7 @@ async def test_raw_response_prefetch(self, async_client: AsyncBrandDev) -> None: brand = await response.parse() assert_matches_type(BrandPrefetchResponse, brand, path=["response"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize async def test_streaming_response_prefetch(self, async_client: AsyncBrandDev) -> None: async with async_client.brand.with_streaming_response.prefetch( @@ -680,50 +628,7 @@ async def test_streaming_response_prefetch(self, async_client: AsyncBrandDev) -> assert cast(Any, response.is_closed) is True - @pytest.mark.skip() - @parametrize - async def test_method_retrieve_by_ticker(self, async_client: AsyncBrandDev) -> None: - brand = await async_client.brand.retrieve_by_ticker( - ticker="ticker", - ) - assert_matches_type(BrandRetrieveByTickerResponse, brand, path=["response"]) - - @pytest.mark.skip() - @parametrize - async def test_method_retrieve_by_ticker_with_all_params(self, async_client: AsyncBrandDev) -> None: - brand = await async_client.brand.retrieve_by_ticker( - ticker="ticker", - timeout_ms=1, - ) - assert_matches_type(BrandRetrieveByTickerResponse, brand, path=["response"]) - - @pytest.mark.skip() - @parametrize - async def test_raw_response_retrieve_by_ticker(self, async_client: AsyncBrandDev) -> None: - response = await async_client.brand.with_raw_response.retrieve_by_ticker( - ticker="ticker", - ) - - assert response.is_closed is True - assert response.http_request.headers.get("X-Stainless-Lang") == "python" - brand = await response.parse() - assert_matches_type(BrandRetrieveByTickerResponse, brand, path=["response"]) - - @pytest.mark.skip() - @parametrize - async def test_streaming_response_retrieve_by_ticker(self, async_client: AsyncBrandDev) -> None: - async with async_client.brand.with_streaming_response.retrieve_by_ticker( - ticker="ticker", - ) as response: - assert not response.is_closed - assert response.http_request.headers.get("X-Stainless-Lang") == "python" - - brand = await response.parse() - assert_matches_type(BrandRetrieveByTickerResponse, brand, path=["response"]) - - assert cast(Any, response.is_closed) is True - - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize async def test_method_retrieve_naics(self, async_client: AsyncBrandDev) -> None: brand = await async_client.brand.retrieve_naics( @@ -731,7 +636,7 @@ async def test_method_retrieve_naics(self, async_client: AsyncBrandDev) -> None: ) assert_matches_type(BrandRetrieveNaicsResponse, brand, path=["response"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize async def test_method_retrieve_naics_with_all_params(self, async_client: AsyncBrandDev) -> None: brand = await async_client.brand.retrieve_naics( @@ -740,7 +645,7 @@ async def test_method_retrieve_naics_with_all_params(self, async_client: AsyncBr ) assert_matches_type(BrandRetrieveNaicsResponse, brand, path=["response"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize async def test_raw_response_retrieve_naics(self, async_client: AsyncBrandDev) -> None: response = await async_client.brand.with_raw_response.retrieve_naics( @@ -752,7 +657,7 @@ async def test_raw_response_retrieve_naics(self, async_client: AsyncBrandDev) -> brand = await response.parse() assert_matches_type(BrandRetrieveNaicsResponse, brand, path=["response"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize async def test_streaming_response_retrieve_naics(self, async_client: AsyncBrandDev) -> None: async with async_client.brand.with_streaming_response.retrieve_naics( @@ -766,7 +671,7 @@ async def test_streaming_response_retrieve_naics(self, async_client: AsyncBrandD assert cast(Any, response.is_closed) is True - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize async def test_method_retrieve_simplified(self, async_client: AsyncBrandDev) -> None: brand = await async_client.brand.retrieve_simplified( @@ -774,7 +679,7 @@ async def test_method_retrieve_simplified(self, async_client: AsyncBrandDev) -> ) assert_matches_type(BrandRetrieveSimplifiedResponse, brand, path=["response"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize async def test_method_retrieve_simplified_with_all_params(self, async_client: AsyncBrandDev) -> None: brand = await async_client.brand.retrieve_simplified( @@ -783,7 +688,7 @@ async def test_method_retrieve_simplified_with_all_params(self, async_client: As ) assert_matches_type(BrandRetrieveSimplifiedResponse, brand, path=["response"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize async def test_raw_response_retrieve_simplified(self, async_client: AsyncBrandDev) -> None: response = await async_client.brand.with_raw_response.retrieve_simplified( @@ -795,7 +700,7 @@ async def test_raw_response_retrieve_simplified(self, async_client: AsyncBrandDe brand = await response.parse() assert_matches_type(BrandRetrieveSimplifiedResponse, brand, path=["response"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize async def test_streaming_response_retrieve_simplified(self, async_client: AsyncBrandDev) -> None: async with async_client.brand.with_streaming_response.retrieve_simplified( @@ -809,7 +714,7 @@ async def test_streaming_response_retrieve_simplified(self, async_client: AsyncB assert cast(Any, response.is_closed) is True - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize async def test_method_screenshot(self, async_client: AsyncBrandDev) -> None: brand = await async_client.brand.screenshot( @@ -817,7 +722,7 @@ async def test_method_screenshot(self, async_client: AsyncBrandDev) -> None: ) assert_matches_type(BrandScreenshotResponse, brand, path=["response"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize async def test_method_screenshot_with_all_params(self, async_client: AsyncBrandDev) -> None: brand = await async_client.brand.screenshot( @@ -826,7 +731,7 @@ async def test_method_screenshot_with_all_params(self, async_client: AsyncBrandD ) assert_matches_type(BrandScreenshotResponse, brand, path=["response"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize async def test_raw_response_screenshot(self, async_client: AsyncBrandDev) -> None: response = await async_client.brand.with_raw_response.screenshot( @@ -838,7 +743,7 @@ async def test_raw_response_screenshot(self, async_client: AsyncBrandDev) -> Non brand = await response.parse() assert_matches_type(BrandScreenshotResponse, brand, path=["response"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize async def test_streaming_response_screenshot(self, async_client: AsyncBrandDev) -> None: async with async_client.brand.with_streaming_response.screenshot( @@ -852,7 +757,7 @@ async def test_streaming_response_screenshot(self, async_client: AsyncBrandDev) assert cast(Any, response.is_closed) is True - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize async def test_method_styleguide(self, async_client: AsyncBrandDev) -> None: brand = await async_client.brand.styleguide( @@ -860,7 +765,7 @@ async def test_method_styleguide(self, async_client: AsyncBrandDev) -> None: ) assert_matches_type(BrandStyleguideResponse, brand, path=["response"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize async def test_method_styleguide_with_all_params(self, async_client: AsyncBrandDev) -> None: brand = await async_client.brand.styleguide( @@ -869,7 +774,7 @@ async def test_method_styleguide_with_all_params(self, async_client: AsyncBrandD ) assert_matches_type(BrandStyleguideResponse, brand, path=["response"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize async def test_raw_response_styleguide(self, async_client: AsyncBrandDev) -> None: response = await async_client.brand.with_raw_response.styleguide( @@ -881,7 +786,7 @@ async def test_raw_response_styleguide(self, async_client: AsyncBrandDev) -> Non brand = await response.parse() assert_matches_type(BrandStyleguideResponse, brand, path=["response"]) - @pytest.mark.skip() + @pytest.mark.skip(reason="Prism tests are disabled") @parametrize async def test_streaming_response_styleguide(self, async_client: AsyncBrandDev) -> None: async with async_client.brand.with_streaming_response.styleguide( diff --git a/tests/test_client.py b/tests/test_client.py index a2b359c..7473b12 100644 --- a/tests/test_client.py +++ b/tests/test_client.py @@ -717,7 +717,7 @@ def test_retrying_timeout_errors_doesnt_leak(self, respx_mock: MockRouter, clien respx_mock.get("/brand/retrieve").mock(side_effect=httpx.TimeoutException("Test timeout error")) with pytest.raises(APITimeoutError): - client.brand.with_streaming_response.retrieve(domain="domain").__enter__() + client.brand.with_streaming_response.retrieve().__enter__() assert _get_open_connections(self.client) == 0 @@ -727,7 +727,7 @@ def test_retrying_status_errors_doesnt_leak(self, respx_mock: MockRouter, client respx_mock.get("/brand/retrieve").mock(return_value=httpx.Response(500)) with pytest.raises(APIStatusError): - client.brand.with_streaming_response.retrieve(domain="domain").__enter__() + client.brand.with_streaming_response.retrieve().__enter__() assert _get_open_connections(self.client) == 0 @pytest.mark.parametrize("failures_before_success", [0, 2, 4]) @@ -756,7 +756,7 @@ def retry_handler(_request: httpx.Request) -> httpx.Response: respx_mock.get("/brand/retrieve").mock(side_effect=retry_handler) - response = client.brand.with_raw_response.retrieve(domain="domain") + response = client.brand.with_raw_response.retrieve() assert response.retries_taken == failures_before_success assert int(response.http_request.headers.get("x-stainless-retry-count")) == failures_before_success @@ -780,9 +780,7 @@ def retry_handler(_request: httpx.Request) -> httpx.Response: respx_mock.get("/brand/retrieve").mock(side_effect=retry_handler) - response = client.brand.with_raw_response.retrieve( - domain="domain", extra_headers={"x-stainless-retry-count": Omit()} - ) + response = client.brand.with_raw_response.retrieve(extra_headers={"x-stainless-retry-count": Omit()}) assert len(response.http_request.headers.get_list("x-stainless-retry-count")) == 0 @@ -805,9 +803,7 @@ def retry_handler(_request: httpx.Request) -> httpx.Response: respx_mock.get("/brand/retrieve").mock(side_effect=retry_handler) - response = client.brand.with_raw_response.retrieve( - domain="domain", extra_headers={"x-stainless-retry-count": "42"} - ) + response = client.brand.with_raw_response.retrieve(extra_headers={"x-stainless-retry-count": "42"}) assert response.http_request.headers.get("x-stainless-retry-count") == "42" @@ -1538,7 +1534,7 @@ async def test_retrying_timeout_errors_doesnt_leak( respx_mock.get("/brand/retrieve").mock(side_effect=httpx.TimeoutException("Test timeout error")) with pytest.raises(APITimeoutError): - await async_client.brand.with_streaming_response.retrieve(domain="domain").__aenter__() + await async_client.brand.with_streaming_response.retrieve().__aenter__() assert _get_open_connections(self.client) == 0 @@ -1550,7 +1546,7 @@ async def test_retrying_status_errors_doesnt_leak( respx_mock.get("/brand/retrieve").mock(return_value=httpx.Response(500)) with pytest.raises(APIStatusError): - await async_client.brand.with_streaming_response.retrieve(domain="domain").__aenter__() + await async_client.brand.with_streaming_response.retrieve().__aenter__() assert _get_open_connections(self.client) == 0 @pytest.mark.parametrize("failures_before_success", [0, 2, 4]) @@ -1580,7 +1576,7 @@ def retry_handler(_request: httpx.Request) -> httpx.Response: respx_mock.get("/brand/retrieve").mock(side_effect=retry_handler) - response = await client.brand.with_raw_response.retrieve(domain="domain") + response = await client.brand.with_raw_response.retrieve() assert response.retries_taken == failures_before_success assert int(response.http_request.headers.get("x-stainless-retry-count")) == failures_before_success @@ -1605,9 +1601,7 @@ def retry_handler(_request: httpx.Request) -> httpx.Response: respx_mock.get("/brand/retrieve").mock(side_effect=retry_handler) - response = await client.brand.with_raw_response.retrieve( - domain="domain", extra_headers={"x-stainless-retry-count": Omit()} - ) + response = await client.brand.with_raw_response.retrieve(extra_headers={"x-stainless-retry-count": Omit()}) assert len(response.http_request.headers.get_list("x-stainless-retry-count")) == 0 @@ -1631,9 +1625,7 @@ def retry_handler(_request: httpx.Request) -> httpx.Response: respx_mock.get("/brand/retrieve").mock(side_effect=retry_handler) - response = await client.brand.with_raw_response.retrieve( - domain="domain", extra_headers={"x-stainless-retry-count": "42"} - ) + response = await client.brand.with_raw_response.retrieve(extra_headers={"x-stainless-retry-count": "42"}) assert response.http_request.headers.get("x-stainless-retry-count") == "42"