feat(threads): threads.models, threads.graphs

project/core/management/commands/load_graph_dummy_data.py

@@ -0,0 +1,62 @@
+# data_loader.py
+from django.core.management.base import BaseCommand
+from threads.models import Civi, CiviLink, Thread  # Adjust import to your app's name
+
+from django.contrib.auth import get_user_model
+
+User = get_user_model()
+
+
+class Command(BaseCommand):
+    help = "Load dummy data for Civis and CiviLinks"
+
+    def handle(self, *args, **kwargs):
+        # Create a thread
+        thread, _ = Thread.objects.get_or_create(
+            title="Net Neutrality",
+        )
+        user = User.objects.first()
+        # Create dummy Civis
+        civi1 = Civi.objects.create(
+            title="Civi 1: Importance of Net Neutrality",
+            body="Net neutrality ensures that all users have equal access to information and services online.",
+            author=user,
+            votes_pos=10,
+            votes_neg=2,
+            thread=thread,
+        )
+
+        civi2 = Civi.objects.create(
+            title="Civi 2: Risks of Removing Net Neutrality",
+            body="Without net neutrality, ISPs could prioritize their own content or the content of those who pay for faster access.",
+            author=user,
+            votes_pos=15,
+            votes_neg=1,
+            thread=thread,
+        )
+
+        civi3 = Civi.objects.create(
+            title="Civi 3: Public Opinion on Net Neutrality",
+            body="A significant portion of the public supports net neutrality regulations to protect free internet access.",
+            author=user,
+            votes_pos=20,
+            votes_neg=3,
+            thread=thread,
+        )
+
+        # Create dummy CiviLinks
+        CiviLink.objects.create(
+            from_civi=civi1, to_civi=civi2, relation_type="response"
+        )
+
+        CiviLink.objects.create(
+            from_civi=civi2, to_civi=civi1, relation_type="rebuttal"
+        )
+
+        CiviLink.objects.create(from_civi=civi1, to_civi=civi3, relation_type="support")
+
+        CiviLink.objects.create(
+            from_civi=civi3, to_civi=civi2, relation_type="challenge"
+        )
+
+        self.stdout.write(self.style.SUCCESS("Successfully loaded dummy data"))

project/core/urls.py

@@ -13,6 +13,7 @@
     1. Import the include() function: from django.urls import include, path
     2. Add a URL to urlpatterns:  path('blog/', include('blog.urls'))
 """
+
 from core.router import CiviWikiRouter
 from django.conf import settings
 from django.conf.urls.static import static
@@ -25,6 +26,7 @@
     path("admin/", admin.site.urls),
     path("api/v1/", include(CiviWikiRouter.urls)),
     path("api/", include("threads.urls.api")),
+    path("api/", include("threads.urls.graph_api")),
     path("", include("accounts.urls")),
     path("", include("threads.urls.urls")),
     path(

project/threads/graph_api.py

@@ -0,0 +1,87 @@
+from rest_framework.decorators import api_view
+from rest_framework.response import Response
+from .graphs import (
+    load_graph_from_db,
+    most_caused_problems,
+    most_effective_solution,
+    shortest_path_problem_to_solution,
+)
+
+
+@api_view(["GET"])
+def get_most_caused_problem(request):
+    with_score = request.GET.get("with_score", False)
+    G = load_graph_from_db(with_score)
+    problem = most_caused_problems(G)
+    if problem:
+        if with_score:
+            return Response(
+                {
+                    "problem": G.nodes[problem]["label"],
+                    "score": G.nodes[problem]["score"],
+                }
+            )
+        else:
+            return Response({"problem": G.nodes[problem]["label"]})
+    return Response({"error": "No problem found"}, status=404)
+
+
+@api_view(["GET"])
+def get_most_effective_solution(request):
+    with_score = request.GET.get("with_score", False)
+    G = load_graph_from_db(with_score)
+    solution = most_effective_solution(G)
+    if solution:
+        if with_score:
+            return Response(
+                {
+                    "solution": G.nodes[solution]["label"],
+                    "score": G.nodes[solution]["score"],
+                }
+            )
+        else:
+            return Response({"solution": G.nodes[solution]["label"]})
+    return Response({"error": "No solution found"}, status=404)
+
+
+@api_view(["GET"])
+def get_shortest_path(request, problem_id, solution_id):
+    with_score = request.GET.get("with_score", False)
+    G = load_graph_from_db(with_score)
+    path = shortest_path_problem_to_solution(G, int(problem_id), int(solution_id))
+    if path:
+        path_labels = [G.nodes[node]["label"] for node in path]
+        return Response({"path_labels": path_labels, "path":path})
+    return Response({"error": "No path found"}, status=404)
+
+
+
+
+@api_view(['GET'])
+def get_graph_data(request):
+    G = load_graph_from_db()  # Load the graph from your DB or other data source
+    nodes = []
+    edges = []
+
+    # Format nodes and edges to match Cytoscape format
+    for node, attr in G.nodes(data=True):
+        nodes.append({
+            'data': {
+                'id': node,
+                'label': attr.get('label', node),
+                'type': attr.get('type'),
+                'score': attr.get('score', 0),
+            }
+        })
+
+    for source, target, attr in G.edges(data=True):
+        edges.append({
+            'data': {
+                'id': f'{source}-{target}',
+                'source': source,
+                'target': target,
+                'label': attr.get('label', 'related')
+            }
+        })
+
+    return Response({'nodes': nodes, 'edges': edges})

project/threads/graphs.py

@@ -0,0 +1,42 @@
+import networkx as nx
+from .models import Civi, CiviLink
+
+
+def load_graph_from_db(with_score:bool=False):
+    # Create a directed graph
+    G = nx.DiGraph()
+
+    # Add all Civis as nodes
+    for civi in Civi.objects.all():
+        node_args, node_kwargs = civi.__node__(with_score=with_score)
+        G.add_node(*node_args, **node_kwargs)
+
+    # Add CiviLinks as edges
+    for link in CiviLink.objects.all():
+        edge_args, edge_kwargs = link.__edge__()
+        G.add_edge(*edge_args, **edge_kwargs)
+
+    return G
+
+
+def most_caused_problems(G, with_score:bool=False):
+    problem_nodes = [n for n, attr in G.nodes(data=True) if attr["type"] == "Problem"]
+    if with_score:
+      return max(problem_nodes, key=lambda n: (G.in_degree(n), G.nodes[n]['score']), default=None)
+    return max(problem_nodes, key=lambda n: G.in_degree(n), default=None)
+
+
+def most_effective_solution(G, with_score:bool=False):
+    solution_nodes = [n for n, attr in G.nodes(data=True) if attr["type"] == "Solution"]
+    if with_score:
+      return max(solution_nodes, key=lambda n: (G.out_degree(n), G.nodes[n]['score']), default=None)
+    return max(solution_nodes, key=lambda n: G.out_degree(n), default=None)
+
+
+def shortest_path_problem_to_solution(G, problem_id, solution_id, with_score:bool=False):
+    try:
+        if with_score:
+          return nx.shortest_path(G, source=problem_id, target=solution_id, weight='weight')
+        return nx.shortest_path(G, source=problem_id, target=solution_id)
+    except nx.NetworkXNoPath:
+        return None