flagsmith-flag-engine 6.0.1__py3-none-any.whl

flag_engine/projects/models.py

@@ -0,0 +1,16 @@
+import typing
+
+from pydantic import BaseModel, Field
+
+from flag_engine.organisations.models import OrganisationModel
+from flag_engine.segments.models import SegmentModel
+
+
+class ProjectModel(BaseModel):
+    id: int
+    name: str
+    organisation: OrganisationModel
+    hide_disabled_flags: bool = False
+    segments: typing.List[SegmentModel] = Field(default_factory=list)
+    enable_realtime_updates: bool = False
+    server_key_only_feature_ids: typing.List[int] = Field(default_factory=list)

flag_engine/segments/constants.py

@@ -0,0 +1,22 @@
+from flag_engine.segments.types import ConditionOperator, RuleType
+
+# Segment Rules
+ALL_RULE: RuleType = "ALL"
+ANY_RULE: RuleType = "ANY"
+NONE_RULE: RuleType = "NONE"
+
+# Segment Condition Operators
+EQUAL: ConditionOperator = "EQUAL"
+GREATER_THAN: ConditionOperator = "GREATER_THAN"
+LESS_THAN: ConditionOperator = "LESS_THAN"
+LESS_THAN_INCLUSIVE: ConditionOperator = "LESS_THAN_INCLUSIVE"
+CONTAINS: ConditionOperator = "CONTAINS"
+GREATER_THAN_INCLUSIVE: ConditionOperator = "GREATER_THAN_INCLUSIVE"
+NOT_CONTAINS: ConditionOperator = "NOT_CONTAINS"
+NOT_EQUAL: ConditionOperator = "NOT_EQUAL"
+REGEX: ConditionOperator = "REGEX"
+PERCENTAGE_SPLIT: ConditionOperator = "PERCENTAGE_SPLIT"
+MODULO: ConditionOperator = "MODULO"
+IS_SET: ConditionOperator = "IS_SET"
+IS_NOT_SET: ConditionOperator = "IS_NOT_SET"
+IN: ConditionOperator = "IN"

flag_engine/segments/evaluator.py

@@ -0,0 +1,233 @@
+import operator
+import re
+import typing
+from contextlib import suppress
+from functools import partial, wraps
+
+import semver
+
+from flag_engine.context.types import EvaluationContext
+from flag_engine.identities.traits.types import ContextValue
+from flag_engine.segments import constants
+from flag_engine.segments.models import (
+    SegmentConditionModel,
+    SegmentModel,
+    SegmentRuleModel,
+)
+from flag_engine.segments.types import ConditionOperator
+from flag_engine.utils.hashing import get_hashed_percentage_for_object_ids
+from flag_engine.utils.semver import is_semver
+from flag_engine.utils.types import SupportsStr, get_casting_function
+
+
+def get_context_segments(
+    context: EvaluationContext,
+    segments: typing.List[SegmentModel],
+) -> typing.List[SegmentModel]:
+    return [
+        segment
+        for segment in segments
+        if is_context_in_segment(
+            context=context,
+            segment=segment,
+        )
+    ]
+
+
+def is_context_in_segment(
+    context: EvaluationContext,
+    segment: SegmentModel,
+) -> bool:
+    return bool(rules := segment.rules) and all(
+        context_matches_rule(context=context, rule=rule, segment_key=segment.id)
+        for rule in rules
+    )
+
+
+def context_matches_rule(
+    context: EvaluationContext,
+    rule: SegmentRuleModel,
+    segment_key: SupportsStr,
+) -> bool:
+    matches_conditions = (
+        rule.matching_function(
+            [
+                context_matches_condition(
+                    context=context,
+                    condition=condition,
+                    segment_key=segment_key,
+                )
+                for condition in conditions
+            ]
+        )
+        if (conditions := rule.conditions)
+        else True
+    )
+
+    return matches_conditions and all(
+        context_matches_rule(
+            context=context,
+            rule=rule,
+            segment_key=segment_key,
+        )
+        for rule in rule.rules
+    )
+
+
+def context_matches_condition(
+    context: EvaluationContext,
+    condition: SegmentConditionModel,
+    segment_key: SupportsStr,
+) -> bool:
+    context_value = (
+        get_context_value(context, condition.property_) if condition.property_ else None
+    )
+
+    if condition.operator == constants.PERCENTAGE_SPLIT:
+        assert condition.value
+
+        if context_value is not None:
+            object_ids = [segment_key, context_value]
+        else:
+            object_ids = [segment_key, get_context_value(context, "$.identity.key")]
+
+        float_value = float(condition.value)
+        return get_hashed_percentage_for_object_ids(object_ids) <= float_value
+
+    if condition.operator == constants.IS_NOT_SET:
+        return context_value is None
+
+    if condition.operator == constants.IS_SET:
+        return context_value is not None
+
+    return (
+        _matches_context_value(condition, context_value)
+        if context_value is not None
+        else False
+    )
+
+
+def _get_trait(context: EvaluationContext, trait_key: str) -> ContextValue:
+    return (
+        identity_context["traits"][trait_key]
+        if (identity_context := context["identity"])
+        else None
+    )
+
+
+def get_context_value(
+    context: EvaluationContext,
+    property: str,
+) -> ContextValue:
+    getter = CONTEXT_VALUE_GETTERS_BY_PROPERTY.get(property) or partial(
+        _get_trait,
+        trait_key=property,
+    )
+    try:
+        return getter(context)
+    except KeyError:
+        return None
+
+
+def _matches_context_value(
+    condition: SegmentConditionModel,
+    context_value: ContextValue,
+) -> bool:
+    if matcher := MATCHERS_BY_OPERATOR.get(condition.operator):
+        return matcher(condition.value, context_value)
+
+    return False
+
+
+def _evaluate_not_contains(
+    segment_value: typing.Optional[str],
+    context_value: ContextValue,
+) -> bool:
+    return isinstance(context_value, str) and str(segment_value) not in context_value
+
+
+def _evaluate_regex(
+    segment_value: typing.Optional[str],
+    context_value: ContextValue,
+) -> bool:
+    return (
+        context_value is not None
+        and re.compile(str(segment_value)).match(str(context_value)) is not None
+    )
+
+
+def _evaluate_modulo(
+    segment_value: typing.Optional[str],
+    context_value: ContextValue,
+) -> bool:
+    if not isinstance(context_value, (int, float)):
+        return False
+
+    if segment_value is None:
+        return False
+
+    try:
+        divisor_part, remainder_part = segment_value.split("|")
+        divisor = float(divisor_part)
+        remainder = float(remainder_part)
+    except ValueError:
+        return False
+
+    return context_value % divisor == remainder
+
+
+def _evaluate_in(
+    segment_value: typing.Optional[str], context_value: ContextValue
+) -> bool:
+    if segment_value:
+        if isinstance(context_value, str):
+            return context_value in segment_value.split(",")
+        if isinstance(context_value, int) and not any(
+            context_value is x for x in (False, True)
+        ):
+            return str(context_value) in segment_value.split(",")
+    return False
+
+
+def _context_value_typed(
+    func: typing.Callable[..., bool],
+) -> typing.Callable[[typing.Optional[str], ContextValue], bool]:
+    @wraps(func)
+    def inner(
+        segment_value: typing.Optional[str],
+        context_value: typing.Union[ContextValue, semver.Version],
+    ) -> bool:
+        with suppress(TypeError, ValueError):
+            if isinstance(context_value, str) and is_semver(segment_value):
+                context_value = semver.Version.parse(
+                    context_value,
+                )
+            match_value = get_casting_function(context_value)(segment_value)
+            return func(context_value, match_value)
+        return False
+
+    return inner
+
+
+MATCHERS_BY_OPERATOR: typing.Dict[
+    ConditionOperator, typing.Callable[[typing.Optional[str], ContextValue], bool]
+] = {
+    constants.NOT_CONTAINS: _evaluate_not_contains,
+    constants.REGEX: _evaluate_regex,
+    constants.MODULO: _evaluate_modulo,
+    constants.IN: _evaluate_in,
+    constants.EQUAL: _context_value_typed(operator.eq),
+    constants.GREATER_THAN: _context_value_typed(operator.gt),
+    constants.GREATER_THAN_INCLUSIVE: _context_value_typed(operator.ge),
+    constants.LESS_THAN: _context_value_typed(operator.lt),
+    constants.LESS_THAN_INCLUSIVE: _context_value_typed(operator.le),
+    constants.NOT_EQUAL: _context_value_typed(operator.ne),
+    constants.CONTAINS: _context_value_typed(operator.contains),
+}
+
+
+CONTEXT_VALUE_GETTERS_BY_PROPERTY = {
+    "$.identity.identifier": lambda context: context["identity"]["identifier"],
+    "$.identity.key": lambda context: context["identity"]["key"],
+    "$.environment.name": lambda context: context["environment"]["name"],
+}

flag_engine/segments/models.py

@@ -0,0 +1,41 @@
+import typing
+
+from pydantic import BaseModel, BeforeValidator, Field
+from typing_extensions import Annotated
+
+from flag_engine.features.models import FeatureStateModel
+from flag_engine.segments import constants
+from flag_engine.segments.types import ConditionOperator, RuleType
+
+LaxStr = Annotated[str, BeforeValidator(lambda x: str(x))]
+
+
+class SegmentConditionModel(BaseModel):
+    operator: ConditionOperator
+    value: typing.Optional[LaxStr] = None
+    property_: typing.Optional[str] = None
+
+
+class SegmentRuleModel(BaseModel):
+    type: RuleType
+    rules: typing.List["SegmentRuleModel"] = Field(default_factory=list)
+    conditions: typing.List[SegmentConditionModel] = Field(default_factory=list)
+
+    @staticmethod
+    def none(iterable: typing.Iterable[object]) -> bool:
+        return not any(iterable)
+
+    @property
+    def matching_function(self) -> typing.Callable[[typing.Iterable[object]], bool]:
+        return {
+            constants.ANY_RULE: any,
+            constants.ALL_RULE: all,
+            constants.NONE_RULE: SegmentRuleModel.none,
+        }[self.type]
+
+
+class SegmentModel(BaseModel):
+    id: int
+    name: str
+    rules: typing.List[SegmentRuleModel] = Field(default_factory=list)
+    feature_states: typing.List[FeatureStateModel] = Field(default_factory=list)

flag_engine/segments/types.py

@@ -0,0 +1,24 @@
+from typing import Literal
+
+ConditionOperator = Literal[
+    "EQUAL",
+    "GREATER_THAN",
+    "LESS_THAN",
+    "LESS_THAN_INCLUSIVE",
+    "CONTAINS",
+    "GREATER_THAN_INCLUSIVE",
+    "NOT_CONTAINS",
+    "NOT_EQUAL",
+    "REGEX",
+    "PERCENTAGE_SPLIT",
+    "MODULO",
+    "IS_SET",
+    "IS_NOT_SET",
+    "IN",
+]
+
+RuleType = Literal[
+    "ALL",
+    "ANY",
+    "NONE",
+]

flag_engine/utils/datetime.py

@@ -0,0 +1,5 @@
+from datetime import datetime, timezone
+
+
+def utcnow_with_tz() -> datetime:
+    return datetime.now(tz=timezone.utc)

flag_engine/utils/exceptions.py

@@ -0,0 +1,10 @@
+class FeatureStateNotFound(Exception):
+    pass
+
+
+class DuplicateFeatureState(ValueError):
+    pass
+
+
+class InvalidPercentageAllocation(ValueError):
+    pass

flag_engine/utils/hashing.py

@@ -0,0 +1,33 @@
+import hashlib
+import typing
+
+from flag_engine.utils.types import SupportsStr
+
+
+def get_hashed_percentage_for_object_ids(
+    object_ids: typing.Iterable[SupportsStr], iterations: int = 1
+) -> float:
+    """
+    Given a list of object ids, get a floating point number between 0 (inclusive) and
+    100 (exclusive) based on the hash of those ids. This should give the same value
+    every time for any list of ids.
+
+    :param object_ids: list of object ids to calculate the hash for
+    :param iterations: num times to include each id in the generated string to hash
+    :return: (float) number between 0 (inclusive) and 100 (exclusive)
+    """
+
+    to_hash = ",".join(str(id_) for id_ in list(object_ids) * iterations)
+    hashed_value = hashlib.md5(to_hash.encode("utf-8"))
+    hashed_value_as_int = int(hashed_value.hexdigest(), base=16)
+    value = ((hashed_value_as_int % 9999) / 9998) * 100
+
+    if value == 100:
+        # since we want a number between 0 (inclusive) and 100 (exclusive), in the
+        # unlikely case that we get the exact number 100, we call the method again
+        # and increase the number of iterations to ensure we get a different result
+        return get_hashed_percentage_for_object_ids(
+            object_ids=object_ids, iterations=iterations + 1
+        )
+
+    return value

flag_engine/utils/json/encoders.py

@@ -0,0 +1,16 @@
+import decimal
+import json
+
+
+class DecimalEncoder(json.JSONEncoder):
+    """
+    Convert decimal to int/float because decimals are nothing but
+    int/float(for us) converted to decimal by boto3/dynamodb.
+    """
+
+    def default(self, obj: object) -> object:
+        if isinstance(obj, decimal.Decimal):
+            if obj % 1 == 0:
+                return int(obj)
+            return float(obj)
+        return json.JSONEncoder.default(self, obj)

flag_engine/utils/semver.py

@@ -0,0 +1,26 @@
+from typing import Optional
+
+import semver
+
+
+def is_semver(value: Optional[str]) -> bool:
+    """
+    Checks if the given string have `:semver` suffix or not
+    >>> is_semver("2.1.41-beta:semver")
+    True
+    >>> is_semver("2.1.41-beta")
+    False
+    """
+
+    return value is not None and value[-7:] == ":semver"
+
+
+def remove_semver_suffix(value: semver.Version) -> str:
+    """
+    Remove the semver suffix(i.e: last 7 characters) from the given value
+    >>> remove_semver_suffix("2.1.41-beta:semver")
+    '2.1.41-beta'
+    >>> remove_semver_suffix("2.1.41:semver")
+    '2.1.41'
+    """
+    return str(value)[:-7]

flag_engine/utils/types.py

@@ -0,0 +1,46 @@
+import typing
+from functools import singledispatch
+
+import semver
+
+from flag_engine.identities.traits.types import ContextValue
+from flag_engine.utils.semver import remove_semver_suffix
+
+
+class SupportsStr(typing.Protocol):
+    def __str__(self) -> str:  # pragma: no cover
+        ...
+
+
+@singledispatch
+def get_casting_function(
+    input_: object,
+) -> typing.Callable[..., ContextValue]:
+    """
+    This function returns a callable to cast a value to the same type as input_
+    >>> assert get_casting_function("a string") == str
+    >>> assert get_casting_function(10) == int
+    >>> assert get_casting_function(1.2) == float
+    >>> assert get_casting_function(semver.Version.parse("3.4.5")) == remove_semver_suffix
+    """
+    return str
+
+
+@get_casting_function.register
+def _(input_: bool) -> typing.Callable[..., bool]:
+    return lambda v: v not in ("False", "false")
+
+
+@get_casting_function.register
+def _(input_: int) -> typing.Callable[..., int]:
+    return int
+
+
+@get_casting_function.register
+def _(input_: float) -> typing.Callable[..., float]:
+    return float
+
+
+@get_casting_function.register
+def _(input_: semver.Version) -> typing.Callable[..., str]:
+    return remove_semver_suffix

flagsmith_flag_engine-6.0.1.dist-info/METADATA

@@ -0,0 +1,50 @@
+Metadata-Version: 2.4
+Name: flagsmith-flag-engine
+Version: 6.0.1
+Summary: Flag engine for the Flagsmith API.
+Home-page: https://github.com/Flagsmith/flagsmith-engine
+Author: Flagsmith
+Author-email: support@flagsmith.com
+License: BSD3
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE.txt
+Requires-Dist: pydantic<3,>=2.3.0
+Requires-Dist: pydantic-collections<1,>=0.5.1
+Requires-Dist: semver>=3.0.1
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: summary
+
+[![Feature Flag, Remote Config and A/B Testing platform, Flagsmith](https://github.com/Flagsmith/flagsmith/raw/main/static-files/hero.png)](https://www.flagsmith.com/)
+
+[Flagsmith](https://www.flagsmith.com/) is an open source, fully featured, Feature Flag and Remote Config service. Use
+our hosted API, deploy to your own private cloud, or run on-premise.
+
+# Flagsmith Flag Engine
+
+This project powers the core [Flagsmith API](https://github.com/Flagsmith/flagsmith-api) flag evaluations engine.
+
+## Setup
+
+```bash
+python -m venv .venv
+source .venv/bin/activate
+python -m pip install -r requirements-dev.txt
+```
+
+## Design
+
+- Marshmallow Schemas
+- Plain Python

flagsmith_flag_engine-6.0.1.dist-info/RECORD

@@ -0,0 +1,42 @@
+flag_engine/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+flag_engine/engine.py,sha256=IyA2wgUx5wojlRqHXI5rjyoZFafcbFQvZeuPicyfnCg,5244
+flag_engine/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+flag_engine/context/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+flag_engine/context/mappers.py,sha256=cYQx3VLmTjfvr42v39IgcQkv6Db6sfLwwcwA7_LTf3c,1394
+flag_engine/context/types.py,sha256=D7pEyELvR15kLZ2OuaZUhtdGoRhXzLXGNj3_aVPk-yQ,772
+flag_engine/environments/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+flag_engine/environments/models.py,sha256=bBiITUVX-yQrcBG9BuVMAXSklKegrRHZ2-UyZ6a-omY,3198
+flag_engine/environments/integrations/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+flag_engine/environments/integrations/models.py,sha256=_LC_3XOAN9tEhz4wEB7HCxD3NX5si046C6H0mZFA8e4,208
+flag_engine/features/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+flag_engine/features/constants.py,sha256=oinYCtAUD6jw09wVuBSDC0R2CndEZkjXMUXCck1DuXo,68
+flag_engine/features/models.py,sha256=BaW1LAiwSBrND16WAzJgsM0lhRKrwQ4MyBTgxYzqZ9U,5757
+flag_engine/identities/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+flag_engine/identities/models.py,sha256=9Si3uPWoMSXhd_nzuKCZI3bBPHrE-jDUzG9OPg66JP4,3440
+flag_engine/identities/traits/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+flag_engine/identities/traits/constants.py,sha256=pQHoyiBxx7mwO0x3jO029Z4P_vvR0FBOLgFGNfbT6xk,42
+flag_engine/identities/traits/models.py,sha256=NOWvvwJgNweEe9WdcBBjFEkpPECf48nX91sID73vXTo,193
+flag_engine/identities/traits/types.py,sha256=iQhuxZnY2Q81YZXbZW9n4rdf0t34tmEH1Ufh0MIKdlw,1936
+flag_engine/organisations/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+flag_engine/organisations/models.py,sha256=AvYhkDv6Tb8241HrgpKY0kqw8XaIN42LTdA0N348uXA,299
+flag_engine/projects/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+flag_engine/projects/models.py,sha256=Y4IKMwf1EKbSohamzO8cvKssrw8WyXggR44KZLkA77g,495
+flag_engine/segments/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+flag_engine/segments/constants.py,sha256=nu73rNXNvRmtHYOwVeQcXLYD3C1L6_FAK93EoqhblpQ,830
+flag_engine/segments/evaluator.py,sha256=CyPnepaJOBjTR11PkF2IRGQ2yLvHwtOhOIsJD1cllq4,6719
+flag_engine/segments/models.py,sha256=gABacer5WJgMEu68ndNairyPkR7v7XsAh29NHTjtNmY,1296
+flag_engine/segments/types.py,sha256=G17HPxcI_hGWzUQPvP4XAp5xTl9Xe2K0qW3ewOGD8P4,369
+flag_engine/types/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+flag_engine/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+flag_engine/utils/datetime.py,sha256=f2KMnR3jFwXyUz7UhAhLKY1UyxnKroEhY5KT2hjgt8g,117
+flag_engine/utils/exceptions.py,sha256=6T7W7QuOshNDWQv1JWzIzPoKLUjKB4vhNJzD6YbJng4,158
+flag_engine/utils/hashing.py,sha256=tCaDV4MSUpD9jclJ86VAYuwE2-EAkkuEfQLJgORETEE,1311
+flag_engine/utils/semver.py,sha256=aMW-f3wkGJGXCC9AruQc1SSKO7RgQs8BAIsaSAGzN4U,619
+flag_engine/utils/types.py,sha256=HJ0ZqoG8pZVE9n13_aVXCDwqy_PNZOsnNIsPsaPaoDk,1203
+flag_engine/utils/json/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+flag_engine/utils/json/encoders.py,sha256=MYXmhgJ6stSt0ffQDP3DWFh3m_G_fwN-vImkTJF_M0g,447
+flagsmith_flag_engine-6.0.1.dist-info/licenses/LICENSE.txt,sha256=ODfaqV7JJbGSIlIuOA-GHHyc4cGi-QWinwCa2O5nse0,1546
+flagsmith_flag_engine-6.0.1.dist-info/METADATA,sha256=WoVrBt-BB3vHzAl8pSjaDNJMJK-mMWBtjOevxyDXhhY,1532
+flagsmith_flag_engine-6.0.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+flagsmith_flag_engine-6.0.1.dist-info/top_level.txt,sha256=mmD1_GUabsUgkPJ9i9GU5NSOG4dlu9KTViP0ypclpVI,12
+flagsmith_flag_engine-6.0.1.dist-info/RECORD,,

flagsmith_flag_engine-6.0.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

flagsmith_flag_engine-6.0.1.dist-info/licenses/LICENSE.txt

@@ -0,0 +1,12 @@
+Copyright (c) 2021 Bullet Train Ltd (https://www.flagsmith.com/) and individual contributors.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+
+    1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
+
+    2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
+
+    3. Neither the name of the Sentry nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

flagsmith_flag_engine-6.0.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+flag_engine