gllm-misc-binary 0.9.6__cp313-cp313-win_amd64.whl

gllm_misc/cache_manager/__init__.pyi

@@ -0,0 +1,3 @@
+from gllm_misc.cache_manager.cache_manager import CacheManager as CacheManager, CacheOperationType as CacheOperationType
+
+__all__ = ['CacheManager', 'CacheOperationType']

gllm_misc/cache_manager/cache_manager.pyi

@@ -0,0 +1,59 @@
+from _typeshed import Incomplete
+from enum import StrEnum
+from gllm_core.schema import Component
+from gllm_datastore.cache.hybrid_cache.hybrid_cache import BaseHybridCache
+from typing import Any
+
+class CacheOperationType(StrEnum):
+    """The type of operation for the cache manager.
+
+    Attribute:
+        RETRIEVE (str): The operation type for retrieving the cache.
+        STORE (str): The operation type for storing the cache.
+    """
+    RETRIEVE: str
+    STORE: str
+
+class CacheManager(Component):
+    """A class for managing cache in Gen AI applications.
+
+    This class provides functionality for storing and retrieving cache.
+
+    Attributes:
+        data_store (BaseHybridCache): The cache store to use for storing and retrieving the cache.
+    """
+    data_store: Incomplete
+    def __init__(self, data_store: BaseHybridCache) -> None:
+        """Initializes a new instance of the CacheManager class.
+
+        Args:
+            data_store (BaseCacheDataStore): The data store to use for the cache manager.
+        """
+    async def retrieve(self, key: str | dict[str, Any] | tuple[Any, ...]) -> tuple[Any, bool]:
+        """Retrieves the cache of a given key.
+
+        This method stringifies the key and then calls the `retrieve` method of the data store to retrieve the cache.
+        It returns the retrieved cache and a boolean indicating if the cache was found.
+
+        Args:
+            key (str | dict[str, Any] | tuple[Any, ...]): The key of the cache to retrieve.
+
+        Returns:
+            tuple[Any, bool]: The retrieved cache and a boolean indicating if the cache was found.
+        """
+    async def store(self, key: str | dict[str, Any] | tuple[Any, ...], value: Any, ttl: int | str | None = None) -> None:
+        '''Stores the cache of a given key.
+
+        This method stringifies the key and then calls the `store` method of the data store to store the cache.
+        If the value is None, the method will skip the storage process.
+
+        Args:
+            key (str | dict[str, Any] | tuple[Any, ...]): The key of the cache to store.
+            value (Any): The value of the cache to store.
+            ttl (int | str | None, optional): The time-to-live (TTL) for the cache data.
+                Must be an integer in seconds or a string in a valid time format (e.g. "1h", "1d", "1w", "1m", "1y").
+                If None, the cache data will not expire.
+
+        Returns:
+            None
+        '''

gllm_misc/graph_transformer/__init__.pyi

@@ -0,0 +1,5 @@
+from gllm_misc.graph_transformer.lm_based_graph_transformer import LMBasedGraphTransformer as LMBasedGraphTransformer
+from gllm_misc.graph_transformer.lm_based_mindmap_transformer import LMBasedMindMapTransformer as LMBasedMindMapTransformer
+from gllm_misc.graph_transformer.schema import GraphDocument as GraphDocument, Node as Node, Relationship as Relationship
+
+__all__ = ['GraphDocument', 'LMBasedGraphTransformer', 'LMBasedMindMapTransformer', 'Node', 'Relationship']

gllm_misc/graph_transformer/constant.pyi

@@ -0,0 +1,10 @@
+from _typeshed import Incomplete
+
+DEFAULT_NODE_TYPE: str
+MINDMAP_DEFAULT_ALLOWED_NODES: Incomplete
+MINDMAP_DEFAULT_ALLOWED_RELATIONSHIPS: Incomplete
+MINDMAP_DEFAULT_ROOT_NODE_TYPE: str
+MINDMAP_DEFAULT_ROOT_RELATIONSHIP_TYPE: str
+MINDMAP_DEFAULT_TRANSFORMER_PROMPT: str
+MINDMAP_DEFAULT_ROOT_NODE_PROMPT: str
+RELATIONSHIP_TUPLE_LENGTH: int

gllm_misc/graph_transformer/lm_based_graph_transformer.pyi

@@ -0,0 +1,137 @@
+from _typeshed import Incomplete
+from gllm_core.schema import Chunk
+from gllm_inference.lm_invoker.lm_invoker import BaseLMInvoker
+from gllm_inference.prompt_builder import PromptBuilder
+from gllm_inference.schema import ModelId
+from gllm_misc.graph_transformer.schema import GraphDocument as GraphDocument, GraphResponse as GraphResponse, RelationshipTypeFormat as RelationshipTypeFormat
+from gllm_misc.graph_transformer.utils import convert_to_graph_document as convert_to_graph_document, create_simple_model as create_simple_model, filter_graph_document_by_allowed_nodes_and_relationships as filter_graph_document_by_allowed_nodes_and_relationships, filter_relationships_by_existing_nodes as filter_relationships_by_existing_nodes, get_default_prompt as get_default_prompt, validate_and_get_relationship_type as validate_and_get_relationship_type
+from typing import Any
+
+class LMBasedGraphTransformer:
+    '''Transform documents into graph-based documents using a language model.
+
+    This class orchestrates the extraction of knowledge graphs from text documents
+    using a language model. It handles prompt construction, model invocation, and
+    parsing of results into a standardized graph format.
+
+    The transformer can be configured with constraints on node and relationship types,
+    and supports both structured and unstructured output formats from the language model.
+
+    Attributes:
+        lm_invoker: The language model invoker used to generate graph data.
+        allowed_nodes: List of allowed node types to constrain the output.
+        allowed_relationships: List of allowed relationship types to constrain the output.
+        strict_mode: Whether to strictly enforce node and relationship type constraints.
+        use_structured_output: Whether to use the LM\'s structured output capabilities.
+        prompt_builder: The prompt builder used to generate prompts for the LM.
+
+    Example:
+        Using an existing LM invoker:
+
+        ```python
+        from gllm_inference.lm_invoker import OpenAILMInvoker
+        from gllm_misc.graph_transformer import LMBasedGraphTransformer
+        from gllm_core.schema import Chunk
+
+        # Create an LM invoker
+        invoker = OpenAILMInvoker(model_name="gpt-4o-mini", api_key="sk-proj-123")
+
+        # Create a graph transformer with constraints
+        transformer = LMBasedGraphTransformer(
+            lm_invoker=invoker,
+            allowed_nodes=["Person", "Organization", "Event"],
+            allowed_relationships=["WORKS_AT", "PARTICIPATES_IN"]
+        )
+
+        # Extract graph from text
+        chunks = [Chunk(content="Elon Musk is the CEO of SpaceX and Tesla.")]
+        graph_docs = await transformer.convert_to_graph_documents(chunks)
+        ```
+
+        Building LM invoker from model ID:
+
+        ```python
+        from gllm_misc.graph_transformer import LMBasedGraphTransformer
+        from gllm_core.schema import Chunk
+
+        # Create a graph transformer by specifying model ID
+        transformer = LMBasedGraphTransformer(
+            model_id="openai/gpt-4o-mini",
+            allowed_nodes=["Person", "Organization", "Event"],
+            allowed_relationships=["WORKS_AT", "PARTICIPATES_IN"]
+        )
+
+        # Extract graph from text
+        chunks = [Chunk(content="Elon Musk is the CEO of SpaceX and Tesla.")]
+        graph_docs = await transformer.convert_to_graph_documents(chunks)
+        ```
+    '''
+    lm_invoker: Incomplete
+    def __init__(self, lm_invoker: BaseLMInvoker | None = None, model_id: str | ModelId | None = None, credentials: str | dict[str, Any] | None = None, config: dict[str, Any] | None = None, allowed_nodes: list[str] | None = None, allowed_relationships: list[str] | list[tuple[str, str, str]] | None = None, prompt_builder: PromptBuilder | None = None, strict_mode: bool = True, use_structured_output: bool = False) -> None:
+        """Initialize the LMBasedGraphTransformer.
+
+        Args:
+            lm_invoker (BaseLMInvoker | None, optional): The language model invoker to use for generating graph data.
+                Either lm_invoker or model_id must be provided. Defaults to None.
+            model_id (str | ModelId | None, optional): The model ID to use for building the LM invoker.
+                Required if lm_invoker is not provided. Defaults to None.
+            credentials (str | dict[str, Any] | None, optional): Credentials for the LM model.
+                Used when building the LM invoker. Defaults to None.
+            config (dict[str, Any] | None, optional): Configuration for the LM model.
+                Used when building the LM invoker. Defaults to None.
+            allowed_nodes (list[str] | None, optional): Optional list of allowed node types.
+                If provided, the transformer will constrain output to only use these node types.
+                Defaults to None.
+            allowed_relationships (list[str] | list[tuple[str, str, str]] | None, optional): Optional list of allowed
+                relationship types. Can be either a list of strings or a list of tuples in the format
+                (source_type, relationship_type, target_type).
+                Defaults to None.
+            prompt_builder (PromptBuilder | None, optional): Optional custom prompt builder. Defaults to a
+                prompt builder created using get_default_prompt().
+            strict_mode (bool, optional): Determines whether the transformer should apply filtering to
+                strictly adhere to allowed_nodes and allowed_relationships.
+                Defaults to True.
+            use_structured_output (bool, optional): Indicates whether the transformer should use the
+                language model's native structured output functionality.
+                Defaults to False.
+        """
+    async def process_response(self, chunk: Chunk) -> GraphDocument:
+        """Process a single text chunk and transform it into a graph document.
+
+        This method handles the core transformation logic, including:
+        1. Formatting the prompt with the chunk content
+        2. Invoking the language model
+        3. Parsing the response into nodes and relationships
+        4. Applying filtering based on allowed node and relationship types if strict_mode is enabled
+
+        Args:
+            chunk (Chunk): A Chunk object containing the text content to transform into a graph
+
+        Returns:
+            GraphDocument: A GraphDocument containing the extracted nodes and relationships
+        """
+    async def convert_to_graph_documents(self, documents: list[Chunk]) -> list[GraphDocument]:
+        '''Asynchronously convert a sequence of text chunks into graph documents.
+
+        This method processes multiple chunks in parallel by creating asyncio tasks
+        for each document and gathering their results. Each chunk is processed
+        independently using the process_response method.
+
+        Args:
+            documents (list[Chunk]): A list of Chunk objects containing the text content to
+                transform into graphs.
+
+        Returns:
+            list[GraphDocument]: A list of GraphDocument objects, each containing nodes and relationships
+                extracted from the corresponding input chunk.
+
+        Example:
+            ```python
+            chunks = [
+                Chunk(content="Alice works at Acme Corp."),
+                Chunk(content="Bob is the CEO of TechStart.")
+            ]
+            graph_docs = await transformer.convert_to_graph_documents(chunks)
+            # Returns a list of two GraphDocument objects
+            ```
+        '''

gllm_misc/graph_transformer/lm_based_mindmap_transformer.pyi

@@ -0,0 +1,127 @@
+from _typeshed import Incomplete
+from gllm_core.schema import Chunk as Chunk
+from gllm_inference.lm_invoker.lm_invoker import BaseLMInvoker
+from gllm_inference.prompt_builder import PromptBuilder
+from gllm_inference.schema import ModelId
+from gllm_misc.graph_transformer.constant import MINDMAP_DEFAULT_ALLOWED_NODES as MINDMAP_DEFAULT_ALLOWED_NODES, MINDMAP_DEFAULT_ALLOWED_RELATIONSHIPS as MINDMAP_DEFAULT_ALLOWED_RELATIONSHIPS, MINDMAP_DEFAULT_ROOT_NODE_PROMPT as MINDMAP_DEFAULT_ROOT_NODE_PROMPT, MINDMAP_DEFAULT_ROOT_NODE_TYPE as MINDMAP_DEFAULT_ROOT_NODE_TYPE, MINDMAP_DEFAULT_ROOT_RELATIONSHIP_TYPE as MINDMAP_DEFAULT_ROOT_RELATIONSHIP_TYPE, MINDMAP_DEFAULT_TRANSFORMER_PROMPT as MINDMAP_DEFAULT_TRANSFORMER_PROMPT
+from gllm_misc.graph_transformer.lm_based_graph_transformer import LMBasedGraphTransformer as LMBasedGraphTransformer
+from gllm_misc.graph_transformer.schema import GraphDocument as GraphDocument, GraphResponse as GraphResponse, Node as Node, Relationship as Relationship
+from typing import Any
+
+class LMBasedMindMapTransformer(LMBasedGraphTransformer):
+    '''Transform documents into mindmap-based knowledge representations using a language model.
+
+    This class extends LMBasedGraphTransformer to specifically handle the extraction of hierarchical
+    mind map structures from text documents. It uses a specialized prompt and default node/relationship
+    types designed for mind mapping, organizing content into central themes, main ideas, and sub-ideas.
+
+    The transformer maintains the hierarchical structure of ideas while converting text into a
+    graph representation that can be visualized as a mind map.
+
+    The transformer extends LMBasedGraphTransformer by adding specialized functionality for
+    merging root nodes and pruning disconnected graph documents to ensure the mind map forms
+    a connected graph stemming from a single root node.
+
+    Attributes:
+        lm_invoker (BaseLMInvoker): The language model invoker used to generate graph data.
+        allowed_nodes (list[str]): List of allowed node types to constrain the output.
+            Defaults to MINDMAP_DEFAULT_ALLOWED_NODES (CentralTheme, MainIdea, SubIdea).
+        allowed_relationships (list[str] | list[tuple[str, str, str]]): List of allowed
+            relationship types to constrain the output. Defaults to MINDMAP_DEFAULT_ALLOWED_RELATIONSHIPS
+            which define the hierarchical structure of a mind map.
+        root_node_type (str): The type of the root node. Defaults to
+            MINDMAP_DEFAULT_ROOT_NODE_TYPE (CentralTheme).
+        strict_mode (bool): Whether to strictly enforce node and relationship type constraints.
+            Defaults to True.
+        use_structured_output (bool): Whether to use the LM\'s structured output capabilities.
+            Defaults to True.
+        prompt_builder (PromptBuilder, optional): The prompt builder used to generate prompts for the LM.
+            If None, creates a default prompt builder with the mind map extraction prompt.
+
+    Example:
+        Using an existing LM invoker:
+
+        ```python
+        from gllm_inference.lm_invoker import OpenAILMInvoker
+        from gllm_misc.graph_transformer import LMBasedMindMapTransformer
+        from gllm_core.schema import Chunk
+
+        # Create an LM invoker
+        invoker = OpenAILMInvoker(model_name="gpt-4o-mini", api_key="sk-proj-123")
+
+        # Create a mind map transformer
+        transformer = LMBasedMindMapTransformer(lm_invoker=invoker)
+
+        # Extract mind map from text
+        chunks = [Chunk(content="Artificial Intelligence is transforming industries...")]
+        mind_map_docs = await transformer.convert_to_graph_documents(chunks)
+        ```
+
+        Building LM invoker from model ID:
+
+        ```python
+        from gllm_misc.graph_transformer import LMBasedMindMapTransformer
+        from gllm_core.schema import Chunk
+
+        # Create a mind map transformer by specifying model ID
+        transformer = LMBasedMindMapTransformer(
+            model_id="openai/gpt-4o-mini",
+        )
+
+        # Extract mind map from text
+        chunks = [Chunk(content="Artificial Intelligence is transforming industries...")]
+        mind_map_docs = await transformer.convert_to_graph_documents(chunks)
+        ```
+    '''
+    root_node_type: Incomplete
+    def __init__(self, lm_invoker: BaseLMInvoker | None = None, model_id: str | ModelId | None = None, credentials: str | dict[str, Any] | None = None, config: dict[str, Any] | None = None, allowed_nodes: list[str] | None = None, allowed_relationships: list[str] | list[tuple[str, str, str]] | None = None, root_node_type: str | None = None, prompt_builder: PromptBuilder | None = None, strict_mode: bool = True, use_structured_output: bool = True) -> None:
+        """Initialize the LMBasedMindMapTransformer with the specified configuration.
+
+        This constructor sets up the mind map transformer with appropriate defaults
+        for mind map extraction if not explicitly provided.
+
+        Args:
+            lm_invoker (BaseLMInvoker | None, optional): The language model invoker to use for generating graph data.
+                Either lm_invoker or model_id must be provided. Defaults to None.
+            model_id (str | ModelId | None, optional): The model ID to use for building the LM invoker.
+                Required if lm_invoker is not provided. Defaults to None.
+            credentials (str | dict[str, Any] | None, optional): Credentials for the LM model.
+                Used when building the LM invoker. Defaults to None.
+            config (dict[str, Any] | None, optional): Configuration for the LM model.
+                Used when building the LM invoker. Defaults to None.
+            allowed_nodes (list[str] | None, optional): Optional list of allowed node types. If None,
+                defaults to MINDMAP_DEFAULT_ALLOWED_NODES (CentralTheme, MainIdea, SubIdea).
+                Defaults to None.
+            allowed_relationships (list[str] | list[tuple[str, str, str]] | None, optional): Optional list of
+                allowed relationship types. If None, defaults to MINDMAP_DEFAULT_ALLOWED_RELATIONSHIPS
+                which define the hierarchical structure of a mind map.
+                Defaults to None.
+            root_node_type (str | None, optional): Optional root node type. If None,
+                uses the default root node type MINDMAP_DEFAULT_ROOT_NODE_TYPE.
+                Defaults to None.
+            prompt_builder (PromptBuilder | None, optional): Optional prompt builder. If None,
+                creates a default prompt builder with the mind map extraction prompt.
+                Defaults to None.
+            strict_mode (bool, optional): Whether to strictly enforce node and relationship type constraints.
+                Defaults to True.
+            use_structured_output (bool, optional): Whether to use the LM's structured output capabilities.
+                Defaults to True.
+
+        Raises:
+            ValueError: If root_node_type is not in allowed_nodes
+                or if both/none of lm_invoker and lm_model_id are provided.
+        """
+    async def convert_to_graph_documents(self, documents: list[Chunk]) -> list[GraphDocument]:
+        """Asynchronously convert a sequence of text chunks into graph documents.
+
+        This method overrides the parent class to ensure that each graph document
+        has its root nodes merged after processing.
+
+        Args:
+            documents (list[Chunk]): A list of Chunk objects containing the text content to
+                transform into graphs.
+
+        Returns:
+            list[GraphDocument]: A list of GraphDocument objects, each containing nodes and relationships
+                extracted from the corresponding input chunk, with merged root nodes.
+        """

gllm_misc/graph_transformer/prompt.pyi

@@ -0,0 +1,19 @@
+from gllm_misc.graph_transformer.schema import PrimitiveNodeType as PrimitiveNodeType, PrimitiveRelationshipType as PrimitiveRelationshipType
+
+def get_default_graph_transformer_system_prompt(allowed_nodes: list[PrimitiveNodeType] | None = None, allowed_relationships: list[PrimitiveRelationshipType] | None = None) -> str:
+    """Generate system prompt with optional allowed nodes and relationships.
+
+    This is a public utility function that creates a formatted system prompt for LLMs
+    to guide knowledge graph extraction. The prompt includes instructions for the model
+    on how to identify and structure entities and relationships.
+
+    Args:
+        allowed_nodes (list[PrimitiveNodeType] | None, optional): Optional list of allowed node types.
+            If provided, the prompt will instruct the model to only use these specific node types. Defaults to None.
+        allowed_relationships (list[PrimitiveRelationshipType] | None, optional): Optional list of allowed
+            relationship types. If provided, the prompt will instruct the model to only use these specific
+            relationship types. Defaults to None.
+
+    Returns:
+        str: Formatted system prompt string ready to be used with an LLM.
+    """

gllm_misc/graph_transformer/schema.pyi

@@ -0,0 +1,100 @@
+from enum import StrEnum
+from gllm_core.schema import Chunk
+from pydantic import BaseModel
+
+class InputType(StrEnum):
+    """Enum for input types used in graph element descriptions."""
+    NODE: str
+    RELATIONSHIP: str
+    PROPERTY: str
+
+class RelationshipTypeFormat(StrEnum):
+    '''Enum for relationship type formats.
+
+    This enum defines the valid formats for specifying relationship types:
+    - STRING: Relationship types are specified as simple strings (e.g., "WORKS_AT")
+    - TUPLE: Relationship types are specified as 3-tuples in the format
+      (source_type, relationship_type, target_type)
+    '''
+    STRING: str
+    TUPLE: str
+
+class Node(BaseModel):
+    '''Represents a node in a graph with associated properties.
+
+    Attributes:
+        id (str): A unique identifier for the node.
+        type (str): The type or label of the node. Defaults to "Node".
+        properties (dict): Additional properties and metadata associated with the node.
+    '''
+    id: str
+    type: str
+    properties: dict
+
+class Relationship(BaseModel):
+    '''Represents a directed relationship between two nodes in a graph.
+
+    Attributes:
+        source (Node): The source node of the relationship.
+        target (Node): The target node of the relationship.
+        type (str): The type of the relationship. Defaults to "Relationship".
+        properties (dict): Additional properties associated with the relationship.
+    '''
+    source: Node
+    target: Node
+    type: str
+    properties: dict
+
+class GraphDocument(BaseModel):
+    """Represents a graph document consisting of nodes and relationships.
+
+    Attributes:
+        nodes (list[Node]): A list of nodes in the graph.
+        relationships (list[Relationship]): A list of relationships in the graph.
+        source (Chunk | None): The document from which the graph information is derived.
+    """
+    nodes: list[Node]
+    relationships: list[Relationship]
+    source: Chunk | None
+
+class SimpleNode(BaseModel):
+    '''Represents a node in a graph with associated properties.
+
+    This class is to be used as the schema for the LMInvoker\'s structured output.
+
+    Attributes:
+        id (str): A unique identifier for the node.
+        type (str): The type or label of the node. Defaults to "Node".
+    '''
+    id: str
+    type: str
+
+class SimpleRelationship(BaseModel):
+    """Represents a simple directed relationship between two nodes in a graph.
+
+    This class is to be used as the schema for the LMInvoker's structured output.
+
+    Attributes:
+        source_node_id (str): The ID of the source node.
+        source_node_type (str): The type of the source node.
+        target_node_id (str): The ID of the target node.
+        target_node_type (str): The type of the target node.
+        type (str): The type of the relationship.
+    """
+    source_node_id: str
+    source_node_type: str
+    target_node_id: str
+    target_node_type: str
+    type: str
+
+class GraphResponse(BaseModel):
+    """Represents a graph response generated by LM Invoker containing nodes and relationships.
+
+    Attributes:
+        nodes (list[SimpleNode] | None): A list of nodes generated by LM Invoker.
+        relationships (list[SimpleRelationship] | None): A list of relationships generated by LM Invoker.
+    """
+    nodes: list[SimpleNode] | None
+    relationships: list[SimpleRelationship] | None
+PrimitiveNodeType = str
+PrimitiveRelationshipType = str | tuple[str, str, str]

gllm_misc/graph_transformer/utils.pyi

@@ -0,0 +1,176 @@
+from gllm_inference.prompt_builder import PromptBuilder
+from gllm_inference.schema import LMOutput
+from gllm_misc.graph_transformer.constant import DEFAULT_NODE_TYPE as DEFAULT_NODE_TYPE, RELATIONSHIP_TUPLE_LENGTH as RELATIONSHIP_TUPLE_LENGTH
+from gllm_misc.graph_transformer.schema import GraphDocument as GraphDocument, GraphResponse as GraphResponse, InputType as InputType, Node as Node, PrimitiveNodeType as PrimitiveNodeType, PrimitiveRelationshipType as PrimitiveRelationshipType, Relationship as Relationship, RelationshipTypeFormat as RelationshipTypeFormat, SimpleNode as SimpleNode, SimpleRelationship as SimpleRelationship
+from typing import Any
+
+def get_default_prompt(allowed_nodes: list[PrimitiveNodeType] | None = None, allowed_relationships: list[PrimitiveRelationshipType] | None = None, relationship_type: RelationshipTypeFormat | None = None) -> PromptBuilder:
+    """Create a prompt for LMBasedGraphTransformer that does not use structured output.
+
+    Args:
+        allowed_nodes (list[PrimitiveNodeType] | None, optional): Optional list of allowed node types. Defaults to None.
+        allowed_relationships (list[PrimitiveRelationshipType] | None, optional): Optional list of allowed
+            relationship types. Defaults to None.
+        relationship_type (str | None, optional): Optional string indicating the type of relationship. Defaults to None.
+
+    Returns:
+        A PromptBuilder instance with the prompt template.
+    """
+def optional_enum_field(enum_values: list[str] | list[tuple[str, str, str]] | None = None, description: str = '', input_type: str | InputType = ..., relationship_type: RelationshipTypeFormat | None = None, **field_kwargs: Any) -> Any:
+    """Utility function to conditionally create a field with an enum constraint.
+
+    This function creates a Pydantic Field with optional enum constraints based on the
+    provided parameters. It handles different LLM types and relationship formats.
+
+    Args:
+        enum_values (list[str] | list[tuple[str, str, str]] | None, optional): List of allowed values for the field.
+            Can be a list of strings or a list of tuples (relationship_type, source_node, target_node).
+            Defaults to None.
+        description (str, optional): Description of the field. Defaults to an empty string.
+        input_type (InputType, optional): The type of input to get additional information for.
+            Defaults to InputType.NODE.
+        relationship_type (RelationshipTypeFormat | None, optional): The type of relationship for relationship fields.
+            Defaults to None.
+        **field_kwargs (Any, optional): Additional keyword arguments to pass to the Field constructor.
+
+    Returns:
+        Any: A Pydantic Field with the specified constraints and descriptions.
+    """
+def create_simple_model(node_labels: list[PrimitiveNodeType] | None = None, rel_types: list[PrimitiveRelationshipType] | None = None, relationship_type: RelationshipTypeFormat | None = None) -> type[GraphResponse]:
+    """Create a simple graph model with optional constraints on node and relationship types.
+
+    This public utility function dynamically creates a Pydantic model for graph data
+    with optional constraints on node and relationship types. The model includes
+    fields for nodes and relationships with appropriate validation rules.
+
+    Args:
+        node_labels (list[PrimitiveNodeType] | None, optional): Specifies the allowed node types.
+            If None, all node types are allowed. Defaults to None.
+        rel_types (list[PrimitiveRelationshipType] | None, optional): Specifies the allowed relationship types.
+            Can be either a list of strings or a list of tuples in the format (source_type, relationship_type,
+            target_type). If None, all relationship types are allowed. Defaults to None.
+        relationship_type (str | None, optional): Type of relationship format. If 'tuple', will extract
+            relationship types from the tuples in rel_types. Defaults to None.
+
+    Returns:
+        Type[GraphResponse]: A dynamically created Pydantic model class with the specified constraints.
+
+    Raises:
+        ValueError: If 'id' is included in the node or relationship properties list.
+    """
+def map_to_base_node(node: SimpleNode) -> Node:
+    """Map the SimpleNode to the base Node.
+
+    This internal helper function converts a dynamically created SimpleNode instance
+    to the standard Node class used throughout the application.
+
+    Args:
+        node (SimpleNode): A SimpleNode instance from the dynamically created model.
+
+    Returns:
+        Node: A standard Node instance with properties copied from the SimpleNode.
+    """
+def map_to_base_relationship(rel: SimpleRelationship) -> Relationship:
+    """Map the SimpleRelationship to the base Relationship.
+
+    This internal helper function converts a dynamically created SimpleRelationship instance
+    to the standard Relationship class used throughout the application.
+
+    Args:
+        rel (SimpleRelationship): A SimpleRelationship instance from the dynamically created model.
+
+    Returns:
+        Relationship: A standard Relationship instance with properties copied from the SimpleRelationship.
+    """
+def format_property_key(s: str) -> str:
+    '''Format property keys in camelCase style.
+
+    This utility function converts a space-separated string into camelCase format,
+    which is commonly used for property keys in graph databases and JSON.
+
+    Args:
+        s (str): The input string to format as a property key.
+
+    Returns:
+        str: The formatted property key in camelCase (first word lowercase,
+            subsequent words capitalized with no spaces).
+
+    Examples:
+        >>> format_property_key("date of birth")
+        \'dateOfBirth\'
+        >>> format_property_key("name")
+        \'name\'
+    '''
+def convert_to_graph_document(output: LMOutput | str) -> GraphDocument:
+    """Convert LLM output to formatted nodes and relationships.
+
+    This internal helper function processes the output from a language model
+    (either as a string or structured LMOutput) and converts it into properly
+    formatted lists of nodes and relationships.
+
+    The function handles both structured output (Pydantic model) and unstructured
+    output (JSON string) formats, applying appropriate parsing and formatting.
+
+    Args:
+        output (LMOutput | str): Either a structured LMOutput object or a JSON string containing
+            nodes and relationships data.
+
+    Returns:
+        GraphDocument: A GraphDocument containing the extracted nodes and relationships
+
+    Note:
+        If parsing fails for string output, empty lists will be returned.
+        For structured output, nodes without IDs and relationships without type,
+        source_node_id, or target_node_id will be filtered out.
+    """
+def validate_and_get_relationship_type(allowed_relationships: list[PrimitiveRelationshipType] | None, allowed_nodes: list[PrimitiveNodeType] | None) -> RelationshipTypeFormat | None:
+    '''Validate relationship type format and return the format type.
+
+    This utility function validates that the allowed_relationships parameter
+    is in one of the expected formats (list of strings or list of tuples)
+    and returns the detected format type as an enum.
+
+    Args:
+        allowed_relationships (list[PrimitiveRelationshipType] | None, optional): List of allowed relationship types,
+            either as:
+                - A list of strings (e.g., ["WORKS_AT", "FRIEND_OF"])
+                - A list of 3-tuples in the format (source_type, relationship_type, target_type)
+                (e.g., [("Person", "WORKS_AT", "Company")])
+        allowed_nodes (list[PrimitiveNodeType] | None, optional): Optional list of allowed node types. Required when
+            allowed_relationships is a list of tuples to validate that source and
+            target node types are in the allowed_nodes list. Defaults to None.
+
+    Returns:
+        RelationshipTypeFormat | None: The detected format type:
+            - RelationshipTypeFormat.STRING if allowed_relationships is a list of strings
+            - RelationshipTypeFormat.TUPLE if allowed_relationships is a list of 3-tuples
+            - None if allowed_relationships is empty or None
+
+    Raises:
+        ValueError: If allowed_relationships is not a list, or if it contains invalid
+            formats, or if tuple source/target types are not in allowed_nodes.
+    '''
+def filter_relationships_by_existing_nodes(nodes: list[Node], relationships: list[Relationship]) -> list[Relationship]:
+    """Remove relationships where source or target node is not in nodes.
+
+    Args:
+        nodes (list[Node]): List of nodes.
+        relationships (list[Relationship]): List of relationships.
+
+    Returns:
+        list[Relationship]: List of relationships where source and target node is in nodes.
+    """
+def filter_graph_document_by_allowed_nodes_and_relationships(graph_document: GraphDocument, allowed_nodes: list[str] | None, allowed_relationships: list[str] | list[tuple[str, str, str]] | None, relationship_type: RelationshipTypeFormat | None) -> GraphDocument:
+    """Filter graph document by allowed nodes and relationships.
+
+    This implementation performs filtering with case-insensitive comparison.
+
+    Args:
+        graph_document (GraphDocument): Graph document to filter.
+        allowed_nodes (list[str] | None): List of allowed node types.
+        allowed_relationships (list[str] | list[tuple[str, str, str]] | None): List of allowed relationship types.
+        relationship_type (str | None): Type of relationship.
+
+    Returns:
+        GraphDocument: Filtered graph document.
+    """

gllm_misc.pyi

@@ -0,0 +1,35 @@
+# This file was generated by Nuitka
+
+# Stubs included by default
+from __future__ import annotations
+
+
+__name__ = ...
+
+
+
+# Modules used internally, to allow implicit dependencies to be seen:
+import os
+import hashlib
+import json
+import enum
+import typing
+import gllm_core
+import gllm_core.schema
+import gllm_datastore
+import gllm_datastore.cache
+import gllm_datastore.cache.hybrid_cache
+import gllm_datastore.cache.hybrid_cache.hybrid_cache
+import asyncio
+import gllm_core.utils
+import gllm_core.utils.logger_manager
+import gllm_inference
+import gllm_inference.lm_invoker
+import gllm_inference.lm_invoker.lm_invoker
+import gllm_inference.prompt_builder
+import gllm_inference.schema
+import json_repair
+import collections
+import collections.defaultdict
+import collections.deque
+import pydantic

gllm_misc_binary-0.9.6.dist-info/METADATA

@@ -0,0 +1,152 @@
+Metadata-Version: 2.2
+Name: gllm-misc-binary
+Version: 0.9.6
+Summary: A library containing miscellaneous components for Gen AI applications.
+Author-email: Dimitrij Ray <dimitrij.ray@gdplabs.id>, Henry Wicaksono <henry.wicaksono@gdplabs.id>, Resti Febriana <resti.febriana@gdplabs.id>, Kadek Denaya <kadek.d.r.diana@gdplabs.id>
+Requires-Python: <3.14,>=3.11
+Description-Content-Type: text/markdown
+Requires-Dist: gllm-core-binary<0.5.0,>=0.3.0
+Requires-Dist: gllm-inference-binary[google]<0.7.0,>=0.5.0
+Requires-Dist: gllm-datastore-binary[chroma]<0.6.0,>=0.5.0
+Provides-Extra: dev
+Requires-Dist: coverage<8.0.0,>=7.4.4; extra == "dev"
+Requires-Dist: mypy<2.0.0,>=1.15.0; extra == "dev"
+Requires-Dist: pre-commit<4.0.0,>=3.7.0; extra == "dev"
+Requires-Dist: pytest<10.0.0,>=9.0.3; extra == "dev"
+Requires-Dist: pytest-asyncio<2.0.0,>=1.0.0; extra == "dev"
+Requires-Dist: pytest-cov<6.0.0,>=5.0.0; extra == "dev"
+Requires-Dist: ruff<0.7.0,>=0.6.7; extra == "dev"
+Provides-Extra: json-repair
+Requires-Dist: json-repair<1.0.0,>=0.47.6; extra == "json-repair"
+
+# GLLM Misc
+
+## Description
+A library containing miscellaneous utilities and helper functions for Generative AI applications.
+
+---
+
+## Installation
+
+### Prerequisites
+
+Mandatory:
+1. Python 3.11+ — [Install here](https://www.python.org/downloads/)
+2. pip — [Install here](https://pip.pypa.io/en/stable/installation/)
+3. uv — [Install here](https://docs.astral.sh/uv/getting-started/installation/)
+4. gcloud CLI (for authentication) — [Install here](https://cloud.google.com/sdk/docs/install), then log in using:
+   ```bash
+   gcloud auth login
+   ```
+
+---
+
+### Install from Artifact Registry
+
+This requires authentication via the `gcloud` CLI.
+
+```bash
+uv pip install \
+  --extra-index-url "https://oauth2accesstoken:$(gcloud auth print-access-token)@glsdk.gdplabs.id/gen-ai-internal/simple/" \
+  gllm-misc
+```
+
+---
+
+## Local Development Setup
+
+### Prerequisites
+
+1. Python 3.11+ — [Install here](https://www.python.org/downloads/)
+2. pip — [Install here](https://pip.pypa.io/en/stable/installation/)
+3. uv — [Install here](https://docs.astral.sh/uv/getting-started/installation/)
+4. gcloud CLI — [Install here](https://cloud.google.com/sdk/docs/install), then log in using:
+
+   ```bash
+   gcloud auth login
+   ```
+5. Git — [Install here](https://git-scm.com/downloads)
+6. Access to the [GDP Labs SDK GitHub repository](https://github.com/GDP-ADMIN/gl-sdk)
+
+---
+
+### 1. Clone Repository
+
+```bash
+git clone git@github.com:GDP-ADMIN/gl-sdk.git
+cd gl-sdk/libs/gllm-misc
+```
+
+---
+
+### 2. Setup Authentication
+
+Set the following environment variables to authenticate with internal package indexes:
+
+```bash
+export UV_INDEX_GEN_AI_INTERNAL_USERNAME=oauth2accesstoken
+export UV_INDEX_GEN_AI_INTERNAL_PASSWORD="$(gcloud auth print-access-token)"
+export UV_INDEX_GEN_AI_USERNAME=oauth2accesstoken
+export UV_INDEX_GEN_AI_PASSWORD="$(gcloud auth print-access-token)"
+```
+
+---
+
+### 3. Quick Setup
+
+Run:
+
+```bash
+make setup
+```
+
+---
+
+### 4. Activate Virtual Environment
+
+```bash
+source .venv/bin/activate
+```
+
+---
+
+## Local Development Utilities
+
+The following Makefile commands are available for quick operations:
+
+### Install uv
+
+```bash
+make install-uv
+```
+
+### Install Pre-Commit
+
+```bash
+make install-pre-commit
+```
+
+### Install Dependencies
+
+```bash
+make install
+```
+
+### Update Dependencies
+
+```bash
+make update
+```
+
+### Run Tests
+
+```bash
+make test
+```
+
+---
+
+## Contributing
+
+Please refer to the [Python Style Guide](https://docs.google.com/document/d/1uRggCrHnVfDPBnG641FyQBwUwLoFw0kTzNqRm92vUwM/edit?usp=sharing)
+for information about code style, documentation standards, and SCA requirements.

gllm_misc_binary-0.9.6.dist-info/RECORD

@@ -0,0 +1,16 @@
+gllm_misc.cp313-win_amd64.pyd,sha256=1HsOL2e8t8vxNCr5Cu9rklmDyihcWfgvxFp7cMazC_w,627200
+gllm_misc.pyi,sha256=TzFLLF1rrJDtKBMH_SY8l0xnahr12pHfKdetY0FoaQI,789
+gllm_misc/__init__.pyi,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+gllm_misc/cache_manager/__init__.pyi,sha256=xlTbERx84PBt7weWfQ_ef2mLpHtUDjvbVVeBXcFCOUA,174
+gllm_misc/cache_manager/cache_manager.pyi,sha256=BOc_6WahW9sESXHf3c3dURirro6TeOu2qm6ncSVpoF0,2497
+gllm_misc/graph_transformer/__init__.pyi,sha256=rxzbZy51KZntL5VuX3VPv5tD-Llnu8lOPMf6jTN4G-U,478
+gllm_misc/graph_transformer/constant.pyi,sha256=2YtEYPJAhLzTVBLMhAqUQ7gUTkww1hirtO4pT7PO2fc,348
+gllm_misc/graph_transformer/lm_based_graph_transformer.pyi,sha256=TOJMDvCejPX2MxuwmebfIij5fY-btCIImMo6dB7blok,7712
+gllm_misc/graph_transformer/lm_based_mindmap_transformer.pyi,sha256=Y8j4WJ3ay0AR-avideS8OJSAi1SWZFgS4pti8FxPN5M,7924
+gllm_misc/graph_transformer/prompt.pyi,sha256=NhiOmUC5Ya37OabxBADfb6XLgB2vMdHbd8hnkBO0sM4,1250
+gllm_misc/graph_transformer/schema.pyi,sha256=SQttxH_YnVGH6DZbVInUgFPiVwEkLwcBsjP2yxzTz0o,3524
+gllm_misc/graph_transformer/utils.pyi,sha256=gXzW-kXpKM4x8Pi9n0uKlaf4aQ67kO8xXZ-_Kja2PYg,9849
+gllm_misc_binary-0.9.6.dist-info/METADATA,sha256=a2x9kfbjyCZo0o1pfePD_cLl4hrovsu5oZ4JXyrmD6M,3815
+gllm_misc_binary-0.9.6.dist-info/WHEEL,sha256=ikXeVivtRq-oqOZfN0jwm7M68yNYx-wxpXplGP7L4Is,97
+gllm_misc_binary-0.9.6.dist-info/top_level.txt,sha256=qauofm35pMgS3PoJTXiZF-eZWLfbegOgp5d9-tCUa6w,10
+gllm_misc_binary-0.9.6.dist-info/RECORD,,

gllm_misc_binary-0.9.6.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: Nuitka (2.8.10)
+Root-Is-Purelib: false
+Tag: cp313-cp313-win_amd64
+

gllm_misc_binary-0.9.6.dist-info/top_level.txt

@@ -0,0 +1 @@
+gllm_misc