ami-djAPI-analyzing 0.1.0__tar.gz

ami_djapi_analyzing-0.1.0/LICENSE

@@ -0,0 +1,19 @@
+MIT License
+
+Copyright (c) 2026 Ami
+
+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.
+
+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 BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY.

ami_djapi_analyzing-0.1.0/PKG-INFO

@@ -0,0 +1,54 @@
+Metadata-Version: 2.4
+Name: ami-djAPI-analyzing
+Version: 0.1.0
+Summary: Lightweight Django middleware for profiling SQL queries, detecting performance issues, and analyzing request execution.
+Author: Ami
+License: MIT
+Keywords: django,django-profiler,sql-profiler,performance,django-middleware,debugging
+Classifier: Framework :: Django
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: Django>=3.2
+Requires-Dist: cryptography>=41.0
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: black; extra == "dev"
+Requires-Dist: flake8; extra == "dev"
+Dynamic: license-file
+
+# ami-djAPI-analyzing
+
+Lightweight **ami-djAPI-analyzing** for analyzing SQL queries, request performance, and detecting common database issues like **N+1 queries, duplicate queries, slow queries, and missing indexes**.
+
+It provides detailed profiling information directly in the response headers and API responses.
+
+---
+
+# Features
+
+• Capture all SQL queries executed during a request  
+• Detect **N+1 queries automatically**  
+• Detect **duplicate queries**  
+• Detect **slow SQL queries**  
+• Detect **potential missing indexes**  
+• Analyze **database time vs total response time**  
+• **Performance score system (A–F grading)**  
+• Track **request history**  
+• Capture **memory usage**  
+• Generate **EXPLAIN plans for slow queries**  
+• Optional **step-by-step view execution profiler**  
+• Encrypted performance payload in response headers  
+
+---
+
+# Installation
+
+```bash
+pip install ami-djAPI-analyzing

ami_djapi_analyzing-0.1.0/README.md

@@ -0,0 +1,29 @@
+# ami-djAPI-analyzing
+
+Lightweight **ami-djAPI-analyzing** for analyzing SQL queries, request performance, and detecting common database issues like **N+1 queries, duplicate queries, slow queries, and missing indexes**.
+
+It provides detailed profiling information directly in the response headers and API responses.
+
+---
+
+# Features
+
+• Capture all SQL queries executed during a request  
+• Detect **N+1 queries automatically**  
+• Detect **duplicate queries**  
+• Detect **slow SQL queries**  
+• Detect **potential missing indexes**  
+• Analyze **database time vs total response time**  
+• **Performance score system (A–F grading)**  
+• Track **request history**  
+• Capture **memory usage**  
+• Generate **EXPLAIN plans for slow queries**  
+• Optional **step-by-step view execution profiler**  
+• Encrypted performance payload in response headers  
+
+---
+
+# Installation
+
+```bash
+pip install ami-djAPI-analyzing

ami_djapi_analyzing-0.1.0/ami_djAPI_analyzing.egg-info/PKG-INFO

@@ -0,0 +1,54 @@
+Metadata-Version: 2.4
+Name: ami-djAPI-analyzing
+Version: 0.1.0
+Summary: Lightweight Django middleware for profiling SQL queries, detecting performance issues, and analyzing request execution.
+Author: Ami
+License: MIT
+Keywords: django,django-profiler,sql-profiler,performance,django-middleware,debugging
+Classifier: Framework :: Django
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: Django>=3.2
+Requires-Dist: cryptography>=41.0
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: black; extra == "dev"
+Requires-Dist: flake8; extra == "dev"
+Dynamic: license-file
+
+# ami-djAPI-analyzing
+
+Lightweight **ami-djAPI-analyzing** for analyzing SQL queries, request performance, and detecting common database issues like **N+1 queries, duplicate queries, slow queries, and missing indexes**.
+
+It provides detailed profiling information directly in the response headers and API responses.
+
+---
+
+# Features
+
+• Capture all SQL queries executed during a request  
+• Detect **N+1 queries automatically**  
+• Detect **duplicate queries**  
+• Detect **slow SQL queries**  
+• Detect **potential missing indexes**  
+• Analyze **database time vs total response time**  
+• **Performance score system (A–F grading)**  
+• Track **request history**  
+• Capture **memory usage**  
+• Generate **EXPLAIN plans for slow queries**  
+• Optional **step-by-step view execution profiler**  
+• Encrypted performance payload in response headers  
+
+---
+
+# Installation
+
+```bash
+pip install ami-djAPI-analyzing

ami_djapi_analyzing-0.1.0/ami_djAPI_analyzing.egg-info/SOURCES.txt

@@ -0,0 +1,15 @@
+LICENSE
+README.md
+pyproject.toml
+ami_djAPI_analyzing.egg-info/PKG-INFO
+ami_djAPI_analyzing.egg-info/SOURCES.txt
+ami_djAPI_analyzing.egg-info/dependency_links.txt
+ami_djAPI_analyzing.egg-info/requires.txt
+ami_djAPI_analyzing.egg-info/top_level.txt
+ami_djapi_analyzing/__init__.py
+ami_djapi_analyzing/analyzer.py
+ami_djapi_analyzing/middleware.py
+ami_djapi_analyzing/perf_detector.py
+ami_djapi_analyzing/scorer.py
+ami_djapi_analyzing/sql_collector.py
+ami_djapi_analyzing/steps.py

ami_djapi_analyzing-0.1.0/ami_djAPI_analyzing.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

ami_djapi_analyzing-0.1.0/ami_djAPI_analyzing.egg-info/requires.txt

@@ -0,0 +1,7 @@
+Django>=3.2
+cryptography>=41.0
+
+[dev]
+pytest
+black
+flake8

ami_djapi_analyzing-0.1.0/ami_djAPI_analyzing.egg-info/top_level.txt

@@ -0,0 +1 @@
+ami_djapi_analyzing

ami_djapi_analyzing-0.1.0/ami_djapi_analyzing/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"

ami_djapi_analyzing-0.1.0/ami_djapi_analyzing/analyzer.py

@@ -0,0 +1,151 @@
+import re
+from collections import defaultdict
+
+
+SLOW_QUERY_THRESHOLD = 0.05
+
+
+def normalize_sql(sql: str):
+    """
+    Normalize SQL to detect duplicates.
+    """
+    sql = re.sub(r"\s+", " ", sql)
+    sql = re.sub(r"=\s*[\d']+", "= ?", sql)
+    return sql.strip().lower()
+
+
+def detect_duplicate_queries(queries):
+
+    counter = defaultdict(list)
+
+    for q in queries:
+        key = normalize_sql(q["sql"])
+        counter[key].append(q)
+
+    duplicates = []
+
+    for key, items in counter.items():
+        if len(items) > 1:
+            duplicates.append({
+                "query": key,
+                "count": len(items),
+                "total_time": sum(q["time"] for q in items)
+            })
+
+    return duplicates
+
+
+def detect_n_plus_one(queries):
+
+    grouped = defaultdict(list)
+
+    for q in queries:
+        model = q.get("model")
+        if model:
+            grouped[model].append(q)
+
+    n_plus_one = []
+
+    for model, items in grouped.items():
+        if len(items) > 5:
+            n_plus_one.append({
+                "model": model,
+                "count": len(items),
+                "suggestion": "Consider using select_related or prefetch_related"
+            })
+
+    return n_plus_one
+
+
+def detect_slow_queries(queries):
+
+    return [
+        q for q in queries
+        if q["time"] > SLOW_QUERY_THRESHOLD
+    ]
+
+
+def detect_missing_indexes(queries):
+
+    problems = []
+
+    for q in queries:
+
+        sql = q["sql"].lower()
+
+        if "where" in sql and "id" not in sql:
+            problems.append({
+                "sql": q["sql"],
+                "reason": "Possible missing index on filtered column"
+            })
+
+    return problems
+
+
+def build_suggestions(n_plus_one, duplicates, slow_queries, index_problems):
+
+    suggestions = []
+
+    if n_plus_one:
+        suggestions.append(
+            "Detected potential N+1 queries. Use select_related or prefetch_related."
+        )
+
+    if duplicates:
+        suggestions.append(
+            "Duplicate queries detected. Consider caching or query optimization."
+        )
+
+    if slow_queries:
+        suggestions.append(
+            "Slow queries detected. Add indexes or optimize joins."
+        )
+
+    if index_problems:
+        suggestions.append(
+            "Queries filtering non-indexed columns detected."
+        )
+
+    return suggestions
+
+
+def analyze_queries(queries, response_time):
+
+    duplicate_queries = detect_duplicate_queries(queries)
+
+    n_plus_one = detect_n_plus_one(queries)
+
+    slow_queries = detect_slow_queries(queries)
+
+    index_problems = detect_missing_indexes(queries)
+
+    suggestions = build_suggestions(
+        n_plus_one,
+        duplicate_queries,
+        slow_queries,
+        index_problems
+    )
+
+    total_db_time = round(sum(q["time"] for q in queries), 4)
+
+    return {
+
+        "query_count": len(queries),
+
+        "total_db_time": total_db_time,
+
+        "duplicate_details": duplicate_queries,
+        "duplicate_query_count": len(duplicate_queries),
+
+        "n_plus_one_details": n_plus_one,
+        "n_plus_one_count": len(n_plus_one),
+
+        "slow_queries": slow_queries,
+        "slow_query_count": len(slow_queries),
+
+        "missing_index_warnings": index_problems,
+
+        "optimization_suggestions": suggestions,
+
+        "is_slow_endpoint": response_time > 1.0,
+    }

ami_djapi_analyzing-0.1.0/ami_djapi_analyzing/middleware.py

@@ -0,0 +1,83 @@
+import time
+import tracemalloc
+from collections import deque
+from django.db import connections
+from django.conf import settings
+
+from .analyzer import analyze_queries
+from .scorer import calculate_score
+from .sql_collector import QueryCaptureWrapper, generate_key, encrypt_data
+import base64
+
+
+REQUEST_HISTORY = deque(maxlen=50)
+
+class PerformanceMiddleware:
+    def __init__(self, get_response):
+        self.get_response = get_response
+
+    def __call__(self, request):
+        wrapper = QueryCaptureWrapper()
+        tracemalloc.start()
+        start_time = time.perf_counter()
+
+        # SQL Capture
+        with connections["default"].execute_wrapper(wrapper):
+            response = self.get_response(request)
+
+        current, peak = tracemalloc.get_traced_memory()
+        tracemalloc.stop()
+
+        total_response_time = round(time.perf_counter() - start_time, 4)
+        queries = wrapper.queries
+
+        analysis = analyze_queries(queries, total_response_time)
+        score_data = calculate_score(analysis)
+
+        slow_queries = sorted(queries, key=lambda q: q["time"], reverse=True)[:5]
+
+        memory_data = {
+            "current_memory_bytes": current,
+            "peak_memory_bytes": peak
+        }
+        
+
+        REQUEST_HISTORY.append({
+            "path": request.path,
+            "method": request.method,
+            "response_time": total_response_time,
+            "query_count": analysis["query_count"],
+        })
+        history = list(REQUEST_HISTORY)
+
+        # Build agent payload
+        agent_payload = {
+            "summary": {
+                "query_count": analysis["query_count"],
+                "db_time": analysis["total_db_time"],
+                "response_time": total_response_time,
+                "score": score_data["score"],
+                "grade": score_data["grade"],
+            },
+            "sql_queries": queries,
+            "top_slow_queries": slow_queries,
+            "sql_analysis": {
+                "duplicate_queries": analysis["duplicate_details"],
+                "n_plus_one_queries": analysis["n_plus_one_details"],
+                "slow_query_count": analysis["slow_query_count"],
+                "is_slow_endpoint": analysis["is_slow_endpoint"],
+            },
+            "memory_usage": memory_data,
+            "request_history": history,
+            
+        }
+
+        # Encrypt agent payload
+        key = generate_key()
+        encrypted_payload = encrypt_data(agent_payload, key)
+        response["agent_encrypted"] = encrypted_payload
+        response["X-Encryption-Key"] = base64.b64encode(key).decode("utf-8")
+        response["X-Debug-Mode"] = str(settings.DEBUG)
+        response["X-Profiler-Enabled"] = "True"
+
+        return response

ami_djapi_analyzing-0.1.0/ami_djapi_analyzing/perf_detector.py

@@ -0,0 +1,52 @@
+# perf.py
+
+import re
+from collections import defaultdict, Counter
+
+
+def detect_n_plus_one(queries, threshold=5):
+    """
+    Detect repeated similar queries (N+1).
+    Normalizes numeric values.
+    """
+
+    normalized = defaultdict(list)
+
+    for q in queries:
+        sql = q["sql"]
+
+        # Normalize numbers to detect pattern
+        normalized_sql = re.sub(r"\b\d+\b", "?", sql)
+
+        normalized[normalized_sql].append(sql)
+
+    warnings = [
+        {
+            "query_sample": key[:120],
+            "count": len(val)
+        }
+        for key, val in normalized.items()
+        if len(val) >= threshold
+    ]
+
+    return warnings
+
+
+def detect_duplicate_queries(queries):
+    """
+    Detect exact duplicate SQL queries.
+    """
+
+    sql_list = [q["sql"] for q in queries]
+    counter = Counter(sql_list)
+
+    duplicates = [
+        {
+            "query_sample": sql[:120],
+            "count": count
+        }
+        for sql, count in counter.items()
+        if count > 1
+    ]
+
+    return duplicates

ami_djapi_analyzing-0.1.0/ami_djapi_analyzing/scorer.py

@@ -0,0 +1,43 @@
+def calculate_score(analysis):
+
+    score = 100
+
+    if analysis["query_count"] > 20:
+        score -= 25
+    elif analysis["query_count"] > 10:
+        score -= 10
+
+    if analysis["total_db_time"] > 1.0:
+        score -= 20
+    elif analysis["total_db_time"] > 0.5:
+        score -= 10
+
+    if analysis["n_plus_one_count"] > 0:
+        score -= 20
+
+    if analysis["duplicate_query_count"] > 0:
+        score -= 10
+
+    if analysis["is_slow_endpoint"]:
+        score -= 20
+
+    score = max(score, 0)
+
+    return {
+        "score": score,
+        "grade": grade_from_score(score),
+    }
+
+
+def grade_from_score(score):
+
+    if score >= 90:
+        return "A"
+    elif score >= 75:
+        return "B"
+    elif score >= 60:
+        return "C"
+    elif score >= 40:
+        return "D"
+    else:
+        return "F"

ami_djapi_analyzing-0.1.0/ami_djapi_analyzing/sql_collector.py

@@ -0,0 +1,120 @@
+import time
+import traceback
+import re
+from django.db import connections
+from django.conf import settings
+import os
+import base64
+import json
+from cryptography.hazmat.primitives.ciphers.aead import AESGCM
+
+
+def detect_model_from_sql(sql):
+    match = re.search(r'FROM\s+"?([\w_]+)"?', sql, re.IGNORECASE)
+    if match:
+        return match.group(1)
+    return None
+
+
+def get_raw_sql(sql, params):
+    """
+    Return exact SQL executed by DB using cursor.mogrify()
+    """
+    try:
+        from django.db import connection
+
+        with connection.cursor() as cursor:
+            raw_sql = cursor.mogrify(sql, params)
+
+            if isinstance(raw_sql, bytes):
+                raw_sql = raw_sql.decode("utf-8")
+
+            return raw_sql
+
+    except Exception:
+        return sql
+
+
+class QueryCaptureWrapper:
+
+    def __init__(self):
+        self.queries = []
+
+    def _stack_trace(self):
+
+        if not settings.DEBUG:
+            return []
+
+        stack = traceback.extract_stack()[:-3]
+
+        return [
+            {
+                "file": frame.filename,
+                "line": frame.lineno,
+                "function": frame.name,
+            }
+            for frame in stack[-6:]
+        ]
+
+    def explain_query(self, sql, params):
+
+        if not sql.lower().startswith("select"):
+            return []
+
+        try:
+            with connections["default"].cursor() as cursor:
+                cursor.execute(f"EXPLAIN {sql}", params or [])
+                plan = cursor.fetchall()
+                return [str(p) for p in plan]
+        except Exception:
+            return []
+
+    def __call__(self, execute, sql, params, many, context):
+
+        start = time.perf_counter()
+
+        try:
+            return execute(sql, params, many, context)
+
+        finally:
+
+            duration = time.perf_counter() - start
+            model = detect_model_from_sql(sql)
+
+            raw_sql = get_raw_sql(sql, params)
+
+            query_data = {
+                "sql": raw_sql,
+                "params": params,
+                "time": round(duration, 6),
+                "model": model,
+                "many": many,
+                "stack_trace": self._stack_trace(),
+            }
+
+            if duration > 0.05:
+                query_data["explain_plan"] = self.explain_query(sql, params)
+
+            self.queries.append(query_data)
+
+
+def generate_key() -> bytes:
+    """Generate a 32-byte AES key"""
+    return AESGCM.generate_key(bit_length=256)
+
+def encrypt_data(data: dict, key: bytes) -> str:
+    """Encrypt JSON-serializable dict and return base64 string"""
+    aesgcm = AESGCM(key)
+    nonce = os.urandom(12)  # 12-byte nonce
+    plaintext = json.dumps(data, default=str).encode("utf-8")
+    ciphertext = aesgcm.encrypt(nonce, plaintext, None)
+    return base64.b64encode(nonce + ciphertext).decode("utf-8")
+
+def decrypt_data(encrypted_b64: str, key_b64: str) -> dict:
+    """Decrypt base64 string back to dict"""
+    key = base64.b64decode(key_b64)
+    raw = base64.b64decode(encrypted_b64)
+    nonce, ciphertext = raw[:12], raw[12:]
+    aesgcm = AESGCM(key)
+    plaintext = aesgcm.decrypt(nonce, ciphertext, None)
+    return json.loads(plaintext)

ami_djapi_analyzing-0.1.0/ami_djapi_analyzing/steps.py

@@ -0,0 +1,130 @@
+import functools
+import sys
+import time
+import linecache
+import os
+
+
+class StepProfiler:
+
+    def __init__(self, target_file=None, max_steps=2000):
+        self.target_file = target_file
+        self.max_steps = max_steps
+        self.steps = []
+        self.start_time = None
+        self._original_trace = None
+
+    def _trace(self, frame, event, arg):
+
+        try:
+            if event != "line":
+                return self._trace
+
+            filename = os.path.basename(frame.f_code.co_filename)
+
+            # Only track API file
+            if filename != self.target_file:
+                return self._trace
+
+            if len(self.steps) >= self.max_steps:
+                return self._trace
+
+            lineno = frame.f_lineno
+            func_name = frame.f_code.co_name
+            code_line = linecache.getline(frame.f_code.co_filename, lineno).strip()
+
+            step = {
+                "file": filename,
+                "function": func_name,
+                "line_no": lineno,
+                "code": code_line,
+                "time_from_start": round(time.time() - self.start_time, 6),
+            }
+
+            self.steps.append(step)
+
+        except Exception:
+            pass
+
+        return self._trace
+
+    def start(self):
+        self.steps = []
+        self.start_time = time.time()
+        self._original_trace = sys.gettrace()
+        sys.settrace(self._trace)
+
+    def stop(self):
+        sys.settrace(self._original_trace)
+        return self.steps
+    
+def human_readable_time(seconds: float) -> str:
+
+    if seconds <= 0:
+        return "0 ms"
+
+    if seconds < 0.001:
+        return f"{round(seconds * 1_000_000, 2)} (Microseconds)"
+
+    elif seconds < 1:
+        return f"{round(seconds * 1000, 3)} ms (Milliseconds)"
+
+    else:
+        return f"{round(seconds, 3)} s (Seconds)"
+
+def format_steps(steps):
+    formatted = []
+    prev_time = None
+
+    for i, step in enumerate(steps, start=1):
+
+        current_time = step.get("time_from_start", 0)
+
+        if prev_time is None:
+            step_time = 0
+        else:
+            step_time = current_time - prev_time
+
+        prev_time = current_time
+
+        formatted.append({
+            "step": i,
+            "file": step.get("file"),
+            "function": step.get("function"),
+            "line_no": step.get("line_no"),
+            "code": step.get("code"),
+            "execution_time": human_readable_time(step_time)
+        })
+
+    return formatted
+
+
+def with_steps(view_func):
+
+    @functools.wraps(view_func)
+    def wrapper(*args, **kwargs):
+
+        view_file = os.path.basename(view_func.__code__.co_filename)
+
+        profiler = StepProfiler(target_file=view_file)
+        
+
+        profiler.start()
+
+        try:
+            response = view_func(*args, **kwargs)
+        finally:
+            steps = profiler.stop()
+
+        formatted_steps = format_steps(steps)
+
+        if hasattr(response, "data") and isinstance(response.data, dict):
+
+            response.data["profiler"] = {
+                "total_steps": len(formatted_steps),
+                "steps": formatted_steps,
+            }
+
+        return response
+
+    return wrapper

ami_djapi_analyzing-0.1.0/pyproject.toml

@@ -0,0 +1,51 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "ami-djAPI-analyzing"
+version = "0.1.0"
+description = "Lightweight Django middleware for profiling SQL queries, detecting performance issues, and analyzing request execution."
+readme = "README.md"
+requires-python = ">=3.9"
+
+authors = [
+    { name = "Ami" }
+]
+
+license = { text = "MIT" }
+
+keywords = [
+    "django",
+    "django-profiler",
+    "sql-profiler",
+    "performance",
+    "django-middleware",
+    "debugging"
+]
+
+dependencies = [
+    "Django>=3.2",
+    "cryptography>=41.0"
+]
+
+classifiers = [
+    "Framework :: Django",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+]
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["ami_djapi_analyzing*"]
+
+[project.optional-dependencies]
+dev = [
+    "pytest",
+    "black",
+    "flake8"
+]

ami_djapi_analyzing-0.1.0/setup.cfg

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