Skip to content

edsnlp.pipelines.core.contextual_matcher.models

Flags = Union[re.RegexFlag, int] module-attribute

Window = Union[Tuple[int, int], List[int], int] module-attribute

SingleExcludeModel

Bases: BaseModel

Source code in edsnlp/pipelines/core/contextual_matcher/models.py 
32
33
34
35
36
37
38
39
40
41
42
43
class SingleExcludeModel(BaseModel):
    regex: ListOrStr = []
    window: Window
    regex_flags: Optional[Flags] = None

    @validator("regex")
    def exclude_regex_validation(cls, v):
        if type(v) == str:
            v = [v]
        return v

    _normalize_window = validator("window", allow_reuse=True)(normalize_window)

regex: ListOrStr = [] class-attribute

window: Window = None class-attribute

regex_flags: Optional[Flags] = None class-attribute

exclude_regex_validation(v)

Source code in edsnlp/pipelines/core/contextual_matcher/models.py 
37
38
39
40
41
@validator("regex")
def exclude_regex_validation(cls, v):
    if type(v) == str:
        v = [v]
    return v

ExcludeModel

Bases: BaseModel

Source code in edsnlp/pipelines/core/contextual_matcher/models.py 
46
47
48
49
50
51
52
53
54
55
56
57
class ExcludeModel(BaseModel, extra=Extra.forbid):

    __root__: Union[
        List[SingleExcludeModel],
        SingleExcludeModel,
    ]

    @validator("__root__", pre=True)
    def item_to_list(cls, v):
        if not isinstance(v, list):
            return [v]
        return v

__root__: Union[List[SingleExcludeModel], SingleExcludeModel] = None class-attribute

item_to_list(v)

Source code in edsnlp/pipelines/core/contextual_matcher/models.py 
53
54
55
56
57
@validator("__root__", pre=True)
def item_to_list(cls, v):
    if not isinstance(v, list):
        return [v]
    return v

SingleAssignModel

Bases: BaseModel

Source code in edsnlp/pipelines/core/contextual_matcher/models.py 
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
class SingleAssignModel(BaseModel):
    name: str
    regex: str
    window: Window
    regex_flags: Optional[Flags] = None
    expand_entity: bool = False

    @validator("regex")
    def check_single_regex_group(cls, pat):
        compiled_pat = re.compile(pat)
        n_groups = compiled_pat.groups
        assert n_groups == 1, (
            "The pattern {pat} should have only one" "capturing group, not {n_groups}"
        ).format(
            pat=pat,
            n_groups=n_groups,
        )

        return pat

    _normalize_window = validator("window", allow_reuse=True)(normalize_window)

name: str = None class-attribute

regex: str = None class-attribute

window: Window = None class-attribute

regex_flags: Optional[Flags] = None class-attribute

expand_entity: bool = False class-attribute

check_single_regex_group(pat)

Source code in edsnlp/pipelines/core/contextual_matcher/models.py 
67
68
69
70
71
72
73
74
75
76
77
78
@validator("regex")
def check_single_regex_group(cls, pat):
    compiled_pat = re.compile(pat)
    n_groups = compiled_pat.groups
    assert n_groups == 1, (
        "The pattern {pat} should have only one" "capturing group, not {n_groups}"
    ).format(
        pat=pat,
        n_groups=n_groups,
    )

    return pat

AssignModel

Bases: BaseModel

Source code in edsnlp/pipelines/core/contextual_matcher/models.py 
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
class AssignModel(BaseModel, extra=Extra.forbid):

    __root__: Union[
        List[SingleAssignModel],
        SingleAssignModel,
    ]

    @validator("__root__", pre=True)
    def item_to_list(cls, v):
        if not isinstance(v, list):
            return [v]
        return v

    @validator("__root__")
    def name_uniqueness(cls, v):
        names = [item.name for item in v]
        assert len(names) == len(set(names)), "Each `name` field should be unique"
        return v

__root__: Union[List[SingleAssignModel], SingleAssignModel] = None class-attribute

item_to_list(v)

Source code in edsnlp/pipelines/core/contextual_matcher/models.py 
90
91
92
93
94
@validator("__root__", pre=True)
def item_to_list(cls, v):
    if not isinstance(v, list):
        return [v]
    return v

name_uniqueness(v)

Source code in edsnlp/pipelines/core/contextual_matcher/models.py 
 96
 97
 98
 99
100
@validator("__root__")
def name_uniqueness(cls, v):
    names = [item.name for item in v]
    assert len(names) == len(set(names)), "Each `name` field should be unique"
    return v

SingleConfig

Bases: BaseModel

Source code in edsnlp/pipelines/core/contextual_matcher/models.py 
103
104
105
106
107
108
109
110
111
class SingleConfig(BaseModel, extra=Extra.forbid):

    source: str
    terms: ListOrStr = []
    regex: ListOrStr = []
    regex_attr: Optional[str] = None
    regex_flags: Union[re.RegexFlag, int] = None
    exclude: Optional[ExcludeModel] = []
    assign: Optional[AssignModel] = []

source: str = None class-attribute

terms: ListOrStr = [] class-attribute

regex: ListOrStr = [] class-attribute

regex_attr: Optional[str] = None class-attribute

regex_flags: Union[re.RegexFlag, int] = None class-attribute

exclude: Optional[ExcludeModel] = [] class-attribute

assign: Optional[AssignModel] = [] class-attribute

FullConfig

Bases: BaseModel

Source code in edsnlp/pipelines/core/contextual_matcher/models.py 
114
115
116
117
118
119
120
121
122
123
124
125
class FullConfig(BaseModel, extra=Extra.forbid):

    __root__: Union[
        List[SingleConfig],
        SingleConfig,
    ]

    @validator("__root__", pre=True)
    def pattern_to_list(cls, v):
        if not isinstance(v, list):
            return [v]
        return v

__root__: Union[List[SingleConfig], SingleConfig] = None class-attribute

pattern_to_list(v)

Source code in edsnlp/pipelines/core/contextual_matcher/models.py 
121
122
123
124
125
@validator("__root__", pre=True)
def pattern_to_list(cls, v):
    if not isinstance(v, list):
        return [v]
    return v

normalize_window(cls, v)

Source code in edsnlp/pipelines/core/contextual_matcher/models.py 
16
17
18
19
20
21
22
23
24
25
26
27
28
29
def normalize_window(cls, v):
    if isinstance(v, list):
        assert (
            len(v) == 2
        ), "`window` should be a tuple/list of two integer, or a single integer"
        v = tuple(v)
    if isinstance(v, int):
        assert v != 0, "The provided `window` should not be 0"
        if v < 0:
            return (v, 0)
        if v > 0:
            return (0, v)
    assert v[0] < v[1], "The provided `window` should contain at least 1 token"
    return v