cloudfloordns.models.zone 

 1# from dataclasses import dataclass, field
 2from typing import List, Optional, Union
 3
 4from pydantic import AliasChoices, BaseModel, Field, StringConstraints
 5from typing_extensions import Annotated
 6
 7DEFAULT_PRIMARY_NS = "ns1.g02.cfdns.net"
 8
 9
10class DomainDescription(BaseModel):
11    """
12    Pydantic model
13    """
14
15    status: Optional[str]
16    status_extended: Optional[str]
17
18    class Config:
19        extra = "allow"
20
21
22class Zone(BaseModel):
23    """
24    Pydantic model
25    """
26
27    domainname: Annotated[str, StringConstraints(strip_whitespace=True)]
28
29    id: Optional[str] = None
30    zone: Optional[str] = None
31    registered: Optional[int] = None
32    secondary: Optional[int] = None
33    primary: Optional[int] = None
34    domain_description: Optional[DomainDescription] = None
35    group_ids: Optional[List[str]] = None
36
37    class Config:
38        populate_by_name = True
39        extra = "allow"
40
41    def __hash__(self):
42        return hash(self.domainname)
43
44    def __eq__(self, op):
45        return self.is_same(op)
46
47    def is_same(self, right: Union[str, "Zone"]) -> bool:
48        """
49        This method check the identity
50        """
51        if not isinstance(right, (Zone, str)):
52            return NotImplemented
53        if isinstance(right, Zone):
54            right = right.domainname
55        return self.domainname == right
56
57    @property
58    def normalized_name(self) -> Optional[str]:
59        name = self.domainname
60        return ".".join(p.strip() for p in name.lower().split("."))
61
62
63class Redirect(BaseModel):
64    """
65    Pydantic model
66    """
67
68    name: str = Field(validation_alias=AliasChoices("name", "source", "src"))
69    dst: str = Field(
70        validation_alias=AliasChoices(
71            "forwardto", "destination", "dst", "dest", "target"
72        )
73    )
74    zone: Optional[str] = None
DEFAULT_PRIMARY_NS = 'ns1.g02.cfdns.net'
class DomainDescription(pydantic.main.BaseModel): 
11class DomainDescription(BaseModel):
12    """
13    Pydantic model
14    """
15
16    status: Optional[str]
17    status_extended: Optional[str]
18
19    class Config:
20        extra = "allow"

Pydantic model

status: Optional[str]
status_extended: Optional[str]
model_config: ClassVar[pydantic.config.ConfigDict] = {'extra': 'allow'}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class DomainDescription.Config: 
19    class Config:
20        extra = "allow"
extra = 'allow'
class Zone(pydantic.main.BaseModel): 
23class Zone(BaseModel):
24    """
25    Pydantic model
26    """
27
28    domainname: Annotated[str, StringConstraints(strip_whitespace=True)]
29
30    id: Optional[str] = None
31    zone: Optional[str] = None
32    registered: Optional[int] = None
33    secondary: Optional[int] = None
34    primary: Optional[int] = None
35    domain_description: Optional[DomainDescription] = None
36    group_ids: Optional[List[str]] = None
37
38    class Config:
39        populate_by_name = True
40        extra = "allow"
41
42    def __hash__(self):
43        return hash(self.domainname)
44
45    def __eq__(self, op):
46        return self.is_same(op)
47
48    def is_same(self, right: Union[str, "Zone"]) -> bool:
49        """
50        This method check the identity
51        """
52        if not isinstance(right, (Zone, str)):
53            return NotImplemented
54        if isinstance(right, Zone):
55            right = right.domainname
56        return self.domainname == right
57
58    @property
59    def normalized_name(self) -> Optional[str]:
60        name = self.domainname
61        return ".".join(p.strip() for p in name.lower().split("."))

Pydantic model

domainname: typing.Annotated[str, StringConstraints(strip_whitespace=True, to_upper=None, to_lower=None, strict=None, min_length=None, max_length=None, pattern=None)]
id: Optional[str]
zone: Optional[str]
registered: Optional[int]
secondary: Optional[int]
primary: Optional[int]
domain_description: Optional[DomainDescription]
group_ids: Optional[List[str]]
def is_same(self, right: Union[str, Zone]) -> bool: 
48    def is_same(self, right: Union[str, "Zone"]) -> bool:
49        """
50        This method check the identity
51        """
52        if not isinstance(right, (Zone, str)):
53            return NotImplemented
54        if isinstance(right, Zone):
55            right = right.domainname
56        return self.domainname == right

This method check the identity

normalized_name: Optional[str] 
58    @property
59    def normalized_name(self) -> Optional[str]:
60        name = self.domainname
61        return ".".join(p.strip() for p in name.lower().split("."))
model_config: ClassVar[pydantic.config.ConfigDict] = {'extra': 'allow', 'populate_by_name': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class Zone.Config: 
38    class Config:
39        populate_by_name = True
40        extra = "allow"
populate_by_name = True
extra = 'allow'
class Redirect(pydantic.main.BaseModel): 
64class Redirect(BaseModel):
65    """
66    Pydantic model
67    """
68
69    name: str = Field(validation_alias=AliasChoices("name", "source", "src"))
70    dst: str = Field(
71        validation_alias=AliasChoices(
72            "forwardto", "destination", "dst", "dest", "target"
73        )
74    )
75    zone: Optional[str] = None

Pydantic model

name: str
dst: str
zone: Optional[str]
model_config: ClassVar[pydantic.config.ConfigDict] = {}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].