MGost 0.4__tar.gz

mgost-0.4/.flake8

@@ -0,0 +1,10 @@
+[flake8]
+ignore =
+    B008
+exclude =
+    .venv
+per-file-ignores = 
+    # F401: imported but unused
+    # Sometimes imports in __init__
+    # done to make shortcuts
+    __init__.py: F401, F403

mgost-0.4/.github/workflows/coverage.yml

@@ -0,0 +1,24 @@
+name: Coverage
+
+on: [push]
+
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v3
+    - name: Install uv
+      uses: astral-sh/setup-uv@v5
+      with:
+        enable-cache: true
+    - name: Installing project with coverage
+      run: uv sync --group tests
+    - name: Testing code with coverage
+      run: uv run -m coverage run -m unittest
+    - name: Collecting coverage
+      run: uv run -m coverage json
+    - uses: actions/upload-artifact@v4
+      with:
+        name: coverage
+        path: coverage.json

mgost-0.4/.github/workflows/flake8.yml

@@ -0,0 +1,17 @@
+name: Flake8
+
+on: [push]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v3
+    - name: Install uv
+      uses: astral-sh/setup-uv@v5
+      with:
+        enable-cache: true
+    - name: Sync project
+      run: uv sync --group tests
+    - name: Testing code flake8
+      run: uv run -m flake8

mgost-0.4/.github/workflows/tests.yml

@@ -0,0 +1,23 @@
+name: Tests
+
+on: [push]
+
+jobs:
+  build:
+    strategy:
+      matrix:
+        python-version: ["3.12", "3.13"]
+        os: [ubuntu-latest]
+      fail-fast: false
+    runs-on: ${{ matrix.os }}
+    steps:
+    - uses: actions/checkout@v3
+    - name: Install uv
+      uses: astral-sh/setup-uv@v5
+      with:
+        python-version: ${{ matrix.python-version }}
+        enable-cache: true
+    - name: Sync project
+      run: uv sync --group tests
+    - name: Testing code with django test framework
+      run: uv run -m unittest

mgost-0.4/.gitignore

@@ -0,0 +1,4 @@
+uv.lock
+**/__pycache__
+dist
+.coverage

mgost-0.4/.pre-commit-config.yaml

@@ -0,0 +1,16 @@
+ci:
+  autoupdate_schedule: monthly
+repos:
+  - repo: https://github.com/PyCQA/flake8
+    rev: 7.0.0
+    hooks:
+      - id: flake8
+        additional_dependencies:
+          - flake8-bugbear
+        types: [python]
+
+  - repo: https://github.com/pycqa/isort
+    rev: 5.13.2
+    hooks:
+      - id: isort
+        types: [python]

mgost-0.4/.python-version

@@ -0,0 +1 @@
+3.13

mgost-0.4/.vscode/launch.json

@@ -0,0 +1,16 @@
+{
+    // Use IntelliSense to learn about possible attributes.
+    // Hover to view descriptions of existing attributes.
+    // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
+    "version": "0.2.0",
+    "configurations": [
+        {
+            "name": "Python Debugger: Module",
+            "type": "debugpy",
+            "request": "launch",
+            "module": "mgost",
+            "args": ["sync"],
+            "cwd": "${workspaceFolder}/test"
+        }
+    ]
+}

mgost-0.4/.vscode/settings.json

@@ -0,0 +1,11 @@
+{
+    "files.exclude": {
+        "**/__pycache__": true,
+        ".venv": true,
+        "uv.lock": true,
+    },
+    "cSpell.words": [
+        "ARTICHAAPI",
+        "рендера"
+    ]
+}

mgost-0.4/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 ArtichaSite
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

mgost-0.4/PKG-INFO

@@ -0,0 +1,33 @@
+Metadata-Version: 2.4
+Name: MGost
+Version: 0.4
+Summary: MGost converter console app based on ArtichaAPI
+Project-URL: homepage, https://articha.ru/mgost/
+Project-URL: repository, https://github.com/ArtichaTM/MGost
+Author-email: Геворкян Артём <tima-1324@mail.ru>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: ArtichaSite,api
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Education
+Classifier: Intended Audience :: Information Technology
+Classifier: Natural Language :: English
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.13
+Requires-Python: >=3.13
+Requires-Dist: aiofiles>=25.1.0
+Requires-Dist: aiopath>=0.7.7
+Requires-Dist: dotenv>=0.9.9
+Requires-Dist: httpx>=0.28.1
+Requires-Dist: pre-commit>=4.2.0
+Requires-Dist: pydantic>=2.11.7
+Requires-Dist: typer>=0.16.1
+Description-Content-Type: text/markdown
+
+# MGost
+Библиотека позволяет пользоваться преимуществами MGost конвертера локально

mgost-0.4/README.md

@@ -0,0 +1,2 @@
+# MGost
+Библиотека позволяет пользоваться преимуществами MGost конвертера локально

mgost-0.4/pyproject.toml

@@ -0,0 +1,61 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = [
+  "src/mgost"
+]
+
+[project]
+name = "MGost"
+version = "0.4"
+authors = [
+  {name="Геворкян Артём", email="tima-1324@mail.ru"}
+]
+description = "MGost converter console app based on ArtichaAPI"
+readme = "README.md"
+license = "MIT"
+license-files = ["LICENSE"]
+keywords = ["ArtichaSite", "api"]
+requires-python = ">=3.13"
+dependencies = [
+    "aiofiles>=25.1.0",
+    "aiopath>=0.7.7",
+    "dotenv>=0.9.9",
+    "httpx>=0.28.1",
+    "pre-commit>=4.2.0",
+    "pydantic>=2.11.7",
+    "typer>=0.16.1",
+]
+
+
+classifiers = [
+  "Development Status :: 4 - Beta"
+  , "Operating System :: POSIX :: Linux"
+  , "Operating System :: Microsoft :: Windows"
+  , "Environment :: Console"
+  , "Programming Language :: Python"
+  , "Programming Language :: Python :: 3"
+  , "Programming Language :: Python :: 3 :: Only"
+  , "Programming Language :: Python :: 3.13"
+  , "Natural Language :: English"
+  , "Intended Audience :: Education"
+  , "Intended Audience :: Information Technology"
+]
+
+[project.urls]
+homepage = "https://articha.ru/mgost/"
+repository = "https://github.com/ArtichaTM/MGost"
+
+[project.scripts]
+mgost = "mgost:main"
+
+[dependency-groups]
+tests = [
+    "coverage>=7.11.0",
+    "flake8>=7.3.0",
+]
+
+[tool.isort]
+multi_line_output = 5

mgost-0.4/src/mgost/__init__.py

@@ -0,0 +1 @@
+from .cli import app as main

mgost-0.4/src/mgost/__main__.py

@@ -0,0 +1,4 @@
+from .cli import app as main
+
+if __name__ == "__main__":
+    main()

mgost-0.4/src/mgost/api/__init__.py

@@ -0,0 +1,2 @@
+from .api import ArtichaAPI
+from .exceptions import APIRequestError

mgost-0.4/src/mgost/api/actions.py

@@ -0,0 +1,114 @@
+from abc import ABC, abstractmethod
+from dataclasses import dataclass
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+from rich.progress import Progress
+
+if TYPE_CHECKING:
+    from mgost.mgost import MGost
+
+    from .api import ArtichaAPI
+
+
+@dataclass(frozen=True, slots=True)
+class Action(ABC):
+    pass
+
+
+@dataclass(frozen=True, slots=True)
+class MGostCompletableAction(Action, ABC):
+    @abstractmethod
+    async def complete_mgost(
+        self, mgost: 'MGost',
+        progress: Progress | None = None
+    ) -> Action | None:
+        raise NotImplementedError()
+
+
+@dataclass(frozen=True, slots=True)
+class APICompletableAction(MGostCompletableAction, ABC):
+    async def complete_mgost(
+        self, mgost, progress=None
+    ) -> Action | None:
+        return await self.complete_api(mgost.api, progress)
+
+    @abstractmethod
+    async def complete_api(
+        self,
+        api: 'ArtichaAPI',
+        progress: Progress | None = None
+    ) -> Action | None:
+        raise NotImplementedError()
+
+
+@dataclass(frozen=True, slots=True)
+class PathAction(Action, ABC):
+    project_id: int
+    path: Path
+
+
+@dataclass(frozen=True, slots=True)
+class MoveAction(PathAction, ABC):
+    new_path: Path
+
+
+@dataclass(frozen=True, slots=True)
+class DoNothing(APICompletableAction):
+    async def complete_api(self, api, progress=None):
+        from asyncio import sleep
+        from random import random
+        await sleep(random())
+
+
+@dataclass(frozen=True, slots=True)
+class UploadFileAction(APICompletableAction, PathAction):
+    overwrite: bool
+
+    async def complete_api(self, api, progress=None):
+        await api.upload(
+            project_id=self.project_id,
+            path=self.path,
+            overwrite=self.overwrite,
+            progress=progress
+        )
+
+
+@dataclass(frozen=True, slots=True)
+class DownloadFileAction(APICompletableAction, PathAction):
+    overwrite_ok: bool
+
+    async def complete_api(self, api, progress=None):
+        await api.download(
+            project_id=self.project_id,
+            path=self.path,
+            overwrite_ok=self.overwrite_ok,
+            progress=progress
+        )
+
+
+@dataclass(frozen=True, slots=True)
+class FileMovedLocally(APICompletableAction, MoveAction):
+    async def complete_api(self, api, progress=None):
+        project_files = await api.project_files(
+            self.project_id
+        )
+        if self.path in project_files:
+            await api.move_on_cloud(
+                project_id=self.project_id,
+                old_path=self.path,
+                new_path=self.new_path
+            )
+        else:
+            await api.upload(
+                self.project_id,
+                path=self.new_path,
+                overwrite=False,
+                progress=progress
+            )
+
+
+@dataclass(frozen=True, slots=True)
+class FileSync(MGostCompletableAction, PathAction):
+    async def complete_mgost(self, mgost, progress=None) -> Action:
+        return await mgost.sync_file(self.project_id, self.path)

mgost-0.4/src/mgost/api/api.py

@@ -0,0 +1,272 @@
+from datetime import datetime
+from os import utime
+from pathlib import Path
+from typing import Awaitable, Literal
+
+from aiopath import AsyncPath
+from httpx import (
+    AsyncClient, ConnectError, HTTPStatusError, QueryParams, Response
+)
+from httpx._types import RequestFiles
+from rich.progress import Progress
+
+from . import schemas
+from .caller import api_request
+from .exceptions import ClientClosed
+from .request import APIRequestInfo
+
+CURRENT_TIMEZONE = datetime.now().astimezone().tzinfo
+
+
+class ArtichaAPI:
+    __slots__ = (
+        '_token',
+        '_client',
+        '_cache',
+        '_base_url',
+    )
+    _host: str = 'https://articha.ru/api'
+    _base_url: str
+    _token: str
+    _client: AsyncClient | None
+    _cache: dict[tuple[
+        str,
+        str,
+        QueryParams | dict | None,
+        RequestFiles | dict | None
+    ], Response]
+
+    def __init__(
+        self,
+        api_token: str,
+        /,
+        base_url: str | None = None
+    ) -> None:
+        assert base_url is None or isinstance(base_url, str)
+        assert isinstance(api_token, str)
+        if base_url is None:
+            base_url = self._host
+        assert base_url is not None
+        self._base_url = base_url
+        self._token = api_token
+        self._cache = dict()
+
+    async def __aenter__[T: ArtichaAPI](self: T) -> T:
+        assert self._base_url is not None
+        self._client = AsyncClient(
+            headers={
+                'X-API-Key': self._token
+            },
+            base_url=self._base_url
+        )
+        await self._client.__aenter__()
+        return self
+
+    async def __aexit__(self, *args) -> None:
+        assert isinstance(self._client, AsyncClient)
+        if self._client is None:
+            raise ClientClosed(f"{self.__qualname__} is closed")
+        await self._client.__aexit__()
+        self._client = None
+
+    def method(
+        self, request: APIRequestInfo
+    ) -> Awaitable[Response]:
+        assert self._client is not None
+        return api_request(
+            client=self._client,
+            cache=self._cache,
+            request=request
+        )
+
+    def _invalidate_cache(self) -> None:
+        self._cache.clear()
+
+    async def validate_token(self) -> str | schemas.TokenInfo:
+        try:
+            resp = await self.method(APIRequestInfo(
+                'GET', '/me'
+            ))
+            return schemas.TokenInfo(**resp.json())
+        except HTTPStatusError as e:
+            resp = e.response
+            info = resp.json()
+            assert 'detail' in info
+            return info['detail']
+        except ConnectError:
+            return "Ошибка подключения: сайт недоступен"
+
+    async def me(self) -> schemas.TokenInfo:
+        return schemas.TokenInfo(**(await self.method(APIRequestInfo(
+            'GET', '/me'
+        ))).json())
+
+    async def trust(self) -> int:
+        return (await self.method(APIRequestInfo(
+            'GET', '/trust'
+        ))).json()['trust']
+
+    async def trust_factors(self) -> dict[str, int]:
+        return (await self.method(APIRequestInfo(
+            'GET', '/trust/factors'
+        ))).json()
+
+    async def download_example(
+        self,
+        name: str = 'init',
+        type: Literal['md', 'docx'] = 'md'
+    ) -> bytes:
+        resp = await self.method(APIRequestInfo(
+            'GET', '/mgost/examples',
+            {
+                'name': name,
+                'type': type
+            }
+        ))
+        return resp.read()
+
+    async def is_project_available(self, project_id: int) -> bool:
+        assert isinstance(project_id, int)
+        try:
+            response = await self.method(APIRequestInfo(
+                'GET', f'/mgost/project/{project_id}'
+            ))
+            return response.status_code == 200
+        except HTTPStatusError:
+            return False
+
+    async def projects(self) -> list[schemas.Project]:
+        resp = await self.method(APIRequestInfo(
+            'GET', '/mgost/project'
+        ))
+        return [
+            schemas.Project(**i) for i in resp.json()
+        ]
+
+    async def project(self, project_id: int) -> schemas.ProjectExtended:
+        assert isinstance(project_id, int)
+        assert await self.is_project_available(project_id)
+        resp = await self.method(APIRequestInfo(
+            'GET', f'/mgost/project/{project_id}'
+        ))
+        return schemas.ProjectExtended(
+            **resp.json(),
+        )
+
+    async def project_requirements(
+        self, project_id
+    ) -> dict[str, schemas.FileRequirement]:
+        resp = await self.method(APIRequestInfo(
+            'GET', f'/mgost/project/{project_id}/requirements'
+        ))
+        return {
+            k: schemas.FileRequirement(
+                **v
+            ) for k, v in resp.json().items()
+        }
+
+    async def project_files(
+        self, project_id: int
+    ) -> dict[Path, schemas.ProjectFile]:
+        assert isinstance(project_id, int)
+        resp = await self.method(APIRequestInfo(
+            'GET', f'/mgost/project/{project_id}/files'
+        ))
+        return {
+            Path(i['path']): schemas.ProjectFile(**i) for i in resp.json()
+        }
+
+    async def create_project(self, name: str) -> int:
+        assert isinstance(name, str)
+        resp = await self.method(APIRequestInfo(
+            'GET', '/mgost/project',
+            {'project_name': name}
+        ))
+        self._invalidate_cache()
+        return resp.json()['id']
+
+    async def upload(
+        self,
+        project_id: int,
+        path: Path,
+        overwrite: bool,
+        progress: Progress | None = None
+    ) -> None:
+        assert isinstance(project_id, int)
+        assert isinstance(path, Path)
+        assert isinstance(overwrite, bool)
+        if not (path.exists() and path.is_file()):
+            raise FileNotFoundError
+        params: dict = {
+            'project_id': project_id,
+            'modify_time': datetime.fromtimestamp(
+                path.lstat().st_mtime, CURRENT_TIMEZONE
+            )
+        }
+        if overwrite:
+            await self.method(APIRequestInfo(
+                'POST',
+                f'/mgost/project/{project_id}/files/{path}',
+                params=params,
+                request_file_path=AsyncPath(path),
+                progress=progress
+            ))
+        else:
+            params['path'] = path
+            await self.method(APIRequestInfo(
+                'PUT',
+                f'/mgost/project/{project_id}/files/{path}',
+                params=params,
+                request_file_path=AsyncPath(path),
+                progress=progress
+            ))
+        self._invalidate_cache()
+
+    async def download(
+        self,
+        project_id: int,
+        path: Path,
+        overwrite_ok: bool = True,
+        progress: Progress | None = None
+    ) -> None:
+        assert isinstance(project_id, int)
+        assert isinstance(path, Path)
+        assert isinstance(overwrite_ok, bool)
+        resp = await self.method(APIRequestInfo(
+            'GET', f'/mgost/project/{project_id}/files/{path}',
+            response_file_path=AsyncPath(path),
+            progress=progress
+        ))
+        resp.raise_for_status()
+        access_time = path.lstat().st_atime
+        project_files = await self.project_files(project_id)
+        project_file = project_files[path]
+        utime(path, (access_time, project_file.modified.timestamp()))
+
+    async def move_on_cloud(
+        self,
+        project_id: int,
+        old_path: Path,
+        new_path: Path
+    ) -> bool:
+        resp = await self.method(APIRequestInfo(
+            'PATCH',
+            f'/mgost/project/{project_id}/files/{old_path}',
+            {'target': new_path}
+        ))
+        self._invalidate_cache()
+        return schemas.Message(**resp.json()).is_ok()
+
+    async def render(
+        self,
+        project_id: int
+    ) -> schemas.mgost.BuildResult:
+        """Requests api to render project
+        :raises HTTPStatusError: Raised when got non-success code from the api
+        """
+        resp = await self.method(APIRequestInfo(
+            'GET', f'/mgost/project/{project_id}/render'
+        ))
+        resp.raise_for_status()
+        self._invalidate_cache()
+        return schemas.mgost.BuildResult(**resp.json())