initial commit

Author: NF-coder

.github/workflows/stats.yaml

@@ -0,0 +1,54 @@
+name: Update SVG and Deploy to Pages
+
+on:
+  schedule:
+    - cron: '0 */2 * * *'
+  workflow_dispatch:
+  push:
+    branches: [ main ]
+
+jobs:
+  generate-and-deploy:
+    runs-on: ubuntu-latest
+    
+    steps:
+    - name: Checkout repository
+      uses: actions/checkout@v4
+      with:
+        token: ${{ secrets.GITHUB_TOKEN }}
+        fetch-depth: 0
+
+    - name: Set up Python
+      uses: actions/setup-python@v4
+      with:
+        python-version: '3.12'
+
+    - name: Install dependencies
+      run: |
+        python -m pip install --upgrade pip
+        if [ -f requirements.txt ]; then pip install -r requirements.txt; fi
+
+    - name: Generate SVG file
+      env:
+        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        USERNAME: "NF-coder"
+      run: |
+        python src/main.py
+
+    - name: Verify SVG file
+      run: |
+        if [ ! -f out.svg ]; then
+          echo "Error: out.svg was not generated!"
+          exit 1
+        fi
+
+        mkdir -p deploy-files
+        cp out.svg deploy-files/
+
+    - name: Deploy to GitHub Pages
+      uses: peaceiris/actions-gh-pages@v3
+      with:
+        github_token: ${{ secrets.GITHUB_TOKEN }}
+        publish_dir: ./deploy-files
+        keep_files: false
+        allow_empty_commit: false

.gitignore

@@ -0,0 +1,6 @@
+.vscode/
+.venv/
+__pycache__/
+
+out.svg
+out.html

requirements.txt

@@ -0,0 +1,2 @@
+Jinja2==3.1.6
+requests==2.32.4

src/calc.py

@@ -0,0 +1,68 @@
+from renderer.renderer import IRenderer
+from math import sin, cos, pi, degrees
+
+class Math:
+    @staticmethod
+    def math_rounding(value: float) -> int:
+        """Округление по правилам математики"""
+        return int(value)+1 if value%1>0.5 else int(value)
+
+class Calc:
+    def __init__(
+            self,
+            outer_radius: int,
+            thickness: int,
+            percent_array: list[float],
+            sections_colors_array: list[str],
+            names_array: list[str],
+            renderer: IRenderer,
+            margin_x: int = 0,
+            margin_y: int = 0,
+        ) -> None:
+        self._thickness = thickness
+        self._outer_radius = outer_radius
+        self._renderer = renderer
+        self._margin_x = margin_x
+        self._margin_y = margin_y
+        self._percent_array = percent_array
+        self._sections_colors_array = sections_colors_array
+        self._inner_radius = outer_radius - thickness
+        self._names_array = names_array
+    
+    def __call__(self) -> str:
+        angle_accumulator = 0 # sum of all previous angles
+
+        next_outer_curve_start_x = self._margin_x + self._outer_radius  # x-axis position of end of previous outer curve / start of new outer curve
+        next_outer_curve_start_y = self._margin_y  # y-axis position of end of previous outer curve / start of new outer curve
+
+        next_inner_curve_start_x = self._margin_x + self._outer_radius  # x-axis position of end of previous inner curve / start of new inner curve
+        next_inner_curve_start_y = self._margin_y + self._thickness  # y-axis position of end of previous inner curve / start of new inner curve
+
+        for percent,color,name in zip(self._percent_array, self._sections_colors_array, self._names_array):
+            current_angle = 2*pi*percent + angle_accumulator
+
+            outer_x = self._margin_x + self._outer_radius*(1+sin(current_angle))
+            outer_y = self._margin_y + self._outer_radius*(1-cos(current_angle))
+            inner_x = self._margin_x + self._thickness + self._inner_radius*(1+sin(current_angle))
+            inner_y = self._margin_y + self._thickness + self._inner_radius*(1-cos(current_angle))
+
+            self._renderer.add_section(
+                (Math.math_rounding(next_outer_curve_start_x), Math.math_rounding(next_outer_curve_start_y)),
+                (Math.math_rounding(outer_x), Math.math_rounding(outer_y)),
+                (Math.math_rounding(inner_x), Math.math_rounding(inner_y)),
+                (Math.math_rounding(next_inner_curve_start_x), Math.math_rounding(next_inner_curve_start_y)),
+                section_start_angle=degrees(angle_accumulator),
+                section_finish_angle=degrees(current_angle),
+                color=color,
+                name=name
+            )
+            
+            # Updating all values
+            angle_accumulator += 2*pi*percent
+            next_outer_curve_start_x = outer_x
+            next_outer_curve_start_y = outer_y
+            next_inner_curve_start_x = inner_x
+            next_inner_curve_start_y = inner_y
+
+        return self._renderer.render()
+        

src/fetcher/fetcher.py

@@ -0,0 +1,46 @@
+import requests
+
+from .fetcherSettings import FetcherSettings
+from .utils.bodyFabric import BodyFabric
+
+from .langElem import LangElem
+
+class FetchLangStats:
+    def __init__(self, token: str) -> None:
+        self._token = token
+
+    def fetch_user(self, username: str) -> list[LangElem]:
+        headers = {
+            'Authorization': f'token {self._token}',
+            'Content-Type': 'application/json'
+        }
+
+        body_fabric = BodyFabric(
+            username=username,
+            first_k_repos_fetch=FetcherSettings.FIRST_K_REPOS_FETCH,
+            top_k_languages_in_repo=FetcherSettings.TOP_K_LANGUAGES_IN_REPO
+        )
+
+        response = requests.post(
+            url=FetcherSettings.GITHUB_APT_URL,
+            headers=headers,
+            json=body_fabric.create()
+        )
+        
+        if response.status_code == 200:
+            response = response.json()
+
+            result = []
+
+            for repo in response["data"]["user"]["repositories"]["nodes"]:
+                for languages in repo["languages"]["edges"]:
+                    result.append(
+                        LangElem(
+                            languages["size"],
+                            languages["node"]["color"],
+                            languages["node"]["name"]
+                        )
+                    )
+            return result
+        
+        raise RuntimeError("Github returnrd non-200 responce")

src/fetcher/fetcherSettings.py

@@ -0,0 +1,9 @@
+from dataclasses import dataclass
+
+@dataclass
+class FetcherSettings:
+    GITHUB_APT_URL: str = "https://api.github.com/graphql"
+
+    FIRST_K_REPOS_FETCH: int = 100
+    TOP_K_LANGUAGES_IN_REPO: int = 10
+    

src/fetcher/langElem.py

@@ -0,0 +1,7 @@
+from dataclasses import dataclass
+
+@dataclass
+class LangElem:
+    size: int
+    github_color: str
+    name: str

src/fetcher/utils/bodyFabric.py

@@ -0,0 +1,38 @@
+class BodyFabric:
+    def __init__(
+            self,
+            username: str,
+            first_k_repos_fetch: int,
+            top_k_languages_in_repo: int
+        ) -> None:
+        self._username = username
+        self._first_k_repos_fetch = first_k_repos_fetch
+        self._top_k_languages_in_repo = top_k_languages_in_repo
+
+    def create(self) -> dict[str, str]:
+        return {
+            "query":
+                """query {user(login: \"""" + self._username + """\") {
+                        repositories(ownerAffiliations: OWNER, isFork: false, first: """ +  str(self._first_k_repos_fetch) +  """) {
+                            nodes {
+                                name languages(
+                                    first: """ + str(self._top_k_languages_in_repo) +""",
+                                    orderBy: {
+                                        field: SIZE,
+                                        direction: DESC
+                                    }
+                                ) {
+                                    edges {
+                                        size
+                                        node {
+                                            color
+                                            name
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            """.replace("\n","")
+        }

src/main.py

@@ -0,0 +1,95 @@
+import os
+
+from renderer.renderer import RenderBuilder
+from oklchUtils.OKLCHUtils import OKLCHUtils
+from calc import Calc
+
+from fetcher.fetcher import FetchLangStats
+
+# Fetch info
+USERNAME = os.environ['USERNAME']
+TOKEN = os.environ['GITHUB_TOKEN']
+
+# Plane settings
+HEIGHT: int = 140
+WIDTH: int = 250
+
+# Captions settings
+LEGEND_MARGIN_X: int = 140
+LEGEND_MARGIN_Y: int = 30
+SPACE_BETWEEN_CAPTIONS: int = 22
+FONT_COLOR: str = "#c1c1c1"
+
+# Color settings
+OKLCH_CHROMA: float = 0.099
+OKLCH_LIGHTNESS: float = 0.636
+OTHER_COLOR_CHROMA: float = 0.000
+
+# Round sizes settings
+OUTER_RADIUS: int = 55
+THICKNESS: int = 12
+
+# Margins settings
+MARGIN_X: int = 20
+MARGIN_Y: int = 15
+
+# Arrays settings
+TOP_K: int = 4
+
+# Output filepath
+OUTPUT_FILE: str = "./out.svg"
+
+def get_langs_data(token: str):
+    info = {}
+    
+    total_size = 0
+
+    for elem in FetchLangStats(token).fetch_user(USERNAME):
+        total_size += elem.size
+        if elem.name not in info: info[elem.name] = elem.size
+        else: info[elem.name] += elem.size
+
+    return info.keys(), map(lambda x: x/total_size, info.values())
+
+def truncate(langs_arr: list[tuple[float, str]], k: int):
+    if len(langs_arr) <= k: return langs_arr
+    return langs_arr[:k-1] + [(sum(map(lambda x: x[0], langs_arr[k-1:])), "Other")]
+
+def main():
+    NAMES_ARR, PERCENT_ARR = get_langs_data(TOKEN)
+
+    sorted_percents = sorted([(percent, name) for percent,name in zip(PERCENT_ARR, NAMES_ARR)], key=lambda x: x[0], reverse=True)
+
+    sorted_percents = truncate(sorted_percents, TOP_K)
+
+    _ = Calc(
+        outer_radius=OUTER_RADIUS,
+        thickness=THICKNESS,
+        percent_array=[elem[0] for elem in sorted_percents],
+        sections_colors_array=OKLCHUtils.create_colors_array(
+            length=len(sorted_percents),
+            chroma=OKLCH_CHROMA,
+            lightness=OKLCH_LIGHTNESS
+        ),
+        renderer=RenderBuilder(
+            height=HEIGHT,
+            width=WIDTH, 
+            outer_radius=OUTER_RADIUS, 
+            thickness=THICKNESS,
+            margin_x=MARGIN_X,
+            margin_y=MARGIN_Y, 
+            legend_margin_x=LEGEND_MARGIN_X,
+            legend_margin_y=LEGEND_MARGIN_Y, 
+            space_between_captions=SPACE_BETWEEN_CAPTIONS,
+            font_color=FONT_COLOR
+        ),
+        margin_x=MARGIN_X,
+        margin_y=MARGIN_Y,
+        names_array=[elem[1] for elem in sorted_percents]
+    )
+
+    with open(OUTPUT_FILE, "w+", encoding="utf-8-sig") as f:
+        f.write(_())
+
+if __name__ == '__main__':
+    main()

src/oklchUtils/OKLCHUtils.py

@@ -0,0 +1,9 @@
+from .oklchConv.OKLCHConverter import OKLCHConverter
+
+class OKLCHUtils:
+    @staticmethod
+    def create_colors_array(length: int, chroma: float, lightness: float):
+        return [
+            OKLCHConverter.oklch_to_rgb(lightness, chroma, hue)
+            for hue in range(0, 360, 360//length)
+        ]