switchbox-flags 0.6.0__tar.gz → 0.7.0__tar.gz

{switchbox_flags-0.6.0 → switchbox_flags-0.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: switchbox-flags
-Version: 0.6.0
+Version: 0.7.0
 Summary: Feature flag SDK with zero dependencies
 Project-URL: Homepage, https://github.com/ignat14/switchbox-sdk-python
 Project-URL: Repository, https://github.com/ignat14/switchbox-sdk-python

{switchbox_flags-0.6.0 → switchbox_flags-0.7.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "switchbox-flags"
-version = "0.6.0"
+version = "0.7.0"
 description = "Feature flag SDK with zero dependencies"
 readme = "README.md"
 license = "MIT"

switchbox_flags-0.7.0/switchbox/__init__.py

@@ -0,0 +1,5 @@
+from switchbox._version import __version__
+from switchbox.client import Switchbox
+from switchbox.exceptions import SwitchboxError
+
+__all__ = ["Switchbox", "SwitchboxError", "__version__"]

switchbox_flags-0.7.0/switchbox/_version.py

@@ -0,0 +1,15 @@
+"""Single source of the package version (FABLE_IMPROVEMENTS 2.7).
+
+Derived from the installed distribution metadata (pyproject.toml's `version`)
+so `__version__`, the User-Agent, and PyPI can never drift — previously
+__init__.py said 0.5.0, pyproject said 0.6.0 and the User-Agent hardcoded a
+third copy. Lives in its own leaf module because both __init__.py and sync.py
+need it (importing from the package root inside sync would be circular).
+"""
+
+from importlib.metadata import PackageNotFoundError, version
+
+try:
+    __version__ = version("switchbox-flags")
+except PackageNotFoundError:  # running from a raw source tree, not installed
+    __version__ = "0.0.0"

{switchbox_flags-0.6.0 → switchbox_flags-0.7.0}/switchbox/evaluator.py

@@ -20,25 +20,48 @@ def _js_str(value: Any) -> str:
     - booleans are lowercase ("true"/"false"), not Python's "True"/"False"
     - None becomes "null"
     - an integer-valued float drops its trailing ".0" (JS has no int/float split)
+      — but only below 1e21, where JS switches to exponential notation
+    - NaN/Infinity render as JS does ("NaN"/"Infinity"), not Python's "nan"/"inf"
+    - exponents are not zero-padded ("1e-7", not Python's "1e-07")
+
+    Residual, documented divergence (deliberately not chased — see
+    FABLE_IMPROVEMENTS 2.9): floats in [1e-6, 1e-4) render exponential here but
+    fixed in JS (str(1e-5)="1e-05" vs String(1e-5)="0.00001"), and lists/dicts
+    stringify Python-style, not JS-style ("[object Object]"). Vectors only pin
+    the converged cases.
     """
     if isinstance(value, bool):
         return "true" if value else "false"
     if value is None:
         return "null"
-    if isinstance(value, float) and value.is_integer():
-        return str(int(value))
+    if isinstance(value, float):
+        if value != value:  # NaN
+            return "NaN"
+        if value == float("inf"):
+            return "Infinity"
+        if value == float("-inf"):
+            return "-Infinity"
+        if value.is_integer() and abs(value) < 1e21:
+            return str(int(value))
+        return re.sub(r"e([+-])0(\d)$", r"e\1\2", str(value))
     return str(value)
 
 
 def _to_number(value: Any) -> float | None:
     """Mimic JS parseFloat(String(value)): parse a leading numeric prefix, or
     return None (JS NaN) when there isn't one. Booleans are NaN, matching
-    parseFloat("true")."""
+    parseFloat("true"). "Infinity"/"-Infinity" prefixes parse like parseFloat
+    does (parseFloat("Infinity") is Infinity, not NaN)."""
     if isinstance(value, bool):
         return None
     if isinstance(value, (int, float)):
         return float(value)
-    match = _NUMERIC_PREFIX.match(str(value).lstrip())
+    s = str(value).lstrip()
+    if s.startswith(("Infinity", "+Infinity")):
+        return float("inf")
+    if s.startswith("-Infinity"):
+        return float("-inf")
+    match = _NUMERIC_PREFIX.match(s)
     return float(match.group(0)) if match else None
 
 
@@ -59,8 +82,11 @@ def evaluate(flag: Flag, user_context: dict | None = None) -> bool | str | int |
         if not flag.enabled:
             return flag.default_value
 
-        # 2. No user context
-        if not user_context:
+        # 2. No user context (None only — an empty dict {} deliberately proceeds
+        #    to the rules loop and behaves like "no matching attributes", the
+        #    same path the JS SDK takes; parity-pinned. The end result is
+        #    identical because step 5 mirrors this branch.)
+        if user_context is None:
             if flag.rollout_pct == 100:
                 return _enabled_value(flag)
             return flag.default_value

{switchbox_flags-0.6.0 → switchbox_flags-0.7.0}/switchbox/models.py

@@ -56,17 +56,28 @@ class FlagConfig:
 
     @classmethod
     def from_dict(cls, data: dict) -> FlagConfig:
-        """Parse the CDN JSON into a FlagConfig object."""
+        """Parse the CDN JSON into a FlagConfig object.
+
+        **Per-flag tolerant** (FABLE_IMPROVEMENTS 2.3): one malformed flag —
+        e.g. a missing ``enabled`` or a null ``rules`` from a future publisher
+        bug — is skipped, not fatal. Before this, the sync loop's generic
+        handler discarded the *entire* config, freezing every Python client on
+        the old version while the (per-flag tolerant) JS SDK kept updating.
+        The JS parser skips non-object flag entries the same way
+        (``normalizeConfig`` in ``sync.ts``); keep them aligned."""
         flags = {}
         for key, flag_data in data.get("flags", {}).items():
-            rules = [_parse_rule_group(r) for r in flag_data.get("rules", [])]
-            flags[key] = Flag(
-                key=key,
-                enabled=flag_data["enabled"],
-                rollout_pct=flag_data.get("rollout_pct", 0),
-                flag_type=flag_data.get("flag_type", "boolean"),
-                default_value=flag_data.get("default_value"),
-                enabled_value=flag_data.get("enabled_value"),
-                rules=rules,
-            )
+            try:
+                rules = [_parse_rule_group(r) for r in flag_data.get("rules") or []]
+                flags[key] = Flag(
+                    key=key,
+                    enabled=flag_data["enabled"],
+                    rollout_pct=flag_data.get("rollout_pct", 0),
+                    flag_type=flag_data.get("flag_type", "boolean"),
+                    default_value=flag_data.get("default_value"),
+                    enabled_value=flag_data.get("enabled_value"),
+                    rules=rules,
+                )
+            except Exception:
+                continue  # skip the bad flag, keep the rest
         return cls(version=data.get("version", ""), flags=flags)

{switchbox_flags-0.6.0 → switchbox_flags-0.7.0}/switchbox/sync.py

@@ -5,6 +5,7 @@ import urllib.error
 import urllib.request
 from typing import Callable
 
+from switchbox._version import __version__
 from switchbox.cache import FlagCache
 from switchbox.exceptions import ConfigFetchError
 from switchbox.models import FlagConfig
@@ -86,7 +87,7 @@ class SyncWorker:
         try:
             req = urllib.request.Request(
                 self._cdn_url,
-                headers={"User-Agent": "switchbox-python/0.6.0"},
+                headers={"User-Agent": f"switchbox-python/{__version__}"},
             )
             with urllib.request.urlopen(req, timeout=self._timeout) as resp:
                 data = json.loads(resp.read().decode("utf-8"))

{switchbox_flags-0.6.0 → switchbox_flags-0.7.0}/tests/fixtures/parity/parity_vectors.json

@@ -1,5 +1,5 @@
 {
-  "_comment": "SEC-4 cross-SDK parity vectors (evaluation half of the parity story; the format half is fixtures/cdn-json/). CANONICAL SOURCE: fixtures/parity/parity_vectors.json — distributed into each SDK repo's tests/fixtures/parity/ by `python3 fixtures/sync.py` (do NOT hand-edit a synced copy; edit the canonical and re-sync). Both SDK suites run it (test_parity_vectors.py, parity.test.ts). Sections: rule_match (single-condition coercion/operators), evaluate (full evaluate path incl. rollout-bucket boundaries), rollout_bucket (sha256(user_id:flag_key)%100 — pins the hash itself across languages). Canonical semantics are JS-style: lowercase booleans (String(true)='true'), parseFloat-style prefix numeric parsing, null coerces to 'null', user_id resolved with ??-style null-only fallback, and a user context lacking a usable id serves only 100% rollouts (ADR-008). See DECISIONS.md ADR-013 (coercion) + ADR-024 (shared-fixture mechanism).",
+  "_comment": "SEC-4 cross-SDK parity vectors (evaluation half of the parity story; the format half is fixtures/cdn-json/). CANONICAL SOURCE: fixtures/parity/parity_vectors.json — distributed into each SDK repo's tests/fixtures/parity/ by `python3 fixtures/sync.py` (do NOT hand-edit a synced copy; edit the canonical and re-sync). Both SDK suites run it (test_parity_vectors.py, parity.test.ts). Sections: rule_match (single-condition coercion/operators), evaluate (full evaluate path incl. rollout-bucket boundaries), rollout_bucket (sha256(user_id:flag_key)%100 — pins the hash itself across languages). Canonical semantics are JS-style: lowercase booleans (String(true)='true'), parseFloat-style prefix numeric parsing, null coerces to 'null', user_id resolved with ??-style null-only fallback, and a user context lacking a usable id serves only 100% rollouts (ADR-008). The 'hostile:' vectors (FABLE_IMPROVEMENTS 2.8) pin the outside-the-happy-path envelope: evaluation-never-throws containment (ADR-043), {} context = no matching attributes, omitted flag_type/rollout_pct parse defaults (boolean/0), prototype-chain attributes, string-valued in_list substring semantics, Infinity/1e21 coercion, non-ASCII rollout hashing. Runners must exercise their REAL parse path (Python FlagConfig.from_dict, JS normalizeConfig) and compare strictly (no True==1). See DECISIONS.md ADR-013 (coercion) + ADR-024 (shared-fixture mechanism) + ADR-043 (error containment).",
   "rule_match": [
     {"name": "boolean true matches lowercase 'true'", "rule": {"attribute": "is_beta", "operator": "equals", "value": "true"}, "context": {"is_beta": true}, "expected": true},
     {"name": "boolean false matches lowercase 'false'", "rule": {"attribute": "is_beta", "operator": "equals", "value": "false"}, "context": {"is_beta": false}, "expected": true},
@@ -17,7 +17,19 @@
     {"name": "lt numeric", "rule": {"attribute": "age", "operator": "lt", "value": "18"}, "context": {"age": "5"}, "expected": true},
     {"name": "in_list string member matches", "rule": {"attribute": "country", "operator": "in_list", "value": ["US", "CA", "UK"]}, "context": {"country": "US"}, "expected": true},
     {"name": "in_list stringified number does not match raw number item (shared footgun)", "rule": {"attribute": "n", "operator": "in_list", "value": [42]}, "context": {"n": 42}, "expected": false},
-    {"name": "in_list stringified number matches string item", "rule": {"attribute": "n", "operator": "in_list", "value": ["42"]}, "context": {"n": 42}, "expected": true}
+    {"name": "in_list stringified number matches string item", "rule": {"attribute": "n", "operator": "in_list", "value": ["42"]}, "context": {"n": 42}, "expected": true},
+    {"name": "hostile: in_list with a STRING rule value does substring matching (pinned coincidence: JS String.includes / Python 'in')", "rule": {"attribute": "country", "operator": "in_list", "value": "US,CA"}, "context": {"country": "US"}, "expected": true},
+    {"name": "hostile: in_list string rule value, non-substring does not match", "rule": {"attribute": "country", "operator": "in_list", "value": "US,CA"}, "context": {"country": "FR"}, "expected": false},
+    {"name": "hostile: not_equals with an absent attribute does not match (absence is not inequality)", "rule": {"attribute": "plan", "operator": "not_equals", "value": "pro"}, "context": {"other": 1}, "expected": false},
+    {"name": "hostile: prototype-chain attribute never matches (constructor)", "rule": {"attribute": "constructor", "operator": "equals", "value": "anything"}, "context": {"other": "x"}, "expected": false},
+    {"name": "hostile: prototype-chain attribute never matches (toString)", "rule": {"attribute": "toString", "operator": "not_equals", "value": "x"}, "context": {"other": "x"}, "expected": false},
+    {"name": "hostile: gt parses a string 'Infinity' context like parseFloat", "rule": {"attribute": "n", "operator": "gt", "value": "1000000"}, "context": {"n": "Infinity"}, "expected": true},
+    {"name": "hostile: lt parses '-Infinity'", "rule": {"attribute": "n", "operator": "lt", "value": "0"}, "context": {"n": "-Infinity"}, "expected": true},
+    {"name": "hostile: gt with 'Infinity' RULE value never matches a finite context", "rule": {"attribute": "n", "operator": "gt", "value": "Infinity"}, "context": {"n": "999999999"}, "expected": false},
+    {"name": "hostile: equals at 1e21 uses exponential form (String(1e21)='1e+21')", "rule": {"attribute": "n", "operator": "equals", "value": "1e+21"}, "context": {"n": 1e21}, "expected": true},
+    {"name": "hostile: gt with tiny float context (1e-5 > 0, numeric path)", "rule": {"attribute": "n", "operator": "gt", "value": "0"}, "context": {"n": 1e-5}, "expected": true},
+    {"name": "hostile: gt with huge float context (1e21 > 1e20)", "rule": {"attribute": "n", "operator": "gt", "value": "1e20"}, "context": {"n": 1e21}, "expected": true},
+    {"name": "hostile: equals with CJK strings", "rule": {"attribute": "name", "operator": "equals", "value": "用户"}, "context": {"name": "用户"}, "expected": true}
   ],
   "evaluate": [
     {"name": "disabled flag returns default", "flag_key": "f", "flag": {"enabled": false, "rollout_pct": 100, "flag_type": "boolean", "default_value": "off", "rules": []}, "user": {"user_id": "1"}, "expected": "off"},
@@ -44,13 +56,23 @@
     {"name": "rollout: user bucket 58 with rollout 59 -> enabled (bucket < pct)", "flag_key": "f", "flag": {"enabled": true, "rollout_pct": 59, "flag_type": "boolean", "default_value": false, "rules": []}, "user": {"user_id": "u_low"}, "expected": true},
     {"name": "rollout: user bucket 58 with rollout 58 -> default (boundary is exclusive)", "flag_key": "f", "flag": {"enabled": true, "rollout_pct": 58, "flag_type": "boolean", "default_value": false, "rules": []}, "user": {"user_id": "u_low"}, "expected": false},
     {"name": "rollout: user bucket 47 with rollout 48 -> enabled", "flag_key": "f", "flag": {"enabled": true, "rollout_pct": 48, "flag_type": "boolean", "default_value": false, "rules": []}, "user": {"user_id": "user-2"}, "expected": true},
-    {"name": "rollout: user bucket 47 with rollout 47 -> default", "flag_key": "f", "flag": {"enabled": true, "rollout_pct": 47, "flag_type": "boolean", "default_value": false, "rules": []}, "user": {"user_id": "user-2"}, "expected": false}
+    {"name": "rollout: user bucket 47 with rollout 47 -> default", "flag_key": "f", "flag": {"enabled": true, "rollout_pct": 47, "flag_type": "boolean", "default_value": false, "rules": []}, "user": {"user_id": "user-2"}, "expected": false},
+    {"name": "hostile: malformed in_list (null value) is contained -> default (evaluation never throws, ADR-043)", "flag_key": "f", "flag": {"enabled": true, "rollout_pct": 0, "flag_type": "boolean", "default_value": false, "rules": [{"conditions": [{"attribute": "x", "operator": "in_list", "value": null}]}]}, "user": {"x": "a", "user_id": "u1"}, "expected": false},
+    {"name": "hostile: empty user context {} behaves like no matching attributes, rollout 100 -> enabled", "flag_key": "f", "flag": {"enabled": true, "rollout_pct": 100, "flag_type": "boolean", "default_value": false, "rules": []}, "user": {}, "expected": true},
+    {"name": "hostile: empty user context {}, rollout 50 -> default", "flag_key": "f", "flag": {"enabled": true, "rollout_pct": 50, "flag_type": "boolean", "default_value": false, "rules": []}, "user": {}, "expected": false},
+    {"name": "hostile: empty user context {} with rules present, rollout 0 -> default", "flag_key": "f", "flag": {"enabled": true, "rollout_pct": 0, "flag_type": "boolean", "default_value": false, "rules": [{"conditions": [{"attribute": "plan", "operator": "equals", "value": "pro"}]}]}, "user": {}, "expected": false},
+    {"name": "hostile: omitted flag_type defaults to boolean (serves true)", "flag_key": "f", "flag": {"enabled": true, "rollout_pct": 100, "default_value": false, "rules": []}, "user": null, "expected": true},
+    {"name": "hostile: omitted rollout_pct defaults to 0 -> default", "flag_key": "f", "flag": {"enabled": true, "flag_type": "boolean", "default_value": false, "rules": []}, "user": {"user_id": "u1"}, "expected": false},
+    {"name": "hostile: non-ASCII user_id evaluates through the rollout hash (bucket 18 < 50)", "flag_key": "new_checkout", "flag": {"enabled": true, "rollout_pct": 50, "flag_type": "boolean", "default_value": false, "rules": []}, "user": {"user_id": "用户42"}, "expected": true}
   ],
   "rollout_bucket": [
     {"name": "42:new_checkout", "user_id": "42", "flag_key": "new_checkout", "expected": 98},
     {"name": "user_100:feature_x", "user_id": "user_100", "flag_key": "feature_x", "expected": 4},
     {"name": "abc:search_version", "user_id": "abc", "flag_key": "search_version", "expected": 10},
     {"name": "u_low:f", "user_id": "u_low", "flag_key": "f", "expected": 58},
-    {"name": "user-2:f", "user_id": "user-2", "flag_key": "f", "expected": 47}
+    {"name": "user-2:f", "user_id": "user-2", "flag_key": "f", "expected": 47},
+    {"name": "hostile: CJK user_id (UTF-8 hashing parity)", "user_id": "用户42", "flag_key": "new_checkout", "expected": 18},
+    {"name": "hostile: emoji user_id (astral-plane UTF-8)", "user_id": "🚀user", "flag_key": "feature_x", "expected": 59},
+    {"name": "hostile: latin diacritics user_id", "user_id": "Ünïcode-Üser", "flag_key": "search_version", "expected": 85}
   ]
 }

{switchbox_flags-0.6.0 → switchbox_flags-0.7.0}/tests/test_evaluator.py

@@ -243,3 +243,56 @@ def test_rule_attribute_not_in_context_skipped():
         rules=[Rule(attribute="missing_attr", operator="equals", value="x")],
     )
     assert evaluate(flag, {"user_id": "1", "other": "y"}) is False
+
+
+# --- JS-coercion extremes (FABLE_IMPROVEMENTS 2.9) ---
+
+
+def test_js_str_extremes_match_js_string():
+    """The cheap-to-fix String() divergences, pinned: Infinity/NaN naming,
+    exponential form at 1e21+, no zero-padded exponents. The residual
+    divergence (fixed-vs-exponential in the 1e-6..1e-4 range, lists/dicts) is
+    documented in _js_str's docstring, deliberately not chased."""
+    from switchbox.evaluator import _js_str
+
+    assert _js_str(float("inf")) == "Infinity"
+    assert _js_str(float("-inf")) == "-Infinity"
+    assert _js_str(float("nan")) == "NaN"
+    assert _js_str(1e21) == "1e+21"  # JS switches to exponential at 1e21
+    assert _js_str(1e22) == "1e+22"
+    assert _js_str(1e20) == "100000000000000000000"  # still fixed below 1e21
+    assert _js_str(1e-7) == "1e-7"  # no zero-padded exponent ("1e-07")
+    assert _js_str(1.5e-8) == "1.5e-8"
+    assert _js_str(42.0) == "42"  # unchanged: int-valued float drops .0
+
+
+def test_to_number_parses_infinity_like_parsefloat():
+    from switchbox.evaluator import _to_number
+
+    assert _to_number("Infinity") == float("inf")
+    assert _to_number("+Infinity") == float("inf")
+    assert _to_number("-Infinity") == float("-inf")
+    assert _to_number("Infinity-and-beyond") == float("inf")  # prefix parse
+    assert _to_number("Inf") is None  # parseFloat("Inf") is NaN
+
+
+def test_empty_context_takes_the_rules_path_not_the_no_context_branch():
+    """{} is a real (empty) context: rules are walked (none can match), then
+    the no-usable-id tail applies — the same path JS takes (parity-pinned by
+    the hostile vectors)."""
+    flag = make_flag(rollout_pct=100)
+    assert evaluate(flag, {}) is True
+    flag = make_flag(rollout_pct=50)
+    assert evaluate(flag, {}) is False
+
+
+def test_evaluation_error_is_contained_to_default():
+    """Evaluation never throws (ADR-043): a malformed in_list value degrades to
+    default_value. Same contract as the JS SDK's try/catch."""
+    flag = make_flag(
+        rollout_pct=0,
+        default_value="safe",
+        flag_type="string",
+        rules=[Rule(attribute="x", operator="in_list", value=None)],
+    )
+    assert evaluate(flag, {"x": "a", "user_id": "u1"}) == "safe"

{switchbox_flags-0.6.0 → switchbox_flags-0.7.0}/tests/test_models.py

@@ -10,9 +10,7 @@ def test_flag_config_from_dict_valid():
                 "rollout_pct": 50,
                 "flag_type": "boolean",
                 "default_value": False,
-                "rules": [
-                    {"attribute": "country", "operator": "equals", "value": "US"}
-                ],
+                "rules": [{"attribute": "country", "operator": "equals", "value": "US"}],
             }
         },
     }
@@ -105,3 +103,56 @@ def test_rule_stores_fields():
     assert rule.attribute == "country"
     assert rule.operator == "equals"
     assert rule.value == "US"
+
+
+def test_from_dict_skips_a_malformed_flag_keeps_the_rest():
+    """Per-flag tolerance (FABLE_IMPROVEMENTS 2.3): one bad flag from a future
+    publisher bug must not discard the whole config — that froze every Python
+    client on the old version while the JS SDK kept updating."""
+    data = {
+        "version": "v1",
+        "flags": {
+            "good": {
+                "enabled": True,
+                "rollout_pct": 100,
+                "flag_type": "boolean",
+                "default_value": False,
+                "rules": [],
+            },
+            "missing_enabled": {
+                "rollout_pct": 100,
+                "flag_type": "boolean",
+                "default_value": False,
+                "rules": [],
+            },
+            "not_a_dict": None,
+            "garbage_rules": {
+                "enabled": True,
+                "rollout_pct": 0,
+                "flag_type": "boolean",
+                "default_value": False,
+                "rules": [{"conditions": [{"nope": 1}]}],
+            },
+        },
+    }
+    config = FlagConfig.from_dict(data)
+    assert set(config.flags) == {"good"}
+    assert config.version == "v1"
+
+
+def test_from_dict_null_rules_parses_as_no_rules():
+    """A null `rules` is tolerated as [] (JS toRuleGroups(null) → []), not fatal."""
+    data = {
+        "version": "v1",
+        "flags": {
+            "f": {
+                "enabled": True,
+                "rollout_pct": 100,
+                "flag_type": "boolean",
+                "default_value": False,
+                "rules": None,
+            }
+        },
+    }
+    flag = FlagConfig.from_dict(data).flags["f"]
+    assert flag.rules == []

{switchbox_flags-0.6.0 → switchbox_flags-0.7.0}/tests/test_parity_vectors.py

@@ -39,9 +39,19 @@ def test_rule_match_vectors(case):
     assert _match_rule(rule, case["context"]) == case["expected"]
 
 
+def _assert_strict(result, expected):
+    """Value AND type must match — Python's `==` alone would let `True == 1`
+    pass while the JS runner's `toBe` fails it (runner-asymmetry fix,
+    FABLE_IMPROVEMENTS 2.8)."""
+    assert result == expected and type(result) is type(expected), (
+        f"{result!r} ({type(result).__name__}) != "
+        f"{expected!r} ({type(expected).__name__})"
+    )
+
+
 @pytest.mark.parametrize("case", _VECTORS["evaluate"], ids=lambda c: c["name"])
 def test_evaluate_vectors(case):
-    assert evaluate(_flag_from(case), case["user"]) == case["expected"]
+    _assert_strict(evaluate(_flag_from(case), case["user"]), case["expected"])
 
 
 @pytest.mark.parametrize("case", _VECTORS["rollout_bucket"], ids=lambda c: c["name"])

{switchbox_flags-0.6.0 → switchbox_flags-0.7.0}/uv.lock

@@ -236,7 +236,7 @@ wheels = [
 
 [[package]]
 name = "switchbox-flags"
-version = "0.6.0"
+version = "0.7.0"
 source = { editable = "." }
 
 [package.optional-dependencies]

switchbox_flags-0.6.0/switchbox/__init__.py

@@ -1,5 +0,0 @@
-from switchbox.client import Switchbox
-from switchbox.exceptions import SwitchboxError
-
-__version__ = "0.5.0"
-__all__ = ["Switchbox", "SwitchboxError"]