StickyText 0.1.1__py3-none-any.whl

StickyText/BuildGraph.py

@@ -0,0 +1,144 @@
+import networkx as nx
+import matplotlib.pyplot as plt 
+import itertools 
+
+
+def build_L2_graph(token_df, merge_id, merge_text, merge_head, G=None):
+    """
+    Build a directed dependency graph from a token DataFrame.
+
+    Required columns:
+        token_id, text, dep, head, pos, noun_phrase, ner,
+        coref, representative text
+
+    Edge direction:
+        head -> dependent
+    """
+    if not G:
+        G = nx.DiGraph()
+
+    # Add every token as a node
+    for _, row in token_df.iterrows():
+        token_id = row[merge_id]
+
+        G.add_node(
+            token_id,
+            text=row[merge_text],
+            attributes = row.get("attributes")
+            #dep=row["dep"],
+            #pos=row["pos"],
+            #noun_phrase=row["noun_phrase"],
+            #ner= row["ner"],
+            #coref=row["coref"],
+            #representative_text=row["representative_text"],
+        )
+    # Add dependency edges
+    
+    for _, row in token_df.iterrows():
+            token_id = row[merge_id]
+            heads = row[merge_head]
+    
+            # Handle missing heads
+            if heads is None:
+                continue
+            for head in heads:
+              try:
+                if head != token_id and head in G:
+                    G.add_edge(
+                        head,
+                        token_id,
+                        #dep=row["dep"] 
+                    )
+              except TypeError:
+                # Handles NaN / non-hashable values 
+                continue
+
+    return G
+
+
+def visualize_dependency_graph(G, figsize=(16, 10)):
+    """
+    Visualize a dependency graph.
+
+    Node label:
+        token_id: text
+
+    Edge label:
+        dependency relation
+    """
+
+    plt.figure(figsize=figsize)
+
+    # Hierarchical-ish layout
+    pos = nx.spring_layout(
+        G,
+        seed=42,
+        k=2.0,
+        iterations=100
+    )
+
+    # Node labels
+    node_labels = {
+        node: f"{data['text']}:{', '.join(data.get('attributes'))}" if data.get('attributes') is not None else f"{data['text']}"
+        for node, data in G.nodes(data=True)
+    }
+
+    # Draw nodes
+    nx.draw_networkx_nodes(
+        G,
+        pos,
+        node_color="lightblue",
+        node_size=2000,
+        edgecolors="black",
+        linewidths=1
+    )
+
+    # Draw edges
+    nx.draw_networkx_edges(
+        G,
+        pos,
+        arrows=True,
+        arrowsize=20,
+        arrowstyle="-|>",
+        edge_color="gray",
+        width=1.5,
+        connectionstyle="arc3,rad=0.05"
+    )
+
+    # Draw node labels
+    nx.draw_networkx_labels(
+        G,
+        pos,
+        labels=node_labels,
+        font_size=9
+    )
+
+    # Dependency labels
+    edge_labels = nx.get_edge_attributes(G, "dep")
+
+    nx.draw_networkx_edge_labels(
+        G,
+        pos,
+        edge_labels=edge_labels,
+        font_size=8,
+        label_pos=0.5
+    )
+
+    plt.title("Dependency Graph")
+    plt.axis("off")
+    plt.tight_layout()
+    plt.show()
+
+
+def subside_nodes(G, node_ids):
+    def remove_forward(node):
+        pred = list(G.predecessors(node)) 
+        succ = list(G.successors(node)) 
+        conn_nodes = pred + succ 
+        G.add_edges_from((p, s) for p in conn_nodes for s in conn_nodes if p != s and not G.has_edge(s, p))
+        G.add_edges_from((u, v) for u, v in itertools.combinations(conn_nodes, 2)
+                 )
+        G.remove_node(node)
+    list(map(remove_forward, node_ids)) 
+
+    return G 

StickyText/CoRef.py

@@ -0,0 +1,42 @@
+
+from .ModelManager import ModelManager 
+import pandas as pd
+
+class CoRef: 
+    def __init__(self, model_manager: ModelManager, model_name, text:str, doc_id, chunk_id): 
+        self.text = text 
+        self.pipe = model_manager.load(model_name) 
+        self.doc_id = doc_id ; self.chunk_id = chunk_id 
+
+    def process_text(self): 
+        self.res = self.pipe(self.text) 
+        d = self.res.__dict__
+
+        coref_df = pd.DataFrame(
+        {
+        "coref": chain_id,
+        "representative_text": str(chain.representative_text).strip().lower(),
+        "is_representative": (
+            m == chain.mentions[0] 
+        ),
+        "sentence_id": m.sentence,
+        "start_word": m.start_word,
+        "end_word": m.end_word,
+        "start_char": d["_sentences"][m.sentence].words[m.start_word:m.end_word][0].start_char,
+        "end_char": d["_sentences"][m.sentence].words[m.start_word:m.end_word][-1].end_char,
+    
+        
+        }
+        for chain_id, chain in enumerate(d["_coref"])
+        for m in chain.mentions
+        )
+        # coref_df['doc_id'] = self.doc_id
+        return coref_df 
+
+class NER:
+    def __init__(self, coref_stanza):
+        self.coref_stanza = coref_stanza
+    def process_text(self):
+        self.coref_stanza.res 
+
+

StickyText/DepParse.py

@@ -0,0 +1,30 @@
+"""
+This is abstract class with methods initialize or load model , process text , process batch
+"""
+from .ModelManager import ModelManager
+import pandas as pd 
+
+class DependencyParser:
+    def __init__(self, model_manager: ModelManager, text:str):
+        self.model_manager = model_manager
+        self.text = text 
+
+    def process_text(self):
+        """Returns DataFrame or JSON records with columns token_text (lower), 
+        sentence_num, token_num, pos, dep
+        """
+        pass
+
+class SpacyDepParser(DependencyParser):
+    def __init__(self, model_manager, spacy_model_name, text): 
+        super().__init__(model_manager, text) 
+        self.model_name = spacy_model_name 
+        self.model_manager.load(self.model_name) 
+    def process_text(self):
+        self.res = self.model_manager.models[self.model_name](self.text) 
+        df = pd.DataFrame(self.res.to_json()["tokens"])[['start','end',"head","pos", "dep"]] 
+        return df 
+
+    
+
+

StickyText/EdgeMerge.py

@@ -0,0 +1,336 @@
+import pandas as pd
+
+class EdgeMerge:
+    def __init__(self, token_df):
+       self.token_df = token_df   
+
+    def head_to_coref(self, coref_nodes_df, token_id_col="token_id",
+                      coref_token_ids_col ="coref_token_ids", coref_id_col="coref_id", 
+                      coref_head_col="coref_head", token_head_col="head"):
+        # token_id -> coref_id
+        token_df = self.token_df.copy()
+        coref_nodes_df = coref_nodes_df.copy()
+
+        # token_id -> coref_id
+        token_to_coref = (
+        coref_nodes_df
+        .explode(coref_token_ids_col)
+        .rename(columns={coref_token_ids_col: token_id_col})
+        [[token_id_col, coref_id_col]]
+        .drop_duplicates(token_id_col)
+        )
+
+        coref_map = token_to_coref.set_index(token_id_col)[coref_id_col]
+
+        # --------------------------------------------------
+        # token_df
+        # --------------------------------------------------
+        token_df[coref_head_col] = (
+        token_df[token_head_col]
+        .map(coref_map)
+        .fillna(token_df[token_head_col])
+        )
+
+        # --------------------------------------------------
+        # coref_nodes_df
+        # --------------------------------------------------
+        token_to_head = token_df.set_index(token_id_col)[token_head_col]
+
+        def get_external_heads(token_ids):
+            external_heads = []
+
+            # Get the coref_id of this group
+            current_coref_id = coref_map.get(token_ids[0])
+
+            for token_id in token_ids:
+                head = token_to_head.get(token_id)
+
+                if head is None:
+                    continue
+
+                # If head is not part of the same coref group,
+                # it is an external head.
+                head_coref_id = coref_map.get(head)
+
+                if head_coref_id != current_coref_id:
+                    external_heads.append(head) 
+
+            # Remove duplicates while preserving order
+            return list(dict.fromkeys(external_heads))
+
+        coref_nodes_df[coref_head_col] = (
+        coref_nodes_df[coref_token_ids_col]
+        .apply(get_external_heads)
+        ) 
+        token_df = token_df[
+        ~token_df[coref_id_col].isin(coref_nodes_df[coref_id_col])
+        ].copy() 
+        return token_df, coref_nodes_df 
+
+    def head_to_verb(self, verb_df, head_col="coref_head"):
+        token_df = self.token_df.copy()
+        verb_df = verb_df.copy()
+
+        # --------------------------------------------------
+        # token_id -> verb_id
+        # --------------------------------------------------
+        token_to_verb = (
+            verb_df
+            .explode("verb_token_ids")
+            .rename(columns={"verb_token_ids": "token_id"})
+            [["token_id", "verb_id"]]
+            .drop_duplicates("token_id")
+        )
+
+        verb_map = token_to_verb.set_index("token_id")["verb_id"]
+
+        # --------------------------------------------------
+        # token_df
+        # --------------------------------------------------
+        token_df["verb_head"] = (
+            token_df[head_col]
+            .map(verb_map)
+            .fillna(token_df[head_col])
+        )
+
+        # -------------------------------------------------- 
+        # verb_df 
+        # -------------------------------------------------- 
+        token_to_head = token_df.set_index("token_id")[head_col] 
+
+        def get_external_heads(token_ids):
+            external_heads = []
+
+            current_verb_id = verb_map.get(token_ids[0])
+
+            for token_id in token_ids:
+                head = token_to_head.get(token_id)
+
+                if head is None:
+                    continue
+
+                head_verb_id = verb_map.get(head)
+
+                if head_verb_id != current_verb_id:
+                    external_heads.append(head)
+
+            return list(dict.fromkeys(external_heads))
+
+        verb_df["verb_head"] = (
+        verb_df["verb_token_ids"]
+        .apply(get_external_heads)
+        )
+
+        # Remove tokens belonging to verb groups
+        token_df = token_df[
+            ~token_df["token_id"].isin(token_to_verb["token_id"])
+        ].copy()
+
+        return token_df, verb_df
+
+    def head_to_merge(self, merge_df, head_col="head", merge_id_col='merge_id', merge_token_ids_col='merge_token_ids', 
+                       merge_head_col='merge_head', new_tokens='token_id'):
+            token_df = self.token_df.copy()
+            merge_df = merge_df.copy() 
+    
+            # --------------------------------------------------
+            # token_id -> verb_id
+            # --------------------------------------------------
+            token_to_verb = (
+                merge_df
+                .explode(merge_token_ids_col)
+                .rename(columns={merge_token_ids_col: 'token_id'})
+                [['token_id', merge_id_col]]
+                .drop_duplicates('token_id')
+            )
+    
+            verb_map = token_to_verb.set_index('token_id')[merge_id_col]
+    
+            # --------------------------------------------------
+            # token_df
+            # --------------------------------------------------
+            token_df[merge_head_col] = (
+                token_df[head_col]
+                .map(verb_map)
+                .fillna(token_df[head_col])
+            )
+    
+            # -------------------------------------------------- 
+            # verb_df 
+            # -------------------------------------------------- 
+            token_to_head = token_df.set_index("token_id")[head_col] 
+    
+            def get_external_heads(token_ids):
+                external_heads = []
+    
+                current_verb_id = verb_map.get(token_ids[0])
+    
+                for token_id in token_ids:
+                    head = token_to_head.get(token_id)
+    
+                    if head is None:
+                        continue
+    
+                    head_verb_id = verb_map.get(head)
+    
+                    if head_verb_id != current_verb_id:
+                        external_heads.append(head)
+    
+                return list(dict.fromkeys(external_heads))
+    
+            merge_df[merge_head_col] = (
+            merge_df[merge_token_ids_col]
+            .apply(get_external_heads)
+            )
+    
+            # Remove tokens belonging to verb groups
+            token_df = token_df[
+                ~token_df["token_id"].isin(token_to_verb["token_id"])
+            ].copy()
+    
+            return token_df, merge_df
+    
+    def head_to_merge(
+    self,
+    merge_df,
+    head_col="head",
+    merge_id_col="merge_id",
+    merge_token_ids_col="merge_token_ids",
+    merge_head_col="merge_head",
+    new_tokens="token_id",
+    ):
+        token_df = self.token_df.copy()
+        merge_df = merge_df.copy()
+
+        # --------------------------------------------------
+        # 1. token_id -> merge_id
+        # --------------------------------------------------
+        token_to_merge = (
+        merge_df[[merge_id_col, merge_token_ids_col]]
+        .explode(merge_token_ids_col)
+        .rename(columns={merge_token_ids_col: "token_id"})
+        .drop_duplicates("token_id")
+        .set_index("token_id")[merge_id_col]
+        .to_dict()
+        )
+
+        # --------------------------------------------------
+        # 2. Resolve a token/head to its merged node
+        #
+        # If token belongs to a merge, return merge_id.
+        # Otherwise return original token_id.
+        # --------------------------------------------------
+        def resolve_node(token_id):
+            if token_id in token_to_merge:
+                return token_to_merge[token_id]
+            return token_id
+
+        # --------------------------------------------------
+        # 3. Build merged edges
+        #
+        # For every token in every merge:
+        #
+        #     token -> head
+        #
+        # becomes:
+        #
+        #     merge_id -> resolved(head)
+        #
+        # We only keep heads that are outside the same merge.
+        # --------------------------------------------------
+        merge_heads = {}
+
+        token_to_head = (
+        token_df
+        .set_index(new_tokens)[head_col]
+        .to_dict()
+        )
+
+        for merge_id, row in merge_df.set_index(merge_id_col).iterrows():
+
+            token_ids = row[merge_token_ids_col]
+
+            if not token_ids:
+                merge_heads[merge_id] = []
+                continue
+
+            external_heads = []
+
+            for token_id in token_ids:
+
+                head = token_to_head.get(token_id)
+
+                # Root / missing head
+                if head is None:
+                    continue
+
+                resolved_head = resolve_node(head)
+
+                # Ignore edges internal to this merge
+                if resolved_head == merge_id:
+                    continue
+
+                external_heads.append(resolved_head)
+
+            # Preserve order while removing duplicates
+            merge_heads[merge_id] = list(dict.fromkeys(external_heads))
+
+        merge_df[merge_head_col] = (
+        merge_df[merge_id_col]
+        .map(merge_heads)
+        .apply(lambda x: x if isinstance(x, list) else [])
+        )
+
+        # --------------------------------------------------
+        # 4. Update token_df heads
+        #
+        # This is useful if you want the remaining token-level
+        # edges to point to merged nodes.
+        # --------------------------------------------------
+        token_df[merge_head_col] = (
+        token_df[head_col]
+        .map(resolve_node)
+        )
+
+        # --------------------------------------------------
+        # 5. Remove tokens absorbed into merge groups
+        # --------------------------------------------------
+        merged_token_ids = set(token_to_merge.keys())
+
+        token_df = token_df[
+        ~token_df[new_tokens].isin(merged_token_ids)
+        ].copy()
+
+        # --------------------------------------------------
+        # 6. IMPORTANT:
+        #    If the resulting dataframe should contain the
+        #    merged nodes themselves, create one row per merge.
+        # --------------------------------------------------
+        merged_rows = []
+
+        for _, row in merge_df.iterrows():
+            merge_id = row[merge_id_col]
+            heads = row[merge_head_col]
+
+            # A merge can have multiple external heads.
+            for head in heads:
+                merged_rows.append({
+                new_tokens: merge_id,
+                head_col: head,
+                })
+
+        merged_token_df = pd.DataFrame(
+        merged_rows,
+        columns=[new_tokens, head_col]
+        )
+
+        # --------------------------------------------------
+        # 7. Combine normal tokens + merged nodes
+        # --------------------------------------------------
+        token_df = pd.concat(
+        [token_df, merged_token_df],
+        ignore_index=True,
+        )
+
+        return token_df, merge_df
+    

StickyText/Graph.py

@@ -0,0 +1,44 @@
+from .ModelManager import ModelManager
+from .Pipeline import Pipeline
+from .NodeMerge import NodeMerge
+from .BuildGraph import build_L2_graph, visualize_dependency_graph, subside_nodes 
+from .EdgeMerge import EdgeMerge
+from .NodeAttributes import NodeAttributes
+import pandas as pd
+
+def load_models():
+    return ModelManager() 
+
+def show_graph(text:str):
+    try:
+        model_manager = load_models()
+        token_df = Pipeline(text, 1, 1, model_manager, L3=True).process_text() 
+        if token_df is None:
+            print(f"No subject found in : {text}")
+            return 
+        token_df = token_df.drop(token_df[token_df["pos"] == "PUNCT"].index) 
+        nodes_merge = NodeMerge(token_df=token_df) 
+        coref_nodes_df = nodes_merge.coref_nodes() 
+        coref_nodes_df = NodeAttributes(token_df).noun_node_attributes(coref_nodes_df) 
+        verbs_nodes_df = nodes_merge.merge_nodes(merge_id_col='phrase_id',merge_text_col="verb_text")
+        verbs_nodes_df["attributes"] = None
+
+        coref_nodes_df['merge_id'] = coref_nodes_df['coref_id']
+        coref_nodes_df['merge_text'] = coref_nodes_df['representative_text'] 
+        coref_nodes_df['merge_token_ids'] = coref_nodes_df['coref_token_ids'] 
+        verbs_nodes_df['merge_id'] = verbs_nodes_df['phrase_id']
+        # aux nodes
+        aux_nodes = verbs_nodes_df.loc[verbs_nodes_df["merge_text"] == "", "merge_id"].tolist()
+
+        merge_df = pd.concat([verbs_nodes_df, coref_nodes_df], axis=0, join="inner") 
+
+        token_df, coref_nodes_df = EdgeMerge(token_df).head_to_merge(merge_df) 
+
+        G = build_L2_graph( coref_nodes_df, 'merge_id', 'merge_text', 'merge_head') 
+
+        G = subside_nodes(G, aux_nodes)
+
+        visualize_dependency_graph(G) 
+    except Exception as e:
+        print("Error in building the graph.")
+

StickyText/MergeCoref.py

@@ -0,0 +1,34 @@
+import pandas as pd 
+
+class MergeCoref:
+    def __init__(self, coref_df, doc_id, chunk_id):
+        self.coref_df = coref_df
+        self.doc_id = doc_id
+        self.chunk_id = chunk_id 
+
+    def _apply(self, row):
+        
+        matches = self.coref_df[
+        (self.coref_df["start_char"] < row["end"]) &
+        (self.coref_df["end_char"] > row["start"])
+        ]
+
+        if matches.empty:
+            return pd.Series({
+            "coref": None,
+            "representative_text": None,
+            "is_representative": False
+        })
+
+        # If multiple chains can overlap, preserve them
+        return pd.Series({
+        "coref": matches["coref"].tolist(),
+        "representative_text": matches["representative_text"].tolist(),
+        "is_representative": matches["is_representative"].tolist()
+        })
+
+    def merge(self, token_df):
+        token_df[
+        ["coref", "representative_text", "is_representative"]
+        ] = token_df.apply(self._apply, axis=1)
+        return token_df 

StickyText/MergeDF.py

@@ -0,0 +1,46 @@
+import pandas as pd
+
+
+
+class MergeDF:
+    def __init__(
+        self,
+        given_df,
+        token_start_col="start",
+        token_end_col="end",
+        given_start_col="start",
+        given_end_col="end",
+    ):
+        self.given_df = given_df
+        self.token_start_col = token_start_col
+        self.token_end_col = token_end_col
+        self.given_start_col = given_start_col
+        self.given_end_col = given_end_col
+
+    def _apply(self, row):
+        matches = self.given_df[
+            (self.given_df[self.given_start_col] < row[self.token_end_col]) &
+            (self.given_df[self.given_end_col] > row[self.token_start_col])
+        ]
+
+        # Only return columns that shouldn't overwrite token columns
+        merge_cols = [
+            col for col in self.given_df.columns
+            if col not in (self.given_start_col, self.given_end_col)
+        ]
+
+        if matches.empty:
+            return pd.Series({col: None for col in merge_cols})
+
+        return pd.Series({
+            col: matches[col].tolist()
+            for col in merge_cols
+        })
+
+    def merge(self, token_df):
+        merged_columns = token_df.apply(self._apply, axis=1)
+
+        for col in merged_columns.columns:
+            token_df[col] = merged_columns[col]
+
+        return token_df

StickyText/ModelManager.py

@@ -0,0 +1,34 @@
+
+from .model_config import MODELS
+from .load_models import download_spacy_model, load_spacy_model, load_stanza_pipe 
+
+class ModelManager:
+
+    def __init__(self):
+        self.config = MODELS 
+        self.models = {} 
+
+    def download(self, model_name):
+        model_config = self.config[model_name] 
+        if model_config['type'] == "spacy":
+            download_spacy_model(model_config['name'])
+            
+
+    def load(self, model_name):
+          model_config = self.config[model_name]
+        #try:
+          if model_config['type'] == "spacy":
+            model = load_spacy_model(model_config['name']) 
+            self.models[model_name] = model
+          elif model_config['type'] == "stanza":
+            model = load_stanza_pipe(model_config['name'], model_config['processor']) 
+          else:
+            raise Exception   
+          return model
+        #except Exception as e:
+        #  try:  
+        #    self.download(model_name) 
+        #  except Exception as e:
+        #     print("Error downloading model") 
+
+            

StickyText/NER.py

@@ -0,0 +1,41 @@
+""" 
+This is abstract class with methods initialize or load model , process text , process batch 
+""" 
+from .ModelManager import ModelManager 
+import pandas as pd 
+
+class NER: 
+    def __init__(self, model_manager: ModelManager, text:str): 
+        self.model_manager = model_manager 
+        self.text = text 
+
+    def process_text(self): 
+        """Returns DataFrame or JSON records with columns token_text (lower), 
+        sentence_num, token_num, pos, dep 
+        """ 
+        pass 
+
+class SpacyNER(NER): 
+    def __init__(self, model_manager, spacy_model_name, text_tokenizer, text): 
+        super().__init__(model_manager, text) 
+        self.model_name = spacy_model_name 
+        self.model_manager.load(self.model_name) 
+        self.text_tokenizer = text_tokenizer 
+    def process_text(self, res): 
+        # self.res = self.model_manager.models[self.model_name](self.text) 
+      try:
+        self.res = res 
+        df = pd.DataFrame(self.res.to_json()["ents"])[['start','end',"label"]] 
+        df.rename(columns={'label':'ner'}, inplace=True)
+        return df 
+      except Exception as e:
+          return None
+
+class SpacyNounPhrases:
+    def __init__(self, text_tokenizer):
+        self.text_tokenizer = text_tokenizer
+
+    def process_text(self):
+        return list(self.text_tokenizer.res.noun_chunks) 
+
+

StickyText/NodeAttributes.py

@@ -0,0 +1,17 @@
+
+class NodeAttributes: 
+    def __init__(self, token_df): 
+        self.token_df = token_df 
+
+    def noun_node_attributes(self, coref_nodes_df, coref_token_ids_col="coref_token_ids"): 
+        def get_attributes(row): 
+            token_ids = row[coref_token_ids_col] 
+
+            matched = self.token_df[self.token_df["token_id"].isin(token_ids)] 
+
+            return matched.loc[matched["pos"] != "PRON", "text"].tolist() 
+        
+        coref_nodes_df["attributes"] = coref_nodes_df.apply(get_attributes, axis=1) 
+        return coref_nodes_df 
+
+

StickyText/NodeMerge.py

@@ -0,0 +1,87 @@
+import pandas as pd
+
+class NodeMerge:
+    def __init__(self, token_df):
+        self.token_df = token_df
+
+    def noun_phrase_nodes(self, noun_phrase_column = "noun_phrase"):
+        self.token_df[noun_phrase_column] = self.token_df[noun_phrase_column].apply(
+            lambda x: x[0] if isinstance(x, (list, tuple)) else x
+        )
+        noun_df = (
+        self.token_df
+        .groupby(["noun_phrase", "chunk_id", "doc_id"], sort=False, as_index=False)
+        .agg(token_ids=("token_id", list))
+        .reset_index(drop=True) 
+        )
+
+        noun_df.insert(0, "noun_id", range(len(noun_df)))
+        return noun_df
+
+    def coref_nodes(self):
+        self.token_df["coref_id"] = self.token_df["coref"].apply(
+        lambda x: f"nn_{int(x[0])}" if isinstance(x, (list, tuple)) else x
+        )
+        self.token_df["representative_text"] = self.token_df["representative_text"].apply(
+            lambda x: x[0] if isinstance(x, (list, tuple)) else x
+        )
+        self.token_df["is_representative"] = self.token_df["is_representative"].apply(
+            lambda x: x[0] if isinstance(x, (list, tuple)) else x
+        )
+
+        coref_df = (
+        self.token_df
+        .groupby(["coref_id", "chunk_id", "doc_id"], sort=False, as_index=False)
+        .agg(
+        representative_text=("representative_text", "first"),
+        representative_text_token_ids=(
+            "token_id",
+            lambda x: list(x)
+            ),
+            coref_token_ids=("token_id", list)
+        )
+        )
+        coref_df = (
+        self.token_df
+    .groupby(["coref_id", "chunk_id", "doc_id"], sort=False)
+    .apply(
+        lambda g: pd.Series({
+            # "token_id":g["coref_id"],
+             "text": g["representative_text"].iloc[0],
+            "representative_text": g["representative_text"].iloc[0],
+            "representative_text_token_ids": g.loc[
+                g["is_representative"], "token_id"
+            ].tolist(),
+            "coref_token_ids": g["token_id"].tolist(),
+            "ner":g['ner'].iloc[0] , 
+           # "coref_head_ids":g['head'].tolist(),
+        }) 
+    )
+    .reset_index()
+    )
+        #coref_df['coref_id'] = coref_df['coref_id'].astype('int')
+        return coref_df 
+
+    def merge_nodes(self, merge_id_col = "merge_id", merge_text_col = "merge_text"):
+            self.token_df[merge_id_col] = self.token_df[merge_id_col].apply(
+                lambda x: x[0] if isinstance(x, (list, tuple)) else x
+            )
+            self.token_df[merge_text_col] = self.token_df[merge_text_col].apply(
+                            lambda x: x[0] if isinstance(x, (list, tuple)) else x
+                        )
+            merge_df = (
+                self.token_df
+                    .groupby(
+                     [merge_id_col, "chunk_id", "doc_id"],
+                    sort=False,  as_index=False
+                    )
+                    .agg(
+                    merge_text = (merge_text_col, "first"),  
+                    merge_token_ids=("token_id", list),
+                    merge_heads=("head", list), 
+                    #pos = ('pos', " ".join),
+                    )
+            ) 
+            #noun_df.insert(0, "noun_id", range(len(noun_df))) 
+            return merge_df 
+

StickyText/NounPhrases.py

@@ -0,0 +1,26 @@
+from .DepParse import SpacyDepParser
+from .TextTokenizer import TextTokenizer
+import pandas as pd
+
+class NounPhrases:
+    def __init__(self, text_tokenizer: TextTokenizer):
+        self.text_tokenizer = text_tokenizer
+
+    def process_text(self, res):
+        noun_chunks = res.noun_chunks 
+        
+        noun_df = pd.DataFrame(
+                {
+                "noun_phrase": str(chunk.text).strip().lower(), 
+                "start": chunk.start_char,
+                "end": chunk.end_char,
+                #"start_token": chunk.start,
+                #"end_token":chunk.end,
+                
+                }
+                for chunk in noun_chunks
+                
+                )
+        return noun_df
+
+

StickyText/NounPhrasesAppend.py

@@ -0,0 +1,28 @@
+import pandas as pd
+
+class NounPhrasesAppend:
+    def __init__(self):
+        pass
+
+    def add_missing_nouns(self, coref_df, noun_df, representative_text_col='representative_text',
+                          is_representative_col='is_representative'):
+        
+        noun_df = noun_df.rename(columns={'start':'start_char','end':'end_char'})
+
+        def check_missed(ref_row, df_sec):
+            # Returns True if ANY span in df_sec overlaps with the current ref_row
+            overlap = (df_sec["start_char"] < ref_row["end_char"]) & (df_sec["end_char"] > ref_row["start_char"])
+            return overlap.any()
+
+        # Apply the function across rows axis=1, then filter where it evaluates to False (completely missed)
+        missed_mask = ~noun_df.apply(lambda row: check_missed(row, coref_df), axis=1)
+
+        df_to_add = noun_df[missed_mask]
+        if df_to_add is not None:   
+            df_to_add['coref'] = df_to_add.reset_index(drop=True).index + len(coref_df)
+            df_to_add[is_representative_col] = True
+            df_to_add.rename(columns={'noun_phrase':representative_text_col,}, inplace=True)
+            coref_df = pd.concat([coref_df, df_to_add], axis=0, join="outer") 
+            return coref_df
+        return coref_df 
+        

StickyText/PhrasalVerbs.py

@@ -0,0 +1,58 @@
+import pandas as pd 
+from nltk.stem import PorterStemmer 
+
+class PhrasalVerbs:
+    def __init__(self, token_df):
+        self.token_df = token_df
+
+    def phrasal_verbs_df(self, include_start=True, include_end=True):
+        df = self.token_df.copy().sort_values("token_id").reset_index(drop=True)
+
+        coref_indices = df.index[df["coref"].notna()].tolist()
+        length = len(self.token_df)
+
+        spans = list(zip(coref_indices, coref_indices[1:]))
+
+        _ = spans.insert(0, (-1, coref_indices[0]))  if include_start else None
+
+        _ =   spans.append((coref_indices[-1], length)) if include_end else None
+
+        between = [
+                list(range(a + 1, b))
+                    for a, b in spans
+                        if a + 1 < b
+                        ] 
+        cluster_map = dict(enumerate(between))
+
+        verbs_df = (
+            pd.DataFrame(cluster_map.items(), columns=["phrase_id", "token_id"])
+        .explode("token_id")
+        .reset_index(drop=True)
+        )               
+        verbs_df['phrase_id'] = verbs_df['phrase_id'].apply(lambda x: f"vv_{x}") 
+        token_df = self.token_df.merge( verbs_df,  on="token_id",  how="left" )  
+        #remove helping verbs or AUX
+        token_df.loc[token_df["pos"] == "AUX", "text"] = "" 
+        verbs_df = (  token_df
+                            .groupby(
+                             ["phrase_id", "chunk_id", "doc_id"],
+                            sort=False,  as_index=False
+                            )
+                            .agg(
+                            #verb_token_ids=("token_id", list),
+                            verb_text=("text", " ".join),
+                            start=("start", "min"),
+                            end=("end", "max"),
+                            )
+                    ) 
+        verbs_df = verbs_df.drop(columns=['chunk_id', 'doc_id']) 
+        # handle isolated aux 
+        verbs_df['aux'] = None
+        verbs_df.loc[verbs_df["verb_text"] == "", "aux"] = "AUX"
+        #verbs_df["verb_text"] = verbs_df["verb_text"].replace("", "#be-form")
+        # stem
+        stemmer = PorterStemmer()
+        verbs_df["verb_text"] = verbs_df["verb_text"].apply(lambda x: stemmer.stem(x) if isinstance(x, str) else x)
+
+        return verbs_df 
+

StickyText/Pipeline.py

@@ -0,0 +1,48 @@
+from .CoRef import CoRef
+from .MergeCoref import MergeCoref
+from .MergeDF import MergeDF
+from .NER import NER, SpacyNER
+from .NounPhrases import NounPhrases
+from .NounPhrasesAppend import NounPhrasesAppend
+from .PhrasalVerbs import PhrasalVerbs 
+from .TextTokenizer import TextTokenizer
+from .SpacyProcess import SpacyProcess
+
+class Pipeline: 
+    def __init__(self, text:str, doc_id, chunk_id, model_manager, L3=False): 
+        self.spacy_process = SpacyProcess(text, doc_id,chunk_id, "dep_parse", model_manager)
+        self.text_tokenizer = TextTokenizer(text, chunk_id, doc_id) 
+        self.coref = CoRef(model_manager, "coref", text, doc_id, chunk_id) 
+        self.ner = SpacyNER(model_manager, "dep_parse", self.text_tokenizer, text) 
+        self.noun_phrases = NounPhrases(self.text_tokenizer) 
+        self.L3 = L3 
+        self.merge_coref = None 
+        self.merge_df = None 
+
+    def process_text(self): 
+      try: 
+        coref_df = self.coref.process_text() 
+        res = self.spacy_process.process_text()
+        token_df = self.text_tokenizer.process_text(res=res) 
+        noun_df = self.noun_phrases.process_text(res) 
+        coref_df = NounPhrasesAppend().add_missing_nouns(coref_df, noun_df) 
+        token_df = MergeCoref(coref_df=coref_df, doc_id=None, chunk_id=None).merge(token_df=token_df) 
+        del coref_df
+        
+        token_df = MergeDF(given_df=noun_df ).merge(token_df=token_df) 
+        ner_df = self.ner.process_text(res) 
+        if ner_df is not None:
+            token_df = MergeDF(given_df=ner_df).merge(token_df=token_df) 
+        else:
+            token_df['ner'] = None
+        if self.L3:
+            verbs_df = PhrasalVerbs(token_df).phrasal_verbs_df() 
+            token_df = MergeDF(verbs_df).merge(token_df=token_df) 
+            return token_df
+        return token_df 
+      except Exception as e: 
+         print("Error while processing text.") 
+         return None
+
+
+        

StickyText/SpacyProcess.py

@@ -0,0 +1,17 @@
+"""
+This class tokenize text and creates dataframe with doc_id, chunk_id, sentence_num, token_num, text (lower), start, end
+"""
+
+class SpacyProcess:
+    def __init__(self, text:str, doc_id, chunk_id, spacy_model_name, model_manager):
+        self.text = text
+        self.doc_id = doc_id
+        self.chunk_id = chunk_id
+        self.model_name = spacy_model_name 
+        self.model_manager = model_manager
+        self.model_manager.load(self.model_name) 
+
+    def process_text(self):
+        self.res = self.model_manager.load(self.model_name)(self.text) 
+    
+        return self.res

StickyText/TextTokenizer.py

@@ -0,0 +1,21 @@
+"""
+This class tokenize text and creates dataframe with doc_id, chunk_id, sentence_num, token_num, text (lower), start, end
+"""
+import pandas as pd
+
+class TextTokenizer:
+    def __init__(self, text:str, chunk_id, doc_id):
+        self.text = text 
+        self.chunk_id = chunk_id
+        self.doc_id = doc_id
+        
+    def process_text(self, res):
+        self.res = res  # self.model_manager.load(self.model_name)(self.text) 
+        df = pd.DataFrame(self.res.to_json()["tokens"])[['id','start','end',"head","pos", "dep"]] 
+        df.rename(columns={'id':'token_id'}, inplace=True)
+        df['text'] = df.apply(lambda r: self.text[int(r['start']) : int(r['end'])], axis=1)
+        df['text'] = df['text'].str.lower().str.strip() 
+        df['chunk_id'] = self.chunk_id
+        df['doc_id'] = self.doc_id 
+
+        return df 

StickyText/__init__.py

@@ -0,0 +1,3 @@
+from .Graph import show_graph
+
+__all__ = ["show_graph"]

StickyText/load_models.py

@@ -0,0 +1,24 @@
+import spacy
+import subprocess, sys 
+import stanza
+from functools import cache
+
+
+def download_spacy_model(model_name):
+    subprocess.run([sys.executable, "-m", "spacy", "download", model_name]) 
+
+@cache
+def load_spacy_model(model_name):
+    try:
+        nlp = spacy.load(model_name)
+    except Exception as e:
+        download_spacy_model(model_name)
+        try:
+            nlp = load_spacy_model(model_name)
+        except Exception as e:
+            print("Error: Cannot download the model.")
+    return nlp
+
+@cache
+def load_stanza_pipe(lang, processors):
+    return stanza.Pipeline(lang, processors=processors, verbose=False)

StickyText/model_config.py

@@ -0,0 +1,14 @@
+
+MODELS = {
+    "dep_parse": {
+        "type": "spacy",
+        "name": "en_core_web_sm",
+        "cache_dir": "~/.stickY-text/models",
+    },
+    "coref": {
+        "type": "stanza",
+        "name": "en",
+        "processor": "tokenize,coref",
+        "cache_dir": "~/.stickY-text/models",
+    },
+}

stickytext-0.1.1.dist-info/METADATA

@@ -0,0 +1,70 @@
+Metadata-Version: 2.4
+Name: StickyText
+Version: 0.1.1
+Summary: A package for building and visualizing dependency graphs.
+Author-email: Yoga Harshitha D <harshithad731@gmail.com>
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: Licence.md
+Requires-Dist: networkx
+Requires-Dist: pandas
+Requires-Dist: spacy
+Requires-Dist: nltk
+Requires-Dist: stanza
+Requires-Dist: transformers
+Requires-Dist: peft
+Requires-Dist: matplotlib
+Dynamic: license-file
+
+# `sticky-text`
+
+A Python package for building and visualizing linguistic dependency graphs from text using custom NLP pipelines and model managers.
+
+---
+
+## Features
+
+* **Automated Text Processing:** Runs end-to-end text processing pipelines directly from input text.
+* **Triplet Style Knowledge Graph Construction:** Builds entity and dependency graphs from the data.
+* **Dependency Graph Visualization:** Generates visual graphs showing token relationships and coreferences.
+
+---
+
+## Installation
+
+Install the package directly using `pip`:
+
+```bash
+pip install sticky-text
+
+```
+
+
+## Quickstart
+
+The package exposes a single entry-point function, `show_graph`:
+
+```python
+from StickyText import show_graph
+
+# Process text and visualize the generated dependency graph
+text = "Alice went to the store. She bought some apples."
+show_graph(text)
+
+```
+
+---
+
+## Package Architecture
+
+```text
+your_package_name/
+├── __init__.py          # Main entry point exposing show_graph
+├── ModelManager.py      # Manages NLP model initialization and loading
+├── Pipeline.py          # Executes text processing pipelines
+└── BuildGraph.py        # Handles graph construction and network visualization
+
+```
+## About this version
+
+This is a free and trial version. For large documents and premium features contact author. 

stickytext-0.1.1.dist-info/RECORD

@@ -0,0 +1,25 @@
+StickyText/BuildGraph.py,sha256=2Tuu5hhtZEmV5ag-6qO3FuV3jf6LW0r8vwbGL6bvrdM,3561
+StickyText/CoRef.py,sha256=Law3ndj5vJgkWX8iSZoIbNM1hJWnk5jnR_Jl4BSKoJA,1308
+StickyText/DepParse.py,sha256=wV2gbjv4SnWgs4tqSfrXcc3CvbhA_OgCh_sd8_otf7A,991
+StickyText/EdgeMerge.py,sha256=3abvSLXN3UayfCY8BHUVBraegd6-lrbOAtY3iVE4nuI,11272
+StickyText/Graph.py,sha256=6oYejtqIho75k48Lc0y45A5B9cuEhNdBRpNIQXToXtk,1855
+StickyText/MergeCoref.py,sha256=j508qLyPlSKL3T4R4Vnl9SBYdCmQjl3FCJRNWVOk_3w,1043
+StickyText/MergeDF.py,sha256=cW-icvLDdUVhX6P9pesQ0iT1zuQ0iKxIfZ3kn-CZTgk,1335
+StickyText/ModelManager.py,sha256=OrP4X5YpRAYJek74v35MXTVSwTWrEMugtu1_UmTF3Do,1086
+StickyText/NER.py,sha256=lNGeC1yrpXy1bplorTmzHlgHTVxa3Pm-GAH30Dpaakc,1372
+StickyText/NodeAttributes.py,sha256=p80_eope6QBay_cv-H8JNea_bWxki6TTozNsbAhIFOM,571
+StickyText/NodeMerge.py,sha256=_FO5QdHc-hXZ0tRAIxbVkVwUdo6wtkICdjxpk0f_87Q,3338
+StickyText/NounPhrases.py,sha256=Lj2JTU_MqKTnv5ntiaI6eOM9r6DjKSzkLBlE8E3bhnU,744
+StickyText/NounPhrasesAppend.py,sha256=Wp4GJEo6ggZG6RmsrYmcuDjd88_VXjVcL82XzAyqJt0,1292
+StickyText/PhrasalVerbs.py,sha256=x02B3wetgWkNeFkV4g0Nde6ZIb6Vl8Wu255Iu1ncymI,2333
+StickyText/Pipeline.py,sha256=J48BW20NV3mnGiSCOkobTvGWXl0IeQINN5Xh2qO3VJE,1989
+StickyText/SpacyProcess.py,sha256=VHqJankXn7DYkELYSjwWLMKXgM-n8f4vTvPIbDQY98s,605
+StickyText/TextTokenizer.py,sha256=QBu93pFYM5WC0bjOriItv6FCuP9GrTtugaf9XK_UH4I,854
+StickyText/__init__.py,sha256=Q47vpfQ7_9cMlkFB0mvKW_GMUhB1Z9c3-G34gYDWl_c,57
+StickyText/load_models.py,sha256=MSH-RxWPchp0aXnShiVbVzkv1fliLZ0939dDr7jK5q8,656
+StickyText/model_config.py,sha256=t_6P4ELmQMYyQcizvsugaUbG8GTmI5U1AXZlk3G5FVw,312
+stickytext-0.1.1.dist-info/licenses/Licence.md,sha256=Wu3M8G8ovXxcdSPlUw5IbDEC0o8RkYSC4xjybmxPw1U,4637
+stickytext-0.1.1.dist-info/METADATA,sha256=GFCsbQJxlNVCM8t5zZLDEkOoWNiANGv2owSXuiXDLHM,1871
+stickytext-0.1.1.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+stickytext-0.1.1.dist-info/top_level.txt,sha256=cFZ_lHIuNP8ePwPH1-SqSIamgWlrdulsPUDOTl8Z0Fs,16
+stickytext-0.1.1.dist-info/RECORD,,

stickytext-0.1.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

stickytext-0.1.1.dist-info/licenses/Licence.md

@@ -0,0 +1,89 @@
+# Proprietary Software License
+
+**Copyright © 2026 Yoga Harshitha D. All Rights Reserved.**
+
+This software package, including all source code, object code, documentation, files, modules, and related materials (collectively, the **"Software"**) is proprietary property of **Yoga Harshitha D.**
+
+## 1. Grant of License
+
+Subject to the terms of this license, Yoga Harshitha D. grants the authorized user a limited, non-exclusive, non-transferable, non-sublicensable license to **install and use** the Software solely for its intended purpose.
+
+This license does not transfer ownership of the Software or any intellectual property rights to the user.
+
+## 2. Restrictions
+
+Except with prior written permission from Yoga Harshitha D., you **may not**:
+
+* Copy, reproduce, duplicate, or redistribute the Software or any portion of it.
+* Modify, alter, adapt, translate, or create derivative works from the Software.
+* Publish, distribute, sell, rent, lease, sublicense, or transfer the Software.
+* Share the Software with any unauthorized third party.
+* Upload, mirror, or redistribute the Software through public or private package repositories.
+* Include the Software or any portion of it in another software package or product.
+* Remove, alter, or obscure copyright, license, or proprietary notices.
+* Reverse engineer, decompile, disassemble, or attempt to derive the source code, algorithms, or underlying implementation of the Software, except where such restriction is prohibited by applicable law.
+* Use the Software to create a competing product or service.
+* Use the Software outside the scope of the license granted to you.
+
+## 3. Ownership and Intellectual Property
+
+The Software and all associated intellectual property rights remain the exclusive property of **Yoga Harshitha D.**
+
+No copyright, patent, trademark, trade secret, or other intellectual property rights are transferred or assigned to the user by this license.
+
+All rights not expressly granted under this license are reserved.
+
+## 4. Source Code
+
+The source code of the Software is proprietary.
+
+Possession of a copy of the Software does not grant any right to access, obtain, copy, modify, or redistribute its source code.
+
+Any attempt to circumvent technical measures intended to protect the Software or its source code is prohibited, except where such restriction is prohibited by applicable law.
+
+## 5. Third-Party Components
+
+The Software may contain or depend upon third-party libraries, packages, or other components.
+
+Such components remain subject to their respective licenses. This license does not modify or restrict rights granted by applicable third-party licenses.
+
+## 6. Termination
+
+This license automatically terminates if you materially breach any of its terms.
+
+Upon termination, you must immediately cease using the Software and delete copies of the Software in your possession or control, to the extent permitted and required by applicable law.
+
+Termination does not limit any other rights or remedies available to Yoga Harshitha D.
+
+## 7. Disclaimer of Warranty
+
+THE SOFTWARE IS PROVIDED **"AS IS"** AND **"AS AVAILABLE"**, WITHOUT WARRANTIES OF ANY KIND, EXPRESS OR IMPLIED, TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW.
+
+Yoga Harshitha D. disclaims all warranties, including but not limited to warranties of merchantability, fitness for a particular purpose, accuracy, title, and non-infringement.
+
+## 8. Limitation of Liability
+
+TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, YOGA HARSHITHA D. SHALL NOT BE LIABLE FOR ANY INDIRECT, INCIDENTAL, SPECIAL, CONSEQUENTIAL, EXEMPLARY, OR PUNITIVE DAMAGES ARISING OUT OF OR RELATING TO THE USE OF THE SOFTWARE.
+
+## 9. Governing Law
+
+This license shall be governed by and construed in accordance with the laws of **India**.
+
+Subject to applicable law, disputes arising out of or relating to this license shall be subject to the jurisdiction of the competent courts in **Bengaluru, Karnataka, India**.
+
+## 10. No Implied Rights
+
+No rights are granted by implication, estoppel, or otherwise.
+
+Any permission to copy, modify, distribute, sublicense, or otherwise use the Software beyond the rights expressly granted in this license must be obtained through prior written authorization from **Yoga Harshitha D.**
+
+## 11. Reservation of Rights
+
+**Yoga Harshitha D. reserves all rights not expressly granted under this license.**
+
+Unauthorized copying, modification, distribution, redistribution, or use of the Software is prohibited.
+
+---
+
+**Copyright © 2026 Yoga Harshitha D.**
+**All Rights Reserved.**

stickytext-0.1.1.dist-info/top_level.txt

@@ -0,0 +1,2 @@
+StickyText
+dist