> ## Documentation Index
> Fetch the complete documentation index at: https://docs.kameleoon.com/llms.txt
> Use this file to discover all available pages before exploring further.
# Python SDK
> Integrieren Sie das Kameleoon Python SDK, um Experimente auszuführen und Feature Flags auf Python-Backend-Servern zu aktivieren, einschließlich Django-Umgebungen.
Mit dem Python SDK können Sie Experimente ausführen und Feature Flags auf Ihrem Python-Backend-Server aktivieren. Die Integration unseres SDK in Ihre Webanwendung ist einfach, und sein Footprint (Speicher- und Netzwerknutzung) ist gering.
**Erste Schritte**: Hilfe für den Einstieg finden Sie im [Entwicklerhandbuch](#entwicklerhandbuch).
**Changelog**: Aktuelle Version des Python SDK: 3.18.0 [Changelog](https://github.com/Kameleoon/client-python/blob/main/CHANGELOG.md).
**SDK-Methoden**: Die vollständige Referenzdokumentation des Python SDK finden Sie im Abschnitt [Referenz](#referenz).
## Entwicklerhandbuch
Dieses Handbuch soll Ihnen helfen, unser SDK in wenigen Minuten zu integrieren und Experimente in Ihren Python-Anwendungen auszuführen. Dieses Tutorial erklärt die Einrichtung eines einfachen A/B Tests, um die Anzahl der empfohlenen Produkte basierend auf verschiedenen Variationen zu ändern.
### Erste Schritte
#### Installation des Python-Clients
Sie können das SDK mit einem Python-pip-Paket installieren. Unser Paket wird im offiziellen pip-Repository gehostet, sodass Sie nur den folgenden Befehl ausführen müssen:
```python theme={null}
pip install kameleoon-client-python
```
#### Zusätzliche Konfiguration
Sie müssen die Anmeldedaten für das Python SDK über eine Konfigurationsdatei bereitstellen, die Sie auch verwenden können, um das Verhalten des SDK anzupassen. Eine Beispielkonfigurationsdatei [kann hier abgerufen werden](/assets/developer-docs/sdks/web-sdks/client-configs/client-python.yaml). Wir empfehlen, diese Datei in den Standardpfad `/etc/kameleoon/client-python.yaml` zu installieren, Sie können sie jedoch auch an einem anderen Ort ablegen und den Pfad als Argument an die `KameleoonClient()`-Konstruktormethode übergeben. Mit der aktuellen Version des Python SDK sind dies die verfügbaren Schlüssel:
| Schlüssel | Beschreibung | Standardwert |
| --------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------- |
| `client_id` (*erforderlich*) | Erforderlich für die Authentifizierung beim Kameleoon-Dienst. Um Ihre **client id** zu finden, lesen Sie die [API credentials](/user-manual/account-and-team-management/users-and-teams/api-credentials)-Dokumentation. | |
| `client_secret` (*erforderlich*) | Erforderlich für die Authentifizierung beim Kameleoon-Dienst. Um Ihr **client secret** zu finden, lesen Sie die [API credentials](/user-manual/account-and-team-management/users-and-teams/api-credentials)-Dokumentation. | |
| `session_duration_minute` (*optional*) | Bezeichnet das vordefinierte Zeitintervall, in dem Kameleoon den Besucher und die zugehörigen Daten im Speicher (RAM) speichert. Beachten Sie, dass eine Verlängerung der Sitzungsdauer den RAM-Bedarf zur Speicherung der Besucherdaten erhöht. | `30` Minuten |
| `refresh_interval_minute` (*optional*) | Gibt das Aktualisierungsintervall in Minuten an, in dem das SDK die Konfiguration der aktiven Experimente und Feature Flags abruft. Der Wert bestimmt die maximale Zeit, die benötigt wird, um Änderungen wie das Aktivieren oder Deaktivieren von Feature Flags oder das Starten von Experimenten auf Ihre Produktionsserver zu übertragen. Zusätzlich bieten wir einen [Streaming-Modus](/developer-docs/feature-experimentation/technical-reference/technical-considerations/#streaming-premium-option) an, der Server-Sent Events (SSE) verwendet, um neue Konfigurationen automatisch an das SDK zu übermitteln und in Echtzeit ohne Verzögerungen anzuwenden. | `60` Minuten |
| `default_timeout_millisecond` (*optional*) | Gibt das Timeout in Millisekunden für Netzwerkanfragen vom SDK an. Setzen Sie den Wert auf 30 Sekunden oder mehr, wenn Sie keine stabile Verbindung haben. Einige Methoden verfügen über einen zusätzlichen Parameter, mit dem Sie das Standard-Timeout für diese bestimmte Methode überschreiben können. Wenn Sie das Timeout für eine Methode nicht explizit angeben, verwendet das SDK diesen Standardwert. | `10000` Millisekunden |
| `tracking_interval_millisecond` (*optional*) | Gibt das Intervall für Tracking-Anfragen in Millisekunden an. Alle Besucher, die Kameleoon für ein Feature Flag ausgewertet hat oder deren Daten geflusht wurden, sind in dieser Tracking-Anfrage enthalten, die das SDK einmal pro Intervall durchführt. Der Mindestwert ist `1000` ms, was auch der Standardwert ist, und der Höchstwert ist `5000` ms. | `1000` Millisekunden |
| `environment` (*optional*) | Umgebung, aus der die Konfiguration des Feature Flags verwendet werden soll. Der Wert kann `production`, `staging`, `development` sein. Weitere Informationen finden Sie im Artikel [Umgebungen verwalten](/user-manual/experimentation/feature-experimentation/configure-your-feature-flags/manage-environments). | `production` |
| `top_level_domain` *(im Hybrid-Modus erforderlich)* | Die aktuelle Top-Level-Domain für Ihre Website. Verwenden Sie das Format: `example.com`. Geben Sie nicht `https://`, `www` oder andere Subdomains an. Kameleoon verwendet diese Information, um das entsprechende Cookie auf der Top-Level-Domain zu setzen. | `""` |
| `network_domain` (*optional*) | Benutzerdefinierte Domain, die von SDKs für ausgehende Anfragen verwendet wird, oft für Proxying. Muss eine gültige Domain sein (z. B. example.com oder sub.example.com). Ungültige Formate werden auf den Standardwert von Kameleoon zurückgesetzt. | `None` |
| `logger` *(veraltet)* | Ermöglicht das Überschreiben des Standard-Python-Loggers. Dieses Feld ist veraltet und wird in der SDK-Version `4.0.0` entfernt. Verwenden Sie stattdessen [`KameleoonLogger.set_logger()`](#logging). | `logging.Logger` |
| `multi_threading` *(veraltet)* | Eine Option vom Typ `bool`, die angibt, ob Threads für Netzwerkanfragen verwendet werden können. Standardmäßig wird alles in einem Thread ausgeführt, um Performance-Probleme mit dem GIL zu vermeiden, falls der (C)Python-Interpreter verwendet wird. Mögliche Werte: `True`, `False`. | `None` |
Alternativ können Sie `configuration_object` vom Typ `KameleoonClientConfig` als Parameter während der Initialisierung verwenden. Es hat die gleiche Liste von Argumenten wie eine Konfigurationsdatei. `configuration_object` hat Vorrang vor der Konfigurationsdatei und überschreibt deren Einstellungen.
#### Initialisierung des Kameleoon-Clients
Nachdem Sie das SDK in Ihre Anwendung installiert, die korrekten Anmeldedaten (in `/etc/kameleoon/client-python.yaml`) konfiguriert und ein serverseitiges Experiment im Backoffice von Kameleoon eingerichtet haben, besteht der nächste Schritt darin, den Kameleoon-Client in Ihrem Anwendungscode zu erstellen.
Der Code rechts gibt ein klares Beispiel. Ein `KameleoonClient` ist ein Singleton-Objekt, das als Brücke zwischen Ihrer Anwendung und der Kameleoon-Plattform fungiert. Er enthält alle Methoden und Eigenschaften, die Sie zur Durchführung eines Experiments benötigen.
Entwickler sind dafür verantwortlich, die korrekte Logik ihres Anwendungscodes bei der Implementierung von A/B Testing mit Kameleoon sicherzustellen. Eine bewährte Praxis besteht darin, immer davon auszugehen, dass ein Besucher vom Experiment ausgeschlossen werden kann, wenn es noch nicht gestartet wurde. Diese Praxis ist einfach zu implementieren, da sie mit der Standard- oder Referenzvariation-Logik übereinstimmt, die immer vorhanden sein sollte. Die Code-Beispiele im nächsten Abschnitt zeigen diesen Ansatz.
```python theme={null}
from kameleoon import KameleoonClient, KameleoonClientConfig, KameleoonClientFactory
SITE_CODE = 'a8st4f59bj'
# Option 1
kameleoon_client = KameleoonClientFactory.create(SITE_CODE, config_path='/etc/kameleoon/client-python.yaml')
# Option 2
configuration_object = KameleoonClientConfig.read_from_yaml('/etc/kameleoon/client-python.yaml')
configuration_object.set_top_level_domain("example.com")
kameleoon_client = KameleoonClientFactory.create(SITE_CODE, configuration_object)
# Option 3
configuration_object = KameleoonClientConfig(
"client_id", # required
"client_secret", # required
refresh_interval_minute=60, # (in minutes) optional, default: 60 minutes
session_duration_minute=30, # (in minutes) optional, default: 30 minutes
default_timeout_millisecond=10000, # (in milliseconds) optional, default: 10000 milliseconds
tracking_interval_millisecond=1000, # (in milliseconds) optional, default: 1000 milliseconds
environment="production", # optional, possible values: "production" / "staging" / "development" / "staging", default: None
top_level_domain="example.com",
multi_threading=False, # optional, default: False
logger=my_logger, # optional, default: standard kameleoon logger. This field is deprecated and will be removed in SDK version `4.0.0`. Use `KameleoonLogger.set_logger` instead.
network_domain="example.com", # optional
)
kameleoon_client = KameleoonClientFactory.create(SITE_CODE, configuration_object)
```
#### Aktivierung eines Feature Flags
##### Zuweisung einer eindeutigen ID an einen Benutzer
Um einem Benutzer eine eindeutige ID zuzuweisen, können Sie die Methode [`get_visitor_code()`](#get_visitor_code) verwenden. Wenn ein **visitor code** nicht existiert (aus dem Cookie der Request-Header), generiert die Methode eine zufällige eindeutige ID oder verwendet einen `default_visitor_code`, den Sie generiert hätten. Die ID wird dann in einem Cookie der Response-Header gesetzt.
Wenn Sie Kameleoon im [Hybrid-Modus](/developer-docs/feature-experimentation/get-started/hybrid-experimentation) verwenden, stellt der Aufruf der Methode `get_visitor_code()` sicher, dass die eindeutige ID (**visitor code**) zwischen der Anwendungsdatei `engine.js` (zuvor `kameleoon.js`) und dem SDK geteilt wird.
##### Abrufen einer Flag-Konfiguration
Um ein Feature Flag in Ihrem Code zu implementieren, müssen Sie zunächst das Feature Flag in Ihrem Kameleoon-Konto erstellen.
Um den Status oder die Variation eines Feature Flags für einen bestimmten Benutzer zu ermitteln, sollten Sie die Methode [`get_variation()`](#get_variation) oder [`is_feature_active()`](#is_feature_active) verwenden, um die Konfiguration basierend auf dem `feature_key` abzurufen.
Die Methode `get_variation()` verarbeitet sowohl einfache Feature Flags mit ON/OFF-Zuständen als auch komplexere Flags mit mehreren Variationen. Die Methode ruft die entsprechende Variation für den Benutzer ab, indem sie die Feature-Regeln überprüft, die Variation zuweist und sie basierend auf dem `feature_key` und `visitor_code` zurückgibt.
Die Methode `is_feature_active()` kann verwendet werden, wenn Sie die Konfiguration eines einfachen Feature Flags abrufen möchten, das nur einen ON- oder OFF-Zustand hat, im Gegensatz zu komplexeren Feature Flags mit mehreren Variationen oder Targeting-Optionen.
Wenn Ihr Feature Flag zugehörige Variablen hat (wie z. B. spezifische Verhaltensweisen, die an jede Variation gebunden sind), ermöglicht Ihnen `get_variation()` auch den Zugriff auf das [`Variation`](#variation)-Objekt, das Details über die zugewiesene Variation und das zugehörige Experiment liefert. Diese Methode prüft, ob der Benutzer Ziel ist, findet die dem Besucher zugewiesene Variation und speichert sie. Wenn `track=True`, sendet das SDK das Expositionsereignis bei der nächsten Tracking-Anfrage an das angegebene Experiment, die automatisch basierend auf dem [`tracking_interval_millisecond`](#zusätzliche-konfiguration) des SDK ausgelöst wird. Standardmäßig ist dieses Intervall auf 1000 Millisekunden (1 Sekunde) eingestellt.
Mit der Methode `get_variation()` können Sie steuern, ob Tracking durchgeführt wird. Wenn `track=False`, werden keine Expositionsereignisse vom SDK gesendet. Dies ist nützlich, wenn Sie es vorziehen, Daten nicht über das SDK zu verfolgen, sondern sich stattdessen z. B. auf das clientseitige Tracking durch die Kameleoon-Engine zu verlassen. Darüber hinaus ist die Einstellung `track=False` hilfreich, wenn Sie die Methode `get_variations()` verwenden, bei der Sie möglicherweise nur die Variationen für alle Flags benötigen, ohne Tracking-Ereignisse auszulösen. Wenn Sie mehr über die Funktionsweise des Trackings erfahren möchten, lesen Sie [diesen Artikel](/developer-docs/feature-experimentation/technical-reference/faq-global#when-does-the-sdk-send-a-tracking-request-for-analytics)
##### Hinzufügen von Datenpunkten zur Zielgruppenansprache oder zum Filtern / Aufschlüsseln von Besuchen in Berichten
Um einen Benutzer anzusprechen, stellen Sie sicher, dass Sie relevante Datenpunkte zu seinem Profil hinzugefügt haben, bevor Sie die Feature-Variation abrufen oder prüfen, ob das Flag aktiv ist. Verwenden Sie die Methode [`add_data()`](#add_data), um diese Datenpunkte zum Profil des Benutzers hinzuzufügen.
Um auf anderen Geräten gesammelte Datenpunkte abzurufen oder auf vergangene Benutzerdaten zuzugreifen (clientseitig gesammelt bei Verwendung von Kameleoon im Hybrid-Modus), verwenden Sie die Methode [`get_remote_visitor_data()`](#get_remote_visitor_data). Diese Methode ruft Daten asynchron von den Servern ab. Es ist wichtig, `get_remote_visitor_data()` *vor* dem Abrufen der Variation oder der Prüfung, ob das Feature Flag aktiv ist, aufzurufen, da diese Daten möglicherweise erforderlich sind, um einen Benutzer einer bestimmten Variation zuzuweisen.
Um mehr über verfügbare Targeting-Bedingungen zu erfahren, lesen Sie den [ausführlichen Artikel zu diesem Thema](/developer-docs/feature-experimentation/targeting-and-segmentation/native-segmentation).
Darüber hinaus stehen die Datenpunkte, die Sie zum Besucherprofil hinzufügen, bei der Analyse Ihrer Experimente zur Verfügung, sodass Sie Ihre Ergebnisse nach Faktoren wie Gerät und Browser filtern und aufschlüsseln können. Der Kameleoon-Hybrid-Modus sammelt automatisch eine Vielzahl von Datenpunkten auf der Clientseite, was es einfach macht, Ihre Ergebnisse basierend auf diesen vorgesammelten Datenpunkten aufzuschlüsseln. Die vollständige Liste finden Sie [hier](/de/user-manual/experiment-analytics/analyze-results/results-page/results-page-settings#zielgruppe-aufschlüsseln).
Wenn Sie zusätzliche Datenpunkte über das hinaus erfassen müssen, was automatisch erfasst wird, können Sie die [Custom-Data-Funktion](#customdata) von Kameleoon verwenden. Mit Custom Data können Sie spezifische Informationen erfassen und analysieren, die für Ihre Experimente relevant sind. Vergessen Sie nicht, die Methode [`flush()`](#flush) aufzurufen, um die gesammelten Daten zur Analyse an die Kameleoon-Server zu senden.
Um sicherzustellen, dass Ihre Ergebnisse genau sind, wird empfohlen, Bots mithilfe des Datentyps [`UserAgent`](#useragent) herauszufiltern.
##### Verfolgung von Ziel-Konversionen
Wenn ein Benutzer eine gewünschte Aktion ausführt (z. B. einen Kauf tätigt), wird dies als Konversion erfasst. Um Konversionen zu verfolgen, verwenden Sie die Methode [`track_conversion()`](#track_conversion) und geben Sie die erforderlichen Parameter `visitor_code` und `goal_id` an.
Die Konversions-Tracking-Anfrage wird zusammen mit der nächsten geplanten Tracking-Anfrage gesendet, die das SDK in regelmäßigen Abständen sendet (definiert durch [`tracking_interval_millisecond`](#zusätzliche-konfiguration)). Wenn Sie die Anfrage sofort senden möchten, verwenden Sie die Methode [`flush()`](#flush) mit dem Parameter `instant=True`.
##### Senden von Ereignissen an Analyselösungen
Um Konversionen zu verfolgen und Expositionsereignisse an Ihre Customer-Analytics-Lösung zu senden, müssen Sie Kameleoon zunächst im [Hybrid-Modus](/developer-docs/feature-experimentation/get-started/hybrid-experimentation/) implementieren. Verwenden Sie dann die Methode [`get_engine_tracking_code()`](#get_engine_tracking_code).
Die Methode `get_engine_tracking_code()` ruft den eindeutigen Tracking-Code ab, der erforderlich ist, um Expositionsereignisse an Ihre Analyselösung zu senden. Mit dieser Methode können Sie Ereignisse aufzeichnen und an die gewünschte Analyseplattform senden.
### Verwendung des Kameleoon Python SDK in einer Django-Umgebung
Wenn Sie Django verwenden, empfehlen wir Ihnen, den Kameleoon-Client beim Serverstart in der Datei `apps.py` Ihrer Django-Anwendung zu initialisieren.
Wenn Sie python manage.py runserver verwenden, startet Django zwei Prozesse: einen für den eigentlichen Entwicklungsserver und einen anderen, um Ihre Anwendung neu zu laden, wenn sich der Code ändert.
Sie können den Server auch ohne die Reload-Option starten, dann sehen Sie nur einen Prozess laufen. Der Prozess wird nur einmal ausgeführt:
`python manage.py runserver --noreload`
Sie können auch die Umgebungsvariable RUN\_MAIN in der Methode `ready()` überprüfen.
```python theme={null}
def ready(self):
if os.environ.get('RUN_MAIN', None) == 'true':
configuration_path = os.path.join(ROOT_DIR, 'path_to_config', 'config.yml')
self.kameleoon_client = KameleoonClientFactory.create(SITE_CODE, config_path=configuration_path)
```
Dies gilt nur für die lokale Entwicklung, wenn Sie python manage.py runserver verwenden. In einer Produktionsumgebung wird der Code in der Funktion `ready()` nur einmal bei der Initialisierung der Anwendung ausgeführt.
```python theme={null}
from django.apps import apps
my_application = apps.get_app_config('your_app')
client = my_application.kameleoon_client
```
Sie können dann in Ihrer Anwendung auf den Kameleoon-Client zugreifen.
Ein weiterer Vorteil der Verwendung von Django ist, dass das SDK den **visitor\_code** automatisch über ein Cookie aus der HTTP-Anfrage/-Antwort liest und schreibt. Wenn Sie ein anderes Framework in einer Webumgebung verwenden, in der Sie einen Cookie-Mechanismus zur Persistierung des **visitor\_code** verwenden möchten, müssen Sie Implementierungen der Methoden `read_cookies()` und `write_cookies()` bereitstellen.
### Cross-Device-Experimente
Um Besucher zu unterstützen, die von mehreren Geräten auf eine App zugreifen, ermöglicht Kameleoon die Synchronisierung zuvor gesammelter Besucherdaten über alle Geräte des Besuchers hinweg und die Abgleichung seiner Besuchsgeschichte zwischen Geräten durch Cross-Device-Experimente. Fallstudien und detaillierte Informationen darüber, wie Kameleoon Daten geräteübergreifend verarbeitet, finden Sie im [Artikel über Cross-Device-Experimente](/developer-docs/cross-device-experimentation).
#### Synchronisierung von Custom Data zwischen Geräten
Obwohl Custom-Mapping-Synchronisierung verwendet wird, um Besucherdaten zwischen Geräten abzugleichen, ist sie nicht immer erforderlich. Im Folgenden sind zwei Szenarien aufgeführt, in denen keine Custom-Mapping-Synchronisierung erforderlich ist:
**Gleiche Benutzer-ID auf allen Geräten**
Wenn die gleiche Benutzer-ID konsistent auf allen Geräten verwendet wird, erfolgt die Synchronisierung automatisch ohne Custom-Mapping-Synchronisierung. Es genügt, die Methode `get_remote_visitor_data()` aufzurufen, wenn Sie die zwischen mehreren Geräten gesammelten Daten synchronisieren möchten.
**Multi-Server-Instanzen mit konsistenten IDs**
In komplexen Setups mit mehreren Servern (z. B. verteilten Serverinstanzen), bei denen die gleiche Benutzer-ID auf allen Servern verfügbar ist, ist die Synchronisierung zwischen Servern (mit `get_remote_visitor_data()`) ohne zusätzliche Custom-Mapping-Synchronisierung ausreichend.
Kunden, die zusätzliche Daten benötigen, finden weitere Informationen in der Beschreibung der Methode [`get_remote_visitor_data()`](#get_remote_visitor_data). Im folgenden Code wird davon ausgegangen, dass derselbe eindeutige Identifikator (in diesem Fall der `visitor_code`, der auch als `userId` bezeichnet werden kann) konsistent zwischen den beiden Geräten verwendet wird, um einen genauen Datenabruf zu gewährleisten.
Wenn Sie gesammelte Daten in Echtzeit synchronisieren möchten, müssen Sie den Bereich **Visitor** für Ihre Custom Data auswählen.
```python title="Device A" theme={null}
# In this example, Custom data with index `90` was set to "Visitor" scope in Kameleoon.
VISITOR_SCOPE_CUSTOM_DATA_INDEX = 90
kameleoon_client.add_data(visitor_code, CustomData(VISITOR_SCOPE_CUSTOM_DATA_INDEX, "your data"))
kameleoon_client.flush(visitor_code)
```
```python title="Device B" theme={null}
# Before working with the data, call `get_remote_visitor_data`.
kameleoon_client.get_remote_visitor_data(visitor_code)
# After calling, the SDK on Device B will have access to CustomData of Visitor scope defined on Device A.
# So, "your data" will be available to target and track the visitor.
```
#### Verwendung von Custom Data für die Sitzungszusammenführung
[Cross-Device-Experimente](/developer-docs/cross-device-experimentation) ermöglichen es, die Historie eines Besuchers über alle seine Geräte hinweg zu kombinieren (Historien-Abgleich). Der Historien-Abgleich ermöglicht das Zusammenführen verschiedener Besuchersitzungen zu einer. Um die Besuchsgeschichte abzugleichen, verwenden Sie [`CustomData`](#customdata), um einen eindeutigen Identifikator für den Besucher anzugeben. Weitere Informationen finden Sie in der [dedizierten Dokumentation](/developer-docs/cross-device-experimentation/#activating-cross-device-history-reconciliation).
Nachdem der Cross-Device-Abgleich aktiviert wurde, ruft der Aufruf von [`get_remote_visitor_data()`](#get_remote_visitor_data) mit dem Parameter `userId` alle bekannten Daten für einen bestimmten Benutzer ab.
Sitzungen mit demselben Identifikator sehen in einem Experiment immer dieselbe Variation. In der Visitor-Ansicht der Ergebnisseiten Ihres Experiments erscheinen diese Sitzungen als ein einziger Besucher.
Die SDK-Konfiguration stellt sicher, dass zugehörige Sitzungen immer dieselbe Variation des Experiments sehen. Es gibt jedoch einige Einschränkungen bei der geräteübergreifenden Variationszuweisung. Diese Einschränkungen werden [hier](/developer-docs/cross-device-experimentation#critical-points-and-practical-insights) beschrieben.
Folgen Sie dem Leitfaden zur [Aktivierung des Cross-Device-Historien-Abgleichs](#cross-device-experimente), um Ihre Custom Data auf der Kameleoon-Plattform einzurichten.
Anschließend können Sie das SDK normal verwenden. Die folgenden Methoden können im Kontext der Sitzungszusammenführung hilfreich sein:
* `get_remote_visitor_data()` mit hinzugefügtem `UniqueIdentifier(True)` - um Daten für alle verknüpften Besucher abzurufen.
* [`track_conversion()`](#track_conversion) oder [`flush()`](#flush) mit hinzugefügten `UniqueIdentifier(True)`-Daten - um bestimmte Daten für einen spezifischen Besucher zu verfolgen, der mit einem anderen Besucher verknüpft ist.
Da die Custom Data, die Sie als Identifikator verwenden, auf den Bereich **Visitor** gesetzt sein muss, müssen Sie die [Cross-Device-Custom-Data-Synchronisierung](/developer-docs/cross-device-experimentation) verwenden, um den Identifikator mit der Methode [`get_remote_visitor_data()`](#get_remote_visitor_data) auf jedem Gerät abzurufen.
Hier ist ein Beispiel für die Verwendung von Custom Data zur Sitzungszusammenführung.
```python theme={null}
# In this example, `91` represents the Custom Data's index configured as a unique identifier in Kameleoon.
MAPPING_INDEX = 91
FEATURE_KEY = "ff123"
# 1. Before the visitor is authenticated
# Retrieve the variation for an unauthenticated visitor.
# Assume `anonymous_visitor_code` is the randomly generated ID for that visitor.
anonymous_variation = kameleoon_client.get_variation(anonymous_visitor_code, FEATURE_KEY)
# 2. After the visitor is authenticated
# Assume `user_id` is the visitor code of the authenticated visitor.
kameleoon_client.add_data(anonymous_visitor_code, CustomData(MAPPING_INDEX, user_id))
kameleoon_client.flush(anonymous_visitor_code, instant=True)
# Indicate that `user_id` is a unique identifier.
kameleoon_client.add_data(user_id, UniqueIdentifier(True))
# 3. After the visitor has been authenticated
# Retrieve the variation for the `user_id`, which will match the anonymous visitor code's variation.
user_variation = kameleoon_client.get_variation(user_id, FEATURE_KEY)
is_same_variation = user_variation.key == anonymous_variation.key # True
# The `user_id` and `anonymous_visitor_code` are now linked and tracked as a single visitor.
kameleoon_client.track_conversion(user_id, 123, 10.0)
# Additionally, the linked visitors will share all fetched remote visitor data.
kameleoon_client.get_remote_visitor_data(user_id)
```
In diesem Beispiel verfügt die Anwendung über eine Anmeldeseite. Da die Benutzer-ID zum Zeitpunkt der Anmeldung unbekannt ist, wird ein anonymer Besucher-Identifikator verwendet, der von der Methode [`get_visitor_code()`](#get_visitor_code) generiert wird. Nachdem sich der Benutzer angemeldet hat, wird der anonyme Besucher mit der Benutzer-ID verknüpft und als eindeutiger Identifikator für den Besucher verwendet.
### Verwendung eines benutzerdefinierten Bucketing-Schlüssels
Standardmäßig verwendet Kameleoon eine eindeutige, anonyme Besucher-ID (`visitor_code`), um Benutzer Feature-Flag-Variationen zuzuweisen. Diese ID wird in der Regel auf dem Gerät des Benutzers generiert und gespeichert (in einem Browser-Cookie für Client- und Server-SDKs – im persistenten Speicher für mobile SDKs). In bestimmten Szenarien müssen Sie jedoch möglicherweise sicherstellen, dass alle Benutzer derselben Organisation dieselbe Variante eines Feature Flags sehen.
Die Option **Custom Bucketing Key** ermöglicht es Ihnen, dieses Standardverhalten zu überschreiben, indem Sie Ihren eigenen benutzerdefinierten Identifikator für das Bucketing bereitstellen. Diese Überschreibung stellt sicher, dass die Zuweisungslogik von Kameleoon Ihren angegebenen Schlüssel anstelle des standardmäßigen `visitor_code` verwendet.
#### Anwendungsfälle
Die Verwendung eines benutzerdefinierten Bucketing-Schlüssels ist entscheidend für die Aufrechterhaltung der Konsistenz und Genauigkeit Ihrer Feature-Flag-Zuweisungen, insbesondere in diesen Situationen:
* **Experimente auf Konto- oder Organisationsebene:** Für B2B-Produkte oder Szenarien, in denen Sie alle Benutzer derselben Organisation derselben Variation zuweisen möchten, können Sie einen Identifikator wie eine `account_id` verwenden. Benutzerdefinierte Bucketing-Schlüssel sind entscheidend für A/B Tests von Funktionen, die ein ganzes Team oder Unternehmen betreffen.
Durch die Implementierung eines benutzerdefinierten Bucketing-Schlüssels gewährleisten Sie eine höhere Konsistenz und Genauigkeit in Ihren Experimenten, was zu zuverlässigeren Ergebnissen und einer besseren Benutzererfahrung führt.
#### Technische Details
Wenn Sie einen benutzerdefinierten Bucketing-Schlüssel für ein Feature Flag konfigurieren, geben Sie Kameleoon einen bestimmten Identifikator aus den Daten Ihrer Anwendung:
```python theme={null}
from kameleoon.data import CustomData
kameleoon_client.add_data(visitor_code, CustomData(index, "new_visitor_code"))
```
* **Bereitstellung des benutzerdefinierten Schlüssels:** Sie stellen Ihren benutzerdefinierten Identifikator dem Kameleoon SDK mithilfe der Methode [`add_data()`](#add_data) zur Verfügung. In dieser Methode übergeben Sie Ihren gewählten benutzerdefinierten Bucketing-Schlüssel als [`CustomData`](#customdata)-Objekt. Hier bezieht sich `new_visitor_code` auf den Identifikator, den Sie für Ihr Bucketing verwenden möchten (zum Beispiel die neue `user_id` oder `account_id`).
Damit der benutzerdefinierte Bucketing-Schlüssel korrekt funktioniert, muss er auch beim Erstellen oder Bearbeiten des Feature Flags definiert und konfiguriert werden. Ohne diese entsprechende Konfiguration wendet das SDK-Bucketing Ihren benutzerdefinierten Schlüssel nicht an. Detaillierte Anweisungen zur Einrichtung in Kameleoon finden Sie in diesem [Artikel](/user-manual/experimentation/feature-experimentation/create-and-manage-flags/create-a-feature-flag#Advanced_Flag_Settings).
* **Bucketing-Logik:** Sobald ein benutzerdefinierter Bucketing-Schlüssel über die Methode `add_data()` bereitgestellt wird, verwenden alle Hash-Berechnungen zur Zuweisung von Benutzern zu Variationen diesen `new_visitor_code` (Ihren benutzerdefinierten Schlüssel) anstelle des standardmäßigen `visitor_code`. Die Verwendung des `new_visitor_code` bedeutet, dass die Bucketing-Entscheidung an Ihren benutzerdefinierten Identifikator gebunden ist, was konsistente Zuweisungen in verschiedenen Kontexten gewährleistet, in denen dieser Identifikator vorhanden ist.
* **Datentracking und Analytics:** Es ist entscheidend zu beachten, dass, während der `new_visitor_code` (Ihr benutzerdefinierter Schlüssel) für Bucketing-Entscheidungen verwendet wird, **alle nachfolgenden Daten (z. B. Tracking-Ereignisse und Konversionen) gesendet und mit dem *ursprünglichen* `visitor_code` verknüpft werden.** Diese Trennung stellt sicher, dass Ihre Analytics individuelle Benutzerreisen und Interaktionen im breiteren Kontext Ihres Experiments genau widerspiegeln, selbst wenn das Bucketing auf einer höheren Ebene (wie einem Konto) oder über mehrere Geräte/Sitzungen hinweg durchgeführt wird. Ihre ursprünglichen Besucherdaten bleiben für umfassende Berichte intakt.
#### Technische Anforderungen
Um einen benutzerdefinierten Bucketing-Schlüssel effektiv zu verwenden:
* Der Schlüssel muss vom Typ `str` sein.
* Er muss für die Entität, die Sie bucketing möchten, eindeutig sein (zum Beispiel, wenn Sie eine `user_id` verwenden, sollte die ID jedes Benutzers eindeutig sein).
* Der Schlüssel muss dem SDK zu dem genauen Zeitpunkt verfügbar sein, an dem die Feature-Flag-Entscheidung für diesen Benutzer oder diese Anfrage ausgewertet wird.
### Targeting-Bedingungen
Die Kameleoon SDKs unterstützen eine Vielzahl vordefinierter Targeting-Bedingungen, die Sie verwenden können, um Benutzer in Ihren Kampagnen anzusprechen. Die Liste der von diesem SDK unterstützten Bedingungen finden Sie unter [Besuchshistorie zur Zielgruppenansprache verwenden](/developer-docs/feature-experimentation/targeting-and-segmentation/native-segmentation).
Sie können auch Ihre eigenen [externen Daten zur Zielgruppenansprache verwenden](/developer-docs/apis/data-api-rest/tutorials/storing-and-retrieving-external-data-to-target-users).
### Logging
Das SDK erzeugt Logs, um verschiedene interne Prozesse und Probleme widerzuspiegeln.
#### Log-Levels
Das SDK unterstützt die Konfiguration einer Logging-Einschränkung durch ein Log-Level.
```python theme={null}
from kameleoon.logging.log_level import LogLevel
from kameleoon.logging.kameleoon_logger import KameleoonLogger
# The `NONE` log level does not allow logging.
KameleoonLogger.set_log_level(LogLevel.NONE)
# The `ERROR` log level only allows logging issues that may affect the SDK's main behaviour.
KameleoonLogger.set_log_level(LogLevel.ERROR)
# The `WARNING` log level allows logging issues which may require additional attention.
# It extends the `ERROR` log level.
# The `WARNING` log level is a default log level.
KameleoonLogger.set_log_level(LogLevel.WARNING)
# The `INFO` log level allows logging general information on the SDK's internal processes.
# It extends the `WARNING` log level.
KameleoonLogger.set_log_level(LogLevel.INFO)
# The `DEBUG` level logs additional details about the SDK’s internal processes and extends the `INFO` level
# with more granular. diagnostic output.
# This information is not intended for end-user interpretation but can be sent to our support team
# to assist with internal troubleshooting.
KameleoonLogger.set_log_level(LogLevel.DEBUG)
```
#### Benutzerdefinierte Verarbeitung von Logs
Das SDK schreibt seine Logs standardmäßig in die Konsolenausgabe. Dieses Verhalten kann überschrieben werden.
Die Logging-Einschränkung durch ein Log-Level wird unabhängig von der Log-Verarbeitungslogik durchgeführt.
```python theme={null}
from loguru import logger
from kameleoon.logging.log_level import LogLevel
from kameleoon.logging.logger import Logger
class CustomLogger(Logger):
"""Custom logger implementation using loguru."""
def log(self, level: LogLevel, message: str) -> None:
"""Accepts logs from the SDK"""
if level == LogLevel.ERROR:
logger.error(message)
elif level == LogLevel.WARNING:
logger.warning(message)
elif level == LogLevel.INFO:
logger.info(message)
elif level == LogLevel.DEBUG:
logger.debug(message)
from kameleoon.logging.kameleoon_logger import KameleoonLogger
# Log level filtering is applied separately from log handling logic.
# The custom logger will only accept logs that meet or exceed the specified log level.
# Ensure the log level is set correctly.
KameleoonLogger.set_logger(CustomLogger())
KameleoonLogger.set_log_level(LogLevel.DEBUG) # Optional, defaults to `LogLevel.WARNING`.
```
## Referenz
Dies ist die vollständige Referenzdokumentation des Python SDK.
#### create()
Um das SDK zu verwenden, müssen Sie die Initialisierung abschließen. Alle Interaktionen mit dem SDK erfolgen über ein Objekt namens `Kameleoon::KameleoonClient`. Das Erste, was Sie tun müssen, ist also, dieses Objekt zu erstellen.
```python theme={null}
kameleoon_config = KameleoonClientConfig("client_id", "client_secret")
kameleoon_client = KameleoonClientFactory.create("a8st4f59bj", kameleoon_config)
kameleoon_client = KameleoonClientFactory.create("a8st4f59bj", config_path="/etc/kameleoon/client-ruby.yaml")
```
##### Argumente
| Name | Typ | Beschreibung |
| ------------ | --------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| site\_code | str | Dies ist ein [eindeutiger Schlüssel](/user-manual/faq#how-do-i-find-my-sitecode) des Kameleoon-Projekts, das Sie mit dem SDK verwenden. Dieses Feld ist obligatorisch. |
| config | KameleoonClientConfig | Konfigurations-SDK-Objekt, das Sie anstelle einer Konfigurationsdatei übergeben können. Dieses Feld ist optional. |
| config\_path | str | Pfad zur SDK-Konfigurationsdatei. Dieses Feld ist optional. Der Standardwert ist `/etc/kameleoon/client-ruby.yaml` |
##### Geworfene Ausnahmen
| Typ | Beschreibung |
| ------------------ | -------------------------------------------------------------------------------------------------------------- |
| SiteCodeIsEmpty | Ausnahme, die anzeigt, dass der angegebene Site Code eine leere Zeichenkette ist, was ein ungültiger Wert ist. |
| ConfigFileNotFound | Ausnahme, die anzeigt, dass die Konfigurationsdatei nicht gefunden wurde. |
#### wait\_init\_async()
`wait_init_async` wartet asynchron auf die Initialisierung des Kameleoon-Clients. Mit dieser Methode können Sie prüfen, ob der Client erfolgreich initialisiert wurde, bevor Sie mit anderen Operationen fortfahren.
```python theme={null}
kameleoon_client = KameleoonClientFactory.create('a8st4f59bj')
if await kameleoon_client.wait_init_async():
# The SDK has been initialized; you can fetch a feature flag / experiment configuration here.
```
##### Rückgabewert
| Typ | Beschreibung |
| -------------------------- | ------------------------------------------------------------------------------------------------------------------------------ |
| Coroutine\[Any, Any, bool] | Eine Coroutine, die `True` zurückgibt, wenn die Kameleoon-Client-Instanz erfolgreich initialisiert wurde, andernfalls `False`. |
#### wait\_init()
`wait_init` wartet synchron auf die Initialisierung des Kameleoon-Clients. Mit dieser Methode können Sie prüfen, ob der Client erfolgreich initialisiert wurde, bevor Sie mit anderen Operationen fortfahren.
```python theme={null}
kameleoon_client = KameleoonClientFactory.create('a8st4f59bj')
if kameleoon_client.wait_init():
# The SDK has been initialized; you can fetch a feature flag / experiment configuration here.
```
##### Rückgabewert
| Typ | Beschreibung |
| ------ | ----------------------------------------------------------------------------------------------- |
| `bool` | `True`, wenn die Kameleoon-Client-Instanz erfolgreich initialisiert wurde, andernfalls `False`. |
### Feature Flags und Variationen
#### is\_feature\_active()
* 📨 *Sendet Tracking-Daten an Kameleoon (abhängig vom Parameter `track`)*
Zuvor `activate_feature` genannt – veraltet seit der SDK-Version `2.1.0` und wird in zukünftigen Versionen entfernt.
Um zu prüfen, ob ein Feature Flag für einen Besucher aktiv ist, rufen Sie die Methode `is_feature_active()` auf.
Diese Methode nimmt einen **visitor\_code** und einen **feature\_key** als obligatorische Argumente, um zu prüfen, ob das Feature für einen bestimmten Benutzer aktiv ist.
Wenn ein solcher Benutzer noch nie mit diesem Feature Flag verknüpft wurde, gibt das SDK zufällig einen booleschen Wert zurück (**true**, wenn das Feature für den Benutzer aktiv ist, oder **false**, wenn nicht). Wenn ein Benutzer mit einem bestimmten **visitor\_code** bereits mit diesem Feature Flag registriert ist, wird der vorherige **Feature-Flag**-Wert erkannt.
Sie müssen sicherstellen, dass in Ihrem Code eine ordnungsgemäße Fehlerbehandlung eingerichtet ist, wie im Beispiel rechts gezeigt, um potenzielle Ausnahmen abzufangen.
Wenn Sie einen `visitor_code` angeben, verwendet die Methode `is_feature_active()` den `visitor_code` als eindeutigen Besucher-Identifikator, was für [Cross-Device-Experimente](/developer-docs/cross-device-experimentation) nützlich ist. Wenn Sie einen `visitor_code` angeben und den Parameter `is_unique_identifier` auf `true` setzen, verknüpft das SDK die geflushten Daten mit dem Besucher, der mit dem angegebenen Identifikator verknüpft ist.
Der Parameter `is_unique_identifier` ist veraltet. Bitte verwenden Sie stattdessen [`UniqueIdentifier`](#uniqueidentifier).
Der `is_unique_identifier` kann auch in anderen Sonderfallszenarien nützlich sein, z. B. wenn Sie nicht auf den anonymen `visitor_code` zugreifen können, der dem Besucher ursprünglich zugewiesen wurde, aber Zugriff auf eine interne ID haben, die über die Sitzungszusammenführungs-Funktionen mit dem anonymen Besucher verknüpft ist.
Kameleoon verwendet Tracking, um Sitzungen und Besucher zu zählen, wenn Sie bestimmte Methoden wie `is_feature_active()`, `get_variation()` oder `get_variations()` aufrufen.
Verwenden Sie den Standardwert `True` für den Parameter `track`, wenn Sie Besucher einer Variation aussetzen und sie zählen müssen. Setzen Sie den Parameter `track` nur dann auf `False`, wenn Sie diese Methoden aufrufen, bevor Sie die Besucher aussetzen.
Wenn Sie beispielsweise `get_variations()` aufrufen, um alle Variationen abzurufen, bevor Sie die Besucher aussetzen, setzen Sie den Parameter `track` auf `False`. Diese Einstellung verhindert, dass Kameleoon eine Sitzung vorzeitig zählt. Sie können das Tracking dann später auslösen, wenn Sie den Besucher explizit aussetzen.
Kameleoon sendet Tracking-Daten standardmäßig jede Sekunde. Sie können dieses Intervall mit der Konfigurationsoption Tracking-Intervall auf bis zu fünf Sekunden konfigurieren. Kameleoon gruppiert Tracking-Ereignisse in einer einzigen Sitzung, solange das Intervall zwischen den Ereignissen weniger als 30 Minuten beträgt. Wenn zwischen Tracking-Ereignissen mehr als 30 Minuten vergehen, zählt Kameleoon die Ereignisse als separate Sitzungen. Ein Besuch erscheint 30 Minuten nach dem letzten aufgezeichneten Ereignis in der Sitzung in Ihren Berichten.
```python theme={null}
visitor_code = kameleoon_client.get_visitor_code(request.COOKIES)
feature_key = "new_checkout"
has_new_checkout = False
try
has_new_checkout = kameleoon_client.is_feature_active(visitor_code, feature_key)
# disabling tracking
has_new_checkout = kameleoon_client.is_feature_active(visitor_code, feature_key, track=False)
except FeatureNotFound as ex:
# The user will not be counted in the experiment,
# but should see the reference variation.
has_new_checkout = False
except VisitorCodeInvalid as ex:
# The visitor code you passed to the method isn't valid and can't be accepted by SDK.
has_new_checkout = False
if has_new_checkout
# Implement new checkout code here
```
Die Methode `is_feature_active()` wertet die ausgelieferte Variante aus, nicht den Master-Flag-Status. Wenn Sie Regeln ausschließen, verwendet die Methode den Standardstatus **Then, for everyone else serve**. Wenn Sie für diesen Standardstatus **Off** auswählen, gibt die Methode immer `false` zurück, selbst wenn das Master-Feature-Flag **On** ist.
##### Argumente
| Name | Typ | Beschreibung |
| --------------------------------- | --------------- | ------------------------------------------------------------------------------------------------------------------------ |
| visitor\_code | str | Eindeutiger Identifikator des Benutzers. Dieses Feld ist obligatorisch. |
| feature\_key | str | ID oder Schlüssel des Features, das Sie einem Benutzer aussetzen möchten. Dieses Feld ist obligatorisch. |
| is\_unique\_identifier (Veraltet) | Optional\[bool] | Bei `True` verknüpft das SDK die geflushten Daten mit dem Besucher, der mit dem angegebenen Identifikator verknüpft ist. |
| track | bool | Ein optionaler Parameter zum Aktivieren oder Deaktivieren des Trackings der Feature-Auswertung (standardmäßig `True`). |
##### Rückgabewert
| Typ | Beschreibung |
| ---- | ------------------------------------------------------------------------------ |
| bool | Wert des Features, das für einen bestimmten **visitor\_code** registriert ist. |
##### Geworfene Ausnahmen
| Typ | Beschreibung |
| ------------------ | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| FeatureNotFound | Ausnahme, die anzeigt, dass die angeforderte Feature-ID nicht in der internen Konfiguration des SDK gefunden wurde. Diese Ausnahme ist normalerweise normal und bedeutet, dass das Feature Flag noch nicht auf Kameleoon-Seite aktiviert wurde (aber der Code, der das Feature implementiert, ist bereits auf der Seite der Webanwendung bereitgestellt). |
| VisitorCodeInvalid | Ausnahme, die anzeigt, dass der angegebene Visitor Code ungültig ist (leer oder länger als 255 Zeichen). |
#### get\_variation()
* 📨 *Sendet Tracking-Daten an Kameleoon (abhängig vom Parameter `track`)*
Ruft die [`Variation`](#variation) ab, die einem bestimmten Besucher für ein bestimmtes Feature Flag zugewiesen wurde.
Diese Methode nimmt einen `visitor_code` und einen `feature_key` als obligatorische Argumente. Das Argument `track` ist optional und standardmäßig auf `True` gesetzt.
Sie gibt die zugewiesene `Variation` für den Besucher zurück. Wenn der Besucher mit keinen Feature-Flag-Regeln verknüpft ist, gibt die Methode die Standard-`Variation` für das angegebene Feature Flag zurück.
Stellen Sie sicher, dass in Ihrem Code eine ordnungsgemäße Fehlerbehandlung implementiert ist, um potenzielle Ausnahmen zu verwalten.
Die Standardvariation bezieht sich auf die Variation, die einem Besucher zugewiesen wird, wenn er mit keiner vordefinierten Lieferregel für ein Feature Flag übereinstimmt. Mit anderen Worten, es ist die Fallback-Variation, die auf alle Benutzer angewendet wird, die nicht von bestimmten Regeln angesprochen werden. Sie wird durch die Variation im Abschnitt "Then, for everyone else..." in einer Verwaltungsoberfläche dargestellt.
```python theme={null}
feature_key = "new_checkout"
try:
variation = kameleoon_client.get_variation(visitor_code, feature_key)
# disabling tracking
variation = kameleoon_client.get_variation(visitor_code, feature_key, False)
except FeatureNotFound as ex:
# The error has occurred; the feature flag isn't found in current configuration.
except FeatureEnvironmentDisabled as ex:
# The feature flag is disabled for the environment.
except VisitoCodeNotValid as ex:
# The visitor code you passed to the method is invalid and can't be accepted by SDK.
# Fetch a variable value for the assigned variation
title = variation.variables["title"].value
if variation.key == "on":
# Main variation key is selected for visitorCode
elif variation.key == "alternative_variation":
# Alternative variation key
else:
# Default variation key
```
##### Argumente
| Name | Typ | Beschreibung | Standard |
| ------------------------------ | ------ | ----------------------------------------------------------------------------------------------- | -------- |
| visitor\_code (*erforderlich*) | `str` | Eindeutiger Identifikator des Besuchers. | |
| feature\_key (*erforderlich*) | `str` | Schlüssel des Features, das Sie einem Besucher aussetzen möchten. | |
| track (*optional*) | `bool` | Ein optionaler Parameter zum Aktivieren oder Deaktivieren des Trackings der Feature-Auswertung. | `True` |
##### Rückgabewert
| Typ | Beschreibung |
| ----------- | --------------------------------------------------------------------------------------------------------- |
| `Variation` | Eine zugewiesene [`Variation`](#variation) für einen bestimmten Besucher und ein bestimmtes Feature Flag. |
##### Geworfene Ausnahmen
| Typ | Beschreibung |
| ---------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `VisitorCodeInvalid` | Ausnahme, die anzeigt, dass der angegebene Visitor Code ungültig ist. Er ist entweder leer oder länger als 255 Zeichen. |
| `FeatureNotFound` | Ausnahme, die anzeigt, dass der angeforderte Feature Key nicht in der internen Konfiguration des SDK gefunden wurde. Dies bedeutet normalerweise, dass das Feature Flag in der Kameleoon-App nicht aktiviert ist (aber der Code, der das Feature implementiert, ist bereits in der Anwendung bereitgestellt). |
| `FeatureEnvironmentDisabled` | Ausnahme, die anzeigt, dass das Feature Flag für die aktuelle Umgebung des Besuchers deaktiviert ist (z. B. production, staging oder development). |
#### get\_variations()
* 📨 *Sendet Tracking-Daten an Kameleoon (abhängig vom Parameter `track`)*
Ruft eine Map von [`Variation`](#variation)-Objekten ab, die einem bestimmten Besucher über alle Feature Flags hinweg zugewiesen wurden.
Diese Methode iteriert über alle verfügbaren Feature Flags und gibt die zugewiesene `Variation` für jedes Flag zurück, das mit dem angegebenen Besucher verknüpft ist. Sie nimmt `visitor_code` als obligatorisches Argument, während `only_active` und `track` optional sind.
* Wenn `only_active` auf `True` gesetzt ist, gibt die Methode `get_variations()` Feature-Flag-Variationen zurück, sofern der Benutzer nicht mit der `off`-Variation gebucketet ist.
* Der Parameter `track` steuert, ob die Methode die Variationszuweisungen verfolgt oder nicht. Standardmäßig ist er auf `True` gesetzt. Wenn er auf `False` gesetzt ist, wird das Tracking deaktiviert.
Die zurückgegebene Map besteht aus Feature-Flag-Schlüsseln als Schlüsseln und ihrer entsprechenden `Variation` als Werten. Wenn keine Variation für ein Feature Flag zugewiesen ist, gibt die Methode die Standard-`Variation` für dieses Flag zurück.
Eine ordnungsgemäße Fehlerbehandlung sollte implementiert werden, um potenzielle Ausnahmen zu verwalten.
Die Standardvariation bezieht sich auf die Variation, die einem Besucher zugewiesen wird, wenn er mit keiner vordefinierten Lieferregel für ein Feature Flag übereinstimmt. Mit anderen Worten, es ist die Fallback-Variation, die auf alle Benutzer angewendet wird, die nicht von bestimmten Regeln angesprochen werden. Sie wird durch die Variation im Abschnitt "Then, for everyone else..." in einer Verwaltungsoberfläche dargestellt.
```python theme={null}
try:
variations = kameleoon_client.get_variations(visitor_code)
# only active variations
variations = kameleoon_client.get_variations(visitor_code, only_active=True)
# disable tracking
variations = kameleoon_client.get_variations(visitor_code, track=False)
except VisitorCodeInvalid as ex:
# Handle exception
```
##### Argumente
| Name | Typ | Beschreibung | Standard |
| ------------------------------ | ------ | --------------------------------------------------------------------------------------------------------------------------------------- | -------- |
| visitor\_code (*erforderlich*) | `str` | Eindeutiger Identifikator des Besuchers. | |
| only\_active (*optional*) | `bool` | Ein optionaler Parameter, der angibt, ob Variationen für aktive (`True`) oder alle (`False`) Feature Flags zurückgegeben werden sollen. | `False` |
| track (*optional*) | `bool` | Ein optionaler Parameter zum Aktivieren oder Deaktivieren des Trackings der Feature-Auswertung. | `True` |
##### Rückgabewert
| Typ | Beschreibung |
| ---------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------- |
| `Dict[str, Variation]` | Map, die die zugewiesenen [`Variation`](#variation)-Objekte der Feature Flags unter Verwendung der Schlüssel der entsprechenden Features enthält. |
##### Geworfene Ausnahmen
| Typ | Beschreibung |
| -------------------- | ----------------------------------------------------------------------------------------------------------------------- |
| `VisitorCodeInvalid` | Ausnahme, die anzeigt, dass der angegebene Visitor Code ungültig ist. Er ist entweder leer oder länger als 255 Zeichen. |
#### get\_data\_file()
Um alle Feature Flags auszuwerten, verwenden Sie [`get_variations()`](#get_variations). Diese Methode ist effizienter als der Aufruf von `DataFile` und das Iterieren durch Flags mit [`get_variation()`](#get_variation).
Gibt die aktuelle SDK-Konfiguration als [`DataFile`](#datafile)-Objekt zurück.
```python theme={null}
data_file = kameleoon_client.get_data_file()
date_modified = data_file.date_modified
```
##### Rückgabewert
| Typ | Beschreibung |
| ---------- | -------------------------------------------------------------- |
| `DataFile` | Die [`DataFile`](#datafile), die die SDK-Konfiguration enthält |
#### set\_forced\_variation()
Die Methode ermöglicht es Ihnen, einem Benutzer programmatisch eine bestimmte [`Variation`](#variation) zuzuweisen und so den Standard-Auswertungsprozess zu umgehen. Dies ist besonders wertvoll für kontrollierte Experimente, bei denen die übliche Auswertungslogik nicht erforderlich ist oder übersprungen werden muss. Es kann auch in Szenarien wie Debugging oder benutzerdefinierten Tests hilfreich sein.
Wenn eine **erzwungene** Variation gesetzt ist, überschreibt sie die Echtzeit-Auswertungslogik von Kameleoon. Prozesse wie Segmentierung, Targeting-Bedingungen und algorithmische Berechnungen werden übersprungen. Um Segmentierung und Targeting-Bedingungen während eines Experiments beizubehalten, setzen Sie stattdessen `force_targeting=False`.
**Simulierte** Variationen haben in der Ausführungsreihenfolge immer Vorrang. Wenn eine **simulierte** Variationsberechnung ausgelöst wird, wird sie zuerst vollständig verarbeitet und abgeschlossen.
Eine erzwungene Variation wird genauso behandelt wie eine ausgewertete Variation. Sie wird in den Analytics verfolgt und wie jede standardmäßig ausgewertete Variation im Benutzerkontext gespeichert, was die Konsistenz der Berichte gewährleistet.
Die Methode kann unter bestimmten Bedingungen Ausnahmen werfen (z. B. ungültige Parameter, Benutzerkontext oder interne Probleme). Eine ordnungsgemäße Ausnahmebehandlung ist unerlässlich, um sicherzustellen, dass Ihre Anwendung stabil und widerstandsfähig bleibt.
Es ist wichtig, **erzwungene** Variationen von **[simulierten](#get_visitor_code)** Variationen zu unterscheiden:
* **Erzwungene Variationen**: Sind spezifisch für ein einzelnes Experiment.
* **Simulierte Variationen**: Beeinflussen das Gesamtergebnis des **Feature Flags**.
```python theme={null}
experiment_id = 9516
try:
# Forcing the variation "on" for the experiment 9516 for the visitor
kameleoon_client.set_forced_variation(visitor_code, experiment_id, "on")
# Forcing the variation "on" while preserving segmentation and targeting conditions during the experiment
kameleoon_client.set_forced_variation(visitor_code, experiment_id, "on", False)
# Resetting the forced variation for the experiment 9516 for the visitor
kameleoon_client.set_forced_variation(visitor_code, experiment_id, None)
except KameleoonError as e:
# Handling the error
```
##### Argumente
| Name | Typ | Beschreibung | Standard |
| ------------------------------- | --------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------- |
| visitor\_code (*erforderlich*) | `str` | Eindeutiger Identifikator des Besuchers. | |
| experiment\_id (*erforderlich*) | `int` | **Experiment Id**, die während des Auswertungsprozesses angesprochen und ausgewählt wird. | |
| variation\_key (*erforderlich*) | `Optional[str]` | **Variation Key**, der einer `Variation` entspricht, die als zurückgegebener Wert für das Experiment erzwungen werden soll. Wenn der Wert `None` ist, wird die erzwungene Variation zurückgesetzt. | |
| force\_targeting (*optional*) | `bool` | Gibt an, ob das Targeting für das Experiment erzwungen und übersprungen werden soll (`True`) oder wie im Standard-Auswertungsprozess angewendet werden soll (`False`). | `True` |
##### Geworfene Ausnahmen
| Typ | Beschreibung |
| --------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `VisitorCodeInvalid` | Ausnahme, die anzeigt, dass der angegebene Visitor Code ungültig ist. Er ist entweder leer oder länger als 255 Zeichen. |
| `FeatureExperimentNotFound` | Ausnahme, die anzeigt, dass die angeforderte Experiment-ID nicht in der internen Konfiguration des SDK gefunden wurde. Dies ist normalerweise normal und bedeutet, dass das der Regel entsprechende Experiment noch nicht auf Kameleoon-Seite aktiviert wurde. |
| `FeatureVariationNotFound` | Ausnahme, die anzeigt, dass der angeforderte Variation Key (ID) nicht in der internen Konfiguration des SDK gefunden wurde. Dies ist normalerweise normal und bedeutet, dass das der Variation entsprechende Experiment noch nicht auf Kameleoon-Seite aktiviert wurde. |
In den meisten Fällen muss nur der grundlegende Fehler, `KameleoonError`, behandelt werden, wie im Beispiel gezeigt. Wenn jedoch verschiedene Arten von Fehlern eine Reaktion erfordern, behandeln Sie jeden separat basierend auf den spezifischen Anforderungen. Darüber hinaus können für eine erhöhte Zuverlässigkeit allgemeine Sprachfehler durch Einschluss von `Exception` behandelt werden.
#### evaluate\_audiences()
* 📨 *Sendet Tracking-Daten an Kameleoon*
Diese Methode wertet Besucher gegen alle verfügbaren Audiences-Explorer-Segmente aus und verfolgt diejenigen, die übereinstimmen.
`evaluate_audiences()` sollte aufgerufen werden, **nachdem alle relevanten Besucherdaten gesetzt oder aktualisiert wurden**, und **kurz bevor** Sie eine Feature-Variation abrufen oder ein Feature Flag prüfen. Dieser Ansatz stellt sicher, dass der Besucher gegen die aktuellsten verfügbaren Daten ausgewertet wird, was eine genaue Zielgruppenzuweisung basierend auf allen Kriterien ermöglicht.
Nach dem Aufruf dieser Methode können Sie eine detaillierte Analyse der Segment-Performance im Audiences Explorer durchführen.
```python theme={null}
try:
kameleoon_client.evaluate_audiences(visitor_code)
except KameleoonError as e:
# Handling the error
```
##### Argumente
| Name | Typ | Beschreibung |
| ------------------------------ | ----- | ---------------------------------------- |
| visitor\_code (*erforderlich*) | `str` | Eindeutiger Identifikator des Besuchers. |
##### Geworfene Ausnahmen
| Typ | Beschreibung |
| -------------------- | ----------------------------------------------------------------------------------------------------------------------- |
| `VisitorCodeInvalid` | Ausnahme, die anzeigt, dass der angegebene Visitor Code ungültig ist. Er ist entweder leer oder länger als 255 Zeichen. |
In den meisten Fällen muss nur der grundlegende Fehler, `KameleoonError`, behandelt werden, wie im Beispiel gezeigt. Wenn jedoch verschiedene Arten von Fehlern eine Reaktion erfordern, behandeln Sie jeden separat basierend auf den spezifischen Anforderungen. Darüber hinaus können für eine erhöhte Zuverlässigkeit allgemeine Sprachfehler durch Einschluss von `Exception` behandelt werden.
### Besucherdaten
#### get\_visitor\_code()
Diese Methode hieß zuvor `obtain_visitor_code` und wurde in der SDK-Version `3.0.0` entfernt.
Die Hilfsmethode `get_visitor_code()` sollte aufgerufen werden, um den aktuellen Kameleoon-**visitor\_code** des Besuchers zu erhalten. Diese Methode ist besonders wichtig, wenn Kameleoon in einer gemischten Frontend- und Backend-Umgebung verwendet wird, in der die Konsistenz der Benutzeridentifikation gewährleistet sein muss. Die Implementierungslogik wird hier beschrieben:
1. Zuerst prüfen wir, ob ein **kameleoonVisitorCode**-Cookie oder Query-Parameter, der mit der aktuellen HTTP-Anfrage verknüpft ist, gefunden werden kann. Wenn ja, verwenden wir diesen als Besucher-Identifikator.
2. Wenn in der aktuellen Anfrage kein Cookie/Parameter gefunden wird, generieren wir entweder zufällig einen neuen Identifikator oder verwenden das Argument **default\_visitor\_code** als Identifikator, falls es übergeben wird. Dies ermöglicht es unseren Kunden, ihre eigenen Identifikatoren als Visitor Codes zu verwenden, wenn sie dies wünschen, was den zusätzlichen Vorteil hat, Kameleoon-Besucher ohne zusätzliche Suchvorgänge in einer Abgleichstabelle ihren eigenen Benutzern zuzuordnen.
3. In jedem Fall wird der serverseitige (über HTTP-Header) **kameleoonVisitorCode**-Cookie mit dem Wert gesetzt. Dann wird dieser Identifikator-Wert schließlich von der Methode zurückgegeben.
Wenn Sie Ihren eigenen `visitor_code` angeben, müssen Sie dessen Eindeutigkeit garantieren. Das SDK validiert den als Argument übergebenen Wert nicht. Beachten Sie auch, dass die Länge des `visitor_code` auf **255** Zeichen begrenzt ist. Eine `VisitorCodeInvalid`-Ausnahme wird ausgelöst, wenn diese Grenze überschritten wird.
Mit der Methode `get_visitor_code()` können Sie **simulierte** Variationen für einen Besucher festlegen. Wenn Cookies (aus einer **Anfrage** oder einem **Dokument**) den Schlüssel `kameleoonSimulationFFData` enthalten, wird der Standard-Auswertungsprozess umgangen. Stattdessen gibt die Methode direkt eine [`Variation`](#variation) basierend auf den bereitgestellten Daten zurück.
Sie können Simulationen auf zwei Arten anwenden:
* **Automatisch (empfohlen):** Wenn Sie Kameleoon Web Experimentation oder das SDK im [Hybrid-Modus](/developer-docs/feature-experimentation/get-started/hybrid-experimentation#linking-feature-experiments-with-front-end-tracking-code) verwenden, wird das Cookie automatisch erstellt, wenn Sie die Anzeige einer Variante über das [Simulation Panel](/user-manual/experimentation/feature-experimentation/using-the-rollout-planner/validation-and-rollback/using-simulation-mode) simulieren.
* **Manuell:** Setzen Sie das Cookie `kameleoonSimulationFFData` manuell.
Es ist wichtig, **simulierte** Variationen von **[erzwungenen](#set_forced_variation)** Variationen zu unterscheiden:
* **Simulierte Variationen**: Beeinflussen das Gesamtergebnis des **Feature Flags**.
* **Erzwungene Variationen**: Sind spezifisch für ein einzelnes Experiment.
⚙️ **Manuelle Einrichtung**
Bitte stellen Sie sicher, dass das Cookie `kameleoonSimulationFFData` diesem Format folgt:
* `kameleoonSimulationFFData={"featureKey":{"expId":10,"varId":20}}`: Simuliert die Variation mit `varId` des Experiments `expId` für den angegebenen `featureKey`.
* `kameleoonSimulationFFData={"featureKey":{"expId":0}}`: Simuliert die Standardvariation (definiert im Abschnitt **Then, for everyone else in Production, serve**) für den angegebenen `featureKey`.
⚠️ Um eine ordnungsgemäße Funktionalität zu gewährleisten, muss der Cookie-Wert als URI-Komponente kodiert werden, z. B. mit einer Methode wie [`encodeURIComponent`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/encodeURIComponent).
```python theme={null}
### if you use KameleoonWSGIMiddleware service
visitor_code = kameleoon_client.get_visitor_code(cookies_readonly=request.COOKIES)
kameleoon_client.set_legal_consent(visitor_code, True)
### if you want to manage cookies manually
simple_cookies = SimpleCookie()
simple_cookies.load(cookie_header)
visitor_code = kameleoon_client.get_visitor_code(cookies=simple_cookies, default_visitor_code=default_visitor_code)
cookie_header = simple_cookies.output()
```
##### Argumente
| Name | Typ | Beschreibung |
| ---------------------- | ----------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| cookies\_readonly | Optional\[Dict\[str, str]] | Schreibgeschütztes Wörterbuch, normalerweise `request.COOKIES`. Verwenden Sie diesen Parameter, wenn Sie auch den Dienst `KameleoonWSGIMiddleware` verwenden. Dieses Feld ist optional. |
| cookies | Optinal\[Dict\[str, http.cookies.Morsel\[str]]] | Übergeben Sie Cookies in der aktuellen HTTP-Anfrage als `Dict[str, http.cookies.Morsel[str]]`- oder `http.cookies.\|SimpleCookie[str]`-Objekt, wenn Sie Cookies manuell ohne den Dienst `KameleoonWSGIMiddleware` verwalten. Dieses Feld ist optional. |
| default\_visitor\_code | str | Dieser Parameter wird als **visitor\_code** verwendet, wenn in der Anfrage kein vorhandenes **kameleoonVisitorCode**-Cookie gefunden wird. Dieses Feld ist optional, und standardmäßig wird ein zufälliger **visitor\_code** generiert. |
##### Rückgabewert
| Typ | Beschreibung |
| --- | ------------------------------------------------------------------------------------------------------------------------------------------ |
| str | Ein **visitor\_code**, der mit diesem speziellen Benutzer verknüpft wird und mit den meisten unserer SDK-Methoden verwendet werden sollte. |
##### Geworfene Ausnahmen
| Typ | Beschreibung |
| ------------------ | ----------------------------------------------------------------------------------------------------------------------- |
| VisitorCodeInvalid | Ausnahme, die anzeigt, dass der angegebene Visitor Code ungültig ist. Er ist entweder leer oder länger als 255 Zeichen. |
#### add\_data()
Die Methode `add_data()` fügt [Targeting-Daten](#datentypen) zum Speicher hinzu, damit andere Methoden die Daten verwenden können, um zu entscheiden, ob der aktuelle Besucher angesprochen werden soll oder nicht.
Die Methode `add_data()` gibt keinen Wert zurück und interagiert nicht selbständig mit den Kameleoon-Backend-Servern. Stattdessen werden alle deklarierten Daten für die spätere Übertragung über die Methode [`flush()`](#flush) gespeichert. Dieser Ansatz reduziert die Anzahl der Serveraufrufe, da die Daten in der Regel zu einem einzigen Serveraufruf zusammengefasst werden, der durch `flush()` ausgelöst wird.
Die Methode [`track_conversion()`](#track_conversion) sendet auch alle zuvor verknüpften Daten, genau wie `flush()`. Dasselbe gilt für die Methoden [`get_variation()`](#get_variation) und [`get_variations()`](#get_variations), wenn eine Experimentierungsregel ausgelöst wird.
Jeder Besucher kann für die meisten Datentypen nur eine Instanz verknüpfter Daten haben. [`CustomData`](#customdata) ist jedoch eine Ausnahme. Besucher können eine Instanz verknüpfter `CustomData` pro Index haben.
```python theme={null}
require "kameleoon"
require "kameleoon/data"
# Add a single data item (tracked by default)
kameleoon_client.add_data(visitor_code, Browser(BrowserType.CHROME))
# Add multiple data items (tracked by default)
kameleoon_client.add_data(
visitor_code,
PageView("https://url.com", "title", [3]),
UserAgent("UserAgent")
)
# Add multiple data items stored locally for targeting only (not sent to the Kameleoon Data API)
kameleoon_client.add_data(
visitor_code,
PageView("https://url.com", "title", [3]),
UserAgent("UserAgent"),
track=False
)
```
##### Argumente
| Name | Typ | Beschreibung | Standardwert |
| ------------------------------ | ------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------ |
| visitor\_code (*erforderlich*) | `str` | Eindeutiger Identifikator des Besuchers. | |
| data (*erforderlich*) | `*Data` | Sammlung von Kameleoon-Datentypen. | |
| track (*optional*) | `bool` | Gibt an, ob die hinzugefügten Daten für das Tracking geeignet sind. Wenn auf `False` gesetzt, werden die Daten lokal gespeichert und nur für die Targeting-Auswertung verwendet; sie werden nicht an die Kameleoon Data API gesendet. | `True` |
##### Ausnahmen
| Typ | Beschreibung |
| -------------------- | ----------------------------------------------------------------------------------------------------------------------- |
| `VisitorCodeInvalid` | Ausnahme, die anzeigt, dass der angegebene Visitor Code ungültig ist. Er ist entweder leer oder länger als 255 Zeichen. |
#### flush()
* 📨 *Sendet Tracking-Daten an Kameleoon*
`flush()` nimmt die Kameleoon-Daten, die mit dem Besucher verknüpft sind, und alle Daten, die zuvor mit der Methode `add_data` hinzugefügt wurden und beim Aufruf einer [dieser Methoden](/developer-docs/feature-experimentation/technical-reference/faq-global#when-does-the-sdk-send-a-tracking-request-for-analytics) noch nicht gesendet wurden, und sendet eine Tracking-Anfrage. `flush()` ist nicht blockierend, da der Serveraufruf asynchron erfolgt.
Mit `flush()` können Sie steuern, wann die mit einem bestimmten `visitor_code` verknüpften Daten an unsere Server gesendet werden. Wenn Sie beispielsweise `add_data()` ein Dutzend Mal aufrufen, wäre es ineffizient, Daten bei jedem Aufruf von `add_data()` an den Server zu senden, sodass Sie `flush()` nur einmal am Ende aufrufen müssen.
Wenn Sie einen `visitor_code` angeben, verwendet die Methode `flush()` diesen als eindeutigen Besucher-Identifikator, was für [Cross-Device-Experimente](/developer-docs/cross-device-experimentation) nützlich ist. Wenn Sie einen `visitor_code` angeben und den Parameter `is_unique_identifier` auf `true` setzen, verknüpft das SDK die geflushten Daten mit dem Besucher, der mit dem angegebenen Identifikator verknüpft ist.
Der Parameter `is_unique_identifier` ist veraltet. Bitte verwenden Sie stattdessen [`UniqueIdentifier`](#uniqueidentifier).
Der `is_unique_identifier` kann auch in anderen Sonderfallszenarien nützlich sein, z. B. wenn Sie nicht auf den anonymen `visitor_code` zugreifen können, der dem Besucher ursprünglich zugewiesen wurde, aber Zugriff auf eine interne ID haben, die über die Sitzungszusammenführungs-Funktionen mit dem anonymen Besucher verknüpft ist.
```python theme={null}
kameleoon_client.add_data(visitor_code, Browser(BrowserType.CHROME))
kameleoon_client.add_data(
visitor_code,
PageView("https://url.com", "title", [3]),
CustomData(0, "value")
)
kameleoon_client.add_data(visitor_code, Conversion(32, 10, false))
kameleoon_client.flush(visitor_code) # Interval tracking (most performant way for tracking)
kameleoon_client.flush(visitor_code, instant=True) # Instant tracking
# If you operate with unique ID
kameleoon_client.add_data(UniqueIdentifier(True))
kameleoon_client.flush(visitor_code)
```
##### Argumente
| Name | Typ | Beschreibung |
| --------------------------------- | --------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| visitor\_code | String | Eindeutiger Identifikator des Benutzers. Dieses Feld ist obligatorisch. |
| is\_unique\_identifier (Veraltet) | Optional\[bool] | Bei `True` verknüpft das SDK die geflushten Daten mit dem Besucher, der mit dem angegebenen Identifikator verknüpft ist. |
| instant | bool | Boolesches Flag, das angibt, ob die Daten sofort (`True`) oder gemäß dem geplanten Tracking-Intervall (`False`) gesendet werden sollen. Wenn nicht angegeben, ist der Standardwert `False`. Dieses Feld ist optional. |
#### get\_remote\_data()
* Zuvor `retrieve_data_from_remote_source` genannt, das in der SDK-Version `3.0.0` entfernt wurde.
* Wenn Sie Daten asynchron abrufen möchten, verwenden Sie stattdessen die Methode `get_remote_data_async` (verfügbar seit Version 2.3.0).
Die Methode `get_remote_data` ruft Daten synchron (gemäß einem als Argument übergebenen **Schlüssel**) für einen angegebenen **site\_code** (angegeben mit `KameleoonClient.__init__`) ab, der auf einem entfernten Kameleoon-Server gespeichert ist. Daten werden in der Regel über unsere Data API auf unseren entfernten Servern gespeichert. Diese Methode bietet zusammen mit der Verfügbarkeit unserer hoch skalierbaren Server für diesen Zweck eine bequeme Methode, um große Datenmengen zu speichern, die für jeden Ihrer Besucher/Benutzer abgerufen werden können.
```python theme={null}
kameleoon_client.get_remote_data('key1') # default timeout
kameleoon_client.get_remote_data('key2', 1.0) # 1 second timeout
```
##### Argumente
| Name | Typ | Beschreibung |
| ------- | ---------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| key | str | Der Schlüssel, mit dem die Daten verknüpft sind. Dieses Feld ist obligatorisch. |
| timeout | Optional\[float] | Timeout (in Sekunden). Dieser Parameter gibt die maximale Zeit an, in der die Methode auf ein Ergebnis warten kann. Dieses Feld ist optional; wenn es nicht angegeben wird, wird der Wert `default_timeout_millisecond` aus der Konfigurationsdatei verwendet, oder zwei Sekunden, falls dieser in der Datei nicht angegeben ist. |
##### Rückgabewert
| Typ | Beschreibung |
| ----------- | -------------------------------------------------------------------------------------------- |
| JSON object | JSON-Objekt, das mit dem Abrufen von Daten für einen bestimmten **Schlüssel** verknüpft ist. |
#### get\_remote\_data\_async()
Mit der Methode `get_remote_data_async` können Sie Daten asynchron (gemäß einem als Argument übergebenen **Schlüssel**) für einen angegebenen **site\_code** (angegeben mit `KameleoonClient.__init__`) abrufen, der auf einem entfernten Kameleoon-Server gespeichert ist. Daten werden in der Regel über unsere Data API auf unseren entfernten Servern gespeichert. Diese Methode bietet zusammen mit der Verfügbarkeit unserer hoch skalierbaren Server für diesen Zweck eine bequeme Methode, um große Datenmengen zu speichern, die für jeden Ihrer Besucher/Benutzer abgerufen werden können.
```python theme={null}
await kameleoon_client.get_remote_data_async('key1') # default timeout
await kameleoon_client.get_remote_data_async('key2', 1.0) # 1 second timeout
```
##### Argumente
| Name | Typ | Beschreibung |
| ------- | ---------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| key | str | Der Schlüssel, mit dem die Daten verknüpft sind. Dieses Feld ist obligatorisch. |
| timeout | Optional\[float] | Timeout (in Sekunden). Dieser Parameter gibt die maximale Zeit an, in der die Methode auf ein Ergebnis warten kann. Dieses Feld ist optional; wenn es nicht angegeben wird, wird der Wert `default_timeout_millisecond` aus der Konfigurationsdatei verwendet, oder zwei Sekunden, falls dieser in der Datei nicht angegeben ist. |
##### Rückgabewert
| Typ | Beschreibung |
| ----------- | -------------------------------------------------------------------------------------------- |
| JSON object | JSON-Objekt, das mit dem Abrufen von Daten für einen bestimmten **Schlüssel** verknüpft ist. |
#### get\_remote\_visitor\_data()
`get_remote_visitor_data()` ist eine asynchrone Methode zum Abrufen der Kameleoon Visits Data für den `visitor_code` von der Kameleoon Data API. Die Methode fügt die Daten dem Speicher hinzu, damit andere Methoden sie bei Targeting-Entscheidungen verwenden können.
Mit dieser Methode erhaltene Daten spielen eine wichtige Rolle, wenn Sie:
* Daten verwenden möchten, die auf anderen Geräten gesammelt wurden.
* auf den Verlauf eines Benutzers zugreifen möchten, z. B. auf Seiten, die bei früheren Besuchen besucht wurden.
* Daten verwenden möchten, die nur auf der Clientseite zugänglich sind, wie Datalayer-Variablen und Ziele, die nur im Frontend konvertieren.
Lesen Sie [diesen Artikel](/developer-docs/feature-experimentation/targeting-and-segmentation/native-segmentation), um die möglichen Anwendungsfälle besser zu verstehen.
Standardmäßig ruft `get_remote_visitor_data()` automatisch die zuletzt gespeicherten Custom Data mit `scope=visitor` ab und hängt sie an den Besucher an, ohne dass die Methode `add_data()` aufgerufen werden muss. Dies ist besonders nützlich, um [Custom Data zwischen mehreren Geräten zu synchronisieren](/developer-docs/sdks/web-sdks/nodejs-sdk#synchronizing-custom-data-across-devices).
Der Parameter `is_unique_identifier` ist veraltet. Bitte verwenden Sie stattdessen [`UniqueIdentifier`](#uniqueidentifier).
Der `is_unique_identifier` kann auch in anderen Sonderfallszenarien nützlich sein, z. B. wenn Sie nicht auf den anonymen `visitor_code` zugreifen können, der dem Besucher ursprünglich zugewiesen wurde, aber Zugriff auf eine interne ID haben, die über die Sitzungszusammenführungs-Funktionen mit dem anonymen Besucher verknüpft ist.
```python theme={null}
visitor_code = 'visitorCode'
# Visitor data will be fetched and automatically added for `visitor_code`
data_list = kameleoon_client.get_remote_visitor_data(visitor_code) # default timeout
data_list = kameleoon_client.get_remote_visitor_data(visitor_code, timeout=1.0) # 1 second timeout
# If you only want to fetch data and add it yourself manually, set `add_data` to `False`
data_list = kameleoon_client.get_remote_visitor_data(visitor_code, False) # default timeout
data_list = kameleoon_client.get_remote_visitor_data(visitor_code, False, 1.0) # 1 second timeout
# If you want to fetch custom list of data types
data_filter = RemoteVisitorDataFilter(25, customData=False, conversions=True, experiments=True)
data_list = kameleoon_client.get_remote_visitor_data(visitor_code, data_filter=data_filter)
# If you want the SDK to link the extracted data with the visitor associated with the specified identifier.
kameleoon_client.add_data(UniqueIdentifier(True))
data_list = kameleoon_client.get_remote_visitor_data(visitor_code)
```
##### Argumente
| Name | Typ | Beschreibung |
| --------------------------------- | ----------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| visitor\_code | str | Der Visitor Code, für den Sie die zugewiesenen Daten abrufen möchten. Dieses Feld ist obligatorisch. |
| add\_data | bool | Ein Boolean, der angibt, ob die Methode die abgerufenen Daten für einen Besucher automatisch hinzufügen soll. Wenn nicht angegeben, ist der Standardwert **True**. Dieses Feld ist optional. |
| data\_filter | RemoteVisitorDataFilter | Filter, der angibt, welche Daten aus Besuchen abgerufen werden sollen. Standardmäßig werden nur `CustomData` aus dem aktuellen und letzten vorherigen Besuch abgerufen (`RemoteVisitorDataFilter(previousVisitAmount=1, currentVisit=True, customData=True)` oder `RemoteVisitorDataFilter()`). Andere Filterparameter sind auf `False` gesetzt. Dieses Feld ist optional. |
| is\_unique\_identifier (Veraltet) | Optional\[bool] | Ein optionaler Parameter zur Angabe, ob der `visitorCode` ein eindeutiger Identifikator ist. Wenn nicht angegeben, ist der Standardwert `False`. Dieses Feld ist optional. |
| timeout | Optional\[float] | Timeout (in Sekunden). Dieser Parameter gibt die maximale Zeit an, in der die Methode auf ein Ergebnis warten kann. Dieses Feld ist optional; wenn es nicht angegeben wird, wird der Wert `default_timeout_millisecond` aus der Konfigurationsdatei verwendet, oder zwei Sekunden, falls dieser in der Datei nicht angegeben ist. |
##### Verwendung von Parametern in get\_remote\_visitor\_data()
Die Methode `get_remote_visitor_data()` bietet Flexibilität, indem sie es Ihnen ermöglicht, verschiedene Parameter beim Abrufen von Daten über Besucher zu definieren. Egal, ob Sie auf der Grundlage von Zielen, Experimenten oder Variationen ansprechen, der gleiche Ansatz gilt für alle Datentypen.
Angenommen, Sie möchten Daten über Besucher abrufen, die das Ziel "Order transaction" abgeschlossen haben. Sie können Parameter innerhalb der Methode `get_remote_visitor_data()` angeben, um Ihr Targeting zu verfeinern. Wenn Sie beispielsweise nur Benutzer ansprechen möchten, die das Ziel in ihren letzten fünf Besuchen konvertiert haben, können Sie den Parameter `previous_visit_amount` auf 5 und `conversions` auf true setzen.
Die in diesem Beispiel gezeigte Flexibilität ist nicht auf Zieldaten beschränkt. Sie können Parameter innerhalb der Methode `get_remote_visitor_data()` verwenden, um Daten zu einer Vielzahl von Besucherverhaltensweisen abzurufen.
##### Rückgabewert
| Typ | Beschreibung |
| ----------- | ------------------------------------------------------------------- |
| List\[Data] | Eine Liste von Daten, die dem angegebenen Besucher zugewiesen sind. |
Hier ist die Liste der verfügbaren `Kameleoon::Configuration::RemoteVisitorDataFilter`-Optionen:
| Name | Typ | Beschreibung | Standard |
| ------------------------------------ | ------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | -------- |
| previous\_visit\_amount (*optional*) | `int` | Anzahl der vorherigen Besuche, aus denen Daten abgerufen werden sollen. Zahl zwischen `1` und `25` | `1` |
| current\_visit (*optional*) | `bool` | Bei True werden Daten des aktuellen Besuchs abgerufen | `True` |
| custom\_data (*optional*) | `bool` | Bei True werden Custom Data abgerufen. | `True` |
| page\_views (*optional*) | `bool` | Bei True werden Seitendaten abgerufen. | `False` |
| geolocation (*optional*) | `bool` | Bei True werden Geolokationsdaten abgerufen. | `False` |
| device (*optional*) | `bool` | Bei True werden Gerätedaten abgerufen. | `False` |
| browser (*optional*) | `bool` | Bei True werden Browserdaten abgerufen. | `False` |
| operating\_system (*optional*) | `bool` | Bei True werden Betriebssystemdaten abgerufen. | `False` |
| conversions (*optional*) | `bool` | Bei True werden Konversionsdaten abgerufen. | `False` |
| experiments (*optional*) | `bool` | Bei True werden Experimentdaten abgerufen. | `False` |
| kcs (*optional*) | `bool` | Bei true wird der Kameleoon Conversion Score (KCS) abgerufen. Erfordert das [AI Predictive Targeting Add-on](/user-manual/ai-predictive-targeting/target-users-based-on-likelihood-to-convert) | `False` |
| visitor\_code (*optional*) | `bool` | Bei true ruft Kameleoon den `visitorCode` aus dem jüngsten Besuch ab und verwendet ihn für den aktuellen Besuch. Dies ist notwendig, wenn Sie sicherstellen möchten, dass der Besucher, identifiziert durch seinen `visitorCode`, bei allen Besuchen für [Cross-Device-Experimente](/developer-docs/cross-device-experimentation) immer dieselbe Variation erhält. | `True` |
| cbs (*optional*) | `bool` | Bei true werden Contextual-Bandit-Score-Daten abgerufen. | `False` |
| personalization (*optional*) | `bool` | Bei True werden Personalisierungsdaten abgerufen. Dies ist für die Personalisierungsbedingung erforderlich. | `False` |
#### get\_remote\_visitor\_data\_async()
Die Methode `get_remote_visitor_data_async` ruft asynchron Custom Data ab, die auf entfernten Kameleoon-Servern für einen Besucher (angegeben mit dem Argument **visitor\_code**) gespeichert sind. Wenn **add\_data** auf **True** gesetzt ist, fügt diese Methode die abgerufenen Daten automatisch einem Besucher hinzu, ohne dass ein separater `add_data`-Aufruf erforderlich ist.
Sie müssen zuvor Daten auf unseren entfernten Servern gespeichert haben, die Sie mit einem der folgenden Tracking-Aufrufe im SDK hinzufügen können:
* `flush`
* `get_feature_variation_key`
* `get_feature_variable`
* `is_feature_active`
Die Verwendung der Methode `get_remote_visitor_data` zusammen mit der Verfügbarkeit unserer hoch skalierbaren Server bietet eine bequeme Methode, um auf große Datenmengen über alle Geräte des Besuchers hinweg zuzugreifen und sie zu synchronisieren.
Wenn Sie einen `visitor_code` angeben, verwendet die Methode `get_remote_visitor_data_async` den `visitor_code` als eindeutigen Besucher-Identifikator, was für [Cross-Device-Experimente](/developer-docs/cross-device-experimentation) nützlich ist. Wenn Sie einen `visitor_code` angeben und den Parameter `is_unique_identifier` auf `true` setzen, verknüpft das SDK die geflushten Daten mit dem Besucher, der mit dem angegebenen Identifikator verknüpft ist.
Der Parameter `is_unique_identifier` ist veraltet. Bitte verwenden Sie stattdessen [`UniqueIdentifier`](#uniqueidentifier).
Der `is_unique_identifier` kann auch in anderen Sonderfallszenarien nützlich sein, z. B. wenn Sie nicht auf den anonymen `visitor_code` zugreifen können, der dem Besucher ursprünglich zugewiesen wurde, aber Zugriff auf eine interne ID haben, die über die Sitzungszusammenführungs-Funktionen mit dem anonymen Besucher verknüpft ist.
```python theme={null}
visitor_code = 'visitorCode'
# Visitor data will be fetched and automatically added for `visitor_code`
data_list = await kameleoon_client.get_remote_visitor_data_async(visitor_code) # default timeout
data_list = await kameleoon_client.get_remote_visitor_data_async(visitor_code, timeout=1.0) # 1 second timeout
# If you only want to fetch data and add it yourself manually, set `add_data` to `False`
data_list = await kameleoon_client.get_remote_visitor_data_async(visitor_code, False) # default timeout
data_list = await kameleoon_client.get_remote_visitor_data_async(visitor_code, False, 1.0) # 1 second timeout
# If you want to fetch custom list of data types
data_filter = RemoteVisitorDataFilter(25, customData=False, conversions=True, experiments=True)
data_list = kameleoon_client.get_remote_visitor_data(visitor_code, data_filter=data_filter)
# If you want the SDK to link the extracted data with the visitor associated with the specified identifier.
kameleoon_client.add_data(UniqueIdentifier(True))
data_list = kameleoon_client.get_remote_visitor_data(visitor_code)
```
##### Argumente
| Name | Typ | Beschreibung |
| --------------------------------- | ----------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| visitor\_code | str | Der Visitor Code, für den Sie die zugewiesenen Daten abrufen möchten. Dieses Feld ist obligatorisch. |
| add\_data | bool | Ein Boolean, der angibt, ob die Methode die abgerufenen Daten für einen Besucher automatisch hinzufügen soll. Wenn nicht angegeben, ist der Standardwert **True**. Dieses Feld ist optional. |
| data\_filter | RemoteVisitorDataFilter | Filter, der angibt, welche Daten aus Besuchen abgerufen werden sollen. Standardmäßig werden nur `CustomData` aus dem aktuellen und letzten vorherigen Besuch abgerufen (`RemoteVisitorDataFilter(previousVisitAmount=1, currentVisit=True, customData=True)` oder `RemoteVisitorDataFilter()`). Andere Filterparameter sind auf `False` gesetzt. Dieses Feld ist optional. |
| is\_unique\_identifier (Veraltet) | Optional\[bool] | Ein optionaler Parameter zur Angabe, ob der `visitorCode` ein eindeutiger Identifikator ist. Wenn nicht angegeben, ist der Standardwert `False`. Das Feld ist optional. |
| timeout | Optional\[float] | Timeout (in Sekunden). Dieser Parameter gibt die maximale Zeit an, in der die Methode auf ein Ergebnis warten kann. Dieses Feld ist optional; wenn es nicht angegeben wird, wird der Wert `default_timeout_millisecond` aus der Konfigurationsdatei verwendet, oder zwei Sekunden, falls dieser in der Datei nicht angegeben ist. |
##### Rückgabewert
| Typ | Beschreibung |
| ----------- | ------------------------------------------------------- |
| List\[Data] | Eine Liste von Daten, die dem Besucher zugewiesen sind. |
##### Verwendung von Parametern in get\_remote\_visitor\_data\_async()
Die Methode `get_remote_visitor_data_async()` bietet Flexibilität, indem sie es Ihnen ermöglicht, verschiedene Parameter beim Abrufen von Daten über Besucher zu definieren. Egal, ob Sie auf der Grundlage von Zielen, Experimenten oder Variationen ansprechen, der gleiche Ansatz gilt für alle Datentypen.
Angenommen, Sie möchten Daten über Besucher abrufen, die das Ziel "Order transaction" abgeschlossen haben. Sie können Parameter innerhalb der Methode `get_remote_visitor_data_async()` angeben, um Ihr Targeting zu verfeinern. Wenn Sie beispielsweise nur Benutzer ansprechen möchten, die das Ziel in ihren letzten fünf Besuchen konvertiert haben, können Sie den Parameter `previous_visit_amount` auf 5 und `conversions` auf true setzen.
Die in diesem Beispiel gezeigte Flexibilität ist nicht auf Zieldaten beschränkt. Sie können Parameter innerhalb der Methode `get_remote_visitor_data_async()` verwenden, um Daten zu einer Vielzahl von Besucherverhaltensweisen abzurufen.
Hier ist die Liste der verfügbaren `Kameleoon::Configuration::RemoteVisitorDataFilter`-Optionen:
| Name | Typ | Beschreibung | Standard |
| ------------------------------------ | ------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | -------- |
| previous\_visit\_amount (*optional*) | `int` | Anzahl der vorherigen Besuche, aus denen Daten abgerufen werden sollen. Zahl zwischen `1` und `25` | `1` |
| current\_visit (*optional*) | `bool` | Bei True werden Daten des aktuellen Besuchs abgerufen | `True` |
| custom\_data (*optional*) | `bool` | Bei True werden Custom Data abgerufen. | `True` |
| page\_views (*optional*) | `bool` | Bei True werden Seitendaten abgerufen. | `False` |
| geolocation (*optional*) | `bool` | Bei True werden Geolokationsdaten abgerufen. | `False` |
| device (*optional*) | `bool` | Bei True werden Gerätedaten abgerufen. | `False` |
| browser (*optional*) | `bool` | Bei True werden Browserdaten abgerufen. | `False` |
| operating\_system (*optional*) | `bool` | Bei True werden Betriebssystemdaten abgerufen. | `False` |
| conversions (*optional*) | `bool` | Bei True werden Konversionsdaten abgerufen. | `False` |
| experiments (*optional*) | `bool` | Bei True werden Experimentdaten abgerufen. | `False` |
| kcs (*optional*) | `bool` | Bei true wird der Kameleoon Conversion Score (KCS) abgerufen. Erfordert das [AI Predictive Targeting Add-on](/user-manual/ai-predictive-targeting/target-users-based-on-likelihood-to-convert) | `False` |
| visitor\_code (*optional*) | `bool` | Bei true ruft Kameleoon den `visitorCode` aus dem jüngsten Besuch ab und verwendet ihn für den aktuellen Besuch. Dies ist notwendig, wenn Sie sicherstellen möchten, dass der Besucher, identifiziert durch seinen `visitorCode`, bei allen Besuchen für [Cross-Device-Experimente](/developer-docs/cross-device-experimentation) immer dieselbe Variation erhält. | `True` |
| cbs (*optional*) | `bool` | Bei true werden Contextual-Bandit-Score-Daten abgerufen. | `False` |
#### get\_visitor\_warehouse\_audience()
Ruft synchron alle Zielgruppendaten ab, die mit dem Besucher in Ihrem Data Warehouse verknüpft sind, unter Verwendung des angegebenen **visitor\_code** und **warehouse\_key**. Der **warehouse\_key** ist in der Regel Ihre interne Benutzer-ID. Der Parameter **custom\_data\_index** entspricht der Kameleoon-Custom-Data, die Kameleoon verwendet, um Ihre Besucher anzusprechen. Weitere Details finden Sie in der [Warehouse-Targeting-Dokumentation](/user-manual/integrations/data-warehouses/bigquery/use-bigquery-as-a-source-audience-targeting). Die Methode gibt ein `CustomData`-Objekt zurück, das bestätigt, dass die Daten dem Besucher hinzugefügt wurden und für Targeting-Zwecke verfügbar sind.
Wenn Sie die Daten asynchron abrufen möchten, verwenden Sie stattdessen die Methode `get_visitor_warehouse_audience_async`.
```python theme={null}
try:
warehouse_audience_data = kameleoon_client.\
get_visitor_warehouse_audience(visitor_code, custom_data_index) # default timeout
warehouse_audience_data = kameleoon_client.\
get_visitor_warehouse_audience(visitor_code, custom_data_index, timeout=1.0) # 1 second timeout
warehouse_audience_data = kameleoon_client.\
get_visitor_warehouse_audience(visitor_code, custom_data_index, warehouse_key) # default timeout
warehouse_audience_data = kameleoon_client.\
get_visitor_warehouse_audience(visitor_code, custom_data_index, warehouse_key, 1.0) # 1 second timeout
# Your custom code
except VisitorCodeInvalid as e:
# Handle exception
```
##### Argumente
| Name | Typ | Beschreibung |
| ------------------- | ---------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| visitor\_code | str | Eine eindeutige Besucher-Identifikationszeichenkette, darf 255 Zeichen nicht überschreiten. Dieses Feld ist obligatorisch. |
| custom\_data\_index | int | Eine Ganzzahl, die den Index der Custom Data darstellt, die Sie zum Ansprechen Ihrer BigQuery Audiences verwenden möchten. Dieses Feld ist obligatorisch. |
| warehouse\_key | Optional\[str] | Ein eindeutiger Schlüssel zur Identifizierung der Warehouse-Daten (in der Regel Ihre interne Benutzer-ID). Dieses Feld ist optional. |
| timeout | Optional\[float] | Timeout (in Sekunden). Dieser Parameter gibt die maximale Zeit an, die auf ein Ergebnis gewartet werden soll. Dieses Feld ist optional. Wenn nicht angegeben, beträgt der Standardwert 10 Sekunden. |
##### Rückgabewert
| Typ | Beschreibung |
| --------------------- | ----------------------------------------------------------------------------------------- |
| Optional\[CustomData] | Eine `CustomData`-Instanz, die bestätigt, dass die Daten dem Besucher hinzugefügt wurden. |
##### Geworfene Ausnahmen
| Typ | Beschreibung |
| ------------------ | ----------------------------------------------------------------------------------------------------------------------- |
| VisitorCodeInvalid | Ausnahme, die anzeigt, dass der angegebene Visitor Code ungültig ist. Er ist entweder leer oder länger als 255 Zeichen. |
#### get\_visitor\_warehouse\_audience\_async()
Ruft asynchron alle Zielgruppendaten ab, die mit dem Besucher in Ihrem Data Warehouse verknüpft sind, unter Verwendung des angegebenen **visitor\_code** und **warehouse\_key**. Der **warehouse\_key** ist in der Regel Ihre interne Benutzer-ID. Der Parameter **custom\_data\_index** entspricht der Kameleoon-Custom-Data, die Kameleoon verwendet, um Ihre Besucher anzusprechen. Weitere Details finden Sie in der [Warehouse-Targeting-Dokumentation](/user-manual/integrations/data-warehouses/bigquery/use-bigquery-as-a-source-audience-targeting). Die Methode gibt ein `CustomData`-Objekt zurück, das bestätigt, dass die Daten dem Besucher hinzugefügt wurden und für Targeting-Zwecke verfügbar sind.
```python theme={null}
try:
warehouse_audience_data = await kameleoon_client.\
get_visitor_warehouse_audience_async(visitor_code, custom_data_index) # default timeout
warehouse_audience_data = await kameleoon_client.\
get_visitor_warehouse_audience_async(visitor_code, custom_data_index, timeout=1.0) # 1 second timeout
warehouse_audience_data = await kameleoon_client.\
get_visitor_warehouse_audience_async(visitor_code, custom_data_index, warehouse_key) # default timeout
warehouse_audience_data = await kameleoon_client.\
get_visitor_warehouse_audience_async(visitor_code, custom_data_index, warehouse_key, 1.0) # 1 second timeout
# Your custom code
except VisitorCodeInvalid as e:
# Handle exception
```
##### Argumente
| Name | Typ | Beschreibung |
| ------------------- | ---------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| visitor\_code | str | Eine eindeutige Besucher-Identifikationszeichenkette, darf 255 Zeichen nicht überschreiten. Dieses Feld ist obligatorisch. |
| custom\_data\_index | int | Eine Ganzzahl, die den Index der Custom Data darstellt, die Sie zum Ansprechen Ihrer BigQuery Audiences verwenden möchten. Dieses Feld ist obligatorisch. |
| warehouse\_key | Optional\[str] | Ein eindeutiger Schlüssel zur Identifizierung der Warehouse-Daten (in der Regel Ihre interne Benutzer-ID). Dieses Feld ist optional. |
| timeout | Optional\[float] | Timeout (in Sekunden). Dieser Parameter gibt die maximale Zeit an, die auf ein Ergebnis gewartet werden soll. Dieses Feld ist optional. Wenn nicht angegeben, beträgt der Standardwert 10 Sekunden. |
##### Rückgabewert
| Typ | Beschreibung |
| --------------------- | ----------------------------------------------------------------------------------------- |
| Optional\[CustomData] | Eine `CustomData`-Instanz, die bestätigt, dass die Daten dem Besucher hinzugefügt wurden. |
##### Geworfene Ausnahmen
| Typ | Beschreibung |
| ------------------ | ----------------------------------------------------------------------------------------------------------------------- |
| VisitorCodeInvalid | Ausnahme, die anzeigt, dass der angegebene Visitor Code ungültig ist. Er ist entweder leer oder länger als 255 Zeichen. |
#### set\_legal\_consent()
Sie müssen diese Methode verwenden, um anzugeben, ob der Besucher die rechtliche Einwilligung zur Verwendung personenbezogener Daten erteilt hat. Wenn Sie den Parameter `consent` auf `False` setzen, werden die Arten von Daten, die Sie in Tracking-Anfragen einbeziehen können, eingeschränkt. Diese Methode hilft Ihnen, rechtliche und regulatorische Anforderungen einzuhalten und gleichzeitig Besucherdaten verantwortungsvoll zu verwalten. Weitere Informationen zu personenbezogenen Daten finden Sie in unserer [Richtlinie zum Einwilligungsmanagement](/user-manual/project-management/consent-management-policy).
```python theme={null}
### if you use KameleoonWSGIMiddleware service
visitor_code = kameleoon_client.get_visitor_code(cookies_readonly=request.COOKIES)
kameleoon_client.set_legal_consent(visitor_code, True)
### if you want to manage cookies manually
cookies = http.cookies.SimpleCookie()
cookies.load(cookie_header)
visitor_code = kameleoon_client.get_visitor_code(cookies=cookies)
kameleoon_client.set_legal_consent(visitor_code, True, cookies)
cookie_header = cookies.output()
```
##### Verhalten bei Widerruf der Einwilligung
Wenn Sie `set_legal_consent()` mit `consent=False` aufrufen, löscht das SDK das `kameleoonVisitorCode`-Cookie nicht. Stattdessen hört es auf, das Ablaufdatum des Cookies zu verlängern, sodass das Cookie bis zu seinem natürlichen Ablauf bestehen bleibt.
Wenn Ihre Compliance-Anforderungen die sofortige Entfernung der Cookie-Datei bei Opt-Out verlangen, müssen Sie sie manuell mit den nativen Cookie-Verwaltungsmethoden Ihres Frameworks löschen. Das SDK entfernt die Datei nicht automatisch.
##### Argumente
| Name | Typ | Beschreibung |
| ------------- | ------------------------------------------------ | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| visitor\_code | str | Der eindeutige Identifikator des Benutzers. Dieses Feld ist erforderlich. |
| consent | bool | Ein boolescher Wert, der den Status der rechtlichen Einwilligung darstellt. `true` zeigt an, dass der Besucher die rechtliche Einwilligung erteilt hat, `false` zeigt an, dass der Besucher die rechtliche Einwilligung nie erteilt oder widerrufen hat. Dieses Feld ist erforderlich. |
| cookies | Optional\[Dict\[str, http.cookies.Morsel\[str]]] | Die Cookies, die basierend auf dem Status der rechtlichen Einwilligung angepasst werden sollen, als `Dict[str, http.cookies.Morsel[str]]`- oder `http.cookies.SimpleCookie[str]`-Objekt. Dieses Feld ist optional. |
##### Geworfene Ausnahmen
| Typ | Beschreibung |
| ------------------ | ----------------------------------------------------------------------------------------------------------------------- |
| VisitorCodeInvalid | Ausnahme, die anzeigt, dass der angegebene Visitor Code ungültig ist. Er ist entweder leer oder länger als 255 Zeichen. |
#### forget()
Die Methode `forget` entfernt eine `KameleoonClient`-Instanz aus der `KameleoonClientFactory` mit dem angegebenen **site\_code** und gibt die von der `KameleoonClient`-Instanz verwendeten Ressourcen frei. Die `KameleoonClient`-Instanz darf nach dem Aufruf der Methode `forget` nicht mehr verwendet werden.
Wenn Sie einen `visitor_code` angeben, verwendet die Methode `track_conversion` den `visitor_code` als eindeutigen Besucher-Identifikator, was für [Cross-Device-Experimente](/developer-docs/cross-device-experimentation) nützlich ist. Wenn Sie einen `visitor_code` angeben und den Parameter `is_unique_identifier` auf `true` setzen, verknüpft das SDK die geflushten Daten mit dem Besucher, der mit dem angegebenen Identifikator verknüpft ist.
Der `is_unique_identifier` kann auch in anderen Sonderfallszenarien nützlich sein, z. B. wenn Sie nicht auf den anonymen `visitor_code` zugreifen können, der dem Besucher ursprünglich zugewiesen wurde, aber Zugriff auf eine interne ID haben, die über die Sitzungszusammenführungs-Funktionen mit dem anonymen Besucher verknüpft ist.
```python theme={null}
require "kameleoon"
require "kameleoon/data"
visitor_code = kameleoon_client.get_visitor_code(request.COOKIES)
goal_id = 83023
kameleoon_client.add_data(visitor_code, Browser(BrowserType.CHROME))
kameleoon_client.add_data(
visitor_code,
PageView("https://url.com", "title", [3]),
CustomData(2, "value")
)
kameleoon_client.add_data(visitor_code, Conversion(32, 10, false))
kameleoon_client.track_conversion(visitor_code, goal_id)
```
##### Argumente
| Name | Typ | Beschreibung |
| ---------------------- | ------ | ------------------------------------------------------------------------------------------------------------------------ |
| visitor\_code | String | Eindeutiger Identifikator des Benutzers. Dieses Feld ist obligatorisch. |
| goal\_id | int | ID des Ziels. Dieses Feld ist obligatorisch. |
| revenue | float | Umsatz der Konversion. Dieses Feld ist optional. |
| is\_unique\_identifier | bool | Bei `True` verknüpft das SDK die geflushten Daten mit dem Besucher, der mit dem angegebenen Identifikator verknüpft ist. |
### Ziele und Drittanbieter-Analytics
#### get\_engine\_tracking\_code()
Kameleoon ist in mehrere Analyselösungen integriert, darunter Mixpanel, Google Analytics 4 und Segment. Um serverseitige Experimente korrekt zu verfolgen, rufen Sie die Methode `get_engine_tracking_code()` auf, nachdem der Besucher ein Experiment ausgelöst hat. Das SDK gibt JavaScript-Queue-Befehle für die Experimente zurück, die der Besucher in den letzten fünf Sekunden ausgelöst hat. Wenn Sie diesen Code in die Seite einfügen, verarbeitet Engine.js die Befehle und sendet die Expositionsereignisse über die aktive Analytics-Integration.
Weitere Informationen zur Implementierung dieser Methode finden Sie unter [Hybrid-Experimente](/developer-docs/feature-experimentation/get-started/hybrid-experimentation).
```python theme={null}
engine_tracking_code = kameleoon_client.get_engine_tracking_code(visitor_code)
```
* Um diese Funktion zu verwenden, implementieren Sie sowohl das Python SDK als auch Kameleoon [Engine.js](/developer-docs/web-experimentation/implementation-and-deployment/standard-implementation). Da Engine.js in diesem Ablauf nur für das Tracking verwendet wird, können Sie das asynchrone Tag vor dem schließenden ``-Tag installieren.
* Wenn Sie Experimente nur in Kameleoon verfolgen möchten und keine Expositionsereignisse an Drittanbieter-Analytics-Tools senden müssen, verwenden Sie das [JavaScript / TypeScript SDK](/developer-docs/sdks/web-sdks/js-sdk). Diese Option funktioniert gut für [serverlose Edge-Compute-Plattformen](/developer-docs/feature-experimentation/implementation-and-deployment/serverless-edge-compute-starter-kits). Das JavaScript / TypeScript SDK verfolgt Variationen automatisch, wenn Sie [`getVisitorCode`](/developer-docs/sdks/web-sdks/js-sdk#getvisitorcode) aufrufen, sofern Sie die entsprechenden Experimentzuweisungen zu `window.kameleoonQueue` hinzufügen..
* Sie können den zurückgegebenen Tracking-Code direkt in ein HTML-`