hina 0.1__tar.gz

hina-0.1/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2012-2024 Scott Chacon and others
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

hina-0.1/PKG-INFO

@@ -0,0 +1,88 @@
+Metadata-Version: 2.2
+Name: hina
+Version: 0.1
+Summary: Heterogenous Interaction Network Analysis in Python
+Home-page: https://hina.readthedocs.io/en/latest/index.html
+Author: Shihui Feng, Baiyue He, Alec Kirkley
+Author-email: shihuife@hku.hk, baiyue.he@connect.hku.hk, akirkley@hku.hk
+License: The MIT License
+Project-URL: Documentation, https://hina.readthedocs.io/en/latest/index.html
+Project-URL: Source, https://hina.readthedocs.io/en/latest/index.html
+Requires-Python: >=3.9, <3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE.txt
+Requires-Dist: numpy>=1.24
+Requires-Dist: pandas>=2.2
+Requires-Dist: scipy>=1.10
+Requires-Dist: scikit-network==0.32.1
+Requires-Dist: dash<=3.0.0
+Dynamic: author
+Dynamic: author-email
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license
+Dynamic: project-url
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# BNApy (Bipartite Network Analysis)
+
+HINA is a learning analytics tool that models and analyzes heterogenous interactions during learning. Heterogenous interactions refer to the interactions occurring between different types of entities during learning processes, such as students’ interactions with learning objects or students’ display of different behaviors coded using multimodal process data. These heterogenous interactions can be modelled with heterogenous interaction networks that consist of different sets of nodes and edges connecting nodes from different sets. Each node in a heterogenous interaction network can represent any meaningful entity reflecting a certain object or construct in a learning process, such as a student, group of students, coded behavior, or learning artefact. Edges in the network pair nodes from different sets and can reflect affiliations, associations, or interactions among the nodes for modeling a specific learning process. Heterogenous interaction networks offer a flexible, adaptive, and widely applicable method to model a wide variety of interactions that can occur during the learning processes, across individual learning, group learning, and community learning. 
+
+## Features
+
+- **Individual-level Analysis**: Provides functions to compute the node-level measures of gauging the quantity and diversity of individuals’ interactions in the learning process. New package contributions can incorporate other node-level measures for understanding individuals’ interaction patterns.
+- **Dyadic Analysis**: Provides methods to identify statistically significant edges in the heterogeneous interaction network relative to multiple different null models of interaction structure, which can be specified by the user. New package contributions can incorporate other dyad-level analyses for understanding interaction patterns among pairs of nodes.
+- **Mesoscale Clustering**: Provides methods for clustering nodes in a bipartite projection of the heterogeneous interaction network according to shared interaction structure, automatically learning the number of clusters from heterogeneity in the interaction data to find a mesoscale representation. New package contributions can incorporate other measures for understanding the mesoscale structure of the interaction network.
+- **Visualization**: Provides network visualization functions for networks at the group level or cohort level that enable the user to easily project the heterogeneous interaction network onto any subset of node types (e.g. students, tasks, behavioral codes). These methods allow for the inclusion of various metadata such as inferred student clusters or contribution metrics, as well as pruning of the interaction network to identify significant interaction structure. Also enables visualization with Sankey diagrams for an alternative representation of the weighted networks. These visualizations come together with a web-based interface that enables interactions and user engagement. New package contributions can incorporate other relevant metadata for visualization, as well as other preprocessing tools for augmenting or modifying the network structure to highlight particular features.
+- **Web Interface**: Includes a web-based interface for engaging with the visualizations.
+- **Extensibility**: Easily incorporate additional measures, clustering methods, or visualizations.
+
+
+## Installation
+
+To install BNA, you can use `pip` from the PyPI repository:
+
+```bash
+pip install bna
+
+BNA_Package/
+├── __init__.py
+├── individual/
+│   ├── __init__.py
+│   ├── quantity_diversity.py    
+│   └── tests/                   
+│       ├── __init__.py
+│       └── test_quantity_diversity.py
+├── dyad/
+│   ├── __init__.py
+│   ├── significant_edges.py     
+│   └── tests/                  
+│       ├── __init__.py
+│       └── test_significant_edges.py
+├── mesoscale/
+│   ├── __init__.py
+│   ├── clustering.py            
+│   └── tests/                  
+│       ├── __init__.py
+│       └── test_clustering.py
+├── visualization/
+│   ├── __init__.py
+│   ├── network_visualization.py 
+│   ├── web_interface.py         
+│   └── tests/                   
+│       ├── __init__.py
+│       └── test_network_visualization.py
+├── utils/
+│   ├── __init__.py
+│   ├── graph_tools.py        
+│   ├── plot_tools.py          
+│   └── tests/
+│       ├── __init__.py
+│       ├── test_graph_tools.py
+│       └── test_plot_tools.py
+├── data/                       
+    ├── __init__.py
+    └── synthetic_data.csv

hina-0.1/README.md

@@ -0,0 +1,59 @@
+# BNApy (Bipartite Network Analysis)
+
+HINA is a learning analytics tool that models and analyzes heterogenous interactions during learning. Heterogenous interactions refer to the interactions occurring between different types of entities during learning processes, such as students’ interactions with learning objects or students’ display of different behaviors coded using multimodal process data. These heterogenous interactions can be modelled with heterogenous interaction networks that consist of different sets of nodes and edges connecting nodes from different sets. Each node in a heterogenous interaction network can represent any meaningful entity reflecting a certain object or construct in a learning process, such as a student, group of students, coded behavior, or learning artefact. Edges in the network pair nodes from different sets and can reflect affiliations, associations, or interactions among the nodes for modeling a specific learning process. Heterogenous interaction networks offer a flexible, adaptive, and widely applicable method to model a wide variety of interactions that can occur during the learning processes, across individual learning, group learning, and community learning. 
+
+## Features
+
+- **Individual-level Analysis**: Provides functions to compute the node-level measures of gauging the quantity and diversity of individuals’ interactions in the learning process. New package contributions can incorporate other node-level measures for understanding individuals’ interaction patterns.
+- **Dyadic Analysis**: Provides methods to identify statistically significant edges in the heterogeneous interaction network relative to multiple different null models of interaction structure, which can be specified by the user. New package contributions can incorporate other dyad-level analyses for understanding interaction patterns among pairs of nodes.
+- **Mesoscale Clustering**: Provides methods for clustering nodes in a bipartite projection of the heterogeneous interaction network according to shared interaction structure, automatically learning the number of clusters from heterogeneity in the interaction data to find a mesoscale representation. New package contributions can incorporate other measures for understanding the mesoscale structure of the interaction network.
+- **Visualization**: Provides network visualization functions for networks at the group level or cohort level that enable the user to easily project the heterogeneous interaction network onto any subset of node types (e.g. students, tasks, behavioral codes). These methods allow for the inclusion of various metadata such as inferred student clusters or contribution metrics, as well as pruning of the interaction network to identify significant interaction structure. Also enables visualization with Sankey diagrams for an alternative representation of the weighted networks. These visualizations come together with a web-based interface that enables interactions and user engagement. New package contributions can incorporate other relevant metadata for visualization, as well as other preprocessing tools for augmenting or modifying the network structure to highlight particular features.
+- **Web Interface**: Includes a web-based interface for engaging with the visualizations.
+- **Extensibility**: Easily incorporate additional measures, clustering methods, or visualizations.
+
+
+## Installation
+
+To install BNA, you can use `pip` from the PyPI repository:
+
+```bash
+pip install bna
+
+BNA_Package/
+├── __init__.py
+├── individual/
+│   ├── __init__.py
+│   ├── quantity_diversity.py    
+│   └── tests/                   
+│       ├── __init__.py
+│       └── test_quantity_diversity.py
+├── dyad/
+│   ├── __init__.py
+│   ├── significant_edges.py     
+│   └── tests/                  
+│       ├── __init__.py
+│       └── test_significant_edges.py
+├── mesoscale/
+│   ├── __init__.py
+│   ├── clustering.py            
+│   └── tests/                  
+│       ├── __init__.py
+│       └── test_clustering.py
+├── visualization/
+│   ├── __init__.py
+│   ├── network_visualization.py 
+│   ├── web_interface.py         
+│   └── tests/                   
+│       ├── __init__.py
+│       └── test_network_visualization.py
+├── utils/
+│   ├── __init__.py
+│   ├── graph_tools.py        
+│   ├── plot_tools.py          
+│   └── tests/
+│       ├── __init__.py
+│       ├── test_graph_tools.py
+│       └── test_plot_tools.py
+├── data/                       
+    ├── __init__.py
+    └── synthetic_data.csv

hina-0.1/hina/__init__.py

@@ -0,0 +1 @@
+from . import individual, dyad, mesoscale, visualization, utils

hina-0.1/hina/app/__init__.py

@@ -0,0 +1 @@
+from .app import *

hina-0.1/hina/app/app.py

@@ -0,0 +1,502 @@
+import base64
+import io
+import dash
+from dash import dcc, html, Input, Output, State, no_update
+import dash_cytoscape as cyto
+import dash_table
+import pandas as pd
+import networkx as nx
+from bnapy.dyad.significant_edges import prune_edges
+from bnapy.mesoscale.clustering import cluster_nodes
+from bnapy.individual.quantity_diversity import get_bipartite, quantity_and_diversity
+
+#############################
+# Helper Functions
+#############################
+
+def parse_contents(contents, filename):
+    """Decodes an uploaded CSV file and returns a DataFrame."""
+    content_type, content_string = contents.split(',')
+    decoded = base64.b64decode(content_string)
+    try:
+        df = pd.read_csv(io.StringIO(decoded.decode('utf-8')))
+    except Exception as e:
+        return None, f"Error processing file: {str(e)}"
+    return df, f"{filename} uploaded successfully!"
+
+def build_hina_network(df, group, attribute_1, attribute_2, pruning, layout):
+    """
+    Build a NetworkX graph for the HINA network using bnapy logic.
+    Node labels are converted to strings.
+    """
+    if attribute_1 is None or attribute_2 is None:
+        raise ValueError("Both attribute_1 and attribute_2 must be specified.")
+    if group != 'All':
+        df = df[df['group'] == group]
+    
+    G = nx.Graph()
+    for _, row in df.iterrows():
+        n1 = str(row[attribute_1])
+        n2 = str(row[attribute_2])
+        weight = row.get('task weight', 1)
+        G.add_node(n1)
+        G.add_node(n2)
+        G.add_edge(n1, n2, weight=weight)
+    
+    # Apply pruning if specified.
+    if pruning != "none":
+        edge_tuples = [(u, v, d['weight']) for u, v, d in G.edges(data=True)]
+        if isinstance(pruning, dict):
+            significant_edges = prune_edges(edge_tuples, **pruning)
+        else:
+            significant_edges = prune_edges(edge_tuples)
+        G_new = nx.Graph()
+        for u, v, w in significant_edges:
+            G_new.add_edge(u, v, weight=w)
+        G = G_new
+
+    # Set node attributes and colors.
+    for node in G.nodes():
+        if node in df[attribute_1].astype(str).values:
+            G.nodes[node]['type'] = 'attribute_1'
+            G.nodes[node]['color'] = 'blue'
+        elif node in df[attribute_2].astype(str).values:
+            G.nodes[node]['type'] = 'attribute_2'
+            G.nodes[node]['color'] = 'grey'
+        else:
+            G.nodes[node]['type'] = 'unknown'
+            G.nodes[node]['color'] = 'black'
+    
+    # Compute layout positions.
+    if layout == 'bipartite':
+        attribute_1_nodes = {n for n, d in G.nodes(data=True) if d['type'] == 'attribute_1'}
+        if not nx.is_bipartite(G):
+            raise ValueError("The graph is not bipartite; check the input data.")
+        pos = nx.bipartite_layout(G, attribute_1_nodes, align='vertical', scale=2, aspect_ratio=4)
+    elif layout == 'spring':
+        pos = nx.spring_layout(G, k=0.2)
+    elif layout == 'circular':
+        pos = nx.circular_layout(G)
+    else:
+        raise ValueError(f"Unsupported layout: {layout}")
+    return G, pos
+
+def cy_elements_from_graph(G, pos):
+    """
+    Convert a NetworkX graph and positions into Cytoscape elements.
+    All node IDs are forced to strings.
+    """
+    elements = []
+    for node, data in G.nodes(data=True):
+        node_str = str(node)
+        x = pos[node][0] * 400 + 300
+        y = pos[node][1] * 400 + 300
+        elements.append({
+            'data': {'id': node_str, 'label': node_str},
+            'position': {'x': x, 'y': y},
+            'classes': data.get('type', '')
+        })
+    for u, v, d in G.edges(data=True):
+        elements.append({
+            'data': {'source': str(u), 'target': str(v), 'weight': d.get('weight', 1)}
+        })
+    return elements
+
+def build_clustered_network(df, group, attribute_1, attribute_2, clustering_method, pruning="none", layout="spring"):
+    """
+    Build a clustered bipartite network using bnapy's get_bipartite and cluster_nodes.
+    An optional pruning parameter (either "none" or a dict) is applied before clustering.
+    All node IDs are cast to strings.
+    """
+    if attribute_1 is None or attribute_2 is None:
+        raise ValueError("Both attribute_1 and attribute_2 must be specified.")
+    if group != 'All':
+        df = df[df['group'] == group]
+    
+    G_edges = get_bipartite(df, attribute_1, attribute_2)
+    if pruning != "none":
+        edge_tuples = list(G_edges)
+        if isinstance(pruning, dict):
+            pruned = prune_edges(edge_tuples, **pruning)
+        else:
+            pruned = prune_edges(edge_tuples)
+        G_edges = pruned
+    cluster_labels = cluster_nodes(G_edges, method=clustering_method)
+    nx_G = nx.Graph()
+    for edge in G_edges:
+        nx_G.add_edge(str(edge[0]), str(edge[1]), weight=edge[2])
+    for node in nx_G.nodes():
+        nx_G.nodes[node]['cluster'] = cluster_labels.get(str(node), -1)
+    unique_clusters = sorted(set(cluster_labels.values()) | {-1})
+    colors = ['#e41a1c', '#377eb8', '#4daf4a', '#984ea3', '#ff7f00', '#ffff33']
+    color_map = {}
+    for i, label in enumerate(unique_clusters):
+        color_map[label] = 'grey' if label == -1 else colors[i % len(colors)]
+    for node in nx_G.nodes():
+        cl = nx_G.nodes[node]['cluster']
+        nx_G.nodes[node]['color'] = color_map.get(cl, 'black')
+    if layout == 'bipartite':
+        # For bipartite layout, you could add custom logic; here we use spring layout.
+        pos = nx.spring_layout(nx_G, k=0.2)
+    elif layout == 'spring':
+        pos = nx.spring_layout(nx_G, k=0.2)
+    elif layout == 'circular':
+        pos = nx.circular_layout(nx_G)
+    else:
+        pos = nx.spring_layout(nx_G, k=0.2)
+    return nx_G, pos
+
+#############################
+# Dash App Layout
+#############################
+
+app = dash.Dash(__name__, suppress_callback_exceptions=True)
+server = app.server
+
+app.layout = html.Div([
+    html.H1("HINA Visualization Web App"),
+    # File Upload
+    dcc.Upload(
+        id='upload-data',
+        children=html.Div(['Drag and drop or ', html.A('Select a CSV File')]),
+        style={
+            'width': '90%', 'height': '60px', 'lineHeight': '60px',
+            'borderWidth': '1px', 'borderStyle': 'dashed', 'borderRadius': '5px',
+            'textAlign': 'center', 'margin': '10px'
+        },
+        multiple=False
+    ),
+    html.Div(id='upload-status'),
+    # Store uploaded data as JSON
+    dcc.Store(id='stored-data'),
+    # Common dropdowns
+    html.Div([
+        html.Label("Group:"),
+        dcc.Dropdown(
+            id="common-group",
+            options=[], value="All",
+            style={'width': '25%', 'display': 'inline-block', 'margin-right': '10px'}
+        ),
+        html.Label("Attribute 1:"),
+        dcc.Dropdown(
+            id="common-attr1",
+            options=[], value="",
+            style={'width': '25%', 'display': 'inline-block', 'margin-right': '10px'}
+        ),
+        html.Label("Attribute 2:"),
+        dcc.Dropdown(
+            id="common-attr2",
+            options=[], value="",
+           style={'width': '25%', 'display': 'inline-block','margin-right': '10px'}
+        ),
+        html.Br(), html.Br(),
+        html.Label("Task Weight Column:"),
+        dcc.Dropdown(
+            id="common-weight",
+            options=[], value="",
+            style={'width': '25%', 'display': 'inline-block', 'margin-right': '10px'}
+        )
+    ], style={'padding': '2px', 'border': '1px solid #ccc', 'margin': '2px'}),
+    # Tabs
+    dcc.Tabs(id='tabs', value='tab-hina', children=[
+        dcc.Tab(label='HINA Network', value='tab-hina'),
+        dcc.Tab(label='Clustered Network', value='tab-cluster'),
+        dcc.Tab(label='Quantity & Diversity', value='tab-qd')
+    ]),
+    html.Div(id='tabs-content')
+])
+
+#############################
+# Callbacks
+#############################
+
+# Update common dropdown options.
+@app.callback(
+    Output('common-group', 'options'),
+    Output('common-attr1', 'options'),
+    Output('common-attr2', 'options'),
+    Output('common-weight', 'options'),
+    Input('stored-data', 'data')
+)
+def update_common_dropdowns(data):
+    if data is None:
+        return [], [], [], []
+    df = pd.read_json(data, orient='split')
+    if 'group' in df.columns:
+        group_options = [{'label': str(x), 'value': str(x)} for x in sorted(df['group'].unique())]
+        group_options.insert(0, {'label': 'All', 'value': 'All'})
+    else:
+        group_options = [{'label': 'All', 'value': 'All'}]
+    col_options = [{'label': col, 'value': col} for col in df.columns]
+    return group_options, col_options, col_options, col_options
+
+# Process file upload.
+@app.callback(
+    Output('stored-data', 'data'),
+    Output('upload-status', 'children'),
+    Input('upload-data', 'contents'),
+    State('upload-data', 'filename')
+)
+def store_file(contents, filename):
+    if contents is None:
+        return no_update, "Awaiting file upload..."
+    df, msg = parse_contents(contents, filename)
+    if df is None:
+        return no_update, msg
+    return df.to_json(date_format='iso', orient='split'), msg
+
+# Render tab content.
+@app.callback(
+    Output('tabs-content', 'children'),
+    Input('tabs', 'value')
+)
+def render_tab(tab):
+    if tab == 'tab-hina':
+        return html.Div([
+            html.H3("HINA Network Visualization"),
+            html.Div([
+                html.Label("Pruning:"),
+                dcc.RadioItems(
+                    id='hina-pruning',
+                    options=[
+                        {'label': 'No Pruning', 'value': 'none'},
+                        {'label': 'Custom Pruning', 'value': 'custom'}
+                    ],
+                    value='none',
+                    labelStyle={'display': 'inline-block', 'margin-right': '10px'}
+                ),
+                html.Div(id='custom-pruning-options', children=[
+                    html.Label("Alpha:"),
+                    dcc.Input(id='pruning-alpha', type='number', value=0.05, step=0.01, style={'margin-right': '10px'}),
+                    html.Label("Fix Deg:"),
+                    dcc.Input(id='pruning-fix-deg', type='text', value='Set 1')
+                ], style={'display': 'none', 'margin-top': '10px'}),
+                html.Br(),
+                html.Label("Layout:"),
+                dcc.Dropdown(
+                    id='hina-layout',
+                    options=[
+                        {'label': 'Bipartite', 'value': 'bipartite'},
+                        {'label': 'Spring', 'value': 'spring'},
+                        {'label': 'Circular', 'value': 'circular'}
+                    ],
+                    value='spring',
+                    style={'width': '50%'}
+                ),
+                html.Br(),
+                html.Button("Update HINA Network", id='update-hina', n_clicks=0)
+            ], style={'padding': '10px', 'border': '1px solid #ccc', 'margin-bottom': '10px'}),
+            html.Div([
+                cyto.Cytoscape(
+                    id='hina-network',
+                    layout={'name': 'preset'},
+                    style={'width': '100%', 'height': '800px'}, #canvas size
+                    elements=[],
+                    zoom=1,
+                    userZoomingEnabled=False,  
+                    userPanningEnabled=True     # Enable dragging/panning
+                ),
+                html.Div([
+                    html.Button("+", id="zoom-in", n_clicks=0, style={'font-size': '24px', 'margin': '2px'}),
+                    html.Button("–", id="zoom-out", n_clicks=0, style={'font-size': '24px', 'margin': '2px'})
+                ], style={'position': 'absolute', 'top': '10px', 'right': '10px', 'zIndex': 999})
+            ], style={'position': 'relative', 'width': '100%', 'height': '800px'})
+        ])
+    elif tab == 'tab-cluster':
+        return html.Div([
+            html.H3("Clustered Network Visualization"),
+            html.Div([
+                html.Label("Pruning:"),
+                dcc.RadioItems(
+                    id='cluster-pruning',
+                    options=[
+                        {'label': 'No Pruning', 'value': 'none'},
+                        {'label': 'Custom Pruning', 'value': 'custom'}
+                    ],
+                    value='none',
+                    labelStyle={'display': 'inline-block', 'margin-right': '10px'}
+                ),
+                html.Div(id='cluster-custom-pruning-options', children=[
+                    html.Label("Alpha:"),
+                    dcc.Input(id='cluster-pruning-alpha', type='number', value=0.05, step=0.01, style={'margin-right': '10px'}),
+                    html.Label("Fix Deg:"),
+                    dcc.Input(id='cluster-pruning-fix-deg', type='text', value='Set 1')
+                ], style={'display': 'none', 'margin-top': '10px'}),
+                html.Br(),
+                html.Label("Layout:"),
+                dcc.Dropdown(
+                    id='cluster-layout',
+                    options=[
+                        {'label': 'Bipartite', 'value': 'bipartite'},
+                        {'label': 'Spring', 'value': 'spring'},
+                        {'label': 'Circular', 'value': 'circular'}
+                    ],
+                    value='spring',
+                    style={'width': '50%'}
+                ),
+                html.Br(),
+                html.Label("Clustering Method:"),
+                dcc.Dropdown(
+                    id='clustering-method',
+                    options=[{'label': 'Modularity', 'value': 'modularity'}],
+                    value='modularity',
+                    style={'width': '50%'}
+                ),
+                html.Br(),
+                html.Button("Update Clustered Network", id='update-cluster', n_clicks=0)
+            ], style={'padding': '10px', 'border': '1px solid #ccc', 'margin-bottom': '10px'}),
+            html.Div([
+                cyto.Cytoscape(
+                    id='cluster-network',
+                    layout={'name': 'preset'},
+                    style={'width': '100%', 'height': '800px'},
+                    elements=[],
+                    zoom=1,
+                    userZoomingEnabled=False,
+                    userPanningEnabled=True
+                ),
+                html.Div([
+                    html.Button("+", id="cluster-zoom-in", n_clicks=0, style={'font-size': '24px', 'margin': '2px'}),
+                    html.Button("–", id="cluster-zoom-out", n_clicks=0, style={'font-size': '24px', 'margin': '2px'})
+                ], style={'position': 'absolute', 'top': '10px', 'right': '10px', 'zIndex': 999})
+            ], style={'position': 'relative', 'width': '100%', 'height': '800px'})
+        ])
+    elif tab == 'tab-qd':
+        return html.Div([
+            html.H3("Quantity and Diversity"),
+            html.Br(),
+            html.Button("Compute Quantity & Diversity", id='compute-qd', n_clicks=0),
+            html.Br(),
+            html.Div(id='qd-output')
+        ])
+
+# Show/hide custom pruning options in HINA tab.
+@app.callback(
+    Output('custom-pruning-options', 'style'),
+    Input('hina-pruning', 'value')
+)
+def toggle_custom_pruning_hina(pruning_value):
+    if pruning_value == 'custom':
+        return {'display': 'block', 'margin-top': '10px'}
+    else:
+        return {'display': 'none'}
+
+# Show/hide custom pruning options in Clustered tab.
+@app.callback(
+    Output('cluster-custom-pruning-options', 'style'),
+    Input('cluster-pruning', 'value')
+)
+def toggle_custom_pruning_cluster(pruning_value):
+    if pruning_value == 'custom':
+        return {'display': 'block', 'margin-top': '10px'}
+    else:
+        return {'display': 'none'}
+
+# Update HINA Network visualization.
+@app.callback(
+    Output('hina-network', 'elements'),
+    Input('update-hina', 'n_clicks'),
+    State('stored-data', 'data'),
+    State('common-group', 'value'),
+    State('common-attr1', 'value'),
+    State('common-attr2', 'value'),
+    State('hina-pruning', 'value'),
+    State('pruning-alpha', 'value'),
+    State('pruning-fix-deg', 'value'),
+    State('hina-layout', 'value')
+)
+def update_hina(n_clicks, data, group, attr1, attr2, pruning_value, alpha, fix_deg, layout_choice):
+    if data is None or n_clicks == 0:
+        return no_update
+    df = pd.read_json(data, orient='split')
+    if pruning_value == 'custom':
+        pruning_param = {'alpha': alpha, 'fix_deg': fix_deg}
+    else:
+        pruning_param = "none"
+    try:
+        G, pos = build_hina_network(df, group, attr1, attr2, pruning_param, layout_choice)
+        elements = cy_elements_from_graph(G, pos)
+    except Exception as e:
+        elements = []
+    return elements
+
+# Update Clustered Network visualization.
+@app.callback(
+    Output('cluster-network', 'elements'),
+    Input('update-cluster', 'n_clicks'),
+    State('stored-data', 'data'),
+    State('common-group', 'value'),
+    State('common-attr1', 'value'),
+    State('common-attr2', 'value'),
+    State('cluster-pruning', 'value'),
+    State('cluster-pruning-alpha', 'value'),
+    State('cluster-pruning-fix-deg', 'value'),
+    State('cluster-layout', 'value'),
+    State('clustering-method', 'value')
+)
+def update_cluster(n_clicks, data, group, attr1, attr2, pruning_value, alpha, fix_deg, layout_choice, clustering_method):
+    if data is None or n_clicks == 0:
+        return no_update
+    df = pd.read_json(data, orient='split')
+    if pruning_value == 'custom':
+        pruning_param = {'alpha': alpha, 'fix_deg': fix_deg}
+    else:
+        pruning_param = "none"
+    try:
+        nx_G, pos = build_clustered_network(df, group, attr1, attr2, clustering_method, pruning=pruning_param, layout=layout_choice)
+        elements = cy_elements_from_graph(nx_G, pos)
+    except Exception as e:
+        elements = []
+    return elements
+
+# Compute Quantity & Diversity.
+@app.callback(
+    Output('qd-output', 'children'),
+    Input('compute-qd', 'n_clicks'),
+    State('stored-data', 'data'),
+    State('common-attr1', 'value'),
+    State('common-attr2', 'value'),
+    State('common-weight', 'value')
+)
+def compute_qd(n_clicks, data, attr1, attr2, weight_col):
+    if data is None or n_clicks == 0:
+        return no_update
+    df = pd.read_json(data, orient='split')
+    q, d = quantity_and_diversity(df, student_col=attr1, task_col=attr2, weight_col=weight_col)
+    table_df = pd.DataFrame({
+        attr1: list(q.keys()),
+        'Quantity': list(q.values()),
+        'Diversity': list(d.values())
+    })
+    return dash_table.DataTable(
+        data=table_df.to_dict('records'),
+        columns=[{'name': i, 'id': i} for i in table_df.columns],
+        style_table={'overflowX': 'auto'},
+        page_size=10
+    )
+
+# Callback to update the zoom level of the HINA network.
+@app.callback(
+    Output('hina-network', 'zoom'),
+    Input('zoom-in', 'n_clicks'),
+    Input('zoom-out', 'n_clicks')
+)
+def update_hina_zoom(n_zoom_in, n_zoom_out):
+    zoom = 1 * (1.2 ** n_zoom_in) * (0.8 ** n_zoom_out)
+    return zoom
+
+# Callback to update the zoom level of the Clustered network.
+@app.callback(
+    Output('cluster-network', 'zoom'),
+    Input('cluster-zoom-in', 'n_clicks'),
+    Input('cluster-zoom-out', 'n_clicks')
+)
+def update_cluster_zoom(n_zoom_in, n_zoom_out):
+    zoom = 1 * (1.2 ** n_zoom_in) * (0.8 ** n_zoom_out)
+    return zoom
+
+#############################
+# Run the App
+#############################
+if __name__ == '__main__':
+    app.run_server(debug=True)

hina-0.1/hina/cli.py

@@ -0,0 +1,2 @@
+def main():
+    print("Package loading!")

hina-0.1/hina/dyad/__init__.py

@@ -0,0 +1 @@
+from .significant_edges import *

hina-0.1/hina/dyad/significant_edges.py

@@ -0,0 +1,49 @@
+import scipy.stats as stats
+
+def prune_edges(G,alpha=0.05,fix_deg='Set 1'):
+    """
+    compute edges that are statistically significant in a null model where degree
+        of nodes in the set specified are fixed, as in Feng et al 2023   
+    inputs:
+        G is a set of tuples (i,j,w)
+        alpha is desired significance level
+        fix_deg fixes degrees of desired node set
+            options are: 'None', 'Set 1', 'Set 2'
+    returns:
+        subset of G corresponding to statistically significant edges under the null model
+    """
+
+    set1,set2 = set([e[0] for e in G]),set([e[1] for e in G])
+    N1,N2 = len(set1),len(set2)
+    
+    if fix_deg is None:
+
+        E = sum(e[-1] for e in G)
+        p = 1./(N1*N2)
+        weight_threshold = stats.binom.ppf(1-alpha, E, p)
+
+        return set([e for e in G if e[-1] > weight_threshold])
+
+    if fix_deg == 'Set 1':
+
+        degs = {}
+        for e in G:
+            i = e[0]
+            if not(i in degs): degs[i] = 0
+            degs[i] += e[-1]
+
+        p = 1./N2
+
+        return set([e for e in G if e[-1] > stats.binom.ppf(1-alpha, degs[e[0]], p)])
+
+    if fix_deg == 'Set 2':
+
+        degs = {}
+        for e in G:
+            i = e[1]
+            if not(i in degs): degs[i] = 0
+            degs[i] += e[-1]
+
+        p = 1./N1
+
+        return set([e for e in G if e[-1] > stats.binom.ppf(1-alpha, degs[e[1]], p)])

hina-0.1/hina/individual/__init__.py

@@ -0,0 +1 @@
+from .quantity_diversity import *

hina-0.1/hina/individual/quantity_diversity.py

@@ -0,0 +1,75 @@
+from collections import Counter
+import numpy as np
+
+def get_bipartite(df,col1,col2):
+    """
+    projection of dataset onto bipartite network with nodes in col1 and col2 of dataset
+        can use composite indices, e.g. col2 = (col A,col B) to merge attributes A,B
+        weight of edge (i,j) determined by the number of times (i,j) occurs in the dataset
+    inputs:
+        dataframe df
+        strings col1 and col2 representing columns of the dataframe
+    returns:
+        set of tuples (i,j,w) representing (source node, destination node, weight of edge)
+    """
+
+    if isinstance(col1, tuple):
+        new_col1 = '_'.join(list(col1))
+        df[new_col1] = df[list(col1)].apply(lambda row: tuple(row), axis=1)
+    else:
+        new_col1 = col1
+
+    if isinstance(col2, tuple):
+        new_col2 = '_'.join(list(col2))
+        df[new_col2] = df[list(col2)].apply(lambda row: tuple(row), axis=1)
+    else:
+        new_col2 = col2
+
+    edge_dict = Counter([tuple(e) for e in df[[new_col1,new_col2]].values])
+    G = set([tuple([it[0][0],it[0][1],it[1]]) for it in edge_dict.items()])
+    
+    return G
+
+def quantity_and_diversity(df,student_col,task_col,weight_col):
+    """
+    compute quantity and diversity measures of Feng et al 2024 for students in student_col
+    inputs:
+        df is dataframe
+        student_col is column name for student identifiers
+        task_col is column name for tasks
+        weight_col is column name for weights of tasks
+    returns:
+        quantity and diversity measures for student nodes with respect to indicated tasks and weights,
+            in form of dictionaries with {node name: quantity} and {node name: diversity}
+    """
+    G = get_bipartite(df,student_col,task_col)
+    weights_dict = dict(df[[task_col,weight_col]].values)
+    W = sum(weights_dict.values())
+    N2 = len(set([e[1] for e in G]))
+    
+    quantities = {}
+    for e in G:
+        i,j = e[0],e[1]
+        if not(i in quantities): quantities[i] = 0
+        quantities[i] += weights_dict[j]/W
+
+    degs = {}
+    for e in G:
+        i = e[0]
+        if not(i in degs): degs[i] = 0
+        degs[i] += e[-1]
+
+    out_weights = {}
+    for e in G:
+        i,j,w = e
+        if not(i in out_weights): out_weights[i] = {}
+        if not(j in out_weights[i]): out_weights[i][j] = 0
+        out_weights[i][j] += w
+    
+    diversities = {}
+    for i in out_weights:
+        wi = sum(out_weights[i].values())
+        diversities[i] = -sum([(out_weights[i][j]/wi)*np.log(out_weights[i][j]/wi) for j in out_weights[i]])
+        diversities[i] /= np.log(N2)
+    
+    return quantities,diversities

hina-0.1/hina/mesoscale/__init__.py

@@ -0,0 +1 @@
+from .clustering import *

hina-0.1/hina/mesoscale/clustering.py

@@ -0,0 +1,43 @@
+from sknetwork.data import from_edge_list
+from sknetwork.clustering import Louvain
+import numpy as np
+
+def cluster_nodes(G,num_clusters=None,method='modularity',nodes='All'):
+    """
+    compute node clusters in bipartite network using method of Feng et al 2024 
+        for network aggregated over nodes in indicated node list 'nodes'
+        computes for first node set (typically student nodes) in the bipartite network
+    inputs:
+        set of tuples G
+        num_clusters is fixed # of node clusters if desired 
+            defaults to None to learn # of clusters automatically
+        method specifies clustering objective and optimization algorithm. 
+        current options are: 
+            'modularity': Barber's (2007) modularity for bipartite graphs, through sknetwork
+            'SBM': Peixoto's microcanonical SBM (2014), through graph-tool
+        nodes is list of node names to which we apply the clustering. 'All' includes all nodes
+    returns:
+        dict of form {node name:cluster label}
+    """
+    if nodes == 'All': 
+        nodes = set(np.unique([e[0] for e in G]))
+    else:
+        nodes = set(nodes)
+
+    G = set([e for e in G if e[0] in nodes])
+
+    if method == 'modularity':
+        
+        e_list = list(G)
+        G_b = from_edge_list(e_list, bipartite=True)
+        A_b = G_b.biadjacency
+
+        louvain = Louvain()
+        louvain.fit(A_b,force_bipartite=True)
+
+        community_labels = {stud:louvain.labels_row_[s] for s,stud in enumerate(G_b.names_row)}
+
+    if method == 'SBM':
+
+        community_labels = None
+    return community_labels

hina-0.1/hina/utils/__init__.py

@@ -0,0 +1 @@
+from .graph_tools import *

hina-0.1/hina/utils/graph_tools.py

@@ -0,0 +1,20 @@
+import networkx as nx
+
+def save_network(G, filename, format='gml'):
+    """
+    Saves the bipartite network G (set of tuples (i,j,w)) to a specified file format.
+    Supported formats: 'graphml', 'gexf', 'gpickle', etc.
+    """
+    # Convert edge set to a NetworkX graph
+    B = nx.Graph()
+    for s, t, w in G:
+        B.add_edge(s, t, weight=w)
+
+    if format == 'gml':
+        nx.write_gml(B, filename + '.gml')
+    elif format == 'gexf':
+        nx.write_gexf(B, filename + '.gexf')
+    elif format == 'gpickle':
+        nx.write_gpickle(B, filename + '.gpickle')
+    else:
+        raise ValueError("Unsupported format: {}".format(format))

hina-0.1/hina/visualization/__init__.py

@@ -0,0 +1 @@
+from .network_visualization import *

hina-0.1/hina/visualization/network_visualization.py

@@ -0,0 +1,204 @@
+import networkx as nx
+import numpy as np
+import pandas as pd
+import matplotlib.pyplot as plt
+from matplotlib.lines import Line2D
+from bnapy.dyad.significant_edges import prune_edges
+from bnapy.mesoscale.clustering import cluster_nodes
+from bnapy.individual.quantity_diversity import get_bipartite
+
+
+def plot_HINA(df, group='All', attribute_1=None, attribute_2=None, pruning=False, layout='spring', NetworkX_kwargs=None):
+    """
+    Plots a bipartite network visualization with specified attributes and layout.
+
+    Parameters:
+    - df (pd.DataFrame): Input dataframe containing the network data.
+    - group (str): Group to filter and plot (default: 'All' for entire dataset).
+    - attribute_1 (str): Column name for the first node set (e.g., 'student id').
+    - attribute_2 (str): Column name for the second node set (e.g., 'task').
+    - pruning (bool or dict): Whether to prune edges using significance logic. 
+                              If dict, specifies parameters for pruning.
+    - layout (str): Layout to use for node positioning. Supported layouts:
+                    - 'bipartite': Nodes are positioned in two vertical columns.
+                    - 'spring': Force-directed layout for a visually appealing arrangement.
+                    - 'circular': Nodes are arranged in a circle.
+    - NetworkX_kwargs (dict): Additional arguments for NetworkX visualization.
+
+    Returns:
+    - None: Displays a plot of the bipartite network.
+
+    """
+    if NetworkX_kwargs is None:
+        NetworkX_kwargs = {}
+
+    if attribute_1 is None or attribute_2 is None:
+        raise ValueError("Both 'attribute_1' and 'attribute_2' must be specified.")
+
+    if group != 'All':
+        df = df[df['group'] == group]
+
+    G = nx.Graph()
+    for _, row in df.iterrows():
+        G.add_node(row[attribute_1])
+        G.add_node(row[attribute_2])
+        G.add_edge(row[attribute_1], row[attribute_2], weight=row['task weight'])
+
+    if pruning:
+        edge_tuples = [(u, v, d['weight']) for u, v, d in G.edges(data=True)]
+        if isinstance(pruning, dict):
+            significant_edges = prune_edges(edge_tuples, **pruning)
+        else:
+            significant_edges = prune_edges(edge_tuples)
+        G = nx.Graph()
+        for u, v, w in significant_edges:
+            G.add_edge(u, v, weight=w)
+
+    for node in G.nodes:
+        if node in df[attribute_1].values:
+            G.nodes[node]['type'] = 'attribute_1'
+            G.nodes[node]['color'] = 'blue'
+        elif node in df[attribute_2].values:
+            G.nodes[node]['type'] = 'attribute_2'
+            G.nodes[node]['color'] = 'grey'
+        else:
+            G.nodes[node]['type'] = 'unknown'
+            G.nodes[node]['color'] = 'black'
+
+    if layout == 'bipartite':
+        attribute_1_nodes = {n for n, d in G.nodes(data=True) if d['type'] == 'attribute_1'}
+        if not nx.is_bipartite(G):
+            raise ValueError("The graph is not bipartite; check the input data.")
+        pos = nx.bipartite_layout(G, attribute_1_nodes, align='vertical', scale=2, aspect_ratio=4)
+    elif layout == 'spring':
+        pos = nx.spring_layout(G, k=0.2)  
+    elif layout == 'circular':
+        pos = nx.circular_layout(G)
+    else:
+        raise ValueError(f"Unsupported layout: {layout}")
+
+    max_y = max(abs(y) for _, y in pos.values())  
+    label_offset = max_y * 0.03  
+
+    node_colors = [d['color'] for _, d in G.nodes(data=True)]
+    edge_widths = [d['weight'] / 15 for _, _, d in G.edges(data=True)]
+
+    plt.figure(figsize=(12, 12))
+    nx.draw(
+        G,
+        pos,
+        with_labels=False,
+        node_color=node_colors,
+        width=edge_widths,
+        node_size=200,
+        **NetworkX_kwargs
+    )
+
+    for node, (x, y) in pos.items():
+        label = str(node)
+        plt.text(
+            x, y + label_offset,  
+            label,
+            fontsize=9,
+            ha='center',
+            va='center',
+            color='black'
+        )
+
+    plt.title(f"HINA Network Visualization: Group = {group}")
+    plt.show()
+
+def plot_clusters(df, group='All', attribute_1=None, attribute_2=None, pruning=False, clustering_method='modularity', NetworkX_kwargs=None):
+    """
+    Plots a clustered bipartite network for the selected group.
+
+    Parameters:
+    - df (pd.DataFrame): Input dataframe containing the network data.
+    - group (str): Group to filter and plot (default: 'All' for the entire dataset).
+    - attribute_1 (str): Column name for the first node set (e.g., 'student id').
+    - attribute_2 (str): Column name for the second node set (e.g., 'task').
+    - pruning (bool or dict): Whether to prune edges using significance logic. 
+                              If dict, specifies parameters for pruning.
+    - clustering_method (str): Clustering method to use for grouping nodes. 
+                               Supported methods:
+                               - 'modularity': Louvain modularity clustering for bipartite graphs.
+                               - 'SBM': Stochastic Block Model (for future implementation).
+    - NetworkX_kwargs (dict): Additional arguments for NetworkX visualization.
+
+    Returns:
+    - None: Displays a plot of the clustered bipartite network.
+    """
+    if NetworkX_kwargs is None:
+        NetworkX_kwargs = {}
+
+    # Filter the dataframe by the selected group
+    if group != 'All':
+        df = df[df['group'] == group]
+
+    if attribute_1 is None or attribute_2 is None:
+        raise ValueError("Both 'attribute_1' and 'attribute_2' must be specified.")
+
+    G = get_bipartite(df, attribute_1, attribute_2)
+
+    cluster_labels = cluster_nodes(G, method=clustering_method)
+    print("Cluster labels:", cluster_labels)
+
+    nx_G = nx.Graph()
+    for edge in G:
+        nx_G.add_edge(edge[0], edge[1], weight=edge[2])
+
+    for node in nx_G.nodes:
+        nx_G.nodes[node]['cluster'] = cluster_labels.get(str(node), -1)  # Default cluster is -1 for unclustered nodes
+
+    unique_clusters = sorted(set(cluster_labels.values()) | {-1})  # Include -1 for unclustered nodes
+    label_to_color = {label: idx for idx, label in enumerate(unique_clusters)}  # Map labels to indices
+
+    cmap = plt.get_cmap('tab10', len(unique_clusters))  # Dynamically get a colormap with enough colors
+    label_to_color[-1] = 'grey'  # Set grey for unclustered nodes
+
+    node_colors = [
+        'grey' if nx_G.nodes[node]['cluster'] == -1 else cmap(label_to_color[nx_G.nodes[node]['cluster']])
+        for node in nx_G.nodes
+    ]
+
+    pos = nx.spring_layout(nx_G, k=0.2)
+    max_y = max(abs(y) for _, y in pos.values())  
+    label_offset = max_y * 0.07  
+
+    plt.figure(figsize=(12, 8))
+    nx.draw(
+        nx_G,
+        pos,
+        with_labels=False,
+        node_color=node_colors,
+        node_size=800,
+        edge_color='gray',
+        width=1,
+        **NetworkX_kwargs
+    )
+
+    for node, (x, y) in pos.items():
+        plt.text(
+            x, y + label_offset,  
+            str(node),
+            fontsize=9,
+            ha='center',
+            va='center',
+            color='black'
+        )
+
+    legend_elements = [
+        Line2D(
+            [0], [0],
+            marker='o',
+            color='w',
+            markerfacecolor='grey' if label == -1 else cmap(idx),
+            markersize=10,
+            label=f'Cluster {label}' if label != -1 else attribute_2
+        )
+        for label, idx in label_to_color.items()
+    ]
+    plt.legend(handles=legend_elements, loc='upper right', title='Clusters', frameon=True)
+
+    plt.title(f"Clustered Bipartite Network ({clustering_method.capitalize()} Method) for Group: {group}")
+    plt.show()

hina-0.1/hina.egg-info/PKG-INFO

@@ -0,0 +1,88 @@
+Metadata-Version: 2.2
+Name: hina
+Version: 0.1
+Summary: Heterogenous Interaction Network Analysis in Python
+Home-page: https://hina.readthedocs.io/en/latest/index.html
+Author: Shihui Feng, Baiyue He, Alec Kirkley
+Author-email: shihuife@hku.hk, baiyue.he@connect.hku.hk, akirkley@hku.hk
+License: The MIT License
+Project-URL: Documentation, https://hina.readthedocs.io/en/latest/index.html
+Project-URL: Source, https://hina.readthedocs.io/en/latest/index.html
+Requires-Python: >=3.9, <3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE.txt
+Requires-Dist: numpy>=1.24
+Requires-Dist: pandas>=2.2
+Requires-Dist: scipy>=1.10
+Requires-Dist: scikit-network==0.32.1
+Requires-Dist: dash<=3.0.0
+Dynamic: author
+Dynamic: author-email
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license
+Dynamic: project-url
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# BNApy (Bipartite Network Analysis)
+
+HINA is a learning analytics tool that models and analyzes heterogenous interactions during learning. Heterogenous interactions refer to the interactions occurring between different types of entities during learning processes, such as students’ interactions with learning objects or students’ display of different behaviors coded using multimodal process data. These heterogenous interactions can be modelled with heterogenous interaction networks that consist of different sets of nodes and edges connecting nodes from different sets. Each node in a heterogenous interaction network can represent any meaningful entity reflecting a certain object or construct in a learning process, such as a student, group of students, coded behavior, or learning artefact. Edges in the network pair nodes from different sets and can reflect affiliations, associations, or interactions among the nodes for modeling a specific learning process. Heterogenous interaction networks offer a flexible, adaptive, and widely applicable method to model a wide variety of interactions that can occur during the learning processes, across individual learning, group learning, and community learning. 
+
+## Features
+
+- **Individual-level Analysis**: Provides functions to compute the node-level measures of gauging the quantity and diversity of individuals’ interactions in the learning process. New package contributions can incorporate other node-level measures for understanding individuals’ interaction patterns.
+- **Dyadic Analysis**: Provides methods to identify statistically significant edges in the heterogeneous interaction network relative to multiple different null models of interaction structure, which can be specified by the user. New package contributions can incorporate other dyad-level analyses for understanding interaction patterns among pairs of nodes.
+- **Mesoscale Clustering**: Provides methods for clustering nodes in a bipartite projection of the heterogeneous interaction network according to shared interaction structure, automatically learning the number of clusters from heterogeneity in the interaction data to find a mesoscale representation. New package contributions can incorporate other measures for understanding the mesoscale structure of the interaction network.
+- **Visualization**: Provides network visualization functions for networks at the group level or cohort level that enable the user to easily project the heterogeneous interaction network onto any subset of node types (e.g. students, tasks, behavioral codes). These methods allow for the inclusion of various metadata such as inferred student clusters or contribution metrics, as well as pruning of the interaction network to identify significant interaction structure. Also enables visualization with Sankey diagrams for an alternative representation of the weighted networks. These visualizations come together with a web-based interface that enables interactions and user engagement. New package contributions can incorporate other relevant metadata for visualization, as well as other preprocessing tools for augmenting or modifying the network structure to highlight particular features.
+- **Web Interface**: Includes a web-based interface for engaging with the visualizations.
+- **Extensibility**: Easily incorporate additional measures, clustering methods, or visualizations.
+
+
+## Installation
+
+To install BNA, you can use `pip` from the PyPI repository:
+
+```bash
+pip install bna
+
+BNA_Package/
+├── __init__.py
+├── individual/
+│   ├── __init__.py
+│   ├── quantity_diversity.py    
+│   └── tests/                   
+│       ├── __init__.py
+│       └── test_quantity_diversity.py
+├── dyad/
+│   ├── __init__.py
+│   ├── significant_edges.py     
+│   └── tests/                  
+│       ├── __init__.py
+│       └── test_significant_edges.py
+├── mesoscale/
+│   ├── __init__.py
+│   ├── clustering.py            
+│   └── tests/                  
+│       ├── __init__.py
+│       └── test_clustering.py
+├── visualization/
+│   ├── __init__.py
+│   ├── network_visualization.py 
+│   ├── web_interface.py         
+│   └── tests/                   
+│       ├── __init__.py
+│       └── test_network_visualization.py
+├── utils/
+│   ├── __init__.py
+│   ├── graph_tools.py        
+│   ├── plot_tools.py          
+│   └── tests/
+│       ├── __init__.py
+│       ├── test_graph_tools.py
+│       └── test_plot_tools.py
+├── data/                       
+    ├── __init__.py
+    └── synthetic_data.csv

hina-0.1/hina.egg-info/SOURCES.txt

@@ -0,0 +1,29 @@
+LICENSE.txt
+README.md
+setup.py
+hina/__init__.py
+hina/cli.py
+hina.egg-info/PKG-INFO
+hina.egg-info/SOURCES.txt
+hina.egg-info/dependency_links.txt
+hina.egg-info/requires.txt
+hina.egg-info/top_level.txt
+hina/app/__init__.py
+hina/app/app.py
+hina/app/tests/__init__.py
+hina/data/__init__.py
+hina/dyad/__init__.py
+hina/dyad/significant_edges.py
+hina/dyad/tests/__init__.py
+hina/individual/__init__.py
+hina/individual/quantity_diversity.py
+hina/individual/tests/__init__.py
+hina/mesoscale/__init__.py
+hina/mesoscale/clustering.py
+hina/mesoscale/tests/__init__.py
+hina/utils/__init__.py
+hina/utils/graph_tools.py
+hina/utils/tests/__init__.py
+hina/visualization/__init__.py
+hina/visualization/network_visualization.py
+hina/visualization/tests/__init__.py

hina-0.1/hina.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

hina-0.1/hina.egg-info/requires.txt

@@ -0,0 +1,5 @@
+numpy>=1.24
+pandas>=2.2
+scipy>=1.10
+scikit-network==0.32.1
+dash<=3.0.0

hina-0.1/hina.egg-info/top_level.txt

@@ -0,0 +1 @@
+hina

hina-0.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

hina-0.1/setup.py

@@ -0,0 +1,27 @@
+from setuptools import setup, find_packages, Extension
+
+setup(
+    name='hina',
+    version='0.1',
+    description='Heterogenous Interaction Network Analysis in Python',
+    long_description=open('README.md', encoding='utf-8').read(),
+    long_description_content_type='text/markdown',
+    url='https://hina.readthedocs.io/en/latest/index.html',
+    author='Shihui Feng, Baiyue He, Alec Kirkley',
+    author_email='shihuife@hku.hk, baiyue.he@connect.hku.hk, akirkley@hku.hk',
+    license='The MIT License',
+    project_urls={
+        "Documentation": "https://hina.readthedocs.io/en/latest/index.html",
+        "Source": "https://hina.readthedocs.io/en/latest/index.html"
+    },
+    python_requires=">=3.9, <3.12",
+    install_requires=[
+        "numpy>=1.24",    
+        "pandas>=2.2",
+        "scipy>=1.10",
+        "scikit-network==0.32.1",
+        "dash<=3.0.0"
+    ],
+    packages=find_packages(),
+    include_package_data=True,
+)