Skip to content

Condition

Source code in src/library_analyzer/processing/api/_extract_dependencies.py 
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
@dataclass
class Condition:
    class Variant(str, Enum):
        CONDITION = "condition"
        IN_RELATION = "in_relation"
        HAS_VALUE = "has_value"
        NO_VALUE = "no_value"
        IS_NONE = "is_none"
        HAS_TYPE = "has_type"
        NO_TYPE = "no_type"

    condition: str = ""
    dependee: str = ""
    combined_with: list[Condition] = field(default_factory=list)

    @classmethod
    def from_dict(cls, d: dict[str, Any]) -> Condition:
        match d["variant"]:
            case Condition.Variant.CONDITION.value:
                return cls(
                    d["condition"],
                    d["dependee"],
                    [Condition.from_dict(cond_dict) for cond_dict in d["combined_with"]],
                )
            case Condition.Variant.IN_RELATION.value:
                return ParametersInRelation.from_dict(d)
            case Condition.Variant.HAS_VALUE.value:
                return ParameterHasValue.from_dict(d)
            case Condition.Variant.NO_VALUE.value:
                return ParameterHasNotValue.from_dict(d)
            case Condition.Variant.IS_NONE.value:
                return ParameterIsNone.from_dict(d)
            case Condition.Variant.HAS_TYPE.value:
                return ParameterHasType.from_dict(d)
            case Condition.Variant.NO_TYPE.value:
                return ParameterDoesNotHaveType.from_dict(d)
            case _:
                raise KeyError("unknown variant found")

    def to_dict(self) -> dict[str, Any]:
        return {
            "variant": Condition.Variant.CONDITION.value,
            "condition": self.condition,
            "dependee": self.dependee,
            "combined_with": [cond.to_dict() for cond in self.combined_with],
        }

combined_with: list[Condition] = field(default_factory=list) class-attribute instance-attribute

condition: str = '' class-attribute instance-attribute

dependee: str = '' class-attribute instance-attribute

Variant

Bases: str, Enum

Source code in src/library_analyzer/processing/api/_extract_dependencies.py 
60
61
62
63
64
65
66
67
class Variant(str, Enum):
    CONDITION = "condition"
    IN_RELATION = "in_relation"
    HAS_VALUE = "has_value"
    NO_VALUE = "no_value"
    IS_NONE = "is_none"
    HAS_TYPE = "has_type"
    NO_TYPE = "no_type"

CONDITION = 'condition' class-attribute instance-attribute

HAS_TYPE = 'has_type' class-attribute instance-attribute

HAS_VALUE = 'has_value' class-attribute instance-attribute

IN_RELATION = 'in_relation' class-attribute instance-attribute

IS_NONE = 'is_none' class-attribute instance-attribute

NO_TYPE = 'no_type' class-attribute instance-attribute

NO_VALUE = 'no_value' class-attribute instance-attribute

__init__(condition='', dependee='', combined_with=list())

from_dict(d) classmethod

Source code in src/library_analyzer/processing/api/_extract_dependencies.py 
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
@classmethod
def from_dict(cls, d: dict[str, Any]) -> Condition:
    match d["variant"]:
        case Condition.Variant.CONDITION.value:
            return cls(
                d["condition"],
                d["dependee"],
                [Condition.from_dict(cond_dict) for cond_dict in d["combined_with"]],
            )
        case Condition.Variant.IN_RELATION.value:
            return ParametersInRelation.from_dict(d)
        case Condition.Variant.HAS_VALUE.value:
            return ParameterHasValue.from_dict(d)
        case Condition.Variant.NO_VALUE.value:
            return ParameterHasNotValue.from_dict(d)
        case Condition.Variant.IS_NONE.value:
            return ParameterIsNone.from_dict(d)
        case Condition.Variant.HAS_TYPE.value:
            return ParameterHasType.from_dict(d)
        case Condition.Variant.NO_TYPE.value:
            return ParameterDoesNotHaveType.from_dict(d)
        case _:
            raise KeyError("unknown variant found")

to_dict()

Source code in src/library_analyzer/processing/api/_extract_dependencies.py 
 97
 98
 99
100
101
102
103
def to_dict(self) -> dict[str, Any]:
    return {
        "variant": Condition.Variant.CONDITION.value,
        "condition": self.condition,
        "dependee": self.dependee,
        "combined_with": [cond.to_dict() for cond in self.combined_with],
    }