feat: support for wingify package (rebranded)

Author: Kaustubh22327

CHANGELOG.md

@@ -5,6 +5,75 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [1.50.0] - 2026-05-28
+
+This release introduces **Wingify** as the primary SDK branding and package namespace, while keeping existing **VWO** integrations fully supported.
+
+### Added
+
+- **Wingify public API** — use `init`, `WingifyClient`, `WingifyBuilder`, and `WingifyOptionsModel` from the `wingify` package as the recommended entry point for new integrations.
+
+  ```python
+  from wingify import init
+
+  client = init(
+      {
+          "account_id": "123456",
+          "sdk_key": "32-alpha-numeric-sdk-key",
+      }
+  )
+
+  context = {"id": "user-123"}
+
+  flag = client.get_flag("feature-key", context)
+  print(flag.is_enabled())
+  print(flag.get_variables())
+  ```
+
+- Dual-brand support: single codebase builds two PyPI packages — `vwo-fme-python-sdk` (legacy) and `wingify-fme-python-sdk` (new).
+- Build script `scripts/build_wheels.sh` to produce both PyPI wheels via `SDK_BRAND` env var; runtime branding via `is_via_vwo` at init.
+- Wingify brand uses split hosts: settings on `edge.wingify.net`, events on `collect.wingify.net`.
+- Dual support for `_wingify_meta` / `_vwo_meta` and `wingifyBuilder` / `vwoBuilder` option keys.
+
+### Changed
+
+- The SDK implementation now lives under the `wingify` package.
+- Log messages and documentation have been updated to reflect Wingify branding.
+- **No breaking changes for existing integrations** — server event names, payload keys, and runtime behavior remain compatible with the VWO platform.
+
+### Deprecated
+
+The following **VWO** types in `vwo` are deprecated but **continue to work without modification**:
+
+| Deprecated (still supported) | Use instead |
+|---|---|
+| `vwo.init` | `wingify.init` |
+| `vwo.VWOClient` | `wingify.WingifyClient` |
+| `vwo.VWOBuilder` | `wingify.WingifyBuilder` |
+| `vwo.VWOOptionsModel` | `wingify.WingifyOptionsModel` |
+| `vwo.StorageConnector` | `wingify.StorageConnector` |
+| `vwo.LogLevelEnum` | `wingify.LogLevelEnum` |
+
+Existing code does not need to change immediately. We recommend adopting the Wingify API for new projects and migrating when convenient:
+
+```python
+# Still supported — no action required today
+from vwo import init
+
+client = init(
+    {
+        "account_id": "123456",
+        "sdk_key": "32-alpha-numeric-sdk-key",
+    }
+)
+
+context = {"id": "user-123"}
+
+flag = client.get_flag("feature-key", context)
+```
+
+**Migration tip:** Replace imports from `vwo` with `wingify`, and rename types (`VWOClient` → `WingifyClient`, `VWOBuilder` → `WingifyBuilder`, `VWOOptionsModel` → `WingifyOptionsModel`). Method signatures and SDK behavior are unchanged. See [MIGRATE.md](MIGRATE.md) for details.
+
 ## [1.21.1] - 2026-05-20
 
 ### Fixed

MANIFEST.in

@@ -3,4 +3,5 @@ include requirements.txt
 include requirements-dev.txt
 include LICENSE
 recursive-exclude tests *
-recursive-include vwo/resources *.json
+recursive-include vwo/resources *.json
+recursive-include wingify/resources *.json

MIGRATE.md

@@ -0,0 +1,194 @@
+# Migrate to the Wingify Python FME SDK
+
+This guide explains how to adopt the **Wingify** public API on the Python FME SDK. Existing **VWO** integrations (`vwo-fme-python-sdk`) continue to work without changes.
+
+For installation, requirements, and advanced configuration (storage, logger, gateway, proxy, polling, and more), see [README.md](README.md).
+
+---
+
+## Overview
+
+The FME SDK is published as **two PyPI packages** built from the **same codebase** at the same version:
+
+| PyPI package | Import | Public types |
+| --- | --- | --- |
+| [`wingify-fme-python-sdk`](https://pypi.org/project/wingify-fme-python-sdk/) | `import wingify` | `WingifyOptionsModel`, `WingifyClient`, … |
+| [`vwo-fme-python-sdk`](https://pypi.org/project/vwo-fme-python-sdk/) | `import vwo` | `VWOOptionsModel`, `VWOClient`, … (legacy) |
+
+Pick **one** package for your app — do **not** install both `vwo-fme-python-sdk` and `wingify-fme-python-sdk` in the same environment.
+
+New integrations should use the **Wingify** package and types. When you install and initialize through `wingify-fme-python-sdk`, the SDK uses Wingify edge/collect endpoints and Wingify-branded logging (see [Runtime behavior](#runtime-behavior-wingify-build) below).
+
+---
+
+## Wingify API — implementation guide
+
+Use PyPI package `wingify-fme-python-sdk`. Public types use the `Wingify*` prefix.
+
+Legacy `VWO*` types on `vwo-fme-python-sdk` remain supported; they are thin aliases over the same core implementation.
+
+### Implementation steps
+
+1. **Add the dependency** — use only the Wingify coordinate (same semver you use on VWO today):
+
+   ```bash
+   pip install wingify-fme-python-sdk
+   ```
+
+2. **Initialize** — call `init()` with `account_id` and `sdk_key`. Returns a `WingifyClient`.
+
+3. **Build user context** — pass a plain dict with at least `id` (string). Optional: `custom_variables`, `user_agent`, `ip_address`, `bucketingSeed`, etc. See [README.md](README.md).
+
+4. **Evaluate flags** — `client.get_flag(feature_key, context)`.
+
+5. **Track and attribute** — `track_event`, `set_attribute`, and `set_alias` on the initialized client.
+
+### Python
+
+```python
+from wingify import init
+
+client = init({
+    'account_id': '123456',
+    'sdk_key': '32-alpha-numeric-sdk-key',
+    'logger': {'level': 'DEBUG'},
+})
+
+context = {'id': 'unique_user_id', 'custom_variables': {'plan': 'pro'}}
+
+flag = client.get_flag('feature_key', context)
+
+if flag.is_enabled():
+    variable = flag.get_variable('feature_variable', 'default-value')
+    print('Variable:', variable)
+
+client.track_event('event_name', context, {'cartValue': 10})
+client.set_attribute('attribute_key', 'attribute_value', context)
+client.set_alias(context, 'alias_id')
+```
+
+### Type hints (Wingify package)
+
+```python
+from wingify import init, WingifyClient, WingifyOptionsModel
+
+options: WingifyOptionsModel = WingifyOptionsModel({
+    'accountId': '123456',
+    'sdkKey': '32-alpha-numeric-sdk-key',
+})
+
+client: WingifyClient = init({
+    'account_id': '123456',
+    'sdk_key': '32-alpha-numeric-sdk-key',
+})
+```
+
+For the legacy VWO package, substitute `VWOClient` and `VWOOptionsModel` — behavior is the same.
+
+---
+
+## Public API mapping
+
+| Legacy (VWO package) | Wingify package |
+| --- | --- |
+| `init` | `init` |
+| `getUUID` | `getUUID` |
+| `VWOOptionsModel` | `WingifyOptionsModel` |
+| `VWOClient` | `WingifyClient` |
+| `vwoBuilder` on options | `wingifyBuilder` (preferred); `vwoBuilder` still accepted |
+| `StorageConnector`, `LogLevelEnum` | Same export names |
+
+### Options that stay VWO-named (platform compatibility)
+
+| Option / field | Notes |
+| --- | --- |
+| `_vwo_meta` | Still supported; use for SDK metadata when needed |
+| Context `_vwo` | Still supported for UA / device hints; `_wingify` also accepted |
+| Event / payload keys (e.g. `_vwo_meta` in network payloads) | Unchanged for server compatibility |
+| `vwoBuilder` | Alias of `wingifyBuilder` on init options |
+| Local storage key | `vwo_fme_settings` for both brands |
+
+---
+
+## Legacy VWO API
+
+The following remain available for existing apps on **`vwo-fme-python-sdk`**:
+
+- `import vwo` with `init`, `getUUID`
+- `VWOClient`, `VWOBuilder`, `VWOOptionsModel`
+- `vwoBuilder`, `StorageConnector`, logger hooks
+- VWO build-time hosts and `VWO-SDK` log prefix
+
+No breaking change is required to stay on the VWO package.
+
+---
+
+## Runtime behavior (Wingify build)
+
+When you install and run the **Wingify** PyPI build (not `vwo-fme-python-sdk`):
+
+| Area | Wingify build | VWO build (legacy package) |
+| --- | --- | --- |
+| Settings / pull / location | `edge.wingify.net` | `dev.visualwebsiteoptimizer.com` |
+| Events / batch | `collect.wingify.net` | Same host as settings (single host) |
+| Log prefix | `Wingify-SDK` | `VWO-SDK` |
+| Log message branding | Wingify where templated | VWO |
+| PyPI `name` in metadata | `wingify-fme-python-sdk` | `vwo-fme-python-sdk` |
+
+With **`proxy_url`**, all requests go to your proxy host. Without `proxy_url`, the SDK selects hosts automatically per build brand.
+
+Event and API payload field names (for example `_vwo_meta`, `vwo_*` event names) are **unchanged** for compatibility with the FME platform.
+
+---
+
+## Migrating from `vwo-fme-python-sdk` to `wingify-fme-python-sdk`
+
+1. In `requirements.txt`, replace the dependency:
+
+   ```diff
+   - vwo-fme-python-sdk==1.50.0
+   + wingify-fme-python-sdk==1.50.0
+   ```
+
+2. Update imports:
+
+   ```diff
+   - from vwo import init
+   + from wingify import init
+   ```
+
+3. Rename types: `VWOClient` → `WingifyClient`, `VWOOptionsModel` → `WingifyOptionsModel`.
+
+4. If you pass a custom builder, prefer `wingifyBuilder` instead of `vwoBuilder` (either still works).
+
+5. Reinstall and run your existing tests — flag evaluation, tracking, and attributes behave the same; only package name, exported type names, default hosts, and log branding change.
+
+### What you do **not** need to change
+
+- `account_id`, `sdk_key`, feature keys, event names
+- User context shape (`{'id': '...'}` and optional fields)
+- Method signatures on the client (`get_flag`, `track_event`, etc.)
+- Server-side campaign / settings JSON
+- `_vwo` / `_vwo_meta` in context or payloads when you already send them
+
+---
+
+## Architecture note
+
+The SDK follows a **Single Repo Two Pacakge Approach**:
+
+| Package | Role |
+| --- | --- |
+| `wingify/` | **Core** — `api/`, `constants/`, `enums/`, `services/`, `utils/`, `packages/`, `wingify_client.py`, … |
+| `vwo/` | **Legacy facade only** (~10 files) — `init`, `VWOClient`, `VWOBuilder`, `VWOOptionsModel`, `StorageConnector`, `LogLevelEnum`, etc. |
+
+Both PyPI wheels ship `wingify` (core) and `vwo` (facade). Existing apps use `import vwo`; new apps use `import wingify`. Brand-specific hosts, SDK name, and log prefix are selected at **runtime** via `is_via_vwo` (`vwo.init()` sets it to `true`; `wingify.init()` defaults to `false`). PyPI wheel metadata still differs per `SDK_BRAND` at build time.
+
+---
+
+## Related documents
+
+| Document | Content |
+| --- | --- |
+| [README.md](README.md) | Installation, requirements, configuration |
+| [CHANGELOG.md](CHANGELOG.md) | Version history and rebranding notes |

scripts/build_wheels.sh

@@ -0,0 +1,27 @@
+#!/usr/bin/env bash
+# Copyright 2024-2026 Wingify Software Pvt. Ltd.
+#
+# Build both brand-specific source distributions from the same codebase.
+#
+# Usage:
+#   ./scripts/build_wheels.sh
+#
+# Outputs:
+#   dist/vwo-fme-python-sdk-<version>.tar.gz
+#   dist/wingify-fme-python-sdk-<version>.tar.gz
+
+set -euo pipefail
+
+ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
+cd "$ROOT"
+
+rm -rf dist/ build/ *.egg-info wingify.egg-info vwo.egg-info 2>/dev/null || true
+
+echo "=== Building VWO source distribution ==="
+SDK_BRAND=vwo python3 setup.py sdist
+
+echo "=== Building Wingify source distribution ==="
+SDK_BRAND=wingify python3 setup.py sdist
+
+echo "=== Done ==="
+ls -la dist/

setup.py

@@ -30,6 +30,28 @@
 with open("README.md", "r") as f:
     long_description = f.read()
 
+# SDK_BRAND env var selects PyPI metadata when building brand-specific wheels.
+SDK_BRAND = os.environ.get("SDK_BRAND", "vwo")
+
+_BRAND_METADATA = {
+    "vwo": {
+        "name": "vwo-fme-python-sdk",
+        "description": "VWO Feature Management and Experimentation SDK for Python",
+        "author": "VWO",
+    },
+    "wingify": {
+        "name": "wingify-fme-python-sdk",
+        "description": "Wingify Feature Management and Experimentation SDK for Python",
+        "author": "Wingify",
+    },
+}
+
+_brand = _BRAND_METADATA.get(SDK_BRAND, _BRAND_METADATA["vwo"])
+
+_all_packages = find_packages(exclude=["tests"])
+# Both wheels ship wingify (core) + vwo (legacy facade). Customers import one or the other.
+_packages = _all_packages
+
 
 class DocCheckCommand(Command):
     description = "Doc Check"
@@ -57,7 +79,7 @@ def finalize_options(self):
 
     def run(self):
         subprocess.call(
-            'python3 ./scripts/apache_license_check.py vwo/ tests/ setup.py --Copyright 2024-2026 Wingify Software Pvt. Ltd."',
+            'python3 ./scripts/apache_license_check.py vwo/ wingify/ tests/ setup.py --Copyright 2024-2026 Wingify Software Pvt. Ltd."',
             shell=True,
         )
 
@@ -120,12 +142,12 @@ def run(self):
 
 
 setup(
-    name="vwo-fme-python-sdk",
-    version="1.21.1",
-    description="VWO Feature Management and Experimentation SDK for Python",
+    name=_brand["name"],
+    version="1.50.0",
+    description=_brand["description"],
     long_description=long_description,
     long_description_content_type="text/markdown",
-    author="VWO",
+    author=_brand["author"],
     author_email="dev@wingify.com",
     url="https://github.com/wingify/vwo-fme-python-sdk",
     license="Apache License 2.0",
@@ -151,7 +173,7 @@ def run(self):
         "license_check": LicenseCheckCommand,
         "doc_check": DocCheckCommand,
     },
-    packages=find_packages(exclude=["tests"]),
+    packages=_packages,
     include_package_data=True,
     install_requires=REQUIREMENTS,
 )

tests/e2e/custom_bucketing_test.py

@@ -466,7 +466,7 @@ def test_aliased_users_resolving_to_different_user_ids_should_get_same_variation
             vwo_client = init(options)
             bucketing_seed = "shared-seed-abc"
 
-            with patch("vwo.vwo_client.get_alias_user_id", side_effect=["RandomUserVWO", "WingifyVWO"]) as mock_alias:
+            with patch("wingify.wingify_client.get_alias_user_id", side_effect=["RandomUserVWO", "WingifyVWO"]) as mock_alias:
                 flag1 = vwo_client.get_flag("featureOne", {
                     "id": "aliasUserA",
                     "bucketingSeed": bucketing_seed
@@ -502,7 +502,7 @@ def test_aliased_users_resolving_to_different_user_ids_should_get_different_vari
             }
             vwo_client = init(options)
 
-            with patch("vwo.vwo_client.get_alias_user_id", side_effect=["RandomUserVWO", "WingifyVWO"]) as mock_alias:
+            with patch("wingify.wingify_client.get_alias_user_id", side_effect=["RandomUserVWO", "WingifyVWO"]) as mock_alias:
                 flag1 = vwo_client.get_flag("featureOne", {"id": "aliasUserA"})
                 flag2 = vwo_client.get_flag("featureOne", {"id": "aliasUserB"})