Skip to content

Identifiers

rigour.ids

Handling of person, organisation and object identifiers. This module contains a collection of validation and formatting tools for identifiers. The IdentifierFormat class is the base class for all identifier formats, and it provides a common interface for validation and formatting.

Currently, identifers can be accessed using short aliases, such as "imo" or "isin". In the future, we will need to introduce a proper, structured identification scheme for identifiers, with qualifiers for country (e.g. ru:nalog:inn, us:sam:uei).

BIC

Bases: IdentifierFormat

BIC (ISO 9362 Business identifier codes).

Source code in rigour/ids/stdnum_.py 
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
class BIC(IdentifierFormat):
    """BIC (ISO 9362 Business identifier codes)."""

    NAME = "bic"
    TITLE = "BIC"
    STRONG = True

    @classmethod
    def is_valid(cls, value: str) -> bool:
        return bic.is_valid(value)

    @classmethod
    def normalize(cls, value: str) -> str | None:
        try:
            norm = bic.compact(bic.validate(value))
            norm = norm[:8].upper()
            if not cls.is_valid(norm):
                return None
            return norm
        except ValidationError:
            return None

    @classmethod
    def format(cls, value: str) -> str:
        return bic.format(value)

CNPJ

Bases: IdentifierFormat

Cadastro Nacional de Pessoas Jurídicas, Brazilian national companies identifier

Source code in rigour/ids/stdnum_.py 
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
class CNPJ(IdentifierFormat):
    """Cadastro Nacional de Pessoas Jurídicas, Brazilian national companies identifier"""

    NAME = "cnpj"
    TITLE = "CNPJ"
    STRONG = True

    @classmethod
    def is_valid(cls, value: str) -> bool:
        return cnpj.is_valid(value)

    @classmethod
    def normalize(cls, value: str) -> str | None:
        try:
            return cnpj.compact(cnpj.validate(value))
        except ValidationError:
            return None

    @classmethod
    def format(cls, value: str) -> str:
        return cnpj.format(value)

CPF

Bases: IdentifierFormat

Cadastro de Pessoas Físicas, Brazilian national identifier

Source code in rigour/ids/stdnum_.py 
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
class CPF(IdentifierFormat):
    """Cadastro de Pessoas Físicas, Brazilian national identifier"""

    NAME = "cpf"
    TITLE = "CPF"

    @classmethod
    def is_valid(cls, value: str) -> bool:
        return cpf.is_valid(value)

    @classmethod
    def normalize(cls, value: str) -> str | None:
        try:
            return cpf.compact(cpf.validate(value))
        except ValidationError:
            return None

    @classmethod
    def format(cls, value: str) -> str:
        return cpf.format(value)

FIGI

Bases: IdentifierFormat

A FIGI number for a security, as managed by OpenFIGI.

Source code in rigour/ids/stdnum_.py 
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
class FIGI(IdentifierFormat):
    """A FIGI number for a security, as managed by OpenFIGI."""

    NAME = "figi"
    TITLE = "FIGI"
    STRONG = True

    impl = figi

    @classmethod
    def is_valid(cls, value: str) -> bool:
        return figi.is_valid(value)

    @classmethod
    def normalize(cls, value: str) -> str | None:
        try:
            return figi.compact(figi.validate(value))
        except ValidationError:
            return None

FormatSpec

Bases: TypedDict

An identifier format specification.

Source code in rigour/ids/__init__.py 
54
55
56
57
58
59
60
class FormatSpec(TypedDict):
    """An identifier format specification."""

    name: str
    title: str
    description: str
    strong: bool

IBAN

Bases: IdentifierFormat

An IBAN number for a bank account.

Source code in rigour/ids/stdnum_.py 
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
class IBAN(IdentifierFormat):
    """An IBAN number for a bank account."""

    NAME = "iban"
    TITLE = "IBAN"
    STRONG = True

    @classmethod
    def is_valid(cls, value: str) -> bool:
        return iban.is_valid(value)

    @classmethod
    def normalize(cls, value: str) -> str | None:
        try:
            return iban.compact(iban.validate(value))
        except ValidationError:
            return None

    @classmethod
    def format(cls, value: str) -> str:
        return iban.format(value)

IMO

Bases: IdentifierFormat

An IMO number for a ship or a shipping company.

Ship and company IMO numbers are both seven digits but use different check digit algorithms; this format admits both. Use is_valid_vessel or is_valid_company when the value must belong to one specific scheme, e.g. when minting scheme-specific entity IDs.

Extraction considers digit runs of five to seven digits, preferring longer runs, then runs carrying an IMO prefix, then earlier ones; the first candidate that passes a checksum wins. Runs shorter than seven digits are left-padded with zeros, since data sources commonly strip leading zeros from IMO fields. The all-zero value is rejected.

Source code in rigour/ids/imo.py 
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 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
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
class IMO(IdentifierFormat):
    """An IMO number for a ship or a shipping company.

    Ship and company IMO numbers are both seven digits but use different check
    digit algorithms; this format admits both. Use
    [is_valid_vessel][rigour.ids.imo.IMO.is_valid_vessel] or
    [is_valid_company][rigour.ids.imo.IMO.is_valid_company] when the value
    must belong to one specific scheme, e.g. when minting scheme-specific
    entity IDs.

    Extraction considers digit runs of five to seven digits, preferring longer
    runs, then runs carrying an `IMO` prefix, then earlier ones; the first
    candidate that passes a checksum wins. Runs shorter than seven digits are
    left-padded with zeros, since data sources commonly strip leading zeros
    from IMO fields. The all-zero value is rejected.
    """

    NAME = "imo"
    TITLE = "IMO"
    STRONG = True

    @classmethod
    def is_valid(cls, text: str) -> bool:
        """Determine if the given text contains a valid IMO number.

        Args:
            text: A string that may contain an IMO number.

        Returns:
            True if an IMO number valid in either checksum scheme can be
            extracted from the text.
        """
        return cls._extract(text, (_vessel_checksum, _company_checksum)) is not None

    @classmethod
    def is_valid_vessel(cls, text: str) -> bool:
        """Determine if the given text contains a valid ship IMO number.

        Args:
            text: A string that may contain an IMO number.

        Returns:
            True if an IMO number valid in the vessel checksum scheme can be
            extracted from the text.
        """
        return cls._extract(text, (_vessel_checksum,)) is not None

    @classmethod
    def is_valid_company(cls, text: str) -> bool:
        """Determine if the given text contains a valid company IMO number.

        Args:
            text: A string that may contain an IMO number.

        Returns:
            True if an IMO number valid in the company checksum scheme can be
            extracted from the text.
        """
        return cls._extract(text, (_company_checksum,)) is not None

    @classmethod
    def normalize(cls, text: str) -> str | None:
        """Extract and normalize an IMO number from the given text.

        Args:
            text: A string that may contain an IMO number.

        Returns:
            The number in `IMO0000000` form, or None if the text contains no
            checksum-valid IMO number.
        """
        value = cls._extract(text, (_vessel_checksum, _company_checksum))
        if value is None:
            return None
        return f"IMO{value}"

    @classmethod
    def _extract(cls, text: str, checksums: tuple[Checksum, ...]) -> str | None:
        matches = sorted(
            IMO_RE.finditer(text),
            key=lambda m: (-len(m.group(2)), m.group(1) is None, m.start()),
        )
        for match in matches:
            value = match.group(2).zfill(7)
            digits = [int(d) for d in value]
            if not any(digits):
                continue
            if any(check(digits) for check in checksums):
                return value
        return None

    @classmethod
    def format(cls, value: str) -> str:
        """Format the given value as an IMO number.

        Args:
            value: A pre-validated IMO number.

        Returns:
            The value with an `IMO` prefix.
        """
        value = value.replace(" ", "")
        if not value.startswith("IMO"):
            value = f"IMO{value}"
        return value

format(value) classmethod

Format the given value as an IMO number.

Parameters:

Name Type Description Default
value str

A pre-validated IMO number.

 required

Returns:

Type Description
str

The value with an IMO prefix.
Source code in rigour/ids/imo.py 
112
113
114
115
116
117
118
119
120
121
122
123
124
125
@classmethod
def format(cls, value: str) -> str:
    """Format the given value as an IMO number.

    Args:
        value: A pre-validated IMO number.

    Returns:
        The value with an `IMO` prefix.
    """
    value = value.replace(" ", "")
    if not value.startswith("IMO"):
        value = f"IMO{value}"
    return value

is_valid(text) classmethod

Determine if the given text contains a valid IMO number.

Parameters:

Name Type Description Default
text str

A string that may contain an IMO number.

 required

Returns:

Type Description
bool

True if an IMO number valid in either checksum scheme can be
bool

extracted from the text.
Source code in rigour/ids/imo.py 
42
43
44
45
46
47
48
49
50
51
52
53
@classmethod
def is_valid(cls, text: str) -> bool:
    """Determine if the given text contains a valid IMO number.

    Args:
        text: A string that may contain an IMO number.

    Returns:
        True if an IMO number valid in either checksum scheme can be
        extracted from the text.
    """
    return cls._extract(text, (_vessel_checksum, _company_checksum)) is not None

is_valid_company(text) classmethod

Determine if the given text contains a valid company IMO number.

Parameters:

Name Type Description Default
text str

A string that may contain an IMO number.

 required

Returns:

Type Description
bool

True if an IMO number valid in the company checksum scheme can be
bool

extracted from the text.
Source code in rigour/ids/imo.py 
68
69
70
71
72
73
74
75
76
77
78
79
@classmethod
def is_valid_company(cls, text: str) -> bool:
    """Determine if the given text contains a valid company IMO number.

    Args:
        text: A string that may contain an IMO number.

    Returns:
        True if an IMO number valid in the company checksum scheme can be
        extracted from the text.
    """
    return cls._extract(text, (_company_checksum,)) is not None

is_valid_vessel(text) classmethod

Determine if the given text contains a valid ship IMO number.

Parameters:

Name Type Description Default
text str

A string that may contain an IMO number.

 required

Returns:

Type Description
bool

True if an IMO number valid in the vessel checksum scheme can be
bool

extracted from the text.
Source code in rigour/ids/imo.py 
55
56
57
58
59
60
61
62
63
64
65
66
@classmethod
def is_valid_vessel(cls, text: str) -> bool:
    """Determine if the given text contains a valid ship IMO number.

    Args:
        text: A string that may contain an IMO number.

    Returns:
        True if an IMO number valid in the vessel checksum scheme can be
        extracted from the text.
    """
    return cls._extract(text, (_vessel_checksum,)) is not None

normalize(text) classmethod

Extract and normalize an IMO number from the given text.

Parameters:

Name Type Description Default
text str

A string that may contain an IMO number.

 required

Returns:

Type Description
str | None

The number in IMO0000000 form, or None if the text contains no
str | None

checksum-valid IMO number.
Source code in rigour/ids/imo.py 
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
@classmethod
def normalize(cls, text: str) -> str | None:
    """Extract and normalize an IMO number from the given text.

    Args:
        text: A string that may contain an IMO number.

    Returns:
        The number in `IMO0000000` form, or None if the text contains no
        checksum-valid IMO number.
    """
    value = cls._extract(text, (_vessel_checksum, _company_checksum))
    if value is None:
        return None
    return f"IMO{value}"

INN

Bases: IdentifierFormat

Russian tax identification number.

Source code in rigour/ids/stdnum_.py 
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
class INN(IdentifierFormat):
    """Russian tax identification number."""

    NAME = "inn"
    TITLE = "INN"
    STRONG = True

    @classmethod
    def is_valid(cls, value: str) -> bool:
        return inn.is_valid(value)

    @classmethod
    def normalize(cls, value: str) -> str | None:
        try:
            return inn.compact(inn.validate(value))
        except ValidationError:
            return None

ISIN

Bases: IdentifierFormat

An ISIN number for a security.

Source code in rigour/ids/stdnum_.py 
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
class ISIN(IdentifierFormat):
    """An ISIN number for a security."""

    NAME = "isin"
    TITLE = "ISIN"
    STRONG = True

    @classmethod
    def is_valid(cls, value: str) -> bool:
        return isin.is_valid(value)

    @classmethod
    def normalize(cls, value: str) -> str | None:
        try:
            return isin.compact(isin.validate(value))
        except ValidationError:
            return None

IdentifierFormat

Base class for identifier types.

Source code in rigour/ids/common.py 
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
class IdentifierFormat:
    """Base class for identifier types."""

    NAME: str = "generic"
    TITLE: str = "Generic identifier"
    STRONG: bool = False

    @classmethod
    def is_valid(cls, value: str) -> bool:
        norm = cls.normalize(value)
        return norm is not None and len(norm) > 0

    @classmethod
    def normalize(cls, value: str) -> str | None:
        return value.strip()

    @classmethod
    def format(cls, value: str) -> str:
        return value.upper()

LEI

Bases: IdentifierFormat

Legal Entity Identifier (ISO 17442)

Source code in rigour/ids/stdnum_.py 
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
class LEI(IdentifierFormat):
    """Legal Entity Identifier (ISO 17442)"""

    NAME = "lei"
    TITLE = "LEI"
    STRONG = True

    @classmethod
    def is_valid(cls, value: str) -> bool:
        return lei.is_valid(value)

    @classmethod
    def normalize(cls, value: str) -> str | None:
        try:
            return lei.compact(lei.validate(value))
        except ValidationError:
            return None

NPI

Bases: IdentifierFormat

National Provider Identifier.

Source code in rigour/ids/npi.py 
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
class NPI(IdentifierFormat):
    """National Provider Identifier."""

    NAME = "npi"
    TITLE = "NPI"
    STRONG = True

    # cf. https://www.johndcook.com/blog/2024/06/26/npi-number/

    @classmethod
    def is_valid(cls, text: str) -> bool:
        """Determine if the given string is a valid NPI."""
        if NPI_RE.match(text) is None:
            return False

        if text in INVALID:
            return False

        if len(text) == 10:
            text = "80840" + text

        return bool(luhn.is_valid(text))

    @classmethod
    def normalize(cls, text: str) -> str | None:
        """Normalize the given string to a valid NPI."""
        match = NPI_RE.search(text)
        if match is None:
            return None
        value = match.group(1)
        if cls.is_valid(value) and value not in INVALID:
            return value
        return None

is_valid(text) classmethod

Determine if the given string is a valid NPI.

Source code in rigour/ids/npi.py 
20
21
22
23
24
25
26
27
28
29
30
31
32
@classmethod
def is_valid(cls, text: str) -> bool:
    """Determine if the given string is a valid NPI."""
    if NPI_RE.match(text) is None:
        return False

    if text in INVALID:
        return False

    if len(text) == 10:
        text = "80840" + text

    return bool(luhn.is_valid(text))

normalize(text) classmethod

Normalize the given string to a valid NPI.

Source code in rigour/ids/npi.py 
34
35
36
37
38
39
40
41
42
43
@classmethod
def normalize(cls, text: str) -> str | None:
    """Normalize the given string to a valid NPI."""
    match = NPI_RE.search(text)
    if match is None:
        return None
    value = match.group(1)
    if cls.is_valid(value) and value not in INVALID:
        return value
    return None

OGRN

Bases: IdentifierFormat

Primary State Registration Number (Russian company registration).

Source code in rigour/ids/ogrn.py 
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
class OGRN(IdentifierFormat):
    """Primary State Registration Number (Russian company registration)."""

    NAME = "ogrn"
    TITLE = "OGRN"
    STRONG = True

    # cf. https://docs.trellix.com/de-DE/bundle/data-loss-prevention-11.10.x-classification-definitions-reference-guide/page/GUID-945B4343-861E-4A57-8E60-8B6028871BA1.html

    @classmethod
    def is_valid(cls, text: str) -> bool:
        """Determine if the given string is a valid OGRN."""
        if OGRN_RE.match(text) is None:
            return False

        # Validate registration type
        if text[0] == "0":
            return False

        # Validate control digit logic
        control_digit = int(text[-1])
        return control_digit == cls.calculate_control_digit(text)

    @classmethod
    def normalize(cls, text: str) -> str | None:
        """Normalize the given string to a valid OGRN."""
        match = OGRN_RE.search(text)
        if match is None:
            return None
        value = match.group(1)
        if cls.is_valid(value):
            return value
        return None

    @classmethod
    def calculate_control_digit(cls, grn: str) -> int | None:
        if len(grn) == 13:
            number = int(grn[:12])
            mod_result = number % 11
            calculated_digit = mod_result if mod_result != 10 else 0
            return calculated_digit
        elif len(grn) == 15:
            number = int(grn[:14])
            mod_result = number % 13
            calculated_digit = mod_result if mod_result != 10 else 0
            return calculated_digit
        return None

is_valid(text) classmethod

Determine if the given string is a valid OGRN.

Source code in rigour/ids/ogrn.py 
17
18
19
20
21
22
23
24
25
26
27
28
29
@classmethod
def is_valid(cls, text: str) -> bool:
    """Determine if the given string is a valid OGRN."""
    if OGRN_RE.match(text) is None:
        return False

    # Validate registration type
    if text[0] == "0":
        return False

    # Validate control digit logic
    control_digit = int(text[-1])
    return control_digit == cls.calculate_control_digit(text)

normalize(text) classmethod

Normalize the given string to a valid OGRN.

Source code in rigour/ids/ogrn.py 
31
32
33
34
35
36
37
38
39
40
@classmethod
def normalize(cls, text: str) -> str | None:
    """Normalize the given string to a valid OGRN."""
    match = OGRN_RE.search(text)
    if match is None:
        return None
    value = match.group(1)
    if cls.is_valid(value):
        return value
    return None

SSN

Bases: IdentifierFormat

US Social Security Number

Source code in rigour/ids/stdnum_.py 
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
class SSN(IdentifierFormat):
    """US Social Security Number"""

    NAME = "ssn"
    TITLE = "SSN"
    STRONG = False

    @classmethod
    def is_valid(cls, value: str) -> bool:
        return ssn.is_valid(value)

    @classmethod
    def normalize(cls, value: str) -> str | None:
        try:
            return ssn.compact(ssn.validate(value))
        except ValidationError:
            return None

    @classmethod
    def format(cls, value: str) -> str:
        return ssn.format(value)

StrictFormat

Bases: IdentifierFormat

A generic identifier type that applies harsh normalization.

Source code in rigour/ids/strict.py 
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
class StrictFormat(IdentifierFormat):
    """A generic identifier type that applies harsh normalization."""

    NAME = "strict"
    TITLE = "Strict identifier"
    STRONG = False

    @classmethod
    def is_valid(cls, value: str) -> bool:
        norm = cls.normalize(value)
        return norm is not None and len(norm) > 2

    @classmethod
    def normalize(cls, value: str) -> str | None:
        ascii = ascii_text(value)
        if len(ascii) < 2:
            return None
        chars = [c for c in ascii if c.isalnum()]
        return "".join(chars).upper()

UEI

Bases: IdentifierFormat

US GSA Unique Entity ID.

Source code in rigour/ids/uei.py 
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
class UEI(IdentifierFormat):
    """US GSA Unique Entity ID."""

    # https://www.gsa.gov/about-us/organization/federal-acquisition-service/integrated-award-environment-iae/iae-systems-information-kit/uei-technical-specifications-and-api-information

    NAME = "uei"
    TITLE = "NPI"
    STRONG = False
    """Marked false because the SAM database is massively duplicated, and entities in 
    SAM conflate companies and their owners. This makes UEIs more like cluster IDs than
    unique entity identifiers."""

    @classmethod
    def is_valid(cls, text: str) -> bool:
        """Determine if the given string is a valid NPI."""
        text = text.strip()
        match = UEI_RE.search(text)
        if match is None or match.group(1) != text:
            return False

        if text.startswith("0"):
            return False

        # TODO: Figure out checksum scheme
        return True

    @classmethod
    def normalize(cls, text: str) -> str | None:
        """Normalize the given string to a valid NPI."""
        match = UEI_RE.search(text)
        if match is None:
            return None
        value = match.group(1)
        if not cls.is_valid(value):
            return None
        return value.upper()

    @classmethod
    def format(cls, value: str) -> str:
        return value.upper()

STRONG = False class-attribute instance-attribute

Marked false because the SAM database is massively duplicated, and entities in SAM conflate companies and their owners. This makes UEIs more like cluster IDs than unique entity identifiers.

is_valid(text) classmethod

Determine if the given string is a valid NPI.

Source code in rigour/ids/uei.py 
20
21
22
23
24
25
26
27
28
29
30
31
32
@classmethod
def is_valid(cls, text: str) -> bool:
    """Determine if the given string is a valid NPI."""
    text = text.strip()
    match = UEI_RE.search(text)
    if match is None or match.group(1) != text:
        return False

    if text.startswith("0"):
        return False

    # TODO: Figure out checksum scheme
    return True

normalize(text) classmethod

Normalize the given string to a valid NPI.

Source code in rigour/ids/uei.py 
34
35
36
37
38
39
40
41
42
43
@classmethod
def normalize(cls, text: str) -> str | None:
    """Normalize the given string to a valid NPI."""
    match = UEI_RE.search(text)
    if match is None:
        return None
    value = match.group(1)
    if not cls.is_valid(value):
        return None
    return value.upper()

USCC

Bases: IdentifierFormat

Unified Social Credit Identifier, a Chinese national identifier

Source code in rigour/ids/stdnum_.py 
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
class USCC(IdentifierFormat):
    """Unified Social Credit Identifier, a Chinese national identifier"""

    NAME = "uscc"
    TITLE = "USCC"
    STRONG = True

    @classmethod
    def is_valid(cls, value: str) -> bool:
        return uscc.is_valid(value)

    @classmethod
    def normalize(cls, value: str) -> str | None:
        try:
            return uscc.compact(uscc.validate(value))
        except ValidationError:
            return None

    @classmethod
    def format(cls, value: str) -> str:
        return uscc.format(value)

WikidataQID

Bases: IdentifierFormat

A wikidata item identifier.

Source code in rigour/ids/wikidata.py 
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
class WikidataQID(IdentifierFormat):
    """A wikidata item identifier."""

    NAME = "wikidata"
    TITLE = "Wikidata QID"
    STRONG = True

    @classmethod
    def is_valid(cls, text: str) -> bool:
        """Determine if the given string is a valid wikidata QID."""
        return is_qid(text)

    @classmethod
    def normalize(cls, text: str) -> str | None:
        """Normalize the given string to a valid wikidata QID."""
        text = text.rsplit("/", 1)[-1].strip().upper()
        match = QID.match(text)
        if match is None:
            return None
        return text

is_valid(text) classmethod

Determine if the given string is a valid wikidata QID.

Source code in rigour/ids/wikidata.py 
23
24
25
26
@classmethod
def is_valid(cls, text: str) -> bool:
    """Determine if the given string is a valid wikidata QID."""
    return is_qid(text)

normalize(text) classmethod

Normalize the given string to a valid wikidata QID.

Source code in rigour/ids/wikidata.py 
28
29
30
31
32
33
34
35
@classmethod
def normalize(cls, text: str) -> str | None:
    """Normalize the given string to a valid wikidata QID."""
    text = text.rsplit("/", 1)[-1].strip().upper()
    match = QID.match(text)
    if match is None:
        return None
    return text

get_identifier_format(name) cached

Get the identifier type class for the given format name.

Source code in rigour/ids/__init__.py 
63
64
65
66
67
68
69
70
@cache
def get_identifier_format(name: str) -> FormatType | None:
    """Get the identifier type class for the given format name."""
    name = FORMAT_ALIASES.get(name, name)
    for fmt in _FORMATS:
        if fmt.NAME == name:
            return fmt
    return None

get_identifier_format_names()

Get a list of all identifier type names.

Source code in rigour/ids/__init__.py 
73
74
75
def get_identifier_format_names() -> list[str]:
    """Get a list of all identifier type names."""
    return [fmt.NAME for fmt in _FORMATS]

get_identifier_formats()

Get a list of all identifier formats.

Source code in rigour/ids/__init__.py 
78
79
80
81
82
83
84
85
86
87
88
89
90
def get_identifier_formats() -> list[FormatSpec]:
    """Get a list of all identifier formats."""
    formats: list[FormatSpec] = []
    for type_ in _FORMATS:
        name = type_.NAME
        fmt: FormatSpec = {
            "name": name,
            "title": type_.TITLE,
            "description": type_.__doc__ or "",
            "strong": type_.STRONG,
        }
        formats.append(fmt)
    return sorted(formats, key=lambda f: f["title"])

get_strong_format_names() cached

Get a list of all strong identifier type names.

Source code in rigour/ids/__init__.py 
93
94
95
96
@cache
def get_strong_format_names() -> list[str]:
    """Get a list of all strong identifier type names."""
    return [fmt.NAME for fmt in _FORMATS if fmt.STRONG]