Skip to content

processes

Processes of POS and feature tagging.

PromptBuilder module-attribute 

PromptBuilder = (
    Callable[[str, str], PromptInfo] | PromptInfo | str
)

DependencyProcess

Bases: Process

Base class for morphosyntactic processes.

process_id class-attribute 

process_id: str = ''

glottolog_id class-attribute instance-attribute 

glottolog_id: Optional[str] = None

run abstractmethod 

run(input_doc: Doc) -> Doc

Process input_doc and return an enriched/modified copy.

Source code in cltk/core/data_types.py 
886
887
888
889
@abstractmethod
def run(self, input_doc: Doc) -> Doc:
    """Process ``input_doc`` and return an enriched/modified copy."""
    pass

GenAIDependencyProcess

Bases: DependencyProcess

Language-specific dependency process using a generative GPT model.

process_id class-attribute 

process_id: str = 'dependency.genai'

prompt_builder_from_tokens class-attribute instance-attribute 

prompt_builder_from_tokens: Optional[PromptBuilder] = None

prompt_builder_from_text class-attribute instance-attribute 

prompt_builder_from_text: Optional[PromptBuilder] = None

prompt_profile class-attribute instance-attribute 

prompt_profile: Optional[str] = None

prompt_version class-attribute instance-attribute 

prompt_version: Optional[str] = None

algorithm cached property 

algorithm: Callable[..., Doc]

Return the dependency generation function for this process.

glottolog_id class-attribute instance-attribute 

glottolog_id: Optional[str] = None

run 

run(input_doc: Doc) -> Doc

Run the configured GPT dependency parsing workflow.

Source code in cltk/dependency/processes.py 
 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
def run(self, input_doc: Doc) -> Doc:
    """Run the configured GPT dependency parsing workflow."""
    output_doc = copy(input_doc)
    if not output_doc.normalized_text:
        msg: str = "Doc must have `normalized_text`."
        bind_from_doc(output_doc).error(msg)
        raise ValueError(msg)
    # Ensure required attributes are present
    if self.glottolog_id is None:
        raise ValueError("glottolog_id must be set for sentence splitting")
    prompt_builder_from_tokens = self.prompt_builder_from_tokens
    prompt_builder_from_text = self.prompt_builder_from_text
    prompt_digest = None
    if self.prompt_profile and (
        prompt_builder_from_tokens is None or prompt_builder_from_text is None
    ):
        template = PromptProfileRegistry.get_prompt(
            self.prompt_profile, self.process_id, self.prompt_version
        )
        prompt_digest = template.digest
        if prompt_builder_from_tokens is None:

            def _builder_tokens(
                lang: str, table: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from tokens via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="tokens",
                    lang_or_dialect_name=lang,
                    token_table=table,
                    text=table,
                    sentence=table,
                )

            prompt_builder_from_tokens = _builder_tokens
        if prompt_builder_from_text is None:

            def _builder_text(
                lang: str, sentence: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from text via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="text",
                    lang_or_dialect_name=lang,
                    sentence=sentence,
                    text=sentence,
                    token_table=sentence,
                )

            prompt_builder_from_text = _builder_text
    # Callable typing does not retain keyword names; pass positionally
    output_doc = self.algorithm(
        output_doc,
        prompt_builder_from_tokens=prompt_builder_from_tokens,
        prompt_builder_from_text=prompt_builder_from_text,
        prompt_profile=self.prompt_profile,
        prompt_digest=prompt_digest,
        provenance_process=f"{self.process_id}:{self.__class__.__name__}",
    )
    return output_doc

CuneiformLuwianGenAIDependencyProcess

Bases: GenAIDependencyProcess

Language-specific dependency process using a generative GPT model.

glottolog_id class-attribute instance-attribute 

glottolog_id: Optional[str] = 'cune1239'

description class-attribute instance-attribute 

description: str = (
    "Default dependency syntax parsing process using a generative GPT model for the Cuneiform Luwian language."
)

authorship_info class-attribute instance-attribute 

authorship_info: str = 'CLTK'

process_id class-attribute 

process_id: str = 'dependency.genai'

prompt_builder_from_tokens class-attribute instance-attribute 

prompt_builder_from_tokens: Optional[PromptBuilder] = None

prompt_builder_from_text class-attribute instance-attribute 

prompt_builder_from_text: Optional[PromptBuilder] = None

prompt_profile class-attribute instance-attribute 

prompt_profile: Optional[str] = None

prompt_version class-attribute instance-attribute 

prompt_version: Optional[str] = None

algorithm cached property 

algorithm: Callable[..., Doc]

Return the dependency generation function for this process.

run 

run(input_doc: Doc) -> Doc

Run the configured GPT dependency parsing workflow.

Source code in cltk/dependency/processes.py 
 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
def run(self, input_doc: Doc) -> Doc:
    """Run the configured GPT dependency parsing workflow."""
    output_doc = copy(input_doc)
    if not output_doc.normalized_text:
        msg: str = "Doc must have `normalized_text`."
        bind_from_doc(output_doc).error(msg)
        raise ValueError(msg)
    # Ensure required attributes are present
    if self.glottolog_id is None:
        raise ValueError("glottolog_id must be set for sentence splitting")
    prompt_builder_from_tokens = self.prompt_builder_from_tokens
    prompt_builder_from_text = self.prompt_builder_from_text
    prompt_digest = None
    if self.prompt_profile and (
        prompt_builder_from_tokens is None or prompt_builder_from_text is None
    ):
        template = PromptProfileRegistry.get_prompt(
            self.prompt_profile, self.process_id, self.prompt_version
        )
        prompt_digest = template.digest
        if prompt_builder_from_tokens is None:

            def _builder_tokens(
                lang: str, table: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from tokens via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="tokens",
                    lang_or_dialect_name=lang,
                    token_table=table,
                    text=table,
                    sentence=table,
                )

            prompt_builder_from_tokens = _builder_tokens
        if prompt_builder_from_text is None:

            def _builder_text(
                lang: str, sentence: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from text via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="text",
                    lang_or_dialect_name=lang,
                    sentence=sentence,
                    text=sentence,
                    token_table=sentence,
                )

            prompt_builder_from_text = _builder_text
    # Callable typing does not retain keyword names; pass positionally
    output_doc = self.algorithm(
        output_doc,
        prompt_builder_from_tokens=prompt_builder_from_tokens,
        prompt_builder_from_text=prompt_builder_from_text,
        prompt_profile=self.prompt_profile,
        prompt_digest=prompt_digest,
        provenance_process=f"{self.process_id}:{self.__class__.__name__}",
    )
    return output_doc

HieroglyphicLuwianGenAIDependencyProcess

Bases: GenAIDependencyProcess

Language-specific dependency process using a generative GPT model.

glottolog_id class-attribute instance-attribute 

glottolog_id: Optional[str] = 'hier1240'

description class-attribute instance-attribute 

description: str = (
    "Default dependency syntax parsing process using a generative GPT model for the Hieroglyphic Luwian language."
)

authorship_info class-attribute instance-attribute 

authorship_info: str = 'CLTK'

process_id class-attribute 

process_id: str = 'dependency.genai'

prompt_builder_from_tokens class-attribute instance-attribute 

prompt_builder_from_tokens: Optional[PromptBuilder] = None

prompt_builder_from_text class-attribute instance-attribute 

prompt_builder_from_text: Optional[PromptBuilder] = None

prompt_profile class-attribute instance-attribute 

prompt_profile: Optional[str] = None

prompt_version class-attribute instance-attribute 

prompt_version: Optional[str] = None

algorithm cached property 

algorithm: Callable[..., Doc]

Return the dependency generation function for this process.

run 

run(input_doc: Doc) -> Doc

Run the configured GPT dependency parsing workflow.

Source code in cltk/dependency/processes.py 
 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
def run(self, input_doc: Doc) -> Doc:
    """Run the configured GPT dependency parsing workflow."""
    output_doc = copy(input_doc)
    if not output_doc.normalized_text:
        msg: str = "Doc must have `normalized_text`."
        bind_from_doc(output_doc).error(msg)
        raise ValueError(msg)
    # Ensure required attributes are present
    if self.glottolog_id is None:
        raise ValueError("glottolog_id must be set for sentence splitting")
    prompt_builder_from_tokens = self.prompt_builder_from_tokens
    prompt_builder_from_text = self.prompt_builder_from_text
    prompt_digest = None
    if self.prompt_profile and (
        prompt_builder_from_tokens is None or prompt_builder_from_text is None
    ):
        template = PromptProfileRegistry.get_prompt(
            self.prompt_profile, self.process_id, self.prompt_version
        )
        prompt_digest = template.digest
        if prompt_builder_from_tokens is None:

            def _builder_tokens(
                lang: str, table: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from tokens via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="tokens",
                    lang_or_dialect_name=lang,
                    token_table=table,
                    text=table,
                    sentence=table,
                )

            prompt_builder_from_tokens = _builder_tokens
        if prompt_builder_from_text is None:

            def _builder_text(
                lang: str, sentence: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from text via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="text",
                    lang_or_dialect_name=lang,
                    sentence=sentence,
                    text=sentence,
                    token_table=sentence,
                )

            prompt_builder_from_text = _builder_text
    # Callable typing does not retain keyword names; pass positionally
    output_doc = self.algorithm(
        output_doc,
        prompt_builder_from_tokens=prompt_builder_from_tokens,
        prompt_builder_from_text=prompt_builder_from_text,
        prompt_profile=self.prompt_profile,
        prompt_digest=prompt_digest,
        provenance_process=f"{self.process_id}:{self.__class__.__name__}",
    )
    return output_doc

OldPrussianGenAIDependencyProcess

Bases: GenAIDependencyProcess

Language-specific dependency process using a generative GPT model.

glottolog_id class-attribute instance-attribute 

glottolog_id: Optional[str] = 'prus1238'

description class-attribute instance-attribute 

description: str = (
    "Default dependency syntax parsing process using a generative GPT model for the Old Prussian language."
)

authorship_info class-attribute instance-attribute 

authorship_info: str = 'CLTK'

process_id class-attribute 

process_id: str = 'dependency.genai'

prompt_builder_from_tokens class-attribute instance-attribute 

prompt_builder_from_tokens: Optional[PromptBuilder] = None

prompt_builder_from_text class-attribute instance-attribute 

prompt_builder_from_text: Optional[PromptBuilder] = None

prompt_profile class-attribute instance-attribute 

prompt_profile: Optional[str] = None

prompt_version class-attribute instance-attribute 

prompt_version: Optional[str] = None

algorithm cached property 

algorithm: Callable[..., Doc]

Return the dependency generation function for this process.

run 

run(input_doc: Doc) -> Doc

Run the configured GPT dependency parsing workflow.

Source code in cltk/dependency/processes.py 
 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
def run(self, input_doc: Doc) -> Doc:
    """Run the configured GPT dependency parsing workflow."""
    output_doc = copy(input_doc)
    if not output_doc.normalized_text:
        msg: str = "Doc must have `normalized_text`."
        bind_from_doc(output_doc).error(msg)
        raise ValueError(msg)
    # Ensure required attributes are present
    if self.glottolog_id is None:
        raise ValueError("glottolog_id must be set for sentence splitting")
    prompt_builder_from_tokens = self.prompt_builder_from_tokens
    prompt_builder_from_text = self.prompt_builder_from_text
    prompt_digest = None
    if self.prompt_profile and (
        prompt_builder_from_tokens is None or prompt_builder_from_text is None
    ):
        template = PromptProfileRegistry.get_prompt(
            self.prompt_profile, self.process_id, self.prompt_version
        )
        prompt_digest = template.digest
        if prompt_builder_from_tokens is None:

            def _builder_tokens(
                lang: str, table: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from tokens via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="tokens",
                    lang_or_dialect_name=lang,
                    token_table=table,
                    text=table,
                    sentence=table,
                )

            prompt_builder_from_tokens = _builder_tokens
        if prompt_builder_from_text is None:

            def _builder_text(
                lang: str, sentence: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from text via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="text",
                    lang_or_dialect_name=lang,
                    sentence=sentence,
                    text=sentence,
                    token_table=sentence,
                )

            prompt_builder_from_text = _builder_text
    # Callable typing does not retain keyword names; pass positionally
    output_doc = self.algorithm(
        output_doc,
        prompt_builder_from_tokens=prompt_builder_from_tokens,
        prompt_builder_from_text=prompt_builder_from_text,
        prompt_profile=self.prompt_profile,
        prompt_digest=prompt_digest,
        provenance_process=f"{self.process_id}:{self.__class__.__name__}",
    )
    return output_doc

LithuanianGenAIDependencyProcess

Bases: GenAIDependencyProcess

Language-specific dependency process using a generative GPT model.

glottolog_id class-attribute instance-attribute 

glottolog_id: Optional[str] = 'lith1251'

description class-attribute instance-attribute 

description: str = (
    "Default dependency syntax parsing process using a generative GPT model for the Lithuanian language."
)

authorship_info class-attribute instance-attribute 

authorship_info: str = 'CLTK'

process_id class-attribute 

process_id: str = 'dependency.genai'

prompt_builder_from_tokens class-attribute instance-attribute 

prompt_builder_from_tokens: Optional[PromptBuilder] = None

prompt_builder_from_text class-attribute instance-attribute 

prompt_builder_from_text: Optional[PromptBuilder] = None

prompt_profile class-attribute instance-attribute 

prompt_profile: Optional[str] = None

prompt_version class-attribute instance-attribute 

prompt_version: Optional[str] = None

algorithm cached property 

algorithm: Callable[..., Doc]

Return the dependency generation function for this process.

run 

run(input_doc: Doc) -> Doc

Run the configured GPT dependency parsing workflow.

Source code in cltk/dependency/processes.py 
 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
def run(self, input_doc: Doc) -> Doc:
    """Run the configured GPT dependency parsing workflow."""
    output_doc = copy(input_doc)
    if not output_doc.normalized_text:
        msg: str = "Doc must have `normalized_text`."
        bind_from_doc(output_doc).error(msg)
        raise ValueError(msg)
    # Ensure required attributes are present
    if self.glottolog_id is None:
        raise ValueError("glottolog_id must be set for sentence splitting")
    prompt_builder_from_tokens = self.prompt_builder_from_tokens
    prompt_builder_from_text = self.prompt_builder_from_text
    prompt_digest = None
    if self.prompt_profile and (
        prompt_builder_from_tokens is None or prompt_builder_from_text is None
    ):
        template = PromptProfileRegistry.get_prompt(
            self.prompt_profile, self.process_id, self.prompt_version
        )
        prompt_digest = template.digest
        if prompt_builder_from_tokens is None:

            def _builder_tokens(
                lang: str, table: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from tokens via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="tokens",
                    lang_or_dialect_name=lang,
                    token_table=table,
                    text=table,
                    sentence=table,
                )

            prompt_builder_from_tokens = _builder_tokens
        if prompt_builder_from_text is None:

            def _builder_text(
                lang: str, sentence: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from text via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="text",
                    lang_or_dialect_name=lang,
                    sentence=sentence,
                    text=sentence,
                    token_table=sentence,
                )

            prompt_builder_from_text = _builder_text
    # Callable typing does not retain keyword names; pass positionally
    output_doc = self.algorithm(
        output_doc,
        prompt_builder_from_tokens=prompt_builder_from_tokens,
        prompt_builder_from_text=prompt_builder_from_text,
        prompt_profile=self.prompt_profile,
        prompt_digest=prompt_digest,
        provenance_process=f"{self.process_id}:{self.__class__.__name__}",
    )
    return output_doc

LatvianGenAIDependencyProcess

Bases: GenAIDependencyProcess

Language-specific dependency process using a generative GPT model.

glottolog_id class-attribute instance-attribute 

glottolog_id: Optional[str] = 'latv1249'

description class-attribute instance-attribute 

description: str = (
    "Default dependency syntax parsing process using a generative GPT model for the Latvian language."
)

authorship_info class-attribute instance-attribute 

authorship_info: str = 'CLTK'

process_id class-attribute 

process_id: str = 'dependency.genai'

prompt_builder_from_tokens class-attribute instance-attribute 

prompt_builder_from_tokens: Optional[PromptBuilder] = None

prompt_builder_from_text class-attribute instance-attribute 

prompt_builder_from_text: Optional[PromptBuilder] = None

prompt_profile class-attribute instance-attribute 

prompt_profile: Optional[str] = None

prompt_version class-attribute instance-attribute 

prompt_version: Optional[str] = None

algorithm cached property 

algorithm: Callable[..., Doc]

Return the dependency generation function for this process.

run 

run(input_doc: Doc) -> Doc

Run the configured GPT dependency parsing workflow.

Source code in cltk/dependency/processes.py 
 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
def run(self, input_doc: Doc) -> Doc:
    """Run the configured GPT dependency parsing workflow."""
    output_doc = copy(input_doc)
    if not output_doc.normalized_text:
        msg: str = "Doc must have `normalized_text`."
        bind_from_doc(output_doc).error(msg)
        raise ValueError(msg)
    # Ensure required attributes are present
    if self.glottolog_id is None:
        raise ValueError("glottolog_id must be set for sentence splitting")
    prompt_builder_from_tokens = self.prompt_builder_from_tokens
    prompt_builder_from_text = self.prompt_builder_from_text
    prompt_digest = None
    if self.prompt_profile and (
        prompt_builder_from_tokens is None or prompt_builder_from_text is None
    ):
        template = PromptProfileRegistry.get_prompt(
            self.prompt_profile, self.process_id, self.prompt_version
        )
        prompt_digest = template.digest
        if prompt_builder_from_tokens is None:

            def _builder_tokens(
                lang: str, table: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from tokens via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="tokens",
                    lang_or_dialect_name=lang,
                    token_table=table,
                    text=table,
                    sentence=table,
                )

            prompt_builder_from_tokens = _builder_tokens
        if prompt_builder_from_text is None:

            def _builder_text(
                lang: str, sentence: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from text via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="text",
                    lang_or_dialect_name=lang,
                    sentence=sentence,
                    text=sentence,
                    token_table=sentence,
                )

            prompt_builder_from_text = _builder_text
    # Callable typing does not retain keyword names; pass positionally
    output_doc = self.algorithm(
        output_doc,
        prompt_builder_from_tokens=prompt_builder_from_tokens,
        prompt_builder_from_text=prompt_builder_from_text,
        prompt_profile=self.prompt_profile,
        prompt_digest=prompt_digest,
        provenance_process=f"{self.process_id}:{self.__class__.__name__}",
    )
    return output_doc

AlbanianGenAIDependencyProcess

Bases: GenAIDependencyProcess

Language-specific dependency process using a generative GPT model.

glottolog_id class-attribute instance-attribute 

glottolog_id: Optional[str] = 'gheg1238'

description class-attribute instance-attribute 

description: str = (
    "Default dependency syntax parsing process using a generative GPT model for the Albanian language."
)

authorship_info class-attribute instance-attribute 

authorship_info: str = 'CLTK'

process_id class-attribute 

process_id: str = 'dependency.genai'

prompt_builder_from_tokens class-attribute instance-attribute 

prompt_builder_from_tokens: Optional[PromptBuilder] = None

prompt_builder_from_text class-attribute instance-attribute 

prompt_builder_from_text: Optional[PromptBuilder] = None

prompt_profile class-attribute instance-attribute 

prompt_profile: Optional[str] = None

prompt_version class-attribute instance-attribute 

prompt_version: Optional[str] = None

algorithm cached property 

algorithm: Callable[..., Doc]

Return the dependency generation function for this process.

run 

run(input_doc: Doc) -> Doc

Run the configured GPT dependency parsing workflow.

Source code in cltk/dependency/processes.py 
 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
def run(self, input_doc: Doc) -> Doc:
    """Run the configured GPT dependency parsing workflow."""
    output_doc = copy(input_doc)
    if not output_doc.normalized_text:
        msg: str = "Doc must have `normalized_text`."
        bind_from_doc(output_doc).error(msg)
        raise ValueError(msg)
    # Ensure required attributes are present
    if self.glottolog_id is None:
        raise ValueError("glottolog_id must be set for sentence splitting")
    prompt_builder_from_tokens = self.prompt_builder_from_tokens
    prompt_builder_from_text = self.prompt_builder_from_text
    prompt_digest = None
    if self.prompt_profile and (
        prompt_builder_from_tokens is None or prompt_builder_from_text is None
    ):
        template = PromptProfileRegistry.get_prompt(
            self.prompt_profile, self.process_id, self.prompt_version
        )
        prompt_digest = template.digest
        if prompt_builder_from_tokens is None:

            def _builder_tokens(
                lang: str, table: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from tokens via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="tokens",
                    lang_or_dialect_name=lang,
                    token_table=table,
                    text=table,
                    sentence=table,
                )

            prompt_builder_from_tokens = _builder_tokens
        if prompt_builder_from_text is None:

            def _builder_text(
                lang: str, sentence: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from text via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="text",
                    lang_or_dialect_name=lang,
                    sentence=sentence,
                    text=sentence,
                    token_table=sentence,
                )

            prompt_builder_from_text = _builder_text
    # Callable typing does not retain keyword names; pass positionally
    output_doc = self.algorithm(
        output_doc,
        prompt_builder_from_tokens=prompt_builder_from_tokens,
        prompt_builder_from_text=prompt_builder_from_text,
        prompt_profile=self.prompt_profile,
        prompt_digest=prompt_digest,
        provenance_process=f"{self.process_id}:{self.__class__.__name__}",
    )
    return output_doc

AkkadianGenAIDependencyProcess

Bases: GenAIDependencyProcess

Language-specific dependency process using a generative GPT model.

glottolog_id class-attribute instance-attribute 

glottolog_id: Optional[str] = 'akka1240'

description class-attribute instance-attribute 

description: str = (
    "Default dependency syntax parsing process using a generative GPT model for the Akkadian language."
)

authorship_info class-attribute instance-attribute 

authorship_info: str = 'CLTK'

process_id class-attribute 

process_id: str = 'dependency.genai'

prompt_builder_from_tokens class-attribute instance-attribute 

prompt_builder_from_tokens: Optional[PromptBuilder] = None

prompt_builder_from_text class-attribute instance-attribute 

prompt_builder_from_text: Optional[PromptBuilder] = None

prompt_profile class-attribute instance-attribute 

prompt_profile: Optional[str] = None

prompt_version class-attribute instance-attribute 

prompt_version: Optional[str] = None

algorithm cached property 

algorithm: Callable[..., Doc]

Return the dependency generation function for this process.

run 

run(input_doc: Doc) -> Doc

Run the configured GPT dependency parsing workflow.

Source code in cltk/dependency/processes.py 
 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
def run(self, input_doc: Doc) -> Doc:
    """Run the configured GPT dependency parsing workflow."""
    output_doc = copy(input_doc)
    if not output_doc.normalized_text:
        msg: str = "Doc must have `normalized_text`."
        bind_from_doc(output_doc).error(msg)
        raise ValueError(msg)
    # Ensure required attributes are present
    if self.glottolog_id is None:
        raise ValueError("glottolog_id must be set for sentence splitting")
    prompt_builder_from_tokens = self.prompt_builder_from_tokens
    prompt_builder_from_text = self.prompt_builder_from_text
    prompt_digest = None
    if self.prompt_profile and (
        prompt_builder_from_tokens is None or prompt_builder_from_text is None
    ):
        template = PromptProfileRegistry.get_prompt(
            self.prompt_profile, self.process_id, self.prompt_version
        )
        prompt_digest = template.digest
        if prompt_builder_from_tokens is None:

            def _builder_tokens(
                lang: str, table: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from tokens via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="tokens",
                    lang_or_dialect_name=lang,
                    token_table=table,
                    text=table,
                    sentence=table,
                )

            prompt_builder_from_tokens = _builder_tokens
        if prompt_builder_from_text is None:

            def _builder_text(
                lang: str, sentence: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from text via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="text",
                    lang_or_dialect_name=lang,
                    sentence=sentence,
                    text=sentence,
                    token_table=sentence,
                )

            prompt_builder_from_text = _builder_text
    # Callable typing does not retain keyword names; pass positionally
    output_doc = self.algorithm(
        output_doc,
        prompt_builder_from_tokens=prompt_builder_from_tokens,
        prompt_builder_from_text=prompt_builder_from_text,
        prompt_profile=self.prompt_profile,
        prompt_digest=prompt_digest,
        provenance_process=f"{self.process_id}:{self.__class__.__name__}",
    )
    return output_doc

AncientGreekGenAIDependencyProcess

Bases: GenAIDependencyProcess

Language-specific dependency process using a generative GPT model.

glottolog_id class-attribute instance-attribute 

glottolog_id: Optional[str] = 'anci1242'

description class-attribute instance-attribute 

description: str = (
    "Default dependency syntax parsing process using a generative GPT model for the Ancient Greek language."
)

authorship_info class-attribute instance-attribute 

authorship_info: str = 'CLTK'

process_id class-attribute 

process_id: str = 'dependency.genai'

prompt_builder_from_tokens class-attribute instance-attribute 

prompt_builder_from_tokens: Optional[PromptBuilder] = None

prompt_builder_from_text class-attribute instance-attribute 

prompt_builder_from_text: Optional[PromptBuilder] = None

prompt_profile class-attribute instance-attribute 

prompt_profile: Optional[str] = None

prompt_version class-attribute instance-attribute 

prompt_version: Optional[str] = None

algorithm cached property 

algorithm: Callable[..., Doc]

Return the dependency generation function for this process.

run 

run(input_doc: Doc) -> Doc

Run the configured GPT dependency parsing workflow.

Source code in cltk/dependency/processes.py 
 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
def run(self, input_doc: Doc) -> Doc:
    """Run the configured GPT dependency parsing workflow."""
    output_doc = copy(input_doc)
    if not output_doc.normalized_text:
        msg: str = "Doc must have `normalized_text`."
        bind_from_doc(output_doc).error(msg)
        raise ValueError(msg)
    # Ensure required attributes are present
    if self.glottolog_id is None:
        raise ValueError("glottolog_id must be set for sentence splitting")
    prompt_builder_from_tokens = self.prompt_builder_from_tokens
    prompt_builder_from_text = self.prompt_builder_from_text
    prompt_digest = None
    if self.prompt_profile and (
        prompt_builder_from_tokens is None or prompt_builder_from_text is None
    ):
        template = PromptProfileRegistry.get_prompt(
            self.prompt_profile, self.process_id, self.prompt_version
        )
        prompt_digest = template.digest
        if prompt_builder_from_tokens is None:

            def _builder_tokens(
                lang: str, table: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from tokens via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="tokens",
                    lang_or_dialect_name=lang,
                    token_table=table,
                    text=table,
                    sentence=table,
                )

            prompt_builder_from_tokens = _builder_tokens
        if prompt_builder_from_text is None:

            def _builder_text(
                lang: str, sentence: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from text via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="text",
                    lang_or_dialect_name=lang,
                    sentence=sentence,
                    text=sentence,
                    token_table=sentence,
                )

            prompt_builder_from_text = _builder_text
    # Callable typing does not retain keyword names; pass positionally
    output_doc = self.algorithm(
        output_doc,
        prompt_builder_from_tokens=prompt_builder_from_tokens,
        prompt_builder_from_text=prompt_builder_from_text,
        prompt_profile=self.prompt_profile,
        prompt_digest=prompt_digest,
        provenance_process=f"{self.process_id}:{self.__class__.__name__}",
    )
    return output_doc

BiblicalHebrewGenAIDependencyProcess

Bases: GenAIDependencyProcess

Language-specific dependency process using a generative GPT model.

glottolog_id class-attribute instance-attribute 

glottolog_id: Optional[str] = 'anci1244'

description class-attribute instance-attribute 

description: str = (
    "Default dependency syntax parsing process using a generative GPT model for the Biblical Hebrew language."
)

authorship_info class-attribute instance-attribute 

authorship_info: str = 'CLTK'

process_id class-attribute 

process_id: str = 'dependency.genai'

prompt_builder_from_tokens class-attribute instance-attribute 

prompt_builder_from_tokens: Optional[PromptBuilder] = None

prompt_builder_from_text class-attribute instance-attribute 

prompt_builder_from_text: Optional[PromptBuilder] = None

prompt_profile class-attribute instance-attribute 

prompt_profile: Optional[str] = None

prompt_version class-attribute instance-attribute 

prompt_version: Optional[str] = None

algorithm cached property 

algorithm: Callable[..., Doc]

Return the dependency generation function for this process.

run 

run(input_doc: Doc) -> Doc

Run the configured GPT dependency parsing workflow.

Source code in cltk/dependency/processes.py 
 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
def run(self, input_doc: Doc) -> Doc:
    """Run the configured GPT dependency parsing workflow."""
    output_doc = copy(input_doc)
    if not output_doc.normalized_text:
        msg: str = "Doc must have `normalized_text`."
        bind_from_doc(output_doc).error(msg)
        raise ValueError(msg)
    # Ensure required attributes are present
    if self.glottolog_id is None:
        raise ValueError("glottolog_id must be set for sentence splitting")
    prompt_builder_from_tokens = self.prompt_builder_from_tokens
    prompt_builder_from_text = self.prompt_builder_from_text
    prompt_digest = None
    if self.prompt_profile and (
        prompt_builder_from_tokens is None or prompt_builder_from_text is None
    ):
        template = PromptProfileRegistry.get_prompt(
            self.prompt_profile, self.process_id, self.prompt_version
        )
        prompt_digest = template.digest
        if prompt_builder_from_tokens is None:

            def _builder_tokens(
                lang: str, table: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from tokens via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="tokens",
                    lang_or_dialect_name=lang,
                    token_table=table,
                    text=table,
                    sentence=table,
                )

            prompt_builder_from_tokens = _builder_tokens
        if prompt_builder_from_text is None:

            def _builder_text(
                lang: str, sentence: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from text via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="text",
                    lang_or_dialect_name=lang,
                    sentence=sentence,
                    text=sentence,
                    token_table=sentence,
                )

            prompt_builder_from_text = _builder_text
    # Callable typing does not retain keyword names; pass positionally
    output_doc = self.algorithm(
        output_doc,
        prompt_builder_from_tokens=prompt_builder_from_tokens,
        prompt_builder_from_text=prompt_builder_from_text,
        prompt_profile=self.prompt_profile,
        prompt_digest=prompt_digest,
        provenance_process=f"{self.process_id}:{self.__class__.__name__}",
    )
    return output_doc

ClassicalArabicGenAIDependencyProcess

Bases: GenAIDependencyProcess

Language-specific dependency process using a generative GPT model.

glottolog_id class-attribute instance-attribute 

glottolog_id: Optional[str] = 'clas1259'

description class-attribute instance-attribute 

description: str = (
    "Default dependency syntax parsing process using a generative GPT model for the Classical Arabic language."
)

authorship_info class-attribute instance-attribute 

authorship_info: str = 'CLTK'

process_id class-attribute 

process_id: str = 'dependency.genai'

prompt_builder_from_tokens class-attribute instance-attribute 

prompt_builder_from_tokens: Optional[PromptBuilder] = None

prompt_builder_from_text class-attribute instance-attribute 

prompt_builder_from_text: Optional[PromptBuilder] = None

prompt_profile class-attribute instance-attribute 

prompt_profile: Optional[str] = None

prompt_version class-attribute instance-attribute 

prompt_version: Optional[str] = None

algorithm cached property 

algorithm: Callable[..., Doc]

Return the dependency generation function for this process.

run 

run(input_doc: Doc) -> Doc

Run the configured GPT dependency parsing workflow.

Source code in cltk/dependency/processes.py 
 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
def run(self, input_doc: Doc) -> Doc:
    """Run the configured GPT dependency parsing workflow."""
    output_doc = copy(input_doc)
    if not output_doc.normalized_text:
        msg: str = "Doc must have `normalized_text`."
        bind_from_doc(output_doc).error(msg)
        raise ValueError(msg)
    # Ensure required attributes are present
    if self.glottolog_id is None:
        raise ValueError("glottolog_id must be set for sentence splitting")
    prompt_builder_from_tokens = self.prompt_builder_from_tokens
    prompt_builder_from_text = self.prompt_builder_from_text
    prompt_digest = None
    if self.prompt_profile and (
        prompt_builder_from_tokens is None or prompt_builder_from_text is None
    ):
        template = PromptProfileRegistry.get_prompt(
            self.prompt_profile, self.process_id, self.prompt_version
        )
        prompt_digest = template.digest
        if prompt_builder_from_tokens is None:

            def _builder_tokens(
                lang: str, table: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from tokens via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="tokens",
                    lang_or_dialect_name=lang,
                    token_table=table,
                    text=table,
                    sentence=table,
                )

            prompt_builder_from_tokens = _builder_tokens
        if prompt_builder_from_text is None:

            def _builder_text(
                lang: str, sentence: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from text via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="text",
                    lang_or_dialect_name=lang,
                    sentence=sentence,
                    text=sentence,
                    token_table=sentence,
                )

            prompt_builder_from_text = _builder_text
    # Callable typing does not retain keyword names; pass positionally
    output_doc = self.algorithm(
        output_doc,
        prompt_builder_from_tokens=prompt_builder_from_tokens,
        prompt_builder_from_text=prompt_builder_from_text,
        prompt_profile=self.prompt_profile,
        prompt_digest=prompt_digest,
        provenance_process=f"{self.process_id}:{self.__class__.__name__}",
    )
    return output_doc

AvestanGenAIDependencyProcess

Bases: GenAIDependencyProcess

Language-specific dependency process using a generative GPT model.

glottolog_id class-attribute instance-attribute 

glottolog_id: Optional[str] = 'aves1237'

description class-attribute instance-attribute 

description: str = (
    "Default dependency syntax parsing process using a generative GPT model for the Avestan language."
)

authorship_info class-attribute instance-attribute 

authorship_info: str = 'CLTK'

process_id class-attribute 

process_id: str = 'dependency.genai'

prompt_builder_from_tokens class-attribute instance-attribute 

prompt_builder_from_tokens: Optional[PromptBuilder] = None

prompt_builder_from_text class-attribute instance-attribute 

prompt_builder_from_text: Optional[PromptBuilder] = None

prompt_profile class-attribute instance-attribute 

prompt_profile: Optional[str] = None

prompt_version class-attribute instance-attribute 

prompt_version: Optional[str] = None

algorithm cached property 

algorithm: Callable[..., Doc]

Return the dependency generation function for this process.

run 

run(input_doc: Doc) -> Doc

Run the configured GPT dependency parsing workflow.

Source code in cltk/dependency/processes.py 
 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
def run(self, input_doc: Doc) -> Doc:
    """Run the configured GPT dependency parsing workflow."""
    output_doc = copy(input_doc)
    if not output_doc.normalized_text:
        msg: str = "Doc must have `normalized_text`."
        bind_from_doc(output_doc).error(msg)
        raise ValueError(msg)
    # Ensure required attributes are present
    if self.glottolog_id is None:
        raise ValueError("glottolog_id must be set for sentence splitting")
    prompt_builder_from_tokens = self.prompt_builder_from_tokens
    prompt_builder_from_text = self.prompt_builder_from_text
    prompt_digest = None
    if self.prompt_profile and (
        prompt_builder_from_tokens is None or prompt_builder_from_text is None
    ):
        template = PromptProfileRegistry.get_prompt(
            self.prompt_profile, self.process_id, self.prompt_version
        )
        prompt_digest = template.digest
        if prompt_builder_from_tokens is None:

            def _builder_tokens(
                lang: str, table: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from tokens via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="tokens",
                    lang_or_dialect_name=lang,
                    token_table=table,
                    text=table,
                    sentence=table,
                )

            prompt_builder_from_tokens = _builder_tokens
        if prompt_builder_from_text is None:

            def _builder_text(
                lang: str, sentence: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from text via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="text",
                    lang_or_dialect_name=lang,
                    sentence=sentence,
                    text=sentence,
                    token_table=sentence,
                )

            prompt_builder_from_text = _builder_text
    # Callable typing does not retain keyword names; pass positionally
    output_doc = self.algorithm(
        output_doc,
        prompt_builder_from_tokens=prompt_builder_from_tokens,
        prompt_builder_from_text=prompt_builder_from_text,
        prompt_profile=self.prompt_profile,
        prompt_digest=prompt_digest,
        provenance_process=f"{self.process_id}:{self.__class__.__name__}",
    )
    return output_doc

BactrianGenAIDependencyProcess

Bases: GenAIDependencyProcess

Language-specific dependency process using a generative GPT model.

glottolog_id class-attribute instance-attribute 

glottolog_id: Optional[str] = 'bact1239'

description class-attribute instance-attribute 

description: str = (
    "Default dependency syntax parsing process using a generative GPT model for the Bactrian language."
)

authorship_info class-attribute instance-attribute 

authorship_info: str = 'CLTK'

process_id class-attribute 

process_id: str = 'dependency.genai'

prompt_builder_from_tokens class-attribute instance-attribute 

prompt_builder_from_tokens: Optional[PromptBuilder] = None

prompt_builder_from_text class-attribute instance-attribute 

prompt_builder_from_text: Optional[PromptBuilder] = None

prompt_profile class-attribute instance-attribute 

prompt_profile: Optional[str] = None

prompt_version class-attribute instance-attribute 

prompt_version: Optional[str] = None

algorithm cached property 

algorithm: Callable[..., Doc]

Return the dependency generation function for this process.

run 

run(input_doc: Doc) -> Doc

Run the configured GPT dependency parsing workflow.

Source code in cltk/dependency/processes.py 
 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
def run(self, input_doc: Doc) -> Doc:
    """Run the configured GPT dependency parsing workflow."""
    output_doc = copy(input_doc)
    if not output_doc.normalized_text:
        msg: str = "Doc must have `normalized_text`."
        bind_from_doc(output_doc).error(msg)
        raise ValueError(msg)
    # Ensure required attributes are present
    if self.glottolog_id is None:
        raise ValueError("glottolog_id must be set for sentence splitting")
    prompt_builder_from_tokens = self.prompt_builder_from_tokens
    prompt_builder_from_text = self.prompt_builder_from_text
    prompt_digest = None
    if self.prompt_profile and (
        prompt_builder_from_tokens is None or prompt_builder_from_text is None
    ):
        template = PromptProfileRegistry.get_prompt(
            self.prompt_profile, self.process_id, self.prompt_version
        )
        prompt_digest = template.digest
        if prompt_builder_from_tokens is None:

            def _builder_tokens(
                lang: str, table: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from tokens via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="tokens",
                    lang_or_dialect_name=lang,
                    token_table=table,
                    text=table,
                    sentence=table,
                )

            prompt_builder_from_tokens = _builder_tokens
        if prompt_builder_from_text is None:

            def _builder_text(
                lang: str, sentence: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from text via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="text",
                    lang_or_dialect_name=lang,
                    sentence=sentence,
                    text=sentence,
                    token_table=sentence,
                )

            prompt_builder_from_text = _builder_text
    # Callable typing does not retain keyword names; pass positionally
    output_doc = self.algorithm(
        output_doc,
        prompt_builder_from_tokens=prompt_builder_from_tokens,
        prompt_builder_from_text=prompt_builder_from_text,
        prompt_profile=self.prompt_profile,
        prompt_digest=prompt_digest,
        provenance_process=f"{self.process_id}:{self.__class__.__name__}",
    )
    return output_doc

SogdianGenAIDependencyProcess

Bases: GenAIDependencyProcess

Language-specific dependency process using a generative GPT model.

glottolog_id class-attribute instance-attribute 

glottolog_id: Optional[str] = 'sogd1245'

description class-attribute instance-attribute 

description: str = (
    "Default dependency syntax parsing process using a generative GPT model for the Sogdian language."
)

authorship_info class-attribute instance-attribute 

authorship_info: str = 'CLTK'

process_id class-attribute 

process_id: str = 'dependency.genai'

prompt_builder_from_tokens class-attribute instance-attribute 

prompt_builder_from_tokens: Optional[PromptBuilder] = None

prompt_builder_from_text class-attribute instance-attribute 

prompt_builder_from_text: Optional[PromptBuilder] = None

prompt_profile class-attribute instance-attribute 

prompt_profile: Optional[str] = None

prompt_version class-attribute instance-attribute 

prompt_version: Optional[str] = None

algorithm cached property 

algorithm: Callable[..., Doc]

Return the dependency generation function for this process.

run 

run(input_doc: Doc) -> Doc

Run the configured GPT dependency parsing workflow.

Source code in cltk/dependency/processes.py 
 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
def run(self, input_doc: Doc) -> Doc:
    """Run the configured GPT dependency parsing workflow."""
    output_doc = copy(input_doc)
    if not output_doc.normalized_text:
        msg: str = "Doc must have `normalized_text`."
        bind_from_doc(output_doc).error(msg)
        raise ValueError(msg)
    # Ensure required attributes are present
    if self.glottolog_id is None:
        raise ValueError("glottolog_id must be set for sentence splitting")
    prompt_builder_from_tokens = self.prompt_builder_from_tokens
    prompt_builder_from_text = self.prompt_builder_from_text
    prompt_digest = None
    if self.prompt_profile and (
        prompt_builder_from_tokens is None or prompt_builder_from_text is None
    ):
        template = PromptProfileRegistry.get_prompt(
            self.prompt_profile, self.process_id, self.prompt_version
        )
        prompt_digest = template.digest
        if prompt_builder_from_tokens is None:

            def _builder_tokens(
                lang: str, table: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from tokens via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="tokens",
                    lang_or_dialect_name=lang,
                    token_table=table,
                    text=table,
                    sentence=table,
                )

            prompt_builder_from_tokens = _builder_tokens
        if prompt_builder_from_text is None:

            def _builder_text(
                lang: str, sentence: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from text via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="text",
                    lang_or_dialect_name=lang,
                    sentence=sentence,
                    text=sentence,
                    token_table=sentence,
                )

            prompt_builder_from_text = _builder_text
    # Callable typing does not retain keyword names; pass positionally
    output_doc = self.algorithm(
        output_doc,
        prompt_builder_from_tokens=prompt_builder_from_tokens,
        prompt_builder_from_text=prompt_builder_from_text,
        prompt_profile=self.prompt_profile,
        prompt_digest=prompt_digest,
        provenance_process=f"{self.process_id}:{self.__class__.__name__}",
    )
    return output_doc

BengaliGenAIDependencyProcess

Bases: GenAIDependencyProcess

Language-specific dependency process using a generative GPT model.

glottolog_id class-attribute instance-attribute 

glottolog_id: Optional[str] = 'beng1280'

description class-attribute instance-attribute 

description: str = (
    "Default dependency syntax parsing process using a generative GPT model for the Bengali language."
)

authorship_info class-attribute instance-attribute 

authorship_info: str = 'CLTK'

process_id class-attribute 

process_id: str = 'dependency.genai'

prompt_builder_from_tokens class-attribute instance-attribute 

prompt_builder_from_tokens: Optional[PromptBuilder] = None

prompt_builder_from_text class-attribute instance-attribute 

prompt_builder_from_text: Optional[PromptBuilder] = None

prompt_profile class-attribute instance-attribute 

prompt_profile: Optional[str] = None

prompt_version class-attribute instance-attribute 

prompt_version: Optional[str] = None

algorithm cached property 

algorithm: Callable[..., Doc]

Return the dependency generation function for this process.

run 

run(input_doc: Doc) -> Doc

Run the configured GPT dependency parsing workflow.

Source code in cltk/dependency/processes.py 
 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
def run(self, input_doc: Doc) -> Doc:
    """Run the configured GPT dependency parsing workflow."""
    output_doc = copy(input_doc)
    if not output_doc.normalized_text:
        msg: str = "Doc must have `normalized_text`."
        bind_from_doc(output_doc).error(msg)
        raise ValueError(msg)
    # Ensure required attributes are present
    if self.glottolog_id is None:
        raise ValueError("glottolog_id must be set for sentence splitting")
    prompt_builder_from_tokens = self.prompt_builder_from_tokens
    prompt_builder_from_text = self.prompt_builder_from_text
    prompt_digest = None
    if self.prompt_profile and (
        prompt_builder_from_tokens is None or prompt_builder_from_text is None
    ):
        template = PromptProfileRegistry.get_prompt(
            self.prompt_profile, self.process_id, self.prompt_version
        )
        prompt_digest = template.digest
        if prompt_builder_from_tokens is None:

            def _builder_tokens(
                lang: str, table: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from tokens via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="tokens",
                    lang_or_dialect_name=lang,
                    token_table=table,
                    text=table,
                    sentence=table,
                )

            prompt_builder_from_tokens = _builder_tokens
        if prompt_builder_from_text is None:

            def _builder_text(
                lang: str, sentence: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from text via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="text",
                    lang_or_dialect_name=lang,
                    sentence=sentence,
                    text=sentence,
                    token_table=sentence,
                )

            prompt_builder_from_text = _builder_text
    # Callable typing does not retain keyword names; pass positionally
    output_doc = self.algorithm(
        output_doc,
        prompt_builder_from_tokens=prompt_builder_from_tokens,
        prompt_builder_from_text=prompt_builder_from_text,
        prompt_profile=self.prompt_profile,
        prompt_digest=prompt_digest,
        provenance_process=f"{self.process_id}:{self.__class__.__name__}",
    )
    return output_doc

CarianGenAIDependencyProcess

Bases: GenAIDependencyProcess

Language-specific dependency process using a generative GPT model.

glottolog_id class-attribute instance-attribute 

glottolog_id: Optional[str] = 'cari1274'

description class-attribute instance-attribute 

description: str = (
    "Default dependency syntax parsing process using a generative GPT model for the Carian language."
)

authorship_info class-attribute instance-attribute 

authorship_info: str = 'CLTK'

process_id class-attribute 

process_id: str = 'dependency.genai'

prompt_builder_from_tokens class-attribute instance-attribute 

prompt_builder_from_tokens: Optional[PromptBuilder] = None

prompt_builder_from_text class-attribute instance-attribute 

prompt_builder_from_text: Optional[PromptBuilder] = None

prompt_profile class-attribute instance-attribute 

prompt_profile: Optional[str] = None

prompt_version class-attribute instance-attribute 

prompt_version: Optional[str] = None

algorithm cached property 

algorithm: Callable[..., Doc]

Return the dependency generation function for this process.

run 

run(input_doc: Doc) -> Doc

Run the configured GPT dependency parsing workflow.

Source code in cltk/dependency/processes.py 
 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
def run(self, input_doc: Doc) -> Doc:
    """Run the configured GPT dependency parsing workflow."""
    output_doc = copy(input_doc)
    if not output_doc.normalized_text:
        msg: str = "Doc must have `normalized_text`."
        bind_from_doc(output_doc).error(msg)
        raise ValueError(msg)
    # Ensure required attributes are present
    if self.glottolog_id is None:
        raise ValueError("glottolog_id must be set for sentence splitting")
    prompt_builder_from_tokens = self.prompt_builder_from_tokens
    prompt_builder_from_text = self.prompt_builder_from_text
    prompt_digest = None
    if self.prompt_profile and (
        prompt_builder_from_tokens is None or prompt_builder_from_text is None
    ):
        template = PromptProfileRegistry.get_prompt(
            self.prompt_profile, self.process_id, self.prompt_version
        )
        prompt_digest = template.digest
        if prompt_builder_from_tokens is None:

            def _builder_tokens(
                lang: str, table: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from tokens via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="tokens",
                    lang_or_dialect_name=lang,
                    token_table=table,
                    text=table,
                    sentence=table,
                )

            prompt_builder_from_tokens = _builder_tokens
        if prompt_builder_from_text is None:

            def _builder_text(
                lang: str, sentence: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from text via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="text",
                    lang_or_dialect_name=lang,
                    sentence=sentence,
                    text=sentence,
                    token_table=sentence,
                )

            prompt_builder_from_text = _builder_text
    # Callable typing does not retain keyword names; pass positionally
    output_doc = self.algorithm(
        output_doc,
        prompt_builder_from_tokens=prompt_builder_from_tokens,
        prompt_builder_from_text=prompt_builder_from_text,
        prompt_profile=self.prompt_profile,
        prompt_digest=prompt_digest,
        provenance_process=f"{self.process_id}:{self.__class__.__name__}",
    )
    return output_doc

ChurchSlavicGenAIDependencyProcess

Bases: GenAIDependencyProcess

Language-specific dependency process using a generative GPT model.

glottolog_id class-attribute instance-attribute 

glottolog_id: Optional[str] = 'chur1257'

description class-attribute instance-attribute 

description: str = (
    "Default dependency syntax parsing process using a generative GPT model for the Church Slavic language."
)

authorship_info class-attribute instance-attribute 

authorship_info: str = 'CLTK'

process_id class-attribute 

process_id: str = 'dependency.genai'

prompt_builder_from_tokens class-attribute instance-attribute 

prompt_builder_from_tokens: Optional[PromptBuilder] = None

prompt_builder_from_text class-attribute instance-attribute 

prompt_builder_from_text: Optional[PromptBuilder] = None

prompt_profile class-attribute instance-attribute 

prompt_profile: Optional[str] = None

prompt_version class-attribute instance-attribute 

prompt_version: Optional[str] = None

algorithm cached property 

algorithm: Callable[..., Doc]

Return the dependency generation function for this process.

run 

run(input_doc: Doc) -> Doc

Run the configured GPT dependency parsing workflow.

Source code in cltk/dependency/processes.py 
 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
def run(self, input_doc: Doc) -> Doc:
    """Run the configured GPT dependency parsing workflow."""
    output_doc = copy(input_doc)
    if not output_doc.normalized_text:
        msg: str = "Doc must have `normalized_text`."
        bind_from_doc(output_doc).error(msg)
        raise ValueError(msg)
    # Ensure required attributes are present
    if self.glottolog_id is None:
        raise ValueError("glottolog_id must be set for sentence splitting")
    prompt_builder_from_tokens = self.prompt_builder_from_tokens
    prompt_builder_from_text = self.prompt_builder_from_text
    prompt_digest = None
    if self.prompt_profile and (
        prompt_builder_from_tokens is None or prompt_builder_from_text is None
    ):
        template = PromptProfileRegistry.get_prompt(
            self.prompt_profile, self.process_id, self.prompt_version
        )
        prompt_digest = template.digest
        if prompt_builder_from_tokens is None:

            def _builder_tokens(
                lang: str, table: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from tokens via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="tokens",
                    lang_or_dialect_name=lang,
                    token_table=table,
                    text=table,
                    sentence=table,
                )

            prompt_builder_from_tokens = _builder_tokens
        if prompt_builder_from_text is None:

            def _builder_text(
                lang: str, sentence: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from text via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="text",
                    lang_or_dialect_name=lang,
                    sentence=sentence,
                    text=sentence,
                    token_table=sentence,
                )

            prompt_builder_from_text = _builder_text
    # Callable typing does not retain keyword names; pass positionally
    output_doc = self.algorithm(
        output_doc,
        prompt_builder_from_tokens=prompt_builder_from_tokens,
        prompt_builder_from_text=prompt_builder_from_text,
        prompt_profile=self.prompt_profile,
        prompt_digest=prompt_digest,
        provenance_process=f"{self.process_id}:{self.__class__.__name__}",
    )
    return output_doc

ClassicalArmenianGenAIDependencyProcess

Bases: GenAIDependencyProcess

Language-specific dependency process using a generative GPT model.

glottolog_id class-attribute instance-attribute 

glottolog_id: Optional[str] = 'clas1256'

description class-attribute instance-attribute 

description: str = (
    "Default dependency syntax parsing process using a generative GPT model for the Classical Armenian language."
)

authorship_info class-attribute instance-attribute 

authorship_info: str = 'CLTK'

process_id class-attribute 

process_id: str = 'dependency.genai'

prompt_builder_from_tokens class-attribute instance-attribute 

prompt_builder_from_tokens: Optional[PromptBuilder] = None

prompt_builder_from_text class-attribute instance-attribute 

prompt_builder_from_text: Optional[PromptBuilder] = None

prompt_profile class-attribute instance-attribute 

prompt_profile: Optional[str] = None

prompt_version class-attribute instance-attribute 

prompt_version: Optional[str] = None

algorithm cached property 

algorithm: Callable[..., Doc]

Return the dependency generation function for this process.

run 

run(input_doc: Doc) -> Doc

Run the configured GPT dependency parsing workflow.

Source code in cltk/dependency/processes.py 
 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
def run(self, input_doc: Doc) -> Doc:
    """Run the configured GPT dependency parsing workflow."""
    output_doc = copy(input_doc)
    if not output_doc.normalized_text:
        msg: str = "Doc must have `normalized_text`."
        bind_from_doc(output_doc).error(msg)
        raise ValueError(msg)
    # Ensure required attributes are present
    if self.glottolog_id is None:
        raise ValueError("glottolog_id must be set for sentence splitting")
    prompt_builder_from_tokens = self.prompt_builder_from_tokens
    prompt_builder_from_text = self.prompt_builder_from_text
    prompt_digest = None
    if self.prompt_profile and (
        prompt_builder_from_tokens is None or prompt_builder_from_text is None
    ):
        template = PromptProfileRegistry.get_prompt(
            self.prompt_profile, self.process_id, self.prompt_version
        )
        prompt_digest = template.digest
        if prompt_builder_from_tokens is None:

            def _builder_tokens(
                lang: str, table: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from tokens via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="tokens",
                    lang_or_dialect_name=lang,
                    token_table=table,
                    text=table,
                    sentence=table,
                )

            prompt_builder_from_tokens = _builder_tokens
        if prompt_builder_from_text is None:

            def _builder_text(
                lang: str, sentence: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from text via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="text",
                    lang_or_dialect_name=lang,
                    sentence=sentence,
                    text=sentence,
                    token_table=sentence,
                )

            prompt_builder_from_text = _builder_text
    # Callable typing does not retain keyword names; pass positionally
    output_doc = self.algorithm(
        output_doc,
        prompt_builder_from_tokens=prompt_builder_from_tokens,
        prompt_builder_from_text=prompt_builder_from_text,
        prompt_profile=self.prompt_profile,
        prompt_digest=prompt_digest,
        provenance_process=f"{self.process_id}:{self.__class__.__name__}",
    )
    return output_doc

ClassicalMandaicGenAIDependencyProcess

Bases: GenAIDependencyProcess

Language-specific dependency process using a generative GPT model.

glottolog_id class-attribute instance-attribute 

glottolog_id: Optional[str] = 'clas1253'

description class-attribute instance-attribute 

description: str = (
    "Default dependency syntax parsing process using a generative GPT model for the Classical Mandaic language."
)

authorship_info class-attribute instance-attribute 

authorship_info: str = 'CLTK'

process_id class-attribute 

process_id: str = 'dependency.genai'

prompt_builder_from_tokens class-attribute instance-attribute 

prompt_builder_from_tokens: Optional[PromptBuilder] = None

prompt_builder_from_text class-attribute instance-attribute 

prompt_builder_from_text: Optional[PromptBuilder] = None

prompt_profile class-attribute instance-attribute 

prompt_profile: Optional[str] = None

prompt_version class-attribute instance-attribute 

prompt_version: Optional[str] = None

algorithm cached property 

algorithm: Callable[..., Doc]

Return the dependency generation function for this process.

run 

run(input_doc: Doc) -> Doc

Run the configured GPT dependency parsing workflow.

Source code in cltk/dependency/processes.py 
 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
def run(self, input_doc: Doc) -> Doc:
    """Run the configured GPT dependency parsing workflow."""
    output_doc = copy(input_doc)
    if not output_doc.normalized_text:
        msg: str = "Doc must have `normalized_text`."
        bind_from_doc(output_doc).error(msg)
        raise ValueError(msg)
    # Ensure required attributes are present
    if self.glottolog_id is None:
        raise ValueError("glottolog_id must be set for sentence splitting")
    prompt_builder_from_tokens = self.prompt_builder_from_tokens
    prompt_builder_from_text = self.prompt_builder_from_text
    prompt_digest = None
    if self.prompt_profile and (
        prompt_builder_from_tokens is None or prompt_builder_from_text is None
    ):
        template = PromptProfileRegistry.get_prompt(
            self.prompt_profile, self.process_id, self.prompt_version
        )
        prompt_digest = template.digest
        if prompt_builder_from_tokens is None:

            def _builder_tokens(
                lang: str, table: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from tokens via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="tokens",
                    lang_or_dialect_name=lang,
                    token_table=table,
                    text=table,
                    sentence=table,
                )

            prompt_builder_from_tokens = _builder_tokens
        if prompt_builder_from_text is None:

            def _builder_text(
                lang: str, sentence: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from text via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="text",
                    lang_or_dialect_name=lang,
                    sentence=sentence,
                    text=sentence,
                    token_table=sentence,
                )

            prompt_builder_from_text = _builder_text
    # Callable typing does not retain keyword names; pass positionally
    output_doc = self.algorithm(
        output_doc,
        prompt_builder_from_tokens=prompt_builder_from_tokens,
        prompt_builder_from_text=prompt_builder_from_text,
        prompt_profile=self.prompt_profile,
        prompt_digest=prompt_digest,
        provenance_process=f"{self.process_id}:{self.__class__.__name__}",
    )
    return output_doc

ClassicalMongolianGenAIDependencyProcess

Bases: GenAIDependencyProcess

Language-specific dependency process using a generative GPT model.

glottolog_id class-attribute instance-attribute 

glottolog_id: Optional[str] = 'mong1331'

description class-attribute instance-attribute 

description: str = (
    "Default dependency syntax parsing process using a generative GPT model for the Classical Mongolian language."
)

authorship_info class-attribute instance-attribute 

authorship_info: str = 'CLTK'

process_id class-attribute 

process_id: str = 'dependency.genai'

prompt_builder_from_tokens class-attribute instance-attribute 

prompt_builder_from_tokens: Optional[PromptBuilder] = None

prompt_builder_from_text class-attribute instance-attribute 

prompt_builder_from_text: Optional[PromptBuilder] = None

prompt_profile class-attribute instance-attribute 

prompt_profile: Optional[str] = None

prompt_version class-attribute instance-attribute 

prompt_version: Optional[str] = None

algorithm cached property 

algorithm: Callable[..., Doc]

Return the dependency generation function for this process.

run 

run(input_doc: Doc) -> Doc

Run the configured GPT dependency parsing workflow.

Source code in cltk/dependency/processes.py 
 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
def run(self, input_doc: Doc) -> Doc:
    """Run the configured GPT dependency parsing workflow."""
    output_doc = copy(input_doc)
    if not output_doc.normalized_text:
        msg: str = "Doc must have `normalized_text`."
        bind_from_doc(output_doc).error(msg)
        raise ValueError(msg)
    # Ensure required attributes are present
    if self.glottolog_id is None:
        raise ValueError("glottolog_id must be set for sentence splitting")
    prompt_builder_from_tokens = self.prompt_builder_from_tokens
    prompt_builder_from_text = self.prompt_builder_from_text
    prompt_digest = None
    if self.prompt_profile and (
        prompt_builder_from_tokens is None or prompt_builder_from_text is None
    ):
        template = PromptProfileRegistry.get_prompt(
            self.prompt_profile, self.process_id, self.prompt_version
        )
        prompt_digest = template.digest
        if prompt_builder_from_tokens is None:

            def _builder_tokens(
                lang: str, table: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from tokens via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="tokens",
                    lang_or_dialect_name=lang,
                    token_table=table,
                    text=table,
                    sentence=table,
                )

            prompt_builder_from_tokens = _builder_tokens
        if prompt_builder_from_text is None:

            def _builder_text(
                lang: str, sentence: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from text via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="text",
                    lang_or_dialect_name=lang,
                    sentence=sentence,
                    text=sentence,
                    token_table=sentence,
                )

            prompt_builder_from_text = _builder_text
    # Callable typing does not retain keyword names; pass positionally
    output_doc = self.algorithm(
        output_doc,
        prompt_builder_from_tokens=prompt_builder_from_tokens,
        prompt_builder_from_text=prompt_builder_from_text,
        prompt_profile=self.prompt_profile,
        prompt_digest=prompt_digest,
        provenance_process=f"{self.process_id}:{self.__class__.__name__}",
    )
    return output_doc

ClassicalSyriacGenAIDependencyProcess

Bases: GenAIDependencyProcess

Language-specific dependency process using a generative GPT model.

glottolog_id class-attribute instance-attribute 

glottolog_id: Optional[str] = 'clas1252'

description class-attribute instance-attribute 

description: str = (
    "Default dependency syntax parsing process using a generative GPT model for the Classical Syriac language."
)

authorship_info class-attribute instance-attribute 

authorship_info: str = 'CLTK'

process_id class-attribute 

process_id: str = 'dependency.genai'

prompt_builder_from_tokens class-attribute instance-attribute 

prompt_builder_from_tokens: Optional[PromptBuilder] = None

prompt_builder_from_text class-attribute instance-attribute 

prompt_builder_from_text: Optional[PromptBuilder] = None

prompt_profile class-attribute instance-attribute 

prompt_profile: Optional[str] = None

prompt_version class-attribute instance-attribute 

prompt_version: Optional[str] = None

algorithm cached property 

algorithm: Callable[..., Doc]

Return the dependency generation function for this process.

run 

run(input_doc: Doc) -> Doc

Run the configured GPT dependency parsing workflow.

Source code in cltk/dependency/processes.py 
 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
def run(self, input_doc: Doc) -> Doc:
    """Run the configured GPT dependency parsing workflow."""
    output_doc = copy(input_doc)
    if not output_doc.normalized_text:
        msg: str = "Doc must have `normalized_text`."
        bind_from_doc(output_doc).error(msg)
        raise ValueError(msg)
    # Ensure required attributes are present
    if self.glottolog_id is None:
        raise ValueError("glottolog_id must be set for sentence splitting")
    prompt_builder_from_tokens = self.prompt_builder_from_tokens
    prompt_builder_from_text = self.prompt_builder_from_text
    prompt_digest = None
    if self.prompt_profile and (
        prompt_builder_from_tokens is None or prompt_builder_from_text is None
    ):
        template = PromptProfileRegistry.get_prompt(
            self.prompt_profile, self.process_id, self.prompt_version
        )
        prompt_digest = template.digest
        if prompt_builder_from_tokens is None:

            def _builder_tokens(
                lang: str, table: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from tokens via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="tokens",
                    lang_or_dialect_name=lang,
                    token_table=table,
                    text=table,
                    sentence=table,
                )

            prompt_builder_from_tokens = _builder_tokens
        if prompt_builder_from_text is None:

            def _builder_text(
                lang: str, sentence: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from text via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="text",
                    lang_or_dialect_name=lang,
                    sentence=sentence,
                    text=sentence,
                    token_table=sentence,
                )

            prompt_builder_from_text = _builder_text
    # Callable typing does not retain keyword names; pass positionally
    output_doc = self.algorithm(
        output_doc,
        prompt_builder_from_tokens=prompt_builder_from_tokens,
        prompt_builder_from_text=prompt_builder_from_text,
        prompt_profile=self.prompt_profile,
        prompt_digest=prompt_digest,
        provenance_process=f"{self.process_id}:{self.__class__.__name__}",
    )
    return output_doc

ClassicalTibetanGenAIDependencyProcess

Bases: GenAIDependencyProcess

Language-specific dependency process using a generative GPT model.

glottolog_id class-attribute instance-attribute 

glottolog_id: Optional[str] = 'clas1254'

description class-attribute instance-attribute 

description: str = (
    "Default dependency syntax parsing process using a generative GPT model for the Classical Tibetan language."
)

authorship_info class-attribute instance-attribute 

authorship_info: str = 'CLTK'

process_id class-attribute 

process_id: str = 'dependency.genai'

prompt_builder_from_tokens class-attribute instance-attribute 

prompt_builder_from_tokens: Optional[PromptBuilder] = None

prompt_builder_from_text class-attribute instance-attribute 

prompt_builder_from_text: Optional[PromptBuilder] = None

prompt_profile class-attribute instance-attribute 

prompt_profile: Optional[str] = None

prompt_version class-attribute instance-attribute 

prompt_version: Optional[str] = None

algorithm cached property 

algorithm: Callable[..., Doc]

Return the dependency generation function for this process.

run 

run(input_doc: Doc) -> Doc

Run the configured GPT dependency parsing workflow.

Source code in cltk/dependency/processes.py 
 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
def run(self, input_doc: Doc) -> Doc:
    """Run the configured GPT dependency parsing workflow."""
    output_doc = copy(input_doc)
    if not output_doc.normalized_text:
        msg: str = "Doc must have `normalized_text`."
        bind_from_doc(output_doc).error(msg)
        raise ValueError(msg)
    # Ensure required attributes are present
    if self.glottolog_id is None:
        raise ValueError("glottolog_id must be set for sentence splitting")
    prompt_builder_from_tokens = self.prompt_builder_from_tokens
    prompt_builder_from_text = self.prompt_builder_from_text
    prompt_digest = None
    if self.prompt_profile and (
        prompt_builder_from_tokens is None or prompt_builder_from_text is None
    ):
        template = PromptProfileRegistry.get_prompt(
            self.prompt_profile, self.process_id, self.prompt_version
        )
        prompt_digest = template.digest
        if prompt_builder_from_tokens is None:

            def _builder_tokens(
                lang: str, table: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from tokens via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="tokens",
                    lang_or_dialect_name=lang,
                    token_table=table,
                    text=table,
                    sentence=table,
                )

            prompt_builder_from_tokens = _builder_tokens
        if prompt_builder_from_text is None:

            def _builder_text(
                lang: str, sentence: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from text via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="text",
                    lang_or_dialect_name=lang,
                    sentence=sentence,
                    text=sentence,
                    token_table=sentence,
                )

            prompt_builder_from_text = _builder_text
    # Callable typing does not retain keyword names; pass positionally
    output_doc = self.algorithm(
        output_doc,
        prompt_builder_from_tokens=prompt_builder_from_tokens,
        prompt_builder_from_text=prompt_builder_from_text,
        prompt_profile=self.prompt_profile,
        prompt_digest=prompt_digest,
        provenance_process=f"{self.process_id}:{self.__class__.__name__}",
    )
    return output_doc

CopticGenAIDependencyProcess

Bases: GenAIDependencyProcess

Language-specific dependency process using a generative GPT model.

glottolog_id class-attribute instance-attribute 

glottolog_id: Optional[str] = 'copt1239'

description class-attribute instance-attribute 

description: str = (
    "Default dependency syntax parsing process using a generative GPT model for the Coptic language."
)

authorship_info class-attribute instance-attribute 

authorship_info: str = 'CLTK'

process_id class-attribute 

process_id: str = 'dependency.genai'

prompt_builder_from_tokens class-attribute instance-attribute 

prompt_builder_from_tokens: Optional[PromptBuilder] = None

prompt_builder_from_text class-attribute instance-attribute 

prompt_builder_from_text: Optional[PromptBuilder] = None

prompt_profile class-attribute instance-attribute 

prompt_profile: Optional[str] = None

prompt_version class-attribute instance-attribute 

prompt_version: Optional[str] = None

algorithm cached property 

algorithm: Callable[..., Doc]

Return the dependency generation function for this process.

run 

run(input_doc: Doc) -> Doc

Run the configured GPT dependency parsing workflow.

Source code in cltk/dependency/processes.py 
 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
def run(self, input_doc: Doc) -> Doc:
    """Run the configured GPT dependency parsing workflow."""
    output_doc = copy(input_doc)
    if not output_doc.normalized_text:
        msg: str = "Doc must have `normalized_text`."
        bind_from_doc(output_doc).error(msg)
        raise ValueError(msg)
    # Ensure required attributes are present
    if self.glottolog_id is None:
        raise ValueError("glottolog_id must be set for sentence splitting")
    prompt_builder_from_tokens = self.prompt_builder_from_tokens
    prompt_builder_from_text = self.prompt_builder_from_text
    prompt_digest = None
    if self.prompt_profile and (
        prompt_builder_from_tokens is None or prompt_builder_from_text is None
    ):
        template = PromptProfileRegistry.get_prompt(
            self.prompt_profile, self.process_id, self.prompt_version
        )
        prompt_digest = template.digest
        if prompt_builder_from_tokens is None:

            def _builder_tokens(
                lang: str, table: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from tokens via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="tokens",
                    lang_or_dialect_name=lang,
                    token_table=table,
                    text=table,
                    sentence=table,
                )

            prompt_builder_from_tokens = _builder_tokens
        if prompt_builder_from_text is None:

            def _builder_text(
                lang: str, sentence: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from text via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="text",
                    lang_or_dialect_name=lang,
                    sentence=sentence,
                    text=sentence,
                    token_table=sentence,
                )

            prompt_builder_from_text = _builder_text
    # Callable typing does not retain keyword names; pass positionally
    output_doc = self.algorithm(
        output_doc,
        prompt_builder_from_tokens=prompt_builder_from_tokens,
        prompt_builder_from_text=prompt_builder_from_text,
        prompt_profile=self.prompt_profile,
        prompt_digest=prompt_digest,
        provenance_process=f"{self.process_id}:{self.__class__.__name__}",
    )
    return output_doc

DemoticGenAIDependencyProcess

Bases: GenAIDependencyProcess

Language-specific dependency process using a generative GPT model.

glottolog_id class-attribute instance-attribute 

glottolog_id: Optional[str] = 'demo1234'

description class-attribute instance-attribute 

description: str = (
    "Default dependency syntax parsing process using a generative GPT model for the Demotic language."
)

authorship_info class-attribute instance-attribute 

authorship_info: str = 'CLTK'

process_id class-attribute 

process_id: str = 'dependency.genai'

prompt_builder_from_tokens class-attribute instance-attribute 

prompt_builder_from_tokens: Optional[PromptBuilder] = None

prompt_builder_from_text class-attribute instance-attribute 

prompt_builder_from_text: Optional[PromptBuilder] = None

prompt_profile class-attribute instance-attribute 

prompt_profile: Optional[str] = None

prompt_version class-attribute instance-attribute 

prompt_version: Optional[str] = None

algorithm cached property 

algorithm: Callable[..., Doc]

Return the dependency generation function for this process.

run 

run(input_doc: Doc) -> Doc

Run the configured GPT dependency parsing workflow.

Source code in cltk/dependency/processes.py 
 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
def run(self, input_doc: Doc) -> Doc:
    """Run the configured GPT dependency parsing workflow."""
    output_doc = copy(input_doc)
    if not output_doc.normalized_text:
        msg: str = "Doc must have `normalized_text`."
        bind_from_doc(output_doc).error(msg)
        raise ValueError(msg)
    # Ensure required attributes are present
    if self.glottolog_id is None:
        raise ValueError("glottolog_id must be set for sentence splitting")
    prompt_builder_from_tokens = self.prompt_builder_from_tokens
    prompt_builder_from_text = self.prompt_builder_from_text
    prompt_digest = None
    if self.prompt_profile and (
        prompt_builder_from_tokens is None or prompt_builder_from_text is None
    ):
        template = PromptProfileRegistry.get_prompt(
            self.prompt_profile, self.process_id, self.prompt_version
        )
        prompt_digest = template.digest
        if prompt_builder_from_tokens is None:

            def _builder_tokens(
                lang: str, table: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from tokens via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="tokens",
                    lang_or_dialect_name=lang,
                    token_table=table,
                    text=table,
                    sentence=table,
                )

            prompt_builder_from_tokens = _builder_tokens
        if prompt_builder_from_text is None:

            def _builder_text(
                lang: str, sentence: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from text via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="text",
                    lang_or_dialect_name=lang,
                    sentence=sentence,
                    text=sentence,
                    token_table=sentence,
                )

            prompt_builder_from_text = _builder_text
    # Callable typing does not retain keyword names; pass positionally
    output_doc = self.algorithm(
        output_doc,
        prompt_builder_from_tokens=prompt_builder_from_tokens,
        prompt_builder_from_text=prompt_builder_from_text,
        prompt_profile=self.prompt_profile,
        prompt_digest=prompt_digest,
        provenance_process=f"{self.process_id}:{self.__class__.__name__}",
    )
    return output_doc

EasternPanjabiGenAIDependencyProcess

Bases: GenAIDependencyProcess

Language-specific dependency process using a generative GPT model.

glottolog_id class-attribute instance-attribute 

glottolog_id: Optional[str] = 'panj1256'

description class-attribute instance-attribute 

description: str = (
    "Default dependency syntax parsing process using a generative GPT model for the Eastern Panjabi language."
)

authorship_info class-attribute instance-attribute 

authorship_info: str = 'CLTK'

process_id class-attribute 

process_id: str = 'dependency.genai'

prompt_builder_from_tokens class-attribute instance-attribute 

prompt_builder_from_tokens: Optional[PromptBuilder] = None

prompt_builder_from_text class-attribute instance-attribute 

prompt_builder_from_text: Optional[PromptBuilder] = None

prompt_profile class-attribute instance-attribute 

prompt_profile: Optional[str] = None

prompt_version class-attribute instance-attribute 

prompt_version: Optional[str] = None

algorithm cached property 

algorithm: Callable[..., Doc]

Return the dependency generation function for this process.

run 

run(input_doc: Doc) -> Doc

Run the configured GPT dependency parsing workflow.

Source code in cltk/dependency/processes.py 
 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
def run(self, input_doc: Doc) -> Doc:
    """Run the configured GPT dependency parsing workflow."""
    output_doc = copy(input_doc)
    if not output_doc.normalized_text:
        msg: str = "Doc must have `normalized_text`."
        bind_from_doc(output_doc).error(msg)
        raise ValueError(msg)
    # Ensure required attributes are present
    if self.glottolog_id is None:
        raise ValueError("glottolog_id must be set for sentence splitting")
    prompt_builder_from_tokens = self.prompt_builder_from_tokens
    prompt_builder_from_text = self.prompt_builder_from_text
    prompt_digest = None
    if self.prompt_profile and (
        prompt_builder_from_tokens is None or prompt_builder_from_text is None
    ):
        template = PromptProfileRegistry.get_prompt(
            self.prompt_profile, self.process_id, self.prompt_version
        )
        prompt_digest = template.digest
        if prompt_builder_from_tokens is None:

            def _builder_tokens(
                lang: str, table: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from tokens via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="tokens",
                    lang_or_dialect_name=lang,
                    token_table=table,
                    text=table,
                    sentence=table,
                )

            prompt_builder_from_tokens = _builder_tokens
        if prompt_builder_from_text is None:

            def _builder_text(
                lang: str, sentence: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from text via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="text",
                    lang_or_dialect_name=lang,
                    sentence=sentence,
                    text=sentence,
                    token_table=sentence,
                )

            prompt_builder_from_text = _builder_text
    # Callable typing does not retain keyword names; pass positionally
    output_doc = self.algorithm(
        output_doc,
        prompt_builder_from_tokens=prompt_builder_from_tokens,
        prompt_builder_from_text=prompt_builder_from_text,
        prompt_profile=self.prompt_profile,
        prompt_digest=prompt_digest,
        provenance_process=f"{self.process_id}:{self.__class__.__name__}",
    )
    return output_doc

EdomiteGenAIDependencyProcess

Bases: GenAIDependencyProcess

Language-specific dependency process using a generative GPT model.

glottolog_id class-attribute instance-attribute 

glottolog_id: Optional[str] = 'edom1234'

description class-attribute instance-attribute 

description: str = (
    "Default dependency syntax parsing process using a generative GPT model for the Edomite language."
)

authorship_info class-attribute instance-attribute 

authorship_info: str = 'CLTK'

process_id class-attribute 

process_id: str = 'dependency.genai'

prompt_builder_from_tokens class-attribute instance-attribute 

prompt_builder_from_tokens: Optional[PromptBuilder] = None

prompt_builder_from_text class-attribute instance-attribute 

prompt_builder_from_text: Optional[PromptBuilder] = None

prompt_profile class-attribute instance-attribute 

prompt_profile: Optional[str] = None

prompt_version class-attribute instance-attribute 

prompt_version: Optional[str] = None

algorithm cached property 

algorithm: Callable[..., Doc]

Return the dependency generation function for this process.

run 

run(input_doc: Doc) -> Doc

Run the configured GPT dependency parsing workflow.

Source code in cltk/dependency/processes.py 
 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
def run(self, input_doc: Doc) -> Doc:
    """Run the configured GPT dependency parsing workflow."""
    output_doc = copy(input_doc)
    if not output_doc.normalized_text:
        msg: str = "Doc must have `normalized_text`."
        bind_from_doc(output_doc).error(msg)
        raise ValueError(msg)
    # Ensure required attributes are present
    if self.glottolog_id is None:
        raise ValueError("glottolog_id must be set for sentence splitting")
    prompt_builder_from_tokens = self.prompt_builder_from_tokens
    prompt_builder_from_text = self.prompt_builder_from_text
    prompt_digest = None
    if self.prompt_profile and (
        prompt_builder_from_tokens is None or prompt_builder_from_text is None
    ):
        template = PromptProfileRegistry.get_prompt(
            self.prompt_profile, self.process_id, self.prompt_version
        )
        prompt_digest = template.digest
        if prompt_builder_from_tokens is None:

            def _builder_tokens(
                lang: str, table: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from tokens via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="tokens",
                    lang_or_dialect_name=lang,
                    token_table=table,
                    text=table,
                    sentence=table,
                )

            prompt_builder_from_tokens = _builder_tokens
        if prompt_builder_from_text is None:

            def _builder_text(
                lang: str, sentence: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from text via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="text",
                    lang_or_dialect_name=lang,
                    sentence=sentence,
                    text=sentence,
                    token_table=sentence,
                )

            prompt_builder_from_text = _builder_text
    # Callable typing does not retain keyword names; pass positionally
    output_doc = self.algorithm(
        output_doc,
        prompt_builder_from_tokens=prompt_builder_from_tokens,
        prompt_builder_from_text=prompt_builder_from_text,
        prompt_profile=self.prompt_profile,
        prompt_digest=prompt_digest,
        provenance_process=f"{self.process_id}:{self.__class__.__name__}",
    )
    return output_doc

GeezGenAIDependencyProcess

Bases: GenAIDependencyProcess

Language-specific dependency process using a generative GPT model.

glottolog_id class-attribute instance-attribute 

glottolog_id: Optional[str] = 'geez1241'

description class-attribute instance-attribute 

description: str = (
    "Default dependency syntax parsing process using a generative GPT model for the Geez language."
)

authorship_info class-attribute instance-attribute 

authorship_info: str = 'CLTK'

process_id class-attribute 

process_id: str = 'dependency.genai'

prompt_builder_from_tokens class-attribute instance-attribute 

prompt_builder_from_tokens: Optional[PromptBuilder] = None

prompt_builder_from_text class-attribute instance-attribute 

prompt_builder_from_text: Optional[PromptBuilder] = None

prompt_profile class-attribute instance-attribute 

prompt_profile: Optional[str] = None

prompt_version class-attribute instance-attribute 

prompt_version: Optional[str] = None

algorithm cached property 

algorithm: Callable[..., Doc]

Return the dependency generation function for this process.

run 

run(input_doc: Doc) -> Doc

Run the configured GPT dependency parsing workflow.

Source code in cltk/dependency/processes.py 
 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
def run(self, input_doc: Doc) -> Doc:
    """Run the configured GPT dependency parsing workflow."""
    output_doc = copy(input_doc)
    if not output_doc.normalized_text:
        msg: str = "Doc must have `normalized_text`."
        bind_from_doc(output_doc).error(msg)
        raise ValueError(msg)
    # Ensure required attributes are present
    if self.glottolog_id is None:
        raise ValueError("glottolog_id must be set for sentence splitting")
    prompt_builder_from_tokens = self.prompt_builder_from_tokens
    prompt_builder_from_text = self.prompt_builder_from_text
    prompt_digest = None
    if self.prompt_profile and (
        prompt_builder_from_tokens is None or prompt_builder_from_text is None
    ):
        template = PromptProfileRegistry.get_prompt(
            self.prompt_profile, self.process_id, self.prompt_version
        )
        prompt_digest = template.digest
        if prompt_builder_from_tokens is None:

            def _builder_tokens(
                lang: str, table: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from tokens via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="tokens",
                    lang_or_dialect_name=lang,
                    token_table=table,
                    text=table,
                    sentence=table,
                )

            prompt_builder_from_tokens = _builder_tokens
        if prompt_builder_from_text is None:

            def _builder_text(
                lang: str, sentence: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from text via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="text",
                    lang_or_dialect_name=lang,
                    sentence=sentence,
                    text=sentence,
                    token_table=sentence,
                )

            prompt_builder_from_text = _builder_text
    # Callable typing does not retain keyword names; pass positionally
    output_doc = self.algorithm(
        output_doc,
        prompt_builder_from_tokens=prompt_builder_from_tokens,
        prompt_builder_from_text=prompt_builder_from_text,
        prompt_profile=self.prompt_profile,
        prompt_digest=prompt_digest,
        provenance_process=f"{self.process_id}:{self.__class__.__name__}",
    )
    return output_doc

GothicGenAIDependencyProcess

Bases: GenAIDependencyProcess

Language-specific dependency process using a generative GPT model.

glottolog_id class-attribute instance-attribute 

glottolog_id: Optional[str] = 'goth1244'

description class-attribute instance-attribute 

description: str = (
    "Default dependency syntax parsing process using a generative GPT model for the Gothic language."
)

authorship_info class-attribute instance-attribute 

authorship_info: str = 'CLTK'

process_id class-attribute 

process_id: str = 'dependency.genai'

prompt_builder_from_tokens class-attribute instance-attribute 

prompt_builder_from_tokens: Optional[PromptBuilder] = None

prompt_builder_from_text class-attribute instance-attribute 

prompt_builder_from_text: Optional[PromptBuilder] = None

prompt_profile class-attribute instance-attribute 

prompt_profile: Optional[str] = None

prompt_version class-attribute instance-attribute 

prompt_version: Optional[str] = None

algorithm cached property 

algorithm: Callable[..., Doc]

Return the dependency generation function for this process.

run 

run(input_doc: Doc) -> Doc

Run the configured GPT dependency parsing workflow.

Source code in cltk/dependency/processes.py 
 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
def run(self, input_doc: Doc) -> Doc:
    """Run the configured GPT dependency parsing workflow."""
    output_doc = copy(input_doc)
    if not output_doc.normalized_text:
        msg: str = "Doc must have `normalized_text`."
        bind_from_doc(output_doc).error(msg)
        raise ValueError(msg)
    # Ensure required attributes are present
    if self.glottolog_id is None:
        raise ValueError("glottolog_id must be set for sentence splitting")
    prompt_builder_from_tokens = self.prompt_builder_from_tokens
    prompt_builder_from_text = self.prompt_builder_from_text
    prompt_digest = None
    if self.prompt_profile and (
        prompt_builder_from_tokens is None or prompt_builder_from_text is None
    ):
        template = PromptProfileRegistry.get_prompt(
            self.prompt_profile, self.process_id, self.prompt_version
        )
        prompt_digest = template.digest
        if prompt_builder_from_tokens is None:

            def _builder_tokens(
                lang: str, table: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from tokens via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="tokens",
                    lang_or_dialect_name=lang,
                    token_table=table,
                    text=table,
                    sentence=table,
                )

            prompt_builder_from_tokens = _builder_tokens
        if prompt_builder_from_text is None:

            def _builder_text(
                lang: str, sentence: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from text via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="text",
                    lang_or_dialect_name=lang,
                    sentence=sentence,
                    text=sentence,
                    token_table=sentence,
                )

            prompt_builder_from_text = _builder_text
    # Callable typing does not retain keyword names; pass positionally
    output_doc = self.algorithm(
        output_doc,
        prompt_builder_from_tokens=prompt_builder_from_tokens,
        prompt_builder_from_text=prompt_builder_from_text,
        prompt_profile=self.prompt_profile,
        prompt_digest=prompt_digest,
        provenance_process=f"{self.process_id}:{self.__class__.__name__}",
    )
    return output_doc

GujaratiGenAIDependencyProcess

Bases: GenAIDependencyProcess

Language-specific dependency process using a generative GPT model.

glottolog_id class-attribute instance-attribute 

glottolog_id: Optional[str] = 'guja1252'

description class-attribute instance-attribute 

description: str = (
    "Default dependency syntax parsing process using a generative GPT model for the Gujarati language."
)

authorship_info class-attribute instance-attribute 

authorship_info: str = 'CLTK'

process_id class-attribute 

process_id: str = 'dependency.genai'

prompt_builder_from_tokens class-attribute instance-attribute 

prompt_builder_from_tokens: Optional[PromptBuilder] = None

prompt_builder_from_text class-attribute instance-attribute 

prompt_builder_from_text: Optional[PromptBuilder] = None

prompt_profile class-attribute instance-attribute 

prompt_profile: Optional[str] = None

prompt_version class-attribute instance-attribute 

prompt_version: Optional[str] = None

algorithm cached property 

algorithm: Callable[..., Doc]

Return the dependency generation function for this process.

run 

run(input_doc: Doc) -> Doc

Run the configured GPT dependency parsing workflow.

Source code in cltk/dependency/processes.py 
 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
def run(self, input_doc: Doc) -> Doc:
    """Run the configured GPT dependency parsing workflow."""
    output_doc = copy(input_doc)
    if not output_doc.normalized_text:
        msg: str = "Doc must have `normalized_text`."
        bind_from_doc(output_doc).error(msg)
        raise ValueError(msg)
    # Ensure required attributes are present
    if self.glottolog_id is None:
        raise ValueError("glottolog_id must be set for sentence splitting")
    prompt_builder_from_tokens = self.prompt_builder_from_tokens
    prompt_builder_from_text = self.prompt_builder_from_text
    prompt_digest = None
    if self.prompt_profile and (
        prompt_builder_from_tokens is None or prompt_builder_from_text is None
    ):
        template = PromptProfileRegistry.get_prompt(
            self.prompt_profile, self.process_id, self.prompt_version
        )
        prompt_digest = template.digest
        if prompt_builder_from_tokens is None:

            def _builder_tokens(
                lang: str, table: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from tokens via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="tokens",
                    lang_or_dialect_name=lang,
                    token_table=table,
                    text=table,
                    sentence=table,
                )

            prompt_builder_from_tokens = _builder_tokens
        if prompt_builder_from_text is None:

            def _builder_text(
                lang: str, sentence: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from text via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="text",
                    lang_or_dialect_name=lang,
                    sentence=sentence,
                    text=sentence,
                    token_table=sentence,
                )

            prompt_builder_from_text = _builder_text
    # Callable typing does not retain keyword names; pass positionally
    output_doc = self.algorithm(
        output_doc,
        prompt_builder_from_tokens=prompt_builder_from_tokens,
        prompt_builder_from_text=prompt_builder_from_text,
        prompt_profile=self.prompt_profile,
        prompt_digest=prompt_digest,
        provenance_process=f"{self.process_id}:{self.__class__.__name__}",
    )
    return output_doc

HindiGenAIDependencyProcess

Bases: GenAIDependencyProcess

Language-specific dependency process using a generative GPT model.

glottolog_id class-attribute instance-attribute 

glottolog_id: Optional[str] = 'hind1269'

description class-attribute instance-attribute 

description: str = (
    "Default dependency syntax parsing process using a generative GPT model for the Hindi language."
)

authorship_info class-attribute instance-attribute 

authorship_info: str = 'CLTK'

process_id class-attribute 

process_id: str = 'dependency.genai'

prompt_builder_from_tokens class-attribute instance-attribute 

prompt_builder_from_tokens: Optional[PromptBuilder] = None

prompt_builder_from_text class-attribute instance-attribute 

prompt_builder_from_text: Optional[PromptBuilder] = None

prompt_profile class-attribute instance-attribute 

prompt_profile: Optional[str] = None

prompt_version class-attribute instance-attribute 

prompt_version: Optional[str] = None

algorithm cached property 

algorithm: Callable[..., Doc]

Return the dependency generation function for this process.

run 

run(input_doc: Doc) -> Doc

Run the configured GPT dependency parsing workflow.

Source code in cltk/dependency/processes.py 
 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
def run(self, input_doc: Doc) -> Doc:
    """Run the configured GPT dependency parsing workflow."""
    output_doc = copy(input_doc)
    if not output_doc.normalized_text:
        msg: str = "Doc must have `normalized_text`."
        bind_from_doc(output_doc).error(msg)
        raise ValueError(msg)
    # Ensure required attributes are present
    if self.glottolog_id is None:
        raise ValueError("glottolog_id must be set for sentence splitting")
    prompt_builder_from_tokens = self.prompt_builder_from_tokens
    prompt_builder_from_text = self.prompt_builder_from_text
    prompt_digest = None
    if self.prompt_profile and (
        prompt_builder_from_tokens is None or prompt_builder_from_text is None
    ):
        template = PromptProfileRegistry.get_prompt(
            self.prompt_profile, self.process_id, self.prompt_version
        )
        prompt_digest = template.digest
        if prompt_builder_from_tokens is None:

            def _builder_tokens(
                lang: str, table: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from tokens via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="tokens",
                    lang_or_dialect_name=lang,
                    token_table=table,
                    text=table,
                    sentence=table,
                )

            prompt_builder_from_tokens = _builder_tokens
        if prompt_builder_from_text is None:

            def _builder_text(
                lang: str, sentence: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from text via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="text",
                    lang_or_dialect_name=lang,
                    sentence=sentence,
                    text=sentence,
                    token_table=sentence,
                )

            prompt_builder_from_text = _builder_text
    # Callable typing does not retain keyword names; pass positionally
    output_doc = self.algorithm(
        output_doc,
        prompt_builder_from_tokens=prompt_builder_from_tokens,
        prompt_builder_from_text=prompt_builder_from_text,
        prompt_profile=self.prompt_profile,
        prompt_digest=prompt_digest,
        provenance_process=f"{self.process_id}:{self.__class__.__name__}",
    )
    return output_doc

KhariBoliGenAIDependencyProcess

Bases: GenAIDependencyProcess

Language-specific dependency process using a generative GPT model.

glottolog_id class-attribute instance-attribute 

glottolog_id: Optional[str] = 'khad1239'

description class-attribute instance-attribute 

description: str = (
    "Default dependency syntax parsing process using a generative GPT model for the Khari Boli dialect of Hindi."
)

authorship_info class-attribute instance-attribute 

authorship_info: str = 'CLTK'

process_id class-attribute 

process_id: str = 'dependency.genai'

prompt_builder_from_tokens class-attribute instance-attribute 

prompt_builder_from_tokens: Optional[PromptBuilder] = None

prompt_builder_from_text class-attribute instance-attribute 

prompt_builder_from_text: Optional[PromptBuilder] = None

prompt_profile class-attribute instance-attribute 

prompt_profile: Optional[str] = None

prompt_version class-attribute instance-attribute 

prompt_version: Optional[str] = None

algorithm cached property 

algorithm: Callable[..., Doc]

Return the dependency generation function for this process.

run 

run(input_doc: Doc) -> Doc

Run the configured GPT dependency parsing workflow.

Source code in cltk/dependency/processes.py 
 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
def run(self, input_doc: Doc) -> Doc:
    """Run the configured GPT dependency parsing workflow."""
    output_doc = copy(input_doc)
    if not output_doc.normalized_text:
        msg: str = "Doc must have `normalized_text`."
        bind_from_doc(output_doc).error(msg)
        raise ValueError(msg)
    # Ensure required attributes are present
    if self.glottolog_id is None:
        raise ValueError("glottolog_id must be set for sentence splitting")
    prompt_builder_from_tokens = self.prompt_builder_from_tokens
    prompt_builder_from_text = self.prompt_builder_from_text
    prompt_digest = None
    if self.prompt_profile and (
        prompt_builder_from_tokens is None or prompt_builder_from_text is None
    ):
        template = PromptProfileRegistry.get_prompt(
            self.prompt_profile, self.process_id, self.prompt_version
        )
        prompt_digest = template.digest
        if prompt_builder_from_tokens is None:

            def _builder_tokens(
                lang: str, table: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from tokens via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="tokens",
                    lang_or_dialect_name=lang,
                    token_table=table,
                    text=table,
                    sentence=table,
                )

            prompt_builder_from_tokens = _builder_tokens
        if prompt_builder_from_text is None:

            def _builder_text(
                lang: str, sentence: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from text via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="text",
                    lang_or_dialect_name=lang,
                    sentence=sentence,
                    text=sentence,
                    token_table=sentence,
                )

            prompt_builder_from_text = _builder_text
    # Callable typing does not retain keyword names; pass positionally
    output_doc = self.algorithm(
        output_doc,
        prompt_builder_from_tokens=prompt_builder_from_tokens,
        prompt_builder_from_text=prompt_builder_from_text,
        prompt_profile=self.prompt_profile,
        prompt_digest=prompt_digest,
        provenance_process=f"{self.process_id}:{self.__class__.__name__}",
    )
    return output_doc

BrajGenAIDependencyProcess

Bases: GenAIDependencyProcess

Language-specific dependency process using a generative GPT model.

glottolog_id class-attribute instance-attribute 

glottolog_id: Optional[str] = 'braj1242'

description class-attribute instance-attribute 

description: str = (
    "Default dependency syntax parsing process using a generative GPT model for the Braj Bhasha language."
)

authorship_info class-attribute instance-attribute 

authorship_info: str = 'CLTK'

process_id class-attribute 

process_id: str = 'dependency.genai'

prompt_builder_from_tokens class-attribute instance-attribute 

prompt_builder_from_tokens: Optional[PromptBuilder] = None

prompt_builder_from_text class-attribute instance-attribute 

prompt_builder_from_text: Optional[PromptBuilder] = None

prompt_profile class-attribute instance-attribute 

prompt_profile: Optional[str] = None

prompt_version class-attribute instance-attribute 

prompt_version: Optional[str] = None

algorithm cached property 

algorithm: Callable[..., Doc]

Return the dependency generation function for this process.

run 

run(input_doc: Doc) -> Doc

Run the configured GPT dependency parsing workflow.

Source code in cltk/dependency/processes.py 
 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
def run(self, input_doc: Doc) -> Doc:
    """Run the configured GPT dependency parsing workflow."""
    output_doc = copy(input_doc)
    if not output_doc.normalized_text:
        msg: str = "Doc must have `normalized_text`."
        bind_from_doc(output_doc).error(msg)
        raise ValueError(msg)
    # Ensure required attributes are present
    if self.glottolog_id is None:
        raise ValueError("glottolog_id must be set for sentence splitting")
    prompt_builder_from_tokens = self.prompt_builder_from_tokens
    prompt_builder_from_text = self.prompt_builder_from_text
    prompt_digest = None
    if self.prompt_profile and (
        prompt_builder_from_tokens is None or prompt_builder_from_text is None
    ):
        template = PromptProfileRegistry.get_prompt(
            self.prompt_profile, self.process_id, self.prompt_version
        )
        prompt_digest = template.digest
        if prompt_builder_from_tokens is None:

            def _builder_tokens(
                lang: str, table: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from tokens via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="tokens",
                    lang_or_dialect_name=lang,
                    token_table=table,
                    text=table,
                    sentence=table,
                )

            prompt_builder_from_tokens = _builder_tokens
        if prompt_builder_from_text is None:

            def _builder_text(
                lang: str, sentence: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from text via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="text",
                    lang_or_dialect_name=lang,
                    sentence=sentence,
                    text=sentence,
                    token_table=sentence,
                )

            prompt_builder_from_text = _builder_text
    # Callable typing does not retain keyword names; pass positionally
    output_doc = self.algorithm(
        output_doc,
        prompt_builder_from_tokens=prompt_builder_from_tokens,
        prompt_builder_from_text=prompt_builder_from_text,
        prompt_profile=self.prompt_profile,
        prompt_digest=prompt_digest,
        provenance_process=f"{self.process_id}:{self.__class__.__name__}",
    )
    return output_doc

AwadhiGenAIDependencyProcess

Bases: GenAIDependencyProcess

Language-specific dependency process using a generative GPT model.

glottolog_id class-attribute instance-attribute 

glottolog_id: Optional[str] = 'awad1243'

description class-attribute instance-attribute 

description: str = (
    "Default dependency syntax parsing process using a generative GPT model for the Awadhi language."
)

authorship_info class-attribute instance-attribute 

authorship_info: str = 'CLTK'

process_id class-attribute 

process_id: str = 'dependency.genai'

prompt_builder_from_tokens class-attribute instance-attribute 

prompt_builder_from_tokens: Optional[PromptBuilder] = None

prompt_builder_from_text class-attribute instance-attribute 

prompt_builder_from_text: Optional[PromptBuilder] = None

prompt_profile class-attribute instance-attribute 

prompt_profile: Optional[str] = None

prompt_version class-attribute instance-attribute 

prompt_version: Optional[str] = None

algorithm cached property 

algorithm: Callable[..., Doc]

Return the dependency generation function for this process.

run 

run(input_doc: Doc) -> Doc

Run the configured GPT dependency parsing workflow.

Source code in cltk/dependency/processes.py 
 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
def run(self, input_doc: Doc) -> Doc:
    """Run the configured GPT dependency parsing workflow."""
    output_doc = copy(input_doc)
    if not output_doc.normalized_text:
        msg: str = "Doc must have `normalized_text`."
        bind_from_doc(output_doc).error(msg)
        raise ValueError(msg)
    # Ensure required attributes are present
    if self.glottolog_id is None:
        raise ValueError("glottolog_id must be set for sentence splitting")
    prompt_builder_from_tokens = self.prompt_builder_from_tokens
    prompt_builder_from_text = self.prompt_builder_from_text
    prompt_digest = None
    if self.prompt_profile and (
        prompt_builder_from_tokens is None or prompt_builder_from_text is None
    ):
        template = PromptProfileRegistry.get_prompt(
            self.prompt_profile, self.process_id, self.prompt_version
        )
        prompt_digest = template.digest
        if prompt_builder_from_tokens is None:

            def _builder_tokens(
                lang: str, table: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from tokens via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="tokens",
                    lang_or_dialect_name=lang,
                    token_table=table,
                    text=table,
                    sentence=table,
                )

            prompt_builder_from_tokens = _builder_tokens
        if prompt_builder_from_text is None:

            def _builder_text(
                lang: str, sentence: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from text via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="text",
                    lang_or_dialect_name=lang,
                    sentence=sentence,
                    text=sentence,
                    token_table=sentence,
                )

            prompt_builder_from_text = _builder_text
    # Callable typing does not retain keyword names; pass positionally
    output_doc = self.algorithm(
        output_doc,
        prompt_builder_from_tokens=prompt_builder_from_tokens,
        prompt_builder_from_text=prompt_builder_from_text,
        prompt_profile=self.prompt_profile,
        prompt_digest=prompt_digest,
        provenance_process=f"{self.process_id}:{self.__class__.__name__}",
    )
    return output_doc

HittiteGenAIDependencyProcess

Bases: GenAIDependencyProcess

Language-specific dependency process using a generative GPT model.

glottolog_id class-attribute instance-attribute 

glottolog_id: Optional[str] = 'hitt1242'

description class-attribute instance-attribute 

description: str = (
    "Default dependency syntax parsing process using a generative GPT model for the Hittite language."
)

authorship_info class-attribute instance-attribute 

authorship_info: str = 'CLTK'

process_id class-attribute 

process_id: str = 'dependency.genai'

prompt_builder_from_tokens class-attribute instance-attribute 

prompt_builder_from_tokens: Optional[PromptBuilder] = None

prompt_builder_from_text class-attribute instance-attribute 

prompt_builder_from_text: Optional[PromptBuilder] = None

prompt_profile class-attribute instance-attribute 

prompt_profile: Optional[str] = None

prompt_version class-attribute instance-attribute 

prompt_version: Optional[str] = None

algorithm cached property 

algorithm: Callable[..., Doc]

Return the dependency generation function for this process.

run 

run(input_doc: Doc) -> Doc

Run the configured GPT dependency parsing workflow.

Source code in cltk/dependency/processes.py 
 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
def run(self, input_doc: Doc) -> Doc:
    """Run the configured GPT dependency parsing workflow."""
    output_doc = copy(input_doc)
    if not output_doc.normalized_text:
        msg: str = "Doc must have `normalized_text`."
        bind_from_doc(output_doc).error(msg)
        raise ValueError(msg)
    # Ensure required attributes are present
    if self.glottolog_id is None:
        raise ValueError("glottolog_id must be set for sentence splitting")
    prompt_builder_from_tokens = self.prompt_builder_from_tokens
    prompt_builder_from_text = self.prompt_builder_from_text
    prompt_digest = None
    if self.prompt_profile and (
        prompt_builder_from_tokens is None or prompt_builder_from_text is None
    ):
        template = PromptProfileRegistry.get_prompt(
            self.prompt_profile, self.process_id, self.prompt_version
        )
        prompt_digest = template.digest
        if prompt_builder_from_tokens is None:

            def _builder_tokens(
                lang: str, table: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from tokens via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="tokens",
                    lang_or_dialect_name=lang,
                    token_table=table,
                    text=table,
                    sentence=table,
                )

            prompt_builder_from_tokens = _builder_tokens
        if prompt_builder_from_text is None:

            def _builder_text(
                lang: str, sentence: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from text via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="text",
                    lang_or_dialect_name=lang,
                    sentence=sentence,
                    text=sentence,
                    token_table=sentence,
                )

            prompt_builder_from_text = _builder_text
    # Callable typing does not retain keyword names; pass positionally
    output_doc = self.algorithm(
        output_doc,
        prompt_builder_from_tokens=prompt_builder_from_tokens,
        prompt_builder_from_text=prompt_builder_from_text,
        prompt_profile=self.prompt_profile,
        prompt_digest=prompt_digest,
        provenance_process=f"{self.process_id}:{self.__class__.__name__}",
    )
    return output_doc

KhotaneseGenAIDependencyProcess

Bases: GenAIDependencyProcess

Language-specific dependency process using a generative GPT model.

glottolog_id class-attribute instance-attribute 

glottolog_id: Optional[str] = 'khot1251'

description class-attribute instance-attribute 

description: str = (
    "Default dependency syntax parsing process using a generative GPT model for the Khotanese language."
)

authorship_info class-attribute instance-attribute 

authorship_info: str = 'CLTK'

process_id class-attribute 

process_id: str = 'dependency.genai'

prompt_builder_from_tokens class-attribute instance-attribute 

prompt_builder_from_tokens: Optional[PromptBuilder] = None

prompt_builder_from_text class-attribute instance-attribute 

prompt_builder_from_text: Optional[PromptBuilder] = None

prompt_profile class-attribute instance-attribute 

prompt_profile: Optional[str] = None

prompt_version class-attribute instance-attribute 

prompt_version: Optional[str] = None

algorithm cached property 

algorithm: Callable[..., Doc]

Return the dependency generation function for this process.

run 

run(input_doc: Doc) -> Doc

Run the configured GPT dependency parsing workflow.

Source code in cltk/dependency/processes.py 
 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
def run(self, input_doc: Doc) -> Doc:
    """Run the configured GPT dependency parsing workflow."""
    output_doc = copy(input_doc)
    if not output_doc.normalized_text:
        msg: str = "Doc must have `normalized_text`."
        bind_from_doc(output_doc).error(msg)
        raise ValueError(msg)
    # Ensure required attributes are present
    if self.glottolog_id is None:
        raise ValueError("glottolog_id must be set for sentence splitting")
    prompt_builder_from_tokens = self.prompt_builder_from_tokens
    prompt_builder_from_text = self.prompt_builder_from_text
    prompt_digest = None
    if self.prompt_profile and (
        prompt_builder_from_tokens is None or prompt_builder_from_text is None
    ):
        template = PromptProfileRegistry.get_prompt(
            self.prompt_profile, self.process_id, self.prompt_version
        )
        prompt_digest = template.digest
        if prompt_builder_from_tokens is None:

            def _builder_tokens(
                lang: str, table: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from tokens via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="tokens",
                    lang_or_dialect_name=lang,
                    token_table=table,
                    text=table,
                    sentence=table,
                )

            prompt_builder_from_tokens = _builder_tokens
        if prompt_builder_from_text is None:

            def _builder_text(
                lang: str, sentence: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from text via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="text",
                    lang_or_dialect_name=lang,
                    sentence=sentence,
                    text=sentence,
                    token_table=sentence,
                )

            prompt_builder_from_text = _builder_text
    # Callable typing does not retain keyword names; pass positionally
    output_doc = self.algorithm(
        output_doc,
        prompt_builder_from_tokens=prompt_builder_from_tokens,
        prompt_builder_from_text=prompt_builder_from_text,
        prompt_profile=self.prompt_profile,
        prompt_digest=prompt_digest,
        provenance_process=f"{self.process_id}:{self.__class__.__name__}",
    )
    return output_doc

TumshuqeseGenAIDependencyProcess

Bases: GenAIDependencyProcess

Language-specific dependency process using a generative GPT model.

glottolog_id class-attribute instance-attribute 

glottolog_id: Optional[str] = 'tums1237'

description class-attribute instance-attribute 

description: str = (
    "Default dependency syntax parsing process using a generative GPT model for the Tumshuqese language."
)

authorship_info class-attribute instance-attribute 

authorship_info: str = 'CLTK'

process_id class-attribute 

process_id: str = 'dependency.genai'

prompt_builder_from_tokens class-attribute instance-attribute 

prompt_builder_from_tokens: Optional[PromptBuilder] = None

prompt_builder_from_text class-attribute instance-attribute 

prompt_builder_from_text: Optional[PromptBuilder] = None

prompt_profile class-attribute instance-attribute 

prompt_profile: Optional[str] = None

prompt_version class-attribute instance-attribute 

prompt_version: Optional[str] = None

algorithm cached property 

algorithm: Callable[..., Doc]

Return the dependency generation function for this process.

run 

run(input_doc: Doc) -> Doc

Run the configured GPT dependency parsing workflow.

Source code in cltk/dependency/processes.py 
 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
def run(self, input_doc: Doc) -> Doc:
    """Run the configured GPT dependency parsing workflow."""
    output_doc = copy(input_doc)
    if not output_doc.normalized_text:
        msg: str = "Doc must have `normalized_text`."
        bind_from_doc(output_doc).error(msg)
        raise ValueError(msg)
    # Ensure required attributes are present
    if self.glottolog_id is None:
        raise ValueError("glottolog_id must be set for sentence splitting")
    prompt_builder_from_tokens = self.prompt_builder_from_tokens
    prompt_builder_from_text = self.prompt_builder_from_text
    prompt_digest = None
    if self.prompt_profile and (
        prompt_builder_from_tokens is None or prompt_builder_from_text is None
    ):
        template = PromptProfileRegistry.get_prompt(
            self.prompt_profile, self.process_id, self.prompt_version
        )
        prompt_digest = template.digest
        if prompt_builder_from_tokens is None:

            def _builder_tokens(
                lang: str, table: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from tokens via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="tokens",
                    lang_or_dialect_name=lang,
                    token_table=table,
                    text=table,
                    sentence=table,
                )

            prompt_builder_from_tokens = _builder_tokens
        if prompt_builder_from_text is None:

            def _builder_text(
                lang: str, sentence: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from text via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="text",
                    lang_or_dialect_name=lang,
                    sentence=sentence,
                    text=sentence,
                    token_table=sentence,
                )

            prompt_builder_from_text = _builder_text
    # Callable typing does not retain keyword names; pass positionally
    output_doc = self.algorithm(
        output_doc,
        prompt_builder_from_tokens=prompt_builder_from_tokens,
        prompt_builder_from_text=prompt_builder_from_text,
        prompt_profile=self.prompt_profile,
        prompt_digest=prompt_digest,
        provenance_process=f"{self.process_id}:{self.__class__.__name__}",
    )
    return output_doc

LateEgyptianGenAIDependencyProcess

Bases: GenAIDependencyProcess

Language-specific dependency process using a generative GPT model.

glottolog_id class-attribute instance-attribute 

glottolog_id: Optional[str] = 'late1256'

description class-attribute instance-attribute 

description: str = (
    "Default dependency syntax parsing process using a generative GPT model for the Late Egyptian language."
)

authorship_info class-attribute instance-attribute 

authorship_info: str = 'CLTK'

process_id class-attribute 

process_id: str = 'dependency.genai'

prompt_builder_from_tokens class-attribute instance-attribute 

prompt_builder_from_tokens: Optional[PromptBuilder] = None

prompt_builder_from_text class-attribute instance-attribute 

prompt_builder_from_text: Optional[PromptBuilder] = None

prompt_profile class-attribute instance-attribute 

prompt_profile: Optional[str] = None

prompt_version class-attribute instance-attribute 

prompt_version: Optional[str] = None

algorithm cached property 

algorithm: Callable[..., Doc]

Return the dependency generation function for this process.

run 

run(input_doc: Doc) -> Doc

Run the configured GPT dependency parsing workflow.

Source code in cltk/dependency/processes.py 
 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
def run(self, input_doc: Doc) -> Doc:
    """Run the configured GPT dependency parsing workflow."""
    output_doc = copy(input_doc)
    if not output_doc.normalized_text:
        msg: str = "Doc must have `normalized_text`."
        bind_from_doc(output_doc).error(msg)
        raise ValueError(msg)
    # Ensure required attributes are present
    if self.glottolog_id is None:
        raise ValueError("glottolog_id must be set for sentence splitting")
    prompt_builder_from_tokens = self.prompt_builder_from_tokens
    prompt_builder_from_text = self.prompt_builder_from_text
    prompt_digest = None
    if self.prompt_profile and (
        prompt_builder_from_tokens is None or prompt_builder_from_text is None
    ):
        template = PromptProfileRegistry.get_prompt(
            self.prompt_profile, self.process_id, self.prompt_version
        )
        prompt_digest = template.digest
        if prompt_builder_from_tokens is None:

            def _builder_tokens(
                lang: str, table: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from tokens via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="tokens",
                    lang_or_dialect_name=lang,
                    token_table=table,
                    text=table,
                    sentence=table,
                )

            prompt_builder_from_tokens = _builder_tokens
        if prompt_builder_from_text is None:

            def _builder_text(
                lang: str, sentence: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from text via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="text",
                    lang_or_dialect_name=lang,
                    sentence=sentence,
                    text=sentence,
                    token_table=sentence,
                )

            prompt_builder_from_text = _builder_text
    # Callable typing does not retain keyword names; pass positionally
    output_doc = self.algorithm(
        output_doc,
        prompt_builder_from_tokens=prompt_builder_from_tokens,
        prompt_builder_from_text=prompt_builder_from_text,
        prompt_profile=self.prompt_profile,
        prompt_digest=prompt_digest,
        provenance_process=f"{self.process_id}:{self.__class__.__name__}",
    )
    return output_doc

LatinGenAIDependencyProcess

Bases: GenAIDependencyProcess

Language-specific dependency process using a generative GPT model.

glottolog_id class-attribute instance-attribute 

glottolog_id: Optional[str] = 'lati1261'

description class-attribute instance-attribute 

description: str = (
    "Default dependency syntax parsing process using a generative GPT model for the Latin language."
)

authorship_info class-attribute instance-attribute 

authorship_info: str = 'CLTK'

process_id class-attribute 

process_id: str = 'dependency.genai'

prompt_builder_from_tokens class-attribute instance-attribute 

prompt_builder_from_tokens: Optional[PromptBuilder] = None

prompt_builder_from_text class-attribute instance-attribute 

prompt_builder_from_text: Optional[PromptBuilder] = None

prompt_profile class-attribute instance-attribute 

prompt_profile: Optional[str] = None

prompt_version class-attribute instance-attribute 

prompt_version: Optional[str] = None

algorithm cached property 

algorithm: Callable[..., Doc]

Return the dependency generation function for this process.

run 

run(input_doc: Doc) -> Doc

Run the configured GPT dependency parsing workflow.

Source code in cltk/dependency/processes.py 
 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
def run(self, input_doc: Doc) -> Doc:
    """Run the configured GPT dependency parsing workflow."""
    output_doc = copy(input_doc)
    if not output_doc.normalized_text:
        msg: str = "Doc must have `normalized_text`."
        bind_from_doc(output_doc).error(msg)
        raise ValueError(msg)
    # Ensure required attributes are present
    if self.glottolog_id is None:
        raise ValueError("glottolog_id must be set for sentence splitting")
    prompt_builder_from_tokens = self.prompt_builder_from_tokens
    prompt_builder_from_text = self.prompt_builder_from_text
    prompt_digest = None
    if self.prompt_profile and (
        prompt_builder_from_tokens is None or prompt_builder_from_text is None
    ):
        template = PromptProfileRegistry.get_prompt(
            self.prompt_profile, self.process_id, self.prompt_version
        )
        prompt_digest = template.digest
        if prompt_builder_from_tokens is None:

            def _builder_tokens(
                lang: str, table: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from tokens via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="tokens",
                    lang_or_dialect_name=lang,
                    token_table=table,
                    text=table,
                    sentence=table,
                )

            prompt_builder_from_tokens = _builder_tokens
        if prompt_builder_from_text is None:

            def _builder_text(
                lang: str, sentence: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from text via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="text",
                    lang_or_dialect_name=lang,
                    sentence=sentence,
                    text=sentence,
                    token_table=sentence,
                )

            prompt_builder_from_text = _builder_text
    # Callable typing does not retain keyword names; pass positionally
    output_doc = self.algorithm(
        output_doc,
        prompt_builder_from_tokens=prompt_builder_from_tokens,
        prompt_builder_from_text=prompt_builder_from_text,
        prompt_profile=self.prompt_profile,
        prompt_digest=prompt_digest,
        provenance_process=f"{self.process_id}:{self.__class__.__name__}",
    )
    return output_doc

LiteraryChineseGenAIDependencyProcess

Bases: GenAIDependencyProcess

Language-specific dependency process using a generative GPT model.

glottolog_id class-attribute instance-attribute 

glottolog_id: Optional[str] = 'lite1248'

description class-attribute instance-attribute 

description: str = (
    "Default dependency syntax parsing process using a generative GPT model for the Literary Chinese language."
)

authorship_info class-attribute instance-attribute 

authorship_info: str = 'CLTK'

process_id class-attribute 

process_id: str = 'dependency.genai'

prompt_builder_from_tokens class-attribute instance-attribute 

prompt_builder_from_tokens: Optional[PromptBuilder] = None

prompt_builder_from_text class-attribute instance-attribute 

prompt_builder_from_text: Optional[PromptBuilder] = None

prompt_profile class-attribute instance-attribute 

prompt_profile: Optional[str] = None

prompt_version class-attribute instance-attribute 

prompt_version: Optional[str] = None

algorithm cached property 

algorithm: Callable[..., Doc]

Return the dependency generation function for this process.

run 

run(input_doc: Doc) -> Doc

Run the configured GPT dependency parsing workflow.

Source code in cltk/dependency/processes.py 
 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
def run(self, input_doc: Doc) -> Doc:
    """Run the configured GPT dependency parsing workflow."""
    output_doc = copy(input_doc)
    if not output_doc.normalized_text:
        msg: str = "Doc must have `normalized_text`."
        bind_from_doc(output_doc).error(msg)
        raise ValueError(msg)
    # Ensure required attributes are present
    if self.glottolog_id is None:
        raise ValueError("glottolog_id must be set for sentence splitting")
    prompt_builder_from_tokens = self.prompt_builder_from_tokens
    prompt_builder_from_text = self.prompt_builder_from_text
    prompt_digest = None
    if self.prompt_profile and (
        prompt_builder_from_tokens is None or prompt_builder_from_text is None
    ):
        template = PromptProfileRegistry.get_prompt(
            self.prompt_profile, self.process_id, self.prompt_version
        )
        prompt_digest = template.digest
        if prompt_builder_from_tokens is None:

            def _builder_tokens(
                lang: str, table: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from tokens via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="tokens",
                    lang_or_dialect_name=lang,
                    token_table=table,
                    text=table,
                    sentence=table,
                )

            prompt_builder_from_tokens = _builder_tokens
        if prompt_builder_from_text is None:

            def _builder_text(
                lang: str, sentence: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from text via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="text",
                    lang_or_dialect_name=lang,
                    sentence=sentence,
                    text=sentence,
                    token_table=sentence,
                )

            prompt_builder_from_text = _builder_text
    # Callable typing does not retain keyword names; pass positionally
    output_doc = self.algorithm(
        output_doc,
        prompt_builder_from_tokens=prompt_builder_from_tokens,
        prompt_builder_from_text=prompt_builder_from_text,
        prompt_profile=self.prompt_profile,
        prompt_digest=prompt_digest,
        provenance_process=f"{self.process_id}:{self.__class__.__name__}",
    )
    return output_doc

LycianAGenAIDependencyProcess

Bases: GenAIDependencyProcess

Language-specific dependency process using a generative GPT model.

glottolog_id class-attribute instance-attribute 

glottolog_id: Optional[str] = 'lyci1241'

description class-attribute instance-attribute 

description: str = (
    "Default dependency syntax parsing process using a generative GPT model for the Lycian A language."
)

authorship_info class-attribute instance-attribute 

authorship_info: str = 'CLTK'

process_id class-attribute 

process_id: str = 'dependency.genai'

prompt_builder_from_tokens class-attribute instance-attribute 

prompt_builder_from_tokens: Optional[PromptBuilder] = None

prompt_builder_from_text class-attribute instance-attribute 

prompt_builder_from_text: Optional[PromptBuilder] = None

prompt_profile class-attribute instance-attribute 

prompt_profile: Optional[str] = None

prompt_version class-attribute instance-attribute 

prompt_version: Optional[str] = None

algorithm cached property 

algorithm: Callable[..., Doc]

Return the dependency generation function for this process.

run 

run(input_doc: Doc) -> Doc

Run the configured GPT dependency parsing workflow.

Source code in cltk/dependency/processes.py 
 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
def run(self, input_doc: Doc) -> Doc:
    """Run the configured GPT dependency parsing workflow."""
    output_doc = copy(input_doc)
    if not output_doc.normalized_text:
        msg: str = "Doc must have `normalized_text`."
        bind_from_doc(output_doc).error(msg)
        raise ValueError(msg)
    # Ensure required attributes are present
    if self.glottolog_id is None:
        raise ValueError("glottolog_id must be set for sentence splitting")
    prompt_builder_from_tokens = self.prompt_builder_from_tokens
    prompt_builder_from_text = self.prompt_builder_from_text
    prompt_digest = None
    if self.prompt_profile and (
        prompt_builder_from_tokens is None or prompt_builder_from_text is None
    ):
        template = PromptProfileRegistry.get_prompt(
            self.prompt_profile, self.process_id, self.prompt_version
        )
        prompt_digest = template.digest
        if prompt_builder_from_tokens is None:

            def _builder_tokens(
                lang: str, table: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from tokens via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="tokens",
                    lang_or_dialect_name=lang,
                    token_table=table,
                    text=table,
                    sentence=table,
                )

            prompt_builder_from_tokens = _builder_tokens
        if prompt_builder_from_text is None:

            def _builder_text(
                lang: str, sentence: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from text via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="text",
                    lang_or_dialect_name=lang,
                    sentence=sentence,
                    text=sentence,
                    token_table=sentence,
                )

            prompt_builder_from_text = _builder_text
    # Callable typing does not retain keyword names; pass positionally
    output_doc = self.algorithm(
        output_doc,
        prompt_builder_from_tokens=prompt_builder_from_tokens,
        prompt_builder_from_text=prompt_builder_from_text,
        prompt_profile=self.prompt_profile,
        prompt_digest=prompt_digest,
        provenance_process=f"{self.process_id}:{self.__class__.__name__}",
    )
    return output_doc

LydianGenAIDependencyProcess

Bases: GenAIDependencyProcess

Language-specific dependency process using a generative GPT model.

glottolog_id class-attribute instance-attribute 

glottolog_id: Optional[str] = 'lydi1241'

description class-attribute instance-attribute 

description: str = (
    "Default dependency syntax parsing process using a generative GPT model for the Lydian language."
)

authorship_info class-attribute instance-attribute 

authorship_info: str = 'CLTK'

process_id class-attribute 

process_id: str = 'dependency.genai'

prompt_builder_from_tokens class-attribute instance-attribute 

prompt_builder_from_tokens: Optional[PromptBuilder] = None

prompt_builder_from_text class-attribute instance-attribute 

prompt_builder_from_text: Optional[PromptBuilder] = None

prompt_profile class-attribute instance-attribute 

prompt_profile: Optional[str] = None

prompt_version class-attribute instance-attribute 

prompt_version: Optional[str] = None

algorithm cached property 

algorithm: Callable[..., Doc]

Return the dependency generation function for this process.

run 

run(input_doc: Doc) -> Doc

Run the configured GPT dependency parsing workflow.

Source code in cltk/dependency/processes.py 
 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
def run(self, input_doc: Doc) -> Doc:
    """Run the configured GPT dependency parsing workflow."""
    output_doc = copy(input_doc)
    if not output_doc.normalized_text:
        msg: str = "Doc must have `normalized_text`."
        bind_from_doc(output_doc).error(msg)
        raise ValueError(msg)
    # Ensure required attributes are present
    if self.glottolog_id is None:
        raise ValueError("glottolog_id must be set for sentence splitting")
    prompt_builder_from_tokens = self.prompt_builder_from_tokens
    prompt_builder_from_text = self.prompt_builder_from_text
    prompt_digest = None
    if self.prompt_profile and (
        prompt_builder_from_tokens is None or prompt_builder_from_text is None
    ):
        template = PromptProfileRegistry.get_prompt(
            self.prompt_profile, self.process_id, self.prompt_version
        )
        prompt_digest = template.digest
        if prompt_builder_from_tokens is None:

            def _builder_tokens(
                lang: str, table: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from tokens via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="tokens",
                    lang_or_dialect_name=lang,
                    token_table=table,
                    text=table,
                    sentence=table,
                )

            prompt_builder_from_tokens = _builder_tokens
        if prompt_builder_from_text is None:

            def _builder_text(
                lang: str, sentence: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from text via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="text",
                    lang_or_dialect_name=lang,
                    sentence=sentence,
                    text=sentence,
                    token_table=sentence,
                )

            prompt_builder_from_text = _builder_text
    # Callable typing does not retain keyword names; pass positionally
    output_doc = self.algorithm(
        output_doc,
        prompt_builder_from_tokens=prompt_builder_from_tokens,
        prompt_builder_from_text=prompt_builder_from_text,
        prompt_profile=self.prompt_profile,
        prompt_digest=prompt_digest,
        provenance_process=f"{self.process_id}:{self.__class__.__name__}",
    )
    return output_doc

MaharastriPrakritGenAIDependencyProcess

Bases: GenAIDependencyProcess

Language-specific dependency process using a generative GPT model.

glottolog_id class-attribute instance-attribute 

glottolog_id: Optional[str] = 'maha1305'

description class-attribute instance-attribute 

description: str = (
    "Default dependency syntax parsing process using a generative GPT model for the Maharastri Prakrit language."
)

authorship_info class-attribute instance-attribute 

authorship_info: str = 'CLTK'

process_id class-attribute 

process_id: str = 'dependency.genai'

prompt_builder_from_tokens class-attribute instance-attribute 

prompt_builder_from_tokens: Optional[PromptBuilder] = None

prompt_builder_from_text class-attribute instance-attribute 

prompt_builder_from_text: Optional[PromptBuilder] = None

prompt_profile class-attribute instance-attribute 

prompt_profile: Optional[str] = None

prompt_version class-attribute instance-attribute 

prompt_version: Optional[str] = None

algorithm cached property 

algorithm: Callable[..., Doc]

Return the dependency generation function for this process.

run 

run(input_doc: Doc) -> Doc

Run the configured GPT dependency parsing workflow.

Source code in cltk/dependency/processes.py 
 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
def run(self, input_doc: Doc) -> Doc:
    """Run the configured GPT dependency parsing workflow."""
    output_doc = copy(input_doc)
    if not output_doc.normalized_text:
        msg: str = "Doc must have `normalized_text`."
        bind_from_doc(output_doc).error(msg)
        raise ValueError(msg)
    # Ensure required attributes are present
    if self.glottolog_id is None:
        raise ValueError("glottolog_id must be set for sentence splitting")
    prompt_builder_from_tokens = self.prompt_builder_from_tokens
    prompt_builder_from_text = self.prompt_builder_from_text
    prompt_digest = None
    if self.prompt_profile and (
        prompt_builder_from_tokens is None or prompt_builder_from_text is None
    ):
        template = PromptProfileRegistry.get_prompt(
            self.prompt_profile, self.process_id, self.prompt_version
        )
        prompt_digest = template.digest
        if prompt_builder_from_tokens is None:

            def _builder_tokens(
                lang: str, table: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from tokens via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="tokens",
                    lang_or_dialect_name=lang,
                    token_table=table,
                    text=table,
                    sentence=table,
                )

            prompt_builder_from_tokens = _builder_tokens
        if prompt_builder_from_text is None:

            def _builder_text(
                lang: str, sentence: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from text via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="text",
                    lang_or_dialect_name=lang,
                    sentence=sentence,
                    text=sentence,
                    token_table=sentence,
                )

            prompt_builder_from_text = _builder_text
    # Callable typing does not retain keyword names; pass positionally
    output_doc = self.algorithm(
        output_doc,
        prompt_builder_from_tokens=prompt_builder_from_tokens,
        prompt_builder_from_text=prompt_builder_from_text,
        prompt_profile=self.prompt_profile,
        prompt_digest=prompt_digest,
        provenance_process=f"{self.process_id}:{self.__class__.__name__}",
    )
    return output_doc

MiddleArmenianGenAIDependencyProcess

Bases: GenAIDependencyProcess

Language-specific dependency process using a generative GPT model.

glottolog_id class-attribute instance-attribute 

glottolog_id: Optional[str] = 'midd1364'

description class-attribute instance-attribute 

description: str = (
    "Default dependency syntax parsing process using a generative GPT model for the Middle Armenian language."
)

authorship_info class-attribute instance-attribute 

authorship_info: str = 'CLTK'

process_id class-attribute 

process_id: str = 'dependency.genai'

prompt_builder_from_tokens class-attribute instance-attribute 

prompt_builder_from_tokens: Optional[PromptBuilder] = None

prompt_builder_from_text class-attribute instance-attribute 

prompt_builder_from_text: Optional[PromptBuilder] = None

prompt_profile class-attribute instance-attribute 

prompt_profile: Optional[str] = None

prompt_version class-attribute instance-attribute 

prompt_version: Optional[str] = None

algorithm cached property 

algorithm: Callable[..., Doc]

Return the dependency generation function for this process.

run 

run(input_doc: Doc) -> Doc

Run the configured GPT dependency parsing workflow.

Source code in cltk/dependency/processes.py 
 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
def run(self, input_doc: Doc) -> Doc:
    """Run the configured GPT dependency parsing workflow."""
    output_doc = copy(input_doc)
    if not output_doc.normalized_text:
        msg: str = "Doc must have `normalized_text`."
        bind_from_doc(output_doc).error(msg)
        raise ValueError(msg)
    # Ensure required attributes are present
    if self.glottolog_id is None:
        raise ValueError("glottolog_id must be set for sentence splitting")
    prompt_builder_from_tokens = self.prompt_builder_from_tokens
    prompt_builder_from_text = self.prompt_builder_from_text
    prompt_digest = None
    if self.prompt_profile and (
        prompt_builder_from_tokens is None or prompt_builder_from_text is None
    ):
        template = PromptProfileRegistry.get_prompt(
            self.prompt_profile, self.process_id, self.prompt_version
        )
        prompt_digest = template.digest
        if prompt_builder_from_tokens is None:

            def _builder_tokens(
                lang: str, table: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from tokens via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="tokens",
                    lang_or_dialect_name=lang,
                    token_table=table,
                    text=table,
                    sentence=table,
                )

            prompt_builder_from_tokens = _builder_tokens
        if prompt_builder_from_text is None:

            def _builder_text(
                lang: str, sentence: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from text via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="text",
                    lang_or_dialect_name=lang,
                    sentence=sentence,
                    text=sentence,
                    token_table=sentence,
                )

            prompt_builder_from_text = _builder_text
    # Callable typing does not retain keyword names; pass positionally
    output_doc = self.algorithm(
        output_doc,
        prompt_builder_from_tokens=prompt_builder_from_tokens,
        prompt_builder_from_text=prompt_builder_from_text,
        prompt_profile=self.prompt_profile,
        prompt_digest=prompt_digest,
        provenance_process=f"{self.process_id}:{self.__class__.__name__}",
    )
    return output_doc

MiddleBretonGenAIDependencyProcess

Bases: GenAIDependencyProcess

Language-specific dependency process using a generative GPT model.

glottolog_id class-attribute instance-attribute 

glottolog_id: Optional[str] = 'oldb1244'

description class-attribute instance-attribute 

description: str = (
    "Default dependency syntax parsing process using a generative GPT model for the Middle Breton language."
)

authorship_info class-attribute instance-attribute 

authorship_info: str = 'CLTK'

process_id class-attribute 

process_id: str = 'dependency.genai'

prompt_builder_from_tokens class-attribute instance-attribute 

prompt_builder_from_tokens: Optional[PromptBuilder] = None

prompt_builder_from_text class-attribute instance-attribute 

prompt_builder_from_text: Optional[PromptBuilder] = None

prompt_profile class-attribute instance-attribute 

prompt_profile: Optional[str] = None

prompt_version class-attribute instance-attribute 

prompt_version: Optional[str] = None

algorithm cached property 

algorithm: Callable[..., Doc]

Return the dependency generation function for this process.

run 

run(input_doc: Doc) -> Doc

Run the configured GPT dependency parsing workflow.

Source code in cltk/dependency/processes.py 
 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
def run(self, input_doc: Doc) -> Doc:
    """Run the configured GPT dependency parsing workflow."""
    output_doc = copy(input_doc)
    if not output_doc.normalized_text:
        msg: str = "Doc must have `normalized_text`."
        bind_from_doc(output_doc).error(msg)
        raise ValueError(msg)
    # Ensure required attributes are present
    if self.glottolog_id is None:
        raise ValueError("glottolog_id must be set for sentence splitting")
    prompt_builder_from_tokens = self.prompt_builder_from_tokens
    prompt_builder_from_text = self.prompt_builder_from_text
    prompt_digest = None
    if self.prompt_profile and (
        prompt_builder_from_tokens is None or prompt_builder_from_text is None
    ):
        template = PromptProfileRegistry.get_prompt(
            self.prompt_profile, self.process_id, self.prompt_version
        )
        prompt_digest = template.digest
        if prompt_builder_from_tokens is None:

            def _builder_tokens(
                lang: str, table: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from tokens via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="tokens",
                    lang_or_dialect_name=lang,
                    token_table=table,
                    text=table,
                    sentence=table,
                )

            prompt_builder_from_tokens = _builder_tokens
        if prompt_builder_from_text is None:

            def _builder_text(
                lang: str, sentence: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from text via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="text",
                    lang_or_dialect_name=lang,
                    sentence=sentence,
                    text=sentence,
                    token_table=sentence,
                )

            prompt_builder_from_text = _builder_text
    # Callable typing does not retain keyword names; pass positionally
    output_doc = self.algorithm(
        output_doc,
        prompt_builder_from_tokens=prompt_builder_from_tokens,
        prompt_builder_from_text=prompt_builder_from_text,
        prompt_profile=self.prompt_profile,
        prompt_digest=prompt_digest,
        provenance_process=f"{self.process_id}:{self.__class__.__name__}",
    )
    return output_doc

MiddleChineseGenAIDependencyProcess

Bases: GenAIDependencyProcess

Language-specific dependency process using a generative GPT model.

glottolog_id class-attribute instance-attribute 

glottolog_id: Optional[str] = 'midd1344'

description class-attribute instance-attribute 

description: str = (
    "Default dependency syntax parsing process using a generative GPT model for the Middle Chinese language."
)

authorship_info class-attribute instance-attribute 

authorship_info: str = 'CLTK'

process_id class-attribute 

process_id: str = 'dependency.genai'

prompt_builder_from_tokens class-attribute instance-attribute 

prompt_builder_from_tokens: Optional[PromptBuilder] = None

prompt_builder_from_text class-attribute instance-attribute 

prompt_builder_from_text: Optional[PromptBuilder] = None

prompt_profile class-attribute instance-attribute 

prompt_profile: Optional[str] = None

prompt_version class-attribute instance-attribute 

prompt_version: Optional[str] = None

algorithm cached property 

algorithm: Callable[..., Doc]

Return the dependency generation function for this process.

run 

run(input_doc: Doc) -> Doc

Run the configured GPT dependency parsing workflow.

Source code in cltk/dependency/processes.py 
 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
def run(self, input_doc: Doc) -> Doc:
    """Run the configured GPT dependency parsing workflow."""
    output_doc = copy(input_doc)
    if not output_doc.normalized_text:
        msg: str = "Doc must have `normalized_text`."
        bind_from_doc(output_doc).error(msg)
        raise ValueError(msg)
    # Ensure required attributes are present
    if self.glottolog_id is None:
        raise ValueError("glottolog_id must be set for sentence splitting")
    prompt_builder_from_tokens = self.prompt_builder_from_tokens
    prompt_builder_from_text = self.prompt_builder_from_text
    prompt_digest = None
    if self.prompt_profile and (
        prompt_builder_from_tokens is None or prompt_builder_from_text is None
    ):
        template = PromptProfileRegistry.get_prompt(
            self.prompt_profile, self.process_id, self.prompt_version
        )
        prompt_digest = template.digest
        if prompt_builder_from_tokens is None:

            def _builder_tokens(
                lang: str, table: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from tokens via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="tokens",
                    lang_or_dialect_name=lang,
                    token_table=table,
                    text=table,
                    sentence=table,
                )

            prompt_builder_from_tokens = _builder_tokens
        if prompt_builder_from_text is None:

            def _builder_text(
                lang: str, sentence: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from text via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="text",
                    lang_or_dialect_name=lang,
                    sentence=sentence,
                    text=sentence,
                    token_table=sentence,
                )

            prompt_builder_from_text = _builder_text
    # Callable typing does not retain keyword names; pass positionally
    output_doc = self.algorithm(
        output_doc,
        prompt_builder_from_tokens=prompt_builder_from_tokens,
        prompt_builder_from_text=prompt_builder_from_text,
        prompt_profile=self.prompt_profile,
        prompt_digest=prompt_digest,
        provenance_process=f"{self.process_id}:{self.__class__.__name__}",
    )
    return output_doc

MiddleCornishGenAIDependencyProcess

Bases: GenAIDependencyProcess

Language-specific dependency process using a generative GPT model.

glottolog_id class-attribute instance-attribute 

glottolog_id: Optional[str] = 'corn1251'

description class-attribute instance-attribute 

description: str = (
    "Default dependency syntax parsing process using a generative GPT model for the Middle Cornish language."
)

authorship_info class-attribute instance-attribute 

authorship_info: str = 'CLTK'

process_id class-attribute 

process_id: str = 'dependency.genai'

prompt_builder_from_tokens class-attribute instance-attribute 

prompt_builder_from_tokens: Optional[PromptBuilder] = None

prompt_builder_from_text class-attribute instance-attribute 

prompt_builder_from_text: Optional[PromptBuilder] = None

prompt_profile class-attribute instance-attribute 

prompt_profile: Optional[str] = None

prompt_version class-attribute instance-attribute 

prompt_version: Optional[str] = None

algorithm cached property 

algorithm: Callable[..., Doc]

Return the dependency generation function for this process.

run 

run(input_doc: Doc) -> Doc

Run the configured GPT dependency parsing workflow.

Source code in cltk/dependency/processes.py 
 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
def run(self, input_doc: Doc) -> Doc:
    """Run the configured GPT dependency parsing workflow."""
    output_doc = copy(input_doc)
    if not output_doc.normalized_text:
        msg: str = "Doc must have `normalized_text`."
        bind_from_doc(output_doc).error(msg)
        raise ValueError(msg)
    # Ensure required attributes are present
    if self.glottolog_id is None:
        raise ValueError("glottolog_id must be set for sentence splitting")
    prompt_builder_from_tokens = self.prompt_builder_from_tokens
    prompt_builder_from_text = self.prompt_builder_from_text
    prompt_digest = None
    if self.prompt_profile and (
        prompt_builder_from_tokens is None or prompt_builder_from_text is None
    ):
        template = PromptProfileRegistry.get_prompt(
            self.prompt_profile, self.process_id, self.prompt_version
        )
        prompt_digest = template.digest
        if prompt_builder_from_tokens is None:

            def _builder_tokens(
                lang: str, table: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from tokens via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="tokens",
                    lang_or_dialect_name=lang,
                    token_table=table,
                    text=table,
                    sentence=table,
                )

            prompt_builder_from_tokens = _builder_tokens
        if prompt_builder_from_text is None:

            def _builder_text(
                lang: str, sentence: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from text via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="text",
                    lang_or_dialect_name=lang,
                    sentence=sentence,
                    text=sentence,
                    token_table=sentence,
                )

            prompt_builder_from_text = _builder_text
    # Callable typing does not retain keyword names; pass positionally
    output_doc = self.algorithm(
        output_doc,
        prompt_builder_from_tokens=prompt_builder_from_tokens,
        prompt_builder_from_text=prompt_builder_from_text,
        prompt_profile=self.prompt_profile,
        prompt_digest=prompt_digest,
        provenance_process=f"{self.process_id}:{self.__class__.__name__}",
    )
    return output_doc

MiddleEgyptianGenAIDependencyProcess

Bases: GenAIDependencyProcess

Language-specific dependency process using a generative GPT model.

glottolog_id class-attribute instance-attribute 

glottolog_id: Optional[str] = 'midd1369'

description class-attribute instance-attribute 

description: str = (
    "Default dependency syntax parsing process using a generative GPT model for the Middle Egyptian language."
)

authorship_info class-attribute instance-attribute 

authorship_info: str = 'CLTK'

process_id class-attribute 

process_id: str = 'dependency.genai'

prompt_builder_from_tokens class-attribute instance-attribute 

prompt_builder_from_tokens: Optional[PromptBuilder] = None

prompt_builder_from_text class-attribute instance-attribute 

prompt_builder_from_text: Optional[PromptBuilder] = None

prompt_profile class-attribute instance-attribute 

prompt_profile: Optional[str] = None

prompt_version class-attribute instance-attribute 

prompt_version: Optional[str] = None

algorithm cached property 

algorithm: Callable[..., Doc]

Return the dependency generation function for this process.

run 

run(input_doc: Doc) -> Doc

Run the configured GPT dependency parsing workflow.

Source code in cltk/dependency/processes.py 
 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
def run(self, input_doc: Doc) -> Doc:
    """Run the configured GPT dependency parsing workflow."""
    output_doc = copy(input_doc)
    if not output_doc.normalized_text:
        msg: str = "Doc must have `normalized_text`."
        bind_from_doc(output_doc).error(msg)
        raise ValueError(msg)
    # Ensure required attributes are present
    if self.glottolog_id is None:
        raise ValueError("glottolog_id must be set for sentence splitting")
    prompt_builder_from_tokens = self.prompt_builder_from_tokens
    prompt_builder_from_text = self.prompt_builder_from_text
    prompt_digest = None
    if self.prompt_profile and (
        prompt_builder_from_tokens is None or prompt_builder_from_text is None
    ):
        template = PromptProfileRegistry.get_prompt(
            self.prompt_profile, self.process_id, self.prompt_version
        )
        prompt_digest = template.digest
        if prompt_builder_from_tokens is None:

            def _builder_tokens(
                lang: str, table: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from tokens via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="tokens",
                    lang_or_dialect_name=lang,
                    token_table=table,
                    text=table,
                    sentence=table,
                )

            prompt_builder_from_tokens = _builder_tokens
        if prompt_builder_from_text is None:

            def _builder_text(
                lang: str, sentence: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from text via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="text",
                    lang_or_dialect_name=lang,
                    sentence=sentence,
                    text=sentence,
                    token_table=sentence,
                )

            prompt_builder_from_text = _builder_text
    # Callable typing does not retain keyword names; pass positionally
    output_doc = self.algorithm(
        output_doc,
        prompt_builder_from_tokens=prompt_builder_from_tokens,
        prompt_builder_from_text=prompt_builder_from_text,
        prompt_profile=self.prompt_profile,
        prompt_digest=prompt_digest,
        provenance_process=f"{self.process_id}:{self.__class__.__name__}",
    )
    return output_doc

MiddleEnglishGenAIDependencyProcess

Bases: GenAIDependencyProcess

Language-specific dependency process using a generative GPT model.

glottolog_id class-attribute instance-attribute 

glottolog_id: Optional[str] = 'midd1317'

description class-attribute instance-attribute 

description: str = (
    "Default dependency syntax parsing process using a generative GPT model for the Middle English language."
)

authorship_info class-attribute instance-attribute 

authorship_info: str = 'CLTK'

process_id class-attribute 

process_id: str = 'dependency.genai'

prompt_builder_from_tokens class-attribute instance-attribute 

prompt_builder_from_tokens: Optional[PromptBuilder] = None

prompt_builder_from_text class-attribute instance-attribute 

prompt_builder_from_text: Optional[PromptBuilder] = None

prompt_profile class-attribute instance-attribute 

prompt_profile: Optional[str] = None

prompt_version class-attribute instance-attribute 

prompt_version: Optional[str] = None

algorithm cached property 

algorithm: Callable[..., Doc]

Return the dependency generation function for this process.

run 

run(input_doc: Doc) -> Doc

Run the configured GPT dependency parsing workflow.

Source code in cltk/dependency/processes.py 
 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
def run(self, input_doc: Doc) -> Doc:
    """Run the configured GPT dependency parsing workflow."""
    output_doc = copy(input_doc)
    if not output_doc.normalized_text:
        msg: str = "Doc must have `normalized_text`."
        bind_from_doc(output_doc).error(msg)
        raise ValueError(msg)
    # Ensure required attributes are present
    if self.glottolog_id is None:
        raise ValueError("glottolog_id must be set for sentence splitting")
    prompt_builder_from_tokens = self.prompt_builder_from_tokens
    prompt_builder_from_text = self.prompt_builder_from_text
    prompt_digest = None
    if self.prompt_profile and (
        prompt_builder_from_tokens is None or prompt_builder_from_text is None
    ):
        template = PromptProfileRegistry.get_prompt(
            self.prompt_profile, self.process_id, self.prompt_version
        )
        prompt_digest = template.digest
        if prompt_builder_from_tokens is None:

            def _builder_tokens(
                lang: str, table: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from tokens via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="tokens",
                    lang_or_dialect_name=lang,
                    token_table=table,
                    text=table,
                    sentence=table,
                )

            prompt_builder_from_tokens = _builder_tokens
        if prompt_builder_from_text is None:

            def _builder_text(
                lang: str, sentence: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from text via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="text",
                    lang_or_dialect_name=lang,
                    sentence=sentence,
                    text=sentence,
                    token_table=sentence,
                )

            prompt_builder_from_text = _builder_text
    # Callable typing does not retain keyword names; pass positionally
    output_doc = self.algorithm(
        output_doc,
        prompt_builder_from_tokens=prompt_builder_from_tokens,
        prompt_builder_from_text=prompt_builder_from_text,
        prompt_profile=self.prompt_profile,
        prompt_digest=prompt_digest,
        provenance_process=f"{self.process_id}:{self.__class__.__name__}",
    )
    return output_doc

MiddleFrenchGenAIDependencyProcess

Bases: GenAIDependencyProcess

Language-specific dependency process using a generative GPT model.

glottolog_id class-attribute instance-attribute 

glottolog_id: Optional[str] = 'midd1316'

description class-attribute instance-attribute 

description: str = (
    "Default dependency syntax parsing process using a generative GPT model for the Middle French language."
)

authorship_info class-attribute instance-attribute 

authorship_info: str = 'CLTK'

process_id class-attribute 

process_id: str = 'dependency.genai'

prompt_builder_from_tokens class-attribute instance-attribute 

prompt_builder_from_tokens: Optional[PromptBuilder] = None

prompt_builder_from_text class-attribute instance-attribute 

prompt_builder_from_text: Optional[PromptBuilder] = None

prompt_profile class-attribute instance-attribute 

prompt_profile: Optional[str] = None

prompt_version class-attribute instance-attribute 

prompt_version: Optional[str] = None

algorithm cached property 

algorithm: Callable[..., Doc]

Return the dependency generation function for this process.

run 

run(input_doc: Doc) -> Doc

Run the configured GPT dependency parsing workflow.

Source code in cltk/dependency/processes.py 
 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
def run(self, input_doc: Doc) -> Doc:
    """Run the configured GPT dependency parsing workflow."""
    output_doc = copy(input_doc)
    if not output_doc.normalized_text:
        msg: str = "Doc must have `normalized_text`."
        bind_from_doc(output_doc).error(msg)
        raise ValueError(msg)
    # Ensure required attributes are present
    if self.glottolog_id is None:
        raise ValueError("glottolog_id must be set for sentence splitting")
    prompt_builder_from_tokens = self.prompt_builder_from_tokens
    prompt_builder_from_text = self.prompt_builder_from_text
    prompt_digest = None
    if self.prompt_profile and (
        prompt_builder_from_tokens is None or prompt_builder_from_text is None
    ):
        template = PromptProfileRegistry.get_prompt(
            self.prompt_profile, self.process_id, self.prompt_version
        )
        prompt_digest = template.digest
        if prompt_builder_from_tokens is None:

            def _builder_tokens(
                lang: str, table: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from tokens via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="tokens",
                    lang_or_dialect_name=lang,
                    token_table=table,
                    text=table,
                    sentence=table,
                )

            prompt_builder_from_tokens = _builder_tokens
        if prompt_builder_from_text is None:

            def _builder_text(
                lang: str, sentence: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from text via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="text",
                    lang_or_dialect_name=lang,
                    sentence=sentence,
                    text=sentence,
                    token_table=sentence,
                )

            prompt_builder_from_text = _builder_text
    # Callable typing does not retain keyword names; pass positionally
    output_doc = self.algorithm(
        output_doc,
        prompt_builder_from_tokens=prompt_builder_from_tokens,
        prompt_builder_from_text=prompt_builder_from_text,
        prompt_profile=self.prompt_profile,
        prompt_digest=prompt_digest,
        provenance_process=f"{self.process_id}:{self.__class__.__name__}",
    )
    return output_doc

MiddleHighGermanGenAIDependencyProcess

Bases: GenAIDependencyProcess

Language-specific dependency process using a generative GPT model.

glottolog_id class-attribute instance-attribute 

glottolog_id: Optional[str] = 'midd1343'

description class-attribute instance-attribute 

description: str = (
    "Default dependency syntax parsing process using a generative GPT model for the Middle High German language."
)

authorship_info class-attribute instance-attribute 

authorship_info: str = 'CLTK'

process_id class-attribute 

process_id: str = 'dependency.genai'

prompt_builder_from_tokens class-attribute instance-attribute 

prompt_builder_from_tokens: Optional[PromptBuilder] = None

prompt_builder_from_text class-attribute instance-attribute 

prompt_builder_from_text: Optional[PromptBuilder] = None

prompt_profile class-attribute instance-attribute 

prompt_profile: Optional[str] = None

prompt_version class-attribute instance-attribute 

prompt_version: Optional[str] = None

algorithm cached property 

algorithm: Callable[..., Doc]

Return the dependency generation function for this process.

run 

run(input_doc: Doc) -> Doc

Run the configured GPT dependency parsing workflow.

Source code in cltk/dependency/processes.py 
 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
def run(self, input_doc: Doc) -> Doc:
    """Run the configured GPT dependency parsing workflow."""
    output_doc = copy(input_doc)
    if not output_doc.normalized_text:
        msg: str = "Doc must have `normalized_text`."
        bind_from_doc(output_doc).error(msg)
        raise ValueError(msg)
    # Ensure required attributes are present
    if self.glottolog_id is None:
        raise ValueError("glottolog_id must be set for sentence splitting")
    prompt_builder_from_tokens = self.prompt_builder_from_tokens
    prompt_builder_from_text = self.prompt_builder_from_text
    prompt_digest = None
    if self.prompt_profile and (
        prompt_builder_from_tokens is None or prompt_builder_from_text is None
    ):
        template = PromptProfileRegistry.get_prompt(
            self.prompt_profile, self.process_id, self.prompt_version
        )
        prompt_digest = template.digest
        if prompt_builder_from_tokens is None:

            def _builder_tokens(
                lang: str, table: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from tokens via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="tokens",
                    lang_or_dialect_name=lang,
                    token_table=table,
                    text=table,
                    sentence=table,
                )

            prompt_builder_from_tokens = _builder_tokens
        if prompt_builder_from_text is None:

            def _builder_text(
                lang: str, sentence: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from text via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="text",
                    lang_or_dialect_name=lang,
                    sentence=sentence,
                    text=sentence,
                    token_table=sentence,
                )

            prompt_builder_from_text = _builder_text
    # Callable typing does not retain keyword names; pass positionally
    output_doc = self.algorithm(
        output_doc,
        prompt_builder_from_tokens=prompt_builder_from_tokens,
        prompt_builder_from_text=prompt_builder_from_text,
        prompt_profile=self.prompt_profile,
        prompt_digest=prompt_digest,
        provenance_process=f"{self.process_id}:{self.__class__.__name__}",
    )
    return output_doc

MiddleMongolGenAIDependencyProcess

Bases: GenAIDependencyProcess

Language-specific dependency process using a generative GPT model.

glottolog_id class-attribute instance-attribute 

glottolog_id: Optional[str] = 'mong1329'

description class-attribute instance-attribute 

description: str = (
    "Default dependency syntax parsing process using a generative GPT model for the Middle Mongol language."
)

authorship_info class-attribute instance-attribute 

authorship_info: str = 'CLTK'

process_id class-attribute 

process_id: str = 'dependency.genai'

prompt_builder_from_tokens class-attribute instance-attribute 

prompt_builder_from_tokens: Optional[PromptBuilder] = None

prompt_builder_from_text class-attribute instance-attribute 

prompt_builder_from_text: Optional[PromptBuilder] = None

prompt_profile class-attribute instance-attribute 

prompt_profile: Optional[str] = None

prompt_version class-attribute instance-attribute 

prompt_version: Optional[str] = None

algorithm cached property 

algorithm: Callable[..., Doc]

Return the dependency generation function for this process.

run 

run(input_doc: Doc) -> Doc

Run the configured GPT dependency parsing workflow.

Source code in cltk/dependency/processes.py 
 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
def run(self, input_doc: Doc) -> Doc:
    """Run the configured GPT dependency parsing workflow."""
    output_doc = copy(input_doc)
    if not output_doc.normalized_text:
        msg: str = "Doc must have `normalized_text`."
        bind_from_doc(output_doc).error(msg)
        raise ValueError(msg)
    # Ensure required attributes are present
    if self.glottolog_id is None:
        raise ValueError("glottolog_id must be set for sentence splitting")
    prompt_builder_from_tokens = self.prompt_builder_from_tokens
    prompt_builder_from_text = self.prompt_builder_from_text
    prompt_digest = None
    if self.prompt_profile and (
        prompt_builder_from_tokens is None or prompt_builder_from_text is None
    ):
        template = PromptProfileRegistry.get_prompt(
            self.prompt_profile, self.process_id, self.prompt_version
        )
        prompt_digest = template.digest
        if prompt_builder_from_tokens is None:

            def _builder_tokens(
                lang: str, table: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from tokens via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="tokens",
                    lang_or_dialect_name=lang,
                    token_table=table,
                    text=table,
                    sentence=table,
                )

            prompt_builder_from_tokens = _builder_tokens
        if prompt_builder_from_text is None:

            def _builder_text(
                lang: str, sentence: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from text via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="text",
                    lang_or_dialect_name=lang,
                    sentence=sentence,
                    text=sentence,
                    token_table=sentence,
                )

            prompt_builder_from_text = _builder_text
    # Callable typing does not retain keyword names; pass positionally
    output_doc = self.algorithm(
        output_doc,
        prompt_builder_from_tokens=prompt_builder_from_tokens,
        prompt_builder_from_text=prompt_builder_from_text,
        prompt_profile=self.prompt_profile,
        prompt_digest=prompt_digest,
        provenance_process=f"{self.process_id}:{self.__class__.__name__}",
    )
    return output_doc

MoabiteGenAIDependencyProcess

Bases: GenAIDependencyProcess

Language-specific dependency process using a generative GPT model.

glottolog_id class-attribute instance-attribute 

glottolog_id: Optional[str] = 'moab1234'

description class-attribute instance-attribute 

description: str = (
    "Default dependency syntax parsing process using a generative GPT model for the Moabite language."
)

authorship_info class-attribute instance-attribute 

authorship_info: str = 'CLTK'

process_id class-attribute 

process_id: str = 'dependency.genai'

prompt_builder_from_tokens class-attribute instance-attribute 

prompt_builder_from_tokens: Optional[PromptBuilder] = None

prompt_builder_from_text class-attribute instance-attribute 

prompt_builder_from_text: Optional[PromptBuilder] = None

prompt_profile class-attribute instance-attribute 

prompt_profile: Optional[str] = None

prompt_version class-attribute instance-attribute 

prompt_version: Optional[str] = None

algorithm cached property 

algorithm: Callable[..., Doc]

Return the dependency generation function for this process.

run 

run(input_doc: Doc) -> Doc

Run the configured GPT dependency parsing workflow.

Source code in cltk/dependency/processes.py 
 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
def run(self, input_doc: Doc) -> Doc:
    """Run the configured GPT dependency parsing workflow."""
    output_doc = copy(input_doc)
    if not output_doc.normalized_text:
        msg: str = "Doc must have `normalized_text`."
        bind_from_doc(output_doc).error(msg)
        raise ValueError(msg)
    # Ensure required attributes are present
    if self.glottolog_id is None:
        raise ValueError("glottolog_id must be set for sentence splitting")
    prompt_builder_from_tokens = self.prompt_builder_from_tokens
    prompt_builder_from_text = self.prompt_builder_from_text
    prompt_digest = None
    if self.prompt_profile and (
        prompt_builder_from_tokens is None or prompt_builder_from_text is None
    ):
        template = PromptProfileRegistry.get_prompt(
            self.prompt_profile, self.process_id, self.prompt_version
        )
        prompt_digest = template.digest
        if prompt_builder_from_tokens is None:

            def _builder_tokens(
                lang: str, table: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from tokens via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="tokens",
                    lang_or_dialect_name=lang,
                    token_table=table,
                    text=table,
                    sentence=table,
                )

            prompt_builder_from_tokens = _builder_tokens
        if prompt_builder_from_text is None:

            def _builder_text(
                lang: str, sentence: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from text via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="text",
                    lang_or_dialect_name=lang,
                    sentence=sentence,
                    text=sentence,
                    token_table=sentence,
                )

            prompt_builder_from_text = _builder_text
    # Callable typing does not retain keyword names; pass positionally
    output_doc = self.algorithm(
        output_doc,
        prompt_builder_from_tokens=prompt_builder_from_tokens,
        prompt_builder_from_text=prompt_builder_from_text,
        prompt_profile=self.prompt_profile,
        prompt_digest=prompt_digest,
        provenance_process=f"{self.process_id}:{self.__class__.__name__}",
    )
    return output_doc

OdiaGenAIDependencyProcess

Bases: GenAIDependencyProcess

Language-specific dependency process using a generative GPT model.

glottolog_id class-attribute instance-attribute 

glottolog_id: Optional[str] = 'oriy1255'

description class-attribute instance-attribute 

description: str = (
    "Default dependency syntax parsing process using a generative GPT model for the Odia language."
)

authorship_info class-attribute instance-attribute 

authorship_info: str = 'CLTK'

process_id class-attribute 

process_id: str = 'dependency.genai'

prompt_builder_from_tokens class-attribute instance-attribute 

prompt_builder_from_tokens: Optional[PromptBuilder] = None

prompt_builder_from_text class-attribute instance-attribute 

prompt_builder_from_text: Optional[PromptBuilder] = None

prompt_profile class-attribute instance-attribute 

prompt_profile: Optional[str] = None

prompt_version class-attribute instance-attribute 

prompt_version: Optional[str] = None

algorithm cached property 

algorithm: Callable[..., Doc]

Return the dependency generation function for this process.

run 

run(input_doc: Doc) -> Doc

Run the configured GPT dependency parsing workflow.

Source code in cltk/dependency/processes.py 
 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
def run(self, input_doc: Doc) -> Doc:
    """Run the configured GPT dependency parsing workflow."""
    output_doc = copy(input_doc)
    if not output_doc.normalized_text:
        msg: str = "Doc must have `normalized_text`."
        bind_from_doc(output_doc).error(msg)
        raise ValueError(msg)
    # Ensure required attributes are present
    if self.glottolog_id is None:
        raise ValueError("glottolog_id must be set for sentence splitting")
    prompt_builder_from_tokens = self.prompt_builder_from_tokens
    prompt_builder_from_text = self.prompt_builder_from_text
    prompt_digest = None
    if self.prompt_profile and (
        prompt_builder_from_tokens is None or prompt_builder_from_text is None
    ):
        template = PromptProfileRegistry.get_prompt(
            self.prompt_profile, self.process_id, self.prompt_version
        )
        prompt_digest = template.digest
        if prompt_builder_from_tokens is None:

            def _builder_tokens(
                lang: str, table: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from tokens via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="tokens",
                    lang_or_dialect_name=lang,
                    token_table=table,
                    text=table,
                    sentence=table,
                )

            prompt_builder_from_tokens = _builder_tokens
        if prompt_builder_from_text is None:

            def _builder_text(
                lang: str, sentence: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from text via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="text",
                    lang_or_dialect_name=lang,
                    sentence=sentence,
                    text=sentence,
                    token_table=sentence,
                )

            prompt_builder_from_text = _builder_text
    # Callable typing does not retain keyword names; pass positionally
    output_doc = self.algorithm(
        output_doc,
        prompt_builder_from_tokens=prompt_builder_from_tokens,
        prompt_builder_from_text=prompt_builder_from_text,
        prompt_profile=self.prompt_profile,
        prompt_digest=prompt_digest,
        provenance_process=f"{self.process_id}:{self.__class__.__name__}",
    )
    return output_doc

OfficialAramaicGenAIDependencyProcess

Bases: GenAIDependencyProcess

Language-specific dependency process using a generative GPT model.

glottolog_id class-attribute instance-attribute 

glottolog_id: Optional[str] = 'impe1235'

description class-attribute instance-attribute 

description: str = (
    "Default dependency syntax parsing process using a generative GPT model for the Official Aramaic (700-300 BCE) language."
)

authorship_info class-attribute instance-attribute 

authorship_info: str = 'CLTK'

process_id class-attribute 

process_id: str = 'dependency.genai'

prompt_builder_from_tokens class-attribute instance-attribute 

prompt_builder_from_tokens: Optional[PromptBuilder] = None

prompt_builder_from_text class-attribute instance-attribute 

prompt_builder_from_text: Optional[PromptBuilder] = None

prompt_profile class-attribute instance-attribute 

prompt_profile: Optional[str] = None

prompt_version class-attribute instance-attribute 

prompt_version: Optional[str] = None

algorithm cached property 

algorithm: Callable[..., Doc]

Return the dependency generation function for this process.

run 

run(input_doc: Doc) -> Doc

Run the configured GPT dependency parsing workflow.

Source code in cltk/dependency/processes.py 
 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
def run(self, input_doc: Doc) -> Doc:
    """Run the configured GPT dependency parsing workflow."""
    output_doc = copy(input_doc)
    if not output_doc.normalized_text:
        msg: str = "Doc must have `normalized_text`."
        bind_from_doc(output_doc).error(msg)
        raise ValueError(msg)
    # Ensure required attributes are present
    if self.glottolog_id is None:
        raise ValueError("glottolog_id must be set for sentence splitting")
    prompt_builder_from_tokens = self.prompt_builder_from_tokens
    prompt_builder_from_text = self.prompt_builder_from_text
    prompt_digest = None
    if self.prompt_profile and (
        prompt_builder_from_tokens is None or prompt_builder_from_text is None
    ):
        template = PromptProfileRegistry.get_prompt(
            self.prompt_profile, self.process_id, self.prompt_version
        )
        prompt_digest = template.digest
        if prompt_builder_from_tokens is None:

            def _builder_tokens(
                lang: str, table: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from tokens via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="tokens",
                    lang_or_dialect_name=lang,
                    token_table=table,
                    text=table,
                    sentence=table,
                )

            prompt_builder_from_tokens = _builder_tokens
        if prompt_builder_from_text is None:

            def _builder_text(
                lang: str, sentence: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from text via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="text",
                    lang_or_dialect_name=lang,
                    sentence=sentence,
                    text=sentence,
                    token_table=sentence,
                )

            prompt_builder_from_text = _builder_text
    # Callable typing does not retain keyword names; pass positionally
    output_doc = self.algorithm(
        output_doc,
        prompt_builder_from_tokens=prompt_builder_from_tokens,
        prompt_builder_from_text=prompt_builder_from_text,
        prompt_profile=self.prompt_profile,
        prompt_digest=prompt_digest,
        provenance_process=f"{self.process_id}:{self.__class__.__name__}",
    )
    return output_doc

OldBurmeseGenAIDependencyProcess

Bases: GenAIDependencyProcess

Language-specific dependency process using a generative GPT model.

glottolog_id class-attribute instance-attribute 

glottolog_id: Optional[str] = 'oldb1235'

description class-attribute instance-attribute 

description: str = (
    "Default dependency syntax parsing process using a generative GPT model for the Old Burmese language."
)

authorship_info class-attribute instance-attribute 

authorship_info: str = 'CLTK'

process_id class-attribute 

process_id: str = 'dependency.genai'

prompt_builder_from_tokens class-attribute instance-attribute 

prompt_builder_from_tokens: Optional[PromptBuilder] = None

prompt_builder_from_text class-attribute instance-attribute 

prompt_builder_from_text: Optional[PromptBuilder] = None

prompt_profile class-attribute instance-attribute 

prompt_profile: Optional[str] = None

prompt_version class-attribute instance-attribute 

prompt_version: Optional[str] = None

algorithm cached property 

algorithm: Callable[..., Doc]

Return the dependency generation function for this process.

run 

run(input_doc: Doc) -> Doc

Run the configured GPT dependency parsing workflow.

Source code in cltk/dependency/processes.py 
 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
def run(self, input_doc: Doc) -> Doc:
    """Run the configured GPT dependency parsing workflow."""
    output_doc = copy(input_doc)
    if not output_doc.normalized_text:
        msg: str = "Doc must have `normalized_text`."
        bind_from_doc(output_doc).error(msg)
        raise ValueError(msg)
    # Ensure required attributes are present
    if self.glottolog_id is None:
        raise ValueError("glottolog_id must be set for sentence splitting")
    prompt_builder_from_tokens = self.prompt_builder_from_tokens
    prompt_builder_from_text = self.prompt_builder_from_text
    prompt_digest = None
    if self.prompt_profile and (
        prompt_builder_from_tokens is None or prompt_builder_from_text is None
    ):
        template = PromptProfileRegistry.get_prompt(
            self.prompt_profile, self.process_id, self.prompt_version
        )
        prompt_digest = template.digest
        if prompt_builder_from_tokens is None:

            def _builder_tokens(
                lang: str, table: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from tokens via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="tokens",
                    lang_or_dialect_name=lang,
                    token_table=table,
                    text=table,
                    sentence=table,
                )

            prompt_builder_from_tokens = _builder_tokens
        if prompt_builder_from_text is None:

            def _builder_text(
                lang: str, sentence: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from text via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="text",
                    lang_or_dialect_name=lang,
                    sentence=sentence,
                    text=sentence,
                    token_table=sentence,
                )

            prompt_builder_from_text = _builder_text
    # Callable typing does not retain keyword names; pass positionally
    output_doc = self.algorithm(
        output_doc,
        prompt_builder_from_tokens=prompt_builder_from_tokens,
        prompt_builder_from_text=prompt_builder_from_text,
        prompt_profile=self.prompt_profile,
        prompt_digest=prompt_digest,
        provenance_process=f"{self.process_id}:{self.__class__.__name__}",
    )
    return output_doc

OldChineseGenAIDependencyProcess

Bases: GenAIDependencyProcess

Language-specific dependency process using a generative GPT model.

glottolog_id class-attribute instance-attribute 

glottolog_id: Optional[str] = 'oldc1244'

description class-attribute instance-attribute 

description: str = (
    "Default dependency syntax parsing process using a generative GPT model for the Old Chinese language."
)

authorship_info class-attribute instance-attribute 

authorship_info: str = 'CLTK'

process_id class-attribute 

process_id: str = 'dependency.genai'

prompt_builder_from_tokens class-attribute instance-attribute 

prompt_builder_from_tokens: Optional[PromptBuilder] = None

prompt_builder_from_text class-attribute instance-attribute 

prompt_builder_from_text: Optional[PromptBuilder] = None

prompt_profile class-attribute instance-attribute 

prompt_profile: Optional[str] = None

prompt_version class-attribute instance-attribute 

prompt_version: Optional[str] = None

algorithm cached property 

algorithm: Callable[..., Doc]

Return the dependency generation function for this process.

run 

run(input_doc: Doc) -> Doc

Run the configured GPT dependency parsing workflow.

Source code in cltk/dependency/processes.py 
 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
def run(self, input_doc: Doc) -> Doc:
    """Run the configured GPT dependency parsing workflow."""
    output_doc = copy(input_doc)
    if not output_doc.normalized_text:
        msg: str = "Doc must have `normalized_text`."
        bind_from_doc(output_doc).error(msg)
        raise ValueError(msg)
    # Ensure required attributes are present
    if self.glottolog_id is None:
        raise ValueError("glottolog_id must be set for sentence splitting")
    prompt_builder_from_tokens = self.prompt_builder_from_tokens
    prompt_builder_from_text = self.prompt_builder_from_text
    prompt_digest = None
    if self.prompt_profile and (
        prompt_builder_from_tokens is None or prompt_builder_from_text is None
    ):
        template = PromptProfileRegistry.get_prompt(
            self.prompt_profile, self.process_id, self.prompt_version
        )
        prompt_digest = template.digest
        if prompt_builder_from_tokens is None:

            def _builder_tokens(
                lang: str, table: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from tokens via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="tokens",
                    lang_or_dialect_name=lang,
                    token_table=table,
                    text=table,
                    sentence=table,
                )

            prompt_builder_from_tokens = _builder_tokens
        if prompt_builder_from_text is None:

            def _builder_text(
                lang: str, sentence: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from text via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="text",
                    lang_or_dialect_name=lang,
                    sentence=sentence,
                    text=sentence,
                    token_table=sentence,
                )

            prompt_builder_from_text = _builder_text
    # Callable typing does not retain keyword names; pass positionally
    output_doc = self.algorithm(
        output_doc,
        prompt_builder_from_tokens=prompt_builder_from_tokens,
        prompt_builder_from_text=prompt_builder_from_text,
        prompt_profile=self.prompt_profile,
        prompt_digest=prompt_digest,
        provenance_process=f"{self.process_id}:{self.__class__.__name__}",
    )
    return output_doc

BaihuaChineseGenAIDependencyProcess

Bases: GenAIDependencyProcess

Language-specific dependency process using a generative GPT model.

glottolog_id class-attribute instance-attribute 

glottolog_id: Optional[str] = 'clas1255'

description class-attribute instance-attribute 

description: str = (
    "Default dependency syntax parsing process using a generative GPT model for Early Vernacular Chinese (Baihua)."
)

authorship_info class-attribute instance-attribute 

authorship_info: str = 'CLTK'

process_id class-attribute 

process_id: str = 'dependency.genai'

prompt_builder_from_tokens class-attribute instance-attribute 

prompt_builder_from_tokens: Optional[PromptBuilder] = None

prompt_builder_from_text class-attribute instance-attribute 

prompt_builder_from_text: Optional[PromptBuilder] = None

prompt_profile class-attribute instance-attribute 

prompt_profile: Optional[str] = None

prompt_version class-attribute instance-attribute 

prompt_version: Optional[str] = None

algorithm cached property 

algorithm: Callable[..., Doc]

Return the dependency generation function for this process.

run 

run(input_doc: Doc) -> Doc

Run the configured GPT dependency parsing workflow.

Source code in cltk/dependency/processes.py 
 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
def run(self, input_doc: Doc) -> Doc:
    """Run the configured GPT dependency parsing workflow."""
    output_doc = copy(input_doc)
    if not output_doc.normalized_text:
        msg: str = "Doc must have `normalized_text`."
        bind_from_doc(output_doc).error(msg)
        raise ValueError(msg)
    # Ensure required attributes are present
    if self.glottolog_id is None:
        raise ValueError("glottolog_id must be set for sentence splitting")
    prompt_builder_from_tokens = self.prompt_builder_from_tokens
    prompt_builder_from_text = self.prompt_builder_from_text
    prompt_digest = None
    if self.prompt_profile and (
        prompt_builder_from_tokens is None or prompt_builder_from_text is None
    ):
        template = PromptProfileRegistry.get_prompt(
            self.prompt_profile, self.process_id, self.prompt_version
        )
        prompt_digest = template.digest
        if prompt_builder_from_tokens is None:

            def _builder_tokens(
                lang: str, table: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from tokens via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="tokens",
                    lang_or_dialect_name=lang,
                    token_table=table,
                    text=table,
                    sentence=table,
                )

            prompt_builder_from_tokens = _builder_tokens
        if prompt_builder_from_text is None:

            def _builder_text(
                lang: str, sentence: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from text via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="text",
                    lang_or_dialect_name=lang,
                    sentence=sentence,
                    text=sentence,
                    token_table=sentence,
                )

            prompt_builder_from_text = _builder_text
    # Callable typing does not retain keyword names; pass positionally
    output_doc = self.algorithm(
        output_doc,
        prompt_builder_from_tokens=prompt_builder_from_tokens,
        prompt_builder_from_text=prompt_builder_from_text,
        prompt_profile=self.prompt_profile,
        prompt_digest=prompt_digest,
        provenance_process=f"{self.process_id}:{self.__class__.__name__}",
    )
    return output_doc

ClassicalBurmeseGenAIDependencyProcess

Bases: GenAIDependencyProcess

Language-specific dependency process using a generative GPT model.

glottolog_id class-attribute instance-attribute 

glottolog_id: Optional[str] = 'nucl1310'

description class-attribute instance-attribute 

description: str = (
    "Default dependency syntax parsing process using a generative GPT model for the Classical Burmese language."
)

authorship_info class-attribute instance-attribute 

authorship_info: str = 'CLTK'

process_id class-attribute 

process_id: str = 'dependency.genai'

prompt_builder_from_tokens class-attribute instance-attribute 

prompt_builder_from_tokens: Optional[PromptBuilder] = None

prompt_builder_from_text class-attribute instance-attribute 

prompt_builder_from_text: Optional[PromptBuilder] = None

prompt_profile class-attribute instance-attribute 

prompt_profile: Optional[str] = None

prompt_version class-attribute instance-attribute 

prompt_version: Optional[str] = None

algorithm cached property 

algorithm: Callable[..., Doc]

Return the dependency generation function for this process.

run 

run(input_doc: Doc) -> Doc

Run the configured GPT dependency parsing workflow.

Source code in cltk/dependency/processes.py 
 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
def run(self, input_doc: Doc) -> Doc:
    """Run the configured GPT dependency parsing workflow."""
    output_doc = copy(input_doc)
    if not output_doc.normalized_text:
        msg: str = "Doc must have `normalized_text`."
        bind_from_doc(output_doc).error(msg)
        raise ValueError(msg)
    # Ensure required attributes are present
    if self.glottolog_id is None:
        raise ValueError("glottolog_id must be set for sentence splitting")
    prompt_builder_from_tokens = self.prompt_builder_from_tokens
    prompt_builder_from_text = self.prompt_builder_from_text
    prompt_digest = None
    if self.prompt_profile and (
        prompt_builder_from_tokens is None or prompt_builder_from_text is None
    ):
        template = PromptProfileRegistry.get_prompt(
            self.prompt_profile, self.process_id, self.prompt_version
        )
        prompt_digest = template.digest
        if prompt_builder_from_tokens is None:

            def _builder_tokens(
                lang: str, table: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from tokens via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="tokens",
                    lang_or_dialect_name=lang,
                    token_table=table,
                    text=table,
                    sentence=table,
                )

            prompt_builder_from_tokens = _builder_tokens
        if prompt_builder_from_text is None:

            def _builder_text(
                lang: str, sentence: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from text via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="text",
                    lang_or_dialect_name=lang,
                    sentence=sentence,
                    text=sentence,
                    token_table=sentence,
                )

            prompt_builder_from_text = _builder_text
    # Callable typing does not retain keyword names; pass positionally
    output_doc = self.algorithm(
        output_doc,
        prompt_builder_from_tokens=prompt_builder_from_tokens,
        prompt_builder_from_text=prompt_builder_from_text,
        prompt_profile=self.prompt_profile,
        prompt_digest=prompt_digest,
        provenance_process=f"{self.process_id}:{self.__class__.__name__}",
    )
    return output_doc

TangutGenAIDependencyProcess

Bases: GenAIDependencyProcess

Language-specific dependency process using a generative GPT model.

glottolog_id class-attribute instance-attribute 

glottolog_id: Optional[str] = 'tang1334'

description class-attribute instance-attribute 

description: str = (
    "Default dependency syntax parsing process using a generative GPT model for the Tangut (Xixia) language."
)

authorship_info class-attribute instance-attribute 

authorship_info: str = 'CLTK'

process_id class-attribute 

process_id: str = 'dependency.genai'

prompt_builder_from_tokens class-attribute instance-attribute 

prompt_builder_from_tokens: Optional[PromptBuilder] = None

prompt_builder_from_text class-attribute instance-attribute 

prompt_builder_from_text: Optional[PromptBuilder] = None

prompt_profile class-attribute instance-attribute 

prompt_profile: Optional[str] = None

prompt_version class-attribute instance-attribute 

prompt_version: Optional[str] = None

algorithm cached property 

algorithm: Callable[..., Doc]

Return the dependency generation function for this process.

run 

run(input_doc: Doc) -> Doc

Run the configured GPT dependency parsing workflow.

Source code in cltk/dependency/processes.py 
 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
def run(self, input_doc: Doc) -> Doc:
    """Run the configured GPT dependency parsing workflow."""
    output_doc = copy(input_doc)
    if not output_doc.normalized_text:
        msg: str = "Doc must have `normalized_text`."
        bind_from_doc(output_doc).error(msg)
        raise ValueError(msg)
    # Ensure required attributes are present
    if self.glottolog_id is None:
        raise ValueError("glottolog_id must be set for sentence splitting")
    prompt_builder_from_tokens = self.prompt_builder_from_tokens
    prompt_builder_from_text = self.prompt_builder_from_text
    prompt_digest = None
    if self.prompt_profile and (
        prompt_builder_from_tokens is None or prompt_builder_from_text is None
    ):
        template = PromptProfileRegistry.get_prompt(
            self.prompt_profile, self.process_id, self.prompt_version
        )
        prompt_digest = template.digest
        if prompt_builder_from_tokens is None:

            def _builder_tokens(
                lang: str, table: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from tokens via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="tokens",
                    lang_or_dialect_name=lang,
                    token_table=table,
                    text=table,
                    sentence=table,
                )

            prompt_builder_from_tokens = _builder_tokens
        if prompt_builder_from_text is None:

            def _builder_text(
                lang: str, sentence: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from text via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="text",
                    lang_or_dialect_name=lang,
                    sentence=sentence,
                    text=sentence,
                    token_table=sentence,
                )

            prompt_builder_from_text = _builder_text
    # Callable typing does not retain keyword names; pass positionally
    output_doc = self.algorithm(
        output_doc,
        prompt_builder_from_tokens=prompt_builder_from_tokens,
        prompt_builder_from_text=prompt_builder_from_text,
        prompt_profile=self.prompt_profile,
        prompt_digest=prompt_digest,
        provenance_process=f"{self.process_id}:{self.__class__.__name__}",
    )
    return output_doc

NewarGenAIDependencyProcess

Bases: GenAIDependencyProcess

Language-specific dependency process using a generative GPT model.

glottolog_id class-attribute instance-attribute 

glottolog_id: Optional[str] = 'newa1246'

description class-attribute instance-attribute 

description: str = (
    "Default dependency syntax parsing process using a generative GPT model for the Newar (Classical Nepal Bhasa) language."
)

authorship_info class-attribute instance-attribute 

authorship_info: str = 'CLTK'

process_id class-attribute 

process_id: str = 'dependency.genai'

prompt_builder_from_tokens class-attribute instance-attribute 

prompt_builder_from_tokens: Optional[PromptBuilder] = None

prompt_builder_from_text class-attribute instance-attribute 

prompt_builder_from_text: Optional[PromptBuilder] = None

prompt_profile class-attribute instance-attribute 

prompt_profile: Optional[str] = None

prompt_version class-attribute instance-attribute 

prompt_version: Optional[str] = None

algorithm cached property 

algorithm: Callable[..., Doc]

Return the dependency generation function for this process.

run 

run(input_doc: Doc) -> Doc

Run the configured GPT dependency parsing workflow.

Source code in cltk/dependency/processes.py 
 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
def run(self, input_doc: Doc) -> Doc:
    """Run the configured GPT dependency parsing workflow."""
    output_doc = copy(input_doc)
    if not output_doc.normalized_text:
        msg: str = "Doc must have `normalized_text`."
        bind_from_doc(output_doc).error(msg)
        raise ValueError(msg)
    # Ensure required attributes are present
    if self.glottolog_id is None:
        raise ValueError("glottolog_id must be set for sentence splitting")
    prompt_builder_from_tokens = self.prompt_builder_from_tokens
    prompt_builder_from_text = self.prompt_builder_from_text
    prompt_digest = None
    if self.prompt_profile and (
        prompt_builder_from_tokens is None or prompt_builder_from_text is None
    ):
        template = PromptProfileRegistry.get_prompt(
            self.prompt_profile, self.process_id, self.prompt_version
        )
        prompt_digest = template.digest
        if prompt_builder_from_tokens is None:

            def _builder_tokens(
                lang: str, table: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from tokens via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="tokens",
                    lang_or_dialect_name=lang,
                    token_table=table,
                    text=table,
                    sentence=table,
                )

            prompt_builder_from_tokens = _builder_tokens
        if prompt_builder_from_text is None:

            def _builder_text(
                lang: str, sentence: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from text via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="text",
                    lang_or_dialect_name=lang,
                    sentence=sentence,
                    text=sentence,
                    token_table=sentence,
                )

            prompt_builder_from_text = _builder_text
    # Callable typing does not retain keyword names; pass positionally
    output_doc = self.algorithm(
        output_doc,
        prompt_builder_from_tokens=prompt_builder_from_tokens,
        prompt_builder_from_text=prompt_builder_from_text,
        prompt_profile=self.prompt_profile,
        prompt_digest=prompt_digest,
        provenance_process=f"{self.process_id}:{self.__class__.__name__}",
    )
    return output_doc

MeiteiGenAIDependencyProcess

Bases: GenAIDependencyProcess

Language-specific dependency process using a generative GPT model.

glottolog_id class-attribute instance-attribute 

glottolog_id: Optional[str] = 'mani1292'

description class-attribute instance-attribute 

description: str = (
    "Default dependency syntax parsing process using a generative GPT model for the Meitei (Classical Manipuri) language."
)

authorship_info class-attribute instance-attribute 

authorship_info: str = 'CLTK'

process_id class-attribute 

process_id: str = 'dependency.genai'

prompt_builder_from_tokens class-attribute instance-attribute 

prompt_builder_from_tokens: Optional[PromptBuilder] = None

prompt_builder_from_text class-attribute instance-attribute 

prompt_builder_from_text: Optional[PromptBuilder] = None

prompt_profile class-attribute instance-attribute 

prompt_profile: Optional[str] = None

prompt_version class-attribute instance-attribute 

prompt_version: Optional[str] = None

algorithm cached property 

algorithm: Callable[..., Doc]

Return the dependency generation function for this process.

run 

run(input_doc: Doc) -> Doc

Run the configured GPT dependency parsing workflow.

Source code in cltk/dependency/processes.py 
 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
def run(self, input_doc: Doc) -> Doc:
    """Run the configured GPT dependency parsing workflow."""
    output_doc = copy(input_doc)
    if not output_doc.normalized_text:
        msg: str = "Doc must have `normalized_text`."
        bind_from_doc(output_doc).error(msg)
        raise ValueError(msg)
    # Ensure required attributes are present
    if self.glottolog_id is None:
        raise ValueError("glottolog_id must be set for sentence splitting")
    prompt_builder_from_tokens = self.prompt_builder_from_tokens
    prompt_builder_from_text = self.prompt_builder_from_text
    prompt_digest = None
    if self.prompt_profile and (
        prompt_builder_from_tokens is None or prompt_builder_from_text is None
    ):
        template = PromptProfileRegistry.get_prompt(
            self.prompt_profile, self.process_id, self.prompt_version
        )
        prompt_digest = template.digest
        if prompt_builder_from_tokens is None:

            def _builder_tokens(
                lang: str, table: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from tokens via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="tokens",
                    lang_or_dialect_name=lang,
                    token_table=table,
                    text=table,
                    sentence=table,
                )

            prompt_builder_from_tokens = _builder_tokens
        if prompt_builder_from_text is None:

            def _builder_text(
                lang: str, sentence: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from text via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="text",
                    lang_or_dialect_name=lang,
                    sentence=sentence,
                    text=sentence,
                    token_table=sentence,
                )

            prompt_builder_from_text = _builder_text
    # Callable typing does not retain keyword names; pass positionally
    output_doc = self.algorithm(
        output_doc,
        prompt_builder_from_tokens=prompt_builder_from_tokens,
        prompt_builder_from_text=prompt_builder_from_text,
        prompt_profile=self.prompt_profile,
        prompt_digest=prompt_digest,
        provenance_process=f"{self.process_id}:{self.__class__.__name__}",
    )
    return output_doc

SgawKarenGenAIDependencyProcess

Bases: GenAIDependencyProcess

Language-specific dependency process using a generative GPT model.

glottolog_id class-attribute instance-attribute 

glottolog_id: Optional[str] = 'sgaw1245'

description class-attribute instance-attribute 

description: str = (
    "Default dependency syntax parsing process using a generative GPT model for the Sgaw Karen language."
)

authorship_info class-attribute instance-attribute 

authorship_info: str = 'CLTK'

process_id class-attribute 

process_id: str = 'dependency.genai'

prompt_builder_from_tokens class-attribute instance-attribute 

prompt_builder_from_tokens: Optional[PromptBuilder] = None

prompt_builder_from_text class-attribute instance-attribute 

prompt_builder_from_text: Optional[PromptBuilder] = None

prompt_profile class-attribute instance-attribute 

prompt_profile: Optional[str] = None

prompt_version class-attribute instance-attribute 

prompt_version: Optional[str] = None

algorithm cached property 

algorithm: Callable[..., Doc]

Return the dependency generation function for this process.

run 

run(input_doc: Doc) -> Doc

Run the configured GPT dependency parsing workflow.

Source code in cltk/dependency/processes.py 
 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
def run(self, input_doc: Doc) -> Doc:
    """Run the configured GPT dependency parsing workflow."""
    output_doc = copy(input_doc)
    if not output_doc.normalized_text:
        msg: str = "Doc must have `normalized_text`."
        bind_from_doc(output_doc).error(msg)
        raise ValueError(msg)
    # Ensure required attributes are present
    if self.glottolog_id is None:
        raise ValueError("glottolog_id must be set for sentence splitting")
    prompt_builder_from_tokens = self.prompt_builder_from_tokens
    prompt_builder_from_text = self.prompt_builder_from_text
    prompt_digest = None
    if self.prompt_profile and (
        prompt_builder_from_tokens is None or prompt_builder_from_text is None
    ):
        template = PromptProfileRegistry.get_prompt(
            self.prompt_profile, self.process_id, self.prompt_version
        )
        prompt_digest = template.digest
        if prompt_builder_from_tokens is None:

            def _builder_tokens(
                lang: str, table: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from tokens via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="tokens",
                    lang_or_dialect_name=lang,
                    token_table=table,
                    text=table,
                    sentence=table,
                )

            prompt_builder_from_tokens = _builder_tokens
        if prompt_builder_from_text is None:

            def _builder_text(
                lang: str, sentence: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from text via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="text",
                    lang_or_dialect_name=lang,
                    sentence=sentence,
                    text=sentence,
                    token_table=sentence,
                )

            prompt_builder_from_text = _builder_text
    # Callable typing does not retain keyword names; pass positionally
    output_doc = self.algorithm(
        output_doc,
        prompt_builder_from_tokens=prompt_builder_from_tokens,
        prompt_builder_from_text=prompt_builder_from_text,
        prompt_profile=self.prompt_profile,
        prompt_digest=prompt_digest,
        provenance_process=f"{self.process_id}:{self.__class__.__name__}",
    )
    return output_doc

MogholiGenAIDependencyProcess

Bases: GenAIDependencyProcess

Language-specific dependency process using a generative GPT model.

glottolog_id class-attribute instance-attribute 

glottolog_id: Optional[str] = 'mogh1245'

description class-attribute instance-attribute 

description: str = (
    "Default dependency syntax parsing process using a generative GPT model for the Mogholi (Moghol) language."
)

authorship_info class-attribute instance-attribute 

authorship_info: str = 'CLTK'

process_id class-attribute 

process_id: str = 'dependency.genai'

prompt_builder_from_tokens class-attribute instance-attribute 

prompt_builder_from_tokens: Optional[PromptBuilder] = None

prompt_builder_from_text class-attribute instance-attribute 

prompt_builder_from_text: Optional[PromptBuilder] = None

prompt_profile class-attribute instance-attribute 

prompt_profile: Optional[str] = None

prompt_version class-attribute instance-attribute 

prompt_version: Optional[str] = None

algorithm cached property 

algorithm: Callable[..., Doc]

Return the dependency generation function for this process.

run 

run(input_doc: Doc) -> Doc

Run the configured GPT dependency parsing workflow.

Source code in cltk/dependency/processes.py 
 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
def run(self, input_doc: Doc) -> Doc:
    """Run the configured GPT dependency parsing workflow."""
    output_doc = copy(input_doc)
    if not output_doc.normalized_text:
        msg: str = "Doc must have `normalized_text`."
        bind_from_doc(output_doc).error(msg)
        raise ValueError(msg)
    # Ensure required attributes are present
    if self.glottolog_id is None:
        raise ValueError("glottolog_id must be set for sentence splitting")
    prompt_builder_from_tokens = self.prompt_builder_from_tokens
    prompt_builder_from_text = self.prompt_builder_from_text
    prompt_digest = None
    if self.prompt_profile and (
        prompt_builder_from_tokens is None or prompt_builder_from_text is None
    ):
        template = PromptProfileRegistry.get_prompt(
            self.prompt_profile, self.process_id, self.prompt_version
        )
        prompt_digest = template.digest
        if prompt_builder_from_tokens is None:

            def _builder_tokens(
                lang: str, table: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from tokens via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="tokens",
                    lang_or_dialect_name=lang,
                    token_table=table,
                    text=table,
                    sentence=table,
                )

            prompt_builder_from_tokens = _builder_tokens
        if prompt_builder_from_text is None:

            def _builder_text(
                lang: str, sentence: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from text via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="text",
                    lang_or_dialect_name=lang,
                    sentence=sentence,
                    text=sentence,
                    token_table=sentence,
                )

            prompt_builder_from_text = _builder_text
    # Callable typing does not retain keyword names; pass positionally
    output_doc = self.algorithm(
        output_doc,
        prompt_builder_from_tokens=prompt_builder_from_tokens,
        prompt_builder_from_text=prompt_builder_from_text,
        prompt_profile=self.prompt_profile,
        prompt_digest=prompt_digest,
        provenance_process=f"{self.process_id}:{self.__class__.__name__}",
    )
    return output_doc

NumidianGenAIDependencyProcess

Bases: GenAIDependencyProcess

Language-specific dependency process using a generative GPT model.

glottolog_id class-attribute instance-attribute 

glottolog_id: Optional[str] = 'numi1241'

description class-attribute instance-attribute 

description: str = (
    "Default dependency syntax parsing process using a generative GPT model for the Numidian (Ancient Berber) language."
)

authorship_info class-attribute instance-attribute 

authorship_info: str = 'CLTK'

process_id class-attribute 

process_id: str = 'dependency.genai'

prompt_builder_from_tokens class-attribute instance-attribute 

prompt_builder_from_tokens: Optional[PromptBuilder] = None

prompt_builder_from_text class-attribute instance-attribute 

prompt_builder_from_text: Optional[PromptBuilder] = None

prompt_profile class-attribute instance-attribute 

prompt_profile: Optional[str] = None

prompt_version class-attribute instance-attribute 

prompt_version: Optional[str] = None

algorithm cached property 

algorithm: Callable[..., Doc]

Return the dependency generation function for this process.

run 

run(input_doc: Doc) -> Doc

Run the configured GPT dependency parsing workflow.

Source code in cltk/dependency/processes.py 
 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
def run(self, input_doc: Doc) -> Doc:
    """Run the configured GPT dependency parsing workflow."""
    output_doc = copy(input_doc)
    if not output_doc.normalized_text:
        msg: str = "Doc must have `normalized_text`."
        bind_from_doc(output_doc).error(msg)
        raise ValueError(msg)
    # Ensure required attributes are present
    if self.glottolog_id is None:
        raise ValueError("glottolog_id must be set for sentence splitting")
    prompt_builder_from_tokens = self.prompt_builder_from_tokens
    prompt_builder_from_text = self.prompt_builder_from_text
    prompt_digest = None
    if self.prompt_profile and (
        prompt_builder_from_tokens is None or prompt_builder_from_text is None
    ):
        template = PromptProfileRegistry.get_prompt(
            self.prompt_profile, self.process_id, self.prompt_version
        )
        prompt_digest = template.digest
        if prompt_builder_from_tokens is None:

            def _builder_tokens(
                lang: str, table: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from tokens via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="tokens",
                    lang_or_dialect_name=lang,
                    token_table=table,
                    text=table,
                    sentence=table,
                )

            prompt_builder_from_tokens = _builder_tokens
        if prompt_builder_from_text is None:

            def _builder_text(
                lang: str, sentence: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from text via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="text",
                    lang_or_dialect_name=lang,
                    sentence=sentence,
                    text=sentence,
                    token_table=sentence,
                )

            prompt_builder_from_text = _builder_text
    # Callable typing does not retain keyword names; pass positionally
    output_doc = self.algorithm(
        output_doc,
        prompt_builder_from_tokens=prompt_builder_from_tokens,
        prompt_builder_from_text=prompt_builder_from_text,
        prompt_profile=self.prompt_profile,
        prompt_digest=prompt_digest,
        provenance_process=f"{self.process_id}:{self.__class__.__name__}",
    )
    return output_doc

TaitaGenAIDependencyProcess

Bases: GenAIDependencyProcess

Language-specific dependency process using a generative GPT model.

glottolog_id class-attribute instance-attribute 

glottolog_id: Optional[str] = 'tait1247'

description class-attribute instance-attribute 

description: str = (
    "Default dependency syntax parsing process using a generative GPT model for the Cushitic Taita language."
)

authorship_info class-attribute instance-attribute 

authorship_info: str = 'CLTK'

process_id class-attribute 

process_id: str = 'dependency.genai'

prompt_builder_from_tokens class-attribute instance-attribute 

prompt_builder_from_tokens: Optional[PromptBuilder] = None

prompt_builder_from_text class-attribute instance-attribute 

prompt_builder_from_text: Optional[PromptBuilder] = None

prompt_profile class-attribute instance-attribute 

prompt_profile: Optional[str] = None

prompt_version class-attribute instance-attribute 

prompt_version: Optional[str] = None

algorithm cached property 

algorithm: Callable[..., Doc]

Return the dependency generation function for this process.

run 

run(input_doc: Doc) -> Doc

Run the configured GPT dependency parsing workflow.

Source code in cltk/dependency/processes.py 
 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
def run(self, input_doc: Doc) -> Doc:
    """Run the configured GPT dependency parsing workflow."""
    output_doc = copy(input_doc)
    if not output_doc.normalized_text:
        msg: str = "Doc must have `normalized_text`."
        bind_from_doc(output_doc).error(msg)
        raise ValueError(msg)
    # Ensure required attributes are present
    if self.glottolog_id is None:
        raise ValueError("glottolog_id must be set for sentence splitting")
    prompt_builder_from_tokens = self.prompt_builder_from_tokens
    prompt_builder_from_text = self.prompt_builder_from_text
    prompt_digest = None
    if self.prompt_profile and (
        prompt_builder_from_tokens is None or prompt_builder_from_text is None
    ):
        template = PromptProfileRegistry.get_prompt(
            self.prompt_profile, self.process_id, self.prompt_version
        )
        prompt_digest = template.digest
        if prompt_builder_from_tokens is None:

            def _builder_tokens(
                lang: str, table: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from tokens via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="tokens",
                    lang_or_dialect_name=lang,
                    token_table=table,
                    text=table,
                    sentence=table,
                )

            prompt_builder_from_tokens = _builder_tokens
        if prompt_builder_from_text is None:

            def _builder_text(
                lang: str, sentence: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from text via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="text",
                    lang_or_dialect_name=lang,
                    sentence=sentence,
                    text=sentence,
                    token_table=sentence,
                )

            prompt_builder_from_text = _builder_text
    # Callable typing does not retain keyword names; pass positionally
    output_doc = self.algorithm(
        output_doc,
        prompt_builder_from_tokens=prompt_builder_from_tokens,
        prompt_builder_from_text=prompt_builder_from_text,
        prompt_profile=self.prompt_profile,
        prompt_digest=prompt_digest,
        provenance_process=f"{self.process_id}:{self.__class__.__name__}",
    )
    return output_doc

HausaGenAIDependencyProcess

Bases: GenAIDependencyProcess

Language-specific dependency process using a generative GPT model.

glottolog_id class-attribute instance-attribute 

glottolog_id: Optional[str] = 'haus1257'

description class-attribute instance-attribute 

description: str = (
    "Default dependency syntax parsing process using a generative GPT model for the Hausa language."
)

authorship_info class-attribute instance-attribute 

authorship_info: str = 'CLTK'

process_id class-attribute 

process_id: str = 'dependency.genai'

prompt_builder_from_tokens class-attribute instance-attribute 

prompt_builder_from_tokens: Optional[PromptBuilder] = None

prompt_builder_from_text class-attribute instance-attribute 

prompt_builder_from_text: Optional[PromptBuilder] = None

prompt_profile class-attribute instance-attribute 

prompt_profile: Optional[str] = None

prompt_version class-attribute instance-attribute 

prompt_version: Optional[str] = None

algorithm cached property 

algorithm: Callable[..., Doc]

Return the dependency generation function for this process.

run 

run(input_doc: Doc) -> Doc

Run the configured GPT dependency parsing workflow.

Source code in cltk/dependency/processes.py 
 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
def run(self, input_doc: Doc) -> Doc:
    """Run the configured GPT dependency parsing workflow."""
    output_doc = copy(input_doc)
    if not output_doc.normalized_text:
        msg: str = "Doc must have `normalized_text`."
        bind_from_doc(output_doc).error(msg)
        raise ValueError(msg)
    # Ensure required attributes are present
    if self.glottolog_id is None:
        raise ValueError("glottolog_id must be set for sentence splitting")
    prompt_builder_from_tokens = self.prompt_builder_from_tokens
    prompt_builder_from_text = self.prompt_builder_from_text
    prompt_digest = None
    if self.prompt_profile and (
        prompt_builder_from_tokens is None or prompt_builder_from_text is None
    ):
        template = PromptProfileRegistry.get_prompt(
            self.prompt_profile, self.process_id, self.prompt_version
        )
        prompt_digest = template.digest
        if prompt_builder_from_tokens is None:

            def _builder_tokens(
                lang: str, table: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from tokens via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="tokens",
                    lang_or_dialect_name=lang,
                    token_table=table,
                    text=table,
                    sentence=table,
                )

            prompt_builder_from_tokens = _builder_tokens
        if prompt_builder_from_text is None:

            def _builder_text(
                lang: str, sentence: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from text via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="text",
                    lang_or_dialect_name=lang,
                    sentence=sentence,
                    text=sentence,
                    token_table=sentence,
                )

            prompt_builder_from_text = _builder_text
    # Callable typing does not retain keyword names; pass positionally
    output_doc = self.algorithm(
        output_doc,
        prompt_builder_from_tokens=prompt_builder_from_tokens,
        prompt_builder_from_text=prompt_builder_from_text,
        prompt_profile=self.prompt_profile,
        prompt_digest=prompt_digest,
        provenance_process=f"{self.process_id}:{self.__class__.__name__}",
    )
    return output_doc

OldJurchenGenAIDependencyProcess

Bases: GenAIDependencyProcess

Language-specific dependency process using a generative GPT model.

glottolog_id class-attribute instance-attribute 

glottolog_id: Optional[str] = 'jurc1239'

description class-attribute instance-attribute 

description: str = (
    "Default dependency syntax parsing process using a generative GPT model for the Old Jurchen language."
)

authorship_info class-attribute instance-attribute 

authorship_info: str = 'CLTK'

process_id class-attribute 

process_id: str = 'dependency.genai'

prompt_builder_from_tokens class-attribute instance-attribute 

prompt_builder_from_tokens: Optional[PromptBuilder] = None

prompt_builder_from_text class-attribute instance-attribute 

prompt_builder_from_text: Optional[PromptBuilder] = None

prompt_profile class-attribute instance-attribute 

prompt_profile: Optional[str] = None

prompt_version class-attribute instance-attribute 

prompt_version: Optional[str] = None

algorithm cached property 

algorithm: Callable[..., Doc]

Return the dependency generation function for this process.

run 

run(input_doc: Doc) -> Doc

Run the configured GPT dependency parsing workflow.

Source code in cltk/dependency/processes.py 
 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
def run(self, input_doc: Doc) -> Doc:
    """Run the configured GPT dependency parsing workflow."""
    output_doc = copy(input_doc)
    if not output_doc.normalized_text:
        msg: str = "Doc must have `normalized_text`."
        bind_from_doc(output_doc).error(msg)
        raise ValueError(msg)
    # Ensure required attributes are present
    if self.glottolog_id is None:
        raise ValueError("glottolog_id must be set for sentence splitting")
    prompt_builder_from_tokens = self.prompt_builder_from_tokens
    prompt_builder_from_text = self.prompt_builder_from_text
    prompt_digest = None
    if self.prompt_profile and (
        prompt_builder_from_tokens is None or prompt_builder_from_text is None
    ):
        template = PromptProfileRegistry.get_prompt(
            self.prompt_profile, self.process_id, self.prompt_version
        )
        prompt_digest = template.digest
        if prompt_builder_from_tokens is None:

            def _builder_tokens(
                lang: str, table: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from tokens via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="tokens",
                    lang_or_dialect_name=lang,
                    token_table=table,
                    text=table,
                    sentence=table,
                )

            prompt_builder_from_tokens = _builder_tokens
        if prompt_builder_from_text is None:

            def _builder_text(
                lang: str, sentence: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from text via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="text",
                    lang_or_dialect_name=lang,
                    sentence=sentence,
                    text=sentence,
                    token_table=sentence,
                )

            prompt_builder_from_text = _builder_text
    # Callable typing does not retain keyword names; pass positionally
    output_doc = self.algorithm(
        output_doc,
        prompt_builder_from_tokens=prompt_builder_from_tokens,
        prompt_builder_from_text=prompt_builder_from_text,
        prompt_profile=self.prompt_profile,
        prompt_digest=prompt_digest,
        provenance_process=f"{self.process_id}:{self.__class__.__name__}",
    )
    return output_doc

OldJapaneseGenAIDependencyProcess

Bases: GenAIDependencyProcess

Language-specific dependency process using a generative GPT model.

glottolog_id class-attribute instance-attribute 

glottolog_id: Optional[str] = 'japo1237'

description class-attribute instance-attribute 

description: str = (
    "Default dependency syntax parsing process using a generative GPT model for the Old Japanese language."
)

authorship_info class-attribute instance-attribute 

authorship_info: str = 'CLTK'

process_id class-attribute 

process_id: str = 'dependency.genai'

prompt_builder_from_tokens class-attribute instance-attribute 

prompt_builder_from_tokens: Optional[PromptBuilder] = None

prompt_builder_from_text class-attribute instance-attribute 

prompt_builder_from_text: Optional[PromptBuilder] = None

prompt_profile class-attribute instance-attribute 

prompt_profile: Optional[str] = None

prompt_version class-attribute instance-attribute 

prompt_version: Optional[str] = None

algorithm cached property 

algorithm: Callable[..., Doc]

Return the dependency generation function for this process.

run 

run(input_doc: Doc) -> Doc

Run the configured GPT dependency parsing workflow.

Source code in cltk/dependency/processes.py 
 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
def run(self, input_doc: Doc) -> Doc:
    """Run the configured GPT dependency parsing workflow."""
    output_doc = copy(input_doc)
    if not output_doc.normalized_text:
        msg: str = "Doc must have `normalized_text`."
        bind_from_doc(output_doc).error(msg)
        raise ValueError(msg)
    # Ensure required attributes are present
    if self.glottolog_id is None:
        raise ValueError("glottolog_id must be set for sentence splitting")
    prompt_builder_from_tokens = self.prompt_builder_from_tokens
    prompt_builder_from_text = self.prompt_builder_from_text
    prompt_digest = None
    if self.prompt_profile and (
        prompt_builder_from_tokens is None or prompt_builder_from_text is None
    ):
        template = PromptProfileRegistry.get_prompt(
            self.prompt_profile, self.process_id, self.prompt_version
        )
        prompt_digest = template.digest
        if prompt_builder_from_tokens is None:

            def _builder_tokens(
                lang: str, table: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from tokens via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="tokens",
                    lang_or_dialect_name=lang,
                    token_table=table,
                    text=table,
                    sentence=table,
                )

            prompt_builder_from_tokens = _builder_tokens
        if prompt_builder_from_text is None:

            def _builder_text(
                lang: str, sentence: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from text via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="text",
                    lang_or_dialect_name=lang,
                    sentence=sentence,
                    text=sentence,
                    token_table=sentence,
                )

            prompt_builder_from_text = _builder_text
    # Callable typing does not retain keyword names; pass positionally
    output_doc = self.algorithm(
        output_doc,
        prompt_builder_from_tokens=prompt_builder_from_tokens,
        prompt_builder_from_text=prompt_builder_from_text,
        prompt_profile=self.prompt_profile,
        prompt_digest=prompt_digest,
        provenance_process=f"{self.process_id}:{self.__class__.__name__}",
    )
    return output_doc

OldHungarianGenAIDependencyProcess

Bases: GenAIDependencyProcess

Language-specific dependency process using a generative GPT model.

glottolog_id class-attribute instance-attribute 

glottolog_id: Optional[str] = 'oldh1242'

description class-attribute instance-attribute 

description: str = (
    "Default dependency syntax parsing process using a generative GPT model for the Old Hungarian language."
)

authorship_info class-attribute instance-attribute 

authorship_info: str = 'CLTK'

process_id class-attribute 

process_id: str = 'dependency.genai'

prompt_builder_from_tokens class-attribute instance-attribute 

prompt_builder_from_tokens: Optional[PromptBuilder] = None

prompt_builder_from_text class-attribute instance-attribute 

prompt_builder_from_text: Optional[PromptBuilder] = None

prompt_profile class-attribute instance-attribute 

prompt_profile: Optional[str] = None

prompt_version class-attribute instance-attribute 

prompt_version: Optional[str] = None

algorithm cached property 

algorithm: Callable[..., Doc]

Return the dependency generation function for this process.

run 

run(input_doc: Doc) -> Doc

Run the configured GPT dependency parsing workflow.

Source code in cltk/dependency/processes.py 
 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
def run(self, input_doc: Doc) -> Doc:
    """Run the configured GPT dependency parsing workflow."""
    output_doc = copy(input_doc)
    if not output_doc.normalized_text:
        msg: str = "Doc must have `normalized_text`."
        bind_from_doc(output_doc).error(msg)
        raise ValueError(msg)
    # Ensure required attributes are present
    if self.glottolog_id is None:
        raise ValueError("glottolog_id must be set for sentence splitting")
    prompt_builder_from_tokens = self.prompt_builder_from_tokens
    prompt_builder_from_text = self.prompt_builder_from_text
    prompt_digest = None
    if self.prompt_profile and (
        prompt_builder_from_tokens is None or prompt_builder_from_text is None
    ):
        template = PromptProfileRegistry.get_prompt(
            self.prompt_profile, self.process_id, self.prompt_version
        )
        prompt_digest = template.digest
        if prompt_builder_from_tokens is None:

            def _builder_tokens(
                lang: str, table: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from tokens via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="tokens",
                    lang_or_dialect_name=lang,
                    token_table=table,
                    text=table,
                    sentence=table,
                )

            prompt_builder_from_tokens = _builder_tokens
        if prompt_builder_from_text is None:

            def _builder_text(
                lang: str, sentence: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from text via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="text",
                    lang_or_dialect_name=lang,
                    sentence=sentence,
                    text=sentence,
                    token_table=sentence,
                )

            prompt_builder_from_text = _builder_text
    # Callable typing does not retain keyword names; pass positionally
    output_doc = self.algorithm(
        output_doc,
        prompt_builder_from_tokens=prompt_builder_from_tokens,
        prompt_builder_from_text=prompt_builder_from_text,
        prompt_profile=self.prompt_profile,
        prompt_digest=prompt_digest,
        provenance_process=f"{self.process_id}:{self.__class__.__name__}",
    )
    return output_doc

ChagataiGenAIDependencyProcess

Bases: GenAIDependencyProcess

Language-specific dependency process using a generative GPT model.

glottolog_id class-attribute instance-attribute 

glottolog_id: Optional[str] = 'chag1247'

description class-attribute instance-attribute 

description: str = (
    "Default dependency syntax parsing process using a generative GPT model for the Chagatai language."
)

authorship_info class-attribute instance-attribute 

authorship_info: str = 'CLTK'

process_id class-attribute 

process_id: str = 'dependency.genai'

prompt_builder_from_tokens class-attribute instance-attribute 

prompt_builder_from_tokens: Optional[PromptBuilder] = None

prompt_builder_from_text class-attribute instance-attribute 

prompt_builder_from_text: Optional[PromptBuilder] = None

prompt_profile class-attribute instance-attribute 

prompt_profile: Optional[str] = None

prompt_version class-attribute instance-attribute 

prompt_version: Optional[str] = None

algorithm cached property 

algorithm: Callable[..., Doc]

Return the dependency generation function for this process.

run 

run(input_doc: Doc) -> Doc

Run the configured GPT dependency parsing workflow.

Source code in cltk/dependency/processes.py 
 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
def run(self, input_doc: Doc) -> Doc:
    """Run the configured GPT dependency parsing workflow."""
    output_doc = copy(input_doc)
    if not output_doc.normalized_text:
        msg: str = "Doc must have `normalized_text`."
        bind_from_doc(output_doc).error(msg)
        raise ValueError(msg)
    # Ensure required attributes are present
    if self.glottolog_id is None:
        raise ValueError("glottolog_id must be set for sentence splitting")
    prompt_builder_from_tokens = self.prompt_builder_from_tokens
    prompt_builder_from_text = self.prompt_builder_from_text
    prompt_digest = None
    if self.prompt_profile and (
        prompt_builder_from_tokens is None or prompt_builder_from_text is None
    ):
        template = PromptProfileRegistry.get_prompt(
            self.prompt_profile, self.process_id, self.prompt_version
        )
        prompt_digest = template.digest
        if prompt_builder_from_tokens is None:

            def _builder_tokens(
                lang: str, table: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from tokens via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="tokens",
                    lang_or_dialect_name=lang,
                    token_table=table,
                    text=table,
                    sentence=table,
                )

            prompt_builder_from_tokens = _builder_tokens
        if prompt_builder_from_text is None:

            def _builder_text(
                lang: str, sentence: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from text via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="text",
                    lang_or_dialect_name=lang,
                    sentence=sentence,
                    text=sentence,
                    token_table=sentence,
                )

            prompt_builder_from_text = _builder_text
    # Callable typing does not retain keyword names; pass positionally
    output_doc = self.algorithm(
        output_doc,
        prompt_builder_from_tokens=prompt_builder_from_tokens,
        prompt_builder_from_text=prompt_builder_from_text,
        prompt_profile=self.prompt_profile,
        prompt_digest=prompt_digest,
        provenance_process=f"{self.process_id}:{self.__class__.__name__}",
    )
    return output_doc

OldTurkicGenAIDependencyProcess

Bases: GenAIDependencyProcess

Language-specific dependency process using a generative GPT model.

glottolog_id class-attribute instance-attribute 

glottolog_id: Optional[str] = 'oldu1238'

description class-attribute instance-attribute 

description: str = (
    "Default dependency syntax parsing process using a generative GPT model for the Old Turkic language."
)

authorship_info class-attribute instance-attribute 

authorship_info: str = 'CLTK'

process_id class-attribute 

process_id: str = 'dependency.genai'

prompt_builder_from_tokens class-attribute instance-attribute 

prompt_builder_from_tokens: Optional[PromptBuilder] = None

prompt_builder_from_text class-attribute instance-attribute 

prompt_builder_from_text: Optional[PromptBuilder] = None

prompt_profile class-attribute instance-attribute 

prompt_profile: Optional[str] = None

prompt_version class-attribute instance-attribute 

prompt_version: Optional[str] = None

algorithm cached property 

algorithm: Callable[..., Doc]

Return the dependency generation function for this process.

run 

run(input_doc: Doc) -> Doc

Run the configured GPT dependency parsing workflow.

Source code in cltk/dependency/processes.py 
 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
def run(self, input_doc: Doc) -> Doc:
    """Run the configured GPT dependency parsing workflow."""
    output_doc = copy(input_doc)
    if not output_doc.normalized_text:
        msg: str = "Doc must have `normalized_text`."
        bind_from_doc(output_doc).error(msg)
        raise ValueError(msg)
    # Ensure required attributes are present
    if self.glottolog_id is None:
        raise ValueError("glottolog_id must be set for sentence splitting")
    prompt_builder_from_tokens = self.prompt_builder_from_tokens
    prompt_builder_from_text = self.prompt_builder_from_text
    prompt_digest = None
    if self.prompt_profile and (
        prompt_builder_from_tokens is None or prompt_builder_from_text is None
    ):
        template = PromptProfileRegistry.get_prompt(
            self.prompt_profile, self.process_id, self.prompt_version
        )
        prompt_digest = template.digest
        if prompt_builder_from_tokens is None:

            def _builder_tokens(
                lang: str, table: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from tokens via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="tokens",
                    lang_or_dialect_name=lang,
                    token_table=table,
                    text=table,
                    sentence=table,
                )

            prompt_builder_from_tokens = _builder_tokens
        if prompt_builder_from_text is None:

            def _builder_text(
                lang: str, sentence: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from text via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="text",
                    lang_or_dialect_name=lang,
                    sentence=sentence,
                    text=sentence,
                    token_table=sentence,
                )

            prompt_builder_from_text = _builder_text
    # Callable typing does not retain keyword names; pass positionally
    output_doc = self.algorithm(
        output_doc,
        prompt_builder_from_tokens=prompt_builder_from_tokens,
        prompt_builder_from_text=prompt_builder_from_text,
        prompt_profile=self.prompt_profile,
        prompt_digest=prompt_digest,
        provenance_process=f"{self.process_id}:{self.__class__.__name__}",
    )
    return output_doc

OldTamilGenAIDependencyProcess

Bases: GenAIDependencyProcess

Language-specific dependency process using a generative GPT model.

glottolog_id class-attribute instance-attribute 

glottolog_id: Optional[str] = 'oldt1248'

description class-attribute instance-attribute 

description: str = (
    "Default dependency syntax parsing process using a generative GPT model for the Old Tamil language."
)

authorship_info class-attribute instance-attribute 

authorship_info: str = 'CLTK'

process_id class-attribute 

process_id: str = 'dependency.genai'

prompt_builder_from_tokens class-attribute instance-attribute 

prompt_builder_from_tokens: Optional[PromptBuilder] = None

prompt_builder_from_text class-attribute instance-attribute 

prompt_builder_from_text: Optional[PromptBuilder] = None

prompt_profile class-attribute instance-attribute 

prompt_profile: Optional[str] = None

prompt_version class-attribute instance-attribute 

prompt_version: Optional[str] = None

algorithm cached property 

algorithm: Callable[..., Doc]

Return the dependency generation function for this process.

run 

run(input_doc: Doc) -> Doc

Run the configured GPT dependency parsing workflow.

Source code in cltk/dependency/processes.py 
 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
def run(self, input_doc: Doc) -> Doc:
    """Run the configured GPT dependency parsing workflow."""
    output_doc = copy(input_doc)
    if not output_doc.normalized_text:
        msg: str = "Doc must have `normalized_text`."
        bind_from_doc(output_doc).error(msg)
        raise ValueError(msg)
    # Ensure required attributes are present
    if self.glottolog_id is None:
        raise ValueError("glottolog_id must be set for sentence splitting")
    prompt_builder_from_tokens = self.prompt_builder_from_tokens
    prompt_builder_from_text = self.prompt_builder_from_text
    prompt_digest = None
    if self.prompt_profile and (
        prompt_builder_from_tokens is None or prompt_builder_from_text is None
    ):
        template = PromptProfileRegistry.get_prompt(
            self.prompt_profile, self.process_id, self.prompt_version
        )
        prompt_digest = template.digest
        if prompt_builder_from_tokens is None:

            def _builder_tokens(
                lang: str, table: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from tokens via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="tokens",
                    lang_or_dialect_name=lang,
                    token_table=table,
                    text=table,
                    sentence=table,
                )

            prompt_builder_from_tokens = _builder_tokens
        if prompt_builder_from_text is None:

            def _builder_text(
                lang: str, sentence: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from text via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="text",
                    lang_or_dialect_name=lang,
                    sentence=sentence,
                    text=sentence,
                    token_table=sentence,
                )

            prompt_builder_from_text = _builder_text
    # Callable typing does not retain keyword names; pass positionally
    output_doc = self.algorithm(
        output_doc,
        prompt_builder_from_tokens=prompt_builder_from_tokens,
        prompt_builder_from_text=prompt_builder_from_text,
        prompt_profile=self.prompt_profile,
        prompt_digest=prompt_digest,
        provenance_process=f"{self.process_id}:{self.__class__.__name__}",
    )
    return output_doc

AmmoniteGenAIDependencyProcess

Bases: GenAIDependencyProcess

Language-specific dependency process using a generative GPT model.

glottolog_id class-attribute instance-attribute 

glottolog_id: Optional[str] = 'ammo1234'

description class-attribute instance-attribute 

description: str = (
    "Default dependency syntax parsing process using a generative GPT model for the Ammonite language."
)

authorship_info class-attribute instance-attribute 

authorship_info: str = 'CLTK'

process_id class-attribute 

process_id: str = 'dependency.genai'

prompt_builder_from_tokens class-attribute instance-attribute 

prompt_builder_from_tokens: Optional[PromptBuilder] = None

prompt_builder_from_text class-attribute instance-attribute 

prompt_builder_from_text: Optional[PromptBuilder] = None

prompt_profile class-attribute instance-attribute 

prompt_profile: Optional[str] = None

prompt_version class-attribute instance-attribute 

prompt_version: Optional[str] = None

algorithm cached property 

algorithm: Callable[..., Doc]

Return the dependency generation function for this process.

run 

run(input_doc: Doc) -> Doc

Run the configured GPT dependency parsing workflow.

Source code in cltk/dependency/processes.py 
 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
def run(self, input_doc: Doc) -> Doc:
    """Run the configured GPT dependency parsing workflow."""
    output_doc = copy(input_doc)
    if not output_doc.normalized_text:
        msg: str = "Doc must have `normalized_text`."
        bind_from_doc(output_doc).error(msg)
        raise ValueError(msg)
    # Ensure required attributes are present
    if self.glottolog_id is None:
        raise ValueError("glottolog_id must be set for sentence splitting")
    prompt_builder_from_tokens = self.prompt_builder_from_tokens
    prompt_builder_from_text = self.prompt_builder_from_text
    prompt_digest = None
    if self.prompt_profile and (
        prompt_builder_from_tokens is None or prompt_builder_from_text is None
    ):
        template = PromptProfileRegistry.get_prompt(
            self.prompt_profile, self.process_id, self.prompt_version
        )
        prompt_digest = template.digest
        if prompt_builder_from_tokens is None:

            def _builder_tokens(
                lang: str, table: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from tokens via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="tokens",
                    lang_or_dialect_name=lang,
                    token_table=table,
                    text=table,
                    sentence=table,
                )

            prompt_builder_from_tokens = _builder_tokens
        if prompt_builder_from_text is None:

            def _builder_text(
                lang: str, sentence: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from text via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="text",
                    lang_or_dialect_name=lang,
                    sentence=sentence,
                    text=sentence,
                    token_table=sentence,
                )

            prompt_builder_from_text = _builder_text
    # Callable typing does not retain keyword names; pass positionally
    output_doc = self.algorithm(
        output_doc,
        prompt_builder_from_tokens=prompt_builder_from_tokens,
        prompt_builder_from_text=prompt_builder_from_text,
        prompt_profile=self.prompt_profile,
        prompt_digest=prompt_digest,
        provenance_process=f"{self.process_id}:{self.__class__.__name__}",
    )
    return output_doc

OldAramaicGenAIDependencyProcess

Bases: GenAIDependencyProcess

Language-specific dependency process using a generative GPT model.

glottolog_id class-attribute instance-attribute 

glottolog_id: Optional[str] = 'olda1246'

description class-attribute instance-attribute 

description: str = (
    "Default dependency syntax parsing process using a generative GPT model for the Old Aramaic (up to 700 BCE) language."
)

authorship_info class-attribute instance-attribute 

authorship_info: str = 'CLTK'

process_id class-attribute 

process_id: str = 'dependency.genai'

prompt_builder_from_tokens class-attribute instance-attribute 

prompt_builder_from_tokens: Optional[PromptBuilder] = None

prompt_builder_from_text class-attribute instance-attribute 

prompt_builder_from_text: Optional[PromptBuilder] = None

prompt_profile class-attribute instance-attribute 

prompt_profile: Optional[str] = None

prompt_version class-attribute instance-attribute 

prompt_version: Optional[str] = None

algorithm cached property 

algorithm: Callable[..., Doc]

Return the dependency generation function for this process.

run 

run(input_doc: Doc) -> Doc

Run the configured GPT dependency parsing workflow.

Source code in cltk/dependency/processes.py 
 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
def run(self, input_doc: Doc) -> Doc:
    """Run the configured GPT dependency parsing workflow."""
    output_doc = copy(input_doc)
    if not output_doc.normalized_text:
        msg: str = "Doc must have `normalized_text`."
        bind_from_doc(output_doc).error(msg)
        raise ValueError(msg)
    # Ensure required attributes are present
    if self.glottolog_id is None:
        raise ValueError("glottolog_id must be set for sentence splitting")
    prompt_builder_from_tokens = self.prompt_builder_from_tokens
    prompt_builder_from_text = self.prompt_builder_from_text
    prompt_digest = None
    if self.prompt_profile and (
        prompt_builder_from_tokens is None or prompt_builder_from_text is None
    ):
        template = PromptProfileRegistry.get_prompt(
            self.prompt_profile, self.process_id, self.prompt_version
        )
        prompt_digest = template.digest
        if prompt_builder_from_tokens is None:

            def _builder_tokens(
                lang: str, table: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from tokens via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="tokens",
                    lang_or_dialect_name=lang,
                    token_table=table,
                    text=table,
                    sentence=table,
                )

            prompt_builder_from_tokens = _builder_tokens
        if prompt_builder_from_text is None:

            def _builder_text(
                lang: str, sentence: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from text via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="text",
                    lang_or_dialect_name=lang,
                    sentence=sentence,
                    text=sentence,
                    token_table=sentence,
                )

            prompt_builder_from_text = _builder_text
    # Callable typing does not retain keyword names; pass positionally
    output_doc = self.algorithm(
        output_doc,
        prompt_builder_from_tokens=prompt_builder_from_tokens,
        prompt_builder_from_text=prompt_builder_from_text,
        prompt_profile=self.prompt_profile,
        prompt_digest=prompt_digest,
        provenance_process=f"{self.process_id}:{self.__class__.__name__}",
    )
    return output_doc

OldAramaicSamalianGenAIDependencyProcess

Bases: GenAIDependencyProcess

Language-specific dependency process using a generative GPT model.

glottolog_id class-attribute instance-attribute 

glottolog_id: Optional[str] = 'olda1245'

description class-attribute instance-attribute 

description: str = (
    "Default dependency syntax parsing process using a generative GPT model for the Old Aramaic–Samʾalian language."
)

authorship_info class-attribute instance-attribute 

authorship_info: str = 'CLTK'

process_id class-attribute 

process_id: str = 'dependency.genai'

prompt_builder_from_tokens class-attribute instance-attribute 

prompt_builder_from_tokens: Optional[PromptBuilder] = None

prompt_builder_from_text class-attribute instance-attribute 

prompt_builder_from_text: Optional[PromptBuilder] = None

prompt_profile class-attribute instance-attribute 

prompt_profile: Optional[str] = None

prompt_version class-attribute instance-attribute 

prompt_version: Optional[str] = None

algorithm cached property 

algorithm: Callable[..., Doc]

Return the dependency generation function for this process.

run 

run(input_doc: Doc) -> Doc

Run the configured GPT dependency parsing workflow.

Source code in cltk/dependency/processes.py 
 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
def run(self, input_doc: Doc) -> Doc:
    """Run the configured GPT dependency parsing workflow."""
    output_doc = copy(input_doc)
    if not output_doc.normalized_text:
        msg: str = "Doc must have `normalized_text`."
        bind_from_doc(output_doc).error(msg)
        raise ValueError(msg)
    # Ensure required attributes are present
    if self.glottolog_id is None:
        raise ValueError("glottolog_id must be set for sentence splitting")
    prompt_builder_from_tokens = self.prompt_builder_from_tokens
    prompt_builder_from_text = self.prompt_builder_from_text
    prompt_digest = None
    if self.prompt_profile and (
        prompt_builder_from_tokens is None or prompt_builder_from_text is None
    ):
        template = PromptProfileRegistry.get_prompt(
            self.prompt_profile, self.process_id, self.prompt_version
        )
        prompt_digest = template.digest
        if prompt_builder_from_tokens is None:

            def _builder_tokens(
                lang: str, table: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from tokens via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="tokens",
                    lang_or_dialect_name=lang,
                    token_table=table,
                    text=table,
                    sentence=table,
                )

            prompt_builder_from_tokens = _builder_tokens
        if prompt_builder_from_text is None:

            def _builder_text(
                lang: str, sentence: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from text via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="text",
                    lang_or_dialect_name=lang,
                    sentence=sentence,
                    text=sentence,
                    token_table=sentence,
                )

            prompt_builder_from_text = _builder_text
    # Callable typing does not retain keyword names; pass positionally
    output_doc = self.algorithm(
        output_doc,
        prompt_builder_from_tokens=prompt_builder_from_tokens,
        prompt_builder_from_text=prompt_builder_from_text,
        prompt_profile=self.prompt_profile,
        prompt_digest=prompt_digest,
        provenance_process=f"{self.process_id}:{self.__class__.__name__}",
    )
    return output_doc

MiddleAramaicGenAIDependencyProcess

Bases: GenAIDependencyProcess

Language-specific dependency process using a generative GPT model.

glottolog_id class-attribute instance-attribute 

glottolog_id: Optional[str] = 'midd1366'

description class-attribute instance-attribute 

description: str = (
    "Default dependency syntax parsing process using a generative GPT model for the Middle Aramaic language."
)

authorship_info class-attribute instance-attribute 

authorship_info: str = 'CLTK'

process_id class-attribute 

process_id: str = 'dependency.genai'

prompt_builder_from_tokens class-attribute instance-attribute 

prompt_builder_from_tokens: Optional[PromptBuilder] = None

prompt_builder_from_text class-attribute instance-attribute 

prompt_builder_from_text: Optional[PromptBuilder] = None

prompt_profile class-attribute instance-attribute 

prompt_profile: Optional[str] = None

prompt_version class-attribute instance-attribute 

prompt_version: Optional[str] = None

algorithm cached property 

algorithm: Callable[..., Doc]

Return the dependency generation function for this process.

run 

run(input_doc: Doc) -> Doc

Run the configured GPT dependency parsing workflow.

Source code in cltk/dependency/processes.py 
 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
def run(self, input_doc: Doc) -> Doc:
    """Run the configured GPT dependency parsing workflow."""
    output_doc = copy(input_doc)
    if not output_doc.normalized_text:
        msg: str = "Doc must have `normalized_text`."
        bind_from_doc(output_doc).error(msg)
        raise ValueError(msg)
    # Ensure required attributes are present
    if self.glottolog_id is None:
        raise ValueError("glottolog_id must be set for sentence splitting")
    prompt_builder_from_tokens = self.prompt_builder_from_tokens
    prompt_builder_from_text = self.prompt_builder_from_text
    prompt_digest = None
    if self.prompt_profile and (
        prompt_builder_from_tokens is None or prompt_builder_from_text is None
    ):
        template = PromptProfileRegistry.get_prompt(
            self.prompt_profile, self.process_id, self.prompt_version
        )
        prompt_digest = template.digest
        if prompt_builder_from_tokens is None:

            def _builder_tokens(
                lang: str, table: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from tokens via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="tokens",
                    lang_or_dialect_name=lang,
                    token_table=table,
                    text=table,
                    sentence=table,
                )

            prompt_builder_from_tokens = _builder_tokens
        if prompt_builder_from_text is None:

            def _builder_text(
                lang: str, sentence: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from text via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="text",
                    lang_or_dialect_name=lang,
                    sentence=sentence,
                    text=sentence,
                    token_table=sentence,
                )

            prompt_builder_from_text = _builder_text
    # Callable typing does not retain keyword names; pass positionally
    output_doc = self.algorithm(
        output_doc,
        prompt_builder_from_tokens=prompt_builder_from_tokens,
        prompt_builder_from_text=prompt_builder_from_text,
        prompt_profile=self.prompt_profile,
        prompt_digest=prompt_digest,
        provenance_process=f"{self.process_id}:{self.__class__.__name__}",
    )
    return output_doc

HatranGenAIDependencyProcess

Bases: GenAIDependencyProcess

Language-specific dependency process using a generative GPT model.

glottolog_id class-attribute instance-attribute 

glottolog_id: Optional[str] = 'hatr1234'

description class-attribute instance-attribute 

description: str = (
    "Default dependency syntax parsing process using a generative GPT model for the Hatran language."
)

authorship_info class-attribute instance-attribute 

authorship_info: str = 'CLTK'

process_id class-attribute 

process_id: str = 'dependency.genai'

prompt_builder_from_tokens class-attribute instance-attribute 

prompt_builder_from_tokens: Optional[PromptBuilder] = None

prompt_builder_from_text class-attribute instance-attribute 

prompt_builder_from_text: Optional[PromptBuilder] = None

prompt_profile class-attribute instance-attribute 

prompt_profile: Optional[str] = None

prompt_version class-attribute instance-attribute 

prompt_version: Optional[str] = None

algorithm cached property 

algorithm: Callable[..., Doc]

Return the dependency generation function for this process.

run 

run(input_doc: Doc) -> Doc

Run the configured GPT dependency parsing workflow.

Source code in cltk/dependency/processes.py 
 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
def run(self, input_doc: Doc) -> Doc:
    """Run the configured GPT dependency parsing workflow."""
    output_doc = copy(input_doc)
    if not output_doc.normalized_text:
        msg: str = "Doc must have `normalized_text`."
        bind_from_doc(output_doc).error(msg)
        raise ValueError(msg)
    # Ensure required attributes are present
    if self.glottolog_id is None:
        raise ValueError("glottolog_id must be set for sentence splitting")
    prompt_builder_from_tokens = self.prompt_builder_from_tokens
    prompt_builder_from_text = self.prompt_builder_from_text
    prompt_digest = None
    if self.prompt_profile and (
        prompt_builder_from_tokens is None or prompt_builder_from_text is None
    ):
        template = PromptProfileRegistry.get_prompt(
            self.prompt_profile, self.process_id, self.prompt_version
        )
        prompt_digest = template.digest
        if prompt_builder_from_tokens is None:

            def _builder_tokens(
                lang: str, table: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from tokens via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="tokens",
                    lang_or_dialect_name=lang,
                    token_table=table,
                    text=table,
                    sentence=table,
                )

            prompt_builder_from_tokens = _builder_tokens
        if prompt_builder_from_text is None:

            def _builder_text(
                lang: str, sentence: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from text via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="text",
                    lang_or_dialect_name=lang,
                    sentence=sentence,
                    text=sentence,
                    token_table=sentence,
                )

            prompt_builder_from_text = _builder_text
    # Callable typing does not retain keyword names; pass positionally
    output_doc = self.algorithm(
        output_doc,
        prompt_builder_from_tokens=prompt_builder_from_tokens,
        prompt_builder_from_text=prompt_builder_from_text,
        prompt_profile=self.prompt_profile,
        prompt_digest=prompt_digest,
        provenance_process=f"{self.process_id}:{self.__class__.__name__}",
    )
    return output_doc

JewishBabylonianAramaicGenAIDependencyProcess

Bases: GenAIDependencyProcess

Language-specific dependency process using a generative GPT model.

glottolog_id class-attribute instance-attribute 

glottolog_id: Optional[str] = 'jewi1240'

description class-attribute instance-attribute 

description: str = (
    "Default dependency syntax parsing process using a generative GPT model for the Jewish Babylonian Aramaic language."
)

authorship_info class-attribute instance-attribute 

authorship_info: str = 'CLTK'

process_id class-attribute 

process_id: str = 'dependency.genai'

prompt_builder_from_tokens class-attribute instance-attribute 

prompt_builder_from_tokens: Optional[PromptBuilder] = None

prompt_builder_from_text class-attribute instance-attribute 

prompt_builder_from_text: Optional[PromptBuilder] = None

prompt_profile class-attribute instance-attribute 

prompt_profile: Optional[str] = None

prompt_version class-attribute instance-attribute 

prompt_version: Optional[str] = None

algorithm cached property 

algorithm: Callable[..., Doc]

Return the dependency generation function for this process.

run 

run(input_doc: Doc) -> Doc

Run the configured GPT dependency parsing workflow.

Source code in cltk/dependency/processes.py 
 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
def run(self, input_doc: Doc) -> Doc:
    """Run the configured GPT dependency parsing workflow."""
    output_doc = copy(input_doc)
    if not output_doc.normalized_text:
        msg: str = "Doc must have `normalized_text`."
        bind_from_doc(output_doc).error(msg)
        raise ValueError(msg)
    # Ensure required attributes are present
    if self.glottolog_id is None:
        raise ValueError("glottolog_id must be set for sentence splitting")
    prompt_builder_from_tokens = self.prompt_builder_from_tokens
    prompt_builder_from_text = self.prompt_builder_from_text
    prompt_digest = None
    if self.prompt_profile and (
        prompt_builder_from_tokens is None or prompt_builder_from_text is None
    ):
        template = PromptProfileRegistry.get_prompt(
            self.prompt_profile, self.process_id, self.prompt_version
        )
        prompt_digest = template.digest
        if prompt_builder_from_tokens is None:

            def _builder_tokens(
                lang: str, table: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from tokens via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="tokens",
                    lang_or_dialect_name=lang,
                    token_table=table,
                    text=table,
                    sentence=table,
                )

            prompt_builder_from_tokens = _builder_tokens
        if prompt_builder_from_text is None:

            def _builder_text(
                lang: str, sentence: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from text via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="text",
                    lang_or_dialect_name=lang,
                    sentence=sentence,
                    text=sentence,
                    token_table=sentence,
                )

            prompt_builder_from_text = _builder_text
    # Callable typing does not retain keyword names; pass positionally
    output_doc = self.algorithm(
        output_doc,
        prompt_builder_from_tokens=prompt_builder_from_tokens,
        prompt_builder_from_text=prompt_builder_from_text,
        prompt_profile=self.prompt_profile,
        prompt_digest=prompt_digest,
        provenance_process=f"{self.process_id}:{self.__class__.__name__}",
    )
    return output_doc

SamalianGenAIDependencyProcess

Bases: GenAIDependencyProcess

Language-specific dependency process using a generative GPT model.

glottolog_id class-attribute instance-attribute 

glottolog_id: Optional[str] = 'sama1234'

description class-attribute instance-attribute 

description: str = (
    "Default dependency syntax parsing process using a generative GPT model for the Samʾalian language."
)

authorship_info class-attribute instance-attribute 

authorship_info: str = 'CLTK'

process_id class-attribute 

process_id: str = 'dependency.genai'

prompt_builder_from_tokens class-attribute instance-attribute 

prompt_builder_from_tokens: Optional[PromptBuilder] = None

prompt_builder_from_text class-attribute instance-attribute 

prompt_builder_from_text: Optional[PromptBuilder] = None

prompt_profile class-attribute instance-attribute 

prompt_profile: Optional[str] = None

prompt_version class-attribute instance-attribute 

prompt_version: Optional[str] = None

algorithm cached property 

algorithm: Callable[..., Doc]

Return the dependency generation function for this process.

run 

run(input_doc: Doc) -> Doc

Run the configured GPT dependency parsing workflow.

Source code in cltk/dependency/processes.py 
 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
def run(self, input_doc: Doc) -> Doc:
    """Run the configured GPT dependency parsing workflow."""
    output_doc = copy(input_doc)
    if not output_doc.normalized_text:
        msg: str = "Doc must have `normalized_text`."
        bind_from_doc(output_doc).error(msg)
        raise ValueError(msg)
    # Ensure required attributes are present
    if self.glottolog_id is None:
        raise ValueError("glottolog_id must be set for sentence splitting")
    prompt_builder_from_tokens = self.prompt_builder_from_tokens
    prompt_builder_from_text = self.prompt_builder_from_text
    prompt_digest = None
    if self.prompt_profile and (
        prompt_builder_from_tokens is None or prompt_builder_from_text is None
    ):
        template = PromptProfileRegistry.get_prompt(
            self.prompt_profile, self.process_id, self.prompt_version
        )
        prompt_digest = template.digest
        if prompt_builder_from_tokens is None:

            def _builder_tokens(
                lang: str, table: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from tokens via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="tokens",
                    lang_or_dialect_name=lang,
                    token_table=table,
                    text=table,
                    sentence=table,
                )

            prompt_builder_from_tokens = _builder_tokens
        if prompt_builder_from_text is None:

            def _builder_text(
                lang: str, sentence: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from text via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="text",
                    lang_or_dialect_name=lang,
                    sentence=sentence,
                    text=sentence,
                    token_table=sentence,
                )

            prompt_builder_from_text = _builder_text
    # Callable typing does not retain keyword names; pass positionally
    output_doc = self.algorithm(
        output_doc,
        prompt_builder_from_tokens=prompt_builder_from_tokens,
        prompt_builder_from_text=prompt_builder_from_text,
        prompt_profile=self.prompt_profile,
        prompt_digest=prompt_digest,
        provenance_process=f"{self.process_id}:{self.__class__.__name__}",
    )
    return output_doc

OldEgyptianGenAIDependencyProcess

Bases: GenAIDependencyProcess

Language-specific dependency process using a generative GPT model.

glottolog_id class-attribute instance-attribute 

glottolog_id: Optional[str] = 'olde1242'

description class-attribute instance-attribute 

description: str = (
    "Default dependency syntax parsing process using a generative GPT model for the Old Egyptian language."
)

authorship_info class-attribute instance-attribute 

authorship_info: str = 'CLTK'

process_id class-attribute 

process_id: str = 'dependency.genai'

prompt_builder_from_tokens class-attribute instance-attribute 

prompt_builder_from_tokens: Optional[PromptBuilder] = None

prompt_builder_from_text class-attribute instance-attribute 

prompt_builder_from_text: Optional[PromptBuilder] = None

prompt_profile class-attribute instance-attribute 

prompt_profile: Optional[str] = None

prompt_version class-attribute instance-attribute 

prompt_version: Optional[str] = None

algorithm cached property 

algorithm: Callable[..., Doc]

Return the dependency generation function for this process.

run 

run(input_doc: Doc) -> Doc

Run the configured GPT dependency parsing workflow.

Source code in cltk/dependency/processes.py 
 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
def run(self, input_doc: Doc) -> Doc:
    """Run the configured GPT dependency parsing workflow."""
    output_doc = copy(input_doc)
    if not output_doc.normalized_text:
        msg: str = "Doc must have `normalized_text`."
        bind_from_doc(output_doc).error(msg)
        raise ValueError(msg)
    # Ensure required attributes are present
    if self.glottolog_id is None:
        raise ValueError("glottolog_id must be set for sentence splitting")
    prompt_builder_from_tokens = self.prompt_builder_from_tokens
    prompt_builder_from_text = self.prompt_builder_from_text
    prompt_digest = None
    if self.prompt_profile and (
        prompt_builder_from_tokens is None or prompt_builder_from_text is None
    ):
        template = PromptProfileRegistry.get_prompt(
            self.prompt_profile, self.process_id, self.prompt_version
        )
        prompt_digest = template.digest
        if prompt_builder_from_tokens is None:

            def _builder_tokens(
                lang: str, table: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from tokens via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="tokens",
                    lang_or_dialect_name=lang,
                    token_table=table,
                    text=table,
                    sentence=table,
                )

            prompt_builder_from_tokens = _builder_tokens
        if prompt_builder_from_text is None:

            def _builder_text(
                lang: str, sentence: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from text via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="text",
                    lang_or_dialect_name=lang,
                    sentence=sentence,
                    text=sentence,
                    token_table=sentence,
                )

            prompt_builder_from_text = _builder_text
    # Callable typing does not retain keyword names; pass positionally
    output_doc = self.algorithm(
        output_doc,
        prompt_builder_from_tokens=prompt_builder_from_tokens,
        prompt_builder_from_text=prompt_builder_from_text,
        prompt_profile=self.prompt_profile,
        prompt_digest=prompt_digest,
        provenance_process=f"{self.process_id}:{self.__class__.__name__}",
    )
    return output_doc

OldEnglishGenAIDependencyProcess

Bases: GenAIDependencyProcess

Language-specific dependency process using a generative GPT model.

glottolog_id class-attribute instance-attribute 

glottolog_id: Optional[str] = 'olde1238'

description class-attribute instance-attribute 

description: str = (
    "Default dependency syntax parsing process using a generative GPT model for the Old English (ca. 450-1100) language."
)

authorship_info class-attribute instance-attribute 

authorship_info: str = 'CLTK'

process_id class-attribute 

process_id: str = 'dependency.genai'

prompt_builder_from_tokens class-attribute instance-attribute 

prompt_builder_from_tokens: Optional[PromptBuilder] = None

prompt_builder_from_text class-attribute instance-attribute 

prompt_builder_from_text: Optional[PromptBuilder] = None

prompt_profile class-attribute instance-attribute 

prompt_profile: Optional[str] = None

prompt_version class-attribute instance-attribute 

prompt_version: Optional[str] = None

algorithm cached property 

algorithm: Callable[..., Doc]

Return the dependency generation function for this process.

run 

run(input_doc: Doc) -> Doc

Run the configured GPT dependency parsing workflow.

Source code in cltk/dependency/processes.py 
 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
def run(self, input_doc: Doc) -> Doc:
    """Run the configured GPT dependency parsing workflow."""
    output_doc = copy(input_doc)
    if not output_doc.normalized_text:
        msg: str = "Doc must have `normalized_text`."
        bind_from_doc(output_doc).error(msg)
        raise ValueError(msg)
    # Ensure required attributes are present
    if self.glottolog_id is None:
        raise ValueError("glottolog_id must be set for sentence splitting")
    prompt_builder_from_tokens = self.prompt_builder_from_tokens
    prompt_builder_from_text = self.prompt_builder_from_text
    prompt_digest = None
    if self.prompt_profile and (
        prompt_builder_from_tokens is None or prompt_builder_from_text is None
    ):
        template = PromptProfileRegistry.get_prompt(
            self.prompt_profile, self.process_id, self.prompt_version
        )
        prompt_digest = template.digest
        if prompt_builder_from_tokens is None:

            def _builder_tokens(
                lang: str, table: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from tokens via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="tokens",
                    lang_or_dialect_name=lang,
                    token_table=table,
                    text=table,
                    sentence=table,
                )

            prompt_builder_from_tokens = _builder_tokens
        if prompt_builder_from_text is None:

            def _builder_text(
                lang: str, sentence: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from text via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="text",
                    lang_or_dialect_name=lang,
                    sentence=sentence,
                    text=sentence,
                    token_table=sentence,
                )

            prompt_builder_from_text = _builder_text
    # Callable typing does not retain keyword names; pass positionally
    output_doc = self.algorithm(
        output_doc,
        prompt_builder_from_tokens=prompt_builder_from_tokens,
        prompt_builder_from_text=prompt_builder_from_text,
        prompt_profile=self.prompt_profile,
        prompt_digest=prompt_digest,
        provenance_process=f"{self.process_id}:{self.__class__.__name__}",
    )
    return output_doc

OldFrenchGenAIDependencyProcess

Bases: GenAIDependencyProcess

Language-specific dependency process using a generative GPT model.

glottolog_id class-attribute instance-attribute 

glottolog_id: Optional[str] = 'oldf1239'

description class-attribute instance-attribute 

description: str = (
    "Default dependency syntax parsing process using a generative GPT model for the Old French (842-ca. 1400) language."
)

authorship_info class-attribute instance-attribute 

authorship_info: str = 'CLTK'

process_id class-attribute 

process_id: str = 'dependency.genai'

prompt_builder_from_tokens class-attribute instance-attribute 

prompt_builder_from_tokens: Optional[PromptBuilder] = None

prompt_builder_from_text class-attribute instance-attribute 

prompt_builder_from_text: Optional[PromptBuilder] = None

prompt_profile class-attribute instance-attribute 

prompt_profile: Optional[str] = None

prompt_version class-attribute instance-attribute 

prompt_version: Optional[str] = None

algorithm cached property 

algorithm: Callable[..., Doc]

Return the dependency generation function for this process.

run 

run(input_doc: Doc) -> Doc

Run the configured GPT dependency parsing workflow.

Source code in cltk/dependency/processes.py 
 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
def run(self, input_doc: Doc) -> Doc:
    """Run the configured GPT dependency parsing workflow."""
    output_doc = copy(input_doc)
    if not output_doc.normalized_text:
        msg: str = "Doc must have `normalized_text`."
        bind_from_doc(output_doc).error(msg)
        raise ValueError(msg)
    # Ensure required attributes are present
    if self.glottolog_id is None:
        raise ValueError("glottolog_id must be set for sentence splitting")
    prompt_builder_from_tokens = self.prompt_builder_from_tokens
    prompt_builder_from_text = self.prompt_builder_from_text
    prompt_digest = None
    if self.prompt_profile and (
        prompt_builder_from_tokens is None or prompt_builder_from_text is None
    ):
        template = PromptProfileRegistry.get_prompt(
            self.prompt_profile, self.process_id, self.prompt_version
        )
        prompt_digest = template.digest
        if prompt_builder_from_tokens is None:

            def _builder_tokens(
                lang: str, table: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from tokens via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="tokens",
                    lang_or_dialect_name=lang,
                    token_table=table,
                    text=table,
                    sentence=table,
                )

            prompt_builder_from_tokens = _builder_tokens
        if prompt_builder_from_text is None:

            def _builder_text(
                lang: str, sentence: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from text via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="text",
                    lang_or_dialect_name=lang,
                    sentence=sentence,
                    text=sentence,
                    token_table=sentence,
                )

            prompt_builder_from_text = _builder_text
    # Callable typing does not retain keyword names; pass positionally
    output_doc = self.algorithm(
        output_doc,
        prompt_builder_from_tokens=prompt_builder_from_tokens,
        prompt_builder_from_text=prompt_builder_from_text,
        prompt_profile=self.prompt_profile,
        prompt_digest=prompt_digest,
        provenance_process=f"{self.process_id}:{self.__class__.__name__}",
    )
    return output_doc

OldHighGermanGenAIDependencyProcess

Bases: GenAIDependencyProcess

Language-specific dependency process using a generative GPT model.

glottolog_id class-attribute instance-attribute 

glottolog_id: Optional[str] = 'oldh1241'

description class-attribute instance-attribute 

description: str = (
    "Default dependency syntax parsing process using a generative GPT model for the Old High German (ca. 750-1050) language."
)

authorship_info class-attribute instance-attribute 

authorship_info: str = 'CLTK'

process_id class-attribute 

process_id: str = 'dependency.genai'

prompt_builder_from_tokens class-attribute instance-attribute 

prompt_builder_from_tokens: Optional[PromptBuilder] = None

prompt_builder_from_text class-attribute instance-attribute 

prompt_builder_from_text: Optional[PromptBuilder] = None

prompt_profile class-attribute instance-attribute 

prompt_profile: Optional[str] = None

prompt_version class-attribute instance-attribute 

prompt_version: Optional[str] = None

algorithm cached property 

algorithm: Callable[..., Doc]

Return the dependency generation function for this process.

run 

run(input_doc: Doc) -> Doc

Run the configured GPT dependency parsing workflow.

Source code in cltk/dependency/processes.py 
 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
def run(self, input_doc: Doc) -> Doc:
    """Run the configured GPT dependency parsing workflow."""
    output_doc = copy(input_doc)
    if not output_doc.normalized_text:
        msg: str = "Doc must have `normalized_text`."
        bind_from_doc(output_doc).error(msg)
        raise ValueError(msg)
    # Ensure required attributes are present
    if self.glottolog_id is None:
        raise ValueError("glottolog_id must be set for sentence splitting")
    prompt_builder_from_tokens = self.prompt_builder_from_tokens
    prompt_builder_from_text = self.prompt_builder_from_text
    prompt_digest = None
    if self.prompt_profile and (
        prompt_builder_from_tokens is None or prompt_builder_from_text is None
    ):
        template = PromptProfileRegistry.get_prompt(
            self.prompt_profile, self.process_id, self.prompt_version
        )
        prompt_digest = template.digest
        if prompt_builder_from_tokens is None:

            def _builder_tokens(
                lang: str, table: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from tokens via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="tokens",
                    lang_or_dialect_name=lang,
                    token_table=table,
                    text=table,
                    sentence=table,
                )

            prompt_builder_from_tokens = _builder_tokens
        if prompt_builder_from_text is None:

            def _builder_text(
                lang: str, sentence: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from text via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="text",
                    lang_or_dialect_name=lang,
                    sentence=sentence,
                    text=sentence,
                    token_table=sentence,
                )

            prompt_builder_from_text = _builder_text
    # Callable typing does not retain keyword names; pass positionally
    output_doc = self.algorithm(
        output_doc,
        prompt_builder_from_tokens=prompt_builder_from_tokens,
        prompt_builder_from_text=prompt_builder_from_text,
        prompt_profile=self.prompt_profile,
        prompt_digest=prompt_digest,
        provenance_process=f"{self.process_id}:{self.__class__.__name__}",
    )
    return output_doc

EarlyIrishGenAIDependencyProcess

Bases: GenAIDependencyProcess

Language-specific dependency process using a generative GPT model.

glottolog_id class-attribute instance-attribute 

glottolog_id: Optional[str] = 'oldi1245'

description class-attribute instance-attribute 

description: str = (
    "Default dependency syntax parsing process using a generative GPT model for the Old Irish language."
)

authorship_info class-attribute instance-attribute 

authorship_info: str = 'CLTK'

process_id class-attribute 

process_id: str = 'dependency.genai'

prompt_builder_from_tokens class-attribute instance-attribute 

prompt_builder_from_tokens: Optional[PromptBuilder] = None

prompt_builder_from_text class-attribute instance-attribute 

prompt_builder_from_text: Optional[PromptBuilder] = None

prompt_profile class-attribute instance-attribute 

prompt_profile: Optional[str] = None

prompt_version class-attribute instance-attribute 

prompt_version: Optional[str] = None

algorithm cached property 

algorithm: Callable[..., Doc]

Return the dependency generation function for this process.

run 

run(input_doc: Doc) -> Doc

Run the configured GPT dependency parsing workflow.

Source code in cltk/dependency/processes.py 
 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
def run(self, input_doc: Doc) -> Doc:
    """Run the configured GPT dependency parsing workflow."""
    output_doc = copy(input_doc)
    if not output_doc.normalized_text:
        msg: str = "Doc must have `normalized_text`."
        bind_from_doc(output_doc).error(msg)
        raise ValueError(msg)
    # Ensure required attributes are present
    if self.glottolog_id is None:
        raise ValueError("glottolog_id must be set for sentence splitting")
    prompt_builder_from_tokens = self.prompt_builder_from_tokens
    prompt_builder_from_text = self.prompt_builder_from_text
    prompt_digest = None
    if self.prompt_profile and (
        prompt_builder_from_tokens is None or prompt_builder_from_text is None
    ):
        template = PromptProfileRegistry.get_prompt(
            self.prompt_profile, self.process_id, self.prompt_version
        )
        prompt_digest = template.digest
        if prompt_builder_from_tokens is None:

            def _builder_tokens(
                lang: str, table: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from tokens via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="tokens",
                    lang_or_dialect_name=lang,
                    token_table=table,
                    text=table,
                    sentence=table,
                )

            prompt_builder_from_tokens = _builder_tokens
        if prompt_builder_from_text is None:

            def _builder_text(
                lang: str, sentence: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from text via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="text",
                    lang_or_dialect_name=lang,
                    sentence=sentence,
                    text=sentence,
                    token_table=sentence,
                )

            prompt_builder_from_text = _builder_text
    # Callable typing does not retain keyword names; pass positionally
    output_doc = self.algorithm(
        output_doc,
        prompt_builder_from_tokens=prompt_builder_from_tokens,
        prompt_builder_from_text=prompt_builder_from_text,
        prompt_profile=self.prompt_profile,
        prompt_digest=prompt_digest,
        provenance_process=f"{self.process_id}:{self.__class__.__name__}",
    )
    return output_doc

MarathiGenAIDependencyProcess

Bases: GenAIDependencyProcess

Language-specific dependency process using a generative GPT model.

glottolog_id class-attribute instance-attribute 

glottolog_id: Optional[str] = 'mara1378'

description class-attribute instance-attribute 

description: str = (
    "Default dependency syntax parsing process using a generative GPT model for the Marathi language."
)

authorship_info class-attribute instance-attribute 

authorship_info: str = 'CLTK'

process_id class-attribute 

process_id: str = 'dependency.genai'

prompt_builder_from_tokens class-attribute instance-attribute 

prompt_builder_from_tokens: Optional[PromptBuilder] = None

prompt_builder_from_text class-attribute instance-attribute 

prompt_builder_from_text: Optional[PromptBuilder] = None

prompt_profile class-attribute instance-attribute 

prompt_profile: Optional[str] = None

prompt_version class-attribute instance-attribute 

prompt_version: Optional[str] = None

algorithm cached property 

algorithm: Callable[..., Doc]

Return the dependency generation function for this process.

run 

run(input_doc: Doc) -> Doc

Run the configured GPT dependency parsing workflow.

Source code in cltk/dependency/processes.py 
 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
def run(self, input_doc: Doc) -> Doc:
    """Run the configured GPT dependency parsing workflow."""
    output_doc = copy(input_doc)
    if not output_doc.normalized_text:
        msg: str = "Doc must have `normalized_text`."
        bind_from_doc(output_doc).error(msg)
        raise ValueError(msg)
    # Ensure required attributes are present
    if self.glottolog_id is None:
        raise ValueError("glottolog_id must be set for sentence splitting")
    prompt_builder_from_tokens = self.prompt_builder_from_tokens
    prompt_builder_from_text = self.prompt_builder_from_text
    prompt_digest = None
    if self.prompt_profile and (
        prompt_builder_from_tokens is None or prompt_builder_from_text is None
    ):
        template = PromptProfileRegistry.get_prompt(
            self.prompt_profile, self.process_id, self.prompt_version
        )
        prompt_digest = template.digest
        if prompt_builder_from_tokens is None:

            def _builder_tokens(
                lang: str, table: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from tokens via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="tokens",
                    lang_or_dialect_name=lang,
                    token_table=table,
                    text=table,
                    sentence=table,
                )

            prompt_builder_from_tokens = _builder_tokens
        if prompt_builder_from_text is None:

            def _builder_text(
                lang: str, sentence: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from text via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="text",
                    lang_or_dialect_name=lang,
                    sentence=sentence,
                    text=sentence,
                    token_table=sentence,
                )

            prompt_builder_from_text = _builder_text
    # Callable typing does not retain keyword names; pass positionally
    output_doc = self.algorithm(
        output_doc,
        prompt_builder_from_tokens=prompt_builder_from_tokens,
        prompt_builder_from_text=prompt_builder_from_text,
        prompt_profile=self.prompt_profile,
        prompt_digest=prompt_digest,
        provenance_process=f"{self.process_id}:{self.__class__.__name__}",
    )
    return output_doc

OldNorseGenAIDependencyProcess

Bases: GenAIDependencyProcess

Language-specific dependency process using a generative GPT model.

glottolog_id class-attribute instance-attribute 

glottolog_id: Optional[str] = 'oldn1244'

description class-attribute instance-attribute 

description: str = (
    "Default dependency syntax parsing process using a generative GPT model for the Old Norse language."
)

authorship_info class-attribute instance-attribute 

authorship_info: str = 'CLTK'

process_id class-attribute 

process_id: str = 'dependency.genai'

prompt_builder_from_tokens class-attribute instance-attribute 

prompt_builder_from_tokens: Optional[PromptBuilder] = None

prompt_builder_from_text class-attribute instance-attribute 

prompt_builder_from_text: Optional[PromptBuilder] = None

prompt_profile class-attribute instance-attribute 

prompt_profile: Optional[str] = None

prompt_version class-attribute instance-attribute 

prompt_version: Optional[str] = None

algorithm cached property 

algorithm: Callable[..., Doc]

Return the dependency generation function for this process.

run 

run(input_doc: Doc) -> Doc

Run the configured GPT dependency parsing workflow.

Source code in cltk/dependency/processes.py 
 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
def run(self, input_doc: Doc) -> Doc:
    """Run the configured GPT dependency parsing workflow."""
    output_doc = copy(input_doc)
    if not output_doc.normalized_text:
        msg: str = "Doc must have `normalized_text`."
        bind_from_doc(output_doc).error(msg)
        raise ValueError(msg)
    # Ensure required attributes are present
    if self.glottolog_id is None:
        raise ValueError("glottolog_id must be set for sentence splitting")
    prompt_builder_from_tokens = self.prompt_builder_from_tokens
    prompt_builder_from_text = self.prompt_builder_from_text
    prompt_digest = None
    if self.prompt_profile and (
        prompt_builder_from_tokens is None or prompt_builder_from_text is None
    ):
        template = PromptProfileRegistry.get_prompt(
            self.prompt_profile, self.process_id, self.prompt_version
        )
        prompt_digest = template.digest
        if prompt_builder_from_tokens is None:

            def _builder_tokens(
                lang: str, table: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from tokens via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="tokens",
                    lang_or_dialect_name=lang,
                    token_table=table,
                    text=table,
                    sentence=table,
                )

            prompt_builder_from_tokens = _builder_tokens
        if prompt_builder_from_text is None:

            def _builder_text(
                lang: str, sentence: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from text via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="text",
                    lang_or_dialect_name=lang,
                    sentence=sentence,
                    text=sentence,
                    token_table=sentence,
                )

            prompt_builder_from_text = _builder_text
    # Callable typing does not retain keyword names; pass positionally
    output_doc = self.algorithm(
        output_doc,
        prompt_builder_from_tokens=prompt_builder_from_tokens,
        prompt_builder_from_text=prompt_builder_from_text,
        prompt_profile=self.prompt_profile,
        prompt_digest=prompt_digest,
        provenance_process=f"{self.process_id}:{self.__class__.__name__}",
    )
    return output_doc

OldPersianGenAIDependencyProcess

Bases: GenAIDependencyProcess

Language-specific dependency process using a generative GPT model.

glottolog_id class-attribute instance-attribute 

glottolog_id: Optional[str] = 'oldp1254'

description class-attribute instance-attribute 

description: str = (
    "Default dependency syntax parsing process using a generative GPT model for the Old Persian (ca. 600-400 B.C.) language."
)

authorship_info class-attribute instance-attribute 

authorship_info: str = 'CLTK'

process_id class-attribute 

process_id: str = 'dependency.genai'

prompt_builder_from_tokens class-attribute instance-attribute 

prompt_builder_from_tokens: Optional[PromptBuilder] = None

prompt_builder_from_text class-attribute instance-attribute 

prompt_builder_from_text: Optional[PromptBuilder] = None

prompt_profile class-attribute instance-attribute 

prompt_profile: Optional[str] = None

prompt_version class-attribute instance-attribute 

prompt_version: Optional[str] = None

algorithm cached property 

algorithm: Callable[..., Doc]

Return the dependency generation function for this process.

run 

run(input_doc: Doc) -> Doc

Run the configured GPT dependency parsing workflow.

Source code in cltk/dependency/processes.py 
 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
def run(self, input_doc: Doc) -> Doc:
    """Run the configured GPT dependency parsing workflow."""
    output_doc = copy(input_doc)
    if not output_doc.normalized_text:
        msg: str = "Doc must have `normalized_text`."
        bind_from_doc(output_doc).error(msg)
        raise ValueError(msg)
    # Ensure required attributes are present
    if self.glottolog_id is None:
        raise ValueError("glottolog_id must be set for sentence splitting")
    prompt_builder_from_tokens = self.prompt_builder_from_tokens
    prompt_builder_from_text = self.prompt_builder_from_text
    prompt_digest = None
    if self.prompt_profile and (
        prompt_builder_from_tokens is None or prompt_builder_from_text is None
    ):
        template = PromptProfileRegistry.get_prompt(
            self.prompt_profile, self.process_id, self.prompt_version
        )
        prompt_digest = template.digest
        if prompt_builder_from_tokens is None:

            def _builder_tokens(
                lang: str, table: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from tokens via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="tokens",
                    lang_or_dialect_name=lang,
                    token_table=table,
                    text=table,
                    sentence=table,
                )

            prompt_builder_from_tokens = _builder_tokens
        if prompt_builder_from_text is None:

            def _builder_text(
                lang: str, sentence: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from text via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="text",
                    lang_or_dialect_name=lang,
                    sentence=sentence,
                    text=sentence,
                    token_table=sentence,
                )

            prompt_builder_from_text = _builder_text
    # Callable typing does not retain keyword names; pass positionally
    output_doc = self.algorithm(
        output_doc,
        prompt_builder_from_tokens=prompt_builder_from_tokens,
        prompt_builder_from_text=prompt_builder_from_text,
        prompt_profile=self.prompt_profile,
        prompt_digest=prompt_digest,
        provenance_process=f"{self.process_id}:{self.__class__.__name__}",
    )
    return output_doc

OldMiddleWelshGenAIDependencyProcess

Bases: GenAIDependencyProcess

Language-specific dependency process using a generative GPT model.

glottolog_id class-attribute instance-attribute 

glottolog_id: Optional[str] = 'oldw1239'

description class-attribute instance-attribute 

description: str = (
    "Default dependency syntax parsing process using a generative GPT model for the Old-Middle Welsh language."
)

authorship_info class-attribute instance-attribute 

authorship_info: str = 'CLTK'

process_id class-attribute 

process_id: str = 'dependency.genai'

prompt_builder_from_tokens class-attribute instance-attribute 

prompt_builder_from_tokens: Optional[PromptBuilder] = None

prompt_builder_from_text class-attribute instance-attribute 

prompt_builder_from_text: Optional[PromptBuilder] = None

prompt_profile class-attribute instance-attribute 

prompt_profile: Optional[str] = None

prompt_version class-attribute instance-attribute 

prompt_version: Optional[str] = None

algorithm cached property 

algorithm: Callable[..., Doc]

Return the dependency generation function for this process.

run 

run(input_doc: Doc) -> Doc

Run the configured GPT dependency parsing workflow.

Source code in cltk/dependency/processes.py 
 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
def run(self, input_doc: Doc) -> Doc:
    """Run the configured GPT dependency parsing workflow."""
    output_doc = copy(input_doc)
    if not output_doc.normalized_text:
        msg: str = "Doc must have `normalized_text`."
        bind_from_doc(output_doc).error(msg)
        raise ValueError(msg)
    # Ensure required attributes are present
    if self.glottolog_id is None:
        raise ValueError("glottolog_id must be set for sentence splitting")
    prompt_builder_from_tokens = self.prompt_builder_from_tokens
    prompt_builder_from_text = self.prompt_builder_from_text
    prompt_digest = None
    if self.prompt_profile and (
        prompt_builder_from_tokens is None or prompt_builder_from_text is None
    ):
        template = PromptProfileRegistry.get_prompt(
            self.prompt_profile, self.process_id, self.prompt_version
        )
        prompt_digest = template.digest
        if prompt_builder_from_tokens is None:

            def _builder_tokens(
                lang: str, table: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from tokens via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="tokens",
                    lang_or_dialect_name=lang,
                    token_table=table,
                    text=table,
                    sentence=table,
                )

            prompt_builder_from_tokens = _builder_tokens
        if prompt_builder_from_text is None:

            def _builder_text(
                lang: str, sentence: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from text via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="text",
                    lang_or_dialect_name=lang,
                    sentence=sentence,
                    text=sentence,
                    token_table=sentence,
                )

            prompt_builder_from_text = _builder_text
    # Callable typing does not retain keyword names; pass positionally
    output_doc = self.algorithm(
        output_doc,
        prompt_builder_from_tokens=prompt_builder_from_tokens,
        prompt_builder_from_text=prompt_builder_from_text,
        prompt_profile=self.prompt_profile,
        prompt_digest=prompt_digest,
        provenance_process=f"{self.process_id}:{self.__class__.__name__}",
    )
    return output_doc

ParthianGenAIDependencyProcess

Bases: GenAIDependencyProcess

Language-specific dependency process using a generative GPT model.

glottolog_id class-attribute instance-attribute 

glottolog_id: Optional[str] = 'part1239'

description class-attribute instance-attribute 

description: str = (
    "Default dependency syntax parsing process using a generative GPT model for the Parthian language."
)

authorship_info class-attribute instance-attribute 

authorship_info: str = 'CLTK'

process_id class-attribute 

process_id: str = 'dependency.genai'

prompt_builder_from_tokens class-attribute instance-attribute 

prompt_builder_from_tokens: Optional[PromptBuilder] = None

prompt_builder_from_text class-attribute instance-attribute 

prompt_builder_from_text: Optional[PromptBuilder] = None

prompt_profile class-attribute instance-attribute 

prompt_profile: Optional[str] = None

prompt_version class-attribute instance-attribute 

prompt_version: Optional[str] = None

algorithm cached property 

algorithm: Callable[..., Doc]

Return the dependency generation function for this process.

run 

run(input_doc: Doc) -> Doc

Run the configured GPT dependency parsing workflow.

Source code in cltk/dependency/processes.py 
 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
def run(self, input_doc: Doc) -> Doc:
    """Run the configured GPT dependency parsing workflow."""
    output_doc = copy(input_doc)
    if not output_doc.normalized_text:
        msg: str = "Doc must have `normalized_text`."
        bind_from_doc(output_doc).error(msg)
        raise ValueError(msg)
    # Ensure required attributes are present
    if self.glottolog_id is None:
        raise ValueError("glottolog_id must be set for sentence splitting")
    prompt_builder_from_tokens = self.prompt_builder_from_tokens
    prompt_builder_from_text = self.prompt_builder_from_text
    prompt_digest = None
    if self.prompt_profile and (
        prompt_builder_from_tokens is None or prompt_builder_from_text is None
    ):
        template = PromptProfileRegistry.get_prompt(
            self.prompt_profile, self.process_id, self.prompt_version
        )
        prompt_digest = template.digest
        if prompt_builder_from_tokens is None:

            def _builder_tokens(
                lang: str, table: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from tokens via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="tokens",
                    lang_or_dialect_name=lang,
                    token_table=table,
                    text=table,
                    sentence=table,
                )

            prompt_builder_from_tokens = _builder_tokens
        if prompt_builder_from_text is None:

            def _builder_text(
                lang: str, sentence: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from text via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="text",
                    lang_or_dialect_name=lang,
                    sentence=sentence,
                    text=sentence,
                    token_table=sentence,
                )

            prompt_builder_from_text = _builder_text
    # Callable typing does not retain keyword names; pass positionally
    output_doc = self.algorithm(
        output_doc,
        prompt_builder_from_tokens=prompt_builder_from_tokens,
        prompt_builder_from_text=prompt_builder_from_text,
        prompt_profile=self.prompt_profile,
        prompt_digest=prompt_digest,
        provenance_process=f"{self.process_id}:{self.__class__.__name__}",
    )
    return output_doc

MiddlePersianGenAIDependencyProcess

Bases: GenAIDependencyProcess

Language-specific dependency process using a generative GPT model.

glottolog_id class-attribute instance-attribute 

glottolog_id: Optional[str] = 'pahl1241'

description class-attribute instance-attribute 

description: str = (
    "Default dependency syntax parsing process using a generative GPT model for the Middle Persian language."
)

authorship_info class-attribute instance-attribute 

authorship_info: str = 'CLTK'

process_id class-attribute 

process_id: str = 'dependency.genai'

prompt_builder_from_tokens class-attribute instance-attribute 

prompt_builder_from_tokens: Optional[PromptBuilder] = None

prompt_builder_from_text class-attribute instance-attribute 

prompt_builder_from_text: Optional[PromptBuilder] = None

prompt_profile class-attribute instance-attribute 

prompt_profile: Optional[str] = None

prompt_version class-attribute instance-attribute 

prompt_version: Optional[str] = None

algorithm cached property 

algorithm: Callable[..., Doc]

Return the dependency generation function for this process.

run 

run(input_doc: Doc) -> Doc

Run the configured GPT dependency parsing workflow.

Source code in cltk/dependency/processes.py 
 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
def run(self, input_doc: Doc) -> Doc:
    """Run the configured GPT dependency parsing workflow."""
    output_doc = copy(input_doc)
    if not output_doc.normalized_text:
        msg: str = "Doc must have `normalized_text`."
        bind_from_doc(output_doc).error(msg)
        raise ValueError(msg)
    # Ensure required attributes are present
    if self.glottolog_id is None:
        raise ValueError("glottolog_id must be set for sentence splitting")
    prompt_builder_from_tokens = self.prompt_builder_from_tokens
    prompt_builder_from_text = self.prompt_builder_from_text
    prompt_digest = None
    if self.prompt_profile and (
        prompt_builder_from_tokens is None or prompt_builder_from_text is None
    ):
        template = PromptProfileRegistry.get_prompt(
            self.prompt_profile, self.process_id, self.prompt_version
        )
        prompt_digest = template.digest
        if prompt_builder_from_tokens is None:

            def _builder_tokens(
                lang: str, table: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from tokens via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="tokens",
                    lang_or_dialect_name=lang,
                    token_table=table,
                    text=table,
                    sentence=table,
                )

            prompt_builder_from_tokens = _builder_tokens
        if prompt_builder_from_text is None:

            def _builder_text(
                lang: str, sentence: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from text via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="text",
                    lang_or_dialect_name=lang,
                    sentence=sentence,
                    text=sentence,
                    token_table=sentence,
                )

            prompt_builder_from_text = _builder_text
    # Callable typing does not retain keyword names; pass positionally
    output_doc = self.algorithm(
        output_doc,
        prompt_builder_from_tokens=prompt_builder_from_tokens,
        prompt_builder_from_text=prompt_builder_from_text,
        prompt_profile=self.prompt_profile,
        prompt_digest=prompt_digest,
        provenance_process=f"{self.process_id}:{self.__class__.__name__}",
    )
    return output_doc

PalaicGenAIDependencyProcess

Bases: GenAIDependencyProcess

Language-specific dependency process using a generative GPT model.

glottolog_id class-attribute instance-attribute 

glottolog_id: Optional[str] = 'pala1331'

description class-attribute instance-attribute 

description: str = (
    "Default dependency syntax parsing process using a generative GPT model for the Palaic language."
)

authorship_info class-attribute instance-attribute 

authorship_info: str = 'CLTK'

process_id class-attribute 

process_id: str = 'dependency.genai'

prompt_builder_from_tokens class-attribute instance-attribute 

prompt_builder_from_tokens: Optional[PromptBuilder] = None

prompt_builder_from_text class-attribute instance-attribute 

prompt_builder_from_text: Optional[PromptBuilder] = None

prompt_profile class-attribute instance-attribute 

prompt_profile: Optional[str] = None

prompt_version class-attribute instance-attribute 

prompt_version: Optional[str] = None

algorithm cached property 

algorithm: Callable[..., Doc]

Return the dependency generation function for this process.

run 

run(input_doc: Doc) -> Doc

Run the configured GPT dependency parsing workflow.

Source code in cltk/dependency/processes.py 
 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
def run(self, input_doc: Doc) -> Doc:
    """Run the configured GPT dependency parsing workflow."""
    output_doc = copy(input_doc)
    if not output_doc.normalized_text:
        msg: str = "Doc must have `normalized_text`."
        bind_from_doc(output_doc).error(msg)
        raise ValueError(msg)
    # Ensure required attributes are present
    if self.glottolog_id is None:
        raise ValueError("glottolog_id must be set for sentence splitting")
    prompt_builder_from_tokens = self.prompt_builder_from_tokens
    prompt_builder_from_text = self.prompt_builder_from_text
    prompt_digest = None
    if self.prompt_profile and (
        prompt_builder_from_tokens is None or prompt_builder_from_text is None
    ):
        template = PromptProfileRegistry.get_prompt(
            self.prompt_profile, self.process_id, self.prompt_version
        )
        prompt_digest = template.digest
        if prompt_builder_from_tokens is None:

            def _builder_tokens(
                lang: str, table: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from tokens via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="tokens",
                    lang_or_dialect_name=lang,
                    token_table=table,
                    text=table,
                    sentence=table,
                )

            prompt_builder_from_tokens = _builder_tokens
        if prompt_builder_from_text is None:

            def _builder_text(
                lang: str, sentence: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from text via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="text",
                    lang_or_dialect_name=lang,
                    sentence=sentence,
                    text=sentence,
                    token_table=sentence,
                )

            prompt_builder_from_text = _builder_text
    # Callable typing does not retain keyword names; pass positionally
    output_doc = self.algorithm(
        output_doc,
        prompt_builder_from_tokens=prompt_builder_from_tokens,
        prompt_builder_from_text=prompt_builder_from_text,
        prompt_profile=self.prompt_profile,
        prompt_digest=prompt_digest,
        provenance_process=f"{self.process_id}:{self.__class__.__name__}",
    )
    return output_doc

PaliGenAIDependencyProcess

Bases: GenAIDependencyProcess

Language-specific dependency process using a generative GPT model.

glottolog_id class-attribute instance-attribute 

glottolog_id: Optional[str] = 'pali1273'

description class-attribute instance-attribute 

description: str = (
    "Default dependency syntax parsing process using a generative GPT model for the Pali language."
)

authorship_info class-attribute instance-attribute 

authorship_info: str = 'CLTK'

process_id class-attribute 

process_id: str = 'dependency.genai'

prompt_builder_from_tokens class-attribute instance-attribute 

prompt_builder_from_tokens: Optional[PromptBuilder] = None

prompt_builder_from_text class-attribute instance-attribute 

prompt_builder_from_text: Optional[PromptBuilder] = None

prompt_profile class-attribute instance-attribute 

prompt_profile: Optional[str] = None

prompt_version class-attribute instance-attribute 

prompt_version: Optional[str] = None

algorithm cached property 

algorithm: Callable[..., Doc]

Return the dependency generation function for this process.

run 

run(input_doc: Doc) -> Doc

Run the configured GPT dependency parsing workflow.

Source code in cltk/dependency/processes.py 
 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
def run(self, input_doc: Doc) -> Doc:
    """Run the configured GPT dependency parsing workflow."""
    output_doc = copy(input_doc)
    if not output_doc.normalized_text:
        msg: str = "Doc must have `normalized_text`."
        bind_from_doc(output_doc).error(msg)
        raise ValueError(msg)
    # Ensure required attributes are present
    if self.glottolog_id is None:
        raise ValueError("glottolog_id must be set for sentence splitting")
    prompt_builder_from_tokens = self.prompt_builder_from_tokens
    prompt_builder_from_text = self.prompt_builder_from_text
    prompt_digest = None
    if self.prompt_profile and (
        prompt_builder_from_tokens is None or prompt_builder_from_text is None
    ):
        template = PromptProfileRegistry.get_prompt(
            self.prompt_profile, self.process_id, self.prompt_version
        )
        prompt_digest = template.digest
        if prompt_builder_from_tokens is None:

            def _builder_tokens(
                lang: str, table: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from tokens via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="tokens",
                    lang_or_dialect_name=lang,
                    token_table=table,
                    text=table,
                    sentence=table,
                )

            prompt_builder_from_tokens = _builder_tokens
        if prompt_builder_from_text is None:

            def _builder_text(
                lang: str, sentence: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from text via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="text",
                    lang_or_dialect_name=lang,
                    sentence=sentence,
                    text=sentence,
                    token_table=sentence,
                )

            prompt_builder_from_text = _builder_text
    # Callable typing does not retain keyword names; pass positionally
    output_doc = self.algorithm(
        output_doc,
        prompt_builder_from_tokens=prompt_builder_from_tokens,
        prompt_builder_from_text=prompt_builder_from_text,
        prompt_profile=self.prompt_profile,
        prompt_digest=prompt_digest,
        provenance_process=f"{self.process_id}:{self.__class__.__name__}",
    )
    return output_doc

PhoenicianGenAIDependencyProcess

Bases: GenAIDependencyProcess

Language-specific dependency process using a generative GPT model.

glottolog_id class-attribute instance-attribute 

glottolog_id: Optional[str] = 'phoe1239'

description class-attribute instance-attribute 

description: str = (
    "Default dependency syntax parsing process using a generative GPT model for the Phoenician language."
)

authorship_info class-attribute instance-attribute 

authorship_info: str = 'CLTK'

process_id class-attribute 

process_id: str = 'dependency.genai'

prompt_builder_from_tokens class-attribute instance-attribute 

prompt_builder_from_tokens: Optional[PromptBuilder] = None

prompt_builder_from_text class-attribute instance-attribute 

prompt_builder_from_text: Optional[PromptBuilder] = None

prompt_profile class-attribute instance-attribute 

prompt_profile: Optional[str] = None

prompt_version class-attribute instance-attribute 

prompt_version: Optional[str] = None

algorithm cached property 

algorithm: Callable[..., Doc]

Return the dependency generation function for this process.

run 

run(input_doc: Doc) -> Doc

Run the configured GPT dependency parsing workflow.

Source code in cltk/dependency/processes.py 
 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
def run(self, input_doc: Doc) -> Doc:
    """Run the configured GPT dependency parsing workflow."""
    output_doc = copy(input_doc)
    if not output_doc.normalized_text:
        msg: str = "Doc must have `normalized_text`."
        bind_from_doc(output_doc).error(msg)
        raise ValueError(msg)
    # Ensure required attributes are present
    if self.glottolog_id is None:
        raise ValueError("glottolog_id must be set for sentence splitting")
    prompt_builder_from_tokens = self.prompt_builder_from_tokens
    prompt_builder_from_text = self.prompt_builder_from_text
    prompt_digest = None
    if self.prompt_profile and (
        prompt_builder_from_tokens is None or prompt_builder_from_text is None
    ):
        template = PromptProfileRegistry.get_prompt(
            self.prompt_profile, self.process_id, self.prompt_version
        )
        prompt_digest = template.digest
        if prompt_builder_from_tokens is None:

            def _builder_tokens(
                lang: str, table: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from tokens via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="tokens",
                    lang_or_dialect_name=lang,
                    token_table=table,
                    text=table,
                    sentence=table,
                )

            prompt_builder_from_tokens = _builder_tokens
        if prompt_builder_from_text is None:

            def _builder_text(
                lang: str, sentence: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from text via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="text",
                    lang_or_dialect_name=lang,
                    sentence=sentence,
                    text=sentence,
                    token_table=sentence,
                )

            prompt_builder_from_text = _builder_text
    # Callable typing does not retain keyword names; pass positionally
    output_doc = self.algorithm(
        output_doc,
        prompt_builder_from_tokens=prompt_builder_from_tokens,
        prompt_builder_from_text=prompt_builder_from_text,
        prompt_profile=self.prompt_profile,
        prompt_digest=prompt_digest,
        provenance_process=f"{self.process_id}:{self.__class__.__name__}",
    )
    return output_doc

PunjabiGenAIDependencyProcess

Bases: GenAIDependencyProcess

Language-specific dependency process using a generative GPT model.

glottolog_id class-attribute instance-attribute 

glottolog_id: Optional[str] = 'panj1256'

description class-attribute instance-attribute 

description: str = (
    "Default dependency syntax parsing process using a generative GPT model for the Punjabi language."
)

authorship_info class-attribute instance-attribute 

authorship_info: str = 'CLTK'

process_id class-attribute 

process_id: str = 'dependency.genai'

prompt_builder_from_tokens class-attribute instance-attribute 

prompt_builder_from_tokens: Optional[PromptBuilder] = None

prompt_builder_from_text class-attribute instance-attribute 

prompt_builder_from_text: Optional[PromptBuilder] = None

prompt_profile class-attribute instance-attribute 

prompt_profile: Optional[str] = None

prompt_version class-attribute instance-attribute 

prompt_version: Optional[str] = None

algorithm cached property 

algorithm: Callable[..., Doc]

Return the dependency generation function for this process.

run 

run(input_doc: Doc) -> Doc

Run the configured GPT dependency parsing workflow.

Source code in cltk/dependency/processes.py 
 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
def run(self, input_doc: Doc) -> Doc:
    """Run the configured GPT dependency parsing workflow."""
    output_doc = copy(input_doc)
    if not output_doc.normalized_text:
        msg: str = "Doc must have `normalized_text`."
        bind_from_doc(output_doc).error(msg)
        raise ValueError(msg)
    # Ensure required attributes are present
    if self.glottolog_id is None:
        raise ValueError("glottolog_id must be set for sentence splitting")
    prompt_builder_from_tokens = self.prompt_builder_from_tokens
    prompt_builder_from_text = self.prompt_builder_from_text
    prompt_digest = None
    if self.prompt_profile and (
        prompt_builder_from_tokens is None or prompt_builder_from_text is None
    ):
        template = PromptProfileRegistry.get_prompt(
            self.prompt_profile, self.process_id, self.prompt_version
        )
        prompt_digest = template.digest
        if prompt_builder_from_tokens is None:

            def _builder_tokens(
                lang: str, table: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from tokens via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="tokens",
                    lang_or_dialect_name=lang,
                    token_table=table,
                    text=table,
                    sentence=table,
                )

            prompt_builder_from_tokens = _builder_tokens
        if prompt_builder_from_text is None:

            def _builder_text(
                lang: str, sentence: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from text via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="text",
                    lang_or_dialect_name=lang,
                    sentence=sentence,
                    text=sentence,
                    token_table=sentence,
                )

            prompt_builder_from_text = _builder_text
    # Callable typing does not retain keyword names; pass positionally
    output_doc = self.algorithm(
        output_doc,
        prompt_builder_from_tokens=prompt_builder_from_tokens,
        prompt_builder_from_text=prompt_builder_from_text,
        prompt_profile=self.prompt_profile,
        prompt_digest=prompt_digest,
        provenance_process=f"{self.process_id}:{self.__class__.__name__}",
    )
    return output_doc

AssameseGenAIDependencyProcess

Bases: GenAIDependencyProcess

Language-specific dependency process using a generative GPT model.

glottolog_id class-attribute instance-attribute 

glottolog_id: Optional[str] = 'assa1263'

description class-attribute instance-attribute 

description: str = (
    "Default dependency syntax parsing process using a generative GPT model for the Assamese language."
)

authorship_info class-attribute instance-attribute 

authorship_info: str = 'CLTK'

process_id class-attribute 

process_id: str = 'dependency.genai'

prompt_builder_from_tokens class-attribute instance-attribute 

prompt_builder_from_tokens: Optional[PromptBuilder] = None

prompt_builder_from_text class-attribute instance-attribute 

prompt_builder_from_text: Optional[PromptBuilder] = None

prompt_profile class-attribute instance-attribute 

prompt_profile: Optional[str] = None

prompt_version class-attribute instance-attribute 

prompt_version: Optional[str] = None

algorithm cached property 

algorithm: Callable[..., Doc]

Return the dependency generation function for this process.

run 

run(input_doc: Doc) -> Doc

Run the configured GPT dependency parsing workflow.

Source code in cltk/dependency/processes.py 
 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
def run(self, input_doc: Doc) -> Doc:
    """Run the configured GPT dependency parsing workflow."""
    output_doc = copy(input_doc)
    if not output_doc.normalized_text:
        msg: str = "Doc must have `normalized_text`."
        bind_from_doc(output_doc).error(msg)
        raise ValueError(msg)
    # Ensure required attributes are present
    if self.glottolog_id is None:
        raise ValueError("glottolog_id must be set for sentence splitting")
    prompt_builder_from_tokens = self.prompt_builder_from_tokens
    prompt_builder_from_text = self.prompt_builder_from_text
    prompt_digest = None
    if self.prompt_profile and (
        prompt_builder_from_tokens is None or prompt_builder_from_text is None
    ):
        template = PromptProfileRegistry.get_prompt(
            self.prompt_profile, self.process_id, self.prompt_version
        )
        prompt_digest = template.digest
        if prompt_builder_from_tokens is None:

            def _builder_tokens(
                lang: str, table: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from tokens via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="tokens",
                    lang_or_dialect_name=lang,
                    token_table=table,
                    text=table,
                    sentence=table,
                )

            prompt_builder_from_tokens = _builder_tokens
        if prompt_builder_from_text is None:

            def _builder_text(
                lang: str, sentence: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from text via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="text",
                    lang_or_dialect_name=lang,
                    sentence=sentence,
                    text=sentence,
                    token_table=sentence,
                )

            prompt_builder_from_text = _builder_text
    # Callable typing does not retain keyword names; pass positionally
    output_doc = self.algorithm(
        output_doc,
        prompt_builder_from_tokens=prompt_builder_from_tokens,
        prompt_builder_from_text=prompt_builder_from_text,
        prompt_profile=self.prompt_profile,
        prompt_digest=prompt_digest,
        provenance_process=f"{self.process_id}:{self.__class__.__name__}",
    )
    return output_doc

SinhalaGenAIDependencyProcess

Bases: GenAIDependencyProcess

Language-specific dependency process using a generative GPT model.

glottolog_id class-attribute instance-attribute 

glottolog_id: Optional[str] = 'sinh1246'

description class-attribute instance-attribute 

description: str = (
    "Default dependency syntax parsing process using a generative GPT model for the Sinhala language."
)

authorship_info class-attribute instance-attribute 

authorship_info: str = 'CLTK'

process_id class-attribute 

process_id: str = 'dependency.genai'

prompt_builder_from_tokens class-attribute instance-attribute 

prompt_builder_from_tokens: Optional[PromptBuilder] = None

prompt_builder_from_text class-attribute instance-attribute 

prompt_builder_from_text: Optional[PromptBuilder] = None

prompt_profile class-attribute instance-attribute 

prompt_profile: Optional[str] = None

prompt_version class-attribute instance-attribute 

prompt_version: Optional[str] = None

algorithm cached property 

algorithm: Callable[..., Doc]

Return the dependency generation function for this process.

run 

run(input_doc: Doc) -> Doc

Run the configured GPT dependency parsing workflow.

Source code in cltk/dependency/processes.py 
 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
def run(self, input_doc: Doc) -> Doc:
    """Run the configured GPT dependency parsing workflow."""
    output_doc = copy(input_doc)
    if not output_doc.normalized_text:
        msg: str = "Doc must have `normalized_text`."
        bind_from_doc(output_doc).error(msg)
        raise ValueError(msg)
    # Ensure required attributes are present
    if self.glottolog_id is None:
        raise ValueError("glottolog_id must be set for sentence splitting")
    prompt_builder_from_tokens = self.prompt_builder_from_tokens
    prompt_builder_from_text = self.prompt_builder_from_text
    prompt_digest = None
    if self.prompt_profile and (
        prompt_builder_from_tokens is None or prompt_builder_from_text is None
    ):
        template = PromptProfileRegistry.get_prompt(
            self.prompt_profile, self.process_id, self.prompt_version
        )
        prompt_digest = template.digest
        if prompt_builder_from_tokens is None:

            def _builder_tokens(
                lang: str, table: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from tokens via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="tokens",
                    lang_or_dialect_name=lang,
                    token_table=table,
                    text=table,
                    sentence=table,
                )

            prompt_builder_from_tokens = _builder_tokens
        if prompt_builder_from_text is None:

            def _builder_text(
                lang: str, sentence: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from text via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="text",
                    lang_or_dialect_name=lang,
                    sentence=sentence,
                    text=sentence,
                    token_table=sentence,
                )

            prompt_builder_from_text = _builder_text
    # Callable typing does not retain keyword names; pass positionally
    output_doc = self.algorithm(
        output_doc,
        prompt_builder_from_tokens=prompt_builder_from_tokens,
        prompt_builder_from_text=prompt_builder_from_text,
        prompt_profile=self.prompt_profile,
        prompt_digest=prompt_digest,
        provenance_process=f"{self.process_id}:{self.__class__.__name__}",
    )
    return output_doc

SindhiGenAIDependencyProcess

Bases: GenAIDependencyProcess

Language-specific dependency process using a generative GPT model.

glottolog_id class-attribute instance-attribute 

glottolog_id: Optional[str] = 'sind1272'

description class-attribute instance-attribute 

description: str = (
    "Default dependency syntax parsing process using a generative GPT model for the Sindhi language."
)

authorship_info class-attribute instance-attribute 

authorship_info: str = 'CLTK'

process_id class-attribute 

process_id: str = 'dependency.genai'

prompt_builder_from_tokens class-attribute instance-attribute 

prompt_builder_from_tokens: Optional[PromptBuilder] = None

prompt_builder_from_text class-attribute instance-attribute 

prompt_builder_from_text: Optional[PromptBuilder] = None

prompt_profile class-attribute instance-attribute 

prompt_profile: Optional[str] = None

prompt_version class-attribute instance-attribute 

prompt_version: Optional[str] = None

algorithm cached property 

algorithm: Callable[..., Doc]

Return the dependency generation function for this process.

run 

run(input_doc: Doc) -> Doc

Run the configured GPT dependency parsing workflow.

Source code in cltk/dependency/processes.py 
 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
def run(self, input_doc: Doc) -> Doc:
    """Run the configured GPT dependency parsing workflow."""
    output_doc = copy(input_doc)
    if not output_doc.normalized_text:
        msg: str = "Doc must have `normalized_text`."
        bind_from_doc(output_doc).error(msg)
        raise ValueError(msg)
    # Ensure required attributes are present
    if self.glottolog_id is None:
        raise ValueError("glottolog_id must be set for sentence splitting")
    prompt_builder_from_tokens = self.prompt_builder_from_tokens
    prompt_builder_from_text = self.prompt_builder_from_text
    prompt_digest = None
    if self.prompt_profile and (
        prompt_builder_from_tokens is None or prompt_builder_from_text is None
    ):
        template = PromptProfileRegistry.get_prompt(
            self.prompt_profile, self.process_id, self.prompt_version
        )
        prompt_digest = template.digest
        if prompt_builder_from_tokens is None:

            def _builder_tokens(
                lang: str, table: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from tokens via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="tokens",
                    lang_or_dialect_name=lang,
                    token_table=table,
                    text=table,
                    sentence=table,
                )

            prompt_builder_from_tokens = _builder_tokens
        if prompt_builder_from_text is None:

            def _builder_text(
                lang: str, sentence: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from text via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="text",
                    lang_or_dialect_name=lang,
                    sentence=sentence,
                    text=sentence,
                    token_table=sentence,
                )

            prompt_builder_from_text = _builder_text
    # Callable typing does not retain keyword names; pass positionally
    output_doc = self.algorithm(
        output_doc,
        prompt_builder_from_tokens=prompt_builder_from_tokens,
        prompt_builder_from_text=prompt_builder_from_text,
        prompt_profile=self.prompt_profile,
        prompt_digest=prompt_digest,
        provenance_process=f"{self.process_id}:{self.__class__.__name__}",
    )
    return output_doc

KashmiriGenAIDependencyProcess

Bases: GenAIDependencyProcess

Language-specific dependency process using a generative GPT model.

glottolog_id class-attribute instance-attribute 

glottolog_id: Optional[str] = 'kash1277'

description class-attribute instance-attribute 

description: str = (
    "Default dependency syntax parsing process using a generative GPT model for the Kashmiri language."
)

authorship_info class-attribute instance-attribute 

authorship_info: str = 'CLTK'

process_id class-attribute 

process_id: str = 'dependency.genai'

prompt_builder_from_tokens class-attribute instance-attribute 

prompt_builder_from_tokens: Optional[PromptBuilder] = None

prompt_builder_from_text class-attribute instance-attribute 

prompt_builder_from_text: Optional[PromptBuilder] = None

prompt_profile class-attribute instance-attribute 

prompt_profile: Optional[str] = None

prompt_version class-attribute instance-attribute 

prompt_version: Optional[str] = None

algorithm cached property 

algorithm: Callable[..., Doc]

Return the dependency generation function for this process.

run 

run(input_doc: Doc) -> Doc

Run the configured GPT dependency parsing workflow.

Source code in cltk/dependency/processes.py 
 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
def run(self, input_doc: Doc) -> Doc:
    """Run the configured GPT dependency parsing workflow."""
    output_doc = copy(input_doc)
    if not output_doc.normalized_text:
        msg: str = "Doc must have `normalized_text`."
        bind_from_doc(output_doc).error(msg)
        raise ValueError(msg)
    # Ensure required attributes are present
    if self.glottolog_id is None:
        raise ValueError("glottolog_id must be set for sentence splitting")
    prompt_builder_from_tokens = self.prompt_builder_from_tokens
    prompt_builder_from_text = self.prompt_builder_from_text
    prompt_digest = None
    if self.prompt_profile and (
        prompt_builder_from_tokens is None or prompt_builder_from_text is None
    ):
        template = PromptProfileRegistry.get_prompt(
            self.prompt_profile, self.process_id, self.prompt_version
        )
        prompt_digest = template.digest
        if prompt_builder_from_tokens is None:

            def _builder_tokens(
                lang: str, table: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from tokens via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="tokens",
                    lang_or_dialect_name=lang,
                    token_table=table,
                    text=table,
                    sentence=table,
                )

            prompt_builder_from_tokens = _builder_tokens
        if prompt_builder_from_text is None:

            def _builder_text(
                lang: str, sentence: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from text via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="text",
                    lang_or_dialect_name=lang,
                    sentence=sentence,
                    text=sentence,
                    token_table=sentence,
                )

            prompt_builder_from_text = _builder_text
    # Callable typing does not retain keyword names; pass positionally
    output_doc = self.algorithm(
        output_doc,
        prompt_builder_from_tokens=prompt_builder_from_tokens,
        prompt_builder_from_text=prompt_builder_from_text,
        prompt_profile=self.prompt_profile,
        prompt_digest=prompt_digest,
        provenance_process=f"{self.process_id}:{self.__class__.__name__}",
    )
    return output_doc

BagriGenAIDependencyProcess

Bases: GenAIDependencyProcess

Language-specific dependency process using a generative GPT model.

glottolog_id class-attribute instance-attribute 

glottolog_id: Optional[str] = 'bagr1243'

description class-attribute instance-attribute 

description: str = (
    "Default dependency syntax parsing process using a generative GPT model for the Bagri (Rajasthani) language."
)

authorship_info class-attribute instance-attribute 

authorship_info: str = 'CLTK'

process_id class-attribute 

process_id: str = 'dependency.genai'

prompt_builder_from_tokens class-attribute instance-attribute 

prompt_builder_from_tokens: Optional[PromptBuilder] = None

prompt_builder_from_text class-attribute instance-attribute 

prompt_builder_from_text: Optional[PromptBuilder] = None

prompt_profile class-attribute instance-attribute 

prompt_profile: Optional[str] = None

prompt_version class-attribute instance-attribute 

prompt_version: Optional[str] = None

algorithm cached property 

algorithm: Callable[..., Doc]

Return the dependency generation function for this process.

run 

run(input_doc: Doc) -> Doc

Run the configured GPT dependency parsing workflow.

Source code in cltk/dependency/processes.py 
 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
def run(self, input_doc: Doc) -> Doc:
    """Run the configured GPT dependency parsing workflow."""
    output_doc = copy(input_doc)
    if not output_doc.normalized_text:
        msg: str = "Doc must have `normalized_text`."
        bind_from_doc(output_doc).error(msg)
        raise ValueError(msg)
    # Ensure required attributes are present
    if self.glottolog_id is None:
        raise ValueError("glottolog_id must be set for sentence splitting")
    prompt_builder_from_tokens = self.prompt_builder_from_tokens
    prompt_builder_from_text = self.prompt_builder_from_text
    prompt_digest = None
    if self.prompt_profile and (
        prompt_builder_from_tokens is None or prompt_builder_from_text is None
    ):
        template = PromptProfileRegistry.get_prompt(
            self.prompt_profile, self.process_id, self.prompt_version
        )
        prompt_digest = template.digest
        if prompt_builder_from_tokens is None:

            def _builder_tokens(
                lang: str, table: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from tokens via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="tokens",
                    lang_or_dialect_name=lang,
                    token_table=table,
                    text=table,
                    sentence=table,
                )

            prompt_builder_from_tokens = _builder_tokens
        if prompt_builder_from_text is None:

            def _builder_text(
                lang: str, sentence: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from text via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="text",
                    lang_or_dialect_name=lang,
                    sentence=sentence,
                    text=sentence,
                    token_table=sentence,
                )

            prompt_builder_from_text = _builder_text
    # Callable typing does not retain keyword names; pass positionally
    output_doc = self.algorithm(
        output_doc,
        prompt_builder_from_tokens=prompt_builder_from_tokens,
        prompt_builder_from_text=prompt_builder_from_text,
        prompt_profile=self.prompt_profile,
        prompt_digest=prompt_digest,
        provenance_process=f"{self.process_id}:{self.__class__.__name__}",
    )
    return output_doc

ClassicalSanskritGenAIDependencyProcess

Bases: GenAIDependencyProcess

Language-specific dependency process using a generative GPT model.

glottolog_id class-attribute instance-attribute 

glottolog_id: Optional[str] = 'clas1258'

description class-attribute instance-attribute 

description: str = (
    "Default dependency syntax parsing process using a generative GPT model for the Classical Sanskrit language."
)

authorship_info class-attribute instance-attribute 

authorship_info: str = 'CLTK'

process_id class-attribute 

process_id: str = 'dependency.genai'

prompt_builder_from_tokens class-attribute instance-attribute 

prompt_builder_from_tokens: Optional[PromptBuilder] = None

prompt_builder_from_text class-attribute instance-attribute 

prompt_builder_from_text: Optional[PromptBuilder] = None

prompt_profile class-attribute instance-attribute 

prompt_profile: Optional[str] = None

prompt_version class-attribute instance-attribute 

prompt_version: Optional[str] = None

algorithm cached property 

algorithm: Callable[..., Doc]

Return the dependency generation function for this process.

run 

run(input_doc: Doc) -> Doc

Run the configured GPT dependency parsing workflow.

Source code in cltk/dependency/processes.py 
 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
def run(self, input_doc: Doc) -> Doc:
    """Run the configured GPT dependency parsing workflow."""
    output_doc = copy(input_doc)
    if not output_doc.normalized_text:
        msg: str = "Doc must have `normalized_text`."
        bind_from_doc(output_doc).error(msg)
        raise ValueError(msg)
    # Ensure required attributes are present
    if self.glottolog_id is None:
        raise ValueError("glottolog_id must be set for sentence splitting")
    prompt_builder_from_tokens = self.prompt_builder_from_tokens
    prompt_builder_from_text = self.prompt_builder_from_text
    prompt_digest = None
    if self.prompt_profile and (
        prompt_builder_from_tokens is None or prompt_builder_from_text is None
    ):
        template = PromptProfileRegistry.get_prompt(
            self.prompt_profile, self.process_id, self.prompt_version
        )
        prompt_digest = template.digest
        if prompt_builder_from_tokens is None:

            def _builder_tokens(
                lang: str, table: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from tokens via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="tokens",
                    lang_or_dialect_name=lang,
                    token_table=table,
                    text=table,
                    sentence=table,
                )

            prompt_builder_from_tokens = _builder_tokens
        if prompt_builder_from_text is None:

            def _builder_text(
                lang: str, sentence: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from text via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="text",
                    lang_or_dialect_name=lang,
                    sentence=sentence,
                    text=sentence,
                    token_table=sentence,
                )

            prompt_builder_from_text = _builder_text
    # Callable typing does not retain keyword names; pass positionally
    output_doc = self.algorithm(
        output_doc,
        prompt_builder_from_tokens=prompt_builder_from_tokens,
        prompt_builder_from_text=prompt_builder_from_text,
        prompt_profile=self.prompt_profile,
        prompt_digest=prompt_digest,
        provenance_process=f"{self.process_id}:{self.__class__.__name__}",
    )
    return output_doc

VedicSanskritGenAIDependencyProcess

Bases: GenAIDependencyProcess

Language-specific dependency process using a generative GPT model.

glottolog_id class-attribute instance-attribute 

glottolog_id: Optional[str] = 'vedi1234'

description class-attribute instance-attribute 

description: str = (
    "Default dependency syntax parsing process using a generative GPT model for the Vedic Sanskrit language."
)

authorship_info class-attribute instance-attribute 

authorship_info: str = 'CLTK'

process_id class-attribute 

process_id: str = 'dependency.genai'

prompt_builder_from_tokens class-attribute instance-attribute 

prompt_builder_from_tokens: Optional[PromptBuilder] = None

prompt_builder_from_text class-attribute instance-attribute 

prompt_builder_from_text: Optional[PromptBuilder] = None

prompt_profile class-attribute instance-attribute 

prompt_profile: Optional[str] = None

prompt_version class-attribute instance-attribute 

prompt_version: Optional[str] = None

algorithm cached property 

algorithm: Callable[..., Doc]

Return the dependency generation function for this process.

run 

run(input_doc: Doc) -> Doc

Run the configured GPT dependency parsing workflow.

Source code in cltk/dependency/processes.py 
 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
def run(self, input_doc: Doc) -> Doc:
    """Run the configured GPT dependency parsing workflow."""
    output_doc = copy(input_doc)
    if not output_doc.normalized_text:
        msg: str = "Doc must have `normalized_text`."
        bind_from_doc(output_doc).error(msg)
        raise ValueError(msg)
    # Ensure required attributes are present
    if self.glottolog_id is None:
        raise ValueError("glottolog_id must be set for sentence splitting")
    prompt_builder_from_tokens = self.prompt_builder_from_tokens
    prompt_builder_from_text = self.prompt_builder_from_text
    prompt_digest = None
    if self.prompt_profile and (
        prompt_builder_from_tokens is None or prompt_builder_from_text is None
    ):
        template = PromptProfileRegistry.get_prompt(
            self.prompt_profile, self.process_id, self.prompt_version
        )
        prompt_digest = template.digest
        if prompt_builder_from_tokens is None:

            def _builder_tokens(
                lang: str, table: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from tokens via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="tokens",
                    lang_or_dialect_name=lang,
                    token_table=table,
                    text=table,
                    sentence=table,
                )

            prompt_builder_from_tokens = _builder_tokens
        if prompt_builder_from_text is None:

            def _builder_text(
                lang: str, sentence: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from text via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="text",
                    lang_or_dialect_name=lang,
                    sentence=sentence,
                    text=sentence,
                    token_table=sentence,
                )

            prompt_builder_from_text = _builder_text
    # Callable typing does not retain keyword names; pass positionally
    output_doc = self.algorithm(
        output_doc,
        prompt_builder_from_tokens=prompt_builder_from_tokens,
        prompt_builder_from_text=prompt_builder_from_text,
        prompt_profile=self.prompt_profile,
        prompt_digest=prompt_digest,
        provenance_process=f"{self.process_id}:{self.__class__.__name__}",
    )
    return output_doc

TokharianAGenAIDependencyProcess

Bases: GenAIDependencyProcess

Language-specific dependency process using a generative GPT model.

glottolog_id class-attribute instance-attribute 

glottolog_id: Optional[str] = 'toch1238'

description class-attribute instance-attribute 

description: str = (
    "Default dependency syntax parsing process using a generative GPT model for the Tokharian A language."
)

authorship_info class-attribute instance-attribute 

authorship_info: str = 'CLTK'

process_id class-attribute 

process_id: str = 'dependency.genai'

prompt_builder_from_tokens class-attribute instance-attribute 

prompt_builder_from_tokens: Optional[PromptBuilder] = None

prompt_builder_from_text class-attribute instance-attribute 

prompt_builder_from_text: Optional[PromptBuilder] = None

prompt_profile class-attribute instance-attribute 

prompt_profile: Optional[str] = None

prompt_version class-attribute instance-attribute 

prompt_version: Optional[str] = None

algorithm cached property 

algorithm: Callable[..., Doc]

Return the dependency generation function for this process.

run 

run(input_doc: Doc) -> Doc

Run the configured GPT dependency parsing workflow.

Source code in cltk/dependency/processes.py 
 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
def run(self, input_doc: Doc) -> Doc:
    """Run the configured GPT dependency parsing workflow."""
    output_doc = copy(input_doc)
    if not output_doc.normalized_text:
        msg: str = "Doc must have `normalized_text`."
        bind_from_doc(output_doc).error(msg)
        raise ValueError(msg)
    # Ensure required attributes are present
    if self.glottolog_id is None:
        raise ValueError("glottolog_id must be set for sentence splitting")
    prompt_builder_from_tokens = self.prompt_builder_from_tokens
    prompt_builder_from_text = self.prompt_builder_from_text
    prompt_digest = None
    if self.prompt_profile and (
        prompt_builder_from_tokens is None or prompt_builder_from_text is None
    ):
        template = PromptProfileRegistry.get_prompt(
            self.prompt_profile, self.process_id, self.prompt_version
        )
        prompt_digest = template.digest
        if prompt_builder_from_tokens is None:

            def _builder_tokens(
                lang: str, table: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from tokens via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="tokens",
                    lang_or_dialect_name=lang,
                    token_table=table,
                    text=table,
                    sentence=table,
                )

            prompt_builder_from_tokens = _builder_tokens
        if prompt_builder_from_text is None:

            def _builder_text(
                lang: str, sentence: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from text via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="text",
                    lang_or_dialect_name=lang,
                    sentence=sentence,
                    text=sentence,
                    token_table=sentence,
                )

            prompt_builder_from_text = _builder_text
    # Callable typing does not retain keyword names; pass positionally
    output_doc = self.algorithm(
        output_doc,
        prompt_builder_from_tokens=prompt_builder_from_tokens,
        prompt_builder_from_text=prompt_builder_from_text,
        prompt_profile=self.prompt_profile,
        prompt_digest=prompt_digest,
        provenance_process=f"{self.process_id}:{self.__class__.__name__}",
    )
    return output_doc

TokharianBGenAIDependencyProcess

Bases: GenAIDependencyProcess

Language-specific dependency process using a generative GPT model.

glottolog_id class-attribute instance-attribute 

glottolog_id: Optional[str] = 'toch1237'

description class-attribute instance-attribute 

description: str = (
    "Default dependency syntax parsing process using a generative GPT model for the Tokharian B language."
)

authorship_info class-attribute instance-attribute 

authorship_info: str = 'CLTK'

process_id class-attribute 

process_id: str = 'dependency.genai'

prompt_builder_from_tokens class-attribute instance-attribute 

prompt_builder_from_tokens: Optional[PromptBuilder] = None

prompt_builder_from_text class-attribute instance-attribute 

prompt_builder_from_text: Optional[PromptBuilder] = None

prompt_profile class-attribute instance-attribute 

prompt_profile: Optional[str] = None

prompt_version class-attribute instance-attribute 

prompt_version: Optional[str] = None

algorithm cached property 

algorithm: Callable[..., Doc]

Return the dependency generation function for this process.

run 

run(input_doc: Doc) -> Doc

Run the configured GPT dependency parsing workflow.

Source code in cltk/dependency/processes.py 
 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
def run(self, input_doc: Doc) -> Doc:
    """Run the configured GPT dependency parsing workflow."""
    output_doc = copy(input_doc)
    if not output_doc.normalized_text:
        msg: str = "Doc must have `normalized_text`."
        bind_from_doc(output_doc).error(msg)
        raise ValueError(msg)
    # Ensure required attributes are present
    if self.glottolog_id is None:
        raise ValueError("glottolog_id must be set for sentence splitting")
    prompt_builder_from_tokens = self.prompt_builder_from_tokens
    prompt_builder_from_text = self.prompt_builder_from_text
    prompt_digest = None
    if self.prompt_profile and (
        prompt_builder_from_tokens is None or prompt_builder_from_text is None
    ):
        template = PromptProfileRegistry.get_prompt(
            self.prompt_profile, self.process_id, self.prompt_version
        )
        prompt_digest = template.digest
        if prompt_builder_from_tokens is None:

            def _builder_tokens(
                lang: str, table: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from tokens via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="tokens",
                    lang_or_dialect_name=lang,
                    token_table=table,
                    text=table,
                    sentence=table,
                )

            prompt_builder_from_tokens = _builder_tokens
        if prompt_builder_from_text is None:

            def _builder_text(
                lang: str, sentence: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from text via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="text",
                    lang_or_dialect_name=lang,
                    sentence=sentence,
                    text=sentence,
                    token_table=sentence,
                )

            prompt_builder_from_text = _builder_text
    # Callable typing does not retain keyword names; pass positionally
    output_doc = self.algorithm(
        output_doc,
        prompt_builder_from_tokens=prompt_builder_from_tokens,
        prompt_builder_from_text=prompt_builder_from_text,
        prompt_profile=self.prompt_profile,
        prompt_digest=prompt_digest,
        provenance_process=f"{self.process_id}:{self.__class__.__name__}",
    )
    return output_doc

UgariticGenAIDependencyProcess

Bases: GenAIDependencyProcess

Language-specific dependency process using a generative GPT model.

glottolog_id class-attribute instance-attribute 

glottolog_id: Optional[str] = 'ugar1238'

description class-attribute instance-attribute 

description: str = (
    "Default dependency syntax parsing process using a generative GPT model for the Ugaritic language."
)

authorship_info class-attribute instance-attribute 

authorship_info: str = 'CLTK'

process_id class-attribute 

process_id: str = 'dependency.genai'

prompt_builder_from_tokens class-attribute instance-attribute 

prompt_builder_from_tokens: Optional[PromptBuilder] = None

prompt_builder_from_text class-attribute instance-attribute 

prompt_builder_from_text: Optional[PromptBuilder] = None

prompt_profile class-attribute instance-attribute 

prompt_profile: Optional[str] = None

prompt_version class-attribute instance-attribute 

prompt_version: Optional[str] = None

algorithm cached property 

algorithm: Callable[..., Doc]

Return the dependency generation function for this process.

run 

run(input_doc: Doc) -> Doc

Run the configured GPT dependency parsing workflow.

Source code in cltk/dependency/processes.py 
 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
def run(self, input_doc: Doc) -> Doc:
    """Run the configured GPT dependency parsing workflow."""
    output_doc = copy(input_doc)
    if not output_doc.normalized_text:
        msg: str = "Doc must have `normalized_text`."
        bind_from_doc(output_doc).error(msg)
        raise ValueError(msg)
    # Ensure required attributes are present
    if self.glottolog_id is None:
        raise ValueError("glottolog_id must be set for sentence splitting")
    prompt_builder_from_tokens = self.prompt_builder_from_tokens
    prompt_builder_from_text = self.prompt_builder_from_text
    prompt_digest = None
    if self.prompt_profile and (
        prompt_builder_from_tokens is None or prompt_builder_from_text is None
    ):
        template = PromptProfileRegistry.get_prompt(
            self.prompt_profile, self.process_id, self.prompt_version
        )
        prompt_digest = template.digest
        if prompt_builder_from_tokens is None:

            def _builder_tokens(
                lang: str, table: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from tokens via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="tokens",
                    lang_or_dialect_name=lang,
                    token_table=table,
                    text=table,
                    sentence=table,
                )

            prompt_builder_from_tokens = _builder_tokens
        if prompt_builder_from_text is None:

            def _builder_text(
                lang: str, sentence: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from text via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="text",
                    lang_or_dialect_name=lang,
                    sentence=sentence,
                    text=sentence,
                    token_table=sentence,
                )

            prompt_builder_from_text = _builder_text
    # Callable typing does not retain keyword names; pass positionally
    output_doc = self.algorithm(
        output_doc,
        prompt_builder_from_tokens=prompt_builder_from_tokens,
        prompt_builder_from_text=prompt_builder_from_text,
        prompt_profile=self.prompt_profile,
        prompt_digest=prompt_digest,
        provenance_process=f"{self.process_id}:{self.__class__.__name__}",
    )
    return output_doc

UrduGenAIDependencyProcess

Bases: GenAIDependencyProcess

Language-specific dependency process using a generative GPT model.

glottolog_id class-attribute instance-attribute 

glottolog_id: Optional[str] = 'urdu1245'

description class-attribute instance-attribute 

description: str = (
    "Default dependency syntax parsing process using a generative GPT model for the Urdu language."
)

authorship_info class-attribute instance-attribute 

authorship_info: str = 'CLTK'

process_id class-attribute 

process_id: str = 'dependency.genai'

prompt_builder_from_tokens class-attribute instance-attribute 

prompt_builder_from_tokens: Optional[PromptBuilder] = None

prompt_builder_from_text class-attribute instance-attribute 

prompt_builder_from_text: Optional[PromptBuilder] = None

prompt_profile class-attribute instance-attribute 

prompt_profile: Optional[str] = None

prompt_version class-attribute instance-attribute 

prompt_version: Optional[str] = None

algorithm cached property 

algorithm: Callable[..., Doc]

Return the dependency generation function for this process.

run 

run(input_doc: Doc) -> Doc

Run the configured GPT dependency parsing workflow.

Source code in cltk/dependency/processes.py 
 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
def run(self, input_doc: Doc) -> Doc:
    """Run the configured GPT dependency parsing workflow."""
    output_doc = copy(input_doc)
    if not output_doc.normalized_text:
        msg: str = "Doc must have `normalized_text`."
        bind_from_doc(output_doc).error(msg)
        raise ValueError(msg)
    # Ensure required attributes are present
    if self.glottolog_id is None:
        raise ValueError("glottolog_id must be set for sentence splitting")
    prompt_builder_from_tokens = self.prompt_builder_from_tokens
    prompt_builder_from_text = self.prompt_builder_from_text
    prompt_digest = None
    if self.prompt_profile and (
        prompt_builder_from_tokens is None or prompt_builder_from_text is None
    ):
        template = PromptProfileRegistry.get_prompt(
            self.prompt_profile, self.process_id, self.prompt_version
        )
        prompt_digest = template.digest
        if prompt_builder_from_tokens is None:

            def _builder_tokens(
                lang: str, table: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from tokens via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="tokens",
                    lang_or_dialect_name=lang,
                    token_table=table,
                    text=table,
                    sentence=table,
                )

            prompt_builder_from_tokens = _builder_tokens
        if prompt_builder_from_text is None:

            def _builder_text(
                lang: str, sentence: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from text via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="text",
                    lang_or_dialect_name=lang,
                    sentence=sentence,
                    text=sentence,
                    token_table=sentence,
                )

            prompt_builder_from_text = _builder_text
    # Callable typing does not retain keyword names; pass positionally
    output_doc = self.algorithm(
        output_doc,
        prompt_builder_from_tokens=prompt_builder_from_tokens,
        prompt_builder_from_text=prompt_builder_from_text,
        prompt_profile=self.prompt_profile,
        prompt_digest=prompt_digest,
        provenance_process=f"{self.process_id}:{self.__class__.__name__}",
    )
    return output_doc

SauraseniPrakritGenAIDependencyProcess

Bases: GenAIDependencyProcess

Language-specific dependency process using a generative GPT model.

glottolog_id class-attribute instance-attribute 

glottolog_id: Optional[str] = 'saur1252'

description class-attribute instance-attribute 

description: str = (
    "Default dependency syntax parsing process using a generative GPT model for the Sauraseni Prakrit language."
)

authorship_info class-attribute instance-attribute 

authorship_info: str = 'CLTK'

process_id class-attribute 

process_id: str = 'dependency.genai'

prompt_builder_from_tokens class-attribute instance-attribute 

prompt_builder_from_tokens: Optional[PromptBuilder] = None

prompt_builder_from_text class-attribute instance-attribute 

prompt_builder_from_text: Optional[PromptBuilder] = None

prompt_profile class-attribute instance-attribute 

prompt_profile: Optional[str] = None

prompt_version class-attribute instance-attribute 

prompt_version: Optional[str] = None

algorithm cached property 

algorithm: Callable[..., Doc]

Return the dependency generation function for this process.

run 

run(input_doc: Doc) -> Doc

Run the configured GPT dependency parsing workflow.

Source code in cltk/dependency/processes.py 
 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
def run(self, input_doc: Doc) -> Doc:
    """Run the configured GPT dependency parsing workflow."""
    output_doc = copy(input_doc)
    if not output_doc.normalized_text:
        msg: str = "Doc must have `normalized_text`."
        bind_from_doc(output_doc).error(msg)
        raise ValueError(msg)
    # Ensure required attributes are present
    if self.glottolog_id is None:
        raise ValueError("glottolog_id must be set for sentence splitting")
    prompt_builder_from_tokens = self.prompt_builder_from_tokens
    prompt_builder_from_text = self.prompt_builder_from_text
    prompt_digest = None
    if self.prompt_profile and (
        prompt_builder_from_tokens is None or prompt_builder_from_text is None
    ):
        template = PromptProfileRegistry.get_prompt(
            self.prompt_profile, self.process_id, self.prompt_version
        )
        prompt_digest = template.digest
        if prompt_builder_from_tokens is None:

            def _builder_tokens(
                lang: str, table: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from tokens via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="tokens",
                    lang_or_dialect_name=lang,
                    token_table=table,
                    text=table,
                    sentence=table,
                )

            prompt_builder_from_tokens = _builder_tokens
        if prompt_builder_from_text is None:

            def _builder_text(
                lang: str, sentence: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from text via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="text",
                    lang_or_dialect_name=lang,
                    sentence=sentence,
                    text=sentence,
                    token_table=sentence,
                )

            prompt_builder_from_text = _builder_text
    # Callable typing does not retain keyword names; pass positionally
    output_doc = self.algorithm(
        output_doc,
        prompt_builder_from_tokens=prompt_builder_from_tokens,
        prompt_builder_from_text=prompt_builder_from_text,
        prompt_profile=self.prompt_profile,
        prompt_digest=prompt_digest,
        provenance_process=f"{self.process_id}:{self.__class__.__name__}",
    )
    return output_doc

MagadhiPrakritGenAIDependencyProcess

Bases: GenAIDependencyProcess

Language-specific dependency process using a generative GPT model.

glottolog_id class-attribute instance-attribute 

glottolog_id: Optional[str] = 'maga1260'

description class-attribute instance-attribute 

description: str = (
    "Default dependency syntax parsing process using a generative GPT model for the Magadhi Prakrit language."
)

authorship_info class-attribute instance-attribute 

authorship_info: str = 'CLTK'

process_id class-attribute 

process_id: str = 'dependency.genai'

prompt_builder_from_tokens class-attribute instance-attribute 

prompt_builder_from_tokens: Optional[PromptBuilder] = None

prompt_builder_from_text class-attribute instance-attribute 

prompt_builder_from_text: Optional[PromptBuilder] = None

prompt_profile class-attribute instance-attribute 

prompt_profile: Optional[str] = None

prompt_version class-attribute instance-attribute 

prompt_version: Optional[str] = None

algorithm cached property 

algorithm: Callable[..., Doc]

Return the dependency generation function for this process.

run 

run(input_doc: Doc) -> Doc

Run the configured GPT dependency parsing workflow.

Source code in cltk/dependency/processes.py 
 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
def run(self, input_doc: Doc) -> Doc:
    """Run the configured GPT dependency parsing workflow."""
    output_doc = copy(input_doc)
    if not output_doc.normalized_text:
        msg: str = "Doc must have `normalized_text`."
        bind_from_doc(output_doc).error(msg)
        raise ValueError(msg)
    # Ensure required attributes are present
    if self.glottolog_id is None:
        raise ValueError("glottolog_id must be set for sentence splitting")
    prompt_builder_from_tokens = self.prompt_builder_from_tokens
    prompt_builder_from_text = self.prompt_builder_from_text
    prompt_digest = None
    if self.prompt_profile and (
        prompt_builder_from_tokens is None or prompt_builder_from_text is None
    ):
        template = PromptProfileRegistry.get_prompt(
            self.prompt_profile, self.process_id, self.prompt_version
        )
        prompt_digest = template.digest
        if prompt_builder_from_tokens is None:

            def _builder_tokens(
                lang: str, table: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from tokens via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="tokens",
                    lang_or_dialect_name=lang,
                    token_table=table,
                    text=table,
                    sentence=table,
                )

            prompt_builder_from_tokens = _builder_tokens
        if prompt_builder_from_text is None:

            def _builder_text(
                lang: str, sentence: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from text via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="text",
                    lang_or_dialect_name=lang,
                    sentence=sentence,
                    text=sentence,
                    token_table=sentence,
                )

            prompt_builder_from_text = _builder_text
    # Callable typing does not retain keyword names; pass positionally
    output_doc = self.algorithm(
        output_doc,
        prompt_builder_from_tokens=prompt_builder_from_tokens,
        prompt_builder_from_text=prompt_builder_from_text,
        prompt_profile=self.prompt_profile,
        prompt_digest=prompt_digest,
        provenance_process=f"{self.process_id}:{self.__class__.__name__}",
    )
    return output_doc

GandhariGenAIDependencyProcess

Bases: GenAIDependencyProcess

Language-specific dependency process using a generative GPT model.

glottolog_id class-attribute instance-attribute 

glottolog_id: Optional[str] = 'gand1259'

description class-attribute instance-attribute 

description: str = (
    "Default dependency syntax parsing process using a generative GPT model for the Gandhari language."
)

authorship_info class-attribute instance-attribute 

authorship_info: str = 'CLTK'

process_id class-attribute 

process_id: str = 'dependency.genai'

prompt_builder_from_tokens class-attribute instance-attribute 

prompt_builder_from_tokens: Optional[PromptBuilder] = None

prompt_builder_from_text class-attribute instance-attribute 

prompt_builder_from_text: Optional[PromptBuilder] = None

prompt_profile class-attribute instance-attribute 

prompt_profile: Optional[str] = None

prompt_version class-attribute instance-attribute 

prompt_version: Optional[str] = None

algorithm cached property 

algorithm: Callable[..., Doc]

Return the dependency generation function for this process.

run 

run(input_doc: Doc) -> Doc

Run the configured GPT dependency parsing workflow.

Source code in cltk/dependency/processes.py 
 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
def run(self, input_doc: Doc) -> Doc:
    """Run the configured GPT dependency parsing workflow."""
    output_doc = copy(input_doc)
    if not output_doc.normalized_text:
        msg: str = "Doc must have `normalized_text`."
        bind_from_doc(output_doc).error(msg)
        raise ValueError(msg)
    # Ensure required attributes are present
    if self.glottolog_id is None:
        raise ValueError("glottolog_id must be set for sentence splitting")
    prompt_builder_from_tokens = self.prompt_builder_from_tokens
    prompt_builder_from_text = self.prompt_builder_from_text
    prompt_digest = None
    if self.prompt_profile and (
        prompt_builder_from_tokens is None or prompt_builder_from_text is None
    ):
        template = PromptProfileRegistry.get_prompt(
            self.prompt_profile, self.process_id, self.prompt_version
        )
        prompt_digest = template.digest
        if prompt_builder_from_tokens is None:

            def _builder_tokens(
                lang: str, table: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from tokens via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="tokens",
                    lang_or_dialect_name=lang,
                    token_table=table,
                    text=table,
                    sentence=table,
                )

            prompt_builder_from_tokens = _builder_tokens
        if prompt_builder_from_text is None:

            def _builder_text(
                lang: str, sentence: str, _template: PromptTemplate = template
            ) -> PromptInfo:
                """Build a dependency prompt from text via a profile template."""
                return build_prompt_info(
                    _template,
                    variant="text",
                    lang_or_dialect_name=lang,
                    sentence=sentence,
                    text=sentence,
                    token_table=sentence,
                )

            prompt_builder_from_text = _builder_text
    # Callable typing does not retain keyword names; pass positionally
    output_doc = self.algorithm(
        output_doc,
        prompt_builder_from_tokens=prompt_builder_from_tokens,
        prompt_builder_from_text=prompt_builder_from_text,
        prompt_profile=self.prompt_profile,
        prompt_digest=prompt_digest,
        provenance_process=f"{self.process_id}:{self.__class__.__name__}",
    )
    return output_doc