papi-projects 0.4.1__tar.gz → 0.4.3__tar.gz

{papi_projects-0.4.1 → papi_projects-0.4.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: papi-projects
-Version: 0.4.1
+Version: 0.4.3
 Summary: PAPI is an API for managing projects
 Author-email: sandyjmacdonald <sandyjmacdonald@gmail.com>
 License-Expression: MIT

{papi_projects-0.4.1 → papi_projects-0.4.3}/papi/__init__.py

@@ -1,41 +1,60 @@
 import os
 import logging
-from dotenv import dotenv_values
 from pathlib import Path
 
+try:
+    import tomllib
+except ModuleNotFoundError:
+    import tomli as tomllib
+
+
 def load_config():
-    user_env_path = Path.home() / ".config" / "papi" / ".env"
+    config_path = os.environ.get("PAPI_CONFIG_FILE")
+    if config_path:
+        path = Path(config_path).expanduser()
+    else:
+        path = Path.home() / ".config" / "papi" / "config.toml"
+
+    if not path.exists():
+        raise RuntimeError(f"Config file not found: {path}")
+
+    with path.open("rb") as f:
+        raw = tomllib.load(f)
+
     config = {}
 
-    if user_env_path.exists():
-        config.update(dotenv_values(user_env_path))
-
-    for key in (
-        "TOGGL_TRACK_API_KEY",
-        "TOGGL_TRACK_PASSWORD",
-        "NOTION_API_SECRET",
-        "NOTION_CLIENTS_DB",
-        "NOTION_PROJECTS_DB",
-        "NOTION_TASKS_DB",
-        "NOTION_TEMPLATE_PAGE_ID",
-        "NOTION_WORKORDERS_DB",
-        "NOTION_TRAC_COSTS_DB",
-    ):
+    toggl = raw.get("toggl", {})
+    notion = raw.get("notion", {})
+
+    mapping = {
+        "TOGGL_TRACK_API_KEY": toggl.get("api_key"),
+        "TOGGL_TRACK_PASSWORD": toggl.get("password"),
+        "TOGGL_TRACK_WORKSPACE": toggl.get("workspace"),
+        "NOTION_API_SECRET": notion.get("api_secret"),
+        "NOTION_CLIENTS_DB": notion.get("clients_db"),
+        "NOTION_PROJECTS_DB": notion.get("projects_db"),
+        "NOTION_TASKS_DB": notion.get("tasks_db"),
+        "NOTION_TEMPLATE_PAGE_ID": notion.get("template_page_id"),
+        "NOTION_WORKORDERS_DB": notion.get("workorders_db"),
+        "NOTION_TRAC_COSTS_DB": notion.get("trac_costs_db"),
+    }
+
+    for k, v in mapping.items():
+        if v is not None:
+            config[k] = v
+
+    for key in mapping.keys():
         if key in os.environ:
             config[key] = os.environ[key]
 
-    local_env_path = Path(__file__).parent / ".env"
-    if local_env_path.exists():
-        local_vals = dotenv_values(local_env_path)
-        for k, v in local_vals.items():
-            config.setdefault(k, v)
-
     return config
 
+
 config = load_config()
 
 TOGGL_TRACK_API_KEY = config["TOGGL_TRACK_API_KEY"]
 TOGGL_TRACK_PASSWORD = config["TOGGL_TRACK_PASSWORD"]
+TOGGL_TRACK_WORKSPACE = config["TOGGL_TRACK_WORKSPACE"]
 NOTION_API_SECRET = config["NOTION_API_SECRET"]
 NOTION_CLIENTS_DB = config["NOTION_CLIENTS_DB"]
 NOTION_PROJECTS_DB = config["NOTION_PROJECTS_DB"]
@@ -47,6 +66,7 @@ NOTION_TRAC_COSTS_DB = config["NOTION_TRAC_COSTS_DB"]
 required = [
     "TOGGL_TRACK_API_KEY",
     "TOGGL_TRACK_PASSWORD",
+    "TOGGL_TRACK_WORKSPACE",
     "NOTION_API_SECRET",
     "NOTION_CLIENTS_DB",
     "NOTION_PROJECTS_DB",
@@ -60,15 +80,14 @@ missing = [k for k in required if k not in config]
 if missing:
     raise RuntimeError(f"Missing required config values: {', '.join(missing)}")
 
+
 def setup_logger(enable_logging: bool, log_level: str = 'INFO', log_file: str = None):
     logger = logging.getLogger('papi')
     
     if enable_logging:
-        # Convert log_level string to logging level
         numeric_level = getattr(logging, log_level.upper(), logging.INFO)
         logger.setLevel(numeric_level)
-        
-        # Create handler
+
         if log_file:
             handler = logging.FileHandler(log_file)
         else:
@@ -76,18 +95,14 @@ def setup_logger(enable_logging: bool, log_level: str = 'INFO', log_file: str =
         
         handler.setLevel(numeric_level)
         
-        # Create formatter
         formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
         handler.setFormatter(formatter)
         
-        # Add handler to logger if not already added
         if not logger.handlers:
             logger.addHandler(handler)
         
-        # Prevent propagation to root logger
         logger.propagate = False
     else:
-        # Set a higher log level to suppress lower-level logs
         logger.setLevel(logging.WARNING)
     
     return logger

{papi_projects-0.4.1 → papi_projects-0.4.3}/papi/wrappers.py

@@ -176,14 +176,18 @@ class TogglTrackWrapper(Protocol):
             if isinstance(times_json, list):
                 times = {}
                 for t in times_json:
-                    pid = t["pid"]
-                    seconds = t["duration"]
-                    hours = seconds / 60 / 60
-                    if pid not in times:
-                        times[pid] = hours
-                    else:
-                        times[pid] += hours
-                return times
+                    if "pid" in t:
+                        pid = t["pid"]
+                        seconds = t["duration"]
+                        hours = seconds / 60 / 60
+                        if pid not in times:
+                            times[pid] = hours
+                        else:
+                            times[pid] += hours
+                if times:
+                    return times
+                else:
+                    return None
             else:
                 warnings.warn(times_json)
                 return None
@@ -419,7 +423,11 @@ class NotionWrapper(Protocol):
             t = b["type"]
             if t not in ALLOWED:
                 continue
-            minimal = { "type": t, t: b[t] }
+            block_data = {
+                k: v for k, v in b[t].items()
+                if v is not None and not (k == "color" and v == "default")
+            }
+            minimal = {"type": t, t: block_data}
             if b.get("has_children"):
                 child_raw = self._fetch_template_blocks(b["id"])
                 minimal["children"] = self._clean_blocks(child_raw)
@@ -910,7 +918,7 @@ class NotionWrapper(Protocol):
                     "people": []
                 },
                 "Status": {
-                    "status": {"name": "Not Started"}
+                    "status": {"name": "In Development"}
                 },
                 "Priority": {
                     "select": {"name": "Medium"}

{papi_projects-0.4.1 → papi_projects-0.4.3}/papi_projects.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: papi-projects
-Version: 0.4.1
+Version: 0.4.3
 Summary: PAPI is an API for managing projects
 Author-email: sandyjmacdonald <sandyjmacdonald@gmail.com>
 License-Expression: MIT

{papi_projects-0.4.1 → papi_projects-0.4.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "papi-projects"
-version = "0.4.1"
+version = "0.4.3"
 description = "PAPI is an API for managing projects"
 authors = [{ name = "sandyjmacdonald", email = "sandyjmacdonald@gmail.com" }]
 license = "MIT"

{papi_projects-0.4.1 → papi_projects-0.4.3}/scripts/collate_toggl_hours.py

@@ -51,6 +51,7 @@ def main():
         # Get tracked hours and tracked project IDs/names
 
         tracked_hours = toggl.get_user_hours(start_time=start_time, end_time=end_time)
+        print(tracked_hours)
         projects = {p["id"]: p["name"] for p in toggl.get_user_projects() if p["id"] in tracked_hours}
         hours_per_project = [(projects[t], tracked_hours[t]) for t in tracked_hours]
 
@@ -69,4 +70,4 @@ def main():
         warnings.warn("Start time must not be more than 3 months ago!")
 
 if __name__ == "__main__":
-    main()
+    main()

papi_projects-0.4.3/scripts/generate_timesheet.py

@@ -0,0 +1,208 @@
+import argparse
+import pendulum
+import warnings
+import os
+from pathlib import Path
+from papi.wrappers import TogglTrackWrapper, NotionWrapper
+from papi import config, setup_logger
+from papi.project import get_project_ids, check_project_id
+from decimal import Decimal, ROUND_UP
+import pandas as pd
+
+try:
+    import tomllib
+except ModuleNotFoundError:
+    import tomli as tomllib
+
+def load_toggl_users_from_toml():
+    config_path = os.environ.get("PAPI_CONFIG_FILE")
+    if config_path:
+        path = Path(config_path).expanduser()
+    else:
+        path = Path.home() / ".config" / "papi" / "config.toml"
+    if not path.exists():
+        return []
+    with path.open("rb") as f:
+        raw = tomllib.load(f)
+    toggl = raw.get("toggl", {})
+    users = toggl.get("users", {})
+    out = []
+    if isinstance(users, dict):
+        for _, u in users.items():
+            if not isinstance(u, dict):
+                continue
+            name = u.get("name")
+            api_key = u.get("api_key")
+            if name and api_key:
+                out.append({"name": name, "api_key": api_key})
+    return out
+
+def initialise_toggl(toggl_api_key, toggl_workspace):
+    toggl_api_password = config["TOGGL_TRACK_PASSWORD"]
+    toggl = TogglTrackWrapper(toggl_api_key, toggl_api_password)
+    toggl.set_default_workspace(toggl_workspace)
+    toggl.set_me()
+    return toggl
+
+def calculate_cost(hours: float, hourly_rate: float) -> float:
+    cost = Decimal(hours * hourly_rate)
+    cost_rounded = cost.quantize(Decimal("0.01"), rounding=ROUND_UP)
+    return cost_rounded
+
+def get_toggl_hours(start_time, end_time, toggl):
+    tracked_hours = toggl.get_user_hours(start_time=start_time, end_time=end_time)
+    projects = {p["id"]: p["name"] for p in toggl.get_user_projects() if p["id"] in tracked_hours}
+    hours_per_project = [(projects[t], tracked_hours[t]) for t in tracked_hours]
+    hours_dict = {}
+    for i, p in enumerate(hours_per_project):
+        project_id = get_project_ids([p[0]])
+        if len(project_id):
+            hours_dict[project_id[0]] = hours_per_project[i][1]
+        else:
+            hours_dict[p[0]] = hours_per_project[i][1]
+    return hours_dict
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("-s", "--start", type=str, required=True)
+    parser.add_argument("-e", "--end", type=str, default=False)
+    parser.add_argument("--disable-logging", action="store_true")
+    parser.add_argument("-o", "--output", type=str, required=True)
+    args = parser.parse_args()
+
+    if not args.disable_logging:
+        logger = setup_logger(True, "WARNING", None)
+
+    start_time = pendulum.parse(args.start).to_rfc3339_string()
+    # Toggl's end_date is exclusive, so add a day to include entries on the end date itself.
+    end_time = pendulum.now().to_rfc3339_string() if not args.end else pendulum.parse(args.end).add(days=1).to_rfc3339_string()
+
+    if pendulum.now() < pendulum.parse(args.start).add(months=3):
+        toggl_workspace = config["TOGGL_TRACK_WORKSPACE"]
+        toggl_users = load_toggl_users_from_toml()
+        if not toggl_users:
+            toggl_users = [{"name": "Self", "api_key": config["TOGGL_TRACK_API_KEY"]}]
+
+        notion = NotionWrapper(config["NOTION_API_SECRET"])
+        output = args.output
+
+        df = pd.DataFrame(
+            columns=[
+                "workorder",
+                "project_id",
+                "payment_type",
+                "costing_rate",
+                "hourly_rate",
+                "hours",
+                "cost",
+                "person",
+                "description",
+                "agresso_description",
+            ]
+        )
+
+        for user in toggl_users:
+            print(user)
+            toggl = initialise_toggl(user["api_key"], toggl_workspace)
+            hours_dict = get_toggl_hours(start_time, end_time, toggl)
+            print(hours_dict)
+
+            for project_id, hours in hours_dict.items():
+                hours = float(hours)
+                payment_type = ""
+                costing_rate = ""
+                hourly_rate = ""
+                cost = 0.0
+                workorder_id = ""
+                if check_project_id(project_id):
+                    project = notion.get_project(
+                        config["NOTION_PROJECTS_DB"],
+                        project_id,
+                        workorders_db_id=config["NOTION_WORKORDERS_DB"]
+                    )
+                    if project is not None:
+                        project_name = project.name
+                        workorder_id = project.workorder
+                        if workorder_id is not None:
+                            workorder = notion.get_workorder(
+                                workorders_db_id=config["NOTION_WORKORDERS_DB"],
+                                workorder_id=workorder_id
+                            )
+                            if workorder.is_complete():
+                                payment_type = workorder.payment_type
+                                costing_rate = workorder.costing_rate
+                                hourly_rate = workorder.hourly_rate
+                                cost = calculate_cost(hours, workorder.hourly_rate)
+                    else:
+                        project_name = ""
+                        workorder_id = ""
+                else:
+                    project_name = project_id
+
+                df.loc[len(df)] = [
+                    workorder_id,
+                    project_id,
+                    payment_type,
+                    costing_rate,
+                    hourly_rate,
+                    hours,
+                    cost,
+                    user["name"],
+                    project_name,
+                    f"{project_id}: {project_name}",
+                ]
+
+        output_path = Path(output).expanduser()
+        itemised_path = output_path.with_name(f"{output_path.stem}-itemised{output_path.suffix}")
+        totals_path = output_path.with_name(f"{output_path.stem}-totals{output_path.suffix}")
+        da_path = output_path.with_name(f"{output_path.stem}-DA{output_path.suffix}")
+        di_path = output_path.with_name(f"{output_path.stem}-DI{output_path.suffix}")
+
+        df.to_csv(itemised_path, sep="\t", index=False)
+
+        totals_df = df.drop(columns=["person"]).groupby("project_id", as_index=False).agg(
+            {
+                "workorder": "first",
+                "payment_type": "first",
+                "costing_rate": "first",
+                "hourly_rate": "first",
+                "hours": "sum",
+                "cost": "sum",
+                "description": "first",
+                "agresso_description": "first",
+            }
+        )
+        totals_df = totals_df[
+            [
+                "workorder",
+                "project_id",
+                "payment_type",
+                "costing_rate",
+                "hourly_rate",
+                "hours",
+                "cost",
+                "description",
+                "agresso_description",
+            ]
+        ]
+        totals_df.to_csv(totals_path, sep="\t", index=False)
+
+        da_df = totals_df[totals_df["payment_type"] == "DA"]
+        if len(da_df):
+            da_df.to_csv(da_path, sep="\t", index=False)
+
+        di_df = totals_df[totals_df["payment_type"] == "DI"]
+        if len(di_df):
+            di_df.to_csv(di_path, sep="\t", index=False)
+
+        logger.warning(f"{len(df)} journal entries successfully written to {itemised_path}")
+        logger.warning(f"{len(totals_df)} project totals successfully written to {totals_path}")
+        if len(da_df):
+            logger.warning(f"{len(da_df)} DA totals successfully written to {da_path}")
+        if len(di_df):
+            logger.warning(f"{len(di_df)} DI totals successfully written to {di_path}")
+    else:
+        logger.warning("Start time must not be more than 3 months ago!")
+
+if __name__ == "__main__":
+    main()

papi_projects-0.4.1/scripts/generate_timesheet.py

@@ -1,194 +0,0 @@
-import argparse
-import pendulum
-import warnings
-from papi.wrappers import TogglTrackWrapper, NotionWrapper
-from papi import config, setup_logger
-from papi.project import get_project_ids, check_project_id
-from decimal import Decimal, ROUND_UP
-import pandas as pd
-
-def initialise_toggl(toggl_api_key, toggl_workspace):
-    """Initialises the TogglTrackWrapper.
-
-    :param toggl_api_key: A user's Toggl Track API key.
-    :type toggl_api_key: str
-    :param toggl_workspace: The name of the Toggl Track workspace.
-    :type toggl_workspace: str
-    :return: An initialised TogglTrackWrapper.
-    :rtype: TogglTrackWrapper
-    """
-    toggl_api_password = config["TOGGL_TRACK_PASSWORD"]
-    toggl = TogglTrackWrapper(toggl_api_key, toggl_api_password)
-    toggl.set_default_workspace(toggl_workspace)
-    toggl.set_me()
-    return toggl
-
-def calculate_cost(hours: float, hourly_rate: float) -> float:
-    """Calculates a properly-rounded cost given hours and an hourly rate.
-
-    :param hours: A number of hours, e.g. 1.5 for one and a half hours.
-    :type hours: float
-    :param hourly_rate: An hourly rate to charge.
-    :type hourly_rate: float
-    :return: A properly-rounded (note: rounded up) cost to charge.
-    :rtype: float
-    """
-    cost = Decimal(hours * hourly_rate)
-    cost_rounded = cost.quantize(Decimal("0.01"), rounding=ROUND_UP)
-    return cost_rounded
-
-def get_toggl_hours(start_time, end_time, toggl):
-    """Get the tracked hours between a start time and end time from an
-    initialised TogglTrackWrapper instance.
-
-    :param start_time: A start time, e.g. 2025-11-01
-    :type start_time: str
-    :param end_time: An end time, e.g. 2025-11-31
-    :type end_time: str
-    :param toggl: An initialised TogglTrackWrapper instance.
-    :type toggl: TogglTrackWrapper
-    :return: A dicitonary of projects and tracked hours.
-    :rtype: dict
-    """
-    tracked_hours = toggl.get_user_hours(start_time=start_time, end_time=end_time)
-    projects = {p["id"]: p["name"] for p in toggl.get_user_projects() if p["id"] in tracked_hours}
-    hours_per_project = [(projects[t], tracked_hours[t]) for t in tracked_hours]
-    hours_dict = {}
-    for i, p in enumerate(hours_per_project):
-        project_id = get_project_ids([p[0]])
-        if len(project_id):
-            project_id = project_id[0]
-            hours_dict[project_id] = hours_per_project[i][1]
-        else:
-            hours_dict[p[0]] = hours_per_project[i][1]
-    return hours_dict
-
-def main():
-    """Main function of generate-timesheet script"""
-    # Set up argparse
-    parser = argparse.ArgumentParser()
-    parser.add_argument(
-        "-s", "--start", type=str, help="start date in YYYY-MM-DD format", required=True
-    )
-    parser.add_argument(
-        "-e", "--end", type=str, help="end date in YYYY-MM-DD format, if none supplied then end date is now", default=False
-    )
-    parser.add_argument(
-        "--disable-logging",
-        action="store_true",
-        help="disable logging output for the papi library",
-    )
-    parser.add_argument(
-        "-o",
-        "--output",
-        type=str,
-        help="output TSV filename",
-        default=False,
-        required=True
-    )
-    args = parser.parse_args()
-
-    if not args.disable_logging:
-        logger = setup_logger(True, "WARNING", None)
-
-    # Set up start/end date
-    start_date = args.start
-    start_time = pendulum.parse(start_date).to_rfc3339_string()
-    end_date = args.end
-    if not end_date:
-        end_time = pendulum.now().to_rfc3339_string()
-    else:
-        end_time = pendulum.parse(end_date).to_rfc3339_string()
-
-    # Check that start time is not more than 3 months ago
-    if pendulum.now() < pendulum.parse(start_date).add(months=3):
-        toggl_api_key = config["TOGGL_TRACK_API_KEY"]
-        toggl_workspace = config["TOGGL_TRACK_WORKSPACE"]
-        toggl = initialise_toggl(toggl_api_key, toggl_workspace)
-
-        hours_dict = get_toggl_hours(start_time, end_time, toggl)
-
-        notion_api_secret = config["NOTION_API_SECRET"]
-        notion_clients_db = config["NOTION_CLIENTS_DB"]
-        notion_projects_db = config["NOTION_PROJECTS_DB"]
-        notion_workorders_db = config["NOTION_WORKORDERS_DB"]
-        notion = NotionWrapper(notion_api_secret)
-        project_ids = hours_dict.keys()
-        output = args.output
-        df = pd.DataFrame(
-            columns=[
-                "workorder",
-                "project_id",
-                "payment_type",
-                "costing_rate",
-                "hourly_rate",
-                "hours",
-                "cost",
-                "description",
-                "agresso_description",
-            ]
-        )
-
-        for project_id in project_ids:
-            hours = float(hours_dict[project_id])
-            payment_type = ""
-            costing_rate = ""
-            hourly_rate = ""
-            cost = 0.0
-            chargeable = False
-            workorder_id = ""
-            if check_project_id(project_id):
-                project = notion.get_project(
-                    notion_projects_db,
-                    project_id,
-                    workorders_db_id=notion_workorders_db
-                )
-                project_name = project.name
-                workorder_id = project.workorder
-                if workorder_id is not None:
-                    workorder = notion.get_workorder(
-                        workorders_db_id=notion_workorders_db,
-                        workorder_id=workorder_id
-                    )
-                    if workorder.is_complete():
-                        payment_type = workorder.payment_type
-                        costing_rate = workorder.costing_rate
-                        hourly_rate = workorder.hourly_rate
-                        cost = calculate_cost(hours, workorder.hourly_rate)
-                        chargeable = True
-                        logger.warning(
-                            f"Project: {project_id}: Has complete data and is chargeable"
-                        )
-                    else:
-                        logger.warning(
-                            f"Project {project_id}: Workorder {workorder.id} has incomplete data!"
-                        )
-                else:
-                    workorder_id = ""
-                    logger.warning(f"Project {project_id}: Workorder is missing!")
-            else:
-                logger.warning(f"Project {project_id}: Not a valid project ID!")
-                project_name = project_id
-
-            agresso_description = f"{project_id}: {project_name}"
-            description = project_name
-
-            df.loc[len(df)] = [
-                workorder_id,
-                project_id,
-                payment_type,
-                costing_rate,
-                hourly_rate,
-                hours,
-                cost,
-                description,
-                agresso_description,
-            ]
-
-        df.to_csv(output, sep="\t", index=False)
-        logger.warning(f"{len(df)} journal entries successfully written to {output}")
-    else:
-        logger.warning("Start time must not be more than 3 months ago!")
-
-if __name__ == "__main__":
-    main()