esgvoc 0.1.2__py3-none-any.whl → 0.2.1__py3-none-any.whl

esgvoc/apps/drs/validator.py

@@ -0,0 +1,332 @@
+from typing import cast
+from esgvoc.api.project_specs import (ProjectSpecs,
+                               DrsType,
+                               DrsPart,
+                               DrsSpecification,
+                               DrsPartKind,
+                               DrsCollection,
+                               DrsConstant)
+import esgvoc.api.projects as projects
+import esgvoc.apps.drs.constants as constants
+from esgvoc.apps.drs.report import (DrsValidationReport,
+                                    DrsIssue,
+                                    ParserIssue,
+                                    ValidationIssue,
+                                    Space,
+                                    Unparsable,
+                                    ExtraSeparator,
+                                    ExtraChar,
+                                    BlankToken,
+                                    InvalidToken,
+                                    ExtraToken,
+                                    MissingToken,
+                                    FileNameExtensionIssue)
+
+
+class DrsApplication:
+    """
+    Generic DRS application class.
+    """
+
+    def __init__(self, project_id: str, pedantic: bool = False) -> None:
+        self.project_id: str = project_id
+        """The project id."""
+        self.pedantic: bool = pedantic
+        """Same as the option of GCC: turn warnings into errors. Default False."""
+        project_specs: ProjectSpecs = projects.get_project_specs(project_id)
+        for specs in project_specs.drs_specs:
+            match specs.type:
+                case DrsType.DIRECTORY:
+                    self.directory_specs: DrsSpecification = specs
+                    """The DRS directory specs of the project."""
+                case DrsType.FILE_NAME:
+                    self.file_name_specs: DrsSpecification = specs
+                    """The DRS file name specs of the project."""
+                case DrsType.DATASET_ID:
+                    self.dataset_id_specs: DrsSpecification = specs
+                    """The DRS dataset id specs of the project."""
+                case _:
+                    raise ValueError(f'unsupported DRS specs type {specs.type}')
+
+    def _get_full_file_name_extension(self) -> str:
+        """
+        Returns the full file name extension (the separator plus the extension) of the DRS file
+        name specs of the project.
+
+        :returns: The full file name extension.
+        :rtype: str
+        """
+        specs: DrsSpecification = self.file_name_specs
+        if specs.properties:
+            full_extension = specs.properties[constants.FILE_NAME_EXTENSION_SEPARATOR_KEY] + \
+                             specs.properties[constants.FILE_NAME_EXTENSION_KEY]
+        else:
+            raise ValueError('missing properties in the DRS file name specifications of the ' +
+                             f'project {self.project_id}')
+        return full_extension
+    
+    def _get_specs(self, drs_type: DrsType|str) -> DrsSpecification:
+        match drs_type:
+            case DrsType.DIRECTORY:
+                specs = self.directory_specs
+            case DrsType.FILE_NAME:
+                specs = self.file_name_specs
+            case DrsType.DATASET_ID:
+                specs = self.dataset_id_specs
+            case _:
+                raise ValueError(f'unsupported DRS type {drs_type}')
+        return specs
+    
+class DrsValidator(DrsApplication):
+    """
+    Valid a DRS directory, dataset id and file name expression against a project.
+    """
+   
+    def validate_directory(self, drs_expression: str) -> DrsValidationReport:
+        """
+        Validate a DRS directory expression.
+
+        :param drs_expression: A DRS directory expression.
+        :type drs_expression: str
+        :returns: A validation report.
+        :rtype: DrsValidationReport
+        """
+        return self._validate(drs_expression, self.directory_specs)
+    
+    def validate_dataset_id(self, drs_expression: str) -> DrsValidationReport:
+        """
+        Validate a DRS dataset id expression.
+
+        :param drs_expression: A DRS dataset id expression.
+        :type drs_expression: str
+        :returns: A validation report.
+        :rtype: DrsValidationReport
+        """
+        return self._validate(drs_expression, self.dataset_id_specs)
+
+    def validate_file_name(self, drs_expression: str) -> DrsValidationReport:
+        """
+        Validate a file name expression.
+
+        :param drs_expression: A DRS file name expression.
+        :type drs_expression: str
+        :returns: A validation report.
+        :rtype: DrsValidationReport
+        """
+        full_extension = self._get_full_file_name_extension()
+        if drs_expression.endswith(full_extension):
+            drs_expression = drs_expression.replace(full_extension, '')
+            result = self._validate(drs_expression, self.file_name_specs)
+        else:
+            issue = FileNameExtensionIssue(expected_extension=full_extension)
+            result = self._create_report(self.file_name_specs.type, drs_expression,
+                                         [issue], [])
+        return result
+
+    def validate(self, drs_expression: str, drs_type: DrsType|str) -> DrsValidationReport:
+        """
+        Validate a DRS expression.
+
+        :param drs_expression: A DRS expression.
+        :type drs_expression: str
+        :param drs_type: The type of the given DRS expression (directory, file_name or dataset_id)
+        :type drs_type: DrsType|str
+        :returns: A validation report.
+        :rtype: DrsValidationReport
+        """
+        specs = self._get_specs(drs_type)
+        return self._validate(drs_expression, specs)
+    
+    def _parse(self,
+               drs_expression: str,
+               separator: str,
+               drs_type: DrsType) -> tuple[list[str]|None,  # Tokens
+                                           list[DrsIssue],  # Errors
+                                           list[DrsIssue]]: # Warnings
+        errors: list[DrsIssue] = list()
+        warnings: list[DrsIssue] = list()
+        cursor_offset = 0
+        # Spaces at the beginning/end of expression:
+        start_with_space = drs_expression[0].isspace()
+        end_with_space = drs_expression[-1].isspace()
+        if start_with_space or end_with_space:
+            issue: ParserIssue = Space()
+            if self.pedantic:
+                errors.append(issue)
+            else:
+                warnings.append(issue)
+            if start_with_space:
+                previous_len = len(drs_expression)
+                drs_expression = drs_expression.lstrip()
+                cursor_offset = previous_len - len(drs_expression)
+            if end_with_space:
+                drs_expression = drs_expression.rstrip()
+        tokens = drs_expression.split(separator)
+        if len(tokens) < 2:
+            errors.append(Unparsable(expected_drs_type=drs_type))
+            return None, errors, warnings # Early exit
+        max_token_index = len(tokens)
+        cursor_position = initial_cursor_position = len(drs_expression) + 1
+        has_white_token = False
+        for index in range(max_token_index-1, -1, -1):
+            token = tokens[index]
+            if (is_white_token := token.isspace()) or (not token):
+                has_white_token = has_white_token or is_white_token
+                cursor_position -= len(token) + 1
+                del tokens[index]
+                continue
+            else:
+                break
+        if cursor_position != initial_cursor_position:
+            max_token_index = len(tokens)
+            column = cursor_position+cursor_offset
+            if (drs_type == DrsType.DIRECTORY) and (not has_white_token):
+                issue = ExtraSeparator(column=column)
+                warnings.append(issue)
+            else:
+                issue = ExtraChar(column=column)
+                errors.append(issue)
+        for index in range(max_token_index-1, -1, -1):
+            token = tokens[index]
+            len_token = len(token)
+            if not token:
+                column = cursor_position + cursor_offset
+                issue = ExtraSeparator(column=column)
+                if (drs_type != DrsType.DIRECTORY) or self.pedantic or (index == 0):
+                    errors.append(issue)
+                else:
+                    warnings.append(issue)
+                del tokens[index]
+            if token.isspace():
+                column = cursor_position + cursor_offset - len_token
+                issue = BlankToken(column=column)
+                errors.append(issue)
+                del tokens[index]
+            cursor_position -= len_token + 1
+        
+        # Mypy doesn't understand that ParserIssues are DrsIssues...
+        sorted_errors = DrsValidator._sort_parser_issues(errors) # type: ignore
+        sorted_warnings = DrsValidator._sort_parser_issues(warnings) # type: ignore
+        return tokens, sorted_errors, sorted_warnings # type: ignore
+    
+    @staticmethod
+    def _sort_parser_issues(issues: list[ParserIssue]) -> list[ParserIssue]:
+        return sorted(issues, key=lambda issue: issue.column if issue.column else 0)
+
+    def _validate_token(self, token: str, part: DrsPart) -> bool:
+        match part.kind:
+            case DrsPartKind.COLLECTION:
+                casted_part: DrsCollection = cast(DrsCollection, part)
+                try:
+                    matching_terms = projects.valid_term_in_collection(token,
+                                                                       self.project_id,
+                                                                       casted_part.collection_id)
+                except Exception as e:
+                    msg = f'problem while validating token: {e}.Abort.'
+                    raise ValueError(msg) from e
+                if len(matching_terms) > 0:
+                    return True
+                else:
+                    return False
+            case DrsPartKind.CONSTANT:
+                part_casted: DrsConstant = cast(DrsConstant, part)
+                return part_casted.value != token
+            case _:
+                raise ValueError(f'unsupported DRS specs part type {part.kind}')
+
+    def _create_report(self,
+                       type: DrsType,
+                       drs_expression: str,
+                       errors: list[DrsIssue],
+                       warnings: list[DrsIssue]) -> DrsValidationReport:
+        return DrsValidationReport(project_id=self.project_id, type=type,
+                                   expression=drs_expression, errors=errors, warnings=warnings)
+
+    def _validate(self,
+                  drs_expression: str,
+                  specs: DrsSpecification) -> DrsValidationReport:
+        tokens, errors, warnings = self._parse(drs_expression, specs.separator, specs.type)
+        if not tokens:
+            return self._create_report(specs.type, drs_expression, errors, warnings) # Early exit.
+        token_index = 0
+        token_max_index = len(tokens)
+        part_index = 0
+        part_max_index = len(specs.parts)
+        matching_code_mapping = dict()
+        while part_index < part_max_index:
+            token = tokens[token_index]
+            part = specs.parts[part_index]
+            if self._validate_token(token, part):
+                token_index += 1
+                part_index += 1
+                matching_code_mapping[part.__str__()] = 0
+            elif part.kind == DrsPartKind.CONSTANT or \
+                 cast(DrsCollection, part).is_required:
+                issue: ValidationIssue = InvalidToken(token=token,
+                                                      token_position=token_index+1,
+                                                      collection_id_or_constant_value=str(part))
+                errors.append(issue)
+                matching_code_mapping[part.__str__()] = 1
+                token_index += 1
+                part_index += 1
+            else: # The part is not required so try to match the token with the next part.
+                part_index += 1
+                matching_code_mapping[part.__str__()] = -1
+            if token_index == token_max_index:
+                break
+        # Cases:
+        # - All tokens and collections have been processed.
+        # - Not enough token to process all collections.
+        # - Extra tokens left whereas all collections have been processed:
+        #   + The last collections are required => report extra tokens.
+        #   + The last collections are not required and these tokens were not validated by them.
+        #     => Should report error even if the collections are not required.
+        if part_index < part_max_index: # Missing tokens.
+            for index in range(part_index, part_max_index):
+                part = specs.parts[index]
+                issue = MissingToken(collection_id=str(part), collection_position=index+1)
+                if part.kind == DrsPartKind.CONSTANT or \
+                   cast(DrsCollection, part).is_required:
+                    errors.append(issue)
+                else:
+                    warnings.append(issue)
+        elif token_index < token_max_index: # Extra tokens.
+            part_index -= token_max_index - token_index
+            for index in range(token_index, token_max_index):
+                token = tokens[index]
+                part = specs.parts[part_index]
+                if part.kind != DrsPartKind.CONSTANT           and \
+                   (not cast(DrsCollection, part).is_required) and \
+                    matching_code_mapping[part.__str__()] < 0:
+                    issue = ExtraToken(token=token, token_position=index, collection_id=str(part))
+                else:
+                    issue = ExtraToken(token=token, token_position=index, collection_id=None)
+                errors.append(issue)
+                part_index += 1
+        return self._create_report(specs.type, drs_expression, errors, warnings)
+
+
+if __name__ == "__main__":
+    project_id = 'cmip6plus'
+    validator = DrsValidator(project_id)
+    drs_expressions = [
+".CMIP6Plus.CMIP.IPSL.  .MIROC6.amip..r2i2p1f2.ACmon.od550aer. ..gn",
+]
+    import time
+    for drs_expression in drs_expressions:
+        start_time = time.perf_counter_ns()
+        report = validator.validate_dataset_id(drs_expression)
+        stop_time = time.perf_counter_ns()
+        print(f'elapsed time: {(stop_time-start_time)/1000000} ms')
+        if report.nb_errors > 0:
+            print(f'error(s): {report.nb_errors}')
+            for error in report.errors:
+                print(error)
+        else:
+            print('error(s): 0')
+        if report.nb_warnings > 0:
+            print(f'warning(s): {report.nb_warnings}')
+            for warning in report.warnings:
+                print(warning)
+        else:
+            print('warning(s): 0')

esgvoc/cli/config.py

@@ -34,6 +34,9 @@ def config(key: str |None = typer.Argument(None), value: str|None = typer.Argume
     - With no arguments: display all settings.
     - With one argument (key): display the value of the key.
     - With two arguments (key and value): modify the key's value and save.
+
+    usage : 
+    esgvoc config universe.db_path .cache/dbs/somethingelse
     """
     
     settings = load_settings()

esgvoc/cli/drs.py

@@ -0,0 +1,238 @@
+from esgvoc.apps.drs.generator import DrsGenerator
+from esgvoc.apps.drs.report import DrsValidationReport, DrsGeneratorReport
+from esgvoc.apps.drs.validator import DrsValidator
+import sys
+import typer
+from rich.console import Console
+from rich.table import Table
+from typing import List, Optional
+import esgvoc.api as ev
+import shlex
+
+app = typer.Typer()
+console = Console()
+
+
+
+# Predefined list of projects and DRS types
+# projects = ["cmip5", "cmip6","cmip6plus", "cmip7"]
+projects = ev.get_all_projects()
+drs_types = ["filename", "directory", "dataset"]
+
+def display(table):
+    """
+    Function to display a rich table in the console.
+
+    :param table: The table to be displayed
+    """
+    console = Console(record=True, width=200)
+    console.print(table)
+
+
+@app.command()
+def drsvalid(
+    drs_entries: Optional[List[str]] = typer.Argument(None, help="List of DRS validation inputs in the form <project> <drstype> <string>"),
+    file: Optional[typer.FileText] = typer.Option(None, "--file", "-f", help="File containing DRS validation inputs, one per line in the form <project> <drstype> <string>"),
+    verbose: bool = typer.Option(False, "-v", "--verbose", help="Provide detailed validation results"),
+    output: Optional[str] = typer.Option(None, "-o", "--output", help="File to save the DRS entries validation"),
+
+) -> List[DrsValidationReport]:
+    """
+    Validates DRS strings for a specific project and type.
+
+    Args:
+        drs_entries (Optional[List[str]]): A list of DRS validation inputs in the form <project> <drstype> <string>.
+        file (Optional[typer.FileText]): File containing DRS validation inputs, one per line.
+        verbose (bool): If true, prints detailed validation results.
+
+    Usage Examples:
+        # Validate multiple filenames for CMIP6
+        drsvalid cmip6 filename file1.nc file2.nc file3.nc
+
+        # Validate using a file
+        drsvalid --file drs_input.txt
+    """
+    current_project = None
+    current_drs_type = None
+    reports = []
+
+    entries = drs_entries or []
+
+    if not sys.stdin.isatty():  # Check if input is being piped via stdin
+        entries.extend(el for line in sys.stdin for el in shlex.split(line))
+
+
+    if file:
+        entries.extend(el for line in file for el in line.strip().split(" "))
+
+    i = 0
+    while i < len(entries):
+        if entries[i] in [""," "]:
+            i+=1
+            continue
+
+        if entries[i] in projects:
+            current_project = entries[i]
+            i += 1
+            continue
+        if entries[i] in drs_types:
+            current_drs_type = entries[i]
+            i += 1
+            continue
+
+        if current_project is None:
+            raise typer.BadParameter(f"Invalid project: {entries[i]}")
+
+        if current_drs_type is None:
+            raise typer.BadParameter(f"Invalid drs_type: {entries[i]}")
+
+        string = entries[i]
+        i += 1
+        validator = DrsValidator(current_project)
+        report = None
+        match current_drs_type:
+            case "filename":
+                report = validator.validate_file_name(string)
+            case "directory":
+                report = validator.validate_directory(string)
+            case "dataset":
+                report = validator.validate_dataset_id(string)
+            case _:
+                raise RuntimeError("drstype is not known")
+        reports.append(report)
+
+    if verbose:
+        table = Table(title="Validation result")
+        table.add_column("entry", style="cyan")
+        table.add_column("project & drs_type", style="cyan")
+        table.add_column("warnings", style="magenta")
+        table.add_column("errors", style="red")
+        table.add_column("valid")
+
+        for report in reports:
+            entry = str(report.expression)
+            proj_and_type = str(report.project_id) + " " + report.type + " "  
+            warnings = "\n".join(["⚠️ " + str(warning) for warning in report.warnings])
+            errors = "\n".join(["⚠️ " + str(error) for error in report.errors])
+            valid = "✅ Valid" if report else "❌ Invalid"
+
+            table.add_row("-"*4,"-"*4,"-"*4,"-"*4,"-"*4)
+            table.add_row(entry,proj_and_type, warnings, errors, valid)
+
+        console.print(table)
+    elif output:
+        with open(output, "w") as f:
+            for report in reports:
+                f.write(str(report) + "\n")
+        console.print(f"DRS validation entries saved to [green]{output}[/green]")
+
+
+    else:
+        for report in reports:
+            console.print(str(report))
+
+    return reports
+
+
+@app.command()
+def drsgen(
+    drs_entries: Optional[List[str]] = typer.Argument(None, help="List of inputs to generate DRS in the form <project> <drstype> <bag_of_tokens>"),
+    file: Optional[typer.FileText] = typer.Option(None, "--file", "-f", help="File containing DRS generation inputs, one per line in the form <project> <drstype> <bag_of_tokens>"),
+    verbose: bool = typer.Option(False, "-v", "--verbose", help="Provide detailed generation results"),
+    output: Optional[str] = typer.Option(None, "-o", "--output", help="File to save the generated DRS entries"),
+) -> List[DrsGeneratorReport]:
+    """
+    Generates DRS strings for a specific project and type based on input bag of tokens.
+
+    Args:
+        drs_entries (Optional[List[str]]): A list of inputs in the form <project> <drstype> <bag_of_tokens>.
+        file (Optional[typer.FileText]): File containing DRS generation inputs, one per line.
+        verbose (bool): If true, prints detailed generation results.
+        output (Optional[str]): File path to save the generated DRS entries.
+
+    Usage Examples:
+        # Generate multiple filenames for CMIP6
+        drsgen cmip6 filename var1=tas var2=pr
+
+        # Generate using a file
+        drsgen --file drs_input.txt
+    """
+    current_project = None
+    current_drs_type = None
+    generated_reports = []
+
+    entries = drs_entries or []
+
+    if not sys.stdin.isatty():  # Check if input is being piped via stdin
+        entries.extend(el for line in sys.stdin for el in shlex.split(line))
+
+    if file:
+        entries.extend(el for line in file for el in shlex.split(line))
+
+    i = 0
+    while i < len(entries):
+        if entries[i] in [""," "]:
+            i+=1
+            continue
+        if entries[i] in projects:
+            current_project = entries[i]
+            i += 1
+            continue
+        if entries[i] in drs_types:
+            current_drs_type = entries[i]
+            i += 1
+            continue
+
+        if current_project is None:
+            raise typer.BadParameter(f"Invalid project: {entries[i]}")
+
+        if current_drs_type is None:
+            raise typer.BadParameter(f"Invalid drs_type: {entries[i]}")
+
+        bag_of_tokens = entries[i]
+        bag_of_tokens = set(entries[i].split(" "))
+        i += 1
+
+        generator = DrsGenerator(current_project)
+        report = None
+        match current_drs_type:
+            case "filename":
+                report = generator.generate_file_name_from_bag_of_tokens(bag_of_tokens)
+            case "directory":
+                report = generator.generate_directory_from_bag_of_tokens(bag_of_tokens)
+            case "dataset":
+                report = generator.generate_dataset_id_from_bag_of_tokens(bag_of_tokens)
+            case _:
+                raise RuntimeError("drstype is not known")
+        generated_reports.append(report)
+
+    if verbose:
+        table = Table(title="Generation result")
+        table.add_column("deduced mapping entry", style="cyan")
+        table.add_column("warnings", style="magenta")
+        table.add_column("errors", style="red")
+        table.add_column("result", style="green", width=10)
+        for report in generated_reports:
+            entry = str(report.mapping_used)
+            warnings = "\n".join(["⚠️ " + str(warning) for warning in report.warnings])
+            errors = "\n".join([f"🔍 {error}" for error in report.errors])
+            result = report.computed_drs_expression
+            table.add_row(entry, warnings, errors, result)
+            table.add_row("----", "----", "----", "----")
+            if table.columns[3].width is not None and len(result) > table.columns[3].width:
+                table.columns[3].width = len(result)+1
+        console.print(table)
+
+    elif output:
+        with open(output, "w") as f:
+            for report in generated_reports:
+                f.write(str(report) + "\n")
+        console.print(f"Generated entries saved to [green]{output}[/green]")
+
+    else:
+        for report in generated_reports:
+            console.print(str(report))
+
+    return generated_reports
+if __name__ == "__main__":
+    app()

esgvoc/cli/get.py

@@ -19,7 +19,7 @@ def validate_key_format(key: str):
     """
     Validate if the key matches the XXXX:YYYY:ZZZZ format.
     """
-    if not re.match(r"^(\w*-?\w*)*:(\w*-?\w*)*:(\w*-?\w*)*$", key):
+    if not re.match(r"^[a-zA-Z0-9\/_]*:[a-zA-Z0-9\/_]*:[a-zA-Z0-9\/_]*$", key):
         raise typer.BadParameter(f"Invalid key format: {key}. Must be XXXX:YYYY:ZZZZ.")
     return key.split(":")
 

esgvoc/cli/main.py

@@ -1,12 +1,10 @@
-
 import typer
 from esgvoc.cli.config import app as config_app
 from esgvoc.cli.get import app as get_app
 from esgvoc.cli.status import app as status_app
 from esgvoc.cli.valid import app as valid_app
 from esgvoc.cli.install import app as install_app
-    
-
+from esgvoc.cli.drs import app as drs_app   
 app = typer.Typer()
 
 # Register the subcommands
@@ -15,8 +13,11 @@ app.add_typer(get_app)
 app.add_typer(status_app)
 app.add_typer(valid_app)
 app.add_typer(install_app)
+app.add_typer(drs_app)
 
 def main():
     app()
+    
+
 if __name__ == "__main__":
     main()

esgvoc/cli/status.py

@@ -1,4 +1,5 @@
 from esgvoc.core import service
+from rich.table import Table
 import typer
 from rich.console import Console
 
@@ -21,6 +22,17 @@ def status():
     """
 
     service.state_service.get_state_summary()
-    display(service.state_service.table())
+    #display(service.state_service.table())
+
+
+    table = Table(show_header=False, show_lines=True)
+
+    table.add_row("","Remote github repo","Local repository","Cache Database", style = "bright_green")
+    table.add_row("Universe path",service.state_service.universe.github_repo,service.state_service.universe.local_path,service.state_service.universe.db_path, style = "white")
+    table.add_row("Version",service.state_service.universe.github_version,service.state_service.universe.local_version,service.state_service.universe.db_version, style="bright_blue")
+    for proj_name,proj in service.state_service.projects.items():
+        table.add_row(f"{proj_name} path",proj.github_repo,proj.local_path,proj.db_path, style="white")
+        table.add_row("Version",proj.github_version,proj.local_version,proj.db_version,style ="bright_blue")
+    display(table)
 
     

esgvoc/cli/valid.py

@@ -6,10 +6,8 @@ from esgvoc.api.projects import (
     valid_term_in_project, 
     valid_term_in_all_projects
 )
-from esgvoc.api import BasicValidationErrorVisitor
 from requests import logging
 from rich.table import Table
-from sqlmodel import except_
 import typer
 import re
 from rich.console import Console
@@ -121,11 +119,9 @@ def valid(
             # Parse and collect errors for verbose mode
             if validation_result == []:
                 detailed_results.append({"validation":validation, "errors":["did not found matching term"]})
-
             results.append(False)
             if project and collection and term and exception_message is None:
-                visitor = BasicValidationErrorVisitor()
-                errors = [error.accept(visitor) for error in validation_result.errors]
+                errors = [str(error) for error in validation_result.errors]
                 detailed_results.append({"validation": validation, "errors": errors})
             if exception_message is not None:
                 detailed_results.append({"validation": validation, "errors": [exception_message]})

esgvoc/core/db/models/mixins.py

@@ -4,10 +4,17 @@ from sqlmodel import Field
 
 
 class TermKind(Enum):
+    """
+    The kinds of term.
+    """
     PLAIN = "plain"
+    """End written term."""
     PATTERN = "pattern"
+    """Regex based terms"""
     COMPOSITE = "composite"
+    """Term composed of terms."""
     MIXED = 'mixed'
+    """To be defined."""
 
 
 class PkMixin: