feat: Added method for getting transaction count for a range of dates and months

.gitignore

@@ -174,4 +174,5 @@ cython_debug/
 .pypirc
 
 .DS_Store
-.vscode
+.vscode
+.idea

.python-version

@@ -0,0 +1 @@
+3.12.6

src/database/general_db.py

@@ -1,6 +1,7 @@
 from utils.data_processor import fetch_non_time_series_data
-from typing import Tuple, List, Dict, Any
-from database.db_utils import db_pool
+from typing import Tuple, List, Dict, Any, Literal
+from datetime import datetime, timezone, date
+
 
 async def fetch_etherlink_transactions(conn) -> Tuple[List[Dict[str, Any]], Exception]:
     try:
@@ -12,7 +13,8 @@ async def fetch_etherlink_transactions(conn) -> Tuple[List[Dict[str, Any]], Exce
     except Exception as e:
         return None, e
 
-async def fetch_tzkt_transactions(conn) -> Tuple[List[Dict[str, Any]], Exception]:
+
+async def fetch_tzkt_transactions_by_month(conn) -> Tuple[List[Dict[str, Any]], Exception]:
     try:
         query = """
           select date(month), transaction_count from mv_tzkt_monthly_transactions
@@ -22,6 +24,62 @@ async def fetch_tzkt_transactions(conn) -> Tuple[List[Dict[str, Any]], Exception
     except Exception as e:
         return None, e
 
+
+async def fetch_tzkt_transaction_count_by_day(conn, interval: Literal["1d", "1M"], limit: int = 7) -> Tuple[List[List[int]], None] | Tuple[None, Exception]:
+    try:
+        query = ""
+
+        match interval:
+            case "1d":
+                query = f"""
+                    WITH last_day AS (SELECT max(mv_tzkt_daily_transactions.day) AS max_day
+                                    FROM mv_tzkt_daily_transactions)
+                    SELECT t.day                  AS time,
+                        t.transaction_count    AS total_transactions,
+                        c.contract_calls_count AS total_contract_calls
+                    FROM mv_tzkt_daily_transactions t
+                            INNER JOIN mv_tzkt_daily_contract_calls c ON t.day = c.day,
+                        last_day
+                    WHERE t.day >= last_day.max_day - INTERVAL '{limit - 2} days'
+                    ORDER BY time;
+                """
+
+            case "1M":
+                query = f"""
+                    SELECT DATE_TRUNC('month', t.day)::date AS month,
+                        SUM(t.transaction_count)         AS total_transactions,
+                        SUM(c.contract_calls_count)      AS total_contract_calls
+                    FROM mv_tzkt_daily_transactions t
+                            INNER JOIN mv_tzkt_daily_contract_calls c ON t.day = c.day
+                    WHERE t.day >= DATE_TRUNC('month', CURRENT_DATE) - INTERVAL '{limit - 2} months'
+                    AND t.day <= CURRENT_DATE
+                    GROUP BY DATE_TRUNC('month', t.day)
+                    ORDER BY month;
+                """
+
+        rows = await conn.fetch(query)
+        column_data: List[List[int]] = []
+
+        for row in rows:
+            transaction_date: date = row[0]
+
+            timestamp = datetime.combine(
+                transaction_date, datetime.min.time(), tzinfo=timezone.utc)
+            tx_count: int = row[1]
+            call_count: int = row[2]
+
+            column_data.append([
+                int(timestamp.timestamp() * 1000),  # we need milliseconds
+                tx_count,
+                call_count
+            ])
+
+        return column_data, None
+
+    except Exception as e:
+        return None, e
+
+
 async def fetch_etherlink_users(conn) -> Tuple[List[Dict[str, Any]], Exception]:
     try:
         query = """
@@ -31,7 +89,8 @@ async def fetch_etherlink_users(conn) -> Tuple[List[Dict[str, Any]], Exception]:
         return data, None
     except Exception as e:
         return None, e
-
+
+
 async def fetch_tzkt_users(conn) -> Tuple[List[Dict[str, Any]], Exception]:
     try:
         query = """
@@ -42,6 +101,7 @@ async def fetch_tzkt_users(conn) -> Tuple[List[Dict[str, Any]], Exception]:
     except Exception as e:
         return None, e
 
+
 async def fetch_bot_users(conn) -> Tuple[List[Dict[str, Any]], Exception]:
     try:
         query = """
@@ -50,7 +110,8 @@ async def fetch_bot_users(conn) -> Tuple[List[Dict[str, Any]], Exception]:
         data = await fetch_non_time_series_data(conn, query, "bot_users", ["time", "bot_users"])
         return data, None
     except Exception as e:
-        return None, e   
+        return None, e
+
 
 async def fetch_bot_transactions(conn) -> Tuple[List[Dict[str, Any]], Exception]:
     try:
@@ -61,7 +122,8 @@ async def fetch_bot_transactions(conn) -> Tuple[List[Dict[str, Any]], Exception]
         return data, None
     except Exception as e:
         return None, e
-
+
+
 async def fetch_etherlink_recurring_users(conn) -> Tuple[List[Dict[str, Any]], Exception]:
     try:
         query = """
@@ -72,6 +134,7 @@ async def fetch_etherlink_recurring_users(conn) -> Tuple[List[Dict[str, Any]], E
     except Exception as e:
         return None, e
 
+
 async def fetch_tzkt_recurring_users(conn) -> Tuple[List[Dict[str, Any]], Exception]:
     try:
         query = """
@@ -82,6 +145,7 @@ async def fetch_tzkt_recurring_users(conn) -> Tuple[List[Dict[str, Any]], Except
     except Exception as e:
         return None, e
 
+
 async def fetch_etherlink_plus_one_users(conn) -> Tuple[List[Dict[str, Any]], Exception]:
     try:
         query = """
@@ -92,6 +156,7 @@ async def fetch_etherlink_plus_one_users(conn) -> Tuple[List[Dict[str, Any]], Ex
     except Exception as e:
         return None, e
 
+
 async def fetch_tzkt_plus_one_users(conn) -> Tuple[List[Dict[str, Any]], Exception]:
     try:
         query = """
@@ -102,15 +167,16 @@ async def fetch_tzkt_plus_one_users(conn) -> Tuple[List[Dict[str, Any]], Excepti
     except Exception as e:
         return None, e
 
+
 async def fetch_top_projects_transactions(conn) -> Tuple[List[Dict[str, Any]], Exception]:
     try:
         query = """
-        SELECT project, tx_count, layer 
-        FROM mv_etherlink_projects_transactions 
+        SELECT project, tx_count, layer
+        FROM mv_etherlink_projects_transactions
         WHERE month = (SELECT MAX(month) FROM mv_etherlink_projects_transactions)
         AND tx_count > 0
         UNION ALL
-        SELECT project, tx_count, layer 
+        SELECT project, tx_count, layer
         FROM mv_tzkt_projects_transactions
         WHERE month = (SELECT MAX(month) FROM mv_tzkt_projects_transactions)
         AND tx_count > 0
@@ -121,6 +187,7 @@ async def fetch_top_projects_transactions(conn) -> Tuple[List[Dict[str, Any]], E
     except Exception as e:
         return None, e
 
+
 async def fetch_top_projects_users(conn) -> Tuple[List[Dict[str, Any]], Exception]:
     try:
         query = """
@@ -138,17 +205,18 @@ async def fetch_top_projects_users(conn) -> Tuple[List[Dict[str, Any]], Exceptio
     except Exception as e:
         return None, e
 
+
 async def fetch_top_projects_tvl(conn) -> Tuple[List[Dict[str, Any]], Exception]:
     try:
         query = """
-      select project, round(sum(t.tvl))::INTEGER as tvl, 
-		  CASE 
+      select project, round(sum(t.tvl))::INTEGER as tvl,
+		  CASE
       		WHEN layer = 1 THEN 'Tezos L1'
       		WHEN layer = 2 THEN 'Etherlink'
-  		  END AS layer 
+  		  END AS layer
 		  FROM tvl t
-		  join 
-		  (select distinct project, layer from 
+		  join
+		  (select distinct project, layer from
 		  project_mappings) pm
 		  ON SPLIT_PART(pm.project, ' ', 1) = SPLIT_PART(t.project_name, ' ', 1)
 		  WHERE t.date = (
@@ -163,18 +231,19 @@ async def fetch_top_projects_tvl(conn) -> Tuple[List[Dict[str, Any]], Exception]
     except Exception as e:
         return None, e
 
+
 async def fetch_total_tvl_etherlink(conn) -> Tuple[List[Dict[str, Any]], Exception]:
     try:
         query = """
-            SELECT 
+            SELECT
                 DATE_TRUNC('month', day) AS month,
                 AVG(daily_total_tvl) AS avg_daily_total_tvl
             FROM (
-                SELECT 
+                SELECT
                     DATE(date) AS day,
                     SUM(tvl - tf_tvl) AS daily_total_tvl
                 FROM tvl
-                WHERE 
+                WHERE
                     chain = 'Etherlink'
                     and category IS DISTINCT FROM 'RWA'
                     AND date >= CURRENT_DATE - INTERVAL '12 months'
@@ -183,15 +252,15 @@ async def fetch_total_tvl_etherlink(conn) -> Tuple[List[Dict[str, Any]], Excepti
             ) daily_sums
             GROUP BY DATE_TRUNC('month', daily_sums.day)
             UNION ALL
-            SELECT 
+            SELECT
                 CURRENT_DATE - INTERVAL '30 days' AS period,
                 AVG(daily_total_tvl) AS avg_daily_total_tvl
             FROM (
-                SELECT 
+                SELECT
                     DATE(date) AS day,
                     SUM(tvl - tf_tvl) AS daily_total_tvl
                 FROM tvl
-                WHERE 
+                WHERE
                     chain = 'Etherlink'
                     and category IS DISTINCT FROM 'RWA'
                     AND date >= CURRENT_DATE - INTERVAL '30 days'
@@ -204,18 +273,19 @@ async def fetch_total_tvl_etherlink(conn) -> Tuple[List[Dict[str, Any]], Excepti
     except Exception as e:
         return None, e
 
+
 async def fetch_total_tvl_tezos(conn) -> Tuple[List[Dict[str, Any]], Exception]:
     try:
         query = """
-            SELECT 
+            SELECT
                 DATE_TRUNC('month', day) AS month,
                 AVG(daily_total_tvl) AS avg_daily_total_tvl
             FROM (
-                SELECT 
+                SELECT
                     DATE(date) AS day,
                     SUM(tvl - tf_tvl) AS daily_total_tvl
                 FROM tvl
-                WHERE 
+                WHERE
                     chain = 'Tezos'
                     AND date >= CURRENT_DATE - INTERVAL '12 months'
                     and date < date_trunc('month', current_date)
@@ -224,15 +294,15 @@ async def fetch_total_tvl_tezos(conn) -> Tuple[List[Dict[str, Any]], Exception]:
             ) daily_sums
             GROUP BY DATE_TRUNC('month', daily_sums.day)
             UNION ALL
-            SELECT 
+            SELECT
                 CURRENT_DATE - INTERVAL '30 days' AS period,
                 AVG(daily_total_tvl) AS avg_daily_total_tvl
             FROM (
-                SELECT 
+                SELECT
                     DATE(date) AS day,
                     SUM(tvl - tf_tvl) AS daily_total_tvl
                 FROM tvl
-                WHERE 
+                WHERE
                     chain = 'Tezos'
                     AND date >= CURRENT_DATE - INTERVAL '30 days'
                     and project_name not in ('KordFi', 'Flame DeFi', 'Matter Defi', 'Crunchy', 'Crunchy Liquid Staking', 'Gate-io', 'Latoken', 'Bitfinex')
@@ -245,18 +315,19 @@ async def fetch_total_tvl_tezos(conn) -> Tuple[List[Dict[str, Any]], Exception]:
     except Exception as e:
         return None, e
 
+
 async def fetch_total_tvl_tf(conn) -> Tuple[List[Dict[str, Any]], Exception]:
     try:
         query = """
-            SELECT 
+            SELECT
                 DATE_TRUNC('month', day) AS month,
                 AVG(daily_total_tvl) AS avg_daily_total_tvl
             FROM (
-                SELECT 
+                SELECT
                     DATE(date) AS day,
                     SUM(tf_tvl) AS daily_total_tvl
                 FROM tvl
-                WHERE 
+                WHERE
                     date >= CURRENT_DATE - INTERVAL '12 months'
                     and date < date_trunc('month', current_date)
                     and project_name not in ('KordFi', 'Flame DeFi', 'Matter Defi', 'Crunchy', 'Crunchy Liquid Staking', 'Gate-io', 'Latoken', 'Bitfinex')
@@ -265,15 +336,15 @@ async def fetch_total_tvl_tf(conn) -> Tuple[List[Dict[str, Any]], Exception]:
             where daily_total_tvl > 0
             GROUP BY DATE_TRUNC('month', daily_sums.day)
             UNION all
-            SELECT 
+            SELECT
                 CURRENT_DATE - INTERVAL '30 days' AS period,
                 AVG(daily_total_tvl) AS avg_daily_total_tvl
             FROM (
-                SELECT 
+                SELECT
                     DATE(date) AS day,
                     SUM(tf_tvl) AS daily_total_tvl
                 FROM tvl
-                WHERE 
+                WHERE
                     date >= CURRENT_DATE - INTERVAL '30 days'
                     and project_name not in ('KordFi', 'Flame DeFi', 'Matter Defi', 'Crunchy', 'Crunchy Liquid Staking', 'Gate-io', 'Latoken', 'Bitfinex')
                 GROUP BY DATE(date)

src/database/report_db.py

@@ -1,6 +1,7 @@
 from utils.data_processor import fetch_non_time_series_data
 from typing import Tuple, List, Dict, Any
 
+
 async def fetch_targets(conn) -> Tuple[List[Dict[str, Any]], Exception]:
     try:
         query = """
@@ -24,7 +25,7 @@ async def fetch_targets(conn) -> Tuple[List[Dict[str, Any]], Exception]:
                 tvl.tvl_sum * 100.0 / NULLIF(
                     CASE
                         WHEN TRIM(COALESCE(tvl_goal, '')) = '' THEN 0
-                        WHEN tvl_goal ~ '^-?[0-9]+(\.[0-9]+)?$' THEN CAST(tvl_goal AS numeric)
+                        WHEN tvl_goal ~ '^-?[0-9]+(\\.[0-9]+)?$' THEN CAST(tvl_goal AS numeric)
                         ELSE NULL
                     END, 0
                 ) AS numeric
@@ -43,4 +44,4 @@ async def fetch_targets(conn) -> Tuple[List[Dict[str, Any]], Exception]:
         data = await fetch_non_time_series_data(conn, query, "report", ["employee/vertical", "mau_target", "mau_actual", "mau_percentage", "tvl_target", "tvl actual", "tvl_percentage"])
         return data, None
     except Exception as e:
-        return None, e
+        return None, e