juneja-codebase 0.1.3__py3-none-any.whl

juneja_codebase/templates/social_network_analysis/new.ipynb

@@ -0,0 +1,592 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "564f7abe",
+   "metadata": {},
+   "source": [
+    "# Q2: Community Detection in Random Networks\n",
+    "\n",
+    "This notebook demonstrates community detection using different algorithms:\n",
+    "- k-clique communities\n",
+    "- k-clan communities\n",
+    "- k-plex communities\n",
+    "- k-core decomposition\n",
+    "\n",
+    "We'll generate a random network with 1000 nodes and compare the characteristics of communities found by each method."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "2b647b78",
+   "metadata": {},
+   "source": [
+    "## 1. Import Required Libraries"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "48d93307",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import networkx as nx\n",
+    "import matplotlib.pyplot as plt\n",
+    "import numpy as np\n",
+    "from collections import Counter\n",
+    "import warnings\n",
+    "warnings.filterwarnings('ignore')\n",
+    "\n",
+    "# Set random seed for reproducibility\n",
+    "np.random.seed(42)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "632b0f17",
+   "metadata": {},
+   "source": [
+    "## 2. Generate Random Network with 1000 Nodes"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "0b7e15a1",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Generate a random network using Erdos-Renyi model\n",
+    "# Using probability p=0.005 to create a moderately connected network\n",
+    "n_nodes = 1000\n",
+    "p = 0.005  # Edge probability\n",
+    "\n",
+    "G = nx.erdos_renyi_graph(n_nodes, p, seed=42)\n",
+    "\n",
+    "print(f\"Network created with {G.number_of_nodes()} nodes and {G.number_of_edges()} edges\")\n",
+    "print(f\"Average degree: {2 * G.number_of_edges() / G.number_of_nodes():.2f}\")\n",
+    "print(f\"Density: {nx.density(G):.4f}\")\n",
+    "print(f\"Number of connected components: {nx.number_connected_components(G)}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "aaa12097",
+   "metadata": {},
+   "source": [
+    "## 3. k-Clique Communities\n",
+    "\n",
+    "k-clique communities are defined as the union of all cliques of size k that can be reached through adjacent cliques."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "fb68588e",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Find k-clique communities (using k=3 for triangles)\n",
+    "k_clique = 3\n",
+    "clique_communities = list(nx.community.k_clique_communities(G, k_clique))\n",
+    "\n",
+    "print(f\"\\n=== k-CLIQUE COMMUNITIES (k={k_clique}) ===\")\n",
+    "print(f\"Number of communities: {len(clique_communities)}\")\n",
+    "\n",
+    "# Calculate sizes of communities\n",
+    "clique_sizes = [len(comm) for comm in clique_communities]\n",
+    "if clique_sizes:\n",
+    "    print(f\"Average community size: {np.mean(clique_sizes):.2f}\")\n",
+    "    print(f\"Largest community size: {max(clique_sizes)}\")\n",
+    "    print(f\"Smallest community size: {min(clique_sizes)}\")\n",
+    "    print(f\"Median community size: {np.median(clique_sizes):.2f}\")\n",
+    "else:\n",
+    "    print(\"No k-clique communities found\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "45bf5fe4",
+   "metadata": {},
+   "source": [
+    "## 4. k-Core Decomposition\n",
+    "\n",
+    "k-core is a maximal subgraph where every node has at least k neighbors within the subgraph."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "39be4e8d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Find k-core decomposition\n",
+    "core_numbers = nx.core_number(G)\n",
+    "\n",
+    "print(f\"\\n=== k-CORE DECOMPOSITION ===\")\n",
+    "print(f\"Maximum core number: {max(core_numbers.values())}\")\n",
+    "print(f\"Minimum core number: {min(core_numbers.values())}\")\n",
+    "\n",
+    "# Group nodes by their core number\n",
+    "core_distribution = Counter(core_numbers.values())\n",
+    "print(f\"\\nCore distribution:\")\n",
+    "for k in sorted(core_distribution.keys()):\n",
+    "    print(f\"  k-core {k}: {core_distribution[k]} nodes\")\n",
+    "\n",
+    "# Extract different k-cores\n",
+    "max_k = max(core_numbers.values())\n",
+    "k_cores = {}\n",
+    "for k in range(1, max_k + 1):\n",
+    "    k_cores[k] = nx.k_core(G, k)\n",
+    "    print(f\"\\nk-core (k={k}): {k_cores[k].number_of_nodes()} nodes, {k_cores[k].number_of_edges()} edges\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "55f13ae2",
+   "metadata": {},
+   "source": [
+    "## 5. k-Plex Communities\n",
+    "\n",
+    "A k-plex is a relaxed clique where each node can miss connections to at most k-1 other nodes in the group.\n",
+    "\n",
+    "Note: NetworkX doesn't have a built-in k-plex algorithm, so we'll implement a simple version for finding maximal k-plexes."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "a7c236e7",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def find_k_plex(G, k, min_size=3):\n",
+    "    \"\"\"\n",
+    "    Find k-plex subgraphs in G.\n",
+    "    A k-plex is a subgraph where each node is connected to at least n-k nodes in the subgraph,\n",
+    "    where n is the size of the subgraph.\n",
+    "    \"\"\"\n",
+    "    k_plexes = []\n",
+    "    \n",
+    "    # Use cliques as starting points and relax them\n",
+    "    cliques = list(nx.find_cliques(G))\n",
+    "    \n",
+    "    for clique in cliques:\n",
+    "        if len(clique) >= min_size:\n",
+    "            # Check if it's a k-plex\n",
+    "            is_k_plex = True\n",
+    "            for node in clique:\n",
+    "                neighbors_in_clique = len([n for n in clique if n in G.neighbors(node)])\n",
+    "                # Each node should be connected to at least (size - k) nodes\n",
+    "                if neighbors_in_clique < len(clique) - k:\n",
+    "                    is_k_plex = False\n",
+    "                    break\n",
+    "            \n",
+    "            if is_k_plex:\n",
+    "                k_plexes.append(set(clique))\n",
+    "    \n",
+    "    # Remove duplicates\n",
+    "    unique_plexes = []\n",
+    "    for plex in k_plexes:\n",
+    "        if plex not in unique_plexes:\n",
+    "            unique_plexes.append(plex)\n",
+    "    \n",
+    "    return unique_plexes\n",
+    "\n",
+    "# Find k-plex communities\n",
+    "k_plex = 2\n",
+    "plex_communities = find_k_plex(G, k_plex, min_size=3)\n",
+    "\n",
+    "print(f\"\\n=== k-PLEX COMMUNITIES (k={k_plex}) ===\")\n",
+    "print(f\"Number of k-plex communities found: {len(plex_communities)}\")\n",
+    "\n",
+    "if plex_communities:\n",
+    "    plex_sizes = [len(comm) for comm in plex_communities]\n",
+    "    print(f\"Average k-plex size: {np.mean(plex_sizes):.2f}\")\n",
+    "    print(f\"Largest k-plex size: {max(plex_sizes)}\")\n",
+    "    print(f\"Smallest k-plex size: {min(plex_sizes)}\")\n",
+    "    print(f\"Median k-plex size: {np.median(plex_sizes):.2f}\")\n",
+    "else:\n",
+    "    print(\"No k-plex communities found\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "dd50ed9b",
+   "metadata": {},
+   "source": [
+    "## 6. k-Clan Communities\n",
+    "\n",
+    "A k-clan is a k-clique community with the additional constraint that the diameter within the community is at most k.\n",
+    "\n",
+    "Note: NetworkX doesn't have a built-in k-clan algorithm, so we'll implement a version based on cliques."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "13e1423d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def find_k_clans(G, k, min_size=3):\n",
+    "    \"\"\"\n",
+    "    Find k-clan communities.\n",
+    "    A k-clan is a k-clique where the diameter is at most k.\n",
+    "    \"\"\"\n",
+    "    k_clans = []\n",
+    "    \n",
+    "    # Find all cliques of size at least k\n",
+    "    cliques = [c for c in nx.find_cliques(G) if len(c) >= min_size]\n",
+    "    \n",
+    "    for clique in cliques:\n",
+    "        # Check if the diameter of the subgraph is at most k\n",
+    "        subG = G.subgraph(clique)\n",
+    "        \n",
+    "        if nx.is_connected(subG):\n",
+    "            diameter = nx.diameter(subG)\n",
+    "            if diameter <= k:\n",
+    "                k_clans.append(set(clique))\n",
+    "    \n",
+    "    # Remove duplicates\n",
+    "    unique_clans = []\n",
+    "    for clan in k_clans:\n",
+    "        if clan not in unique_clans:\n",
+    "            unique_clans.append(clan)\n",
+    "    \n",
+    "    return unique_clans\n",
+    "\n",
+    "# Find k-clan communities\n",
+    "k_clan = 3\n",
+    "clan_communities = find_k_clans(G, k_clan, min_size=3)\n",
+    "\n",
+    "print(f\"\\n=== k-CLAN COMMUNITIES (k={k_clan}) ===\")\n",
+    "print(f\"Number of k-clan communities found: {len(clan_communities)}\")\n",
+    "\n",
+    "if clan_communities:\n",
+    "    clan_sizes = [len(comm) for comm in clan_communities]\n",
+    "    print(f\"Average k-clan size: {np.mean(clan_sizes):.2f}\")\n",
+    "    print(f\"Largest k-clan size: {max(clan_sizes)}\")\n",
+    "    print(f\"Smallest k-clan size: {min(clan_sizes)}\")\n",
+    "    print(f\"Median k-clan size: {np.median(clan_sizes):.2f}\")\n",
+    "else:\n",
+    "    print(\"No k-clan communities found\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "1ab25e6b",
+   "metadata": {},
+   "source": [
+    "## 7. Visualization of Communities"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "f14a2eee",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Create visualizations for each method\n",
+    "fig, axes = plt.subplots(2, 2, figsize=(16, 16))\n",
+    "fig.suptitle('Community Detection Methods Comparison', fontsize=16, fontweight='bold')\n",
+    "\n",
+    "# Use the largest connected component for better visualization\n",
+    "largest_cc = max(nx.connected_components(G), key=len)\n",
+    "G_vis = G.subgraph(largest_cc).copy()\n",
+    "pos = nx.spring_layout(G_vis, k=0.5, iterations=50, seed=42)\n",
+    "\n",
+    "# 1. k-Clique Communities Visualization\n",
+    "ax1 = axes[0, 0]\n",
+    "nx.draw_networkx_edges(G_vis, pos, alpha=0.1, ax=ax1)\n",
+    "colors_clique = ['lightgray'] * len(G_vis.nodes())\n",
+    "node_list = list(G_vis.nodes())\n",
+    "\n",
+    "if clique_communities:\n",
+    "    color_map = plt.cm.get_cmap('tab20', len(clique_communities))\n",
+    "    for i, comm in enumerate(clique_communities[:20]):  # Limit to 20 for visualization\n",
+    "        comm_in_vis = [n for n in comm if n in G_vis.nodes()]\n",
+    "        for node in comm_in_vis:\n",
+    "            idx = node_list.index(node)\n",
+    "            colors_clique[idx] = color_map(i)\n",
+    "\n",
+    "nx.draw_networkx_nodes(G_vis, pos, node_color=colors_clique, node_size=30, ax=ax1)\n",
+    "ax1.set_title(f'k-Clique Communities (k={k_clique})\\n{len(clique_communities)} communities found', fontsize=12)\n",
+    "ax1.axis('off')\n",
+    "\n",
+    "# 2. k-Core Visualization\n",
+    "ax2 = axes[0, 1]\n",
+    "nx.draw_networkx_edges(G_vis, pos, alpha=0.1, ax=ax2)\n",
+    "core_colors = [core_numbers.get(node, 0) for node in G_vis.nodes()]\n",
+    "nx.draw_networkx_nodes(G_vis, pos, node_color=core_colors, node_size=30, \n",
+    "                       cmap='viridis', ax=ax2, vmin=0, vmax=max(core_numbers.values()))\n",
+    "ax2.set_title(f'k-Core Decomposition\\nMax core: {max(core_numbers.values())}', fontsize=12)\n",
+    "ax2.axis('off')\n",
+    "\n",
+    "# 3. k-Plex Communities Visualization\n",
+    "ax3 = axes[1, 0]\n",
+    "nx.draw_networkx_edges(G_vis, pos, alpha=0.1, ax=ax3)\n",
+    "colors_plex = ['lightgray'] * len(G_vis.nodes())\n",
+    "\n",
+    "if plex_communities:\n",
+    "    color_map = plt.cm.get_cmap('tab20', len(plex_communities))\n",
+    "    for i, comm in enumerate(plex_communities[:20]):  # Limit to 20 for visualization\n",
+    "        comm_in_vis = [n for n in comm if n in G_vis.nodes()]\n",
+    "        for node in comm_in_vis:\n",
+    "            idx = node_list.index(node)\n",
+    "            colors_plex[idx] = color_map(i)\n",
+    "\n",
+    "nx.draw_networkx_nodes(G_vis, pos, node_color=colors_plex, node_size=30, ax=ax3)\n",
+    "ax3.set_title(f'k-Plex Communities (k={k_plex})\\n{len(plex_communities)} communities found', fontsize=12)\n",
+    "ax3.axis('off')\n",
+    "\n",
+    "# 4. k-Clan Communities Visualization\n",
+    "ax4 = axes[1, 1]\n",
+    "nx.draw_networkx_edges(G_vis, pos, alpha=0.1, ax=ax4)\n",
+    "colors_clan = ['lightgray'] * len(G_vis.nodes())\n",
+    "\n",
+    "if clan_communities:\n",
+    "    color_map = plt.cm.get_cmap('tab20', len(clan_communities))\n",
+    "    for i, comm in enumerate(clan_communities[:20]):  # Limit to 20 for visualization\n",
+    "        comm_in_vis = [n for n in comm if n in G_vis.nodes()]\n",
+    "        for node in comm_in_vis:\n",
+    "            idx = node_list.index(node)\n",
+    "            colors_clan[idx] = color_map(i)\n",
+    "\n",
+    "nx.draw_networkx_nodes(G_vis, pos, node_color=colors_clan, node_size=30, ax=ax4)\n",
+    "ax4.set_title(f'k-Clan Communities (k={k_clan})\\n{len(clan_communities)} communities found', fontsize=12)\n",
+    "ax4.axis('off')\n",
+    "\n",
+    "plt.tight_layout()\n",
+    "plt.savefig('community_detection_comparison.png', dpi=300, bbox_inches='tight')\n",
+    "plt.show()\n",
+    "\n",
+    "print(\"\\nVisualization saved as 'community_detection_comparison.png'\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b8054688",
+   "metadata": {},
+   "source": [
+    "## 8. Comparison of Community Characteristics"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "22fd6f5e",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Create comparison table\n",
+    "import pandas as pd\n",
+    "\n",
+    "comparison_data = {\n",
+    "    'Method': [],\n",
+    "    'Number of Communities': [],\n",
+    "    'Avg Size': [],\n",
+    "    'Min Size': [],\n",
+    "    'Max Size': [],\n",
+    "    'Median Size': [],\n",
+    "    'Total Nodes Covered': []\n",
+    "}\n",
+    "\n",
+    "# k-Clique\n",
+    "comparison_data['Method'].append(f'k-Clique (k={k_clique})')\n",
+    "comparison_data['Number of Communities'].append(len(clique_communities))\n",
+    "if clique_sizes:\n",
+    "    comparison_data['Avg Size'].append(f\"{np.mean(clique_sizes):.2f}\")\n",
+    "    comparison_data['Min Size'].append(min(clique_sizes))\n",
+    "    comparison_data['Max Size'].append(max(clique_sizes))\n",
+    "    comparison_data['Median Size'].append(f\"{np.median(clique_sizes):.2f}\")\n",
+    "    comparison_data['Total Nodes Covered'].append(len(set().union(*clique_communities)))\n",
+    "else:\n",
+    "    comparison_data['Avg Size'].append('N/A')\n",
+    "    comparison_data['Min Size'].append('N/A')\n",
+    "    comparison_data['Max Size'].append('N/A')\n",
+    "    comparison_data['Median Size'].append('N/A')\n",
+    "    comparison_data['Total Nodes Covered'].append(0)\n",
+    "\n",
+    "# k-Core (using cores with at least 1 node)\n",
+    "k_core_communities = [set([n for n, c in core_numbers.items() if c == k]) for k in set(core_numbers.values())]\n",
+    "k_core_communities = [c for c in k_core_communities if len(c) > 0]\n",
+    "k_core_sizes = [len(c) for c in k_core_communities]\n",
+    "\n",
+    "comparison_data['Method'].append('k-Core')\n",
+    "comparison_data['Number of Communities'].append(len(k_core_communities))\n",
+    "comparison_data['Avg Size'].append(f\"{np.mean(k_core_sizes):.2f}\")\n",
+    "comparison_data['Min Size'].append(min(k_core_sizes))\n",
+    "comparison_data['Max Size'].append(max(k_core_sizes))\n",
+    "comparison_data['Median Size'].append(f\"{np.median(k_core_sizes):.2f}\")\n",
+    "comparison_data['Total Nodes Covered'].append(len(set().union(*k_core_communities)))\n",
+    "\n",
+    "# k-Plex\n",
+    "comparison_data['Method'].append(f'k-Plex (k={k_plex})')\n",
+    "comparison_data['Number of Communities'].append(len(plex_communities))\n",
+    "if plex_sizes:\n",
+    "    comparison_data['Avg Size'].append(f\"{np.mean(plex_sizes):.2f}\")\n",
+    "    comparison_data['Min Size'].append(min(plex_sizes))\n",
+    "    comparison_data['Max Size'].append(max(plex_sizes))\n",
+    "    comparison_data['Median Size'].append(f\"{np.median(plex_sizes):.2f}\")\n",
+    "    comparison_data['Total Nodes Covered'].append(len(set().union(*plex_communities)))\n",
+    "else:\n",
+    "    comparison_data['Avg Size'].append('N/A')\n",
+    "    comparison_data['Min Size'].append('N/A')\n",
+    "    comparison_data['Max Size'].append('N/A')\n",
+    "    comparison_data['Median Size'].append('N/A')\n",
+    "    comparison_data['Total Nodes Covered'].append(0)\n",
+    "\n",
+    "# k-Clan\n",
+    "comparison_data['Method'].append(f'k-Clan (k={k_clan})')\n",
+    "comparison_data['Number of Communities'].append(len(clan_communities))\n",
+    "if clan_sizes:\n",
+    "    comparison_data['Avg Size'].append(f\"{np.mean(clan_sizes):.2f}\")\n",
+    "    comparison_data['Min Size'].append(min(clan_sizes))\n",
+    "    comparison_data['Max Size'].append(max(clan_sizes))\n",
+    "    comparison_data['Median Size'].append(f\"{np.median(clan_sizes):.2f}\")\n",
+    "    comparison_data['Total Nodes Covered'].append(len(set().union(*clan_communities)))\n",
+    "else:\n",
+    "    comparison_data['Avg Size'].append('N/A')\n",
+    "    comparison_data['Min Size'].append('N/A')\n",
+    "    comparison_data['Max Size'].append('N/A')\n",
+    "    comparison_data['Median Size'].append('N/A')\n",
+    "    comparison_data['Total Nodes Covered'].append(0)\n",
+    "\n",
+    "df_comparison = pd.DataFrame(comparison_data)\n",
+    "print(\"\\n\" + \"=\"*80)\n",
+    "print(\"COMPREHENSIVE COMPARISON OF COMMUNITY DETECTION METHODS\")\n",
+    "print(\"=\"*80)\n",
+    "print(df_comparison.to_string(index=False))\n",
+    "print(\"=\"*80)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "2df81061",
+   "metadata": {},
+   "source": [
+    "## 9. Size Distribution Comparison"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "6a86b65b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Plot size distributions\n",
+    "fig, axes = plt.subplots(2, 2, figsize=(14, 10))\n",
+    "fig.suptitle('Community Size Distributions', fontsize=16, fontweight='bold')\n",
+    "\n",
+    "# k-Clique\n",
+    "if clique_sizes:\n",
+    "    axes[0, 0].hist(clique_sizes, bins=20, color='skyblue', edgecolor='black', alpha=0.7)\n",
+    "    axes[0, 0].set_xlabel('Community Size')\n",
+    "    axes[0, 0].set_ylabel('Frequency')\n",
+    "    axes[0, 0].set_title(f'k-Clique (k={k_clique})')\n",
+    "    axes[0, 0].grid(True, alpha=0.3)\n",
+    "else:\n",
+    "    axes[0, 0].text(0.5, 0.5, 'No communities found', ha='center', va='center')\n",
+    "    axes[0, 0].set_title(f'k-Clique (k={k_clique})')\n",
+    "\n",
+    "# k-Core\n",
+    "axes[0, 1].hist(k_core_sizes, bins=20, color='lightcoral', edgecolor='black', alpha=0.7)\n",
+    "axes[0, 1].set_xlabel('Community Size')\n",
+    "axes[0, 1].set_ylabel('Frequency')\n",
+    "axes[0, 1].set_title('k-Core')\n",
+    "axes[0, 1].grid(True, alpha=0.3)\n",
+    "\n",
+    "# k-Plex\n",
+    "if plex_sizes:\n",
+    "    axes[1, 0].hist(plex_sizes, bins=20, color='lightgreen', edgecolor='black', alpha=0.7)\n",
+    "    axes[1, 0].set_xlabel('Community Size')\n",
+    "    axes[1, 0].set_ylabel('Frequency')\n",
+    "    axes[1, 0].set_title(f'k-Plex (k={k_plex})')\n",
+    "    axes[1, 0].grid(True, alpha=0.3)\n",
+    "else:\n",
+    "    axes[1, 0].text(0.5, 0.5, 'No communities found', ha='center', va='center')\n",
+    "    axes[1, 0].set_title(f'k-Plex (k={k_plex})')\n",
+    "\n",
+    "# k-Clan\n",
+    "if clan_sizes:\n",
+    "    axes[1, 1].hist(clan_sizes, bins=20, color='plum', edgecolor='black', alpha=0.7)\n",
+    "    axes[1, 1].set_xlabel('Community Size')\n",
+    "    axes[1, 1].set_ylabel('Frequency')\n",
+    "    axes[1, 1].set_title(f'k-Clan (k={k_clan})')\n",
+    "    axes[1, 1].grid(True, alpha=0.3)\n",
+    "else:\n",
+    "    axes[1, 1].text(0.5, 0.5, 'No communities found', ha='center', va='center')\n",
+    "    axes[1, 1].set_title(f'k-Clan (k={k_clan})')\n",
+    "\n",
+    "plt.tight_layout()\n",
+    "plt.savefig('community_size_distributions.png', dpi=300, bbox_inches='tight')\n",
+    "plt.show()\n",
+    "\n",
+    "print(\"\\nSize distribution visualization saved as 'community_size_distributions.png'\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "3cc0c99c",
+   "metadata": {},
+   "source": [
+    "## 10. Summary and Insights"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "7be090c8",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "print(\"\\n\" + \"=\"*80)\n",
+    "print(\"SUMMARY AND INSIGHTS\")\n",
+    "print(\"=\"*80)\n",
+    "\n",
+    "print(\"\\n1. k-Clique Communities:\")\n",
+    "print(\"   - Identifies communities based on overlapping cliques\")\n",
+    "print(\"   - Tends to find larger, more interconnected communities\")\n",
+    "print(\"   - Communities can overlap (nodes can belong to multiple communities)\")\n",
+    "\n",
+    "print(\"\\n2. k-Core Decomposition:\")\n",
+    "print(\"   - Identifies hierarchical layers of network density\")\n",
+    "print(\"   - Each node is assigned a core number based on degree\")\n",
+    "print(\"   - Higher k-cores represent more tightly connected groups\")\n",
+    "print(\"   - Non-overlapping partition of the network\")\n",
+    "\n",
+    "print(\"\\n3. k-Plex Communities:\")\n",
+    "print(\"   - Relaxed version of cliques (allows some missing edges)\")\n",
+    "print(\"   - More flexible than strict cliques\")\n",
+    "print(\"   - Can identify cohesive subgroups with minor gaps in connectivity\")\n",
+    "\n",
+    "print(\"\\n4. k-Clan Communities:\")\n",
+    "print(\"   - Combines clique structure with diameter constraint\")\n",
+    "print(\"   - Ensures members are within k steps of each other\")\n",
+    "print(\"   - Identifies tightly-knit communities with short paths\")\n",
+    "\n",
+    "print(\"\\n\" + \"=\"*80)\n",
+    "print(\"KEY DIFFERENCES:\")\n",
+    "print(\"=\"*80)\n",
+    "print(\"- k-Clique and k-Clan focus on clique-based structures\")\n",
+    "print(\"- k-Plex allows for relaxed connectivity within communities\")\n",
+    "print(\"- k-Core emphasizes degree-based hierarchy\")\n",
+    "print(\"- k-Clique, k-Plex, and k-Clan can produce overlapping communities\")\n",
+    "print(\"- k-Core produces a strict hierarchical decomposition\")\n",
+    "print(\"=\"*80)"
+   ]
+  }
+ ],
+ "metadata": {
+  "language_info": {
+   "name": "python"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

juneja_codebase-0.1.3.dist-info/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 AJ
+
+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.

juneja_codebase-0.1.3.dist-info/METADATA

@@ -0,0 +1,75 @@
+Metadata-Version: 2.1
+Name: juneja-codebase
+Version: 0.1.3
+Summary: CLI tool to generate academic practical code files for Compiler Design, Data Structures, OS, and DBMS
+Home-page: UNKNOWN
+Author: AJ
+License: UNKNOWN
+Platform: UNKNOWN
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Intended Audience :: Education
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+License-File: LICENSE
+
+# reqcode-aj
+
+A Python CLI tool to generate academic practical code files offline.
+
+## Installation
+
+```bash
+pip install reqcode-aj
+```
+
+## Usage
+
+### Standard Method
+```bash
+# List available subjects
+reqcode --list
+
+# Generate all code files
+reqcode --all
+
+# Generate specific subject
+reqcode --subject compiler_design
+
+# Save to specific directory
+reqcode --all --output ./my_codes
+
+# Create zip file
+reqcode --all --zip
+```
+
+### Alternative Method (Use this in lab/college systems if `reqcode` command doesn't work)
+```bash
+# If you get "command not found" or "not recognized" error, use:
+python -m reqcode_aj.main --list
+python -m reqcode_aj.main --all
+python -m reqcode_aj.main --subject compiler_design
+python -m reqcode_aj.main --all --zip
+```
+
+**Note:** The alternative method works on ALL systems and doesn't require the Scripts folder to be in PATH.
+
+## Subjects Included
+
+1. **Compiler Design** - Lex and Yacc practical files
+2. **Deep Learning** - Deep learning implementations
+3. **Social Network Analysis** - Network analysis code
+
+## Features
+
+- Works completely offline
+- All practical files bundled in the package
+- Perfect for lab practicals and exam preparation
+- No internet required after installation
+
+## License
+
+MIT License
+
+