github-heatmap 1.3.8__tar.gz → 1.4.0__tar.gz

{github_heatmap-1.3.8 → github_heatmap-1.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: github_heatmap
-Version: 1.3.8
+Version: 1.4.0
 Summary: Make everything a GitHub svg poster and Skyline!
 Home-page: https://github.com/malinkang/GitHubPoster
 Author: malinkang

{github_heatmap-1.3.8 → github_heatmap-1.4.0}/github_heatmap/cli.py

@@ -61,6 +61,8 @@ def run():
         "dom": args.dom_color,
     }
 
+    p.tooltip_template = args.tooltip_template or None
+
     # if special color (Stand with Ukraine) change the color
     if args.stand_with_ukraine:
         p.colors["track"] = "#025DB8"
@@ -108,6 +110,7 @@ def run():
             p.units = args.unit
         else:
             p.units = args.loader.unit
+        p.tooltip_by_date = getattr(loader, "tooltip_by_date_dict", {}) or {}
         p.set_tracks(tracks, years, type_list)
     else:
         if args.unit:
@@ -115,6 +118,7 @@ def run():
         else:
             p.units = args.loader.unit
         p.set_tracks({}, [to_year], type_list)
+        p.tooltip_by_date = {}
 
     # set title
     # we don't know issue content so use name

{github_heatmap-1.3.8 → github_heatmap-1.4.0}/github_heatmap/drawer.py

@@ -35,6 +35,42 @@ class Drawer:
             zip(self.poster.type_list, COLOR_TUPLE[: len(self.poster.type_list)])
         )
 
+    def _format_tooltip(self, date_title, value=None, type_name=None):
+        custom_map = getattr(self.poster, "tooltip_by_date", {}) or {}
+        custom = None
+        if custom_map:
+            entry = custom_map.get(date_title)
+            if isinstance(entry, dict):
+                if type_name and type_name in entry:
+                    custom = entry.get(type_name)
+                elif "__default__" in entry:
+                    custom = entry.get("__default__")
+            else:
+                custom = entry
+            if isinstance(custom, list):
+                custom = "\n".join([str(item) for item in custom if item is not None])
+            if custom is not None and custom != "":
+                return str(custom)
+        template = self.poster.tooltip_template
+        if template and value is not None:
+            context = {
+                "date": date_title,
+                "value": value if value is not None else "",
+                "unit": self.poster.units if value is not None else "",
+                "type": type_name or "",
+            }
+            try:
+                tooltip = template.format(**context)
+            except KeyError:
+                tooltip = template
+            if tooltip:
+                return tooltip
+        if value is not None:
+            if type_name:
+                return f"{date_title} {value} for {type_name}"
+            return f"{date_title} {value} {self.poster.units}"
+        return date_title
+
     def make_color(self, length_range, length):
         sp2 = self.poster.special_number.get("special_number2")
         sp1 = self.poster.special_number.get("special_number1")
@@ -90,7 +126,9 @@ class Drawer:
                 color = self.poster.colors.get("special2") or self.poster.colors.get(
                     "special"
                 )
-            date_title = f"{date_title} {day_tracks} {self.poster.units}"
+            tooltip = self._format_tooltip(date_title, day_tracks)
+        else:
+            tooltip = self._format_tooltip(date_title)
         rect = dr.rect(
             (rect_x, rect_y),
             DOM_BOX_TUPLE,
@@ -100,7 +138,7 @@ class Drawer:
         )
         if with_animation:
             rect = self.__add_animation(rect, key_times, animate_index)
-        rect.set_desc(title=date_title)
+        rect.set_desc(title=tooltip)
         yield rect
 
     def _gen_day_boxes(
@@ -126,6 +164,7 @@ class Drawer:
             types_len = len(day_tracks)
             dom_tuple = DOM_BOX_DICT.get(types_len).get("dom")
             index = 0
+            base_title = date_title
             for _type in self.poster.type_list:
                 num = day_tracks.get(_type, 0)
                 length_range = self.poster.length_range_by_date_dict.get(_type, 1)
@@ -140,10 +179,10 @@ class Drawer:
                     rx=DOM_BOX_RADIUS,
                     ry=DOM_BOX_RADIUS,
                 )
-                date_title = f"{date_title} {num} for {_type}"
+                tooltip = self._format_tooltip(base_title, num, _type)
                 if with_animation:
                     rect = self.__add_animation(rect, key_times, animate_index)
-                rect.set_desc(title=date_title)
+                rect.set_desc(title=tooltip)
                 yield rect
                 rect_y += dom_tuple[index][1]
                 index += 1
@@ -269,6 +308,9 @@ class Drawer:
                     "special_number1": loader.special_number1,
                     "special_number2": loader.special_number2,
                 }
+                self.poster.tooltip_by_date = (
+                    getattr(loader, "tooltip_by_date_dict", {}) or {}
+                )
                 self.poster.colors["track"] = loader.track_color or "#4DD2FF"
                 self.poster.units = loader.unit
                 self.poster.compute_track_statistics([loader._type])

{github_heatmap-1.3.8 → github_heatmap-1.4.0}/github_heatmap/loader/base_loader.py

@@ -218,6 +218,12 @@ class BaseLoader(ABC):
             default="",
             help="unit",
         )
+        group.add_argument(
+            "--tooltip-template",
+            dest="tooltip_template",
+            default="",
+            help="format string for tooltip, supports {date}, {value}, {unit}, {type}",
+        )
         # is_cn here
         group.add_argument(
             "--cn",

github_heatmap-1.4.0/github_heatmap/loader/notion_loader.py

@@ -0,0 +1,314 @@
+from datetime import datetime, timedelta
+import time
+from collections import defaultdict
+
+import pendulum
+import requests
+import json
+
+from github_heatmap.loader.base_loader import BaseLoader
+from github_heatmap.loader.config import NOTION_API_URL, NOTION_API_VERSION
+
+
+class NotionLoader(BaseLoader):
+    track_color = "#40C463"
+    unit = "times"
+
+    def __init__(self, from_year, to_year, _type, **kwargs):
+        super().__init__(from_year, to_year, _type)
+        self.number_by_date_dict = self.generate_date_dict(from_year, to_year)
+        self.notion_token = kwargs.get("notion_token", "").strip()
+        self.database_id = kwargs.get("database_id", "").strip()
+        self.date_prop_name = kwargs.get("date_prop_name", "")
+        self.value_prop_name = kwargs.get("value_prop_name", "")
+        self.database_filter = kwargs.get("database_filter", "")
+        self.tooltip_prop_name = kwargs.get("tooltip_prop_name", "").strip()
+        self.tooltip_by_date_dict = defaultdict(list)
+
+    @classmethod
+    def add_loader_arguments(cls, parser, optional):
+        parser.add_argument(
+            "--notion_token",
+            dest="notion_token",
+            type=str,
+            help="The Notion internal integration token.",
+        )
+        parser.add_argument(
+            "--database_id",
+            dest="database_id",
+            type=str,
+            help="The Notion database id.",
+        )
+        parser.add_argument(
+            "--date_prop_name",
+            dest="date_prop_name",
+            type=str,
+            default="Datetime",
+            required=optional,
+            help="The database property name which stored the datetime.",
+        )
+        parser.add_argument(
+            "--value_prop_name",
+            dest="value_prop_name",
+            type=str,
+            default="Datetime",
+            required=optional,
+            help="The database property name which stored the datetime.",
+        )        
+        parser.add_argument(
+            "--database_filter",
+            dest="database_filter",
+            type=str,
+            default="",
+            required=False,
+            help="The database property name which stored the datetime.",
+        )
+        parser.add_argument(
+            "--tooltip_prop_name",
+            dest="tooltip_prop_name",
+            type=str,
+            default="",
+            required=False,
+            help="The Notion property name used for tooltip text.",
+        )
+
+    def get_api_data(self, start_cursor="", page_size=100, data_list=None):
+        if data_list is None:
+            data_list = []
+        payload = {
+            "page_size": page_size,
+            "filter": {
+                "and": [
+                    {
+                        "property": self.date_prop_name,
+                        "date": {"on_or_after": f"{self.from_year}-01-01"},
+                    },
+                    {
+                        "property": self.date_prop_name,
+                        "date": {"on_or_before": f"{self.to_year}-12-31"},
+                    },
+                ]
+            },
+        }
+        if self.database_filter:
+            payload["filter"]["and"].append(json.loads(self.database_filter))
+        if start_cursor:
+            payload.update({"start_cursor": start_cursor})
+
+        headers = {
+            "Accept": "application/json",
+            "Notion-Version": NOTION_API_VERSION,
+            "Content-Type": "application/json",
+            "Authorization": "Bearer " + self.notion_token,
+        }
+
+        try:
+            resp = requests.post(
+                NOTION_API_URL.format(database_id=self.database_id),
+                json=payload,
+                headers=headers,
+            )
+        except requests.RequestException:
+            return data_list
+
+        if not resp.ok:
+            # Treat non-OK responses as an empty result set so we can still draw
+            # a heatmap even when the Notion API yields no rows for the period.
+            return data_list
+        try:
+            data = resp.json()
+        except ValueError:
+            return data_list
+        results = data["results"]
+        next_cursor = data["next_cursor"]
+        data_list.extend(results)
+        if not data["has_more"]:
+            return data_list
+        # Avoid request limits
+        # The rate limit for incoming requests is an average
+        # of 3 requests per second.
+        # See https://developers.notion.com/reference/request-limits
+        time.sleep(0.3)
+        return self.get_api_data(
+            start_cursor=next_cursor, page_size=page_size, data_list=data_list
+        )
+
+    def generate_date_dict(self, start_year, end_year):
+        start_date = datetime(start_year, 1, 1)
+        end_date = datetime(end_year, 12, 31)
+
+        # 使用字典推导式生成日期字典
+        return {
+            (start_date + timedelta(days=i)).strftime("%Y-%m-%d"): 0
+            for i in range((end_date - start_date).days + 1)
+        }
+
+    def make_track_dict(self):
+        data_list = self.get_api_data()
+        for result in data_list:
+            date = result["properties"][self.date_prop_name]["date"]
+            value = result["properties"][self.value_prop_name]
+            tooltip_text = ""
+            if self.tooltip_prop_name:
+                tooltip_prop = result["properties"].get(self.tooltip_prop_name)
+                tooltip_text = self._extract_property_text(tooltip_prop)
+            if date and value:
+                dt = date.get("start")
+                type = value.get("type")
+                if type == "formula" and value.get(type).get("type") == "number":
+                    value = float(value.get(type).get("number"))
+                elif type == "rollup" and value.get(type).get("type") == "number":
+                    value = float(value.get(type).get("number"))
+                else:
+                    value = value.get(type)
+                date_str = pendulum.parse(dt).to_date_string()
+                self.number_by_date_dict[date_str] = (
+                    self.number_by_date_dict.get(date_str, 0) + value
+                )
+                if tooltip_text:
+                    self.tooltip_by_date_dict[date_str].append(tooltip_text.strip())
+        for _, v in self.number_by_date_dict.items():
+            self.number_list.append(v)
+        for key, texts in list(self.tooltip_by_date_dict.items()):
+            joined = "\n".join(filter(None, [t.strip() for t in texts if t]))
+            if joined:
+                self.tooltip_by_date_dict[key] = joined
+            else:
+                self.tooltip_by_date_dict.pop(key, None)
+
+    def get_all_track_data(self):
+        self.make_track_dict()
+        self.make_special_number()
+        return self.number_by_date_dict, self.year_list
+
+    @staticmethod
+    def _format_date(date_dict):
+        if not date_dict:
+            return ""
+        start = date_dict.get("start")
+        end = date_dict.get("end")
+        if start and end and start != end:
+            return f"{start} - {end}"
+        return start or end or ""
+
+    @staticmethod
+    def _join_plain_text(items):
+        if not items:
+            return ""
+        return "".join([item.get("plain_text", "") for item in items]).strip()
+
+    @classmethod
+    def _extract_rollup_item(cls, item):
+        if not item:
+            return ""
+        item_type = item.get("type")
+        if item_type in ("title", "rich_text"):
+            return cls._join_plain_text(item.get(item_type))
+        if item_type == "people":
+            return ", ".join(
+                [p.get("name") or p.get("id", "") for p in item.get("people", [])]
+            ).strip()
+        if item_type == "relation":
+            return ", ".join([r.get("id", "") for r in item.get("relation", [])]).strip()
+        if item_type == "date":
+            return cls._format_date(item.get("date", {}))
+        if item_type in ("url", "email", "phone_number"):
+            return item.get(item_type) or ""
+        if item_type == "number":
+            number_value = item.get("number")
+            return "" if number_value is None else str(number_value)
+        if item_type == "checkbox":
+            value = item.get("checkbox")
+            if value is None:
+                return ""
+            return "Yes" if value else "No"
+        if item_type == "formula":
+            return cls._extract_property_text(
+                {"type": "formula", "formula": item.get("formula", {})}
+            )
+        if item_type == "rollup":
+            return cls._extract_property_text(
+                {"type": "rollup", "rollup": item.get("rollup", {})}
+            )
+        return ""
+
+    @classmethod
+    def _extract_property_text(cls, prop):
+        if not prop:
+            return ""
+        prop_type = prop.get("type")
+        if not prop_type:
+            return ""
+        if prop_type in ("title", "rich_text"):
+            return cls._join_plain_text(prop.get(prop_type))
+        if prop_type == "multi_select":
+            return ", ".join(
+                [item.get("name", "") for item in prop.get("multi_select", []) if item]
+            ).strip()
+        if prop_type in ("select", "status"):
+            option = prop.get(prop_type) or {}
+            return option.get("name", "") if option else ""
+        if prop_type in ("url", "email", "phone_number"):
+            return prop.get(prop_type) or ""
+        if prop_type == "checkbox":
+            value = prop.get("checkbox")
+            if value is None:
+                return ""
+            return "Yes" if value else "No"
+        if prop_type == "number":
+            number_value = prop.get("number")
+            return "" if number_value is None else str(number_value)
+        if prop_type == "people":
+            return ", ".join(
+                [p.get("name") or p.get("id", "") for p in prop.get("people", [])]
+            ).strip()
+        if prop_type in ("created_time", "last_edited_time"):
+            return prop.get(prop_type) or ""
+        if prop_type in ("created_by", "last_edited_by"):
+            person = prop.get(prop_type)
+            if isinstance(person, dict):
+                return person.get("name") or person.get("id", "") or ""
+            return ""
+        if prop_type == "date":
+            return cls._format_date(prop.get("date", {}))
+        if prop_type == "relation":
+            return ", ".join([r.get("id", "") for r in prop.get("relation", [])]).strip()
+        if prop_type == "files":
+            texts = []
+            for file_obj in prop.get("files", []):
+                name = file_obj.get("name")
+                if name:
+                    texts.append(name)
+                    continue
+                file_url = file_obj.get("file", {}).get("url")
+                external_url = file_obj.get("external", {}).get("url")
+                texts.append(file_url or external_url or "")
+            return ", ".join([t for t in texts if t]).strip()
+        if prop_type == "formula":
+            formula = prop.get("formula", {})
+            formula_type = formula.get("type")
+            if formula_type in ("string", "url", "email", "phone_number"):
+                return formula.get(formula_type) or ""
+            if formula_type == "boolean":
+                value = formula.get("boolean")
+                if value is None:
+                    return ""
+                return "Yes" if value else "No"
+            if formula_type == "number":
+                number_value = formula.get("number")
+                return "" if number_value is None else str(number_value)
+            if formula_type == "date":
+                return cls._format_date(formula.get("date", {}))
+        if prop_type == "rollup":
+            rollup = prop.get("rollup", {})
+            rollup_type = rollup.get("type")
+            if rollup_type == "number":
+                number_value = rollup.get("number")
+                return "" if number_value is None else str(number_value)
+            if rollup_type == "date":
+                return cls._format_date(rollup.get("date", {}))
+            if rollup_type == "array":
+                texts = [cls._extract_rollup_item(item) for item in rollup.get("array", [])]
+                texts = [text for text in texts if text]
+                return ", ".join(texts)
+        return ""

{github_heatmap-1.3.8 → github_heatmap-1.4.0}/github_heatmap/poster.py

@@ -39,6 +39,8 @@ class Poster:
 
         # for year summary
         self.is_summary = False
+        self.tooltip_template = None
+        self.tooltip_by_date = {}
 
     def set_tracks(self, tracks, years, type_list):
         self.type_list.extend(type_list)

{github_heatmap-1.3.8 → github_heatmap-1.4.0}/github_heatmap.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: github_heatmap
-Version: 1.3.8
+Version: 1.4.0
 Summary: Make everything a GitHub svg poster and Skyline!
 Home-page: https://github.com/malinkang/GitHubPoster
 Author: malinkang

{github_heatmap-1.3.8 → github_heatmap-1.4.0}/github_heatmap.egg-info/SOURCES.txt

@@ -62,4 +62,5 @@ github_heatmap/skyline/config.py
 github_heatmap/skyline/skyline.py
 github_heatmap/skyline/font/__init__.py
 tests/__init__.py
+tests/test_notion_loader.py
 tests/test_poster_utils.py

{github_heatmap-1.3.8 → github_heatmap-1.4.0}/setup.py

@@ -6,7 +6,7 @@ setup(
     author_email="linkang.ma@gmail.com",
     url="https://github.com/malinkang/GitHubPoster",
     license="MIT",
-    version="1.3.8",
+    version="1.4.0",
     description="Make everything a GitHub svg poster and Skyline!",
     packages=find_packages(),
     include_package_data=True,

github_heatmap-1.4.0/tests/test_notion_loader.py

@@ -0,0 +1,135 @@
+import requests
+
+from github_heatmap.loader import notion_loader
+from github_heatmap.loader.notion_loader import NotionLoader
+
+
+def build_loader():
+    return NotionLoader(
+        2024,
+        2024,
+        "notion",
+        notion_token="token",
+        database_id="db",
+        date_prop_name="Date",
+        value_prop_name="Value",
+        tooltip_prop_name="Tooltip",
+    )
+
+
+def test_notion_loader_make_track_dict_with_tooltips():
+    loader = build_loader()
+
+    loader.get_api_data = lambda: [
+        {
+            "properties": {
+                "Date": {"date": {"start": "2024-01-01"}},
+                "Value": {"type": "number", "number": 5},
+                "Tooltip": {
+                    "type": "rich_text",
+                    "rich_text": [{"plain_text": "Study"}],
+                },
+            }
+        },
+        {
+            "properties": {
+                "Date": {"date": {"start": "2024-01-01"}},
+                "Value": {"type": "number", "number": 2},
+                "Tooltip": {
+                    "type": "multi_select",
+                    "multi_select": [{"name": "Read"}, {"name": "Write"}],
+                },
+            }
+        },
+    ]
+
+    loader.make_track_dict()
+
+    assert loader.number_by_date_dict["2024-01-01"] == 7
+    assert (
+        loader.tooltip_by_date_dict["2024-01-01"]
+        == "Study\nRead, Write"
+    )
+
+
+def test_notion_loader_extract_property_text_variants():
+    rich_text = {
+        "type": "rich_text",
+        "rich_text": [{"plain_text": "Hello"}, {"plain_text": " World"}],
+    }
+    assert NotionLoader._extract_property_text(rich_text) == "Hello World"
+
+    select = {
+        "type": "select",
+        "select": {"name": "Done"},
+    }
+    assert NotionLoader._extract_property_text(select) == "Done"
+
+    multi_select = {
+        "type": "multi_select",
+        "multi_select": [{"name": "Tag1"}, {"name": "Tag2"}],
+    }
+    assert NotionLoader._extract_property_text(multi_select) == "Tag1, Tag2"
+
+    formula_number = {
+        "type": "formula",
+        "formula": {"type": "number", "number": 42},
+    }
+    assert NotionLoader._extract_property_text(formula_number) == "42"
+
+    rollup_array = {
+        "type": "rollup",
+        "rollup": {
+            "type": "array",
+            "array": [
+                {
+                    "type": "rich_text",
+                    "rich_text": [{"plain_text": "Note"}],
+                },
+                {
+                    "type": "people",
+                    "people": [{"name": "Alice"}, {"name": "Bob"}],
+                },
+            ],
+        },
+    }
+    assert NotionLoader._extract_property_text(rollup_array) == "Note, Alice, Bob"
+
+
+def test_notion_loader_handles_http_error(monkeypatch):
+    loader = build_loader()
+
+    class DummyResp:
+        ok = False
+        status_code = 404
+
+        @staticmethod
+        def json():
+            return {"object": "error"}
+
+    monkeypatch.setattr(
+        notion_loader.requests, "post", lambda *args, **kwargs: DummyResp()
+    )
+
+    tracks, years = loader.get_all_track_data()
+
+    assert years == [2024]
+    assert tracks
+    assert all(value == 0 for value in tracks.values())
+    assert loader.number_list
+
+
+def test_notion_loader_handles_request_exception(monkeypatch):
+    loader = build_loader()
+
+    def fake_post(*args, **kwargs):
+        raise requests.RequestException("boom")
+
+    monkeypatch.setattr(notion_loader.requests, "post", fake_post)
+
+    tracks, years = loader.get_all_track_data()
+
+    assert years == [2024]
+    assert tracks
+    assert all(value == 0 for value in tracks.values())
+    assert loader.number_list

github_heatmap-1.4.0/tests/test_poster_utils.py

@@ -0,0 +1,46 @@
+from github_heatmap.drawer import Drawer
+from github_heatmap.poster import Poster
+from github_heatmap.utils import interpolate_color, make_key_times, parse_years
+
+
+def test_interpolate_color():
+    assert interpolate_color("#000000", "#ffffff", 0) == "#000000"
+    assert interpolate_color("#000000", "#ffffff", 1) == "#ffffff"
+    assert interpolate_color("#000000", "#ffffff", 0.5) == "#7f7f7f"
+    assert interpolate_color("#000000", "#ffffff", -100) == "#000000"
+    assert interpolate_color("#000000", "#ffffff", 12345) == "#ffffff"
+
+
+def test_parse_years():
+    assert parse_years("2012") == (2012, 2012)
+    assert parse_years("2015-2021") == (2015, 2021)
+    assert parse_years("2021-2015") == (2015, 2021)
+
+
+def test_make_key_times():
+    assert make_key_times(5) == ["0", "0.2", "0.4", "0.6", "0.8", "1"]
+
+
+def test_drawer_tooltip_formatting():
+    poster = Poster()
+    poster.units = "XP"
+    drawer = Drawer(poster)
+
+    assert drawer._format_tooltip("2024-01-01", 10) == "2024-01-01 10 XP"
+    assert drawer._format_tooltip("2024-01-01") == "2024-01-01"
+
+    poster.tooltip_template = "{date}: {value}{unit}"
+    assert drawer._format_tooltip("2024-01-01", 5) == "2024-01-01: 5XP"
+    assert drawer._format_tooltip("2024-01-01") == "2024-01-01"
+
+    poster.tooltip_template = "{date} {value} for {type}"
+    assert (
+        drawer._format_tooltip("2024-01-01", 7, "run")
+        == "2024-01-01 7 for run"
+    )
+
+    poster.tooltip_by_date = {"2024-01-01": "Custom"}
+    assert drawer._format_tooltip("2024-01-01", 5) == "Custom"
+
+    poster.tooltip_by_date = {"2024-01-02": {"run": "Run note"}}
+    assert drawer._format_tooltip("2024-01-02", 3, "run") == "Run note"

github_heatmap-1.3.8/github_heatmap/loader/notion_loader.py

@@ -1,149 +0,0 @@
-from datetime import datetime, timedelta
-import time
-from collections import defaultdict
-
-import pendulum
-import requests
-import json
-
-from github_heatmap.loader.base_loader import BaseLoader, LoadError
-from github_heatmap.loader.config import NOTION_API_URL, NOTION_API_VERSION
-
-
-class NotionLoader(BaseLoader):
-    track_color = "#40C463"
-    unit = "times"
-
-    def __init__(self, from_year, to_year, _type, **kwargs):
-        super().__init__(from_year, to_year, _type)
-        self.number_by_date_dict = self.generate_date_dict(from_year, to_year)
-        self.notion_token = kwargs.get("notion_token", "").strip()
-        self.database_id = kwargs.get("database_id", "").strip()
-        self.date_prop_name = kwargs.get("date_prop_name", "")
-        self.value_prop_name = kwargs.get("value_prop_name", "")
-        self.database_filter = kwargs.get("database_filter", "")
-
-    @classmethod
-    def add_loader_arguments(cls, parser, optional):
-        parser.add_argument(
-            "--notion_token",
-            dest="notion_token",
-            type=str,
-            help="The Notion internal integration token.",
-        )
-        parser.add_argument(
-            "--database_id",
-            dest="database_id",
-            type=str,
-            help="The Notion database id.",
-        )
-        parser.add_argument(
-            "--date_prop_name",
-            dest="date_prop_name",
-            type=str,
-            default="Datetime",
-            required=optional,
-            help="The database property name which stored the datetime.",
-        )
-        parser.add_argument(
-            "--value_prop_name",
-            dest="value_prop_name",
-            type=str,
-            default="Datetime",
-            required=optional,
-            help="The database property name which stored the datetime.",
-        )        
-        parser.add_argument(
-            "--database_filter",
-            dest="database_filter",
-            type=str,
-            default="",
-            required=False,
-            help="The database property name which stored the datetime.",
-        )
-
-    def get_api_data(self, start_cursor="", page_size=100, data_list=[]):
-        payload = {
-            "page_size": page_size,
-            "filter": {
-                "and": [
-                    {
-                        "property": self.date_prop_name,
-                        "date": {"on_or_after": f"{self.from_year}-01-01"},
-                    },
-                    {
-                        "property": self.date_prop_name,
-                        "date": {"on_or_before": f"{self.to_year}-12-31"},
-                    },
-                ]
-            },
-        }
-        if self.database_filter:
-            payload["filter"]["and"].append(json.loads(self.database_filter))
-        if start_cursor:
-            payload.update({"start_cursor": start_cursor})
-
-        headers = {
-            "Accept": "application/json",
-            "Notion-Version": NOTION_API_VERSION,
-            "Content-Type": "application/json",
-            "Authorization": "Bearer " + self.notion_token,
-        }
-
-        resp = requests.post(
-            NOTION_API_URL.format(database_id=self.database_id),
-            json=payload,
-            headers=headers,
-        )
-        if not resp.ok:
-            raise LoadError("Can not get Notion data, please check your config")
-        data = resp.json()
-        results = data["results"]
-        next_cursor = data["next_cursor"]
-        data_list.extend(results)
-        if not data["has_more"]:
-            return data_list
-        # Avoid request limits
-        # The rate limit for incoming requests is an average
-        # of 3 requests per second.
-        # See https://developers.notion.com/reference/request-limits
-        time.sleep(0.3)
-        return self.get_api_data(
-            start_cursor=next_cursor, page_size=page_size, data_list=data_list
-        )
-
-    def generate_date_dict(self, start_year, end_year):
-        start_date = datetime(start_year, 1, 1)
-        end_date = datetime(end_year, 12, 31)
-
-        # 使用字典推导式生成日期字典
-        return {
-            (start_date + timedelta(days=i)).strftime("%Y-%m-%d"): 0
-            for i in range((end_date - start_date).days + 1)
-        }
-
-    def make_track_dict(self):
-        data_list = self.get_api_data()
-        for result in data_list:
-            date = result["properties"][self.date_prop_name]["date"]
-            value = result["properties"][self.value_prop_name]
-            if date and value:
-                dt = date.get("start")
-                type = value.get("type")
-                if type == "formula" and value.get(type).get("type") == "number":
-                    value = float(value.get(type).get("number"))
-                elif type == "rollup" and value.get(type).get("type") == "number":
-                    value = float(value.get(type).get("number"))
-                else:
-                    value = value.get(type)
-                date_str = pendulum.parse(dt).to_date_string()
-                self.number_by_date_dict[date_str] = (
-                    self.number_by_date_dict.get(date_str, 0) + value
-                )
-        for _, v in self.number_by_date_dict.items():
-            self.number_list.append(v)
-
-    def get_all_track_data(self):
-        self.make_track_dict()
-        self.make_special_number()
-        return self.number_by_date_dict, self.year_list

github_heatmap-1.3.8/tests/test_poster_utils.py

@@ -1,19 +0,0 @@
-from github_heatmap.utils import interpolate_color, make_key_times, parse_years
-
-
-def test_interpolate_color():
-    assert interpolate_color("#000000", "#ffffff", 0) == "#000000"
-    assert interpolate_color("#000000", "#ffffff", 1) == "#ffffff"
-    assert interpolate_color("#000000", "#ffffff", 0.5) == "#7f7f7f"
-    assert interpolate_color("#000000", "#ffffff", -100) == "#000000"
-    assert interpolate_color("#000000", "#ffffff", 12345) == "#ffffff"
-
-
-def test_parse_years():
-    assert parse_years("2012") == (2012, 2012)
-    assert parse_years("2015-2021") == (2015, 2021)
-    assert parse_years("2021-2015") == (2015, 2021)
-
-
-def test_make_key_times():
-    assert make_key_times(5) == ["0", "0.2", "0.4", "0.6", "0.8", "1"]