flagrant-client 0.1.0__py3-none-any.whl

flagrant/__init__.py

@@ -0,0 +1,14 @@
+from flagrant.client import FlagrantClient, FlagsmithOpts
+from flagrant.grpc_transport import GrpcTransport
+from flagrant.http_transport import HttpTransport
+from flagrant.transport import PermanentError, Transport, TransientError
+
+__all__ = [
+    "FlagrantClient",
+    "FlagsmithOpts",
+    "GrpcTransport",
+    "HttpTransport",
+    "PermanentError",
+    "Transport",
+    "TransientError",
+]

flagrant/cache.py

@@ -0,0 +1,50 @@
+import time
+from collections import OrderedDict
+from typing import Generic, TypeVar
+
+K = TypeVar("K")
+V = TypeVar("V")
+
+
+class LRUCache(Generic[K, V]):
+    """A dict-backed cache with LRU eviction and optional per-entry TTL."""
+
+    def __init__(self, max_size: int, ttl: float | None) -> None:
+        self.max_size = max_size
+        self.ttl = ttl
+        self._data: OrderedDict[K, tuple[float, V]] = OrderedDict()
+
+    def get(self, key: K) -> V | None:
+        """Return the cached value, or None if missing or expired.
+
+        A hit only bumps recency (moves the key to the end of the
+        underlying OrderedDict) when it's within TTL; expired entries
+        are reported as missing but left in place, untouched, so
+        get_stale() can still recover them for failure fallback.
+        """
+        entry = self._data.get(key)
+
+        if entry is None:
+            return None
+
+        timestamp, value = entry
+        if self.ttl is not None and time.monotonic() - timestamp > self.ttl:
+            return None
+        self._data.move_to_end(key)
+        return value
+
+    def get_stale(self, key: K) -> V | None:
+        """Return the cached value even if its TTL has expired, without evicting it.
+
+        Used as a fallback when a fresh fetch fails (e.g. an upstream
+        error), so callers can still serve a previously known value
+        instead of nothing.
+        """
+        entry = self._data.get(key)
+        return entry[1] if entry is not None else None
+
+    def set(self, key: K, value: V) -> None:
+        self._data[key] = (time.monotonic(), value)
+        self._data.move_to_end(key)
+        if len(self._data) > self.max_size:
+            self._data.popitem(last=False)

flagrant/client.py

@@ -0,0 +1,64 @@
+from collections.abc import Callable
+from dataclasses import dataclass
+from typing import Any
+
+from flagrant.cache import LRUCache
+from flagrant.models import Feature
+from flagrant.transport import Transport, TransientError
+
+DefaultFlagHandler = Callable[[str, str], list[Feature] | None]
+
+@dataclass(frozen=True)
+class FlagsmithOpts:
+    cache_ttl: float | None = None
+    cache_size: int | None = None
+
+
+class FlagrantClient:
+    def __init__(
+        self,
+        project: str,
+        transport: Transport,
+        *,
+        default_handler: DefaultFlagHandler | None = None,
+        opts: FlagsmithOpts = FlagsmithOpts()
+    ) -> None:
+        self.project = project
+        self.transport = transport
+        self.opts = opts
+        self.default_handler = default_handler
+
+        self._cache: LRUCache[tuple[str, str], list[Feature]] | None = (
+            LRUCache(max_size=opts.cache_size, ttl=opts.cache_ttl)
+            if opts.cache_size
+            else None
+        )
+
+    def get_features(self, environment: str, identity: str) -> list[Feature] | None:
+        key = (environment, identity)
+        if self._cache is not None:
+            if cached := self._cache.get(key):
+                return cached
+
+        try:
+            features = self.transport.fetch(self.project, environment, identity)
+        except TransientError:
+            if self._cache is not None and (stale := self._cache.get_stale(key)) is not None:
+                return stale
+            if self.default_handler is None:
+                raise
+            return self.default_handler(environment, identity)
+
+        if self._cache is not None:
+            self._cache.set(key, features)
+
+        return features
+
+    def close(self) -> None:
+        self.transport.close()
+
+    def __enter__(self) -> "FlagrantClient":
+        return self
+
+    def __exit__(self, *_args: Any) -> None:
+        self.close()

flagrant/grpc_transport.py

@@ -0,0 +1,92 @@
+import time
+
+import grpc
+
+from flagrant.models import Feature, FeatureValue, JsonValue, TextValue, TomlValue
+from flagrant.proto import features_pb2, features_pb2_grpc
+from flagrant.transport import PermanentError, TransientError
+
+_RETRYABLE_CODES = {
+    grpc.StatusCode.UNAVAILABLE,
+    grpc.StatusCode.UNKNOWN,
+    grpc.StatusCode.INTERNAL,
+    grpc.StatusCode.RESOURCE_EXHAUSTED,
+}
+
+
+def _feature_from_proto(feature: features_pb2.Feature) -> Feature:
+    variant = feature.value
+    value: FeatureValue
+    match variant.WhichOneof("kind"):
+        case "text":
+            value = TextValue(variant.text)
+        case "json":
+            value = JsonValue(variant.json)
+        case "toml":
+            value = TomlValue(variant.toml)
+        case _:
+            raise PermanentError(f"feature {feature.name!r} has no value set")
+
+    return Feature(
+        feature_id=feature.feature_id,
+        name=feature.name,
+        value=value,
+        is_enabled=feature.is_enabled,
+    )
+
+
+class GrpcTransport:
+    def __init__(
+        self,
+        target: str,
+        *,
+        credentials: grpc.ChannelCredentials | None = None,
+        authority: str | None = None,
+        timeout: float = 5.0,
+        retries: int = 5,
+        backoff_factor: float = 0.5,
+    ) -> None:
+        self.timeout = timeout
+        self.retries = retries
+        self.backoff_factor = backoff_factor
+
+        # For unix: targets, grpc-core derives :authority from the percent-encoded
+        # socket path (e.g. "tmp%2Fflagrant%2Fgrpc.sock") instead of a plain host,
+        # which strict/routing-aware HTTP/2 servers can reject. Default it to
+        # "localhost" there, matching what grpcurl/grpc-go send.
+        if authority is None and target.startswith("unix:"):
+            authority = "localhost"
+
+        options = [("grpc.default_authority", authority)] if authority is not None else []
+
+        self._channel = (
+            grpc.secure_channel(target, credentials, options=options)
+            if credentials is not None
+            else grpc.insecure_channel(target, options=options)
+        )
+        self._stub = features_pb2_grpc.FeatureResolverStub(self._channel)
+
+    def fetch(self, project: str, environment: str, identity: str) -> list[Feature]:
+        request = features_pb2.GetFeaturesRequest(project=project, environment=environment)
+        attempt = 0
+        while True:
+            try:
+                response = self._stub.GetFeatures(
+                    request,
+                    metadata=[("x-flagrant-identity", identity)],
+                    timeout=self.timeout,
+                )
+            except grpc.RpcError as exc:
+                code = exc.code()  # type: ignore[attr-defined]
+                if code in _RETRYABLE_CODES:
+                    if attempt < self.retries:
+                        time.sleep(self.backoff_factor * (2**attempt))
+                        attempt += 1
+                        continue
+                    raise TransientError(f"grpc error: {code}") from exc
+                raise PermanentError(f"grpc error: {code}") from exc
+
+            return [_feature_from_proto(feature) for feature in response.features]
+
+    def close(self) -> None:
+        self._channel.close()

flagrant/http_transport.py

@@ -0,0 +1,53 @@
+import time
+
+import httpx
+from pydantic import TypeAdapter
+
+from flagrant.models import Feature
+from flagrant.transport import PermanentError, TransientError
+
+_features_adapter = TypeAdapter(list[Feature])
+
+
+class HttpTransport:
+    def __init__(
+        self,
+        base_url: str,
+        *,
+        timeout: float = 5.0,
+        retries: int = 5,
+        backoff_factor: float = 0.5,
+    ) -> None:
+        transport = httpx.HTTPTransport(retries=retries)
+        
+        self.retries = retries
+        self.backoff_factor = backoff_factor
+        self._http = httpx.Client(
+            base_url=base_url.rstrip("/"), timeout=timeout, transport=transport
+        )
+
+    def fetch(self, project: str, environment: str, identity: str) -> list[Feature]:
+        attempt = 0
+        while True:
+            try:
+                response = self._http.get(
+                    f"/api/v1/projects/{project}/envs/{environment}/features",
+                    headers={"X-Flagrant-Identity": identity},
+                )
+            except httpx.TransportError as exc:
+                raise TransientError from exc
+
+            if response.status_code >= 500:
+                if attempt < self.retries:
+                    time.sleep(self.backoff_factor * (2**attempt))
+                    attempt += 1
+                    continue
+                raise TransientError(f"server error: {response.status_code}")
+
+            if response.status_code >= 400:
+                raise PermanentError(f"client error: {response.status_code}")
+
+            return _features_adapter.validate_python(response.json())
+
+    def close(self) -> None:
+        self._http.close()

flagrant/models.py

@@ -0,0 +1,73 @@
+from typing import Any
+
+from pydantic import BaseModel, Json, field_validator
+
+_UNSET = object()
+
+
+class TextValue(BaseModel):
+    value: str
+
+    def __init__(self, value: Any = _UNSET, **data: Any) -> None:
+        if value is not _UNSET:
+            data["value"] = value
+        super().__init__(**data)
+
+    def __repr__(self) -> str:
+        return f"{type(self).__name__}({self.value!r})"
+
+
+class JsonValue(BaseModel):
+    # the API delivers json values as escaped JSON strings
+    value: Json[dict[str, Any]]
+
+    def __init__(self, value: Any = _UNSET, **data: Any) -> None:
+        if value is not _UNSET:
+            data["value"] = value
+        super().__init__(**data)
+
+    def __repr__(self) -> str:
+        return f"{type(self).__name__}({self.value!r})"
+
+
+class TomlValue(BaseModel):
+    value: str
+
+    def __init__(self, value: Any = _UNSET, **data: Any) -> None:
+        if value is not _UNSET:
+            data["value"] = value
+        super().__init__(**data)
+
+    def __repr__(self) -> str:
+        return f"{type(self).__name__}({self.value!r})"
+
+
+FeatureValue = TextValue | JsonValue | TomlValue
+
+_VALUE_MODELS = {
+    "text": TextValue,
+    "json": JsonValue,
+    "toml": TomlValue,
+}
+
+
+class Feature(BaseModel):
+    feature_id: int
+    name: str
+    value: FeatureValue
+    is_enabled: bool
+
+    @field_validator("value", mode="before")
+    @classmethod
+    def _build_value(cls, v: Any) -> Any:
+        # The API sends the value as a single-key map: {"text": "..."},
+        # {"json": {...}} or {"toml": "..."}. The key tells us which
+        # value model to build.
+        if isinstance(v, dict) and len(v) == 1:
+            type_, value = next(iter(v.items()))
+
+            # Fall back to TextValue for unrecognized types, treating
+            # the payload as plain text.
+            model = _VALUE_MODELS.get(type_, TextValue)
+            return model(value)
+        return v

flagrant/proto/features_pb2.py

@@ -0,0 +1,44 @@
+# -*- coding: utf-8 -*-
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# NO CHECKED-IN PROTOBUF GENCODE
+# source: features.proto
+# Protobuf Python Version: 7.35.1
+"""Generated protocol buffer code."""
+from google.protobuf import descriptor as _descriptor
+from google.protobuf import descriptor_pool as _descriptor_pool
+from google.protobuf import runtime_version as _runtime_version
+from google.protobuf import symbol_database as _symbol_database
+from google.protobuf.internal import builder as _builder
+_runtime_version.ValidateProtobufRuntimeVersion(
+    _runtime_version.Domain.PUBLIC,
+    7,
+    35,
+    1,
+    '',
+    'features.proto'
+)
+# @@protoc_insertion_point(imports)
+
+_sym_db = _symbol_database.Default()
+
+
+
+
+DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x0e\x66\x65\x61tures.proto\x12\x0b\x66lagrant.v1\":\n\x12GetFeaturesRequest\x12\x0f\n\x07project\x18\x01 \x01(\t\x12\x13\n\x0b\x65nvironment\x18\x02 \x01(\t\"=\n\x13GetFeaturesResponse\x12&\n\x08\x66\x65\x61tures\x18\x01 \x03(\x0b\x32\x14.flagrant.v1.Feature\"}\n\x07\x46\x65\x61ture\x12\x12\n\nfeature_id\x18\x01 \x01(\x05\x12\x0c\n\x04name\x18\x02 \x01(\t\x12(\n\x05value\x18\x03 \x01(\x0b\x32\x19.flagrant.v1.VariantValue\x12\x17\n\nis_enabled\x18\x04 \x01(\x08H\x00\x88\x01\x01\x42\r\n\x0b_is_enabled\"F\n\x0cVariantValue\x12\x0e\n\x04text\x18\x01 \x01(\tH\x00\x12\x0e\n\x04json\x18\x02 \x01(\tH\x00\x12\x0e\n\x04toml\x18\x03 \x01(\tH\x00\x42\x06\n\x04kind2c\n\x0f\x46\x65\x61tureResolver\x12P\n\x0bGetFeatures\x12\x1f.flagrant.v1.GetFeaturesRequest\x1a .flagrant.v1.GetFeaturesResponseb\x06proto3')
+
+_globals = globals()
+_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals)
+_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'features_pb2', _globals)
+if not _descriptor._USE_C_DESCRIPTORS:
+  DESCRIPTOR._loaded_options = None
+  _globals['_GETFEATURESREQUEST']._serialized_start=31
+  _globals['_GETFEATURESREQUEST']._serialized_end=89
+  _globals['_GETFEATURESRESPONSE']._serialized_start=91
+  _globals['_GETFEATURESRESPONSE']._serialized_end=152
+  _globals['_FEATURE']._serialized_start=154
+  _globals['_FEATURE']._serialized_end=279
+  _globals['_VARIANTVALUE']._serialized_start=281
+  _globals['_VARIANTVALUE']._serialized_end=351
+  _globals['_FEATURERESOLVER']._serialized_start=353
+  _globals['_FEATURERESOLVER']._serialized_end=452
+# @@protoc_insertion_point(module_scope)

flagrant/proto/features_pb2.pyi

@@ -0,0 +1,43 @@
+from google.protobuf.internal import containers as _containers
+from google.protobuf import descriptor as _descriptor
+from google.protobuf import message as _message
+from collections.abc import Iterable as _Iterable, Mapping as _Mapping
+from typing import ClassVar as _ClassVar, Optional as _Optional, Union as _Union
+
+DESCRIPTOR: _descriptor.FileDescriptor
+
+class GetFeaturesRequest(_message.Message):
+    __slots__ = ("project", "environment")
+    PROJECT_FIELD_NUMBER: _ClassVar[int]
+    ENVIRONMENT_FIELD_NUMBER: _ClassVar[int]
+    project: str
+    environment: str
+    def __init__(self, project: _Optional[str] = ..., environment: _Optional[str] = ...) -> None: ...
+
+class GetFeaturesResponse(_message.Message):
+    __slots__ = ("features",)
+    FEATURES_FIELD_NUMBER: _ClassVar[int]
+    features: _containers.RepeatedCompositeFieldContainer[Feature]
+    def __init__(self, features: _Optional[_Iterable[_Union[Feature, _Mapping]]] = ...) -> None: ...
+
+class Feature(_message.Message):
+    __slots__ = ("feature_id", "name", "value", "is_enabled")
+    FEATURE_ID_FIELD_NUMBER: _ClassVar[int]
+    NAME_FIELD_NUMBER: _ClassVar[int]
+    VALUE_FIELD_NUMBER: _ClassVar[int]
+    IS_ENABLED_FIELD_NUMBER: _ClassVar[int]
+    feature_id: int
+    name: str
+    value: VariantValue
+    is_enabled: bool
+    def __init__(self, feature_id: _Optional[int] = ..., name: _Optional[str] = ..., value: _Optional[_Union[VariantValue, _Mapping]] = ..., is_enabled: _Optional[bool] = ...) -> None: ...
+
+class VariantValue(_message.Message):
+    __slots__ = ("text", "json", "toml")
+    TEXT_FIELD_NUMBER: _ClassVar[int]
+    JSON_FIELD_NUMBER: _ClassVar[int]
+    TOML_FIELD_NUMBER: _ClassVar[int]
+    text: str
+    json: str
+    toml: str
+    def __init__(self, text: _Optional[str] = ..., json: _Optional[str] = ..., toml: _Optional[str] = ...) -> None: ...

flagrant/proto/features_pb2_grpc.py

@@ -0,0 +1,115 @@
+# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT!
+"""Client and server classes corresponding to protobuf-defined services."""
+import grpc
+import warnings
+
+from . import features_pb2 as features__pb2
+
+GRPC_GENERATED_VERSION = '1.83.0'
+GRPC_VERSION = grpc.__version__
+_version_not_supported = False
+
+try:
+    from grpc._utilities import first_version_is_lower
+    _version_not_supported = first_version_is_lower(GRPC_VERSION, GRPC_GENERATED_VERSION)
+except ImportError:
+    _version_not_supported = True
+
+if _version_not_supported:
+    raise RuntimeError(
+        f'The grpc package installed is at version {GRPC_VERSION},'
+        + ' but the generated code in features_pb2_grpc.py depends on'
+        + f' grpcio>={GRPC_GENERATED_VERSION}.'
+        + f' Please upgrade your grpc module to grpcio>={GRPC_GENERATED_VERSION}'
+        + f' or downgrade your generated code using grpcio-tools<={GRPC_VERSION}.'
+    )
+
+
+class FeatureResolverStub:
+    """Mirrors GET /api/v1/projects/{project}/envs/{environment}/features.
+
+    Identity is sent via the `x-flagrant-identity` gRPC metadata key (mirroring the
+    `X-Flagrant-Identity` HTTP header), and the srv-token via the standard `authorization`
+    metadata key as `Bearer <token>` (mirroring the HTTP `Authorization` header) - neither
+    is a message field, same reasoning as HTTP headers not being query/body params.
+    """
+
+    def __init__(self, channel):
+        """Constructor.
+
+        Args:
+            channel: A grpc.Channel.
+        """
+        self.GetFeatures = channel.unary_unary(
+                '/flagrant.v1.FeatureResolver/GetFeatures',
+                request_serializer=features__pb2.GetFeaturesRequest.SerializeToString,
+                response_deserializer=features__pb2.GetFeaturesResponse.FromString,
+                _registered_method=True)
+
+
+class FeatureResolverServicer:
+    """Mirrors GET /api/v1/projects/{project}/envs/{environment}/features.
+
+    Identity is sent via the `x-flagrant-identity` gRPC metadata key (mirroring the
+    `X-Flagrant-Identity` HTTP header), and the srv-token via the standard `authorization`
+    metadata key as `Bearer <token>` (mirroring the HTTP `Authorization` header) - neither
+    is a message field, same reasoning as HTTP headers not being query/body params.
+    """
+
+    def GetFeatures(self, request, context):
+        """Missing associated documentation comment in .proto file."""
+        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
+        context.set_details('Method not implemented!')
+        raise NotImplementedError('Method not implemented!')
+
+
+def add_FeatureResolverServicer_to_server(servicer, server):
+    rpc_method_handlers = {
+            'GetFeatures': grpc.unary_unary_rpc_method_handler(
+                    servicer.GetFeatures,
+                    request_deserializer=features__pb2.GetFeaturesRequest.FromString,
+                    response_serializer=features__pb2.GetFeaturesResponse.SerializeToString,
+            ),
+    }
+    generic_handler = grpc.method_handlers_generic_handler(
+            'flagrant.v1.FeatureResolver', rpc_method_handlers)
+    server.add_generic_rpc_handlers((generic_handler,))
+    server.add_registered_method_handlers('flagrant.v1.FeatureResolver', rpc_method_handlers)
+
+
+ # This class is part of an EXPERIMENTAL API.
+class FeatureResolver:
+    """Mirrors GET /api/v1/projects/{project}/envs/{environment}/features.
+
+    Identity is sent via the `x-flagrant-identity` gRPC metadata key (mirroring the
+    `X-Flagrant-Identity` HTTP header), and the srv-token via the standard `authorization`
+    metadata key as `Bearer <token>` (mirroring the HTTP `Authorization` header) - neither
+    is a message field, same reasoning as HTTP headers not being query/body params.
+    """
+
+    @staticmethod
+    def GetFeatures(request,
+            target,
+            options=(),
+            channel_credentials=None,
+            call_credentials=None,
+            insecure=False,
+            compression=None,
+            wait_for_ready=None,
+            timeout=None,
+            metadata=None):
+        return grpc.experimental.unary_unary(
+            request,
+            target,
+            '/flagrant.v1.FeatureResolver/GetFeatures',
+            features__pb2.GetFeaturesRequest.SerializeToString,
+            features__pb2.GetFeaturesResponse.FromString,
+            options,
+            channel_credentials,
+            insecure,
+            call_credentials,
+            compression,
+            wait_for_ready,
+            timeout,
+            metadata,
+            _registered_method=True)

flagrant/transport.py

@@ -0,0 +1,19 @@
+from typing import Protocol
+
+from flagrant.models import Feature
+
+
+class TransientError(Exception):
+    """A fetch failed in a way that may be resolved by a stale cache entry or default handler."""
+
+
+class PermanentError(Exception):
+    """A fetch failed in a way that should propagate to the caller immediately."""
+
+
+class Transport(Protocol):
+    def fetch(self, project: str, environment: str, identity: str) -> list[Feature]:
+        """Fetch features for an environment/identity, raising TransientError or PermanentError on failure."""
+        ...
+
+    def close(self) -> None: ...

flagrant_client-0.1.0.dist-info/METADATA

@@ -0,0 +1,61 @@
+Metadata-Version: 2.5
+Name: flagrant-client
+Version: 0.1.0
+Summary: A python client for Flagrant feature-flagging API
+Project-URL: Homepage, https://github.com/mbuczko/flagrant-client-python
+Project-URL: Repository, https://github.com/mbuczko/flagrant-client-python
+Author-email: Michal Buczko <michal@buczko.pl>
+License-Expression: MIT
+License-File: LICENSE
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Requires-Python: >=3.11
+Requires-Dist: grpcio>=1.83.0
+Requires-Dist: httpx>=0.28.1
+Requires-Dist: protobuf>=7.36.0
+Requires-Dist: pydantic>=2.13.4
+Description-Content-Type: text/markdown
+
+# flagrant-client-python
+
+A Python client for fetching feature flags from a [Flagrant](https://github.com/mbuczko/flagrant) server, with pluggable transports, optional caching, and stale-on-error fallback.
+
+## Transports
+
+`FlagrantClient` doesn't talk to the network itself - it delegates to a `Transport`, a small protocol with a single `fetch(project, environment, identity) -> list[Feature]` method (plus `close()`). This keeps the client's caching/fallback logic independent of how features are actually retrieved, and makes it easy to add new transports or swap them in tests.
+
+Two transports ship today:
+
+- **`HttpTransport`**  - calls the endpoint `GET /api/v1/projects/{project}/envs/{environment}/features` over HTTP via `httpx`, sending the identity as an `X-Flagrant-Identity` header.
+- **`GrpcTransport`**  - calls for the features over gRPC, sending the identity as an `x-flagrant-identity` metadata entry. Accepts any grpc-core target string, including `unix:` sockets.
+
+Both transports retry on transient failures with exponential backoff (`retries`, `backoff_factor`), and both classify errors into one of two exceptions defined in `transport.py`:
+
+- `TransientError` - the fetch failed in a way that might be resolved by falling back to a stale cache entry or a default handler (e.g. server errors, `UNAVAILABLE`/`UNKNOWN`/`INTERNAL`/`RESOURCE_EXHAUSTED` gRPC codes, connection
+  errors).
+- `PermanentError` - the failure should propagate to the caller immediately (e.g. 4xx responses, malformed feature payloads).
+
+This split lets `FlagrantClient.get_features` react differently depending on whether a retry-worthy or a nonrecoverable failure occurred, regardless of which transport raised it.
+
+## Caching and fallback
+
+`FlagrantClient` optionally wraps fetches in an `LRUCache` (per `(environment, identity)` key), configured via `FlagsmithOpts(cache_size=..., cache_ttl=...)`. On a `TransientError`, the client tries a stale cache entry before falling back to a user-supplied `default_handler`, and only re-raises if neither is available.
+
+## Testing in IPython
+
+With the dev dependencies installed and a Flagrant gRPC server listening on a Unix socket at `/tmp/flagrant/grpc.sock`:
+
+```bash
+uv run ipython
+```
+
+```python
+import flagrant.client as c
+import flagrant.grpc_transport as gt
+
+t = gt.GrpcTransport("unix:/tmp/flagrant/grpc.sock")
+client = c.FlagrantClient(project="demo", transport=t)
+client.get_features(environment="prod", identity="foo")
+```
+
+Swap in `flagrant.http_transport.HttpTransport("http://localhost:3030")` to hit an HTTP server instead - the rest of the snippet stays the same, since `FlagrantClient` only depends on the `Transport` protocol.

flagrant_client-0.1.0.dist-info/RECORD

@@ -0,0 +1,15 @@
+flagrant/__init__.py,sha256=BaO41_qs_iNkEEbYZdXy4nDw65SyVw88hjS-m3YkOBc,392
+flagrant/cache.py,sha256=7BfR3zyHvUmMIyg2XXnOcohK_SmOft_4RgIJsTjrGkw,1706
+flagrant/client.py,sha256=wwBSqkUiWwUPSL1ppR9AqNwVVEcdZ8FIULiySH58brI,1900
+flagrant/grpc_transport.py,sha256=Yg3Oeh4izRA-DsPRWF9lYwPPoQyuSaASlfyq32i6DEo,3236
+flagrant/http_transport.py,sha256=13VEqVnPAX6S_iy0pxnu33vL_0pBtW3mUpSDb0meGBY,1656
+flagrant/models.py,sha256=YOVf4nv7eQx6bdxpempVCcllWrUqRehMPiVXVnuzFAg,1910
+flagrant/transport.py,sha256=B6G5rJ4cmMKl3A-uEsVwSFTsfhi7X1DTEtCpVGwTeQ4,587
+flagrant/proto/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+flagrant/proto/features_pb2.py,sha256=sa1n70I7tcXOQwuYI9ybE5WDsEhmK_iGhA9-g9x5yPA,2386
+flagrant/proto/features_pb2.pyi,sha256=Y8zJKVaEzAD5Vg-DLIqskZVGxWsZBFmD_Ryj7gTxHLM,1842
+flagrant/proto/features_pb2_grpc.py,sha256=_f22muYffSXLZw5e1fC_4XiE8i0WfrLappihibigL5Q,4583
+flagrant_client-0.1.0.dist-info/METADATA,sha256=gVMCevOXdXCJ0riYeK0YwVGVe80w2olZ5j3o9N9Xr1k,3312
+flagrant_client-0.1.0.dist-info/WHEEL,sha256=zOwg4jB6zX2kU910N-cMawjivD6tO8NEWvE12je1bVk,87
+flagrant_client-0.1.0.dist-info/licenses/LICENSE,sha256=r2QbH5GaSyVTmWpq81Fe639BVpEn44iKVVPFhSqezrY,1070
+flagrant_client-0.1.0.dist-info/RECORD,,

flagrant_client-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.32.0
+Root-Is-Purelib: true
+Tag: py3-none-any

flagrant_client-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Michal Buczko
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.