internal.settings.config

Loading configs.

View Source

  1"""Loading configs."""
  2
  3import pathlib
  4from typing import Annotated, Literal
  5
  6import yaml  # type: ignore[import-untyped]
  7from pydantic import BaseModel, Field, model_validator
  8
  9from internal.settings.env import badges_settings
 10
 11
 12class BadgesConfig:
 13    """Badges config."""
 14
 15    class BaseBadgeRule(BaseModel):
 16        """Base model for all badge rules."""
 17
 18        level: int
 19
 20    class QuantityGoal(BaseBadgeRule):
 21        """Badge rule for quantity."""
 22
 23        type: Literal["quantity"]
 24        quantity: int
 25
 26        category_id: int | None = None
 27        seller_id: int | None = None
 28
 29    class CO2Goal(BaseBadgeRule):
 30        """Badge rule for carbon dioxide saving."""
 31
 32        type: Literal["co2"]
 33        carbon_dioxide: float
 34
 35    class DiversityGoal(BaseBadgeRule):
 36        """Badge rule for diverse reservations."""
 37
 38        type: Literal["diversity"]
 39        dif_categories: int = 0
 40        dif_sellers: int = 0
 41
 42        @model_validator(mode="after")
 43        def exclusive_validator(self) -> BadgesConfig.DiversityGoal:
 44            """Validates if no conflicting field are set.
 45
 46            Returns:
 47                valid model
 48
 49            Raises:
 50                ValueError: if model is not valid
 51            """
 52            if self.dif_categories < 1 and self.dif_sellers < 1:
 53                raise ValueError(
 54                    "Provide 'dif_categories' or 'dif_sellers' but not both"
 55                )
 56            if not self.dif_categories < 1 and not self.dif_sellers < 1:
 57                raise ValueError("Provide 'dif_categories' or 'dif_sellers'")
 58            if self.dif_categories < 0 or self.dif_sellers < 0:
 59                raise ValueError("Invalid negative value")
 60            return self
 61
 62    class StreakGoal(BaseBadgeRule):
 63        """Badge rule for a steak of reservations."""
 64
 65        type: Literal["streak"]
 66        streak_days: int = 0
 67        streak_quantity: int = 0
 68
 69        category_id: int | None = None
 70        seller_id: int | None = None
 71
 72        @model_validator(mode="after")
 73        def exclusive_validator(self) -> BadgesConfig.StreakGoal:
 74            """Validates if no conflicting field are set.
 75
 76            Returns:
 77                valid model
 78
 79            Raises:
 80                ValueError: if model is not valid
 81            """
 82            if self.streak_days < 1 and self.streak_quantity < 1:
 83                raise ValueError(
 84                    "Provide 'streak_days' or 'streak_quantity' but not both"
 85                )
 86            if not self.streak_days < 1 and not self.streak_quantity < 1:
 87                raise ValueError("Provide 'streak_days' or 'streak_quantity'")
 88            if self.streak_days < 0 or self.streak_quantity < 0:
 89                raise ValueError("Invalid negative value")
 90            return self
 91
 92    BadgeGoal = Annotated[
 93        QuantityGoal | CO2Goal | DiversityGoal | StreakGoal, Field(discriminator="type")
 94    ]
 95
 96    class BadgeRules(BaseModel):
 97        """Full badge rule set."""
 98
 99        badge_id: int
100        badge_name: str | None = None
101        rules: list[BadgesConfig.BadgeGoal]
102
103    class BadgesRules(BaseModel):
104        """Rules for all badges."""
105
106        badges_rules: list[BadgesConfig.BadgeRules]
107
108    badges_rules: BadgesConfig.BadgesRules
109
110    def initialise(self) -> None:
111        """Load badges rules from file.
112
113        Args:
114          self: class instance
115        """
116        with pathlib.Path(badges_settings.rules_path).open(encoding="utf-8") as file:
117            raw_data = yaml.safe_load(file)
118            self.badges_rules = BadgesConfig.BadgesRules.model_validate(raw_data)
119
120
121badges_config = BadgesConfig()

class BadgesConfig: View Source

 13class BadgesConfig:
 14    """Badges config."""
 15
 16    class BaseBadgeRule(BaseModel):
 17        """Base model for all badge rules."""
 18
 19        level: int
 20
 21    class QuantityGoal(BaseBadgeRule):
 22        """Badge rule for quantity."""
 23
 24        type: Literal["quantity"]
 25        quantity: int
 26
 27        category_id: int | None = None
 28        seller_id: int | None = None
 29
 30    class CO2Goal(BaseBadgeRule):
 31        """Badge rule for carbon dioxide saving."""
 32
 33        type: Literal["co2"]
 34        carbon_dioxide: float
 35
 36    class DiversityGoal(BaseBadgeRule):
 37        """Badge rule for diverse reservations."""
 38
 39        type: Literal["diversity"]
 40        dif_categories: int = 0
 41        dif_sellers: int = 0
 42
 43        @model_validator(mode="after")
 44        def exclusive_validator(self) -> BadgesConfig.DiversityGoal:
 45            """Validates if no conflicting field are set.
 46
 47            Returns:
 48                valid model
 49
 50            Raises:
 51                ValueError: if model is not valid
 52            """
 53            if self.dif_categories < 1 and self.dif_sellers < 1:
 54                raise ValueError(
 55                    "Provide 'dif_categories' or 'dif_sellers' but not both"
 56                )
 57            if not self.dif_categories < 1 and not self.dif_sellers < 1:
 58                raise ValueError("Provide 'dif_categories' or 'dif_sellers'")
 59            if self.dif_categories < 0 or self.dif_sellers < 0:
 60                raise ValueError("Invalid negative value")
 61            return self
 62
 63    class StreakGoal(BaseBadgeRule):
 64        """Badge rule for a steak of reservations."""
 65
 66        type: Literal["streak"]
 67        streak_days: int = 0
 68        streak_quantity: int = 0
 69
 70        category_id: int | None = None
 71        seller_id: int | None = None
 72
 73        @model_validator(mode="after")
 74        def exclusive_validator(self) -> BadgesConfig.StreakGoal:
 75            """Validates if no conflicting field are set.
 76
 77            Returns:
 78                valid model
 79
 80            Raises:
 81                ValueError: if model is not valid
 82            """
 83            if self.streak_days < 1 and self.streak_quantity < 1:
 84                raise ValueError(
 85                    "Provide 'streak_days' or 'streak_quantity' but not both"
 86                )
 87            if not self.streak_days < 1 and not self.streak_quantity < 1:
 88                raise ValueError("Provide 'streak_days' or 'streak_quantity'")
 89            if self.streak_days < 0 or self.streak_quantity < 0:
 90                raise ValueError("Invalid negative value")
 91            return self
 92
 93    BadgeGoal = Annotated[
 94        QuantityGoal | CO2Goal | DiversityGoal | StreakGoal, Field(discriminator="type")
 95    ]
 96
 97    class BadgeRules(BaseModel):
 98        """Full badge rule set."""
 99
100        badge_id: int
101        badge_name: str | None = None
102        rules: list[BadgesConfig.BadgeGoal]
103
104    class BadgesRules(BaseModel):
105        """Rules for all badges."""
106
107        badges_rules: list[BadgesConfig.BadgeRules]
108
109    badges_rules: BadgesConfig.BadgesRules
110
111    def initialise(self) -> None:
112        """Load badges rules from file.
113
114        Args:
115          self: class instance
116        """
117        with pathlib.Path(badges_settings.rules_path).open(encoding="utf-8") as file:
118            raw_data = yaml.safe_load(file)
119            self.badges_rules = BadgesConfig.BadgesRules.model_validate(raw_data)

Badges config.

BadgeGoal = typing.Annotated[BadgesConfig.QuantityGoal | BadgesConfig.CO2Goal | BadgesConfig.DiversityGoal | BadgesConfig.StreakGoal, FieldInfo(annotation=NoneType, required=True, discriminator='type')]

badges_rules: BadgesConfig.BadgesRules

def initialise(self) -> None: View Source

111    def initialise(self) -> None:
112        """Load badges rules from file.
113
114        Args:
115          self: class instance
116        """
117        with pathlib.Path(badges_settings.rules_path).open(encoding="utf-8") as file:
118            raw_data = yaml.safe_load(file)
119            self.badges_rules = BadgesConfig.BadgesRules.model_validate(raw_data)

Load badges rules from file.

Arguments:

self: class instance

class BadgesConfig.BaseBadgeRule(pydantic.main.BaseModel): View Source

16    class BaseBadgeRule(BaseModel):
17        """Base model for all badge rules."""
18
19        level: int

Base model for all badge rules.

level: int = PydanticUndefined

class BadgesConfig.QuantityGoal(BadgesConfig.BaseBadgeRule): View Source

21    class QuantityGoal(BaseBadgeRule):
22        """Badge rule for quantity."""
23
24        type: Literal["quantity"]
25        quantity: int
26
27        category_id: int | None = None
28        seller_id: int | None = None

Badge rule for quantity.

type: Literal['quantity'] = PydanticUndefined

quantity: int = PydanticUndefined

category_id: int | None = None

seller_id: int | None = None

Inherited Members

BadgesConfig.BaseBadgeRule: level

class BadgesConfig.CO2Goal(BadgesConfig.BaseBadgeRule): View Source

30    class CO2Goal(BaseBadgeRule):
31        """Badge rule for carbon dioxide saving."""
32
33        type: Literal["co2"]
34        carbon_dioxide: float

Badge rule for carbon dioxide saving.

type: Literal['co2'] = PydanticUndefined

carbon_dioxide: float = PydanticUndefined

Inherited Members

BadgesConfig.BaseBadgeRule: level

class BadgesConfig.DiversityGoal(BadgesConfig.BaseBadgeRule): View Source

36    class DiversityGoal(BaseBadgeRule):
37        """Badge rule for diverse reservations."""
38
39        type: Literal["diversity"]
40        dif_categories: int = 0
41        dif_sellers: int = 0
42
43        @model_validator(mode="after")
44        def exclusive_validator(self) -> BadgesConfig.DiversityGoal:
45            """Validates if no conflicting field are set.
46
47            Returns:
48                valid model
49
50            Raises:
51                ValueError: if model is not valid
52            """
53            if self.dif_categories < 1 and self.dif_sellers < 1:
54                raise ValueError(
55                    "Provide 'dif_categories' or 'dif_sellers' but not both"
56                )
57            if not self.dif_categories < 1 and not self.dif_sellers < 1:
58                raise ValueError("Provide 'dif_categories' or 'dif_sellers'")
59            if self.dif_categories < 0 or self.dif_sellers < 0:
60                raise ValueError("Invalid negative value")
61            return self

Badge rule for diverse reservations.

type: Literal['diversity'] = PydanticUndefined

dif_categories: int = 0

dif_sellers: int = 0

@model_validator(mode='after')

def exclusive_validator(self) -> BadgesConfig.DiversityGoal: View Source

43        @model_validator(mode="after")
44        def exclusive_validator(self) -> BadgesConfig.DiversityGoal:
45            """Validates if no conflicting field are set.
46
47            Returns:
48                valid model
49
50            Raises:
51                ValueError: if model is not valid
52            """
53            if self.dif_categories < 1 and self.dif_sellers < 1:
54                raise ValueError(
55                    "Provide 'dif_categories' or 'dif_sellers' but not both"
56                )
57            if not self.dif_categories < 1 and not self.dif_sellers < 1:
58                raise ValueError("Provide 'dif_categories' or 'dif_sellers'")
59            if self.dif_categories < 0 or self.dif_sellers < 0:
60                raise ValueError("Invalid negative value")
61            return self

Validates if no conflicting field are set.

Returns:

valid model

Raises:

ValueError: if model is not valid

Inherited Members

BadgesConfig.BaseBadgeRule: level

class BadgesConfig.StreakGoal(BadgesConfig.BaseBadgeRule): View Source

63    class StreakGoal(BaseBadgeRule):
64        """Badge rule for a steak of reservations."""
65
66        type: Literal["streak"]
67        streak_days: int = 0
68        streak_quantity: int = 0
69
70        category_id: int | None = None
71        seller_id: int | None = None
72
73        @model_validator(mode="after")
74        def exclusive_validator(self) -> BadgesConfig.StreakGoal:
75            """Validates if no conflicting field are set.
76
77            Returns:
78                valid model
79
80            Raises:
81                ValueError: if model is not valid
82            """
83            if self.streak_days < 1 and self.streak_quantity < 1:
84                raise ValueError(
85                    "Provide 'streak_days' or 'streak_quantity' but not both"
86                )
87            if not self.streak_days < 1 and not self.streak_quantity < 1:
88                raise ValueError("Provide 'streak_days' or 'streak_quantity'")
89            if self.streak_days < 0 or self.streak_quantity < 0:
90                raise ValueError("Invalid negative value")
91            return self

Badge rule for a steak of reservations.

type: Literal['streak'] = PydanticUndefined

streak_days: int = 0

streak_quantity: int = 0

category_id: int | None = None

seller_id: int | None = None

@model_validator(mode='after')

def exclusive_validator(self) -> BadgesConfig.StreakGoal: View Source

73        @model_validator(mode="after")
74        def exclusive_validator(self) -> BadgesConfig.StreakGoal:
75            """Validates if no conflicting field are set.
76
77            Returns:
78                valid model
79
80            Raises:
81                ValueError: if model is not valid
82            """
83            if self.streak_days < 1 and self.streak_quantity < 1:
84                raise ValueError(
85                    "Provide 'streak_days' or 'streak_quantity' but not both"
86                )
87            if not self.streak_days < 1 and not self.streak_quantity < 1:
88                raise ValueError("Provide 'streak_days' or 'streak_quantity'")
89            if self.streak_days < 0 or self.streak_quantity < 0:
90                raise ValueError("Invalid negative value")
91            return self

Validates if no conflicting field are set.

Returns:

valid model

Raises:

ValueError: if model is not valid

Inherited Members

BadgesConfig.BaseBadgeRule: level

class BadgesConfig.BadgeRules(pydantic.main.BaseModel): View Source

 97    class BadgeRules(BaseModel):
 98        """Full badge rule set."""
 99
100        badge_id: int
101        badge_name: str | None = None
102        rules: list[BadgesConfig.BadgeGoal]

Full badge rule set.

badge_id: int = PydanticUndefined

badge_name: str | None = None

rules: list[typing.Annotated[BadgesConfig.QuantityGoal | BadgesConfig.CO2Goal | BadgesConfig.DiversityGoal | BadgesConfig.StreakGoal, FieldInfo(annotation=NoneType, required=True, discriminator='type')]] = PydanticUndefined

class BadgesConfig.BadgesRules(pydantic.main.BaseModel): View Source

104    class BadgesRules(BaseModel):
105        """Rules for all badges."""
106
107        badges_rules: list[BadgesConfig.BadgeRules]

Rules for all badges.

badges_rules: list[BadgesConfig.BadgeRules] = PydanticUndefined

badges_config = <BadgesConfig object>