| """GPU Finance REST API — indices, futures, billing, payouts, subscriptions.""" | |
| import logging | |
| from decimal import Decimal | |
| from django.db.models import Sum | |
| from django.shortcuts import get_object_or_404 | |
| from django.utils import timezone | |
| 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 .models import * | |
| from .pricing_engine import get_index_history, recalculate_all_indices | |
| from .serializers import * | |
| logger = logging.getLogger(__name__) | |
| class StandardPagination(PageNumberPagination): | |
| page_size = 20 | |
| page_size_query_param = "page_size" | |
| max_page_size = 100 | |
| # ═══════════════════════════════════════════════════════════════ | |
| # COMPUTE INDICES | |
| # ═══════════════════════════════════════════════════════════════ | |
| def index_list(request): | |
| qs = ComputeIndex.objects.all().order_by("gpu_model") | |
| return Response(ComputeIndexSerializer(qs, many=True).data) | |
| def index_detail(request, index_id): | |
| idx = get_object_or_404(ComputeIndex, id=index_id) | |
| data = ComputeIndexSerializer(idx).data | |
| data["history"] = IndexHistorySerializer( | |
| idx.history.order_by("-recorded_at")[:30], many=True | |
| ).data | |
| return Response(data) | |
| def index_chart(request, index_id): | |
| idx = get_object_or_404(ComputeIndex, id=index_id) | |
| days = int(request.query_params.get("days", 30)) | |
| return Response(get_index_history(idx.index_name, days)) | |
| def recalculate_indices(request): | |
| if not request.user.is_staff: | |
| return Response({"error": "Staff only"}, status=403) | |
| return Response(recalculate_all_indices()) | |
| # ═══════════════════════════════════════════════════════════════ | |
| # FUTURES CONTRACTS | |
| # ═══════════════════════════════════════════════════════════════ | |
| def futures_list(request): | |
| qs = FuturesContract.objects.filter(status="open").order_by( | |
| "contract_year", "contract_month" | |
| ) | |
| return Response(FuturesContractSerializer(qs, many=True).data) | |
| def futures_detail(request, contract_id): | |
| contract = get_object_or_404(FuturesContract, id=contract_id) | |
| data = FuturesContractSerializer(contract).data | |
| data["order_book"] = { | |
| "bids": FuturesOrderSerializer( | |
| contract.orders.filter(order_type="buy", status="open").order_by( | |
| "-limit_price" | |
| )[:10], | |
| many=True, | |
| ).data, | |
| "asks": FuturesOrderSerializer( | |
| contract.orders.filter(order_type="sell", status="open").order_by( | |
| "limit_price" | |
| )[:10], | |
| many=True, | |
| ).data, | |
| } | |
| return Response(data) | |
| # ═══════════════════════════════════════════════════════════════ | |
| # FUTURES ORDERS | |
| # ═══════════════════════════════════════════════════════════════ | |
| def place_futures_order(request, contract_id): | |
| contract = get_object_or_404(FuturesContract, id=contract_id) | |
| if contract.status != "open": | |
| return Response({"error": "Contract is not open for trading"}, status=400) | |
| serializer = FuturesOrderSerializer(data=request.data) | |
| if serializer.is_valid(): | |
| order = serializer.save(contract=contract, trader=request.user) | |
| return Response(FuturesOrderSerializer(order).data, status=201) | |
| return Response(serializer.errors, status=400) | |
| def my_futures_orders(request): | |
| qs = FuturesOrder.objects.filter(trader=request.user).order_by("-created_at") | |
| paginator = StandardPagination() | |
| page = paginator.paginate_queryset(qs, request) | |
| return paginator.get_paginated_response( | |
| FuturesOrderSerializer(page, many=True).data | |
| ) | |
| def my_futures_positions(request): | |
| qs = FuturesPosition.objects.filter(trader=request.user).order_by("-opened_at") | |
| total_pnl = qs.aggregate(s=Sum("realized_pnl_usd"))["s"] or 0 | |
| data = FuturesPositionSerializer(qs, many=True).data | |
| return Response({"positions": data, "total_realized_pnl": float(total_pnl)}) | |
| def cancel_futures_order(request, order_id): | |
| order = get_object_or_404(FuturesOrder, id=order_id, trader=request.user) | |
| if order.status != "open": | |
| return Response({"error": "Order already filled or canceled"}, status=400) | |
| order.status = "canceled" | |
| order.save(update_fields=["status"]) | |
| return Response({"status": "canceled"}) | |
| # ═══════════════════════════════════════════════════════════════ | |
| # INVOICES | |
| # ═══════════════════════════════════════════════════════════════ | |
| def invoice_list(request): | |
| qs = Invoice.objects.filter(user=request.user).order_by("-created_at") | |
| status_filter = request.query_params.get("status") | |
| if status_filter: | |
| qs = qs.filter(status=status_filter) | |
| paginator = StandardPagination() | |
| page = paginator.paginate_queryset(qs, request) | |
| return paginator.get_paginated_response(InvoiceSerializer(page, many=True).data) | |
| def invoice_detail(request, invoice_id): | |
| inv = get_object_or_404(Invoice, id=invoice_id, user=request.user) | |
| return Response(InvoiceSerializer(inv).data) | |
| # ═══════════════════════════════════════════════════════════════ | |
| # PAYOUTS | |
| # ═══════════════════════════════════════════════════════════════ | |
| def payout_list(request): | |
| qs = Payout.objects.filter(provider=request.user).order_by("-created_at") | |
| paginator = StandardPagination() | |
| page = paginator.paginate_queryset(qs, request) | |
| return paginator.get_paginated_response(PayoutSerializer(page, many=True).data) | |
| def request_payout(request): | |
| amount = request.data.get("amount_usd") | |
| method = request.data.get("method", "credits") | |
| if not amount: | |
| return Response({"error": "amount_usd required"}, status=400) | |
| from gpu_escrow.models import EscrowAccount | |
| account = get_object_or_404(EscrowAccount, user=request.user) | |
| if Decimal(str(amount)) > account.balance_usd: | |
| return Response({"error": "Insufficient balance"}, status=400) | |
| payout = Payout.objects.create( | |
| provider=request.user, | |
| amount_usd=amount, | |
| method=method, | |
| fee_usd=0, | |
| net_amount_usd=amount, | |
| ) | |
| return Response(PayoutSerializer(payout).data, status=201) | |
| # ═══════════════════════════════════════════════════════════════ | |
| # PAYMENT METHODS | |
| # ═══════════════════════════════════════════════════════════════ | |
| def payment_method_list(request): | |
| if request.method == "GET": | |
| return Response( | |
| PaymentMethodSerializer(request.user.payment_methods.all(), many=True).data | |
| ) | |
| elif request.method == "POST": | |
| serializer = PaymentMethodSerializer(data=request.data) | |
| if serializer.is_valid(): | |
| serializer.save(user=request.user) | |
| return Response(serializer.data, status=201) | |
| return Response(serializer.errors, status=400) | |
| def payment_method_delete(request, method_id): | |
| pm = get_object_or_404(PaymentMethod, id=method_id, user=request.user) | |
| pm.delete() | |
| return Response(status=204) | |
| # ═══════════════════════════════════════════════════════════════ | |
| # SUBSCRIPTIONS & PLANS | |
| # ═══════════════════════════════════════════════════════════════ | |
| def plan_list(request): | |
| return Response( | |
| BillingPlanSerializer( | |
| BillingPlan.objects.filter(is_active=True), many=True | |
| ).data | |
| ) | |
| def my_subscription(request): | |
| sub, _ = Subscription.objects.get_or_create(user=request.user) | |
| return Response(SubscriptionSerializer(sub).data) | |
| def change_plan(request, plan_id): | |
| plan = get_object_or_404(BillingPlan, id=plan_id, is_active=True) | |
| sub, _ = Subscription.objects.get_or_create(user=request.user) | |
| sub.plan = plan | |
| sub.status = "active" | |
| sub.current_period_start = timezone.now() | |
| sub.current_period_end = timezone.now() + timezone.timedelta(days=30) | |
| sub.save() | |
| return Response(SubscriptionSerializer(sub).data) | |
| # ═══════════════════════════════════════════════════════════════ | |
| # USAGE | |
| # ═══════════════════════════════════════════════════════════════ | |
| def my_usage(request): | |
| qs = UsageRecord.objects.filter(user=request.user).order_by("-recorded_at") | |
| paginator = StandardPagination() | |
| page = paginator.paginate_queryset(qs, request) | |
| total = qs.aggregate( | |
| hours=Sum("hours_consumed"), cost=Sum("cost_usd"), fee=Sum("platform_fee_usd") | |
| ) | |
| data = { | |
| "records": UsageRecordSerializer(page, many=True).data, | |
| "total_hours": float(total["hours"] or 0), | |
| "total_cost": float(total["cost"] or 0), | |
| "total_platform_fees": float(total["fee"] or 0), | |
| } | |
| return paginator.get_paginated_response(data) | |
| # ═══════════════════════════════════════════════════════════════ | |
| # CONSUMER DASHBOARD | |
| # ═══════════════════════════════════════════════════════════════ | |
| def consumer_finance_dashboard(request): | |
| invoices = Invoice.objects.filter(user=request.user) | |
| unpaid = ( | |
| invoices.filter(status__in=["open", "overdue"]).aggregate(s=Sum("total_usd"))[ | |
| "s" | |
| ] | |
| or 0 | |
| ) | |
| usage = UsageRecord.objects.filter(user=request.user) | |
| return Response( | |
| { | |
| "balance_due_usd": float(unpaid), | |
| "total_spent_usd": float(usage.aggregate(s=Sum("cost_usd"))["s"] or 0), | |
| "total_hours": float(usage.aggregate(s=Sum("hours_consumed"))["s"] or 0), | |
| "open_invoices": invoices.filter(status="open").count(), | |
| "futures_positions": FuturesPosition.objects.filter( | |
| trader=request.user, status="open" | |
| ).count(), | |
| "futures_pnl": float( | |
| FuturesPosition.objects.filter(trader=request.user).aggregate( | |
| s=Sum("realized_pnl_usd") | |
| )["s"] | |
| or 0 | |
| ), | |
| } | |
| ) | |
| # ═══════════════════════════════════════════════════════════════ | |
| # PROVIDER DASHBOARD | |
| # ═══════════════════════════════════════════════════════════════ | |
| def provider_finance_dashboard(request): | |
| payouts = Payout.objects.filter(provider=request.user) | |
| from gpu_marketplace.models import GPUListing | |
| listings = GPUListing.objects.filter(provider=request.user) | |
| return Response( | |
| { | |
| "total_earned_usd": float( | |
| listings.aggregate(s=Sum("total_earnings_usd"))["s"] or 0 | |
| ), | |
| "pending_payouts": float( | |
| payouts.filter(status="pending").aggregate(s=Sum("net_amount_usd"))["s"] | |
| or 0 | |
| ), | |
| "lifetime_payouts": float( | |
| payouts.filter(status="completed").aggregate(s=Sum("net_amount_usd"))[ | |
| "s" | |
| ] | |
| or 0 | |
| ), | |
| "total_hours_rented": float( | |
| listings.aggregate(s=Sum("total_hours_rented"))["s"] or 0 | |
| ), | |
| } | |
| ) | |
Xet Storage Details
- Size:
- 14.6 kB
- Xet hash:
- fd2a38e8c4516685333f085f0c95713c1cd42f2005986052227576987d31ad83
·
Xet efficiently stores files, intelligently splitting them into unique chunks and accelerating uploads and downloads. More info.