async-httpd-data-collector 0.2__tar.gz → 0.2.1__tar.gz

{async_httpd_data_collector-0.2 → async_httpd_data_collector-0.2.1}/.github/workflows/publish.yml

@@ -114,3 +114,10 @@ jobs:
           TWINE_PASSWORD: ${{ secrets.PYPI_TOKEN }}
         run: |
           python3 -m twine upload dist/*
+      
+      - name: Release
+        uses: softprops/action-gh-release@v2
+        if: startsWith(github.ref, 'refs/tags/')
+        with:
+          files: |
+            dist/*

{async_httpd_data_collector-0.2 → async_httpd_data_collector-0.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: async-httpd-data-collector
-Version: 0.2
+Version: 0.2.1
 Summary: Gateway facilitating asyncronous communication between sensory data-emitting devices, InfluxDB and the user.
 Project-URL: Repository, https://github.com/straightchlorine/async-httpd-data-collector
 Project-URL: Issues, https://github.com/straightchlorine/async-httpd-data-collector/issues

async_httpd_data_collector-0.2.1/ahttpdc/__init__.py

@@ -0,0 +1 @@
+__version__ = '0.2.1'

{async_httpd_data_collector-0.2 → async_httpd_data_collector-0.2.1}/ahttpdc/reads/fetch/async_fetch.py

@@ -135,7 +135,6 @@ class AsyncReadFetcher:
             records (dict): The sensor readings as records for InfluxDB.
         """
 
-        print('<.> writing new read into database...')
         write_api = client.write_api()
         point = Point.from_dict(record, write_precision='ns')
         await write_api.write(

{async_httpd_data_collector-0.2 → async_httpd_data_collector-0.2.1}/ahttpdc/reads/interface.py

@@ -133,13 +133,12 @@ class DatabaseInterface:
             pd.DataFrame: The latest measurement.
         """
 
-        print('<.> querying latest measurement...')
         query_task = asyncio.create_task(self.query_interface.latest())
         await query_task
         result = query_task.result()
         return result
 
-    async def query_historical(self, start: str, end: str) -> pd.DataFrame:
+    async def query_historical(self, start: str, end: str = '') -> pd.DataFrame:
         """
         Query historical data from the database.
 
@@ -151,7 +150,6 @@ class DatabaseInterface:
             pd.DataFrame: Historical data within the specified time range.
         """
 
-        print('<.> querying historical data...')
         query_task = asyncio.create_task(
             self.query_interface.historical_data(start, end)
         )
@@ -170,7 +168,6 @@ class DatabaseInterface:
             pd.DataFrame: The result of the custom query.
         """
 
-        print('<.> custom query...')
         query_task = asyncio.create_task(self.query_interface.query(query))
         await query_task
         result = query_task.result()

{async_httpd_data_collector-0.2 → async_httpd_data_collector-0.2.1}/ahttpdc/reads/query/async_query.py

@@ -8,6 +8,7 @@ from datetime import datetime, timedelta
 
 from influxdb_client.client.exceptions import InfluxDBError
 from influxdb_client.client.influxdb_client_async import InfluxDBClientAsync
+from influxdb_client import InfluxDBClient
 import pandas as pd
 
 __all__ = ['AsyncQuery']
@@ -96,13 +97,14 @@ class AsyncQuery:
 
     def _into_dataframe(self, tables) -> pd.DataFrame:
         """
-        Turns the tables into a pandas DataFrame.
+        Turns the tables into a pandas DataFrame with time of measurement as
+        as index.
+
         Args:
             tables (list): The tables to turn into a DataFrame.
         Returns:
-            pd.DataFrame: procured measurements as a DataFrame.
+            pd.DataFrame: procured measurements as a DataFrame sorted by time.
         """
-        print('into dataframe')
         read: dict = {}
         timestamps = set()
 
@@ -130,8 +132,11 @@ class AsyncQuery:
         for timestamp in local_timestamps:
             read['time'].append(pd.to_datetime(timestamp))
 
-        # return the data as a DataFrame
-        return pd.DataFrame(read)
+        df = pd.DataFrame(read)
+        df.set_index('time', inplace=True)
+        df.sort_index(inplace=True)
+
+        return df
 
     async def latest(self) -> pd.DataFrame:
         """
@@ -163,35 +168,57 @@ class AsyncQuery:
         else:
             return pd.DataFrame()
 
-    async def historical_data(self, start: str, end: str) -> pd.DataFrame:
-        """
-        Query historical data from the database.
+    def historical_query(self, query: str) -> pd.DataFrame:
+        tables = None
+        try:
+            with InfluxDBClient(
+                url=self._db_url,
+                token=self._influxdb_token,
+                org=self._influxdb_organization,
+            ) as client:
+                query_api = client.query_api()
+                tables = query_api.query(query)
+        except InfluxDBError as e:
+            print(f'Exception caught while querying the database:\n\n {e.message}')
 
-        Args:
-            start (str): Start time of the query (e.g., '2024-01-01T00:00:00Z').
-            end (str): End time of the query (e.g., '2024-01-02T00:00:00Z').
+        if tables is not None:
+            return self._into_dataframe(tables)
+        else:
+            return pd.DataFrame()
 
-        Returns:
-            pd.DataFrame: Historical data within the specified time range.
+    async def historical_data(self, start: str, end: str = '') -> pd.DataFrame:
         """
+        Query the database synchronously for historical data within the specified
+        range.
+        Query the database for historical data within the specified time range.
+        Use when dealing with large time intervals. Uses regular client, not the
+        async one.
 
-        # get the connection to the database via query api
-        client = await self._get_InfluxDB_client()
-        query_api = client.query_api()
+        Args:
+            start(str): start time (e.g., '2024-01-02T00:00:00Z') of the query
+                        or relative time string (e.g., '-30d') for end unspecified
+            end (str): End time of the query (e.g., '2024-01-02T00:00:00Z')
 
-        # query the data from specified start and finish
-        query = f'from(bucket:"{self._influxdb_bucket}") |> range(start: {start}, stop: {end})'
+        Example:
+            interface.historical_data('-30d')
 
-        tables = None
-        try:
-            tables = await query_api.query(query)
-        except InfluxDBError as e:
-            print(f'Exception caught while querying the database:\n\n {e.message}')
+            finish = datetime.now()
+            start = finish - timedelta(minuts=30)
+            start = start.strftime('%Y-%m-%dT%H:%M:%SZ')
+            finish = finish.strftime('%Y-%m-%dT%H:%M:%SZ')
 
-        await client.close()
+            interface.historical_data(start, finish)
 
-        if tables is not None:
-            return self._into_dataframe(tables)
+        Returns:
+            pd.DataFrame: Historical data within the specified time range.
+        """
+
+        if start is not None and end == '':
+            query = f'from(bucket:"{self._influxdb_bucket}") |> range(start: {start})'
+            return self.historical_query(query)
+        elif start is not None and end != '':
+            query = f'from(bucket:"{self._influxdb_bucket}") |> range(start: {start}, stop: {end})'
+            return self.historical_query(query)
         else:
             return pd.DataFrame()
 

async_httpd_data_collector-0.2.1/examples/query.py

@@ -0,0 +1,42 @@
+#!/usr/bin/env python
+import json
+import asyncio
+import pandas as pd
+from ahttpdc.reads.interface import DatabaseInterface
+
+# load the secrets
+with open('secrets/rpi-secrets.json', 'r') as f:
+    secrets = json.load(f)
+
+sensors = {
+    'bmp180': ['altitude', 'pressure', 'seaLevelPressure'],
+    'mq135': ['aceton', 'alcohol', 'co', 'co2', 'nh4', 'toulen'],
+    'ds18b20': ['temperature'],
+    'dht22': ['humidity'],
+}
+
+dev_ip = '192.168.10.101'
+dev_port = '80'
+
+# create the DatabaseInterface object
+interface = DatabaseInterface(
+    secrets['host'],
+    secrets['port'],
+    secrets['token'],
+    secrets['organization'],
+    secrets['bucket'],
+    sensors,
+    dev_ip,
+    dev_port,
+    secrets['handle'],
+)
+
+
+async def query():
+    result = await interface.query_historical('-30d')
+    return result
+
+
+if __name__ == '__main__':
+    dataframe: pd.DataFrame = asyncio.run(query())
+    dataframe.to_csv('sensor-data.csv')

{async_httpd_data_collector-0.2 → async_httpd_data_collector-0.2.1}/tests/reads/test_interface.py

@@ -10,7 +10,7 @@ import os
 import pytest
 
 from ahttpdc.reads.interface import DatabaseInterface
-from datetime import datetime, timedelta
+# from datetime import datetime, timedelta
 
 from tests.reads.query.test_query import TestQuery
 
@@ -104,11 +104,8 @@ class TestInterface:
         self.set_up()
         await asyncio.sleep(5)
 
-        finish = datetime.now()
-        start = finish - timedelta(seconds=4)
-        result = await self.interface.query_historical(
-            start.strftime('%Y-%m-%dT%H:%M:%SZ'), finish.strftime('%Y-%m-%dT%H:%M:%SZ')
-        )
+        # the date variant tested in test_query.py
+        result = await self.interface.query_historical('-3s')
         self.interface.disable_fetching()
 
         assert not result.empty

async_httpd_data_collector-0.2/ahttpdc/__init__.py

@@ -1 +0,0 @@
-__version__ = '0.2'