Merge pull request 'Aligning activity logger' (#17) from debug_fitness_more into master

Reviewed-on: #17

fitnessCog/activity_logger.py

@@ -1,80 +1,78 @@
-import json
 import csv
-import os
+import json
+from pathlib import Path
+from typing import Optional
 
 
-def activity_log_path(activity: str) -> str:
+def activity_log_path(activity: str, logs_dir: Optional[Path] = None) -> Path:
     """
-    Returns the path of the activity log file in .csv format
+    Returns the path of the activity log file in .csv format.
-    :param activity:
-    :return:
     """
-    filename = os.path.join("activity_logs", f"{activity}.csv")
+    logs_dir = logs_dir or (Path.cwd() / "activity_logs")
-    return filename
+    return logs_dir / f"{activity}.csv"
 
 
-def activity_units_path(activity: str) -> str:
+def activity_units_path(activity: str, units_dir: Optional[Path] = None) -> Path:
     """
-    Returns the path of the activity activities file in .json format
+    Returns the path of the activity units file in .json format.
-    :param activity:
-    :return:
     """
-    filename = os.path.join("activities", f"{activity}.json")
+    units_dir = units_dir or (Path.cwd() / "activities")
-    return filename
+    return units_dir / f"{activity}.json"
 
 
-def is_convertable(activity: str) -> bool:
+def is_convertable(activity: str, units_dir: Optional[Path] = None) -> bool:
-    """
+    filename = activity_units_path(activity, units_dir)
-    Returns True if the activity has multiple units that needed to be converted.
+    with filename.open("r", encoding="utf-8") as f:
-    i.e. distance may be sent in feet, but would require to be converted in meters.
+        raw_data = json.load(f)
-    :param activity:
+    return bool(raw_data.get("convertable"))
-    :return:
-    """
-    filename = activity_units_path(activity)
-    raw_data = json.load(open(filename))
-    return raw_data.get("convertable")
 
 
-
+def create_activity_log_file(
-def create_activity_log_file(activity: str) -> None:
+    activity: str,
-    """
+    *,
-    Creates the activity log file in .csv format
+    units_dir: Optional[Path] = None,
-    :param activity:
+    logs_dir: Optional[Path] = None,
-    :return:
+) -> None:
-    """
+    if not activity_units_path(activity, units_dir).exists():
-    if not os.path.exists(activity_units_path(activity)):
         raise ValueError(f"{activity} is not a valid activity")
-    if not os.path.exists("activity_logs"):
+
-        os.makedirs("activity_logs")
+    logs_dir = logs_dir or (Path.cwd() / "activity_logs")
-    filename = activity_log_path(activity)
+    logs_dir.mkdir(parents=True, exist_ok=True)
-    with open(filename, 'a') as f:
+
+    filename = activity_log_path(activity, logs_dir)
+    if filename.exists():
+        return  # don't re-add headers
+
+    with filename.open("w", newline="", encoding="utf-8") as f:
         writer = csv.writer(f)
         writer.writerow(["timestamp", "username", "value"])
 
 
-
+def convert_units(
-def convert_units(activity: str, value: int | float, unit: str) -> float:
+    activity: str,
-    """
+    value: int | float,
-    Returns the value of activity in a factor of 1, i.e. converting feet to meters
+    unit: str | None,
-    :param activity:
+    *,
-    :param value:
+    units_dir: Optional[Path] = None,
-    :param unit:
+) -> float:
-    :return:
+    filename = activity_units_path(activity, units_dir)
-    """
+    if not filename.exists():
-    filename = activity_units_path(activity)
-    if not os.path.exists(filename):
         raise ValueError(f"{activity} is not a valid activity")
 
     # Consider None unit value as factor of 1
     if unit is None:
-        return value
+        return float(value)
 
-    raw_data = json.load(open(filename))
+    with filename.open("r", encoding="utf-8") as f:
-    units_data = raw_data.get("units")
+        raw_data = json.load(f)
 
-    for unit_name, data in units_data.items():
+    units_data = raw_data.get("units") or {}
-        if unit in data["aliases"]:
+    unit_l = unit.lower()
-            return value * data["factor"]
+
+    for _, data in units_data.items():
+        aliases = [a.lower() for a in (data.get("aliases") or [])]
+        if unit_l in aliases:
+            return float(value) * float(data["factor"])
 
     raise ValueError(f"{unit} is not a valid unit")
 
@@ -84,36 +82,24 @@ def log_activity(
     username: str,
     activity: str,
     value: int | float,
-        unit: str | None
+    unit: str | None,
+    *,
+    units_dir: Optional[Path] = None,
+    logs_dir: Optional[Path] = None,
 ) -> None:
-    """
+    
-    Logs the activity in .csv file
+    if not isinstance(value, (int, float)) or value <= 0:
-    :param timestamp:
-    :param username:
-    :param activity:
-    :param value:
-    :param unit:
-    :return:
-    """
-    if value <= 0 or not isinstance(value, int | float):
         raise ValueError(f"{value} is not a valid value")
-    filename = activity_log_path(activity)
+
-    if not os.path.exists(filename):
+    filename = activity_log_path(activity, logs_dir)
-        create_activity_log_file(activity)
+    if not filename.exists():
-    if is_convertable(activity):
+        create_activity_log_file(activity, units_dir=units_dir, logs_dir=logs_dir)
-        converted_value = round(convert_units(activity, value, unit), 2)
+
+    if is_convertable(activity, units_dir):
+        converted_value = round(convert_units(activity, value, unit, units_dir=units_dir), 2)
     else:
-        converted_value = round(value, 2)
+        converted_value = round(float(value), 2)
-    with open(filename, 'a') as f:
+
+    with filename.open("a", newline="", encoding="utf-8") as f:
         writer = csv.writer(f)
         writer.writerow([timestamp, username, converted_value])
-
-
-if __name__ == "__main__":
-    log_activity(
-        timestamp=0,
-        username="test",
-        activity="climb",
-        value=1,
-        unit="m"
-    )

fitnessCog/fitness.py

@@ -3,7 +3,7 @@ from pathlib import Path
 
 import discord
 from redbot.core import commands
-from redbot.core.data_manager import bundled_data_path
+from redbot.core.data_manager import cog_data_path
 
 from .activity_logger import log_activity
 
@@ -15,21 +15,20 @@ class FitnessCog(commands.Cog):
         default_threads = "1457402451530350727,1328363409648910356"
         threads_raw = os.getenv("THREADS_ID", default_threads)
 
-        self.threads_id = []
+        self.threads_id: list[int] = []
         for x in threads_raw.split(","):
             x = x.strip()
             if x.isdigit():
                 self.threads_id.append(int(x))
 
         self.confirm_reactions = os.getenv("CONFIRMATION_REACTIONS", "🐈💨")
-        self.bundled_activities_dir: Path = bundled_data_path(self) / "activities"
 
-    # ---- path helpers ----
+        # Units are shipped with the cog in: fitnessCog/activities/*.json
-    def activity_units_path(self, activity: str) -> Path:
+        self.units_dir: Path = Path(__file__).parent / "activities"
-        return self.bundled_activities_dir / f"{activity}.json"
 
-    def activity_log_path(self, activity: str) -> Path:
+        # Logs are writable and belong in Red's data dir
-        return self.bundled_activities_dir / f"{activity}_log.json"
+        self.logs_dir: Path = cog_data_path(self) / "activity_logs"
+        self.logs_dir.mkdir(parents=True, exist_ok=True)
 
     @commands.Cog.listener()
     async def on_message(self, message: discord.Message):
@@ -67,7 +66,8 @@ class FitnessCog(commands.Cog):
                 )
                 return
 
-            path = self.activity_units_path(activity)
+            activity = activity.lower().strip()
+            path = self.units_dir / f"{activity}.json"
 
             if not path.exists():
                 await message.channel.send(f"No units JSON found for `{activity}`.")
@@ -86,10 +86,11 @@ class FitnessCog(commands.Cog):
                 )
                 return
 
-            path = self.activity_log_path(activity)
+            activity = activity.lower().strip()
+            path = self.logs_dir / f"{activity}.csv"
 
             if not path.exists():
-                await message.channel.send(f"No log JSON found for `{activity}`.")
+                await message.channel.send(f"No log CSV found for `{activity}`.")
                 return
 
             await message.channel.send(file=discord.File(fp=str(path)))
@@ -121,7 +122,15 @@ class FitnessCog(commands.Cog):
             timestamp = int(message.created_at.timestamp())
             username = message.author.name
 
-            log_activity(timestamp, username, activity, value, unit)
+            log_activity(
+                timestamp,
+                username,
+                activity,
+                value,
+                unit,
+                units_dir=self.units_dir,
+                logs_dir=self.logs_dir,
+            )
 
             for r in self.confirm_reactions:
                 await message.add_reaction(r)