tahamajs's picture
download
raw
67.7 kB
# notes/views.py import csv import json import logging from datetime import timedelta from io import StringIO from django.db.models import Count, Q from django.http import Http404, HttpResponse from django.shortcuts import get_object_or_404 from django.utils import timezone from rest_framework import status from rest_framework.decorators import api_view, permission_classes from rest_framework.pagination import PageNumberPagination from rest_framework.permissions import AllowAny, IsAuthenticated from rest_framework.response import Response from .filters import NoteFilter from .models import NoteMention, ResearcherNote, WebhookSubscription from .serializers import ( NoteImageSerializer, ResearcherNoteSerializer, WebhookSubscriptionSerializer, ) logger = logging.getLogger(__name__) class StandardPagination(PageNumberPagination): page_size = 20 page_size_query_param = "page_size" max_page_size = 100 from django.contrib.postgres.search import SearchQuery, SearchRank, SearchVector from .models import NoteComment, NoteTemplate, Notification # ─── به ابتدای فایل اضافه کنید ─── from .report_generator import generate_experiment_report # ═══════════════════════════════════════════════════════════════════ # 18. Auto-Generate Experiment Report # ═══════════════════════════════════════════════════════════════════ @api_view(["POST"]) @permission_classes([IsAuthenticated]) def generate_run_report(request, run_id, version="v1"): """Auto-generate a rich Markdown report from a training run.""" note = generate_experiment_report(run_id=run_id, author=request.user, save=True) if note is None: return Response({"error": "Run not found"}, status=404) serializer = ResearcherNoteSerializer(note) return Response(serializer.data, status=status.HTTP_201_CREATED) # ═══════════════════════════════════════════════════════════════════ # 19. Note Templates # ═══════════════════════════════════════════════════════════════════ @api_view(["GET", "POST"]) @permission_classes([IsAuthenticated]) def note_templates(request, version="v1"): """List all templates or create a new one.""" if request.method == "GET": note_type = request.query_params.get("note_type") templates = NoteTemplate.objects.all() if note_type: templates = templates.filter(note_type=note_type) data = [ { "id": str(t.id), "name": t.name, "description": t.description, "note_type": t.note_type, "variables_schema": t.variables_schema, "is_default": t.is_default, } for t in templates ] return Response(data) elif request.method == "POST": template = NoteTemplate.objects.create( name=request.data.get("name", "Untitled Template"), description=request.data.get("description", ""), note_type=request.data.get("note_type", "general"), content_template=request.data.get("content_template", ""), variables_schema=request.data.get("variables_schema", {}), created_by=request.user, ) return Response({"id": str(template.id), "status": "created"}, status=201) @api_view(["POST"]) @permission_classes([IsAuthenticated]) def render_template(request, template_id, version="v1"): """Render a template with provided variables and create a note.""" template = get_object_or_404(NoteTemplate, id=template_id) variables = request.data.get("variables", {}) content = template.render(variables) note = ResearcherNote.objects.create( author=request.user, title=request.data.get("title", template.name), content=content, note_type=template.note_type, tags=request.data.get("tags", []), run_id=request.data.get("run_id"), ) serializer = ResearcherNoteSerializer(note) return Response(serializer.data, status=201) # ═══════════════════════════════════════════════════════════════════ # 20. Full-Text Search # ═══════════════════════════════════════════════════════════════════ @api_view(["GET"]) @permission_classes([IsAuthenticated]) def fulltext_search(request, version="v1"): """Full-text search across all notes using PostgreSQL.""" query = request.query_params.get("q", "").strip() if not query: return Response({"results": [], "total": 0}) search_query = SearchQuery(query, config="english") search_vector = SearchVector("title", weight="A", config="english") + SearchVector( "content", weight="B", config="english" ) notes = ( ResearcherNote.objects.filter(deleted_at__isnull=True) .annotate(rank=SearchRank(search_vector, search_query)) .filter(rank__gte=0.05) .order_by("-rank") ) if not request.user.is_staff: notes = notes.filter(models.Q(is_public=True) | models.Q(author=request.user)) paginator = StandardPagination() page = paginator.paginate_queryset(notes, request) data = [ { "id": str(n.id), "title": n.title, "content_preview": n.content[:300], "author": n.author.username, "note_type": n.note_type, "tags": n.tags, "rank": round(n.rank, 4), "created_at": n.created_at, } for n in page ] return paginator.get_paginated_response(data) # ═══════════════════════════════════════════════════════════════════ # 21. Favorite / Bookmark # ═══════════════════════════════════════════════════════════════════ @api_view(["POST"]) @permission_classes([IsAuthenticated]) def toggle_favorite(request, note_id, version="v1"): """Toggle favorite/bookmark status of a note.""" note = get_object_or_404(ResearcherNote, id=note_id, deleted_at__isnull=True) if not note.is_public and note.author != request.user: return Response({"error": "Not allowed"}, status=403) note.toggle_favorite() return Response({"is_favorite": note.is_favorite}) @api_view(["GET"]) @permission_classes([IsAuthenticated]) def favorite_notes(request, version="v1"): """List all favorite/bookmarked notes for the user.""" notes = ResearcherNote.objects.filter( author=request.user, is_favorite=True, deleted_at__isnull=True ).order_by("-updated_at") paginator = StandardPagination() page = paginator.paginate_queryset(notes, request) serializer = ResearcherNoteSerializer(page, many=True) return paginator.get_paginated_response(serializer.data) # ═══════════════════════════════════════════════════════════════════ # 22. Comments on Notes # ═══════════════════════════════════════════════════════════════════ @api_view(["GET", "POST"]) @permission_classes([IsAuthenticated]) def note_comments(request, note_id, version="v1"): """Get or add comments on a note.""" note = get_object_or_404(ResearcherNote, id=note_id, deleted_at__isnull=True) if request.method == "GET": comments = note.comments.filter(parent_comment__isnull=True).order_by( "created_at" ) data = [ { "id": str(c.id), "author": c.author.username, "content": c.content, "is_resolved": c.is_resolved, "created_at": c.created_at, "replies": [ { "id": str(r.id), "author": r.author.username, "content": r.content, "created_at": r.created_at, } for r in c.replies.all() ], } for c in comments ] return Response(data) elif request.method == "POST": comment = NoteComment.objects.create( note=note, author=request.user, content=request.data.get("content", ""), parent_comment_id=request.data.get("parent_comment_id"), ) return Response({"id": str(comment.id), "status": "created"}, status=201) # ═══════════════════════════════════════════════════════════════════ # 23. Dashboard / Analytics # ═══════════════════════════════════════════════════════════════════ @api_view(["GET"]) @permission_classes([IsAuthenticated]) def notes_dashboard(request, version="v1"): """Analytics dashboard for notes.""" base_qs = ResearcherNote.objects.filter(deleted_at__isnull=True) user_qs = base_qs.filter(author=request.user) return Response( { "total_notes": base_qs.count(), "my_notes": user_qs.count(), "public_notes": base_qs.filter(is_public=True).count(), "favorites": user_qs.filter(is_favorite=True).count(), "pinned": user_qs.filter(is_pinned=True).count(), "by_type": { t[0]: user_qs.filter(note_type=t[0]).count() for t in ResearcherNote.NOTE_TYPES }, "by_tag": _tag_distribution(user_qs), "recent_activity": list( user_qs.order_by("-updated_at")[:5].values( "id", "title", "note_type", "updated_at" ) ), "linked_runs": user_qs.filter(run__isnull=False).count(), "total_comments": NoteComment.objects.filter( note__author=request.user ).count(), "total_mentions": NoteMention.objects.filter( mentioned_user=request.user, is_read=False ).count(), } ) def _tag_distribution(queryset): """Compute tag frequency across notes.""" tag_counts = {} for note in queryset: for tag in note.tags or []: tag_counts[tag] = tag_counts.get(tag, 0) + 1 return dict(sorted(tag_counts.items(), key=lambda x: x[1], reverse=True)[:20]) # ═══════════════════════════════════════════════════════════════════ # 24. Export as Markdown # ═══════════════════════════════════════════════════════════════════ @api_view(["GET"]) @permission_classes([IsAuthenticated]) def export_note_markdown(request, note_id, version="v1"): """Export note as raw Markdown file.""" note = get_object_or_404(ResearcherNote, id=note_id, deleted_at__isnull=True) if not note.is_public and note.author != request.user: return Response({"error": "Not allowed"}, status=403) md_content = f"""--- title: "{note.title}" author: "{note.author.username}" date: "{note.created_at.isoformat()}" tags: {json.dumps(note.tags)} note_type: "{note.note_type}" version: {note.version} --- {note.content} """ response = HttpResponse(md_content, content_type="text/markdown") response["Content-Disposition"] = ( f'attachment; filename="note_{note.slug or note.id}.md"' ) return response # ═══════════════════════════════════════════════════════════════════ # 25. Notifications # ═══════════════════════════════════════════════════════════════════ @api_view(["GET"]) @permission_classes([IsAuthenticated]) def my_notifications(request, version="v1"): """List user's notifications.""" notifs = Notification.objects.filter(recipient=request.user).order_by("-created_at") unread_only = request.query_params.get("unread_only", "false").lower() == "true" if unread_only: notifs = notifs.filter(is_read=False) paginator = StandardPagination() page = paginator.paginate_queryset(notifs, request) data = [ { "id": str(n.id), "type": n.type, "content": n.content, "sender": n.sender.username if n.sender else None, "note_id": str(n.note_id) if n.note else None, "is_read": n.is_read, "created_at": n.created_at, } for n in page ] return paginator.get_paginated_response(data) @api_view(["POST"]) @permission_classes([IsAuthenticated]) def mark_all_notifications_read(request, version="v1"): """Mark all notifications as read.""" Notification.objects.filter(recipient=request.user, is_read=False).update( is_read=True ) return Response({"status": "all marked read"}) # ---------------------------------------------------------------------- # 1. Note List & Create # ---------------------------------------------------------------------- @api_view(["GET", "POST"]) @permission_classes([IsAuthenticated]) def note_list(request, version="v1"): if request.method == "GET": notes = ResearcherNote.objects.filter(deleted_at__isnull=True) filter_set = NoteFilter(request.query_params, queryset=notes) notes = filter_set.qs if not request.user.is_staff: notes = notes.filter(Q(is_public=True) | Q(author=request.user)) if request.query_params.get("export") == "csv": return export_notes_csv(notes) if request.query_params.get("export") == "json": serializer = ResearcherNoteSerializer(notes, many=True) return Response(serializer.data) paginator = StandardPagination() page = paginator.paginate_queryset(notes, request) serializer = ResearcherNoteSerializer(page, many=True) return paginator.get_paginated_response(serializer.data) elif request.method == "POST": serializer = ResearcherNoteSerializer(data=request.data) if serializer.is_valid(): note = serializer.save(author=request.user) logger.info( "Note created", extra={ "user": request.user.username, "note_id": str(note.id), "event": "note.created", }, ) return Response(serializer.data, status=status.HTTP_201_CREATED) return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST) # ---------------------------------------------------------------------- # 2. Note Detail, Update, Delete # ---------------------------------------------------------------------- @api_view(["GET", "PUT", "PATCH", "DELETE"]) @permission_classes([IsAuthenticated]) def note_detail(request, note_id, version="v1"): note = get_object_or_404(ResearcherNote, id=note_id, deleted_at__isnull=True) # ----- Privacy & Permission Guard ----- if not note.is_public and note.author != request.user and not request.user.is_staff: # For GET requests, hide the existence of the note entirely if request.method == "GET": raise Http404 # For any modifying request, return Forbidden (403) return Response({"error": "Not allowed"}, status=403) # For GET, everyone who passed the guard can see the note if request.method == "GET": serializer = ResearcherNoteSerializer(note) return Response(serializer.data) # For modifying requests, only author or staff are allowed if note.author != request.user and not request.user.is_staff: return Response({"error": "Not allowed"}, status=403) if request.method == "PUT" or request.method == "PATCH": partial = request.method == "PATCH" serializer = ResearcherNoteSerializer(note, data=request.data, partial=partial) if serializer.is_valid(): serializer.save() if "content" in request.data: logger.info( "Note updated", extra={ "user": request.user.username, "note_id": str(note.id), "event": "note.updated", }, ) return Response(serializer.data) return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST) elif request.method == "DELETE": note.soft_delete() logger.info( "Note deleted", extra={ "user": request.user.username, "note_id": str(note.id), "event": "note.deleted", }, ) return Response(status=status.HTTP_204_NO_CONTENT) # ---------------------------------------------------------------------- # 3. Reactions # ---------------------------------------------------------------------- @api_view(["POST"]) @permission_classes([IsAuthenticated]) def note_reaction(request, note_id, version="v1"): note = get_object_or_404(ResearcherNote, id=note_id, deleted_at__isnull=True) reaction_type = request.data.get("reaction") if not reaction_type: return Response({"error": "reaction type required"}, status=400) reactions = note.reactions or {} users = reactions.get(reaction_type, []) if request.user.username in users: users.remove(request.user.username) else: users.append(request.user.username) reactions[reaction_type] = users note.reactions = reactions note.save() logger.info( "Reaction added", extra={ "user": request.user.username, "note_id": str(note.id), "reaction": reaction_type, }, ) return Response({"status": "updated", "reactions": reactions}) # ---------------------------------------------------------------------- # 4. Image Upload # ---------------------------------------------------------------------- @api_view(["POST"]) @permission_classes([IsAuthenticated]) def upload_note_image(request, note_id, version="v1"): note = get_object_or_404(ResearcherNote, id=note_id) if note.author != request.user: return Response({"error": "Not allowed"}, status=403) serializer = NoteImageSerializer(data=request.data) if serializer.is_valid(): serializer.save(note=note) return Response(serializer.data, status=201) return Response(serializer.errors, status=400) # ---------------------------------------------------------------------- # 5. Bulk Operations # ---------------------------------------------------------------------- @api_view(["POST"]) @permission_classes([IsAuthenticated]) def bulk_notes(request, version="v1"): action = request.data.get("action") if not action: return Response({"error": "action required"}, status=400) if action == "delete": note_ids = request.data.get("ids", []) notes = ResearcherNote.objects.filter( id__in=note_ids, author=request.user, deleted_at__isnull=True ) count = notes.count() for note in notes: note.soft_delete() return Response({"deleted": count}) elif action == "create": items = request.data.get("items", []) created = [] for item in items: serializer = ResearcherNoteSerializer(data=item) if serializer.is_valid(): note = serializer.save(author=request.user) created.append(str(note.id)) else: return Response(serializer.errors, status=400) return Response({"created": created}) return Response({"error": f"Unknown action {action}"}, status=400) # ---------------------------------------------------------------------- # 6. Export CSV # ---------------------------------------------------------------------- def export_notes_csv(queryset): output = StringIO() writer = csv.writer(output) writer.writerow(["ID", "Title", "Author", "Run ID", "Tags", "Created At"]) for note in queryset: writer.writerow( [ note.id, note.title, note.author.username, note.run_id, ",".join(note.tags), note.created_at, ] ) response = HttpResponse(output.getvalue(), content_type="text/csv") response["Content-Disposition"] = 'attachment; filename="notes_export.csv"' return response # ---------------------------------------------------------------------- # 7. Webhook Management # ---------------------------------------------------------------------- @api_view(["GET", "POST"]) @permission_classes([IsAuthenticated]) def webhook_list(request, version="v1"): if request.method == "GET": subs = WebhookSubscription.objects.filter(user=request.user) serializer = WebhookSubscriptionSerializer(subs, many=True) return Response(serializer.data) elif request.method == "POST": serializer = WebhookSubscriptionSerializer(data=request.data) if serializer.is_valid(): serializer.save(user=request.user) return Response(serializer.data, status=201) return Response(serializer.errors, status=400) @api_view(["DELETE"]) @permission_classes([IsAuthenticated]) def webhook_delete(request, webhook_id, version="v1"): sub = get_object_or_404(WebhookSubscription, id=webhook_id, user=request.user) sub.delete() return Response(status=204) # ---------------------------------------------------------------------- # 8. Versioned URL wrapper # ---------------------------------------------------------------------- def versioned_view(view_func): from functools import wraps from django.views.decorators.csrf import csrf_exempt @csrf_exempt @wraps(view_func) def wrapper(request, *args, **kwargs): version = request.resolver_match.kwargs.get("version", "v1") return view_func(request, version=version, *args, **kwargs) return wrapper # ---------------------------------------------------------------------- # 9. Note Versions (history) # ---------------------------------------------------------------------- @api_view(["GET"]) @permission_classes([IsAuthenticated]) def note_versions(request, note_id, version="v1"): note = get_object_or_404(ResearcherNote, id=note_id, deleted_at__isnull=True) if not request.user.is_staff and note.author != request.user: return Response({"error": "Not allowed"}, status=403) versions = note.versions.all().order_by("-version_number") data = [ { "version": v.version_number, "content_preview": v.content_snapshot[:200], "changed_by": v.changed_by.username if v.changed_by else None, "change_reason": v.change_reason, "created_at": v.created_at, } for v in versions ] return Response(data) @api_view(["GET"]) @permission_classes([IsAuthenticated]) def note_version_detail(request, note_id, version_number, version="v1"): note = get_object_or_404(ResearcherNote, id=note_id, deleted_at__isnull=True) if not request.user.is_staff and note.author != request.user: return Response({"error": "Not allowed"}, status=403) version_obj = get_object_or_404(note.versions, version_number=version_number) return Response( { "version": version_obj.version_number, "title": version_obj.title_snapshot or note.title, "content": version_obj.content_snapshot, "changed_by": ( version_obj.changed_by.username if version_obj.changed_by else None ), "change_reason": version_obj.change_reason, "created_at": version_obj.created_at, } ) # ---------------------------------------------------------------------- # 10. Mentions # ---------------------------------------------------------------------- @api_view(["GET"]) @permission_classes([IsAuthenticated]) def note_mentions(request, note_id, version="v1"): note = get_object_or_404(ResearcherNote, id=note_id, deleted_at__isnull=True) if not request.user.is_staff and note.author != request.user: return Response({"error": "Not allowed"}, status=403) mentions = note.mentions.select_related("mentioned_user").all() data = [ { "user": m.mentioned_user.username, "is_read": m.is_read, "created_at": m.created_at, } for m in mentions ] return Response(data) @api_view(["POST"]) @permission_classes([IsAuthenticated]) def mark_mention_read(request, mention_id, version="v1"): mention = get_object_or_404(NoteMention, id=mention_id, mentioned_user=request.user) mention.is_read = True mention.save() return Response({"status": "marked_read"}) # ---------------------------------------------------------------------- # 11. Replies # ---------------------------------------------------------------------- @api_view(["GET"]) @permission_classes([IsAuthenticated]) def note_replies(request, note_id, version="v1"): note = get_object_or_404( ResearcherNote, id=note_id, deleted_at__isnull=True, parent_note__isnull=True ) replies = note.replies.filter(deleted_at__isnull=True).order_by("created_at") serializer = ResearcherNoteSerializer(replies, many=True) return Response(serializer.data) # ---------------------------------------------------------------------- # 12. Restore # ---------------------------------------------------------------------- @api_view(["POST"]) @permission_classes([IsAuthenticated]) def restore_note(request, note_id, version="v1"): note = get_object_or_404(ResearcherNote, id=note_id, deleted_at__isnull=False) if note.author != request.user and not request.user.is_staff: return Response({"error": "Not allowed"}, status=403) note.deleted_at = None note.save(update_fields=["deleted_at"]) logger.info( "Note restored", extra={ "user": request.user.username, "note_id": str(note.id), "event": "note.restored", }, ) return Response({"status": "restored"}) # ---------------------------------------------------------------------- # 13. Export as PDF # ---------------------------------------------------------------------- @api_view(["GET"]) @permission_classes([IsAuthenticated]) def export_note_pdf(request, note_id, version="v1"): note = get_object_or_404(ResearcherNote, id=note_id, deleted_at__isnull=True) if not note.is_public and note.author != request.user: return Response({"error": "Not allowed"}, status=403) from weasyprint import HTML html_content = f""" <html> <head><title>{note.title or 'Note'}</title></head> <body> <h1>{note.title or 'Untitled'}</h1> <p>Author: {note.author.username}</p> <p>Created: {note.created_at}</p> <hr> <div>{note.content}</div> </body> </html> """ pdf_file = HTML(string=html_content).write_pdf() response = HttpResponse(pdf_file, content_type="application/pdf") response["Content-Disposition"] = f'attachment; filename="note_{note_id}.pdf"' return response # ---------------------------------------------------------------------- # 14. Test Webhook # ---------------------------------------------------------------------- @api_view(["POST"]) @permission_classes([IsAuthenticated]) def test_webhook(request, webhook_id, version="v1"): from .webhook_utils import manual_send sub = get_object_or_404(WebhookSubscription, id=webhook_id, user=request.user) test_payload = { "event": "test", "timestamp": timezone.now().isoformat(), "data": {"message": "This is a test webhook payload"}, } success = manual_send(sub.url, test_payload, sub.secret) return Response({"success": success, "url": sub.url}) # ---------------------------------------------------------------------- # 15. Statistics # ---------------------------------------------------------------------- @api_view(["GET"]) @permission_classes([IsAuthenticated]) def notes_statistics(request, version="v1"): total_notes = ResearcherNote.objects.filter(deleted_at__isnull=True).count() public_notes = ResearcherNote.objects.filter( deleted_at__isnull=True, is_public=True ).count() notes_by_author = ( ResearcherNote.objects.filter(deleted_at__isnull=True) .values("author__username") .annotate(count=Count("id")) .order_by("-count")[:10] ) notes_by_run = ( ResearcherNote.objects.filter(deleted_at__isnull=True, run__isnull=False) .values("run__id") .annotate(count=Count("id")) .order_by("-count")[:10] ) return Response( { "total_notes": total_notes, "public_notes": public_notes, "private_notes": total_notes - public_notes, "top_authors": list(notes_by_author), "top_runs": list(notes_by_run), } ) # ---------------------------------------------------------------------- # 16. Recent Notes # ---------------------------------------------------------------------- @api_view(["GET"]) @permission_classes([IsAuthenticated]) def recent_notes(request, version="v1"): days = int(request.query_params.get("days", 7)) cutoff = timezone.now() - timedelta(days=days) notes = ResearcherNote.objects.filter( deleted_at__isnull=True, updated_at__gte=cutoff ).order_by("-updated_at") if not request.user.is_staff: notes = notes.filter(Q(is_public=True) | Q(author=request.user)) paginator = StandardPagination() page = paginator.paginate_queryset(notes, request) serializer = ResearcherNoteSerializer(page, many=True) return paginator.get_paginated_response(serializer.data) # ---------------------------------------------------------------------- # 17. Bulk Tag Operations # ---------------------------------------------------------------------- @api_view(["PATCH"]) @permission_classes([IsAuthenticated]) def bulk_tags(request, version="v1"): action = request.data.get("action") note_ids = request.data.get("ids", []) tags = request.data.get("tags", []) if not action or not note_ids or not tags: return Response({"error": "action, ids, and tags required"}, status=400) notes = ResearcherNote.objects.filter( id__in=note_ids, author=request.user, deleted_at__isnull=True ) if action == "add": for note in notes: new_tags = list(set(note.tags + tags)) note.tags = new_tags note.save(update_fields=["tags"]) elif action == "remove": for note in notes: new_tags = [t for t in note.tags if t not in tags] note.tags = new_tags note.save(update_fields=["tags"]) else: return Response({"error": "action must be 'add' or 'remove'"}, status=400) return Response({"updated": notes.count()}) @api_view(["GET"]) @permission_classes([IsAuthenticated]) def run_notes(request, run_id): """Get all notes linked to a specific training run.""" notes = ResearcherNote.objects.filter( run__id=run_id, deleted_at__isnull=True ).order_by("-created_at") if not request.user.is_staff: notes = notes.filter(Q(is_public=True) | Q(author=request.user)) paginator = StandardPagination() page = paginator.paginate_queryset(notes, request) serializer = ResearcherNoteSerializer(page, many=True) return paginator.get_paginated_response(serializer.data) @api_view(["POST"]) @permission_classes([IsAuthenticated]) def share_note(request, note_id): note = get_object_or_404(ResearcherNote, id=note_id) if note.author != request.user: return Response({"error": "Only the author can share"}, status=403) username = request.data.get("username") if not username: return Response({"error": "username required"}, status=400) try: user_to_share = User.objects.get(username=username) except User.DoesNotExist: return Response({"error": "User not found"}, status=404) note.shared_with.add(user_to_share) # After note.shared_with.add(user_to_share) from experiment.activity import log_activity log_activity( user=request.user, action_type="share", description=f'Shared note "{note.title or "Untitled"}" with {user_to_share.username}', content_object=note, metadata={"note_id": str(note.id), "shared_with": user_to_share.username}, ) return Response( { "status": "shared", "shared_with": [u.username for u in note.shared_with.all()], } ) @api_view(["POST"]) @permission_classes([IsAuthenticated]) def unshare_note(request, note_id): note = get_object_or_404(ResearcherNote, id=note_id) if note.author != request.user: return Response({"error": "Only the author can unshare"}, status=403) username = request.data.get("username") if not username: return Response({"error": "username required"}, status=400) note.shared_with.remove(User.objects.get(username=username)) return Response({"status": "unshared"}) @api_view(["GET"]) @permission_classes([IsAuthenticated]) def shared_with_me(request): notes = ResearcherNote.objects.filter( shared_with=request.user, deleted_at__isnull=True ) serializer = ResearcherNoteSerializer(notes, many=True) return Response(serializer.data) @api_view(["PATCH"]) @permission_classes([IsAuthenticated]) def toggle_pin(request, note_id): note = get_object_or_404(ResearcherNote, id=note_id) if note.author != request.user: return Response({"error": "Not allowed"}, status=403) note.pinned = not note.pinned note.save(update_fields=["pinned"]) return Response({"pinned": note.pinned}) # notes/views.py – add at the bottom from .hf_upload import upload_note_to_hub # ═══════════════════════════════════════════════════════════════════ # 26. HuggingFace Upload # ═══════════════════════════════════════════════════════════════════ @api_view(["POST"]) @permission_classes([IsAuthenticated]) def upload_note_to_huggingface(request, note_id, version="v1"): """Upload a note to HuggingFace Hub as a Markdown dataset/space.""" note = get_object_or_404(ResearcherNote, id=note_id, deleted_at__isnull=True) if note.author != request.user and not request.user.is_staff: return Response({"error": "Not allowed"}, status=403) try: hub_url = upload_note_to_hub(note) note.metadata["hf_url"] = hub_url note.save(update_fields=["metadata"]) return Response({"status": "uploaded", "url": hub_url}) except Exception as e: return Response({"error": str(e)}, status=500) # ═══════════════════════════════════════════════════════════════════ # 27. Workspace CRUD # ═══════════════════════════════════════════════════════════════════ @api_view(["GET", "POST"]) @permission_classes([IsAuthenticated]) def workspace_list(request, version="v1"): if request.method == "GET": workspaces = Workspace.objects.filter( models.Q(created_by=request.user) | models.Q(members=request.user) ).distinct() data = [ { "id": str(w.id), "name": w.name, "description": w.description, "member_count": w.members.count(), "is_archived": w.is_archived, } for w in workspaces ] return Response(data) elif request.method == "POST": workspace = Workspace.objects.create( name=request.data.get("name", "Untitled"), description=request.data.get("description", ""), created_by=request.user, ) return Response({"id": str(workspace.id), "status": "created"}, status=201) @api_view(["POST"]) @permission_classes([IsAuthenticated]) def workspace_add_note(request, workspace_id, note_id, version="v1"): workspace = get_object_or_404(Workspace, id=workspace_id) note = get_object_or_404(ResearcherNote, id=note_id) workspace.notes.add(note) return Response({"status": "added"}) # (You can add more workspace endpoints similarly) # ═══════════════════════════════════════════════════════════════════ # 28. Task CRUD # ═══════════════════════════════════════════════════════════════════ @api_view(["GET", "POST"]) @permission_classes([IsAuthenticated]) def task_list(request, note_id, version="v1"): note = get_object_or_404(ResearcherNote, id=note_id) if request.method == "GET": tasks = note.tasks.all() data = [ { "id": str(t.id), "title": t.title, "status": t.status, "due_date": t.due_date, "assigned_to": t.assigned_to.username if t.assigned_to else None, } for t in tasks ] return Response(data) elif request.method == "POST": task = Task.objects.create( note=note, title=request.data.get("title", ""), description=request.data.get("description", ""), assigned_to_id=request.data.get("assigned_to"), status=request.data.get("status", "pending"), due_date=request.data.get("due_date"), ) return Response({"id": str(task.id)}, status=201) @api_view(["PATCH"]) @permission_classes([IsAuthenticated]) def task_update(request, note_id, task_id, version="v1"): task = get_object_or_404(Task, id=task_id, note_id=note_id) if request.data.get("status"): task.status = request.data["status"] task.save() return Response({"status": "updated"}) # ═══════════════════════════════════════════════════════════════════ # 29. Model Registry # ═══════════════════════════════════════════════════════════════════ @api_view(["GET", "POST"]) @permission_classes([IsAuthenticated]) def model_registry_list(request, version="v1"): if request.method == "GET": models_qs = ModelRegistry.objects.filter(created_by=request.user) data = [ { "id": str(m.id), "name": m.name, "version": m.version, "stage": m.stage, "created_at": m.created_at, } for m in models_qs ] return Response(data) elif request.method == "POST": registry = ModelRegistry.objects.create( name=request.data["name"], version=request.data["version"], description=request.data.get("description", ""), stage=request.data.get("stage", "development"), created_by=request.user, ) return Response({"id": str(registry.id)}, status=201) # ═══════════════════════════════════════════════════════════════════ # 30. Note Links # ═══════════════════════════════════════════════════════════════════ @api_view(["POST"]) @permission_classes([IsAuthenticated]) def create_note_link(request, version="v1"): source_id = request.data.get("source_id") target_id = request.data.get("target_id") link_type = request.data.get("link_type", "related") source = get_object_or_404(ResearcherNote, id=source_id, author=request.user) target = get_object_or_404(ResearcherNote, id=target_id) link, created = NoteLink.objects.get_or_create( source=source, target=target, defaults={"link_type": link_type} ) return Response({"status": "created" if created else "already_exists"}) # notes/views.py — append at the bottom of the file from .hf_upload import sync_note_to_hf, upload_note_as_space from .models import Artifact, NoteLink, Protocol, ShareableLink # ═══════════════════════════════════════════════════════════════════ # 26. HuggingFace Upload — as Dataset or Space (free hosting) # ═══════════════════════════════════════════════════════════════════ @api_view(["POST"]) @permission_classes([IsAuthenticated]) def upload_note_to_huggingface(request, note_id, version="v1"): """Upload a note to HuggingFace as a Dataset (publicly viewable).""" note = get_object_or_404(ResearcherNote, id=note_id, deleted_at__isnull=True) if note.author != request.user and not request.user.is_staff: return Response({"error": "Not allowed"}, status=403) try: make_public = request.data.get("make_public", True) repo_type = request.data.get("repo_type", "dataset") result = upload_note_to_hub(note, repo_type=repo_type, make_public=make_public) # Store URL in metadata note.metadata = note.metadata or {} note.metadata["hf_url"] = result["url"] note.metadata["hf_repo_id"] = result["repo_id"] note.save(update_fields=["metadata"]) return Response(result) except Exception as e: return Response({"error": str(e)}, status=500) @api_view(["POST"]) @permission_classes([IsAuthenticated]) def upload_note_as_hf_space(request, note_id, version="v1"): """Upload a note to HuggingFace as a static Space (free web hosting).""" note = get_object_or_404(ResearcherNote, id=note_id, deleted_at__isnull=True) if note.author != request.user and not request.user.is_staff: return Response({"error": "Not allowed"}, status=403) try: result = upload_note_as_space(note) note.metadata = note.metadata or {} note.metadata["hf_space_url"] = result["url"] note.save(update_fields=["metadata"]) return Response(result) except Exception as e: return Response({"error": str(e)}, status=500) @api_view(["POST"]) @permission_classes([IsAuthenticated]) def sync_note_to_hf_view(request, note_id, version="v1"): """Sync updated note content to HuggingFace.""" note = get_object_or_404(ResearcherNote, id=note_id, deleted_at__isnull=True) if note.author != request.user: return Response({"error": "Not allowed"}, status=403) result = sync_note_to_hf(note) return Response(result) # ═══════════════════════════════════════════════════════════════════ # 27. Shareable Links — generate, view, revoke # ═══════════════════════════════════════════════════════════════════ @api_view(["POST"]) @permission_classes([IsAuthenticated]) def create_share_link(request, note_id, version="v1"): """Create a public share link for a note.""" note = get_object_or_404(ResearcherNote, id=note_id, deleted_at__isnull=True) if note.author != request.user: return Response({"error": "Not allowed"}, status=403) expires_in_days = request.data.get("expires_in_days") expires_at = ( timezone.now() + timedelta(days=expires_in_days) if expires_in_days else None ) link = ShareableLink.objects.create( note=note, created_by=request.user, password=request.data.get("password", ""), expires_at=expires_at, max_views=request.data.get("max_views"), ) return Response( { "id": str(link.id), "token": link.token, "url": link.public_url, "expires_at": link.expires_at, "is_active": link.is_active, }, status=201, ) @api_view(["GET"]) def view_shared_note(request, token, version="v1"): """ Public endpoint — view a note via share link. No authentication required, but password may be needed. """ link = get_object_or_404(ShareableLink, token=token, is_active=True) # Check expiration if link.is_expired: return Response({"error": "This share link has expired"}, status=410) # Check password if link.password: provided_password = request.query_params.get("password", "") if provided_password != link.password: return Response( {"error": "Password required", "password_required": True}, status=401 ) note = link.note if note.deleted_at: return Response({"error": "Note has been deleted"}, status=404) # Record view link.record_view() serializer = ResearcherNoteSerializer(note) return Response(serializer.data) @api_view(["GET"]) @permission_classes([IsAuthenticated]) def list_share_links(request, note_id, version="v1"): """List all share links for a note.""" note = get_object_or_404(ResearcherNote, id=note_id, deleted_at__isnull=True) if note.author != request.user: return Response({"error": "Not allowed"}, status=403) links = note.share_links.all() data = [ { "id": str(l.id), "token": l.token, "url": l.public_url, "is_active": l.is_active, "view_count": l.view_count, "expires_at": l.expires_at, "created_at": l.created_at, } for l in links ] return Response(data) @api_view(["POST"]) @permission_classes([IsAuthenticated]) def revoke_share_link(request, note_id, link_id, version="v1"): """Revoke a share link.""" link = get_object_or_404(ShareableLink, id=link_id, note_id=note_id) if link.created_by != request.user: return Response({"error": "Not allowed"}, status=403) link.is_active = False link.save(update_fields=["is_active"]) return Response({"status": "revoked"}) # ═══════════════════════════════════════════════════════════════════ # 28. Share with Users (direct) # ═══════════════════════════════════════════════════════════════════ @api_view(["POST"]) @permission_classes([IsAuthenticated]) def share_note(request, note_id, version="v1"): """Share a note with specific users by username.""" note = get_object_or_404(ResearcherNote, id=note_id) if note.author != request.user: return Response({"error": "Only the author can share"}, status=403) username = request.data.get("username") if not username: return Response({"error": "username required"}, status=400) try: user_to_share = User.objects.get(username=username) except User.DoesNotExist: return Response({"error": "User not found"}, status=404) note.shared_with.add(user_to_share) Notification.objects.create( recipient=user_to_share, sender=request.user, type="share", note=note, content=f"{request.user.username} shared a note with you: {note.title or 'Untitled'}", ) return Response( { "status": "shared", "shared_with": [u.username for u in note.shared_with.all()], } ) @api_view(["POST"]) @permission_classes([IsAuthenticated]) def unshare_note(request, note_id, version="v1"): note = get_object_or_404(ResearcherNote, id=note_id) if note.author != request.user: return Response({"error": "Only the author can unshare"}, status=403) username = request.data.get("username") if not username: return Response({"error": "username required"}, status=400) note.shared_with.remove(User.objects.get(username=username)) return Response({"status": "unshared"}) @api_view(["GET"]) @permission_classes([IsAuthenticated]) def shared_with_me(request, version="v1"): notes = ResearcherNote.objects.filter( shared_with=request.user, deleted_at__isnull=True ) serializer = ResearcherNoteSerializer(notes, many=True) return Response(serializer.data) # ═══════════════════════════════════════════════════════════════════ # 29. Artifact CRUD # ═══════════════════════════════════════════════════════════════════ @api_view(["GET", "POST"]) @permission_classes([IsAuthenticated]) def artifact_list(request, note_id, version="v1"): note = get_object_or_404(ResearcherNote, id=note_id, deleted_at__isnull=True) if request.method == "GET": artifacts = note.artifacts.all() data = [ { "id": str(a.id), "name": a.name, "file_type": a.file_type, "file_size_mb": a.file_size_mb, "description": a.description, "file_url": request.build_absolute_uri(a.file.url) if a.file else None, "created_at": a.created_at, } for a in artifacts ] return Response(data) elif request.method == "POST": uploaded_file = request.FILES.get("file") if not uploaded_file: return Response({"error": "file required"}, status=400) size_mb = round(uploaded_file.size / (1024 * 1024), 2) artifact = Artifact.objects.create( note=note, name=request.data.get("name", uploaded_file.name), file=uploaded_file, file_type=request.data.get("file_type", ""), file_size_mb=size_mb, description=request.data.get("description", ""), ) return Response( { "id": str(artifact.id), "file_url": request.build_absolute_uri(artifact.file.url), }, status=201, ) @api_view(["DELETE"]) @permission_classes([IsAuthenticated]) def artifact_delete(request, note_id, artifact_id, version="v1"): note = get_object_or_404(ResearcherNote, id=note_id) artifact = get_object_or_404(Artifact, id=artifact_id, note=note) if note.author != request.user: return Response({"error": "Not allowed"}, status=403) artifact.file.delete(save=False) artifact.delete() return Response(status=204) @api_view(["GET"]) @permission_classes([IsAuthenticated]) def artifact_download(request, note_id, artifact_id, version="v1"): note = get_object_or_404(ResearcherNote, id=note_id, deleted_at__isnull=True) artifact = get_object_or_404(Artifact, id=artifact_id, note=note) if not note.is_public and note.author != request.user: return Response({"error": "Not allowed"}, status=403) response = FileResponse(artifact.file.open("rb"), as_attachment=True) response["Content-Disposition"] = f'attachment; filename="{artifact.name}"' return response # ═══════════════════════════════════════════════════════════════════ # 30. Protocol CRUD # ═══════════════════════════════════════════════════════════════════ @api_view(["GET", "POST"]) @permission_classes([IsAuthenticated]) def protocol_list(request, version="v1"): if request.method == "GET": protocols = Protocol.objects.filter( models.Q(created_by=request.user) | models.Q(is_public=True) ).order_by("-created_at") data = [ { "id": str(p.id), "name": p.name, "description": p.description, "steps_count": len(p.steps), "is_public": p.is_public, "created_by": p.created_by.username, "created_at": p.created_at, } for p in protocols ] return Response(data) elif request.method == "POST": protocol = Protocol.objects.create( name=request.data.get("name", "Untitled Protocol"), description=request.data.get("description", ""), steps=request.data.get("steps", []), created_by=request.user, is_public=request.data.get("is_public", False), ) return Response({"id": str(protocol.id), "status": "created"}, status=201) @api_view(["GET", "PUT", "PATCH", "DELETE"]) @permission_classes([IsAuthenticated]) def protocol_detail(request, protocol_id, version="v1"): protocol = get_object_or_404(Protocol, id=protocol_id) if request.method == "GET": return Response( { "id": str(protocol.id), "name": protocol.name, "description": protocol.description, "steps": protocol.steps, "is_public": protocol.is_public, "created_by": protocol.created_by.username, "created_at": protocol.created_at, "updated_at": protocol.updated_at, } ) if protocol.created_by != request.user: return Response({"error": "Not allowed"}, status=403) if request.method in ("PUT", "PATCH"): protocol.name = request.data.get("name", protocol.name) protocol.description = request.data.get("description", protocol.description) protocol.steps = request.data.get("steps", protocol.steps) protocol.is_public = request.data.get("is_public", protocol.is_public) protocol.save() return Response({"status": "updated"}) elif request.method == "DELETE": protocol.delete() return Response(status=204) # ═══════════════════════════════════════════════════════════════════ # 31. Note Links (Knowledge Graph) # ═══════════════════════════════════════════════════════════════════ @api_view(["POST"]) @permission_classes([IsAuthenticated]) def create_note_link(request, version="v1"): source_id = request.data.get("source_id") target_id = request.data.get("target_id") link_type = request.data.get("link_type", "related") source = get_object_or_404( ResearcherNote, id=source_id, author=request.user, deleted_at__isnull=True ) target = get_object_or_404(ResearcherNote, id=target_id, deleted_at__isnull=True) link, created = NoteLink.objects.get_or_create( source=source, target=target, defaults={"link_type": link_type} ) return Response( {"status": "created" if created else "already_exists", "id": str(link.id)} ) @api_view(["GET"]) @permission_classes([IsAuthenticated]) def note_links_graph(request, note_id, version="v1"): """Return the knowledge graph centered on a note.""" note = get_object_or_404(ResearcherNote, id=note_id, deleted_at__isnull=True) outgoing = note.outgoing_links.select_related("target") incoming = note.incoming_links.select_related("source") nodes = { str(note.id): { "id": str(note.id), "title": note.title or "Untitled", "type": "current", } } edges = [] for link in outgoing: target = link.target if target.deleted_at is None: nodes[str(target.id)] = { "id": str(target.id), "title": target.title or "Untitled", "type": "outgoing", } edges.append( {"from": str(note.id), "to": str(target.id), "type": link.link_type} ) for link in incoming: source = link.source if source.deleted_at is None: nodes[str(source.id)] = { "id": str(source.id), "title": source.title or "Untitled", "type": "incoming", } edges.append( {"from": str(source.id), "to": str(note.id), "type": link.link_type} ) return Response({"nodes": list(nodes.values()), "edges": edges}) @api_view(["DELETE"]) @permission_classes([IsAuthenticated]) def delete_note_link(request, link_id, version="v1"): link = get_object_or_404(NoteLink, id=link_id) if link.source.author != request.user: return Response({"error": "Not allowed"}, status=403) link.delete() return Response(status=204) # ═══════════════════════════════════════════════════════════════════ # 32. Toggle Pin # ═══════════════════════════════════════════════════════════════════ @api_view(["PATCH"]) @permission_classes([IsAuthenticated]) def toggle_pin(request, note_id, version="v1"): note = get_object_or_404(ResearcherNote, id=note_id) if note.author != request.user: return Response({"error": "Not allowed"}, status=403) note.pinned = not note.pinned note.save(update_fields=["pinned"]) return Response({"pinned": note.pinned}) @api_view(["POST"]) @permission_classes([IsAuthenticated]) def create_note_from_paper(request, version="v1"): """ Save a paper and create a note with its details. Body: { paper_id, source, note_title (optional) } """ paper_id = request.data.get("paper_id") source = request.data.get("source", "semantic_scholar") if not paper_id: return Response({"error": "paper_id required"}, status=400) # Fetch paper details from agents.tools import get_paper_details, save_paper result = get_paper_details(paper_id=paper_id, source=source) if result.get("status") != "success": return Response(result, status=404) paper = result["paper"] # Save to user's library save_result = save_paper( title=paper.get("title", ""), source=source, source_id=paper_id, authors=paper.get("authors", []), abstract=paper.get("abstract", ""), url=paper.get("url", ""), year=paper.get("year"), citation_count=paper.get("citation_count", 0), pdf_url=paper.get("pdf_url", ""), user_id=request.user.id, ) # Create a rich note note = ResearcherNote.objects.create( author=request.user, note_type="literature_review", title=request.data.get("note_title") or paper.get("title", "Untitled"), content=f"""## 📄 {paper.get('title','Untitled')} **Authors:** {', '.join(paper.get('authors',[]))} **Year:** {paper.get('year','N/A')} **Citations:** {paper.get('citation_count',0)} **Source:** [{paper.get('source','')}]({paper.get('url','')}) ### Abstract {paper.get('abstract','')} ### Notes *(Add your notes here)* """, tags=["paper-review", source], metadata={"paper": paper}, ) serializer = ResearcherNoteSerializer(note) return Response(serializer.data, status=201) @api_view(["GET"]) @permission_classes([IsAuthenticated]) def note_bibliography(request, note_id, version="v1"): """ Return a formatted bibliography (BibTeX or APA) for all papers linked to a note. """ note = get_object_or_404(ResearcherNote, id=note_id, deleted_at__isnull=True) if not note.is_public and note.author != request.user: return Response({"error": "Not allowed"}, status=403) papers = note.metadata.get("papers", []) if not papers: return Response({"references": [], "bibtex": ""}) format_type = request.query_params.get("format", "apa") references = [] bibtex_entries = [] for paper in papers: title = paper.get("title", "") authors = paper.get("authors", []) year = paper.get("year", "") source = paper.get("source", "") source_id = paper.get("source_id", "") first_author = authors[0].split()[-1] if authors else "Unknown" ref_key = f"{first_author.lower()}{year}" # APA style if len(authors) == 1: author_str = authors[0] elif len(authors) == 2: author_str = f"{authors[0]} & {authors[1]}" elif len(authors) > 2: author_str = f"{authors[0]} et al." else: author_str = "Unknown" apa_ref = f"{author_str} ({year}). {title}." references.append(apa_ref) # BibTeX bibtex = f"""@article{{{ref_key}, title = {{{title}}}, author = {{{' and '.join(authors)}}}, year = {{{year}}}, url = {{https://api.semanticscholar.org/CorpusID:{source_id}}} }}""" bibtex_entries.append(bibtex) bibtex_all = "\n\n".join(bibtex_entries) return Response( { "references": references, "bibtex": bibtex_all, "count": len(references), } ) @api_view(["GET"]) @permission_classes([IsAuthenticated]) def search_and_format_paper(request, version="v1"): """Search for a paper and return a formatted Markdown snippet for insertion into a note.""" query = request.query_params.get("q", "") source = request.query_params.get("source", "semantic_scholar") if not query: return Response({"results": []}) from agents.tools import search_papers result = search_papers(query=query, limit=5, source=source) papers = result.get("results", []) formatted = [] for paper in papers: md = f"""### [{paper.get('title','Untitled')}]({paper.get('url','')}) - **Authors:** {', '.join(paper.get('authors',[]))} - **Year:** {paper.get('year','N/A')} | **Citations:** {paper.get('citation_count',0)} - **Abstract:** {paper.get('abstract','')[:300]}... ```bibtex @article{{{paper.get('authors',[['Unknown']])[0].split()[-1].lower()}{paper.get('year','')}, title = {{{paper.get('title','')}}}, author = {{{' and '.join(paper.get('authors',[]))}}}, year = {{{paper.get('year','')}}} }} ```""" formatted.append( { "source_id": paper.get("source_id"), "source": paper.get("source"), "markdown": md, } ) return Response({"results": formatted}) # notes/views.py — add this @api_view(["POST"]) @permission_classes([IsAuthenticated]) def create_data_app(request): """Convert a notebook/script into an interactive web app.""" import nbformat from nbconvert import HTMLExporter uploaded = request.FILES.get("notebook") if not uploaded: return Response({"error": "Notebook file required"}, status=400) # Convert notebook to HTML notebook = nbformat.read(uploaded, as_version=4) html_exporter = HTMLExporter() html_exporter.theme = "dark" body, _ = html_exporter.from_notebook_node(notebook) app = DataApp.objects.create( user=request.user, title=request.data.get("title", uploaded.name), source_notebook=uploaded, generated_html=body, is_public=request.data.get("is_public", False), ) # Optional: deploy to HuggingFace Space if request.data.get("deploy_to_hf"): from notes.hf_upload import upload_data_app_to_hf space_url = upload_data_app_to_hf(app) app.hugginface_space_url = space_url app.save(update_fields=["hugginface_space_url"]) return Response( { "app_id": str(app.id), "html_url": f"/api/notes/data-apps/{app.id}/render/", "hugginface_space_url": app.hugginface_space_url, }, status=201, ) @api_view(["GET"]) @permission_classes([AllowAny]) def render_data_app(request, app_id): """Render a data app as a standalone HTML page.""" app = get_object_or_404(DataApp, id=app_id) if not app.is_public and app.user != request.user: return Response({"error": "Not allowed"}, status=403) return HttpResponse(app.generated_html)
# notes/views.py
import csv
import json
import logging
from datetime import timedelta
from io import StringIO
from django.db.models import Count, Q
from django.http import Http404, HttpResponse
from django.shortcuts import get_object_or_404
from django.utils import timezone
from rest_framework import status
from rest_framework.decorators import api_view, permission_classes
from rest_framework.pagination import PageNumberPagination
from rest_framework.permissions import AllowAny, IsAuthenticated
from rest_framework.response import Response
from .filters import NoteFilter
from .models import NoteMention, ResearcherNote, WebhookSubscription
from .serializers import (
NoteImageSerializer,
ResearcherNoteSerializer,
WebhookSubscriptionSerializer,
)
logger = logging.getLogger(__name__)
class StandardPagination(PageNumberPagination):
page_size = 20
page_size_query_param = "page_size"
max_page_size = 100
from django.contrib.postgres.search import SearchQuery, SearchRank, SearchVector
from .models import NoteComment, NoteTemplate, Notification
# ─── به ابتدای فایل اضافه کنید ───
from .report_generator import generate_experiment_report
# ═══════════════════════════════════════════════════════════════════
# 18. Auto-Generate Experiment Report
# ═══════════════════════════════════════════════════════════════════
@api_view(["POST"])
@permission_classes([IsAuthenticated])
def generate_run_report(request, run_id, version="v1"):
"""Auto-generate a rich Markdown report from a training run."""
note = generate_experiment_report(run_id=run_id, author=request.user, save=True)
if note is None:
return Response({"error": "Run not found"}, status=404)
serializer = ResearcherNoteSerializer(note)
return Response(serializer.data, status=status.HTTP_201_CREATED)
# ═══════════════════════════════════════════════════════════════════
# 19. Note Templates
# ═══════════════════════════════════════════════════════════════════
@api_view(["GET", "POST"])
@permission_classes([IsAuthenticated])
def note_templates(request, version="v1"):
"""List all templates or create a new one."""
if request.method == "GET":
note_type = request.query_params.get("note_type")
templates = NoteTemplate.objects.all()
if note_type:
templates = templates.filter(note_type=note_type)
data = [
{
"id": str(t.id),
"name": t.name,
"description": t.description,
"note_type": t.note_type,
"variables_schema": t.variables_schema,
"is_default": t.is_default,
}
for t in templates
]
return Response(data)
elif request.method == "POST":
template = NoteTemplate.objects.create(
name=request.data.get("name", "Untitled Template"),
description=request.data.get("description", ""),
note_type=request.data.get("note_type", "general"),
content_template=request.data.get("content_template", ""),
variables_schema=request.data.get("variables_schema", {}),
created_by=request.user,
)
return Response({"id": str(template.id), "status": "created"}, status=201)
@api_view(["POST"])
@permission_classes([IsAuthenticated])
def render_template(request, template_id, version="v1"):
"""Render a template with provided variables and create a note."""
template = get_object_or_404(NoteTemplate, id=template_id)
variables = request.data.get("variables", {})

Xet Storage Details

Size:
67.7 kB
·
Xet hash:
bc8b9f2dc94caaca48404785b4781c00f44f517407f4d316f33448a64954e6d8

Xet efficiently stores files, intelligently splitting them into unique chunks and accelerating uploads and downloads. More info.