isdayoff-api 1.0.0__tar.gz

isdayoff_api-1.0.0/.gitignore

@@ -0,0 +1,131 @@
+.qwen
+
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+pip-wheel-metadata/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+.python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/

isdayoff_api-1.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021 Максим Кобылинский
+
+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.

isdayoff_api-1.0.0/PKG-INFO

@@ -0,0 +1,173 @@
+Metadata-Version: 2.4
+Name: isdayoff-api
+Version: 1.0.0
+Summary: Checking the date for belonging to a non-working day, according to official decrees and orders.
+Project-URL: Homepage, https://github.com/alexbevz/isdayoff
+Project-URL: Source, https://github.com/alexbevz/isdayoff
+Author-email: Aleksandr Bevz <as-bivz@yandex.ru>
+License: MIT
+License-File: LICENSE
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Libraries
+Requires-Python: >=3.11
+Requires-Dist: httpx>=0.28
+Requires-Dist: pydantic>=2
+Description-Content-Type: text/markdown
+
+# isdayoff
+
+Production Calendar API
+
+Description:
+* Checking the date for belonging to a non-working day, according to official decrees and orders.
+
+Official API website — https://isdayoff.ru
+
+## Install
+
+```bash
+pip install isdayoff-api
+```
+
+Requires Python 3.11+.
+
+## Supported locales
+
+| Code | Country |
+|------|---------|
+| `ru` | Russia |
+| `kz` | Kazakhstan |
+| `by` | Belarus |
+| `us` | USA |
+| `uz` | Uzbekistan |
+| `tr` | Turkey |
+| `lv` | Latvia |
+
+## Quick start
+
+### Async (recommended)
+
+```python
+import asyncio
+from datetime import date
+
+from isdayoff import DateType, ProdCalendar
+
+
+async def main():
+    async with ProdCalendar(locale="us") as calendar:
+        if await calendar.today() == DateType.WORKING:
+            print("Today is a working day")
+        else:
+            print("Today is a day off")
+
+
+asyncio.run(main())
+```
+
+### Sync
+
+```python
+from datetime import date
+
+from isdayoff import DateType, SyncProdCalendar
+
+
+with SyncProdCalendar(locale="us") as calendar:
+    if calendar.today() == DateType.WORKING:
+        print("Today is a working day")
+    else:
+        print("Today is a day off")
+```
+
+## API
+
+All methods are available on both `ProdCalendar` (async) and `SyncProdCalendar` (sync).
+
+### Parameters
+
+| Parameter | Type | Default | Description |
+|---|---|---|---|
+| `locale` | `str` | `"ru"` | Country code (see table above) |
+| `pre` | `bool` | `False` | Mark shortened working days |
+| `covid` | `bool` | `False` | Mark working days due to COVID-19 |
+| `sd` | `bool` | `False` | Consider 6-day work week |
+
+### Methods
+
+```python
+# Async
+await calendar.today(locale="ru", pre=True, covid=True, sd=True)
+await calendar.tomorrow()
+await calendar.date(date(2024, 8, 25))
+await calendar.month(date(2024, 8, 1))
+await calendar.year(date(2024, 1, 1))
+await calendar.range_date(date(2024, 1, 1), date(2024, 5, 1))
+calendar.is_leap(date(2024, 1, 1))
+
+# Sync
+calendar.today(locale="ru", pre=True, covid=True, sd=True)
+calendar.tomorrow()
+calendar.date(date(2024, 8, 25))
+calendar.month(date(2024, 8, 1))
+calendar.year(date(2024, 1, 1))
+calendar.range_date(date(2024, 1, 1), date(2024, 5, 1))
+calendar.is_leap(date(2024, 1, 1))
+```
+
+### Return types
+
+| Method | Returns |
+|---|---|
+| `today()` / `tomorrow()` / `date()` | `DateType` enum |
+| `month()` / `year()` / `range_date()` | `dict[str, DateType]` — ISO date → type |
+| `is_leap()` | `bool` |
+
+### DateType values
+
+| Value | Meaning |
+|---|---|
+| `DateType.WORKING` (0) | Working day |
+| `DateType.NOT_WORKING` (1) | Day off / holiday |
+| `DateType.SHORTENED` (2) | Shortened pre-holiday day |
+| `DateType.WORKING_DAY` (4) | Working day (special period) |
+
+## Full example
+
+```python
+import asyncio
+from datetime import date
+
+from isdayoff import DateType, ProdCalendar
+
+
+async def main():
+    async with ProdCalendar(locale="us") as calendar:
+        res = await calendar.month(date(2024, 8, 1), locale="ru")
+        days_off = sum(
+            1 for v in res.values() if v == DateType.NOT_WORKING
+        )
+        print(f"Days off in August 2024: {days_off}")
+
+
+asyncio.run(main())
+```
+
+## Development
+
+```bash
+# Install dependencies
+uv sync
+
+# Run tests
+uv run pytest
+
+# Build
+uv build
+```

isdayoff_api-1.0.0/README.md

@@ -0,0 +1,151 @@
+# isdayoff
+
+Production Calendar API
+
+Description:
+* Checking the date for belonging to a non-working day, according to official decrees and orders.
+
+Official API website — https://isdayoff.ru
+
+## Install
+
+```bash
+pip install isdayoff-api
+```
+
+Requires Python 3.11+.
+
+## Supported locales
+
+| Code | Country |
+|------|---------|
+| `ru` | Russia |
+| `kz` | Kazakhstan |
+| `by` | Belarus |
+| `us` | USA |
+| `uz` | Uzbekistan |
+| `tr` | Turkey |
+| `lv` | Latvia |
+
+## Quick start
+
+### Async (recommended)
+
+```python
+import asyncio
+from datetime import date
+
+from isdayoff import DateType, ProdCalendar
+
+
+async def main():
+    async with ProdCalendar(locale="us") as calendar:
+        if await calendar.today() == DateType.WORKING:
+            print("Today is a working day")
+        else:
+            print("Today is a day off")
+
+
+asyncio.run(main())
+```
+
+### Sync
+
+```python
+from datetime import date
+
+from isdayoff import DateType, SyncProdCalendar
+
+
+with SyncProdCalendar(locale="us") as calendar:
+    if calendar.today() == DateType.WORKING:
+        print("Today is a working day")
+    else:
+        print("Today is a day off")
+```
+
+## API
+
+All methods are available on both `ProdCalendar` (async) and `SyncProdCalendar` (sync).
+
+### Parameters
+
+| Parameter | Type | Default | Description |
+|---|---|---|---|
+| `locale` | `str` | `"ru"` | Country code (see table above) |
+| `pre` | `bool` | `False` | Mark shortened working days |
+| `covid` | `bool` | `False` | Mark working days due to COVID-19 |
+| `sd` | `bool` | `False` | Consider 6-day work week |
+
+### Methods
+
+```python
+# Async
+await calendar.today(locale="ru", pre=True, covid=True, sd=True)
+await calendar.tomorrow()
+await calendar.date(date(2024, 8, 25))
+await calendar.month(date(2024, 8, 1))
+await calendar.year(date(2024, 1, 1))
+await calendar.range_date(date(2024, 1, 1), date(2024, 5, 1))
+calendar.is_leap(date(2024, 1, 1))
+
+# Sync
+calendar.today(locale="ru", pre=True, covid=True, sd=True)
+calendar.tomorrow()
+calendar.date(date(2024, 8, 25))
+calendar.month(date(2024, 8, 1))
+calendar.year(date(2024, 1, 1))
+calendar.range_date(date(2024, 1, 1), date(2024, 5, 1))
+calendar.is_leap(date(2024, 1, 1))
+```
+
+### Return types
+
+| Method | Returns |
+|---|---|
+| `today()` / `tomorrow()` / `date()` | `DateType` enum |
+| `month()` / `year()` / `range_date()` | `dict[str, DateType]` — ISO date → type |
+| `is_leap()` | `bool` |
+
+### DateType values
+
+| Value | Meaning |
+|---|---|
+| `DateType.WORKING` (0) | Working day |
+| `DateType.NOT_WORKING` (1) | Day off / holiday |
+| `DateType.SHORTENED` (2) | Shortened pre-holiday day |
+| `DateType.WORKING_DAY` (4) | Working day (special period) |
+
+## Full example
+
+```python
+import asyncio
+from datetime import date
+
+from isdayoff import DateType, ProdCalendar
+
+
+async def main():
+    async with ProdCalendar(locale="us") as calendar:
+        res = await calendar.month(date(2024, 8, 1), locale="ru")
+        days_off = sum(
+            1 for v in res.values() if v == DateType.NOT_WORKING
+        )
+        print(f"Days off in August 2024: {days_off}")
+
+
+asyncio.run(main())
+```
+
+## Development
+
+```bash
+# Install dependencies
+uv sync
+
+# Run tests
+uv run pytest
+
+# Build
+uv build
+```

isdayoff_api-1.0.0/isdayoff/__init__.py

@@ -0,0 +1,6 @@
+__version__ = "1.0.0"
+
+from .isdayoff import ProdCalendar, SyncProdCalendar
+from .typingapi import DateType
+
+__all__ = ["ProdCalendar", "SyncProdCalendar", "DateType", "__version__"]

isdayoff_api-1.0.0/isdayoff/isdayoff.py

@@ -0,0 +1,319 @@
+from __future__ import annotations
+
+import datetime
+from typing import Any
+
+import httpx
+
+from .typingapi import (
+    DataError,
+    DateType,
+    ProdCalendarParams,
+    ServiceNotRespond,
+)
+
+_LOCALES = ("ru", "kz", "by", "us", "uz", "tr", "lv")
+_DELIMITER = "%7C"
+_FORMAT_DATE = "%Y%m%d"
+
+
+# ── shared helpers ───────────────────────────────────────────────────────────
+
+
+def _validate_locale(locale: str) -> str:
+    if locale not in _LOCALES:
+        msg = f"locale must be one of {_LOCALES}, got {locale!r}"
+        raise ValueError(msg)
+    return locale
+
+
+def _format_result(
+    date_format: str, date: datetime.date, result: list[str]
+) -> dict[str, DateType]:
+    return {
+        (date + datetime.timedelta(days=day)).strftime(date_format): DateType(int(value))
+        for day, value in enumerate(result)
+    }
+
+
+def _build_params(locale: str, **kwargs: Any) -> dict[str, Any]:
+    params = ProdCalendarParams(**kwargs)
+    api_params = params.to_api_params()
+    api_params.setdefault("cc", locale)
+    return api_params
+
+
+# ── async client ─────────────────────────────────────────────────────────────
+
+
+class ProdCalendar:
+    """Async production calendar client using httpx.AsyncClient."""
+
+    __version__ = "1.0.0"
+
+    def __init__(
+        self,
+        locale: str = "ru",
+        base_url: str = "https://isdayoff.ru",
+        date_format: str = "%Y-%m-%d",
+    ) -> None:
+        self.date_format = date_format
+        self.locale = _validate_locale(locale)
+        self.base_url = base_url.rstrip("/")
+        self._client: httpx.AsyncClient | None = None
+
+    async def _get_client(self) -> httpx.AsyncClient:
+        if self._client is None or self._client.is_closed:
+            self._client = httpx.AsyncClient(
+                headers={
+                    "User-Agent": (
+                        f"isdayoff/{self.__version__} "
+                        "Contact: wg7831@gmail.com"
+                    )
+                },
+            )
+        return self._client
+
+    async def _get(
+        self, url: str, params: dict[str, Any] | None = None
+    ) -> str:
+        client = await self._get_client()
+        response = await client.get(self.base_url + url, params=params)
+        if response.status_code == 400:
+            raise DataError("Date error")
+        if response.status_code != 200:
+            raise ServiceNotRespond("No data found")
+        return response.text
+
+    async def _get_date_work(
+        self,
+        data: datetime.date,
+        is_day: bool = True,
+        is_month: bool = True,
+        **kwargs: Any,
+    ) -> str:
+        params = _build_params(self.locale, **kwargs)
+        params["year"] = data.year
+        if is_month:
+            params["month"] = data.month
+        if is_day:
+            params["day"] = data.day
+        if not (is_month and is_day):
+            params["delimeter"] = _DELIMITER
+        return await self._get("/api/getdata", params=params)
+
+    async def _get_range_date_work(
+        self,
+        start_date: datetime.date,
+        end_date: datetime.date,
+        **kwargs: Any,
+    ) -> str:
+        params = _build_params(self.locale, **kwargs)
+        params["date1"] = start_date.strftime(_FORMAT_DATE)
+        params["date2"] = end_date.strftime(_FORMAT_DATE)
+        params["delimeter"] = _DELIMITER
+        return await self._get("/api/getdata", params=params)
+
+    async def _get_date_as_type(
+        self, date: datetime.date, **kwargs: Any
+    ) -> DateType:
+        raw = await self._get_date_work(date, **kwargs)
+        return DateType(int(raw))
+
+    async def range_date(
+        self,
+        start_date: datetime.date,
+        end_date: datetime.date,
+        **kwargs: Any,
+    ) -> dict[str, DateType]:
+        result = (await self._get_range_date_work(start_date, end_date, **kwargs)).split(
+            _DELIMITER,
+        )
+        return _format_result(self.date_format, start_date, result)
+
+    async def month(
+        self, date: datetime.date, **kwargs: Any
+    ) -> dict[str, DateType]:
+        result = (
+            await self._get_date_work(date, is_day=False, **kwargs)
+        ).split(_DELIMITER)
+        return _format_result(
+            self.date_format, datetime.date(date.year, date.month, 1), result,
+        )
+
+    async def year(
+        self, date: datetime.date, **kwargs: Any
+    ) -> dict[str, DateType]:
+        result = (
+            await self._get_date_work(date, is_day=False, is_month=False, **kwargs)
+        ).split(_DELIMITER)
+        return _format_result(self.date_format, datetime.date(date.year, 1, 1), result)
+
+    async def date(self, date: datetime.date, **kwargs: Any) -> DateType:
+        return await self._get_date_as_type(date, **kwargs)
+
+    async def tomorrow(self, **kwargs: Any) -> DateType:
+        return await self._get_date_as_type(
+            datetime.date.today() + datetime.timedelta(days=1),
+            **kwargs,
+        )
+
+    async def today(self, **kwargs: Any) -> DateType:
+        return await self._get_date_as_type(datetime.date.today(), **kwargs)
+
+    @staticmethod
+    def is_leap(date: datetime.date) -> bool:
+        return date.year % 4 == 0 and date.year % 100 != 0 or date.year % 400 == 0
+
+    async def close(self) -> None:
+        if self._client is not None and not self._client.is_closed:
+            await self._client.aclose()
+
+    async def __aenter__(self) -> ProdCalendar:
+        await self._get_client()
+        return self
+
+    async def __aexit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_val: BaseException | None,
+        exc_tb: Any,
+    ) -> None:
+        await self.close()
+
+
+# ── sync client ──────────────────────────────────────────────────────────────
+
+
+class SyncProdCalendar:
+    """Sync production calendar client using httpx.Client."""
+
+    __version__ = "1.0.0"
+
+    def __init__(
+        self,
+        locale: str = "ru",
+        base_url: str = "https://isdayoff.ru",
+        date_format: str = "%Y-%m-%d",
+    ) -> None:
+        self.date_format = date_format
+        self.locale = _validate_locale(locale)
+        self.base_url = base_url.rstrip("/")
+        self._client: httpx.Client | None = None
+
+    def _get_client(self) -> httpx.Client:
+        if self._client is None or self._client.is_closed:
+            self._client = httpx.Client(
+                headers={
+                    "User-Agent": (
+                        f"isdayoff/{self.__version__} "
+                        "Contact: wg7831@gmail.com"
+                    )
+                },
+            )
+        return self._client
+
+    def _get(
+        self, url: str, params: dict[str, Any] | None = None
+    ) -> str:
+        client = self._get_client()
+        response = client.get(self.base_url + url, params=params)
+        if response.status_code == 400:
+            raise DataError("Date error")
+        if response.status_code != 200:
+            raise ServiceNotRespond("No data found")
+        return response.text
+
+    def _get_date_work(
+        self,
+        data: datetime.date,
+        is_day: bool = True,
+        is_month: bool = True,
+        **kwargs: Any,
+    ) -> str:
+        params = _build_params(self.locale, **kwargs)
+        params["year"] = data.year
+        if is_month:
+            params["month"] = data.month
+        if is_day:
+            params["day"] = data.day
+        if not (is_month and is_day):
+            params["delimeter"] = _DELIMITER
+        return self._get("/api/getdata", params=params)
+
+    def _get_range_date_work(
+        self,
+        start_date: datetime.date,
+        end_date: datetime.date,
+        **kwargs: Any,
+    ) -> str:
+        params = _build_params(self.locale, **kwargs)
+        params["date1"] = start_date.strftime(_FORMAT_DATE)
+        params["date2"] = end_date.strftime(_FORMAT_DATE)
+        params["delimeter"] = _DELIMITER
+        return self._get("/api/getdata", params=params)
+
+    def _get_date_as_type(
+        self, date: datetime.date, **kwargs: Any
+    ) -> DateType:
+        raw = self._get_date_work(date, **kwargs)
+        return DateType(int(raw))
+
+    def range_date(
+        self,
+        start_date: datetime.date,
+        end_date: datetime.date,
+        **kwargs: Any,
+    ) -> dict[str, DateType]:
+        result = self._get_range_date_work(start_date, end_date, **kwargs).split(
+            _DELIMITER,
+        )
+        return _format_result(self.date_format, start_date, result)
+
+    def month(
+        self, date: datetime.date, **kwargs: Any
+    ) -> dict[str, DateType]:
+        result = self._get_date_work(date, is_day=False, **kwargs).split(_DELIMITER)
+        return _format_result(
+            self.date_format, datetime.date(date.year, date.month, 1), result,
+        )
+
+    def year(
+        self, date: datetime.date, **kwargs: Any
+    ) -> dict[str, DateType]:
+        result = self._get_date_work(
+            date, is_day=False, is_month=False, **kwargs
+        ).split(_DELIMITER)
+        return _format_result(self.date_format, datetime.date(date.year, 1, 1), result)
+
+    def date(self, date: datetime.date, **kwargs: Any) -> DateType:
+        return self._get_date_as_type(date, **kwargs)
+
+    def tomorrow(self, **kwargs: Any) -> DateType:
+        return self._get_date_as_type(
+            datetime.date.today() + datetime.timedelta(days=1),
+            **kwargs,
+        )
+
+    def today(self, **kwargs: Any) -> DateType:
+        return self._get_date_as_type(datetime.date.today(), **kwargs)
+
+    @staticmethod
+    def is_leap(date: datetime.date) -> bool:
+        return date.year % 4 == 0 and date.year % 100 != 0 or date.year % 400 == 0
+
+    def close(self) -> None:
+        if self._client is not None and not self._client.is_closed:
+            self._client.close()
+
+    def __enter__(self) -> SyncProdCalendar:
+        self._get_client()
+        return self
+
+    def __exit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_val: BaseException | None,
+        exc_tb: Any,
+    ) -> None:
+        self.close()

isdayoff_api-1.0.0/isdayoff/typingapi.py

@@ -0,0 +1,54 @@
+from __future__ import annotations
+
+from enum import IntEnum
+from typing import Any
+
+from pydantic import BaseModel, field_validator
+
+
+class ServiceNotRespond(Exception):
+    """The API service did not respond or returned an unexpected status."""
+
+
+class DataError(Exception):
+    """Invalid date data passed to the API (400 Bad Request)."""
+
+
+class DateType(IntEnum):
+    WORKING = 0
+    NOT_WORKING = 1
+    SHORTENED = 2
+    WORKING_DAY = 4
+
+
+_LOCALES = ("ru", "kz", "by", "us", "uz", "tr", "lv")
+
+
+class ProdCalendarParams(BaseModel):
+    """Validated parameters for ProdCalendar API methods."""
+
+    locale: str | None = None
+    pre: bool = False
+    sd: bool = False
+    covid: bool = False
+
+    @field_validator("locale")
+    @classmethod
+    def _validate_locale(cls, v: str | None) -> str | None:
+        if v is not None and v not in _LOCALES:
+            msg = f"locale must be one of {_LOCALES}, got {v!r}"
+            raise ValueError(msg)
+        return v
+
+    def to_api_params(self) -> dict[str, Any]:
+        """Convert to API query parameters, omitting falsy bools."""
+        params: dict[str, Any] = {}
+        if self.locale is not None:
+            params["cc"] = self.locale
+        if self.pre:
+            params["pre"] = 1
+        if self.sd:
+            params["sd"] = 1
+        if self.covid:
+            params["covid"] = 1
+        return params

isdayoff_api-1.0.0/pyproject.toml

@@ -0,0 +1,45 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "isdayoff-api"
+description = "Checking the date for belonging to a non-working day, according to official decrees and orders."
+readme = "README.md"
+license = { text = "MIT" }
+requires-python = ">=3.11"
+version = "1.0.0"
+authors = [
+    { name = "Aleksandr Bevz", email = "as-bivz@yandex.ru" },
+]
+classifiers = [
+    "Development Status :: 5 - Production/Stable",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Software Development :: Libraries",
+]
+dependencies = [
+    "httpx >= 0.28",
+    "pydantic >= 2",
+]
+urls = { Homepage = "https://github.com/alexbevz/isdayoff", Source = "https://github.com/alexbevz/isdayoff" }
+
+[tool.hatch.build.targets.sdist]
+include = ["/isdayoff", "/tests"]
+
+[tool.hatch.build.targets.wheel]
+packages = ["isdayoff"]
+
+[dependency-groups]
+dev = [
+    "pytest >= 8",
+    "pytest-asyncio >= 0.24",
+]
+
+[tool.pytest.ini_options]
+asyncio_mode = "auto"
+testpaths = ["tests"]

isdayoff_api-1.0.0/tests/test_isdayoff.py

@@ -0,0 +1,327 @@
+from __future__ import annotations
+
+import datetime
+from unittest.mock import ANY, AsyncMock, patch
+
+import httpx
+import pytest
+
+from isdayoff import DateType, ProdCalendar, SyncProdCalendar
+from isdayoff.typingapi import DataError, ServiceNotRespond
+
+
+# ── fixtures ─────────────────────────────────────────────────────────────────
+
+
+@pytest.fixture
+def calendar() -> ProdCalendar:
+    return ProdCalendar(locale="ru")
+
+
+@pytest.fixture
+def sync_calendar() -> SyncProdCalendar:
+    return SyncProdCalendar(locale="ru")
+
+
+# ── helper: mock httpx response ──────────────────────────────────────────────
+
+
+def _mock_httpx_response(text: str = "0", status_code: int = 200) -> httpx.Response:
+    """Build a minimal httpx.Response with the given text/status."""
+    return httpx.Response(status_code=status_code, text=text)
+
+
+# ═══════════════════════════════════════════════════════════════════════════════
+# Async ProdCalendar tests
+# ═══════════════════════════════════════════════════════════════════════════════
+
+
+class TestProdCalendar:
+    """Async client tests."""
+
+    # ── single-date methods ──────────────────────────────────────────────
+
+    @pytest.mark.asyncio
+    async def test_today_working(self, calendar: ProdCalendar) -> None:
+        with patch.object(calendar, "_get", return_value="0"):
+            result = await calendar.today()
+        assert result == DateType.WORKING
+
+    @pytest.mark.asyncio
+    async def test_today_not_working(self, calendar: ProdCalendar) -> None:
+        with patch.object(calendar, "_get", return_value="1"):
+            result = await calendar.today()
+        assert result == DateType.NOT_WORKING
+
+    @pytest.mark.asyncio
+    async def test_today_shortened(self, calendar: ProdCalendar) -> None:
+        with patch.object(calendar, "_get", return_value="2"):
+            result = await calendar.today()
+        assert result == DateType.SHORTENED
+
+    @pytest.mark.asyncio
+    async def test_today_working_covid(self, calendar: ProdCalendar) -> None:
+        with patch.object(calendar, "_get", return_value="4"):
+            result = await calendar.today()
+        assert result == DateType.WORKING_DAY
+
+    @pytest.mark.asyncio
+    async def test_date_specific(self, calendar: ProdCalendar) -> None:
+        with patch.object(calendar, "_get", return_value="1"):
+            result = await calendar.date(datetime.date(2024, 1, 1))
+        assert result == DateType.NOT_WORKING
+
+    @pytest.mark.asyncio
+    async def test_tomorrow(self, calendar: ProdCalendar) -> None:
+        with patch.object(calendar, "_get", return_value="0"):
+            result = await calendar.tomorrow()
+        assert result == DateType.WORKING
+
+    # ── range methods ───────────────────────────────────────────────────
+
+    @pytest.mark.asyncio
+    async def test_month(self, calendar: ProdCalendar) -> None:
+        with patch.object(calendar, "_get", return_value="0%7C1%7C0%7C1%7C0%7C1%7C0"):
+            result = await calendar.month(datetime.date(2024, 1, 1))
+        assert isinstance(result, dict)
+        first_key = min(result.keys())
+        assert first_key == "2024-01-01"
+        assert result["2024-01-01"] == DateType.WORKING
+        assert result["2024-01-02"] == DateType.NOT_WORKING
+
+    @pytest.mark.asyncio
+    async def test_year(self, calendar: ProdCalendar) -> None:
+        with patch.object(calendar, "_get", return_value="0%7C0%7C0"):
+            result = await calendar.year(datetime.date(2024, 1, 1))
+        first_key = min(result.keys())
+        assert first_key == "2024-01-01"
+        assert len(result) == 3
+
+    @pytest.mark.asyncio
+    async def test_range_date(self, calendar: ProdCalendar) -> None:
+        with patch.object(calendar, "_get", return_value="0%7C1%7C0"):
+            result = await calendar.range_date(
+                datetime.date(2024, 1, 1), datetime.date(2024, 1, 3),
+            )
+        assert len(result) == 3
+        assert result["2024-01-01"] == DateType.WORKING
+        assert result["2024-01-02"] == DateType.NOT_WORKING
+
+    # ── locale ──────────────────────────────────────────────────────────
+
+    @pytest.mark.asyncio
+    async def test_locale_us_working(self) -> None:
+        cal = ProdCalendar(locale="us")
+        with patch.object(cal, "_get", return_value="0"):
+            result = await cal.today()
+        assert result == DateType.WORKING
+
+    # ── error handling ──────────────────────────────────────────────────
+
+    @pytest.mark.asyncio
+    async def test_data_error(self, calendar: ProdCalendar) -> None:
+        with patch.object(calendar, "_get", side_effect=DataError("Date error")):
+            with pytest.raises(DataError, match="Date error"):
+                await calendar.today()
+
+    @pytest.mark.asyncio
+    async def test_service_not_respond(self, calendar: ProdCalendar) -> None:
+        with patch.object(
+            calendar, "_get", side_effect=ServiceNotRespond("No data found")
+        ):
+            with pytest.raises(ServiceNotRespond, match="No data found"):
+                await calendar.today()
+
+    # ── context manager ────────────────────────────────────────────────
+
+    @pytest.mark.asyncio
+    async def test_async_context_manager(self) -> None:
+        async with ProdCalendar(locale="ru") as cal:
+            assert isinstance(cal, ProdCalendar)
+            assert cal._client is not None
+        assert cal._client.is_closed
+
+    # ── date format ─────────────────────────────────────────────────────
+
+    @pytest.mark.asyncio
+    async def test_custom_date_format(self) -> None:
+        cal = ProdCalendar(locale="ru", date_format="%d.%m.%Y")
+        with patch.object(cal, "_get", return_value="0%7C1"):
+            result = await cal.month(datetime.date(2024, 1, 1))
+        first_key = min(result.keys())
+        assert first_key == "01.01.2024"
+
+    @pytest.mark.asyncio
+    async def test_default_date_format_is_iso(self) -> None:
+        cal = ProdCalendar(locale="ru")
+        with patch.object(cal, "_get", return_value="0"):
+            result = await cal.month(datetime.date(2024, 1, 1))
+        first_key = min(result.keys())
+        assert first_key == "2024-01-01"
+
+    # ── kwargs ──────────────────────────────────────────────────────────
+
+    @pytest.mark.asyncio
+    async def test_kwargs_passed(self, calendar: ProdCalendar) -> None:
+        with patch.object(calendar, "_get", return_value="0") as mock_get:
+            result = await calendar.today(pre=True, sd=True, covid=True)
+        assert result == DateType.WORKING
+
+
+# ═══════════════════════════════════════════════════════════════════════════════
+# Sync SyncProdCalendar tests
+# ═══════════════════════════════════════════════════════════════════════════════
+
+
+class TestSyncProdCalendar:
+    """Sync client tests."""
+
+    # ── single-date methods ──────────────────────────────────────────────
+
+    def test_today_working(self, sync_calendar: SyncProdCalendar) -> None:
+        with patch.object(sync_calendar, "_get", return_value="0"):
+            result = sync_calendar.today()
+        assert result == DateType.WORKING
+
+    def test_today_not_working(self, sync_calendar: SyncProdCalendar) -> None:
+        with patch.object(sync_calendar, "_get", return_value="1"):
+            result = sync_calendar.today()
+        assert result == DateType.NOT_WORKING
+
+    def test_today_shortened(self, sync_calendar: SyncProdCalendar) -> None:
+        with patch.object(sync_calendar, "_get", return_value="2"):
+            result = sync_calendar.today()
+        assert result == DateType.SHORTENED
+
+    def test_today_working_covid(self, sync_calendar: SyncProdCalendar) -> None:
+        with patch.object(sync_calendar, "_get", return_value="4"):
+            result = sync_calendar.today()
+        assert result == DateType.WORKING_DAY
+
+    def test_date_specific(self, sync_calendar: SyncProdCalendar) -> None:
+        with patch.object(sync_calendar, "_get", return_value="1"):
+            result = sync_calendar.date(datetime.date(2024, 1, 1))
+        assert result == DateType.NOT_WORKING
+
+    def test_tomorrow(self, sync_calendar: SyncProdCalendar) -> None:
+        with patch.object(sync_calendar, "_get", return_value="0"):
+            result = sync_calendar.tomorrow()
+        assert result == DateType.WORKING
+
+    # ── range methods ───────────────────────────────────────────────────
+
+    def test_month(self, sync_calendar: SyncProdCalendar) -> None:
+        with patch.object(sync_calendar, "_get", return_value="0%7C1%7C0%7C1%7C0%7C1%7C0"):
+            result = sync_calendar.month(datetime.date(2024, 1, 1))
+        assert isinstance(result, dict)
+        first_key = min(result.keys())
+        assert first_key == "2024-01-01"
+        assert result["2024-01-01"] == DateType.WORKING
+        assert result["2024-01-02"] == DateType.NOT_WORKING
+
+    def test_year(self, sync_calendar: SyncProdCalendar) -> None:
+        with patch.object(sync_calendar, "_get", return_value="0%7C0%7C0"):
+            result = sync_calendar.year(datetime.date(2024, 1, 1))
+        first_key = min(result.keys())
+        assert first_key == "2024-01-01"
+        assert len(result) == 3
+
+    def test_range_date(self, sync_calendar: SyncProdCalendar) -> None:
+        with patch.object(sync_calendar, "_get", return_value="0%7C1%7C0"):
+            result = sync_calendar.range_date(
+                datetime.date(2024, 1, 1), datetime.date(2024, 1, 3),
+            )
+        assert len(result) == 3
+        assert result["2024-01-01"] == DateType.WORKING
+        assert result["2024-01-02"] == DateType.NOT_WORKING
+
+    # ── locale ──────────────────────────────────────────────────────────
+
+    def test_locale_us_working(self) -> None:
+        cal = SyncProdCalendar(locale="us")
+        with patch.object(cal, "_get", return_value="0"):
+            result = cal.today()
+        assert result == DateType.WORKING
+
+    # ── error handling ──────────────────────────────────────────────────
+
+    def test_data_error(self, sync_calendar: SyncProdCalendar) -> None:
+        with patch.object(
+            sync_calendar, "_get", side_effect=DataError("Date error")
+        ):
+            with pytest.raises(DataError, match="Date error"):
+                sync_calendar.today()
+
+    def test_service_not_respond(self, sync_calendar: SyncProdCalendar) -> None:
+        with patch.object(
+            sync_calendar, "_get", side_effect=ServiceNotRespond("No data found")
+        ):
+            with pytest.raises(ServiceNotRespond, match="No data found"):
+                sync_calendar.today()
+
+    # ── context manager ────────────────────────────────────────────────
+
+    def test_sync_context_manager(self) -> None:
+        with SyncProdCalendar(locale="ru") as cal:
+            assert isinstance(cal, SyncProdCalendar)
+            assert cal._client is not None
+        assert cal._client.is_closed
+
+    # ── date format ─────────────────────────────────────────────────────
+
+    def test_custom_date_format(self) -> None:
+        cal = SyncProdCalendar(locale="ru", date_format="%d.%m.%Y")
+        with patch.object(cal, "_get", return_value="0%7C1"):
+            result = cal.month(datetime.date(2024, 1, 1))
+        first_key = min(result.keys())
+        assert first_key == "01.01.2024"
+
+    def test_default_date_format_is_iso(self) -> None:
+        cal = SyncProdCalendar(locale="ru")
+        with patch.object(cal, "_get", return_value="0"):
+            result = cal.month(datetime.date(2024, 1, 1))
+        first_key = min(result.keys())
+        assert first_key == "2024-01-01"
+
+    # ── kwargs ──────────────────────────────────────────────────────────
+
+    def test_kwargs_passed(self, sync_calendar: SyncProdCalendar) -> None:
+        with patch.object(sync_calendar, "_get", return_value="0") as mock_get:
+            result = sync_calendar.today(pre=True, sd=True, covid=True)
+        assert result == DateType.WORKING
+
+
+# ═══════════════════════════════════════════════════════════════════════════════
+# Shared tests (both clients)
+# ═══════════════════════════════════════════════════════════════════════════════
+
+
+class TestCommon:
+    """Tests that apply to both sync and async clients."""
+
+    def test_invalid_locale(self) -> None:
+        with pytest.raises(ValueError, match="locale must be one of"):
+            ProdCalendar(locale="fr")
+        with pytest.raises(ValueError, match="locale must be one of"):
+            SyncProdCalendar(locale="fr")
+
+    @pytest.mark.parametrize(
+        ("year", "expected"),
+        [
+            (2020, True),
+            (2021, False),
+            (1900, False),
+            (2000, True),
+            (2024, True),
+            (2025, False),
+        ],
+    )
+    def test_is_leap(self, year: int, expected: bool) -> None:
+        assert ProdCalendar.is_leap(datetime.date(year, 1, 1)) is expected
+        assert SyncProdCalendar.is_leap(datetime.date(year, 1, 1)) is expected
+
+    def test_locale_is_valid_in_constructor(self) -> None:
+        cal = ProdCalendar(locale="tr")
+        assert cal.locale == "tr"
+        cal2 = SyncProdCalendar(locale="uz")
+        assert cal2.locale == "uz"