pyquerytracker 0.1.0__py3-none-any.whl → 0.1.1__py3-none-any.whl

{pyquerytracker-0.1.0.dist-info → pyquerytracker-0.1.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyquerytracker
-Version: 0.1.0
+Version: 0.1.1
 Summary: A lightweight, decorator-based query performance tracking library for Python applications. Monitor and analyze database query performance with ease.
 Author-email: MuddyHope <daktarisun@gmail.com>
 License: MIT
@@ -20,6 +20,16 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Dynamic: license-file
 
+
+![GitHub Release](https://img.shields.io/github/v/release/MuddyHope/pyquerytracker)
+![GitHub Issues or Pull Requests](https://img.shields.io/github/issues/MuddyHope/pyquerytracker)
+
+![PyPI - Downloads](https://img.shields.io/pypi/dm/pyquerytracker)
+![GitHub Actions Workflow Status](https://img.shields.io/github/actions/workflow/status/MuddyHope/pyquerytracker/.github%2Fworkflows%2Fpublish.yml)
+![GitHub forks](https://img.shields.io/github/forks/MuddyHope/pyquerytracker)
+
+![PyPI - License](https://img.shields.io/pypi/l/pyquerytracker)
+
 # 🐍 pyquerytracker
 
 **pyquerytracker** is a lightweight Python utility to **track and analyze database query performance** using simple decorators. It enables developers to gain visibility into SQL execution time, log metadata, and export insights in JSON format — with optional FastAPI integration and scheduled reporting.
@@ -46,8 +56,24 @@ Dynamic: license-file
 pip install pyquerytracker
 ```
 
-## Usage
+## 🔧 Configuration
+
+```python
+import logging
+from pyquerytracker.config import configure
+
+configure(
+    slow_log_threshold_ms=200,     # Log queries slower than 200ms
+    slow_log_level=logging.DEBUG   # Use DEBUG level for slow logs
+)
+```
+
+---
+
+## ⚙️ Usage
+
 ### Basic Usage
+
 ```python
 import time
 from pyquerytracker import TrackQuery
@@ -59,26 +85,81 @@ def run_query():
 
 run_query()
 ```
-### Output
-```bash
+
+**Output:**
+```
 2025-06-14 14:23:00,123 - pyquerytracker - INFO - Function run_query executed successfully in 305.12ms
 ```
 
-### With Configure
+---
+
+### 🧩 Async Support
+
+Use the same decorator with `async` functions or class methods:
+
+```python
+import asyncio
+from pyquerytracker import TrackQuery
+
+@TrackQuery()
+async def fetch_data():
+    await asyncio.sleep(0.2)
+    return "fetched"
+
+class MyService:
+    @TrackQuery()
+    async def do_work(self, x, y):
+        await asyncio.sleep(0.1)
+        return x + y
+
+asyncio.run(fetch_data())
 ```
-import logging
+
+---
+
+### 🌐 Run the FastAPI Server
+
+To view tracked query logs via REST, WebSocket, or a Web-based dashboard, start the built-in FastAPI server:
+
+```bash
+uvicorn pyquerytracker.api:app --reload
+```
+
+- ⚠️ If your project or file structure is different, replace `pyquerytracker.api` with your own module path, like `<your_project_name>.<your_server(file)_name>`.
+
+- Open docs at [http://localhost:8000/docs](http://localhost:8000/docs)
+- **Query Dashboard UI:** [http://localhost:8000/dashboard](http://localhost:8000/dashboard)
+- REST endpoint: `GET /queries`
+- WebSocket stream: `ws://localhost:8000/ws`
+
+Then run your tracked functions in another terminal or script:
+
+```python
+@TrackQuery()
+def insert_query():
+    time.sleep(0.4)
+    return "INSERT INTO users ..."
+```
+
+You’ll see logs live on the server via API/WebSocket.
+
+---
+
+## 📤 Export Logs
+
+Enable exporting to CSV or JSON by setting config:
+
+```python
 from pyquerytracker.config import configure
 
 configure(
-    slow_log_threshold_ms=200,     # Log queries slower than 200ms
-    slow_log_level=logging.DEBUG   # Use DEBUG level for slow logs
+    export_type="json",
+    export_path="./query_logs.json"
 )
 ```
 
-### Output
-```bash
-2025-06-14 14:24:45,456 - pyquerytracker - WARNING - Slow execution: run_query took 501.87ms
-```
+---
 
+Let us know how you’re using `pyquerytracker` and feel free to contribute!
 
 

pyquerytracker-0.1.1.dist-info/RECORD

@@ -0,0 +1,39 @@
+examples/async_example.py,sha256=c22yunbe7XW4Lqo9NQGJizNty69ieRtTrAo5179446Y,1476
+examples/fastapi_app.py,sha256=bNYkkgzUCWFV_cJ7lfX-sQBhXXdUUeOd-bxum2KwggE,3334
+examples/test_endpoints.py,sha256=wFea-BE82osBeUvY9zn7zD1PyQhAaaQ4es9AaefnhMQ,2402
+examples/core/async_usage.py,sha256=-JDyXoaglwnipQLwSx_qrc5pE3KGWa7rf-bBurP8a_4,1432
+examples/core/basic_usage.py,sha256=ux-FC8XJFS7KUK0Prci0a2BwGnS4v0_gcGP077e-aeE,393
+examples/core/error_handling.py,sha256=V0ewoMJZOSPQR4NRzhSZv7OAEnjqLjef7QkNRaLvVMQ,527
+examples/core/quick_test.py,sha256=a7lTkWj1ZJD75pH-Ae66nxvzUcKqOjKBi7mVRuJRzcU,850
+examples/core/with_arguments.py,sha256=BWm4kuh7kpzKSb4pGOsx8bU2ZUPtR8UJLaDYQE_t5cM,759
+examples/core/with_config.py,sha256=rqkhelnRnDs6h7KHekP62MSjnjU4lQJz6lKOx3ZIX_A,677
+examples/exporter/csv_exporter_1.py,sha256=g0kB55sA0-8q66491ZD3K1QxB-doktqQAwDaKDVzbcA,648
+examples/exporter/json_exporter.py,sha256=K-ZHdiLgODft6jZmE3nYTesEh_Z_OOOVQmc4WV_0KqY,674
+pyquerytracker/__init__.py,sha256=8vDDWF9EBGmIyijtD4n9PPxVVhXkoUtIWKFAw5WbWXM,126
+pyquerytracker/api.py,sha256=ILxHFRo9A-2rDzWKBK15_Z0wBQeq2JHvvJ8Ky0AJX-w,2079
+pyquerytracker/config.py,sha256=o_MV1pGfb3HGQLNSfyISQ8YX0jDCymiCMQEHGkHVf2A,2268
+pyquerytracker/core.py,sha256=8300ITVvMbjY8OsdqApc69zJaudeOp0YHWeq4f9iR_s,6169
+pyquerytracker/main.py,sha256=EUbMAeokP1nsY-sXhG_kWtGzMLvUcJhLD7N8uJVRlhQ,137
+pyquerytracker/tracker.py,sha256=2RIfq1CNMzJ7XiMBqcMcFgHIwgTXBfuXU7nfwDpNOgo,605
+pyquerytracker/websocket.py,sha256=zPKjqrz1OQniMW9RQTnQHmg9yROE3vfWz23KCbBLd9g,908
+pyquerytracker/db/models.py,sha256=R0o0uHQp0QZl886vi5wJix5I67jCuQq1mhzyKTj4ypQ,644
+pyquerytracker/db/session.py,sha256=uuqrlNGdvTRkYnfEXNGB7bWKUsFDX8KnaI6LgCAW-0w,278
+pyquerytracker/db/writer.py,sha256=h2peKrlEB3bTuzs6NdJe6fyMVZohMRussSzPXPPdlNI,2157
+pyquerytracker/exporter/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pyquerytracker/exporter/base.py,sha256=jRrQT29ZLDAFuyv3YnpmLD_dO7HuFeRQZ53eVDVmtfk,412
+pyquerytracker/exporter/csv_exporter.py,sha256=2XWZs9VKcWxYZ_NTd8iiVhWOFW3FfQwysZRHixZsMZE,1648
+pyquerytracker/exporter/json_exporter.py,sha256=YJGqHJpwi-yA_Cxjj1GIMytm3WW34ngjoH0j3ZTBsOE,1422
+pyquerytracker/exporter/manager.py,sha256=owg6mlvGa6qjR92VayOIO2lUVGBUukYm54Mu3gOzB18,1016
+pyquerytracker/utils/logger.py,sha256=cgBQG8yvwGA1SUsbd2Ef7zBieVEVWxRx_7xIVWrhMsc,506
+pyquerytracker-0.1.1.dist-info/licenses/LICENSE,sha256=lXcEFZRxovixBqp9SYJRLrN5OpP6AMggc_v7eaAMWn4,1065
+tests/test_async_core.py,sha256=mwTvPdUHPVmdQMd_mB1BpIF-PTgcg3Hs3AAofY03sts,2716
+tests/test_config.py,sha256=XKi8GM5P2lj0Xm10pPSwMYnHRnYhvpkmTyeKGFyaiOM,945
+tests/test_core.py,sha256=SFooHkpvYUWipuon0IIwVUChVhRwUaXyBH78humupkM,1688
+tests/test_dashboard.py,sha256=OsUP7_4mBF6u0HgAgzL5Vkf1qO4Vm7Np9z4uv8zSGzc,724
+tests/test_persist.py,sha256=E7MFfP4LAXATRojpGoNgK8HbyszdILNWB47c-9SsBis,123
+tests/test_websocket.py,sha256=Akfd9EH9XhBMMGb-B5Jg_aaC1OAHeVFiMIKlFjyLaS0,1470
+tests/exporter/test_json_exporter.py,sha256=m6mDQTjdmiag9AulmP2mzDl78xwgqXZ1hMm6HQBkKg4,4553
+pyquerytracker-0.1.1.dist-info/METADATA,sha256=F5uwJ3ZyysfGbOQzg8xmDyw-ejkrhjJNwzNc4M_iwmw,4519
+pyquerytracker-0.1.1.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+pyquerytracker-0.1.1.dist-info/top_level.txt,sha256=gSZtdyA6IEnK-AIdMq8dMYY4AUNhnLm6jOmUY8pFZrI,30
+pyquerytracker-0.1.1.dist-info/RECORD,,

{pyquerytracker-0.1.0.dist-info → pyquerytracker-0.1.1.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.9.0)
+Generator: setuptools (80.10.2)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

{pyquerytracker-0.1.0.dist-info → pyquerytracker-0.1.1.dist-info}/top_level.txt

@@ -1 +1,3 @@
+examples
 pyquerytracker
+tests

tests/exporter/test_json_exporter.py

@@ -0,0 +1,182 @@
+import json
+import os
+import subprocess
+import tempfile
+
+
+def run_test_in_subprocess(script: str, export_path: str):
+    print("\n----- Running Script -----\n")
+    print(script)
+    print("\n--------------------------\n")
+
+    try:
+        subprocess.run(
+            ["python3", "-c", script], check=True, capture_output=True, text=True
+        )
+    except subprocess.CalledProcessError as e:
+        print("STDOUT:\n", e.stdout)
+        print("STDERR:\n", e.stderr)
+        raise
+
+    assert os.path.exists(export_path)
+    with open(export_path) as f:
+        return json.load(f)
+
+
+def test_successful_function_logs():
+    with tempfile.TemporaryDirectory() as tmpdir:
+        export_path = os.path.join(tmpdir, "log.json")
+
+        script = f"""
+import time
+from pyquerytracker import TrackQuery
+from pyquerytracker.config import configure, ExportType
+
+configure(
+    slow_log_threshold_ms=0.0,
+    slow_log_level=10,
+    export_type=ExportType.JSON,
+    export_path=r"{export_path}",
+)
+
+@TrackQuery()
+def foo(x, y):
+    return x + y
+
+foo(1, 2)
+from pyquerytracker.exporter.manager import ExporterManager
+ExporterManager.get().flush()
+"""
+
+        logs = run_test_in_subprocess(script, export_path)
+
+        assert isinstance(logs, list)
+        functions_logged = {log.get("function_name") for log in logs}
+        assert "foo" in functions_logged
+        assert any(log.get("event") == "success" for log in logs) or any(
+            log.get("event") == "slow_execution" for log in logs
+        )
+
+
+def test_error_function_logs():
+    with tempfile.TemporaryDirectory() as tmpdir:
+        export_path = os.path.join(tmpdir, "log.json")
+
+        script = f"""
+import time
+from pyquerytracker import TrackQuery
+from pyquerytracker.config import configure, ExportType
+
+configure(
+    slow_log_threshold_ms=0.0,
+    slow_log_level=10,
+    export_type=ExportType.JSON,
+    export_path=r"{export_path}",
+)
+
+@TrackQuery()
+def bar():
+    raise RuntimeError("error")
+
+try:
+    bar()
+except RuntimeError:
+    pass
+
+from pyquerytracker.exporter.manager import ExporterManager
+ExporterManager.get().flush()
+
+"""
+
+        logs = run_test_in_subprocess(script, export_path)
+
+        assert isinstance(logs, list)
+        functions_logged = {log.get("function_name") for log in logs}
+        assert "bar" in functions_logged
+        assert any(log.get("event") == "error" for log in logs)
+
+
+def test_slow_function_logs():
+    with tempfile.TemporaryDirectory() as tmpdir:
+        export_path = os.path.join(tmpdir, "log.json")
+
+        script = f"""
+import time
+from pyquerytracker import TrackQuery
+from pyquerytracker.config import configure, ExportType
+
+# Set threshold low so the sleep triggers slow log
+configure(
+    slow_log_threshold_ms=5.0,
+    slow_log_level=10,
+    export_type=ExportType.JSON,
+    export_path=r"{export_path}",
+)
+
+@TrackQuery()
+def slow_func():
+    time.sleep(0.01)
+    return "done"
+
+slow_func()
+
+from pyquerytracker.exporter.manager import ExporterManager
+ExporterManager.get().flush()
+
+"""
+
+        logs = run_test_in_subprocess(script, export_path)
+
+        assert isinstance(logs, list)
+        functions_logged = {log.get("function_name") for log in logs}
+        assert "slow_func" in functions_logged
+        assert any(log.get("event") == "slow_execution" for log in logs)
+
+
+def test_multiple_calls_logged():
+    with tempfile.TemporaryDirectory() as tmpdir:
+        export_path = os.path.join(tmpdir, "log.json")
+
+        script = f"""
+import time
+from pyquerytracker import TrackQuery
+from pyquerytracker.config import configure, ExportType
+
+configure(
+    slow_log_threshold_ms=0.0,
+    slow_log_level=10,
+    export_type=ExportType.JSON,
+    export_path=r"{export_path}",
+)
+
+@TrackQuery()
+def a():
+    return 1
+
+@TrackQuery()
+def b():
+    raise ValueError("fail")
+
+a()
+try:
+    b()
+except Exception:
+    pass
+a()
+
+from pyquerytracker.exporter.manager import ExporterManager
+ExporterManager.get().flush()
+
+"""
+
+        logs = run_test_in_subprocess(script, export_path)
+
+        assert isinstance(logs, list)
+        functions_logged = [log.get("function_name") for log in logs]
+
+        # Because of overwrite behavior, logs might only contain last flush,
+        # but often logs include multiple entries. So test at least one a, b occurrence:
+        assert "a" in functions_logged or "b" in functions_logged
+        # Check for presence of success and error events in the batch
+        events = {log.get("event") for log in logs}
+        assert "error" in events or "success" in events or "slow_execution" in events

tests/test_async_core.py

@@ -0,0 +1,93 @@
+import asyncio
+import logging
+
+import pytest
+
+from pyquerytracker import TrackQuery, configure
+
+# Mark all tests in this file as asyncio
+pytestmark = pytest.mark.asyncio
+
+
+async def test_async_tracking_output(caplog):
+    caplog.set_level("INFO")
+
+    @TrackQuery()
+    async def fake_async_db_query():
+        await asyncio.sleep(0.01)
+        return "done"
+
+    result = await fake_async_db_query()
+    assert result == "done"
+
+    # Check the log records
+    assert len(caplog.records) == 1
+    record = caplog.records[0]
+    assert record.levelname == "INFO"
+    assert "Function fake_async_db_query executed successfully" in record.message
+    assert "ms" in record.message
+
+
+async def test_async_tracking_output_with_error(caplog):
+    configure(slow_log_threshold_ms=10, slow_log_level=40)
+    caplog.set_level("ERROR")
+
+    @TrackQuery()
+    async def failing_async_query():
+        await asyncio.sleep(0.01)
+        raise ValueError("Async Test error")
+
+    result = await failing_async_query()
+    assert result is None
+
+    # Check the log records
+    assert len(caplog.records) == 1
+    record = caplog.records[0]
+    assert record.levelname == "ERROR"
+    assert "Function failing_async_query failed" in record.message
+    assert "Async Test error" in record.message
+    assert "ms" in record.message
+
+
+async def test_async_tracking_with_class(caplog):
+    configure(slow_log_threshold_ms=1000, slow_log_level=logging.INFO)
+    caplog.set_level("INFO")
+
+    class MyAsyncClass:
+        @TrackQuery()
+        async def do_work(self, a, b):
+            await asyncio.sleep(0.01)
+            return a + b
+
+    result = await MyAsyncClass().do_work(5, 10)
+    assert result == 15
+    assert len(caplog.records) == 1
+    record = caplog.records[0]
+    assert record.levelname == "INFO"
+    assert "MyAsyncClass" in record.message
+    assert "do_work" in record.message
+    assert "ms" in record.message
+
+
+async def test_async_configure_slow_log(caplog):
+    configure(slow_log_threshold_ms=10, slow_log_level=40)
+    caplog.set_level("ERROR", logger="pyquerytracker")
+
+    @TrackQuery()
+    async def do_slow_async_work():
+        await asyncio.sleep(0.1)
+        return "slow"
+
+    try:
+        result = await do_slow_async_work()
+        assert result == "slow"
+        assert len(caplog.records) == 1
+        record = caplog.records[0]
+        assert record.levelname == "ERROR"  # Configured to ERROR for slow logs
+        assert "do_slow_async_work" in record.message
+        assert "Slow execution" in record.message
+        assert "ms" in record.message
+
+    finally:
+        # Reset config to avoid affecting other tests
+        configure(slow_log_threshold_ms=100.0, slow_log_level=logging.WARNING)

tests/test_config.py

@@ -0,0 +1,40 @@
+import logging
+import time
+
+from pyquerytracker.core import TrackQuery, logger
+
+
+def configure(slow_log_threshold_ms=100, slow_log_level=logging.INFO):
+    logger.setLevel(slow_log_level)
+
+
+def test_configure_basic(caplog):
+    configure(slow_log_threshold_ms=250)
+
+    class MyClass:
+        @TrackQuery()
+        def do_work(self, a, b):
+            time.sleep(0.5)
+            return a * b
+
+    MyClass().do_work(2, 3)
+    assert len(caplog.records) == 1
+
+
+def test_configure_basic_with_loglevel(caplog):
+    caplog.set_level("ERROR", logger="pyquerytracker")
+
+    configure(slow_log_threshold_ms=100, slow_log_level=logging.ERROR)
+
+    class MyClass:
+        def do_slow_work(self, a, b):
+            import time
+
+            time.sleep(0.2)
+            return a * b
+
+    # Apply TrackQuery to the unbound method
+    MyClass.do_slow_work = TrackQuery()(MyClass.do_slow_work)
+
+    result = MyClass().do_slow_work(2, 3)
+    assert result == 6

tests/test_core.py

@@ -0,0 +1,72 @@
+import logging
+import time
+
+from pyquerytracker import TrackQuery
+
+
+def test_tracking_output():
+    @TrackQuery()
+    def fake_db_query():
+        return "done"
+
+    assert fake_db_query() == "done"
+
+
+logging.basicConfig(
+    level=logging.INFO, format="%(asctime)s - %(name)s - %(levelname)s - %(message)s"
+)
+
+
+def test_tracking_output_with_logging(caplog):
+    caplog.set_level("INFO")
+
+    @TrackQuery()
+    def fake_db_query():
+        return "done"
+
+    result = fake_db_query()
+    assert result == "done"
+
+    # Check the log records
+    assert len(caplog.records) == 1
+    record = caplog.records[0]
+    assert record.levelname == "INFO"
+    assert "Function fake_db_query executed successfully" in record.message
+    assert "ms" in record.message
+
+
+def test_tracking_output_with_error(caplog):
+    caplog.set_level("ERROR")
+
+    @TrackQuery()
+    def failing_query():
+        raise ValueError("Test error")
+
+    result = failing_query()
+    assert result is None
+
+    # Check the log records
+    assert len(caplog.records) == 1
+    record = caplog.records[0]
+    assert record.levelname == "ERROR"
+    assert "Function failing_query failed" in record.message
+    assert "Test error" in record.message
+    assert "ms" in record.message
+
+
+def test_tracking_with_class(caplog):
+    caplog.set_level("INFO")
+
+    class MyClass:
+        @TrackQuery()
+        def do_work(self, a, b):
+            time.sleep(0.09)
+            return a * b
+
+    MyClass().do_work(2, 3)
+    assert len(caplog.records) == 1
+    record = caplog.records[0]
+    assert record.levelname == "INFO"
+    assert "MyClass" in record.message
+    assert "do_work" in record.message
+    assert "ms" in record.message

tests/test_dashboard.py

@@ -0,0 +1,31 @@
+from fastapi.testclient import TestClient
+
+from pyquerytracker.api import app
+from pyquerytracker.core import TrackQuery
+
+client = TestClient(app)
+
+
+# Simulate query activity
+@TrackQuery()
+def sample_query():
+    return "ok"
+
+
+def test_query_stats_endpoint():
+    # Trigger a few logs
+    for _ in range(3):
+        sample_query()
+
+    # Call the stats endpoint
+    response = client.get("/api/query-stats?minutes=5")
+    assert response.status_code == 200
+
+    json = response.json()
+    assert "labels" in json
+    assert "durations" in json
+    assert isinstance(json["labels"], list)
+    assert isinstance(json["durations"], list)
+
+    # Optional: Print results for debug
+    print("📊 Dashboard API response:", json)

tests/test_persist.py

@@ -0,0 +1,9 @@
+from pyquerytracker import TrackQuery
+
+
+@TrackQuery()
+def sample_query():
+    return "DB test successful"
+
+
+sample_query()

tests/test_websocket.py

@@ -0,0 +1,58 @@
+import asyncio
+
+from starlette.testclient import TestClient
+
+from pyquerytracker.api import app
+from pyquerytracker.websocket import (broadcast, connected_clients,
+                                      websocket_endpoint)
+
+
+def test_websocket_connection():
+    client = TestClient(app)
+    with client.websocket_connect("/ws") as websocket:
+        websocket.send_text("ping")  # No response expected, just test it works
+
+
+def test_broadcast_message_format():
+    class FakeWebSocket:
+        def __init__(self):
+            self.sent = []
+
+        async def send_text(self, msg):
+            self.sent.append(msg)
+
+    fake_ws = FakeWebSocket()
+    connected_clients.append(fake_ws)
+
+    asyncio.run(broadcast("hello"))
+    assert fake_ws.sent == ["hello"]
+
+    connected_clients.remove(fake_ws)
+
+
+def test_connection_lifecycle():
+    class DummyWebSocket:
+        def __init__(self):
+            self.accepted = False
+
+        async def accept(self):
+            self.accepted = True
+
+        async def receive_text(self):
+            raise Exception("Simulated disconnect")
+
+    ws = DummyWebSocket()
+    connected_clients.clear()
+    try:
+        asyncio.run(websocket_endpoint(ws))
+    except Exception:
+        pass
+    assert ws not in connected_clients
+
+
+def test_broadcast_no_clients():
+    connected_clients.clear()
+    try:
+        asyncio.run(broadcast("no one here"))
+    except Exception:
+        assert False, "Broadcast failed when no clients connected"

pyquerytracker-0.1.0.dist-info/RECORD

@@ -1,8 +0,0 @@
-pyquerytracker/__init__.py,sha256=pYyF2RPTTMhA0SakZTZ_dJ5dbPOIPYlacXJg7dSfsdc,98
-pyquerytracker/config.py,sha256=GuMaHx4RB77FFad4bzZTQ-EyQYkDYHRrELHD_bTjAZo,1907
-pyquerytracker/core.py,sha256=eLMfYs41ajLRjoxtxKjyi9G3NPN7tpwYkNerccL2oM4,3583
-pyquerytracker-0.1.0.dist-info/licenses/LICENSE,sha256=lXcEFZRxovixBqp9SYJRLrN5OpP6AMggc_v7eaAMWn4,1065
-pyquerytracker-0.1.0.dist-info/METADATA,sha256=RlPCS75bqssay-luqk6PuGlz_sb6NKAEKlcixWokI8E,2540
-pyquerytracker-0.1.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-pyquerytracker-0.1.0.dist-info/top_level.txt,sha256=E5kxHgMifJIw-S2IjZqA1XuAU06Vbhd7geNfRZgjZuQ,15
-pyquerytracker-0.1.0.dist-info/RECORD,,