Skip to content

edsnlp.pipelines.ner.scores.tnm.models

TnmEnum

Bases: Enum

Source code in edsnlp/pipelines/ner/scores/tnm/models.py 
16
17
18
class TnmEnum(Enum):
    def __str__(self) -> str:
        return self.value

__str__()

Source code in edsnlp/pipelines/ner/scores/tnm/models.py 
17
18
def __str__(self) -> str:
    return self.value

Modifier

Bases: TnmEnum

Source code in edsnlp/pipelines/ner/scores/tnm/models.py 
21
22
23
24
25
26
27
28
29
30
31
class Modifier(TnmEnum):
    clinical = "c"
    histopathology = "p"
    histopathology2 = "P"
    neoadjuvant_therapy = "y"
    recurrent = "r"
    autopsy = "a"
    ultrasonography = "u"
    multifocal = "m"
    py = "yp"
    mp = "mp"

clinical = 'c' class-attribute

histopathology = 'p' class-attribute

histopathology2 = 'P' class-attribute

neoadjuvant_therapy = 'y' class-attribute

recurrent = 'r' class-attribute

autopsy = 'a' class-attribute

ultrasonography = 'u' class-attribute

multifocal = 'm' class-attribute

py = 'yp' class-attribute

mp = 'mp' class-attribute

Tumour

Bases: TnmEnum

Source code in edsnlp/pipelines/ner/scores/tnm/models.py 
34
35
36
37
38
39
40
41
42
class Tumour(TnmEnum):
    unknown = "x"
    in_situ = "is"
    score_0 = "0"
    score_1 = "1"
    score_2 = "2"
    score_3 = "3"
    score_4 = "4"
    o = "o"

unknown = 'x' class-attribute

in_situ = 'is' class-attribute

score_0 = '0' class-attribute

score_1 = '1' class-attribute

score_2 = '2' class-attribute

score_3 = '3' class-attribute

score_4 = '4' class-attribute

o = 'o' class-attribute

Specification

Bases: TnmEnum

Source code in edsnlp/pipelines/ner/scores/tnm/models.py 
45
46
47
48
49
50
class Specification(TnmEnum):
    a = "a"
    b = "b"
    c = "c"
    d = "d"
    x = "x"

a = 'a' class-attribute

b = 'b' class-attribute

c = 'c' class-attribute

d = 'd' class-attribute

x = 'x' class-attribute

Node

Bases: TnmEnum

Source code in edsnlp/pipelines/ner/scores/tnm/models.py 
53
54
55
56
57
58
59
class Node(TnmEnum):
    unknown = "x"
    score_0 = "0"
    score_1 = "1"
    score_2 = "2"
    score_3 = "3"
    o = "o"

unknown = 'x' class-attribute

score_0 = '0' class-attribute

score_1 = '1' class-attribute

score_2 = '2' class-attribute

score_3 = '3' class-attribute

o = 'o' class-attribute

Metastasis

Bases: TnmEnum

Source code in edsnlp/pipelines/ner/scores/tnm/models.py 
62
63
64
65
66
67
68
69
class Metastasis(TnmEnum):
    unknown = "x"
    score_0 = "0"
    score_1 = "1"
    o = "o"
    score_1x = "1x"
    score_2x = "2x"
    ox = "ox"

unknown = 'x' class-attribute

score_0 = '0' class-attribute

score_1 = '1' class-attribute

o = 'o' class-attribute

score_1x = '1x' class-attribute

score_2x = '2x' class-attribute

ox = 'ox' class-attribute

TNM

Bases: BaseModel

Source code in edsnlp/pipelines/ner/scores/tnm/models.py 
 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
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
class TNM(BaseModel):

    modifier: Optional[Modifier] = None
    tumour: Optional[Tumour] = None
    tumour_specification: Optional[Specification] = None
    node: Optional[Node] = None
    node_specification: Optional[Specification] = None
    metastasis: Optional[Metastasis] = None
    regional_nodes: Optional[int] = None
    version: Optional[str] = None
    version_year: Optional[int] = None

    @validator("*", pre=True)
    def coerce_o(cls, v):
        if isinstance(v, str):
            v = v.replace("o", "0")
        return v

    @validator("version_year")
    def validate_year(cls, v):
        if v is None:
            return v

        if v < 40:
            v += 2000
        elif v < 100:
            v += 1900

        return v

    def norm(self) -> str:
        norm = []

        if self.modifier is not None:
            norm.append(str(self.modifier))

        if (self.tumour is not None) | (self.tumour_specification is not None):
            norm.append(
                f"T{str(self.tumour or '')}{str(self.tumour_specification or '')}"
            )

        if (self.node is not None) | (self.node_specification is not None):
            norm.append(f"N{str(self.node or '')}{str(self.node_specification or '')}")

        if self.metastasis is not None:
            norm.append(f"M{self.metastasis}")

        if self.regional_nodes is not None:
            norm.append(f"R{self.regional_nodes}")

        if self.version is not None and self.version_year is not None:
            norm.append(f" ({self.version.upper()} {self.version_year})")

        return "".join(norm)

    def dict(
        self,
        *,
        include: Union["AbstractSetIntStr", "MappingIntStrAny"] = None,
        exclude: Union["AbstractSetIntStr", "MappingIntStrAny"] = None,
        by_alias: bool = False,
        skip_defaults: bool = None,
        exclude_unset: bool = False,
        exclude_defaults: bool = False,
        exclude_none: bool = False,
    ) -> "DictStrAny":
        """
        Generate a dictionary representation of the model,
        optionally specifying which fields to include or exclude.

        """
        if skip_defaults is not None:
            warnings.warn(
                f"""{self.__class__.__name__}.dict(): "skip_defaults"
                is deprecated and replaced by "exclude_unset" """,
                DeprecationWarning,
            )
            exclude_unset = skip_defaults

        d = dict(
            self._iter(
                to_dict=True,
                by_alias=by_alias,
                include=include,
                exclude=exclude,
                exclude_unset=exclude_unset,
                exclude_defaults=exclude_defaults,
                exclude_none=exclude_none,
            )
        )
        set_keys = set(d.keys())
        for k in set_keys.intersection(
            {
                "modifier",
                "tumour",
                "node",
                "metastasis",
                "tumour_specification",
                "node_specification",
            }
        ):
            v = d[k]
            if isinstance(v, TnmEnum):
                d[k] = v.value

        return d

modifier: Optional[Modifier] = None class-attribute

tumour: Optional[Tumour] = None class-attribute

tumour_specification: Optional[Specification] = None class-attribute

node: Optional[Node] = None class-attribute

node_specification: Optional[Specification] = None class-attribute

metastasis: Optional[Metastasis] = None class-attribute

regional_nodes: Optional[int] = None class-attribute

version: Optional[str] = None class-attribute

version_year: Optional[int] = None class-attribute

coerce_o(v)

Source code in edsnlp/pipelines/ner/scores/tnm/models.py 
84
85
86
87
88
@validator("*", pre=True)
def coerce_o(cls, v):
    if isinstance(v, str):
        v = v.replace("o", "0")
    return v

validate_year(v)

Source code in edsnlp/pipelines/ner/scores/tnm/models.py 
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
@validator("version_year")
def validate_year(cls, v):
    if v is None:
        return v

    if v < 40:
        v += 2000
    elif v < 100:
        v += 1900

    return v

norm()

Source code in edsnlp/pipelines/ner/scores/tnm/models.py 
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
def norm(self) -> str:
    norm = []

    if self.modifier is not None:
        norm.append(str(self.modifier))

    if (self.tumour is not None) | (self.tumour_specification is not None):
        norm.append(
            f"T{str(self.tumour or '')}{str(self.tumour_specification or '')}"
        )

    if (self.node is not None) | (self.node_specification is not None):
        norm.append(f"N{str(self.node or '')}{str(self.node_specification or '')}")

    if self.metastasis is not None:
        norm.append(f"M{self.metastasis}")

    if self.regional_nodes is not None:
        norm.append(f"R{self.regional_nodes}")

    if self.version is not None and self.version_year is not None:
        norm.append(f" ({self.version.upper()} {self.version_year})")

    return "".join(norm)

dict(*, include=None, exclude=None, by_alias=False, skip_defaults=None, exclude_unset=False, exclude_defaults=False, exclude_none=False)

Generate a dictionary representation of the model, optionally specifying which fields to include or exclude.

Source code in edsnlp/pipelines/ner/scores/tnm/models.py 
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
def dict(
    self,
    *,
    include: Union["AbstractSetIntStr", "MappingIntStrAny"] = None,
    exclude: Union["AbstractSetIntStr", "MappingIntStrAny"] = None,
    by_alias: bool = False,
    skip_defaults: bool = None,
    exclude_unset: bool = False,
    exclude_defaults: bool = False,
    exclude_none: bool = False,
) -> "DictStrAny":
    """
    Generate a dictionary representation of the model,
    optionally specifying which fields to include or exclude.

    """
    if skip_defaults is not None:
        warnings.warn(
            f"""{self.__class__.__name__}.dict(): "skip_defaults"
            is deprecated and replaced by "exclude_unset" """,
            DeprecationWarning,
        )
        exclude_unset = skip_defaults

    d = dict(
        self._iter(
            to_dict=True,
            by_alias=by_alias,
            include=include,
            exclude=exclude,
            exclude_unset=exclude_unset,
            exclude_defaults=exclude_defaults,
            exclude_none=exclude_none,
        )
    )
    set_keys = set(d.keys())
    for k in set_keys.intersection(
        {
            "modifier",
            "tumour",
            "node",
            "metastasis",
            "tumour_specification",
            "node_specification",
        }
    ):
        v = d[k]
        if isinstance(v, TnmEnum):
            d[k] = v.value

    return d