Presidio Analyzer API Reference
Objects at the top of the presidio-analyzer package
presidio_analyzer.AnalyzerEngine
Entry point for Presidio Analyzer.
Orchestrating the detection of PII entities and all related logic.
PARAMETER | DESCRIPTION |
---|---|
registry
|
instance of type RecognizerRegistry
TYPE:
|
nlp_engine
|
instance of type NlpEngine (for example SpacyNlpEngine)
TYPE:
|
app_tracer
|
instance of type AppTracer, used to trace the logic used during each request for interpretability reasons.
TYPE:
|
log_decision_process
|
bool, defines whether the decision process within the analyzer should be logged or not.
TYPE:
|
default_score_threshold
|
Minimum confidence value for detected entities to be returned
TYPE:
|
supported_languages
|
List of possible languages this engine could be run on. Used for loading the right NLP models and recognizers for these languages.
TYPE:
|
context_aware_enhancer
|
instance of type ContextAwareEnhancer for enhancing confidence score based on context words, (LemmaContextAwareEnhancer will be created by default if None passed)
TYPE:
|
METHOD | DESCRIPTION |
---|---|
get_recognizers |
Return a list of PII recognizers currently loaded. |
get_supported_entities |
Return a list of the entities that can be detected. |
analyze |
Find PII entities in text using different PII recognizers for a given language. |
Source code in presidio_analyzer/analyzer_engine.py
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 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 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 |
|
get_recognizers
get_recognizers(language: Optional[str] = None) -> List[EntityRecognizer]
Return a list of PII recognizers currently loaded.
PARAMETER | DESCRIPTION |
---|---|
language
|
Return the recognizers supporting a given language.
TYPE:
|
RETURNS | DESCRIPTION |
---|---|
List[EntityRecognizer]
|
List of [Recognizer] as a RecognizersAllResponse |
Source code in presidio_analyzer/analyzer_engine.py
113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 |
|
get_supported_entities
get_supported_entities(language: Optional[str] = None) -> List[str]
Return a list of the entities that can be detected.
PARAMETER | DESCRIPTION |
---|---|
language
|
Return only entities supported in a specific language.
TYPE:
|
RETURNS | DESCRIPTION |
---|---|
List[str]
|
List of entity names |
Source code in presidio_analyzer/analyzer_engine.py
134 135 136 137 138 139 140 141 142 143 144 145 146 |
|
analyze
analyze(
text: str,
language: str,
entities: Optional[List[str]] = None,
correlation_id: Optional[str] = None,
score_threshold: Optional[float] = None,
return_decision_process: Optional[bool] = False,
ad_hoc_recognizers: Optional[List[EntityRecognizer]] = None,
context: Optional[List[str]] = None,
allow_list: Optional[List[str]] = None,
allow_list_match: Optional[str] = "exact",
regex_flags: Optional[int] = re.DOTALL | re.MULTILINE | re.IGNORECASE,
nlp_artifacts: Optional[NlpArtifacts] = None,
) -> List[RecognizerResult]
Find PII entities in text using different PII recognizers for a given language.
:Example:
from presidio_analyzer import AnalyzerEngine
# Set up the engine, loads the NLP module (spaCy model by default)
# and other PII recognizers
analyzer = AnalyzerEngine()
# Call analyzer to get results
results = analyzer.analyze(text='My phone number is 212-555-5555', entities=['PHONE_NUMBER'], language='en')
print(results)
PARAMETER | DESCRIPTION |
---|---|
text
|
the text to analyze
TYPE:
|
language
|
the language of the text
TYPE:
|
entities
|
List of PII entities that should be looked for in the text. If entities=None then all entities are looked for.
TYPE:
|
correlation_id
|
cross call ID for this request
TYPE:
|
score_threshold
|
A minimum value for which to return an identified entity
TYPE:
|
return_decision_process
|
Whether the analysis decision process steps returned in the response.
TYPE:
|
ad_hoc_recognizers
|
List of recognizers which will be used only for this specific request.
TYPE:
|
context
|
List of context words to enhance confidence score if matched with the recognized entity's recognizer context
TYPE:
|
allow_list
|
List of words that the user defines as being allowed to keep in the text
TYPE:
|
allow_list_match
|
How the allow_list should be interpreted; either as "exact" or as "regex". - If
TYPE:
|
regex_flags
|
regex flags to be used for when allow_list_match is "regex"
TYPE:
|
nlp_artifacts
|
precomputed NlpArtifacts
TYPE:
|
RETURNS | DESCRIPTION |
---|---|
List[RecognizerResult]
|
an array of the found entities in the text |
Source code in presidio_analyzer/analyzer_engine.py
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 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 |
|
presidio_analyzer.analyzer_engine_provider.AnalyzerEngineProvider
Utility function for loading Presidio Analyzer.
Use this class to load presidio analyzer engine from a yaml file
PARAMETER | DESCRIPTION |
---|---|
analyzer_engine_conf_file
|
the path to the analyzer configuration file
TYPE:
|
nlp_engine_conf_file
|
the path to the nlp engine configuration file
TYPE:
|
recognizer_registry_conf_file
|
the path to the recognizer registry configuration file
TYPE:
|
METHOD | DESCRIPTION |
---|---|
get_configuration |
Retrieve the analyzer engine configuration from the provided file. |
create_engine |
Load Presidio Analyzer from yaml configuration file. |
Source code in presidio_analyzer/analyzer_engine_provider.py
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 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 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 |
|
get_configuration
get_configuration(
conf_file: Optional[Union[Path, str]]
) -> Union[Dict[str, Any]]
Retrieve the analyzer engine configuration from the provided file.
Source code in presidio_analyzer/analyzer_engine_provider.py
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 |
|
create_engine
create_engine() -> AnalyzerEngine
Load Presidio Analyzer from yaml configuration file.
RETURNS | DESCRIPTION |
---|---|
AnalyzerEngine
|
analyzer engine initialized with yaml configuration |
Source code in presidio_analyzer/analyzer_engine_provider.py
68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 |
|
presidio_analyzer.analysis_explanation.AnalysisExplanation
Hold tracing information to explain why PII entities were identified as such.
PARAMETER | DESCRIPTION |
---|---|
recognizer
|
name of recognizer that made the decision
TYPE:
|
original_score
|
recognizer's confidence in result
TYPE:
|
pattern_name
|
name of pattern (if decision was made by a PatternRecognizer)
TYPE:
|
pattern
|
regex pattern that was applied (if PatternRecognizer)
TYPE:
|
validation_result
|
result of a validation (e.g. checksum)
TYPE:
|
textual_explanation
|
Free text for describing a decision of a logic or model
TYPE:
|
METHOD | DESCRIPTION |
---|---|
set_improved_score |
Update the score and calculate the difference from the original score. |
set_supportive_context_word |
Set the context word which helped increase the score. |
append_textual_explanation_line |
Append a new line to textual_explanation field. |
to_dict |
Serialize self to dictionary. |
Source code in presidio_analyzer/analysis_explanation.py
4 5 6 7 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 55 56 57 58 59 60 61 62 63 64 65 |
|
set_improved_score
set_improved_score(score: float) -> None
Update the score and calculate the difference from the original score.
Source code in presidio_analyzer/analysis_explanation.py
43 44 45 46 |
|
set_supportive_context_word
set_supportive_context_word(word: str) -> None
Set the context word which helped increase the score.
Source code in presidio_analyzer/analysis_explanation.py
48 49 50 |
|
append_textual_explanation_line
append_textual_explanation_line(text: str) -> None
Append a new line to textual_explanation field.
Source code in presidio_analyzer/analysis_explanation.py
52 53 54 55 56 57 |
|
to_dict
to_dict() -> Dict
Serialize self to dictionary.
RETURNS | DESCRIPTION |
---|---|
Dict
|
a dictionary |
Source code in presidio_analyzer/analysis_explanation.py
59 60 61 62 63 64 65 |
|
presidio_analyzer.recognizer_result.RecognizerResult
Recognizer Result represents the findings of the detected entity.
Result of a recognizer analyzing the text.
PARAMETER | DESCRIPTION |
---|---|
entity_type
|
the type of the entity
TYPE:
|
start
|
the start location of the detected entity
TYPE:
|
end
|
the end location of the detected entity
TYPE:
|
score
|
the score of the detection
TYPE:
|
analysis_explanation
|
contains the explanation of why this entity was identified
TYPE:
|
recognition_metadata
|
a dictionary of metadata to be used in recognizer specific cases, for example specific recognized context words and recognizer name
TYPE:
|
METHOD | DESCRIPTION |
---|---|
append_analysis_explanation_text |
Add text to the analysis explanation. |
to_dict |
Serialize self to dictionary. |
from_json |
Create RecognizerResult from json. |
intersects |
Check if self intersects with a different RecognizerResult. |
contained_in |
Check if self is contained in a different RecognizerResult. |
contains |
Check if one result is contained or equal to another result. |
equal_indices |
Check if the indices are equal between two results. |
has_conflict |
Check if two recognizer results are conflicted or not. |
Source code in presidio_analyzer/recognizer_result.py
7 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 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 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 178 179 180 181 182 183 184 185 186 187 188 |
|
append_analysis_explanation_text
append_analysis_explanation_text(text: str) -> None
Add text to the analysis explanation.
Source code in presidio_analyzer/recognizer_result.py
57 58 59 60 |
|
to_dict
to_dict() -> Dict
Serialize self to dictionary.
RETURNS | DESCRIPTION |
---|---|
Dict
|
a dictionary |
Source code in presidio_analyzer/recognizer_result.py
62 63 64 65 66 67 68 |
|
from_json
classmethod
from_json(data: Dict) -> RecognizerResult
Create RecognizerResult from json.
PARAMETER | DESCRIPTION |
---|---|
data
|
e.g. { "start": 24, "end": 32, "score": 0.8, "entity_type": "NAME" }
TYPE:
|
RETURNS | DESCRIPTION |
---|---|
RecognizerResult
|
RecognizerResult |
Source code in presidio_analyzer/recognizer_result.py
70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 |
|
intersects
intersects(other: RecognizerResult) -> int
Check if self intersects with a different RecognizerResult.
RETURNS | DESCRIPTION |
---|---|
int
|
If intersecting, returns the number of intersecting characters. If not, returns 0 |
Source code in presidio_analyzer/recognizer_result.py
93 94 95 96 97 98 99 100 101 102 103 104 105 106 |
|
contained_in
contained_in(other: RecognizerResult) -> bool
Check if self is contained in a different RecognizerResult.
RETURNS | DESCRIPTION |
---|---|
bool
|
true if contained |
Source code in presidio_analyzer/recognizer_result.py
108 109 110 111 112 113 114 |
|
contains
contains(other: RecognizerResult) -> bool
Check if one result is contained or equal to another result.
PARAMETER | DESCRIPTION |
---|---|
other
|
another RecognizerResult
TYPE:
|
RETURNS | DESCRIPTION |
---|---|
bool
|
bool |
Source code in presidio_analyzer/recognizer_result.py
116 117 118 119 120 121 122 123 |
|
equal_indices
equal_indices(other: RecognizerResult) -> bool
Check if the indices are equal between two results.
PARAMETER | DESCRIPTION |
---|---|
other
|
another RecognizerResult
TYPE:
|
RETURNS | DESCRIPTION |
---|---|
bool
|
|
Source code in presidio_analyzer/recognizer_result.py
125 126 127 128 129 130 131 132 |
|
has_conflict
has_conflict(other: RecognizerResult) -> bool
Check if two recognizer results are conflicted or not.
I have a conflict if: 1. My indices are the same as the other and my score is lower. 2. If my indices are contained in another.
PARAMETER | DESCRIPTION |
---|---|
other
|
RecognizerResult
TYPE:
|
RETURNS | DESCRIPTION |
---|---|
bool
|
|
Source code in presidio_analyzer/recognizer_result.py
175 176 177 178 179 180 181 182 183 184 185 186 187 188 |
|
Batch modules
presidio_analyzer.batch_analyzer_engine.BatchAnalyzerEngine
Batch analysis of documents (tables, lists, dicts).
Wrapper class to run Presidio Analyzer Engine on multiple values, either lists/iterators of strings, or dictionaries.
PARAMETER | DESCRIPTION |
---|---|
analyzer_engine
|
AnalyzerEngine instance to use for handling the values in those collections.
TYPE:
|
METHOD | DESCRIPTION |
---|---|
analyze_iterator |
Analyze an iterable of strings. |
analyze_dict |
Analyze a dictionary of keys (strings) and values/iterable of values. |
Source code in presidio_analyzer/batch_analyzer_engine.py
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 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 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 |
|
analyze_iterator
analyze_iterator(
texts: Iterable[Union[str, bool, float, int]],
language: str,
batch_size: Optional[int] = None,
**kwargs
) -> List[List[RecognizerResult]]
Analyze an iterable of strings.
PARAMETER | DESCRIPTION |
---|---|
texts
|
An list containing strings to be analyzed.
TYPE:
|
language
|
Input language
TYPE:
|
batch_size
|
Batch size to process in a single iteration
TYPE:
|
kwargs
|
Additional parameters for the
DEFAULT:
|
Source code in presidio_analyzer/batch_analyzer_engine.py
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 |
|
analyze_dict
analyze_dict(
input_dict: Dict[str, Union[Any, Iterable[Any]]],
language: str,
keys_to_skip: Optional[List[str]] = None,
**kwargs
) -> Iterator[DictAnalyzerResult]
Analyze a dictionary of keys (strings) and values/iterable of values.
Non-string values are returned as is.
PARAMETER | DESCRIPTION |
---|---|
input_dict
|
The input dictionary for analysis
TYPE:
|
language
|
Input language
TYPE:
|
keys_to_skip
|
Keys to ignore during analysis
TYPE:
|
kwargs
|
Additional keyword arguments for the
DEFAULT:
|
Source code in presidio_analyzer/batch_analyzer_engine.py
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 126 127 |
|
presidio_analyzer.dict_analyzer_result.DictAnalyzerResult
dataclass
Data class for holding the output of the Presidio Analyzer on dictionaries.
PARAMETER | DESCRIPTION |
---|---|
key
|
key in dictionary
TYPE:
|
value
|
value to run analysis on (either string or list of strings)
TYPE:
|
recognizer_results
|
Analyzer output for one value. Could be either: - A list of recognizer results if the input is one string - A list of lists of recognizer results, if the input is a list of strings. - An iterator of a DictAnalyzerResult, if the input is a dictionary. In this case the recognizer_results would be the iterator of the DictAnalyzerResults next level in the dictionary.
TYPE:
|
Source code in presidio_analyzer/dict_analyzer_result.py
7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 |
|
Recognizers and patterns
presidio_analyzer.entity_recognizer.EntityRecognizer
A class representing an abstract PII entity recognizer.
EntityRecognizer is an abstract class to be inherited by Recognizers which hold the logic for recognizing specific PII entities.
EntityRecognizer exposes a method called enhance_using_context which can be overridden in case a custom context aware enhancement is needed in derived class of a recognizer.
PARAMETER | DESCRIPTION |
---|---|
supported_entities
|
the entities supported by this recognizer (for example, phone number, address, etc.)
TYPE:
|
supported_language
|
the language supported by this recognizer. The supported langauge code is iso6391Name
TYPE:
|
name
|
the name of this recognizer (optional)
TYPE:
|
version
|
the recognizer current version
TYPE:
|
context
|
a list of words which can help boost confidence score when they appear in context of the matched entity
TYPE:
|
METHOD | DESCRIPTION |
---|---|
load |
Initialize the recognizer assets if needed. |
analyze |
Analyze text to identify entities. |
enhance_using_context |
Enhance confidence score using context of the entity. |
get_supported_entities |
Return the list of entities this recognizer can identify. |
get_supported_language |
Return the language this recognizer can support. |
get_version |
Return the version of this recognizer. |
to_dict |
Serialize self to dictionary. |
from_dict |
Create EntityRecognizer from a dict input. |
remove_duplicates |
Remove duplicate results. |
Source code in presidio_analyzer/entity_recognizer.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 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 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 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 |
|
id
property
id
Return a unique identifier of this recognizer.
load
abstractmethod
load() -> None
Initialize the recognizer assets if needed.
(e.g. machine learning models)
Source code in presidio_analyzer/entity_recognizer.py
67 68 69 70 71 72 73 |
|
analyze
abstractmethod
analyze(
text: str, entities: List[str], nlp_artifacts: NlpArtifacts
) -> List[RecognizerResult]
Analyze text to identify entities.
PARAMETER | DESCRIPTION |
---|---|
text
|
The text to be analyzed
TYPE:
|
entities
|
The list of entities this recognizer is able to detect
TYPE:
|
nlp_artifacts
|
A group of attributes which are the result of an NLP process over the input text.
TYPE:
|
RETURNS | DESCRIPTION |
---|---|
List[RecognizerResult]
|
List of results detected by this recognizer. |
Source code in presidio_analyzer/entity_recognizer.py
75 76 77 78 79 80 81 82 83 84 85 86 87 88 |
|
enhance_using_context
enhance_using_context(
text: str,
raw_recognizer_results: List[RecognizerResult],
other_raw_recognizer_results: List[RecognizerResult],
nlp_artifacts: NlpArtifacts,
context: Optional[List[str]] = None,
) -> List[RecognizerResult]
Enhance confidence score using context of the entity.
Override this method in derived class in case a custom logic is needed, otherwise return value will be equal to raw_results.
in case a result score is boosted, derived class need to update result.recognition_metadata[RecognizerResult.IS_SCORE_ENHANCED_BY_CONTEXT_KEY]
PARAMETER | DESCRIPTION |
---|---|
text
|
The actual text that was analyzed
TYPE:
|
raw_recognizer_results
|
This recognizer's results, to be updated based on recognizer specific context.
TYPE:
|
other_raw_recognizer_results
|
Other recognizer results matched in the given text to allow related entity context enhancement
TYPE:
|
nlp_artifacts
|
The nlp artifacts contains elements such as lemmatized tokens for better accuracy of the context enhancement process
TYPE:
|
context
|
list of context words
TYPE:
|
Source code in presidio_analyzer/entity_recognizer.py
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 |
|
get_supported_entities
get_supported_entities() -> List[str]
Return the list of entities this recognizer can identify.
RETURNS | DESCRIPTION |
---|---|
List[str]
|
A list of the supported entities by this recognizer |
Source code in presidio_analyzer/entity_recognizer.py
119 120 121 122 123 124 125 |
|
get_supported_language
get_supported_language() -> str
Return the language this recognizer can support.
RETURNS | DESCRIPTION |
---|---|
str
|
A list of the supported language by this recognizer |
Source code in presidio_analyzer/entity_recognizer.py
127 128 129 130 131 132 133 |
|
get_version
get_version() -> str
Return the version of this recognizer.
RETURNS | DESCRIPTION |
---|---|
str
|
The current version of this recognizer |
Source code in presidio_analyzer/entity_recognizer.py
135 136 137 138 139 140 141 |
|
to_dict
to_dict() -> Dict
Serialize self to dictionary.
RETURNS | DESCRIPTION |
---|---|
Dict
|
a dictionary |
Source code in presidio_analyzer/entity_recognizer.py
143 144 145 146 147 148 149 150 151 152 153 154 155 |
|
from_dict
classmethod
from_dict(entity_recognizer_dict: Dict) -> EntityRecognizer
Create EntityRecognizer from a dict input.
PARAMETER | DESCRIPTION |
---|---|
entity_recognizer_dict
|
Dict containing keys and values for instantiation
TYPE:
|
Source code in presidio_analyzer/entity_recognizer.py
157 158 159 160 161 162 163 164 |
|
remove_duplicates
staticmethod
remove_duplicates(results: List[RecognizerResult]) -> List[RecognizerResult]
Remove duplicate results.
Remove duplicates in case the two results have identical start and ends and types.
PARAMETER | DESCRIPTION |
---|---|
results
|
List[RecognizerResult]
TYPE:
|
RETURNS | DESCRIPTION |
---|---|
List[RecognizerResult]
|
List[RecognizerResult] |
Source code in presidio_analyzer/entity_recognizer.py
166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 |
|
presidio_analyzer.local_recognizer.LocalRecognizer
Bases: ABC
, EntityRecognizer
PII entity recognizer which runs on the same process as the AnalyzerEngine.
METHOD | DESCRIPTION |
---|---|
load |
Initialize the recognizer assets if needed. |
analyze |
Analyze text to identify entities. |
enhance_using_context |
Enhance confidence score using context of the entity. |
get_supported_entities |
Return the list of entities this recognizer can identify. |
get_supported_language |
Return the language this recognizer can support. |
get_version |
Return the version of this recognizer. |
to_dict |
Serialize self to dictionary. |
from_dict |
Create EntityRecognizer from a dict input. |
remove_duplicates |
Remove duplicate results. |
Source code in presidio_analyzer/local_recognizer.py
6 7 |
|
id
property
id
Return a unique identifier of this recognizer.
load
abstractmethod
load() -> None
Initialize the recognizer assets if needed.
(e.g. machine learning models)
Source code in presidio_analyzer/entity_recognizer.py
67 68 69 70 71 72 73 |
|
analyze
abstractmethod
analyze(
text: str, entities: List[str], nlp_artifacts: NlpArtifacts
) -> List[RecognizerResult]
Analyze text to identify entities.
PARAMETER | DESCRIPTION |
---|---|
text
|
The text to be analyzed
TYPE:
|
entities
|
The list of entities this recognizer is able to detect
TYPE:
|
nlp_artifacts
|
A group of attributes which are the result of an NLP process over the input text.
TYPE:
|
RETURNS | DESCRIPTION |
---|---|
List[RecognizerResult]
|
List of results detected by this recognizer. |
Source code in presidio_analyzer/entity_recognizer.py
75 76 77 78 79 80 81 82 83 84 85 86 87 88 |
|
enhance_using_context
enhance_using_context(
text: str,
raw_recognizer_results: List[RecognizerResult],
other_raw_recognizer_results: List[RecognizerResult],
nlp_artifacts: NlpArtifacts,
context: Optional[List[str]] = None,
) -> List[RecognizerResult]
Enhance confidence score using context of the entity.
Override this method in derived class in case a custom logic is needed, otherwise return value will be equal to raw_results.
in case a result score is boosted, derived class need to update result.recognition_metadata[RecognizerResult.IS_SCORE_ENHANCED_BY_CONTEXT_KEY]
PARAMETER | DESCRIPTION |
---|---|
text
|
The actual text that was analyzed
TYPE:
|
raw_recognizer_results
|
This recognizer's results, to be updated based on recognizer specific context.
TYPE:
|
other_raw_recognizer_results
|
Other recognizer results matched in the given text to allow related entity context enhancement
TYPE:
|
nlp_artifacts
|
The nlp artifacts contains elements such as lemmatized tokens for better accuracy of the context enhancement process
TYPE:
|
context
|
list of context words
TYPE:
|
Source code in presidio_analyzer/entity_recognizer.py
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 |
|
get_supported_entities
get_supported_entities() -> List[str]
Return the list of entities this recognizer can identify.
RETURNS | DESCRIPTION |
---|---|
List[str]
|
A list of the supported entities by this recognizer |
Source code in presidio_analyzer/entity_recognizer.py
119 120 121 122 123 124 125 |
|
get_supported_language
get_supported_language() -> str
Return the language this recognizer can support.
RETURNS | DESCRIPTION |
---|---|
str
|
A list of the supported language by this recognizer |
Source code in presidio_analyzer/entity_recognizer.py
127 128 129 130 131 132 133 |
|
get_version
get_version() -> str
Return the version of this recognizer.
RETURNS | DESCRIPTION |
---|---|
str
|
The current version of this recognizer |
Source code in presidio_analyzer/entity_recognizer.py
135 136 137 138 139 140 141 |
|
to_dict
to_dict() -> Dict
Serialize self to dictionary.
RETURNS | DESCRIPTION |
---|---|
Dict
|
a dictionary |
Source code in presidio_analyzer/entity_recognizer.py
143 144 145 146 147 148 149 150 151 152 153 154 155 |
|
from_dict
classmethod
from_dict(entity_recognizer_dict: Dict) -> EntityRecognizer
Create EntityRecognizer from a dict input.
PARAMETER | DESCRIPTION |
---|---|
entity_recognizer_dict
|
Dict containing keys and values for instantiation
TYPE:
|
Source code in presidio_analyzer/entity_recognizer.py
157 158 159 160 161 162 163 164 |
|
remove_duplicates
staticmethod
remove_duplicates(results: List[RecognizerResult]) -> List[RecognizerResult]
Remove duplicate results.
Remove duplicates in case the two results have identical start and ends and types.
PARAMETER | DESCRIPTION |
---|---|
results
|
List[RecognizerResult]
TYPE:
|
RETURNS | DESCRIPTION |
---|---|
List[RecognizerResult]
|
List[RecognizerResult] |
Source code in presidio_analyzer/entity_recognizer.py
166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 |
|
presidio_analyzer.pattern.Pattern
A class that represents a regex pattern.
PARAMETER | DESCRIPTION |
---|---|
name
|
the name of the pattern
TYPE:
|
regex
|
the regex pattern to detect
TYPE:
|
score
|
the pattern's strength (values varies 0-1)
TYPE:
|
METHOD | DESCRIPTION |
---|---|
to_dict |
Turn this instance into a dictionary. |
from_dict |
Load an instance from a dictionary. |
Source code in presidio_analyzer/pattern.py
5 6 7 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 |
|
to_dict
to_dict() -> Dict
Turn this instance into a dictionary.
RETURNS | DESCRIPTION |
---|---|
Dict
|
a dictionary |
Source code in presidio_analyzer/pattern.py
21 22 23 24 25 26 27 28 |
|
from_dict
classmethod
from_dict(pattern_dict: Dict) -> Pattern
Load an instance from a dictionary.
PARAMETER | DESCRIPTION |
---|---|
pattern_dict
|
a dictionary holding the pattern's parameters
TYPE:
|
RETURNS | DESCRIPTION |
---|---|
Pattern
|
a Pattern instance |
Source code in presidio_analyzer/pattern.py
30 31 32 33 34 35 36 37 38 |
|
presidio_analyzer.pattern_recognizer.PatternRecognizer
Bases: LocalRecognizer
PII entity recognizer using regular expressions or deny-lists.
PARAMETER | DESCRIPTION |
---|---|
patterns
|
A list of patterns to detect
TYPE:
|
deny_list
|
A list of words to detect, in case our recognizer uses a predefined list of words (deny list)
TYPE:
|
context
|
list of context words
TYPE:
|
deny_list_score
|
confidence score for a term identified using a deny-list
TYPE:
|
global_regex_flags
|
regex flags to be used in regex matching, including deny-lists.
TYPE:
|
METHOD | DESCRIPTION |
---|---|
enhance_using_context |
Enhance confidence score using context of the entity. |
get_supported_entities |
Return the list of entities this recognizer can identify. |
get_supported_language |
Return the language this recognizer can support. |
get_version |
Return the version of this recognizer. |
remove_duplicates |
Remove duplicate results. |
analyze |
Analyzes text to detect PII using regular expressions or deny-lists. |
validate_result |
Validate the pattern logic e.g., by running checksum on a detected pattern. |
invalidate_result |
Logic to check for result invalidation by running pruning logic. |
build_regex_explanation |
Construct an explanation for why this entity was detected. |
to_dict |
Serialize instance into a dictionary. |
from_dict |
Create instance from a serialized dict. |
Source code in presidio_analyzer/pattern_recognizer.py
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 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 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 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 |
|
id
property
id
Return a unique identifier of this recognizer.
enhance_using_context
enhance_using_context(
text: str,
raw_recognizer_results: List[RecognizerResult],
other_raw_recognizer_results: List[RecognizerResult],
nlp_artifacts: NlpArtifacts,
context: Optional[List[str]] = None,
) -> List[RecognizerResult]
Enhance confidence score using context of the entity.
Override this method in derived class in case a custom logic is needed, otherwise return value will be equal to raw_results.
in case a result score is boosted, derived class need to update result.recognition_metadata[RecognizerResult.IS_SCORE_ENHANCED_BY_CONTEXT_KEY]
PARAMETER | DESCRIPTION |
---|---|
text
|
The actual text that was analyzed
TYPE:
|
raw_recognizer_results
|
This recognizer's results, to be updated based on recognizer specific context.
TYPE:
|
other_raw_recognizer_results
|
Other recognizer results matched in the given text to allow related entity context enhancement
TYPE:
|
nlp_artifacts
|
The nlp artifacts contains elements such as lemmatized tokens for better accuracy of the context enhancement process
TYPE:
|
context
|
list of context words
TYPE:
|
Source code in presidio_analyzer/entity_recognizer.py
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 |
|
get_supported_entities
get_supported_entities() -> List[str]
Return the list of entities this recognizer can identify.
RETURNS | DESCRIPTION |
---|---|
List[str]
|
A list of the supported entities by this recognizer |
Source code in presidio_analyzer/entity_recognizer.py
119 120 121 122 123 124 125 |
|
get_supported_language
get_supported_language() -> str
Return the language this recognizer can support.
RETURNS | DESCRIPTION |
---|---|
str
|
A list of the supported language by this recognizer |
Source code in presidio_analyzer/entity_recognizer.py
127 128 129 130 131 132 133 |
|
get_version
get_version() -> str
Return the version of this recognizer.
RETURNS | DESCRIPTION |
---|---|
str
|
The current version of this recognizer |
Source code in presidio_analyzer/entity_recognizer.py
135 136 137 138 139 140 141 |
|
remove_duplicates
staticmethod
remove_duplicates(results: List[RecognizerResult]) -> List[RecognizerResult]
Remove duplicate results.
Remove duplicates in case the two results have identical start and ends and types.
PARAMETER | DESCRIPTION |
---|---|
results
|
List[RecognizerResult]
TYPE:
|
RETURNS | DESCRIPTION |
---|---|
List[RecognizerResult]
|
List[RecognizerResult] |
Source code in presidio_analyzer/entity_recognizer.py
166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 |
|
analyze
analyze(
text: str,
entities: List[str],
nlp_artifacts: Optional[NlpArtifacts] = None,
regex_flags: Optional[int] = None,
) -> List[RecognizerResult]
Analyzes text to detect PII using regular expressions or deny-lists.
PARAMETER | DESCRIPTION |
---|---|
text
|
Text to be analyzed
TYPE:
|
entities
|
Entities this recognizer can detect
TYPE:
|
nlp_artifacts
|
Output values from the NLP engine
TYPE:
|
regex_flags
|
regex flags to be used in regex matching
TYPE:
|
RETURNS | DESCRIPTION |
---|---|
List[RecognizerResult]
|
|
Source code in presidio_analyzer/pattern_recognizer.py
78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 |
|
validate_result
validate_result(pattern_text: str) -> Optional[bool]
Validate the pattern logic e.g., by running checksum on a detected pattern.
PARAMETER | DESCRIPTION |
---|---|
pattern_text
|
the text to validated. Only the part in text that was detected by the regex engine
TYPE:
|
RETURNS | DESCRIPTION |
---|---|
Optional[bool]
|
A bool indicating whether the validation was successful. |
Source code in presidio_analyzer/pattern_recognizer.py
117 118 119 120 121 122 123 124 125 |
|
invalidate_result
invalidate_result(pattern_text: str) -> Optional[bool]
Logic to check for result invalidation by running pruning logic.
For example, each SSN number group should not consist of all the same digits.
PARAMETER | DESCRIPTION |
---|---|
pattern_text
|
the text to validated. Only the part in text that was detected by the regex engine
TYPE:
|
RETURNS | DESCRIPTION |
---|---|
Optional[bool]
|
A bool indicating whether the result is invalidated |
Source code in presidio_analyzer/pattern_recognizer.py
127 128 129 130 131 132 133 134 135 136 137 |
|
build_regex_explanation
staticmethod
build_regex_explanation(
recognizer_name: str,
pattern_name: str,
pattern: str,
original_score: float,
validation_result: bool,
regex_flags: int,
) -> AnalysisExplanation
Construct an explanation for why this entity was detected.
PARAMETER | DESCRIPTION |
---|---|
recognizer_name
|
Name of recognizer detecting the entity
TYPE:
|
pattern_name
|
Regex pattern name which detected the entity
TYPE:
|
pattern
|
Regex pattern logic
TYPE:
|
original_score
|
Score given by the recognizer
TYPE:
|
validation_result
|
Whether validation was used and its result
TYPE:
|
regex_flags
|
Regex flags used in the regex matching
TYPE:
|
RETURNS | DESCRIPTION |
---|---|
AnalysisExplanation
|
Analysis explanation |
Source code in presidio_analyzer/pattern_recognizer.py
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 |
|
to_dict
to_dict() -> Dict
Serialize instance into a dictionary.
Source code in presidio_analyzer/pattern_recognizer.py
254 255 256 257 258 259 260 261 262 263 264 |
|
from_dict
classmethod
from_dict(entity_recognizer_dict: Dict) -> PatternRecognizer
Create instance from a serialized dict.
Source code in presidio_analyzer/pattern_recognizer.py
266 267 268 269 270 271 272 273 274 |
|
presidio_analyzer.remote_recognizer.RemoteRecognizer
Bases: ABC
, EntityRecognizer
A configuration for a recognizer that runs on a different process / remote machine.
PARAMETER | DESCRIPTION |
---|---|
supported_entities
|
A list of entities this recognizer can identify
TYPE:
|
name
|
name of recognizer
TYPE:
|
supported_language
|
The language this recognizer can detect entities in
TYPE:
|
version
|
Version of this recognizer
TYPE:
|
METHOD | DESCRIPTION |
---|---|
enhance_using_context |
Enhance confidence score using context of the entity. |
get_supported_language |
Return the language this recognizer can support. |
get_version |
Return the version of this recognizer. |
to_dict |
Serialize self to dictionary. |
from_dict |
Create EntityRecognizer from a dict input. |
remove_duplicates |
Remove duplicate results. |
analyze |
Call an external service for PII detection. |
Source code in presidio_analyzer/remote_recognizer.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 |
|
id
property
id
Return a unique identifier of this recognizer.
enhance_using_context
enhance_using_context(
text: str,
raw_recognizer_results: List[RecognizerResult],
other_raw_recognizer_results: List[RecognizerResult],
nlp_artifacts: NlpArtifacts,
context: Optional[List[str]] = None,
) -> List[RecognizerResult]
Enhance confidence score using context of the entity.
Override this method in derived class in case a custom logic is needed, otherwise return value will be equal to raw_results.
in case a result score is boosted, derived class need to update result.recognition_metadata[RecognizerResult.IS_SCORE_ENHANCED_BY_CONTEXT_KEY]
PARAMETER | DESCRIPTION |
---|---|
text
|
The actual text that was analyzed
TYPE:
|
raw_recognizer_results
|
This recognizer's results, to be updated based on recognizer specific context.
TYPE:
|
other_raw_recognizer_results
|
Other recognizer results matched in the given text to allow related entity context enhancement
TYPE:
|
nlp_artifacts
|
The nlp artifacts contains elements such as lemmatized tokens for better accuracy of the context enhancement process
TYPE:
|
context
|
list of context words
TYPE:
|
Source code in presidio_analyzer/entity_recognizer.py
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 |
|
get_supported_language
get_supported_language() -> str
Return the language this recognizer can support.
RETURNS | DESCRIPTION |
---|---|
str
|
A list of the supported language by this recognizer |
Source code in presidio_analyzer/entity_recognizer.py
127 128 129 130 131 132 133 |
|
get_version
get_version() -> str
Return the version of this recognizer.
RETURNS | DESCRIPTION |
---|---|
str
|
The current version of this recognizer |
Source code in presidio_analyzer/entity_recognizer.py
135 136 137 138 139 140 141 |
|
to_dict
to_dict() -> Dict
Serialize self to dictionary.
RETURNS | DESCRIPTION |
---|---|
Dict
|
a dictionary |
Source code in presidio_analyzer/entity_recognizer.py
143 144 145 146 147 148 149 150 151 152 153 154 155 |
|
from_dict
classmethod
from_dict(entity_recognizer_dict: Dict) -> EntityRecognizer
Create EntityRecognizer from a dict input.
PARAMETER | DESCRIPTION |
---|---|
entity_recognizer_dict
|
Dict containing keys and values for instantiation
TYPE:
|
Source code in presidio_analyzer/entity_recognizer.py
157 158 159 160 161 162 163 164 |
|
remove_duplicates
staticmethod
remove_duplicates(results: List[RecognizerResult]) -> List[RecognizerResult]
Remove duplicate results.
Remove duplicates in case the two results have identical start and ends and types.
PARAMETER | DESCRIPTION |
---|---|
results
|
List[RecognizerResult]
TYPE:
|
RETURNS | DESCRIPTION |
---|---|
List[RecognizerResult]
|
List[RecognizerResult] |
Source code in presidio_analyzer/entity_recognizer.py
166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 |
|
analyze
abstractmethod
analyze(text: str, entities: List[str], nlp_artifacts: NlpArtifacts)
Call an external service for PII detection.
PARAMETER | DESCRIPTION |
---|---|
text
|
text to be analyzed
TYPE:
|
entities
|
Entities that should be looked for
TYPE:
|
nlp_artifacts
|
Additional metadata from the NLP engine
TYPE:
|
RETURNS | DESCRIPTION |
---|---|
List of identified PII entities |
Source code in presidio_analyzer/remote_recognizer.py
37 38 39 40 41 42 43 44 45 46 47 48 49 50 |
|
Recognizer registry modules
presidio_analyzer.recognizer_registry.RecognizerRegistry
Detect, register and hold all recognizers to be used by the analyzer.
PARAMETER | DESCRIPTION |
---|---|
recognizers
|
An optional list of recognizers, that will be available instead of the predefined recognizers
TYPE:
|
global_regex_flags
|
regex flags to be used in regex matching, including deny-lists
TYPE:
|
supported_languages
|
List of languages supported by this registry.
TYPE:
|
METHOD | DESCRIPTION |
---|---|
add_nlp_recognizer |
Adding NLP recognizer in accordance with the nlp engine. |
load_predefined_recognizers |
Load the existing recognizers into memory. |
get_recognizers |
Return a list of recognizers which supports the specified name and language. |
add_recognizer |
Add a new recognizer to the list of recognizers. |
remove_recognizer |
Remove a recognizer based on its name. |
add_pattern_recognizer_from_dict |
Load a pattern recognizer from a Dict into the recognizer registry. |
add_recognizers_from_yaml |
Read YAML file and load recognizers into the recognizer registry. |
get_supported_entities |
Return the supported entities by the set of recognizers loaded. |
Source code in presidio_analyzer/recognizer_registry/recognizer_registry.py
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 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 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 |
|