merge: merge pull request #7 from n0rfas/dev

Author: n0rfas

.github/workflows/code-check-dev.yml

@@ -0,0 +1,56 @@
+name: code quality check (dev)
+
+on: 
+  push:
+    branches: [ dev ]
+  pull_request:
+    branches: [ dev]
+
+jobs:
+
+  linter:
+    runs-on: ubuntu-22.04
+    defaults:
+      run:
+        working-directory: .
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: 3.7
+      - run: pipx install "poetry~=2.0.0"
+      - run: poetry install --with dev
+      - run: poetry run ruff check --select I .
+      - run: poetry run ruff check .
+
+  typing:
+    needs: [ linter ]
+    runs-on: ubuntu-22.04
+    defaults:
+      run:
+        working-directory: .
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: 3.7
+      - run: pipx install "poetry~=2.0.0"
+      - run: poetry install --with dev
+      - run: poetry run ruff check --select I .
+      - run: poetry run mypy .
+
+  tests:
+    needs: [ typing, linter ]
+    runs-on: ubuntu-22.04
+    defaults:
+      run:
+        working-directory: .
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: 3.7
+      - run: pipx install "poetry~=2.0.0"
+      - run: poetry install --with dev
+      - run: poetry run ruff check --select I .
+      - run: poetry run pytest --cov=git_analytics --cov-report=term-missing --cov-fail-under=30

.github/workflows/python-matrix-main.yml

@@ -0,0 +1,22 @@
+name: python version compatibility check (main)
+
+on:
+  push:
+    branches: [ main ]
+  pull_request:
+    branches: [ main ]
+
+jobs:
+  tests:
+    runs-on: ubuntu-22.04
+    strategy:
+      matrix:
+        python-version: ["3.7", "3.8", "3.9", "3.10", "3.11", "3.12", "3.13"]
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "${{ matrix.python-version }}"
+      - run: pipx install "poetry~=2.0.0"
+      - run: poetry install --with dev
+      - run: poetry run pytest --verbose

.gitignore

@@ -2,7 +2,10 @@ __pycache__
 .DS_Store
 .vscode
 .venv
+.coverage
 *.egg-info
+htmlcov/
 build/
 dist/
-poetry.lock
+poetry.lock
+coverage.xml

README.md

@@ -44,6 +44,7 @@ poetry run git-analytics
 
 ```bash
 poetry run pytest
+poetry run pytest --cov=git_analytics --cov-report=term-missing --cov-fail-under=30
 ```
 
 ### Type Checking

git_analytics/analyzers/authors_statistics.py

@@ -22,22 +22,13 @@ class AuthorsStatisticsAnalyzer(CommitAnalyzer):
     name = "authors_statistics"
 
     def __init__(self) -> None:
-        self._dict_authors = defaultdict(AuthorStatistics)
+        self._authors: Dict[str, AuthorStatistics] = defaultdict(AuthorStatistics)
 
     def process(self, commit: AnalyticsCommit) -> None:
-        author = self._dict_authors[commit.commit_author]
+        author: AuthorStatistics = self._authors[commit.commit_author]
         author.commits += 1
         author.insertions += commit.lines_insertions
         author.deletions += commit.lines_deletions
 
     def result(self) -> Result:
-        return Result(
-            authors={
-                name: AuthorStatistics(
-                    commits=st.commits,
-                    insertions=st.insertions,
-                    deletions=st.deletions,
-                )
-                for name, st in self._dict_authors.items()
-            }
-        )
+        return Result(authors=dict(self._authors))

git_analytics/analyzers/commit_type.py

@@ -23,7 +23,7 @@ class CommitType(Enum):
 
 @dataclass
 class Result(AnalyticsResult):
-    items: Dict[date, Dict[str, int]]
+    items: Dict[date, Dict[CommitType, int]]
 
 
 TYPE_COMMIT_LIST: tuple = tuple(ct.value for ct in CommitType)
@@ -33,25 +33,20 @@ def _get_type_list(commit_message: str):
     result = [tag for tag in TYPE_COMMIT_LIST if tag in commit_message]
     if result:
         return result
-    return [CommitType.UNKNOWN.value]
+    return [CommitType.UNKNOWN]
 
 
 class CommitTypeAnalyzer(CommitAnalyzer):
     name = "commit_type"
 
     def __init__(self) -> None:
-        self._commit_types_by_date = defaultdict(Counter)
+        self._by_date: Dict[date, Counter] = defaultdict(Counter)
 
     def process(self, commit: AnalyticsCommit) -> None:
+        commit_date = commit.committed_datetime.date()
         commit_types = _get_type_list(commit.message)
         for commit_type in commit_types:
-            self._commit_types_by_date[commit.committed_datetime.date()][
-                commit_type
-            ] += 1
+            self._by_date[commit_date][commit_type] += 1
 
     def result(self) -> Result:
-        days = defaultdict(dict)
-        for dt, st in self._commit_types_by_date.items():
-            days[str(dt)] = dict(st)
-
-        return Result(items=dict(days))
+        return Result(items={dt: dict(counter) for dt, counter in self._by_date.items()})

git_analytics/analyzers/commits_summary.py

@@ -8,39 +8,28 @@
 
 @dataclass
 class Result(AnalyticsResult):
-    date_first_commit: date
-    date_last_commit: date
-    total_number_commit: int
-    total_number_authors: int
+    date_first_commit: Optional[date] = None
+    date_last_commit: Optional[date] = None
+    total_number_commit: int = 0
+    total_number_authors: int = 0
 
 
 class CommitsSummaryAnalyzer(CommitAnalyzer):
     name = "commits_summary"
 
     def __init__(self) -> None:
-        self._date_first_commit: Optional[date] = None
-        self._date_last_commit: Optional[date] = None
-        self._total_number_commit: int = 0
-        self._list_authors: Set = set()
+        self._result = Result()
+        self._authors: Set[str] = set()
 
     def process(self, commit: AnalyticsCommit) -> None:
-        if (
-            self._date_first_commit is None
-            or commit.committed_datetime < self._date_first_commit
-        ):
-            self._date_first_commit = commit.committed_datetime
-        if (
-            self._date_last_commit is None
-            or commit.committed_datetime > self._date_last_commit
-        ):
-            self._date_last_commit = commit.committed_datetime
-        self._total_number_commit += 1
-        self._list_authors.add(commit.commit_author)
+        dt = commit.committed_datetime.date()
+        if self._result.date_first_commit is None or dt < self._result.date_first_commit:
+            self._result.date_first_commit = dt
+        if self._result.date_last_commit is None or dt > self._result.date_last_commit:
+            self._result.date_last_commit = dt
+        self._result.total_number_commit += 1
+        self._authors.add(commit.commit_author)
 
     def result(self) -> Result:
-        return Result(
-            date_first_commit=self._date_first_commit.date(),
-            date_last_commit=self._date_last_commit.date(),
-            total_number_commit=self._total_number_commit,
-            total_number_authors=len(self._list_authors),
-        )
+        self._result.total_number_authors = len(self._authors)
+        return self._result

git_analytics/analyzers/historical_statistics.py

@@ -1,5 +1,4 @@
-from collections import Counter, defaultdict
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from typing import Dict
 
 from git_analytics.entities import AnalyticsCommit, AnalyticsResult
@@ -8,12 +7,14 @@
 
 @dataclass
 class Result(AnalyticsResult):
-    hour_of_day: Dict[int, int]
-    day_of_week: Dict[str, int]
-    day_of_month: Dict[int, int]
+    hour_of_day: Dict[int, Dict[str, int]] = field(default_factory=lambda: {h: {} for h in range(24)})
+    day_of_week: Dict[str, Dict[str, int]] = field(
+        default_factory=lambda: {d: {} for d in [_get_day_name(i) for i in range(7)]}
+    )
+    day_of_month: Dict[int, Dict[str, int]] = field(default_factory=lambda: {d: {} for d in range(1, 32)})
 
 
-def get_day_name(day_index: int) -> str:
+def _get_day_name(day_index: int) -> str:
     days = [
         "Monday",
         "Tuesday",
@@ -30,31 +31,18 @@ class HistoricalStatisticsAnalyzer(CommitAnalyzer):
     name = "historical_statistics"
 
     def __init__(self) -> None:
-        self._dict_hour_of_day = defaultdict(Counter)
-        self._dict_day_of_week = defaultdict(Counter)
-        self._dict_day_of_month = defaultdict(Counter)
+        self._result = Result()
 
     def process(self, commit: AnalyticsCommit) -> None:
-        c = commit
-        self._dict_day_of_week[c.committed_datetime.weekday()][c.commit_author] += 1
-        self._dict_hour_of_day[c.committed_datetime.hour][c.commit_author] += 1
-        self._dict_day_of_month[c.committed_datetime.day][c.commit_author] += 1
+        author = commit.commit_author
+        hour = commit.committed_datetime.hour
+        day = commit.committed_datetime.weekday()
+        month_day = commit.committed_datetime.day
+
+        self._result.hour_of_day[hour][author] = self._result.hour_of_day[hour].get(author, 0) + 1
+        day_name = _get_day_name(day)
+        self._result.day_of_week[day_name][author] = self._result.day_of_week[day_name].get(author, 0) + 1
+        self._result.day_of_month[month_day][author] = self._result.day_of_month[month_day].get(author, 0) + 1
 
     def result(self) -> Result:
-        hour_of_day = {hour: 0 for hour in range(24)}
-        for hour, authors in self._dict_hour_of_day.items():
-            hour_of_day[hour] = dict(authors)
-
-        day_of_week = {get_day_name(day): 0 for day in range(7)}
-        for day, authors in self._dict_day_of_week.items():
-            day_of_week[get_day_name(day)] = dict(authors)
-
-        day_of_month = {day: 0 for day in range(1, 32)}
-        for day, authors in self._dict_day_of_month.items():
-            day_of_month[day] = dict(authors)
-
-        return Result(
-            hour_of_day=hour_of_day,
-            day_of_week=day_of_week,
-            day_of_month=day_of_month,
-        )
+        return self._result

git_analytics/analyzers/lines_statistics.py

@@ -1,7 +1,6 @@
-from collections import defaultdict
 from dataclasses import dataclass
 from datetime import date
-from typing import List
+from typing import Dict, List
 
 from git_analytics.entities import AnalyticsCommit, AnalyticsResult
 from git_analytics.interfaces import CommitAnalyzer
@@ -22,27 +21,17 @@ class LinesAnalyzer(CommitAnalyzer):
     name = "lines_statistics"
 
     def __init__(self) -> None:
-        self._lines_in_day = {}
+        self._daily_delta: Dict[date, int] = {}
 
     def process(self, commit: AnalyticsCommit) -> None:
-        self._lines_in_day[commit.committed_datetime] = (
-            commit.lines_insertions - commit.lines_deletions
-        )
+        d = commit.committed_datetime.date()
+        delta = commit.lines_insertions - commit.lines_deletions
+        self._daily_delta[d] = self._daily_delta.get(d, 0) + delta
 
     def result(self) -> Result:
-        dict_number_lines = defaultdict(int)
-
-        old_rows = 0
-        sort_day = list(self._lines_in_day.keys())
-        sort_day.sort()
-        for day in sort_day:
-            number_rows = self._lines_in_day[day]
-            dict_number_lines[day] = old_rows + number_rows
-            old_rows = old_rows + number_rows
-
-        return Result(
-            items=[
-                LinesStatistics(date=day.date(), lines=lines)
-                for day, lines in dict_number_lines.items()
-            ]
-        )
+        items: List[LinesStatistics] = []
+        total = 0
+        for d in sorted(self._daily_delta.keys()):
+            total += self._daily_delta[d]
+            items.append(LinesStatistics(date=d, lines=total))
+        return Result(items=items)

git_analytics/entities.py

@@ -1,5 +1,7 @@
+from collections.abc import Iterable, Mapping
 from dataclasses import asdict, dataclass
 from datetime import date, datetime
+from enum import Enum
 from typing import Any, Dict
 
 
@@ -20,11 +22,28 @@ def to_dict(self) -> Dict[str, Any]:
         return self._make_json_safe(asdict(self))
 
     @staticmethod
-    def _make_json_safe(obj):
-        if isinstance(obj, date):
+    def _make_json_safe(obj: Any) -> Any:
+        if isinstance(obj, (date, datetime)):
             return obj.isoformat()
-        if isinstance(obj, list):
+
+        if isinstance(obj, Enum):
+            return obj.value
+
+        if isinstance(obj, Mapping):
+            safe: Dict[str, Any] = {}
+            for k, v in obj.items():
+                if isinstance(k, (date, datetime)):
+                    key = k.isoformat()
+                elif isinstance(k, Enum):
+                    key = k.value
+                elif isinstance(k, (str, int, float, bool)) or k is None:
+                    key = str(k)
+                else:
+                    key = str(k)
+                safe[key] = AnalyticsResult._make_json_safe(v)
+            return safe
+
+        if isinstance(obj, Iterable) and not isinstance(obj, (str, bytes)):
             return [AnalyticsResult._make_json_safe(x) for x in obj]
-        if isinstance(obj, dict):
-            return {k: AnalyticsResult._make_json_safe(v) for k, v in obj.items()}
+
         return obj