diff --git a/.codeboarding/Delivery API Interface.md b/.codeboarding/Delivery API Interface.md new file mode 100644 index 0000000..86a2d18 --- /dev/null +++ b/.codeboarding/Delivery API Interface.md @@ -0,0 +1,91 @@ +```mermaid +graph LR + DeliveryApiClient["DeliveryApiClient"] + DeliveryDataModels["DeliveryDataModels"] + DecisioningEngine["DecisioningEngine"] + SDKCore["SDKCore"] + SDKTools["SDKTools"] + SDKCore -- "Initiates API calls" --> DeliveryApiClient + SDKCore -- "Configures API client" --> DeliveryApiClient + DeliveryApiClient -- "Serializes/Deserializes" --> DeliveryDataModels + DeliveryApiClient -- "Uses for request/response structures" --> DeliveryDataModels + SDKCore -- "Constructs requests using" --> DeliveryDataModels + SDKCore -- "Processes responses from" --> DeliveryDataModels + DecisioningEngine -- "Constructs notifications using" --> DeliveryDataModels + DecisioningEngine -- "Validates requests using" --> DeliveryDataModels + SDKTools -- "Creates instances of" --> DeliveryDataModels + SDKTools -- "Manipulates" --> DeliveryDataModels + SDKCore -- "Leverages for internal decisioning" --> DecisioningEngine + DecisioningEngine -- "Utilizes helper functions from" --> SDKTools +``` +[![CodeBoarding](https://img.shields.io/badge/Generated%20by-CodeBoarding-9cf?style=flat-square)](https://github.com/CodeBoarding/GeneratedOnBoardings)[![Demo](https://img.shields.io/badge/Try%20our-Demo-blue?style=flat-square)](https://www.codeboarding.org/demo)[![Contact](https://img.shields.io/badge/Contact%20us%20-%20contact@codeboarding.org-lightgrey?style=flat-square)](mailto:contact@codeboarding.org) + +## Component Details + +The `target-python-sdk` provides a comprehensive interface for interacting with the Adobe Target Delivery API. It orchestrates the process of constructing and sending delivery requests, handling API responses, and performing client-side decisioning. The SDK leverages dedicated components for managing network communication, defining data structures, and implementing decisioning logic, ensuring efficient and structured interaction with the Adobe Target service. + +### DeliveryApiClient +This component is responsible for all network communication with the Adobe Target Delivery API. It manages the underlying HTTP requests, handles API configuration, processes responses, and deals with various API-related exceptions, acting as the primary interface for sending and receiving data from the Target service. It also handles request serialization, response deserialization, and error handling for network communication. + + +**Related Classes/Methods**: + +- `target-python-sdk.delivery_api_client.api.delivery_api.DeliveryApi` (27:209) +- `target-python-sdk.delivery_api_client.api_client.ApiClient` (39:723) +- `target-python-sdk.delivery_api_client.rest.RESTClientObject` (50:296) +- `target-python-sdk.delivery_api_client.configuration.Configuration` (39:311) +- `target-python-sdk.delivery_api_client.exceptions` (full file reference) + + +### DeliveryDataModels +This component defines the structured data models used for all requests and responses exchanged with the Adobe Target Delivery API. It provides the blueprints for various entities such as DeliveryRequest, DeliveryResponse, MboxResponse, Notification, and Context, ensuring consistent data formatting across the SDK and the API. + + +**Related Classes/Methods**: + +- `target-python-sdk.delivery_api_client.Model.delivery_request.DeliveryRequest` (19:463) +- `target-python-sdk.delivery_api_client.Model.delivery_response.DeliveryResponse` (19:300) +- `target-python-sdk.delivery_api_client.Model.mbox_response.MboxResponse` (19:252) +- `target-python-sdk.delivery_api_client.Model.notification.Notification` (19:440) +- `target-python-sdk.delivery_api_client.Model.context.Context` (19:379) +- `target-python-sdk.delivery_api_client.Model.geo.Geo` (19:286) +- `target-python-sdk.delivery_api_client.Model.visitor_id.VisitorId` (19:204) + + +### DecisioningEngine +This component encapsulates the internal logic for processing and managing decisions within the Target Python SDK. It handles tasks such as adding and sending notifications, validating incoming requests, and mapping geographical data, often interacting with the Delivery Data Models to structure its operations. + + +**Related Classes/Methods**: + +- `target_decisioning_engine.notification_provider.NotificationProvider` (29:114) +- `target_decisioning_engine.request_provider` (full file reference) +- `target_decisioning_engine.decision_provider.DecisionProvider` (60:313) +- `target_decisioning_engine.types.decision_provider_response.DecisionProviderResponse` (14:23) +- `target_decisioning_engine.geo_provider` (full file reference) + + +### SDKCore +This component represents the high-level interface and core orchestration logic of the Target Python SDK. It provides methods for initiating delivery requests, handling responses, and managing the overall interaction flow with the Target service, often leveraging helper functions for request construction and response processing. + + +**Related Classes/Methods**: + +- `target_python_sdk.helper` (full file reference) +- `target_python_sdk.target` (full file reference) +- `target_python_sdk.TargetClient` (full file reference) + + +### SDKTools +This component provides a set of utility functions and helper classes that support various operations within the Target Python SDK. These tools assist in tasks such as creating structured response objects, managing properties, and general data manipulation, contributing to the overall functionality and ease of use of the SDK. + + +**Related Classes/Methods**: + +- `target_tools.response_helpers` (full file reference) +- `target_tools.utils` (full file reference) + + + + +### [FAQ](https://github.com/CodeBoarding/GeneratedOnBoardings/tree/main?tab=readme-ov-file#faq) \ No newline at end of file diff --git a/.codeboarding/Local Decisioning Core.md b/.codeboarding/Local Decisioning Core.md new file mode 100644 index 0000000..4d8dca5 --- /dev/null +++ b/.codeboarding/Local Decisioning Core.md @@ -0,0 +1,174 @@ +```mermaid +graph LR + DecisionProvider["DecisionProvider"] + RuleEvaluator["RuleEvaluator"] + AllocationProvider["AllocationProvider"] + ArtifactProvider["ArtifactProvider"] + GeoProvider["GeoProvider"] + ContextProvider["ContextProvider"] + RequestProvider["RequestProvider"] + TraceProvider["TraceProvider"] + NotificationProvider["NotificationProvider"] + PostProcessors["PostProcessors"] + DecisionProvider -- "uses" --> RuleEvaluator + DecisionProvider -- "sends to" --> NotificationProvider + DecisionProvider -- "uses" --> ContextProvider + RuleEvaluator -- "uses" --> ContextProvider + RuleEvaluator -- "uses" --> AllocationProvider + DecisionProvider -- "uses" --> PostProcessors + ArtifactProvider -- "uses" --> TraceProvider + ContextProvider -- "uses" --> GeoProvider + ArtifactProvider -- "uses" --> GeoProvider +``` +[![CodeBoarding](https://img.shields.io/badge/Generated%20by-CodeBoarding-9cf?style=flat-square)](https://github.com/CodeBoarding/GeneratedOnBoardings)[![Demo](https://img.shields.io/badge/Try%20our-Demo-blue?style=flat-square)](https://www.codeboarding.org/demo)[![Contact](https://img.shields.io/badge/Contact%20us%20-%20contact@codeboarding.org-lightgrey?style=flat-square)](mailto:contact@codeboarding.org) + +## Component Details + +The Local Decisioning Core encapsulates the essential logic for evaluating rules and making personalized content decisions directly within the application. It orchestrates the retrieval and management of decisioning artifacts, constructs various context objects from input data, and handles the tracing and dispatching of notifications and telemetry related to local decisions. This core subsystem ensures efficient and accurate content delivery based on predefined rules and real-time contextual information. + +### DecisionProvider +Responsible for executing the core decisioning logic. It takes a delivery request, applies rules, and generates a decisioning response, handling both execute and prefetch requests. It also integrates with tracing and notification mechanisms. + + +**Related Classes/Methods**: + +- `target_python_sdk.target_decisioning_engine.decision_provider.DecisionProvider` (60:313) +- `target_python_sdk.target_decisioning_engine.decision_provider.DecisionProvider:__init__` (full file reference) +- `target_python_sdk.target_decisioning_engine.decision_provider.DecisionProvider:_get_decisions` (full file reference) +- `target_python_sdk.target_decisioning_engine.decision_provider.DecisionProvider:_prepare_notification` (full file reference) +- `target_python_sdk.target_decisioning_engine.decision_provider.DecisionProvider:_get_execute_decisions` (full file reference) +- `target_python_sdk.target_decisioning_engine.decision_provider.DecisionProvider:_get_prefetch_decisions` (full file reference) +- `target_python_sdk.target_decisioning_engine.decision_provider.DecisionProvider:run` (full file reference) + + +### RuleEvaluator +Evaluates decisioning rules against the provided context. It processes individual rules and determines if they match the current request and context, often involving context creation and allocation computations. + + +**Related Classes/Methods**: + +- `target_python_sdk.target_decisioning_engine.rule_evaluator.RuleEvaluator` (21:68) +- `target_python_sdk.target_decisioning_engine.rule_evaluator.RuleEvaluator:process_rule` (full file reference) + + +### AllocationProvider +Manages visitor ID generation and allocation computations. It ensures valid TNT IDs, creates UUIDs for new visitors, and calculates allocation based on memoized functions. + + +**Related Classes/Methods**: + +- `target_python_sdk.target_decisioning_engine.allocation_provider` (full file reference) +- `target_python_sdk.target_decisioning_engine.allocation_provider:valid_tnt_id` (full file reference) +- `target_python_sdk.target_decisioning_engine.allocation_provider:get_or_create_visitor_id` (full file reference) +- `target_python_sdk.target_decisioning_engine.allocation_provider:_calculate_allocation` (full file reference) +- `target_python_sdk.target_decisioning_engine.allocation_provider:compute_allocation` (full file reference) + + +### ArtifactProvider +Manages the decisioning artifact, which contains the rules and other data needed for decisioning. It handles initialization, polling for updates, fetching artifacts, and providing tracing for artifact-related operations. + + +**Related Classes/Methods**: + +- `target_python_sdk.target_decisioning_engine.artifact_provider.ArtifactProvider` (53:231) +- `target_python_sdk.target_decisioning_engine.artifact_provider.ArtifactProvider:__init__` (full file reference) +- `target_python_sdk.target_decisioning_engine.artifact_provider.ArtifactProvider:_get_polling_interval` (full file reference) +- `target_python_sdk.target_decisioning_engine.artifact_provider.ArtifactProvider:initialize` (full file reference) +- `target_python_sdk.target_decisioning_engine.artifact_provider.ArtifactProvider:_fetch_and_schedule` (full file reference) +- `target_python_sdk.target_decisioning_engine.artifact_provider.ArtifactProvider:resume_polling` (full file reference) +- `target_python_sdk.target_decisioning_engine.artifact_provider.ArtifactProvider:_get_initial_artifact` (full file reference) +- `target_python_sdk.target_decisioning_engine.artifact_provider.ArtifactProvider:_artifact_tracer_update` (full file reference) +- `target_python_sdk.target_decisioning_engine.artifact_provider.ArtifactProvider:get_trace` (full file reference) +- `target_python_sdk.target_decisioning_engine.artifact_provider.ArtifactProvider:_fetch_artifact` (full file reference) + + +### GeoProvider +Provides geographical context information for decisioning. + + +**Related Classes/Methods**: + +- `target_python_sdk.target_decisioning_engine.geo_provider.GeoProvider` (121:200) +- `target_python_sdk.target_decisioning_engine.geo_provider` (full file reference) + + +### ContextProvider +Responsible for creating various context objects (browser, URL, page, referring, geo, timing, and decisioning context) that are used during the decisioning process to evaluate rules. + + +**Related Classes/Methods**: + +- `target_python_sdk.target_decisioning_engine.context_provider` (full file reference) +- `target_python_sdk.target_decisioning_engine.context_provider:get_lower_case_attributes` (full file reference) +- `target_python_sdk.target_decisioning_engine.context_provider:_create_browser_context` (full file reference) +- `target_python_sdk.target_decisioning_engine.context_provider:_create_url_context` (full file reference) +- `target_python_sdk.target_decisioning_engine.context_provider:create_page_context` (full file reference) +- `target_python_sdk.target_decisioning_engine.context_provider:create_referring_context` (full file reference) +- `target_python_sdk.target_decisioning_engine.context_provider:with_lowercase_string_values` (full file reference) +- `target_python_sdk.target_decisioning_engine.context_provider:create_mbox_context` (full file reference) +- `target_python_sdk.target_decisioning_engine.context_provider:create_geo_context` (full file reference) +- `target_python_sdk.target_decisioning_engine.context_provider:_create_timing_context` (full file reference) +- `target_python_sdk.target_decisioning_engine.context_provider:create_decisioning_context` (full file reference) + + +### RequestProvider +Validates and processes incoming delivery requests. It checks for valid visitor IDs and ensures the overall delivery request structure is correct before further processing. + + +**Related Classes/Methods**: + +- `target_python_sdk.target_decisioning_engine.request_provider` (full file reference) +- `target_python_sdk.target_decisioning_engine.request_provider:get_customer_id` (full file reference) +- `target_python_sdk.target_decisioning_engine.request_provider:_no_ids` (full file reference) +- `target_python_sdk.target_decisioning_engine.request_provider:valid_visitor_id` (full file reference) +- `target_python_sdk.target_decisioning_engine.request_provider:valid_delivery_request` (full file reference) + + +### TraceProvider +Provides tracing capabilities for decisioning requests and artifact updates. It records details about request processing and rule evaluations to help in debugging and understanding the decision flow. + + +**Related Classes/Methods**: + +- `target_python_sdk.target_decisioning_engine.trace_provider.TraceProvider` (33:83) +- `target_python_sdk.target_decisioning_engine.trace_provider.RequestTracer` (86:217) +- `target_python_sdk.target_decisioning_engine.trace_provider.ArtifactTracer` (220:261) +- `target_python_sdk.target_decisioning_engine.trace_provider.TraceProvider:__init__` (full file reference) +- `target_python_sdk.target_decisioning_engine.trace_provider.RequestTracer:trace_request` (full file reference) +- `target_python_sdk.target_decisioning_engine.trace_provider.RequestTracer:trace_rule_evaluated` (full file reference) +- `target_python_sdk.target_decisioning_engine.trace_provider.RequestTracer:get_trace_result` (full file reference) +- `target_python_sdk.target_decisioning_engine.trace_provider.ArtifactTracer:__init__` (full file reference) + + +### NotificationProvider +Handles the creation and sending of notifications and telemetry data. It allows adding individual notifications and telemetry entries, and then sending them as part of a delivery request. + + +**Related Classes/Methods**: + +- `target_python_sdk.target_decisioning_engine.notification_provider.NotificationProvider` (29:114) +- `target_python_sdk.target_decisioning_engine.notification_provider.NotificationProvider:__init__` (full file reference) +- `target_python_sdk.target_decisioning_engine.notification_provider.NotificationProvider:add_notification` (full file reference) +- `target_python_sdk.target_decisioning_engine.notification_provider.NotificationProvider:add_telemetry_entry` (full file reference) +- `target_python_sdk.target_decisioning_engine.notification_provider.NotificationProvider:send_notifications` (full file reference) + + +### PostProcessors +Applies various post-processing steps to the decisioning responses, such as preparing execute and prefetch responses, adding response tokens, and replacing campaign macros within the content. + + +**Related Classes/Methods**: + +- `target_python_sdk.target_decisioning_engine.post_processors` (full file reference) +- `target_python_sdk.target_decisioning_engine.post_processors:prepare_execute_response` (full file reference) +- `target_python_sdk.target_decisioning_engine.post_processors:prepare_prefetch_response` (full file reference) +- `target_python_sdk.target_decisioning_engine.post_processors:create_response_tokens_post_processor` (full file reference) +- `target_python_sdk.target_decisioning_engine.post_processors:add_campaign_macro_values` (full file reference) +- `target_python_sdk.target_decisioning_engine.post_processors:update_action_campaign_content` (full file reference) +- `target_python_sdk.target_decisioning_engine.post_processors:update_option_campaign_content` (full file reference) +- `target_python_sdk.target_decisioning_engine.post_processors:replace_campaign_macros` (full file reference) + + + + +### [FAQ](https://github.com/CodeBoarding/GeneratedOnBoardings/tree/main?tab=readme-ov-file#faq) \ No newline at end of file diff --git a/.codeboarding/SDK Orchestrator.md b/.codeboarding/SDK Orchestrator.md new file mode 100644 index 0000000..b0f90da --- /dev/null +++ b/.codeboarding/SDK Orchestrator.md @@ -0,0 +1,134 @@ +```mermaid +graph LR + SDK_Orchestrator["SDK Orchestrator"] + Delivery_Helper["Delivery Helper"] + Cookie_Manager["Cookie Manager"] + Local_Decisioning_Engine_Integration["Local Decisioning Engine Integration"] + SDK_Types["SDK Types"] + Request_Validators["Request Validators"] + SDK_Orchestrator -- "initiates requests via" --> Delivery_Helper + SDK_Orchestrator -- "initializes" --> Local_Decisioning_Engine_Integration + SDK_Orchestrator -- "processes responses using" --> Delivery_Helper + Delivery_Helper -- "manages cookies via" --> Cookie_Manager + Delivery_Helper -- "selects API from" --> Local_Decisioning_Engine_Integration + Delivery_Helper -- "constructs" --> SDK_Types + SDK_Orchestrator -- "receives/sends" --> SDK_Types + SDK_Orchestrator -- "validates requests using" --> Request_Validators +``` +[![CodeBoarding](https://img.shields.io/badge/Generated%20by-CodeBoarding-9cf?style=flat-square)](https://github.com/CodeBoarding/GeneratedOnBoardings)[![Demo](https://img.shields.io/badge/Try%20our-Demo-blue?style=flat-square)](https://www.codeboarding.org/demo)[![Contact](https://img.shields.io/badge/Contact%20us%20-%20contact@codeboarding.org-lightgrey?style=flat-square)](mailto:contact@codeboarding.org) + +## Component Details + +This graph illustrates the structure and interactions within the Adobe Target Python SDK's core components. The SDK Orchestrator acts as the central entry point, managing the lifecycle of requests, from initialization and validation to fetching offers and sending notifications. It leverages the Delivery Helper for constructing and processing requests/responses, which in turn interacts with the Cookie Manager for cookie handling, and can utilize the Local Decisioning Engine Integration for client-side decisioning. All data structures are defined by the SDK Types component, ensuring consistent data flow across the system, and requests are validated by the Request Validators. + +### SDK Orchestrator +The primary entry point for interacting with the Adobe Target Python SDK. It orchestrates the entire process of fetching offers, sending notifications, and managing the SDK's lifecycle, including initialization and validation of requests. It can utilize either the local decisioning engine or make remote API calls, and provides helper functionalities for cookie management and request/response processing. + + +**Related Classes/Methods**: + +- `target-python-sdk.target_python_sdk.target.TargetClient` (full file reference) +- `target-python-sdk.target_python_sdk.target.TargetClient:__init__` (full file reference) +- `target-python-sdk.target_python_sdk.target.TargetClient:initialize` (full file reference) +- `target-python-sdk.target_python_sdk.target.TargetClient:create` (full file reference) +- `target-python-sdk.target_python_sdk.target.TargetClient:get_offers` (full file reference) +- `target-python-sdk.target_python_sdk.target.TargetClient:send_notifications` (full file reference) +- `target-python-sdk.target_python_sdk.target.TargetClient:get_attributes` (full file reference) +- `target-python-sdk.target_python_sdk.target:_create_request_context` (52:72) +- `target-python-sdk.target_python_sdk.target:execute_delivery` (75:139) +- `target-python-sdk.target_python_sdk.target:handle_delivery_response` (142:163) + + +### Delivery Helper +A utility module containing functions responsible for constructing various parts of a Target Delivery API request, such as headers, visitor IDs, context, and experience cloud details. It also handles the processing of delivery responses, extracting analytics, trace information, and response tokens, and manages Target-specific cookies. + + +**Related Classes/Methods**: + +- `target-python-sdk.target_python_sdk.helper` (full file reference) +- `target-python-sdk.target_python_sdk.helper:create_headers` (85:92) +- `target-python-sdk.target_python_sdk.helper:get_session_id` (95:106) +- `target-python-sdk.target_python_sdk.helper:get_target_host` (109:119) +- `target-python-sdk.target_python_sdk.helper:get_cluster` (147:150) +- `target-python-sdk.target_python_sdk.helper:create_delivery_api` (160:177) +- `target-python-sdk.target_python_sdk.helper:customer_ids_accumulator` (198:220) +- `target-python-sdk.target_python_sdk.helper:get_customer_ids` (223:233) +- `target-python-sdk.target_python_sdk.helper:create_visitor_id` (236:251) +- `target-python-sdk.target_python_sdk.helper:create_context` (259:266) +- `target-python-sdk.target_python_sdk.helper:get_location_hint` (269:274) +- `target-python-sdk.target_python_sdk.helper:create_audience_manager` (277:292) +- `target-python-sdk.target_python_sdk.helper:is_current_supplemental_data_id` (295:301) +- `target-python-sdk.target_python_sdk.helper:create_supplemental_data_id` (304:316) +- `target-python-sdk.target_python_sdk.helper:create_analytics` (319:327) +- `target-python-sdk.target_python_sdk.helper:create_experience_cloud` (330:342) +- `target-python-sdk.target_python_sdk.helper:valid_mbox` (345:350) +- `target-python-sdk.target_python_sdk.helper:create_mboxes` (353:358) +- `target-python-sdk.target_python_sdk.helper:valid_notification` (361:370) +- `target-python-sdk.target_python_sdk.helper:create_notifications` (373:379) +- `target-python-sdk.target_python_sdk.helper:create_configuration` (382:384) +- `target-python-sdk.target_python_sdk.helper:create_execute` (387:399) +- `target-python-sdk.target_python_sdk.helper:create_prefetch` (402:415) +- `target-python-sdk.target_python_sdk.helper:create_property` (418:420) +- `target-python-sdk.target_python_sdk.helper:create_request` (423:440) +- `target-python-sdk.target_python_sdk.helper:get_target_cookie` (443:463) +- `target-python-sdk.target_python_sdk.helper:extract_cluster_from_edge_host` (466:476) +- `target-python-sdk.target_python_sdk.helper:request_location_hint_cookie` (479:493) +- `target-python-sdk.target_python_sdk.helper:get_target_location_hint_cookie` (496:508) +- `target-python-sdk.target_python_sdk.helper:get_analytics_from_object` (511:517) +- `target-python-sdk.target_python_sdk.helper:get_analytics_from_list` (520:524) +- `target-python-sdk.target_python_sdk.helper:get_analytics_details` (527:550) +- `target-python-sdk.target_python_sdk.helper:get_trace_from_object` (553:559) +- `target-python-sdk.target_python_sdk.helper:get_trace_from_list` (562:566) +- `target-python-sdk.target_python_sdk.helper:get_trace_details` (569:592) +- `target-python-sdk.target_python_sdk.helper:get_response_tokens_from_object` (595:601) +- `target-python-sdk.target_python_sdk.helper:get_response_tokens_from_list` (604:608) +- `target-python-sdk.target_python_sdk.helper:get_response_tokens` (611:634) +- `target-python-sdk.target_python_sdk.helper:get_response_meta` (637:651) +- `target-python-sdk.target_python_sdk.helper:process_response` (654:675) + + +### Cookie Manager +This component is responsible for the serialization and deserialization of Target-specific cookies. It handles parsing incoming cookies and creating outgoing cookies, including managing their expiration. + + +**Related Classes/Methods**: + +- `target-python-sdk.target_python_sdk.cookies` (full file reference) +- `target-python-sdk.target_python_sdk.cookies:deserialize_cookie` (43:58) +- `target-python-sdk.target_python_sdk.cookies:get_max_expires` (75:77) +- `target-python-sdk.target_python_sdk.cookies:parse_cookies` (80:90) +- `target-python-sdk.target_python_sdk.cookies:create_target_cookie` (93:103) + + +### Local Decisioning Engine Integration +This component provides the interface for executing Target delivery requests locally, leveraging a decisioning engine for client-side decisioning. It acts as an alternative to the remote Delivery API when local decisioning is enabled. + + +**Related Classes/Methods**: + +- `target-python-sdk.target_python_sdk.local_delivery_api.LocalDeliveryApi` (15:33) +- `target-python-sdk.target_python_sdk.local_delivery_api.LocalDeliveryApi:execute` (24:33) + + +### SDK Types +This component defines the core data structures and models used throughout the Target Python SDK, ensuring consistent data representation for requests and responses. + + +**Related Classes/Methods**: + +- `target-python-sdk.target_python_sdk.types.target_delivery_response.TargetDeliveryResponse` (14:32) +- `target-python-sdk.target_python_sdk.types.target_delivery_response.TargetDeliveryResponse:__init__` (27:29) + + +### Request Validators +This component is responsible for validating incoming requests and configurations to ensure they meet the required specifications before processing. + + +**Related Classes/Methods**: + +- `target-python-sdk.target_python_sdk.validators` (full file reference) + + + + +### [FAQ](https://github.com/CodeBoarding/GeneratedOnBoardings/tree/main?tab=readme-ov-file#faq) \ No newline at end of file diff --git a/.codeboarding/SDK Samples.md b/.codeboarding/SDK Samples.md new file mode 100644 index 0000000..07d5566 --- /dev/null +++ b/.codeboarding/SDK Samples.md @@ -0,0 +1,106 @@ +```mermaid +graph LR + Application_Orchestration["Application Orchestration"] + Target_API_Client["Target API Client"] + Request_Data_Preparation["Request Data Preparation"] + Delivery_API_Data_Models["Delivery API Data Models"] + General_Utilities["General Utilities"] + Application_Orchestration -- "prepares request data using" --> Request_Data_Preparation + Application_Orchestration -- "invokes Target API for" --> Target_API_Client + Application_Orchestration -- "instantiates" --> Delivery_API_Data_Models + Target_API_Client -- "obtains request details from" --> Request_Data_Preparation + Target_API_Client -- "constructs requests with" --> Delivery_API_Data_Models + Request_Data_Preparation -- "creates instances of" --> Delivery_API_Data_Models + Application_Orchestration -- "utilizes" --> General_Utilities +``` +[![CodeBoarding](https://img.shields.io/badge/Generated%20by-CodeBoarding-9cf?style=flat-square)](https://github.com/CodeBoarding/GeneratedOnBoardings)[![Demo](https://img.shields.io/badge/Try%20our-Demo-blue?style=flat-square)](https://www.codeboarding.org/demo)[![Contact](https://img.shields.io/badge/Contact%20us%20-%20contact@codeboarding.org-lightgrey?style=flat-square)](mailto:contact@codeboarding.org) + +## Component Details + +The SDK Samples component provides practical examples demonstrating the usage of the Adobe Target Python SDK. It showcases how to prepare request data, interact with the Target Delivery API for various scenarios like page loads, mbox calls, and prefetching, and handle notifications. The samples are structured to illustrate the typical flow of integrating with Adobe Target, from setting up request parameters to processing API responses. + +### Application Orchestration +This component represents the high-level application logic that orchestrates calls to the Target API Client and manages the overall flow of Target interactions, including handling different types of requests (page load, mbox, prefetch views) and notifications. + + +**Related Classes/Methods**: + +- `target_python_sdk.samples.app:execute_page_load` (full file reference) +- `target_python_sdk.samples.app:execute_mbox` (full file reference) +- `target_python_sdk.samples.app:prefetch_mbox` (full file reference) +- `target_python_sdk.samples.app:get_offers_callback` (full file reference) +- `target_python_sdk.samples.app:get_target_delivery_response_async_callback` (full file reference) +- `target_python_sdk.samples.app:get_target_delivery_response_async_await` (full file reference) +- `target_python_sdk.samples.app:get_target_delivery_response` (full file reference) +- `target_python_sdk.samples.app:prefetch_view` (full file reference) +- `target_python_sdk.samples.app:prefetch_view_asyncio` (full file reference) +- `target_python_sdk.samples.app:_get_all_view_notifications` (full file reference) +- `target_python_sdk.samples.app:_get_all_mbox_notifications` (full file reference) +- `target_python_sdk.samples.app:send_notifications` (full file reference) + + +### Target API Client +This component serves as the primary interface for interacting with the Adobe Target Delivery API. It encapsulates the logic for constructing various types of delivery requests (page load, mbox, prefetch, notifications) and handling their responses. + + +**Related Classes/Methods**: + +- `target_python_sdk.samples.target_client_service.TargetClientService:get_page_load_target_delivery_response` (full file reference) +- `target_python_sdk.samples.target_client_service.TargetClientService:get_mbox_target_delivery_response` (full file reference) +- `target_python_sdk.samples.target_client_service.TargetClientService:prefetch_views_target_delivery_response` (full file reference) +- `target_python_sdk.samples.target_client_service.TargetClientService:prefetch_views_target_delivery_response_asyncio` (full file reference) +- `target_python_sdk.samples.target_client_service.TargetClientService:send_notifications` (full file reference) +- `target_python_sdk.samples.target_client_service:_get_prefetch_views_request` (full file reference) + + +### Request Data Preparation +This component is responsible for preparing and extracting data related to Target requests, including handling cookies, addresses, context, and visitor IDs. It acts as a utility layer for common request-related operations. + + +**Related Classes/Methods**: + +- `target_python_sdk.samples.target_request_utils:get_target_cookie` (full file reference) +- `target_python_sdk.samples.target_request_utils:get_location_hint_cookie` (full file reference) +- `target_python_sdk.samples.target_request_utils:set_target_cookies` (full file reference) +- `target_python_sdk.samples.target_request_utils:get_address` (full file reference) +- `target_python_sdk.samples.target_request_utils:get_context` (full file reference) +- `target_python_sdk.samples.target_request_utils:get_visitor_id` (full file reference) +- `target_python_sdk.samples.target_request_utils:initialize_options` (full file reference) +- `target_python_sdk.samples.target_request_utils.get_cookie` (full file reference) +- `target_python_sdk.samples.target_request_utils.set_cookie` (full file reference) +- `target_python_sdk.samples.target_request_utils.get_uuid` (full file reference) + + +### Delivery API Data Models +This component encompasses all the data structures and models defined by the `delivery_api_client` for representing various entities in Target API requests and responses, such as addresses, contexts, visitor IDs, mbox requests, view requests, and notifications. + + +**Related Classes/Methods**: + +- `delivery_api_client.Model.address.Address` (19:146) +- `delivery_api_client.Model.context.Context` (19:379) +- `delivery_api_client.Model.visitor_id.VisitorId` (19:204) +- `delivery_api_client.Model.mbox_request.MboxRequest` (19:276) +- `delivery_api_client.Model.view_request.ViewRequest` (19:280) +- `delivery_api_client.Model.notification.Notification` (19:440) +- `delivery_api_client.Model.notification_view.NotificationView` (19:174) +- `delivery_api_client.Model.notification_mbox.NotificationMbox` (19:144) +- `delivery_api_client.Model.prefetch_request.PrefetchRequest` (19:168) +- `delivery_api_client.Model.delivery_request.DeliveryRequest` (19:463) +- `delivery_api_client.Model.customer_id.CustomerId` (19:173) +- `delivery_api_client.Model.execute_request.ExecuteRequest` (19:140) +- `delivery_api_client.Model.request_details.RequestDetails` (19:220) + + +### General Utilities +This component provides miscellaneous utility functions that are not specific to Target request processing but are used by other components, such as time-related utilities. + + +**Related Classes/Methods**: + +- `target_tools.utils.get_epoch_time_milliseconds` (247:250) + + + + +### [FAQ](https://github.com/CodeBoarding/GeneratedOnBoardings/tree/main?tab=readme-ov-file#faq) \ No newline at end of file diff --git a/.codeboarding/Shared Utilities.md b/.codeboarding/Shared Utilities.md new file mode 100644 index 0000000..2d091be --- /dev/null +++ b/.codeboarding/Shared Utilities.md @@ -0,0 +1,45 @@ +```mermaid +graph LR + Shared_Utilities["Shared Utilities"] + DecisioningEngineCore -- "Leverages utilities" --> Shared_Utilities + DecisioningEngineCore -- "Utilizes data structures" --> Shared_Utilities + ContextRequestProcessing -- "Uses utilities" --> Shared_Utilities + ContextRequestProcessing -- "Utilizes data structures" --> Shared_Utilities + ResponseNotificationHandling -- "Applies utilities" --> Shared_Utilities + ResponseNotificationHandling -- "Uses response helpers" --> Shared_Utilities + SDKClientInterface -- "Employs utilities" --> Shared_Utilities + SDKClientInterface -- "Manages events and attributes" --> Shared_Utilities + ArtifactDataManagement -- "Uses utilities" --> Shared_Utilities + ArtifactDataManagement -- "Utilizes data structures" --> Shared_Utilities + AllocationLogic -- "Uses utilities" --> Shared_Utilities + AllocationLogic -- "Performs data checks" --> Shared_Utilities +``` +[![CodeBoarding](https://img.shields.io/badge/Generated%20by-CodeBoarding-9cf?style=flat-square)](https://github.com/CodeBoarding/GeneratedOnBoardings)[![Demo](https://img.shields.io/badge/Try%20our-Demo-blue?style=flat-square)](https://www.codeboarding.org/demo)[![Contact](https://img.shields.io/badge/Contact%20us%20-%20contact@codeboarding.org-lightgrey?style=flat-square)](mailto:contact@codeboarding.org) + +## Component Details + +This graph illustrates the central role of the `Shared Utilities` component within the SDK. It acts as a foundational layer, providing essential general-purpose utility functions, performance monitoring tools, event handling mechanisms, attribute management, and core data structures. Various other key components of the SDK, such as the `DecisioningEngineCore`, `ContextRequestProcessing`, `ResponseNotificationHandling`, `SDKClientInterface`, `ArtifactDataManagement`, and `AllocationLogic`, extensively interact with and rely on `Shared Utilities` to perform their respective functions, ensuring consistency, reusability, and efficient operation across the system. + +### Shared Utilities +A collection of general-purpose utility functions, performance tools, event handling, attribute management, and data structure helpers used across various modules of the SDK, ensuring consistency and reusability. + + +**Related Classes/Methods**: + +- `target-python-sdk.target_tools.response_helpers` (full file reference) +- `target-python-sdk.target_tools.client_info` (full file reference) +- `target-python-sdk.target_tools.perf_tool._PerfTool` (19:75) +- `target-python-sdk.target_tools.event_provider.EventProvider` (28:74) +- `target-python-sdk.target_tools.attributes_provider.AttributesProvider` (36:70) +- `target-python-sdk.target_tools.hashing` (full file reference) +- `target-python-sdk.target_tools.utils` (full file reference) +- `target-python-sdk.target_tools.types.limited_key_dict.LimitedKeyDict` (13:39) +- `target-python-sdk.target_decisioning_engine.post_processors` (full file reference) +- `target-python-sdk.target_decisioning_engine.utils` (full file reference) +- `target-python-sdk.target_decisioning_engine.types.decisioning_artifact` (full file reference) +- `target-python-sdk.target_decisioning_engine.types.decisioning_context` (full file reference) + + + + +### [FAQ](https://github.com/CodeBoarding/GeneratedOnBoardings/tree/main?tab=readme-ov-file#faq) \ No newline at end of file diff --git a/.codeboarding/on_boarding.md b/.codeboarding/on_boarding.md new file mode 100644 index 0000000..ab200fc --- /dev/null +++ b/.codeboarding/on_boarding.md @@ -0,0 +1,114 @@ +```mermaid +graph LR + SDK_Orchestrator["SDK Orchestrator"] + Local_Decisioning_Core["Local Decisioning Core"] + Delivery_API_Interface["Delivery API Interface"] + Shared_Utilities["Shared Utilities"] + SDK_Samples["SDK Samples"] + SDK_Orchestrator -- "orchestrates" --> Local_Decisioning_Core + SDK_Orchestrator -- "orchestrates" --> Delivery_API_Interface + SDK_Orchestrator -- "utilizes" --> Shared_Utilities + Local_Decisioning_Core -- "utilizes" --> Shared_Utilities + Local_Decisioning_Core -- "sends data via" --> Delivery_API_Interface + Delivery_API_Interface -- "utilizes" --> Shared_Utilities + SDK_Samples -- "interacts with" --> SDK_Orchestrator + click SDK_Orchestrator href "https://github.com/CodeBoarding/GeneratedOnBoardings/blob/main/target-python-sdk/SDK Orchestrator.md" "Details" + click Local_Decisioning_Core href "https://github.com/CodeBoarding/GeneratedOnBoardings/blob/main/target-python-sdk/Local Decisioning Core.md" "Details" + click Delivery_API_Interface href "https://github.com/CodeBoarding/GeneratedOnBoardings/blob/main/target-python-sdk/Delivery API Interface.md" "Details" + click Shared_Utilities href "https://github.com/CodeBoarding/GeneratedOnBoardings/blob/main/target-python-sdk/Shared Utilities.md" "Details" + click SDK_Samples href "https://github.com/CodeBoarding/GeneratedOnBoardings/blob/main/target-python-sdk/SDK Samples.md" "Details" +``` +[![CodeBoarding](https://img.shields.io/badge/Generated%20by-CodeBoarding-9cf?style=flat-square)](https://github.com/CodeBoarding/GeneratedOnBoardings)[![Demo](https://img.shields.io/badge/Try%20our-Demo-blue?style=flat-square)](https://www.codeboarding.org/demo)[![Contact](https://img.shields.io/badge/Contact%20us%20-%20contact@codeboarding.org-lightgrey?style=flat-square)](mailto:contact@codeboarding.org) + +## Component Details + +This graph illustrates the high-level architecture of the `target-python-sdk`, detailing its core components and their interactions. The main flow involves the `SDK Orchestrator` handling requests, which can be processed either locally by the `Local Decisioning Core` or remotely via the `Delivery API Interface`. Both core functionalities rely on `Shared Utilities` for common operations, and `SDK Samples` demonstrate typical usage patterns. + +### SDK Orchestrator +The primary entry point for interacting with the Adobe Target Python SDK. It orchestrates the entire process of fetching offers, sending notifications, and managing the SDK's lifecycle, including initialization and validation of requests. It can utilize either the local decisioning engine or make remote API calls, and provides helper functionalities for cookie management and request/response processing. + + +**Related Classes/Methods**: + +- `target-python-sdk.target_python_sdk.target.TargetClient` (full file reference) +- `target-python-sdk.target_python_sdk.local_delivery_api.LocalDeliveryApi` (15:33) +- `target-python-sdk.target_python_sdk.validators` (full file reference) +- `target-python-sdk.target_python_sdk.helper` (full file reference) +- `target-python-sdk.target_python_sdk.cookies` (full file reference) +- `target-python-sdk.target_python_sdk.types.target_delivery_response.TargetDeliveryResponse` (14:32) + + +### Local Decisioning Core +Encapsulates the core logic for evaluating rules and making personalized content decisions locally. It manages decisioning artifacts, constructs various context objects from input data, and handles tracing and dispatching of notifications and telemetry related to local decisions. + + +**Related Classes/Methods**: + +- `target-python-sdk.target_decisioning_engine.decision_provider.DecisionProvider` (60:313) +- `target-python-sdk.target_decisioning_engine.rule_evaluator.RuleEvaluator` (21:68) +- `target-python-sdk.target_decisioning_engine.allocation_provider` (full file reference) +- `target-python-sdk.target_decisioning_engine.filters` (full file reference) +- `target-python-sdk.target_decisioning_engine.artifact_provider.ArtifactProvider` (53:231) +- `target-python-sdk.target_decisioning_engine.geo_provider.GeoProvider` (121:200) +- `target-python-sdk.target_decisioning_engine.context_provider` (full file reference) +- `target-python-sdk.target_decisioning_engine.request_provider` (full file reference) +- `target-python-sdk.target_decisioning_engine.trace_provider.TraceProvider` (33:83) +- `target-python-sdk.target_decisioning_engine.trace_provider.RequestTracer` (86:217) +- `target-python-sdk.target_decisioning_engine.trace_provider.ArtifactTracer` (220:261) +- `target-python-sdk.target_decisioning_engine.notification_provider.NotificationProvider` (29:114) + + +### Delivery API Interface +Provides the low-level interface for making HTTP requests to the Adobe Target Delivery API. It handles request serialization, response deserialization, error handling for network communication, and defines the data models for all requests and responses exchanged with the API. + + +**Related Classes/Methods**: + +- `target-python-sdk.delivery_api_client.api.delivery_api.DeliveryApi` (27:209) +- `target-python-sdk.delivery_api_client.api_client.ApiClient` (39:723) +- `target-python-sdk.delivery_api_client.rest.RESTClientObject` (50:296) +- `target-python-sdk.delivery_api_client.configuration.Configuration` (39:311) +- `target-python-sdk.delivery_api_client.exceptions` (full file reference) +- `target-python-sdk.delivery_api_client.Model.delivery_request.DeliveryRequest` (19:463) +- `target-python-sdk.delivery_api_client.Model.delivery_response.DeliveryResponse` (19:300) +- `target-python-sdk.delivery_api_client.Model.mbox_response.MboxResponse` (19:252) +- `target-python-sdk.delivery_api_client.Model.notification.Notification` (19:440) +- `target-python-sdk.delivery_api_client.Model.context.Context` (19:379) +- `target-python-sdk.delivery_api_client.Model.geo.Geo` (19:286) +- `target-python-sdk.delivery_api_client.Model.visitor_id.VisitorId` (19:204) + + +### Shared Utilities +A collection of general-purpose utility functions, performance tools, event handling, attribute management, and data structure helpers used across various modules of the SDK, ensuring consistency and reusability. + + +**Related Classes/Methods**: + +- `target-python-sdk.target_tools.response_helpers` (full file reference) +- `target-python-sdk.target_tools.client_info` (full file reference) +- `target-python-sdk.target_tools.perf_tool._PerfTool` (19:75) +- `target-python-sdk.target_tools.event_provider.EventProvider` (28:74) +- `target-python-sdk.target_tools.attributes_provider.AttributesProvider` (36:70) +- `target-python-sdk.target_tools.hashing` (full file reference) +- `target-python-sdk.target_tools.utils` (full file reference) +- `target-python-sdk.target_tools.types.limited_key_dict.LimitedKeyDict` (13:39) +- `target-python-sdk.target_decisioning_engine.post_processors` (full file reference) +- `target-python-sdk.target_decisioning_engine.utils` (full file reference) +- `target-python-sdk.target_decisioning_engine.types.decisioning_artifact` (full file reference) +- `target-python-sdk.target_decisioning_engine.types.decisioning_context` (full file reference) + + +### SDK Samples +Contains example code demonstrating how to use the Adobe Target Python SDK for various scenarios, serving as a guide for developers. + + +**Related Classes/Methods**: + +- `target-python-sdk.samples.app` (full file reference) +- `target-python-sdk.samples.target_client_service` (full file reference) +- `target-python-sdk.samples.target_request_utils` (full file reference) + + + + +### [FAQ](https://github.com/CodeBoarding/GeneratedOnBoardings/tree/main?tab=readme-ov-file#faq) \ No newline at end of file