SymfWebAPI 1.26.10.1__tar.gz → 2.1.26.20__tar.gz

symfwebapi-2.1.26.20/PKG-INFO

@@ -0,0 +1,179 @@
+Metadata-Version: 2.4
+Name: SymfWebAPI
+Version: 2.1.26.20
+Summary: Python client for Symfonia WebAPI (sync + threading).
+Author: Maciej Pondo
+Maintainer: Maciej Pondo
+License-Expression: BSD-3-Clause
+Project-URL: Homepage, https://github.com/maku2903/symf-webapi-py
+Project-URL: Repository, https://github.com/maku2903/symf-webapi-py
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: httpx<0.29,>=0.27
+Requires-Dist: pydantic<3.0,>=2.6
+Provides-Extra: dev
+Requires-Dist: pytest<9.0,>=8.0; extra == "dev"
+Requires-Dist: ruff<0.5,>=0.3.0; extra == "dev"
+Requires-Dist: build<2.0,>=1.2; extra == "dev"
+Dynamic: license-file
+
+# SymfWebAPI
+
+[![CI](https://github.com/maku2903/symf-webapi-py/actions/workflows/public-ci-release.yml/badge.svg)](https://github.com/maku2903/symf-webapi-py/actions/workflows/public-ci-release.yml)
+[![PyPI version](https://img.shields.io/pypi/v/SymfWebAPI.svg)](https://pypi.org/project/SymfWebAPI/)
+[![Python versions](https://img.shields.io/pypi/pyversions/SymfWebAPI.svg)](https://pypi.org/project/SymfWebAPI/)
+[![License](https://img.shields.io/pypi/l/SymfWebAPI.svg)](https://github.com/maku2903/symf-webapi-py/blob/main/LICENSE)
+
+Pythonowa biblioteka kliencka do Symfonia WebAPI w architekturze sync-first: z typowanymi modelami, dostępnymi kontrolerami, wsparciem dla threading i opcjonalnym trybem JSON-only.
+
+## Instalacja
+
+```bash
+pip install SymfWebAPI
+```
+
+## Szybki start
+
+```python
+from SymfWebAPI import ClientConfig, WebAPI, build_sync_client
+
+config = ClientConfig(
+    domain="host:9000",
+    application_key="00000000-0000-0000-0000-000000000000",
+    device_name="integration-client",
+)
+
+with build_sync_client(config) as api:
+    resp = WebAPI.Interface.Products.Interfaces.IProductsController.Get(
+        api,
+        salePrices=False,
+    )
+    products = resp.unwrap()
+    print(len(products))
+```
+
+## Tryb JSON-only
+
+Biblioteka wspiera oficjalny tryb pracy bez mapowania do modeli Pydantic.
+
+Masz dwie ścieżki:
+- niskopoziomową: `api.request_json(...)` albo `envelope.json()`,
+- dostępne metody kontrolerów z flagą `validate=False`.
+
+To jest przydatne, gdy:
+- integrujesz się z niestabilnymi lub nieidealnymi danymi produkcyjnymi,
+- chcesz szybko zdiagnozować payload z WebAPI,
+- robisz migracje i chcesz odczytać tylko kilka pól bez kosztu walidacji Pydantic,
+- benchmarkujesz lub przetwarzasz duże listy rekordów.
+
+Przy `validate=False` dostępne metody nadal zachowują podpowiedzi IDE dla kształtu JSON przez stuby `.pyi`.
+
+Tryb `validate=False` działa spójnie po obu stronach:
+- response side: omija walidację odpowiedzi i zwraca surowy JSON,
+- request side: dla endpointów z body pozwala wysłać surowy `dict` / `list` / JSON-serializable payload bez modelu Pydantic.
+
+Przy `validate=True` endpointy z modelowym body nadal oczekują modelu Pydantic.
+
+Najwygodniejsza ścieżka w aktualnej bibliotece to wywołanie dostępnej metody kontrolera z `validate=False`.
+
+Przykład z dostępną metodą kontrolera:
+
+```python
+from SymfWebAPI import ClientConfig, WebAPI, build_sync_client
+
+config = ClientConfig(
+    domain="host:9000",
+    application_key="00000000-0000-0000-0000-000000000000",
+    device_name="json-only-client",
+)
+
+with build_sync_client(config) as api:
+    resp = WebAPI.Interface.Products.Interfaces.IProductsController.GetPagedDocument(
+        api,
+        page=1,
+        size=10,
+        orderBy=WebAPI.Interface.Enums.enumOrderByType.Asc,
+        validate=False,
+    )
+    page = resp.unwrap()
+    print(page["Data"][0]["Code"])
+```
+
+Przykład niskopoziomowy:
+
+```python
+with build_sync_client(config) as api:
+    products = api.request_json(
+        "GET",
+        "/api/Products",
+        params={"salePrices": False},
+    )
+    print(len(products))
+```
+
+Przykład write-pathu bez Pydantic:
+
+```python
+with build_sync_client(config) as api:
+    created = WebAPI.Interface.Products.Interfaces.IProductsController.AddNew(
+        api,
+        product={
+            "Code": "P-RAW-001",
+            "Name": "Produkt z raw JSON",
+            "Active": True,
+        },
+        validate=False,
+    ).unwrap()
+    print(created["Code"])
+```
+
+Przykład gotowego skryptu:
+- `examples/get_products_json_only.py`
+- `examples/add_product_json_only.py` (zabezpieczony przed przypadkowym write)
+
+## Dokumentacja
+
+- Omówienie biblioteki: `docs/overview.md`
+- Przykłady: `examples/`
+
+## Benchmark bez sekretów
+
+Przykład benchmarku znajduje się w:
+- `examples/benchmark_order_details.py`
+
+Przykład pracy bez modeli Pydantic:
+- `examples/get_products_json_only.py`
+- `examples/add_product_json_only.py` (write-path `validate=False`, domyślnie zablokowany)
+
+Konfiguracja przez zmienne środowiskowe:
+- `SYMFWEBAPI_DOMAIN`
+- `SYMFWEBAPI_APP_KEY`
+- `SYMFWEBAPI_DEVICE_NAME` (opcjonalnie)
+- `SYMFWEBAPI_HTTPS` (opcjonalnie, np. `true`/`false`)
+- `SYMFWEBAPI_SANITIZE_NUL` (opcjonalnie, usuwa `NUL` / `\u0000` z odpowiedzi)
+- `SYMFWEBAPI_BENCHMARK_PHYSICAL_CORES` (opcjonalnie, ręcznie ustawia liczbę fizycznych rdzeni dla benchmarku)
+
+Benchmark działa w trybach:
+- `sync`
+- `sync-raw`
+- `threading`
+- `threading-raw`
+
+Przy braku `--thread-workers-list` skrypt automatycznie dorzuca test dla liczby fizycznych rdzeni i liczby logicznych wątków, jeśli da się je rozróżnić.
+
+## Wersjonowanie
+
+Wersja paczki ma format `X.I.WM.Wm`, np. `2.0.26.10`:
+- `X` - major SDK,
+- `I` - iteracja SDK dla tej samej wersji WebAPI.
+- `WM.Wm` - docelowa wersja Symfonia WebAPI.
+
+## Wersjonowanie
+
+Wersja `2.1.26.20` używa formatu `X.I.WM.Wm`: `X` oznacza główną wersję SDK,
+`I` kolejną iterację klienta, a `WM.Wm` docelową wersję WebAPI.
+
+## Licencja BSD
+
+BSD-3-Clause.

symfwebapi-2.1.26.20/README.md

@@ -0,0 +1,159 @@
+# SymfWebAPI
+
+[![CI](https://github.com/maku2903/symf-webapi-py/actions/workflows/public-ci-release.yml/badge.svg)](https://github.com/maku2903/symf-webapi-py/actions/workflows/public-ci-release.yml)
+[![PyPI version](https://img.shields.io/pypi/v/SymfWebAPI.svg)](https://pypi.org/project/SymfWebAPI/)
+[![Python versions](https://img.shields.io/pypi/pyversions/SymfWebAPI.svg)](https://pypi.org/project/SymfWebAPI/)
+[![License](https://img.shields.io/pypi/l/SymfWebAPI.svg)](https://github.com/maku2903/symf-webapi-py/blob/main/LICENSE)
+
+Pythonowa biblioteka kliencka do Symfonia WebAPI w architekturze sync-first: z typowanymi modelami, dostępnymi kontrolerami, wsparciem dla threading i opcjonalnym trybem JSON-only.
+
+## Instalacja
+
+```bash
+pip install SymfWebAPI
+```
+
+## Szybki start
+
+```python
+from SymfWebAPI import ClientConfig, WebAPI, build_sync_client
+
+config = ClientConfig(
+    domain="host:9000",
+    application_key="00000000-0000-0000-0000-000000000000",
+    device_name="integration-client",
+)
+
+with build_sync_client(config) as api:
+    resp = WebAPI.Interface.Products.Interfaces.IProductsController.Get(
+        api,
+        salePrices=False,
+    )
+    products = resp.unwrap()
+    print(len(products))
+```
+
+## Tryb JSON-only
+
+Biblioteka wspiera oficjalny tryb pracy bez mapowania do modeli Pydantic.
+
+Masz dwie ścieżki:
+- niskopoziomową: `api.request_json(...)` albo `envelope.json()`,
+- dostępne metody kontrolerów z flagą `validate=False`.
+
+To jest przydatne, gdy:
+- integrujesz się z niestabilnymi lub nieidealnymi danymi produkcyjnymi,
+- chcesz szybko zdiagnozować payload z WebAPI,
+- robisz migracje i chcesz odczytać tylko kilka pól bez kosztu walidacji Pydantic,
+- benchmarkujesz lub przetwarzasz duże listy rekordów.
+
+Przy `validate=False` dostępne metody nadal zachowują podpowiedzi IDE dla kształtu JSON przez stuby `.pyi`.
+
+Tryb `validate=False` działa spójnie po obu stronach:
+- response side: omija walidację odpowiedzi i zwraca surowy JSON,
+- request side: dla endpointów z body pozwala wysłać surowy `dict` / `list` / JSON-serializable payload bez modelu Pydantic.
+
+Przy `validate=True` endpointy z modelowym body nadal oczekują modelu Pydantic.
+
+Najwygodniejsza ścieżka w aktualnej bibliotece to wywołanie dostępnej metody kontrolera z `validate=False`.
+
+Przykład z dostępną metodą kontrolera:
+
+```python
+from SymfWebAPI import ClientConfig, WebAPI, build_sync_client
+
+config = ClientConfig(
+    domain="host:9000",
+    application_key="00000000-0000-0000-0000-000000000000",
+    device_name="json-only-client",
+)
+
+with build_sync_client(config) as api:
+    resp = WebAPI.Interface.Products.Interfaces.IProductsController.GetPagedDocument(
+        api,
+        page=1,
+        size=10,
+        orderBy=WebAPI.Interface.Enums.enumOrderByType.Asc,
+        validate=False,
+    )
+    page = resp.unwrap()
+    print(page["Data"][0]["Code"])
+```
+
+Przykład niskopoziomowy:
+
+```python
+with build_sync_client(config) as api:
+    products = api.request_json(
+        "GET",
+        "/api/Products",
+        params={"salePrices": False},
+    )
+    print(len(products))
+```
+
+Przykład write-pathu bez Pydantic:
+
+```python
+with build_sync_client(config) as api:
+    created = WebAPI.Interface.Products.Interfaces.IProductsController.AddNew(
+        api,
+        product={
+            "Code": "P-RAW-001",
+            "Name": "Produkt z raw JSON",
+            "Active": True,
+        },
+        validate=False,
+    ).unwrap()
+    print(created["Code"])
+```
+
+Przykład gotowego skryptu:
+- `examples/get_products_json_only.py`
+- `examples/add_product_json_only.py` (zabezpieczony przed przypadkowym write)
+
+## Dokumentacja
+
+- Omówienie biblioteki: `docs/overview.md`
+- Przykłady: `examples/`
+
+## Benchmark bez sekretów
+
+Przykład benchmarku znajduje się w:
+- `examples/benchmark_order_details.py`
+
+Przykład pracy bez modeli Pydantic:
+- `examples/get_products_json_only.py`
+- `examples/add_product_json_only.py` (write-path `validate=False`, domyślnie zablokowany)
+
+Konfiguracja przez zmienne środowiskowe:
+- `SYMFWEBAPI_DOMAIN`
+- `SYMFWEBAPI_APP_KEY`
+- `SYMFWEBAPI_DEVICE_NAME` (opcjonalnie)
+- `SYMFWEBAPI_HTTPS` (opcjonalnie, np. `true`/`false`)
+- `SYMFWEBAPI_SANITIZE_NUL` (opcjonalnie, usuwa `NUL` / `\u0000` z odpowiedzi)
+- `SYMFWEBAPI_BENCHMARK_PHYSICAL_CORES` (opcjonalnie, ręcznie ustawia liczbę fizycznych rdzeni dla benchmarku)
+
+Benchmark działa w trybach:
+- `sync`
+- `sync-raw`
+- `threading`
+- `threading-raw`
+
+Przy braku `--thread-workers-list` skrypt automatycznie dorzuca test dla liczby fizycznych rdzeni i liczby logicznych wątków, jeśli da się je rozróżnić.
+
+## Wersjonowanie
+
+Wersja paczki ma format `X.I.WM.Wm`, np. `2.0.26.10`:
+- `X` - major SDK,
+- `I` - iteracja SDK dla tej samej wersji WebAPI.
+- `WM.Wm` - docelowa wersja Symfonia WebAPI.
+
+## Wersjonowanie
+
+Wersja `2.1.26.20` używa formatu `X.I.WM.Wm`: `X` oznacza główną wersję SDK,
+`I` kolejną iterację klienta, a `WM.Wm` docelową wersję WebAPI.
+
+## Licencja BSD
+
+BSD-3-Clause.

symfwebapi-2.1.26.20/SymfWebAPI/WebAPI/Interface/BankAccounts/Interfaces/IBankAccountsController/__init__.py

@@ -0,0 +1,161 @@
+from __future__ import annotations
+
+from typing import Any, List, overload
+from SymfWebAPI.operations import invoke_operation
+from SymfWebAPI.protocols import (SyncInvokerProtocol, SyncRequestProtocol)
+from SymfWebAPI.response import ResponseEnvelope
+from SymfWebAPI.WebAPI.Interface.BankAccounts.ViewModels import BankAccount
+from ._common import (
+    _prepare_Get,
+    _prepare_GetListByContractor,
+    _prepare_GetListByContractorByContractorCode,
+    _prepare_Insert,
+    _prepare_InsertByBankAccountContractorCode,
+    _prepare_Update,
+    _prepare_SetAsMain,
+)
+from ._ops import (
+    OP_Get,
+    OP_Get_RAW,
+    OP_GetListByContractor,
+    OP_GetListByContractor_RAW,
+    OP_GetListByContractorByContractorCode,
+    OP_GetListByContractorByContractorCode_RAW,
+    OP_Insert,
+    OP_Insert_RAW,
+    OP_InsertByBankAccountContractorCode,
+    OP_InsertByBankAccountContractorCode_RAW,
+    OP_Update,
+    OP_Update_RAW,
+    OP_SetAsMain,
+    OP_SetAsMain_RAW,
+)
+
+_UNSET = object()
+
+@overload
+def Get(api: SyncInvokerProtocol, id: int, *, validate: bool = True) -> ResponseEnvelope[BankAccount]: ...
+@overload
+def Get(api: SyncRequestProtocol, id: int, *, validate: bool = True) -> ResponseEnvelope[BankAccount]: ...
+def Get(api: object, id: int, *, validate: bool = True) -> ResponseEnvelope[Any]:
+    params, data = _prepare_Get(id=id)
+    return invoke_operation(api, OP_Get if validate else OP_Get_RAW, params=params, data=data)
+
+@overload
+def GetListByContractor(api: SyncInvokerProtocol, contractorId: int, *, validate: bool = True) -> ResponseEnvelope[List[BankAccount]]: ...
+@overload
+def GetListByContractor(api: SyncRequestProtocol, contractorId: int, *, validate: bool = True) -> ResponseEnvelope[List[BankAccount]]: ...
+@overload
+def GetListByContractor(api: SyncInvokerProtocol, contractorCode: str, *, validate: bool = True) -> ResponseEnvelope[List[BankAccount]]: ...
+@overload
+def GetListByContractor(api: SyncRequestProtocol, contractorCode: str, *, validate: bool = True) -> ResponseEnvelope[List[BankAccount]]: ...
+def GetListByContractor(api: object, contractorId: object = _UNSET, contractorCode: object = _UNSET, *, validate: bool = True) -> ResponseEnvelope[Any]:
+    provided_names = {
+        'contractorId' if contractorId is not _UNSET else None,
+        'contractorCode' if contractorCode is not _UNSET else None,
+    }
+    provided_names.discard(None)
+    exact_match = None
+    exact_match_name = None
+    if provided_names == {'contractorId'}:
+        if exact_match_name is not None:
+            raise TypeError("GetListByContractor(): ambiguous overload for provided arguments")
+        exact_match = 'GetListByContractor'
+        exact_match_name = 'GetListByContractor'
+    if provided_names == {'contractorCode'}:
+        if exact_match_name is not None:
+            raise TypeError("GetListByContractor(): ambiguous overload for provided arguments")
+        exact_match = 'GetListByContractorByContractorCode'
+        exact_match_name = 'GetListByContractorByContractorCode'
+    if exact_match_name is not None:
+        selected = exact_match_name
+    else:
+        candidates: list[tuple[int, int, str]] = []
+        if {'contractorId'}.issubset(provided_names) and provided_names.issubset({'contractorId'}):
+            candidates.append((1, -1, 'GetListByContractor'))
+        if {'contractorCode'}.issubset(provided_names) and provided_names.issubset({'contractorCode'}):
+            candidates.append((1, -1, 'GetListByContractorByContractorCode'))
+        if not candidates:
+            raise TypeError("GetListByContractor(): no matching overload for provided arguments")
+        candidates.sort(reverse=True)
+        best_score = candidates[0][:2]
+        best = [name for score_req, score_all, name in candidates if (score_req, score_all) == best_score]
+        if len(best) != 1:
+            raise TypeError("GetListByContractor(): ambiguous overload for provided arguments")
+        selected = best[0]
+    if selected == 'GetListByContractor':
+        params, data = _prepare_GetListByContractor(contractorId=contractorId)
+        return invoke_operation(api, OP_GetListByContractor if validate else OP_GetListByContractor_RAW, params=params, data=data)
+    if selected == 'GetListByContractorByContractorCode':
+        params, data = _prepare_GetListByContractorByContractorCode(contractorCode=contractorCode)
+        return invoke_operation(api, OP_GetListByContractorByContractorCode if validate else OP_GetListByContractorByContractorCode_RAW, params=params, data=data)
+    raise TypeError("GetListByContractor(): internal overload dispatch failure")
+
+@overload
+def Insert(api: SyncInvokerProtocol, contractorId: int, bankAccount: "BankAccount", *, validate: bool = True) -> ResponseEnvelope[BankAccount]: ...
+@overload
+def Insert(api: SyncRequestProtocol, contractorId: int, bankAccount: "BankAccount", *, validate: bool = True) -> ResponseEnvelope[BankAccount]: ...
+@overload
+def Insert(api: SyncInvokerProtocol, contractorCode: str, bankAccount: "BankAccount", *, validate: bool = True) -> ResponseEnvelope[BankAccount]: ...
+@overload
+def Insert(api: SyncRequestProtocol, contractorCode: str, bankAccount: "BankAccount", *, validate: bool = True) -> ResponseEnvelope[BankAccount]: ...
+def Insert(api: object, contractorId: object = _UNSET, bankAccount: object = _UNSET, contractorCode: object = _UNSET, *, validate: bool = True) -> ResponseEnvelope[Any]:
+    provided_names = {
+        'contractorId' if contractorId is not _UNSET else None,
+        'bankAccount' if bankAccount is not _UNSET else None,
+        'contractorCode' if contractorCode is not _UNSET else None,
+    }
+    provided_names.discard(None)
+    exact_match = None
+    exact_match_name = None
+    if provided_names == {'bankAccount', 'contractorId'}:
+        if exact_match_name is not None:
+            raise TypeError("Insert(): ambiguous overload for provided arguments")
+        exact_match = 'Insert'
+        exact_match_name = 'Insert'
+    if provided_names == {'bankAccount', 'contractorCode'}:
+        if exact_match_name is not None:
+            raise TypeError("Insert(): ambiguous overload for provided arguments")
+        exact_match = 'InsertByBankAccountContractorCode'
+        exact_match_name = 'InsertByBankAccountContractorCode'
+    if exact_match_name is not None:
+        selected = exact_match_name
+    else:
+        candidates: list[tuple[int, int, str]] = []
+        if {'bankAccount', 'contractorId'}.issubset(provided_names) and provided_names.issubset({'bankAccount', 'contractorId'}):
+            candidates.append((2, -2, 'Insert'))
+        if {'bankAccount', 'contractorCode'}.issubset(provided_names) and provided_names.issubset({'bankAccount', 'contractorCode'}):
+            candidates.append((2, -2, 'InsertByBankAccountContractorCode'))
+        if not candidates:
+            raise TypeError("Insert(): no matching overload for provided arguments")
+        candidates.sort(reverse=True)
+        best_score = candidates[0][:2]
+        best = [name for score_req, score_all, name in candidates if (score_req, score_all) == best_score]
+        if len(best) != 1:
+            raise TypeError("Insert(): ambiguous overload for provided arguments")
+        selected = best[0]
+    if selected == 'Insert':
+        params, data = _prepare_Insert(validate=validate, contractorId=contractorId, bankAccount=bankAccount)
+        return invoke_operation(api, OP_Insert if validate else OP_Insert_RAW, params=params, data=data)
+    if selected == 'InsertByBankAccountContractorCode':
+        params, data = _prepare_InsertByBankAccountContractorCode(validate=validate, contractorCode=contractorCode, bankAccount=bankAccount)
+        return invoke_operation(api, OP_InsertByBankAccountContractorCode if validate else OP_InsertByBankAccountContractorCode_RAW, params=params, data=data)
+    raise TypeError("Insert(): internal overload dispatch failure")
+
+@overload
+def Update(api: SyncInvokerProtocol, bankAccount: "BankAccount", *, validate: bool = True) -> ResponseEnvelope[None]: ...
+@overload
+def Update(api: SyncRequestProtocol, bankAccount: "BankAccount", *, validate: bool = True) -> ResponseEnvelope[None]: ...
+def Update(api: object, bankAccount: "BankAccount", *, validate: bool = True) -> ResponseEnvelope[Any]:
+    params, data = _prepare_Update(validate=validate, bankAccount=bankAccount)
+    return invoke_operation(api, OP_Update if validate else OP_Update_RAW, params=params, data=data)
+
+@overload
+def SetAsMain(api: SyncInvokerProtocol, id: int, *, validate: bool = True) -> ResponseEnvelope[None]: ...
+@overload
+def SetAsMain(api: SyncRequestProtocol, id: int, *, validate: bool = True) -> ResponseEnvelope[None]: ...
+def SetAsMain(api: object, id: int, *, validate: bool = True) -> ResponseEnvelope[Any]:
+    params, data = _prepare_SetAsMain(id=id)
+    return invoke_operation(api, OP_SetAsMain if validate else OP_SetAsMain_RAW, params=params, data=data)
+
+__all__ = ["Get", "GetListByContractor", "Insert", "Update", "SetAsMain"]

symfwebapi-2.1.26.20/SymfWebAPI/WebAPI/Interface/BankAccounts/Interfaces/IBankAccountsController/__init__.pyi

@@ -0,0 +1,97 @@
+from __future__ import annotations
+
+from typing import Any, List, Literal, overload
+from SymfWebAPI.client import SyncAPI
+from SymfWebAPI.protocols import (SyncInvokerProtocol, SyncRequestProtocol)
+from SymfWebAPI.response import ResponseEnvelope
+from SymfWebAPI.WebAPI.Interface.BankAccounts.ViewModels import BankAccount
+from .json_types import BankAccountJSON
+
+@overload
+def Get(api: SyncAPI, id: int, *, validate: Literal[True] = True) -> ResponseEnvelope[BankAccount]: ...
+@overload
+def Get(api: SyncAPI, id: int, *, validate: Literal[False]) -> ResponseEnvelope[BankAccountJSON]: ...
+@overload
+def Get(api: SyncInvokerProtocol, id: int, *, validate: Literal[True] = True) -> ResponseEnvelope[BankAccount]: ...
+@overload
+def Get(api: SyncInvokerProtocol, id: int, *, validate: Literal[False]) -> ResponseEnvelope[BankAccountJSON]: ...
+@overload
+def Get(api: SyncRequestProtocol, id: int, *, validate: Literal[True] = True) -> ResponseEnvelope[BankAccount]: ...
+@overload
+def Get(api: SyncRequestProtocol, id: int, *, validate: Literal[False]) -> ResponseEnvelope[BankAccountJSON]: ...
+
+@overload
+def GetListByContractor(api: SyncAPI, contractorId: int, *, validate: Literal[True] = True) -> ResponseEnvelope[List[BankAccount]]: ...
+@overload
+def GetListByContractor(api: SyncAPI, contractorId: int, *, validate: Literal[False]) -> ResponseEnvelope[list[BankAccountJSON]]: ...
+@overload
+def GetListByContractor(api: SyncInvokerProtocol, contractorId: int, *, validate: Literal[True] = True) -> ResponseEnvelope[List[BankAccount]]: ...
+@overload
+def GetListByContractor(api: SyncInvokerProtocol, contractorId: int, *, validate: Literal[False]) -> ResponseEnvelope[list[BankAccountJSON]]: ...
+@overload
+def GetListByContractor(api: SyncRequestProtocol, contractorId: int, *, validate: Literal[True] = True) -> ResponseEnvelope[List[BankAccount]]: ...
+@overload
+def GetListByContractor(api: SyncRequestProtocol, contractorId: int, *, validate: Literal[False]) -> ResponseEnvelope[list[BankAccountJSON]]: ...
+@overload
+def GetListByContractor(api: SyncAPI, contractorCode: str, *, validate: Literal[True] = True) -> ResponseEnvelope[List[BankAccount]]: ...
+@overload
+def GetListByContractor(api: SyncAPI, contractorCode: str, *, validate: Literal[False]) -> ResponseEnvelope[list[BankAccountJSON]]: ...
+@overload
+def GetListByContractor(api: SyncInvokerProtocol, contractorCode: str, *, validate: Literal[True] = True) -> ResponseEnvelope[List[BankAccount]]: ...
+@overload
+def GetListByContractor(api: SyncInvokerProtocol, contractorCode: str, *, validate: Literal[False]) -> ResponseEnvelope[list[BankAccountJSON]]: ...
+@overload
+def GetListByContractor(api: SyncRequestProtocol, contractorCode: str, *, validate: Literal[True] = True) -> ResponseEnvelope[List[BankAccount]]: ...
+@overload
+def GetListByContractor(api: SyncRequestProtocol, contractorCode: str, *, validate: Literal[False]) -> ResponseEnvelope[list[BankAccountJSON]]: ...
+
+@overload
+def Insert(api: SyncAPI, contractorId: int, bankAccount: "BankAccount", *, validate: Literal[True] = True) -> ResponseEnvelope[BankAccount]: ...
+@overload
+def Insert(api: SyncAPI, contractorId: int, bankAccount: Any, *, validate: Literal[False]) -> ResponseEnvelope[BankAccountJSON]: ...
+@overload
+def Insert(api: SyncInvokerProtocol, contractorId: int, bankAccount: "BankAccount", *, validate: Literal[True] = True) -> ResponseEnvelope[BankAccount]: ...
+@overload
+def Insert(api: SyncInvokerProtocol, contractorId: int, bankAccount: Any, *, validate: Literal[False]) -> ResponseEnvelope[BankAccountJSON]: ...
+@overload
+def Insert(api: SyncRequestProtocol, contractorId: int, bankAccount: "BankAccount", *, validate: Literal[True] = True) -> ResponseEnvelope[BankAccount]: ...
+@overload
+def Insert(api: SyncRequestProtocol, contractorId: int, bankAccount: Any, *, validate: Literal[False]) -> ResponseEnvelope[BankAccountJSON]: ...
+@overload
+def Insert(api: SyncAPI, contractorCode: str, bankAccount: "BankAccount", *, validate: Literal[True] = True) -> ResponseEnvelope[BankAccount]: ...
+@overload
+def Insert(api: SyncAPI, contractorCode: str, bankAccount: Any, *, validate: Literal[False]) -> ResponseEnvelope[BankAccountJSON]: ...
+@overload
+def Insert(api: SyncInvokerProtocol, contractorCode: str, bankAccount: "BankAccount", *, validate: Literal[True] = True) -> ResponseEnvelope[BankAccount]: ...
+@overload
+def Insert(api: SyncInvokerProtocol, contractorCode: str, bankAccount: Any, *, validate: Literal[False]) -> ResponseEnvelope[BankAccountJSON]: ...
+@overload
+def Insert(api: SyncRequestProtocol, contractorCode: str, bankAccount: "BankAccount", *, validate: Literal[True] = True) -> ResponseEnvelope[BankAccount]: ...
+@overload
+def Insert(api: SyncRequestProtocol, contractorCode: str, bankAccount: Any, *, validate: Literal[False]) -> ResponseEnvelope[BankAccountJSON]: ...
+
+@overload
+def Update(api: SyncAPI, bankAccount: "BankAccount", *, validate: Literal[True] = True) -> ResponseEnvelope[None]: ...
+@overload
+def Update(api: SyncAPI, bankAccount: Any, *, validate: Literal[False]) -> ResponseEnvelope[None]: ...
+@overload
+def Update(api: SyncInvokerProtocol, bankAccount: "BankAccount", *, validate: Literal[True] = True) -> ResponseEnvelope[None]: ...
+@overload
+def Update(api: SyncInvokerProtocol, bankAccount: Any, *, validate: Literal[False]) -> ResponseEnvelope[None]: ...
+@overload
+def Update(api: SyncRequestProtocol, bankAccount: "BankAccount", *, validate: Literal[True] = True) -> ResponseEnvelope[None]: ...
+@overload
+def Update(api: SyncRequestProtocol, bankAccount: Any, *, validate: Literal[False]) -> ResponseEnvelope[None]: ...
+
+@overload
+def SetAsMain(api: SyncAPI, id: int, *, validate: Literal[True] = True) -> ResponseEnvelope[None]: ...
+@overload
+def SetAsMain(api: SyncAPI, id: int, *, validate: Literal[False]) -> ResponseEnvelope[None]: ...
+@overload
+def SetAsMain(api: SyncInvokerProtocol, id: int, *, validate: Literal[True] = True) -> ResponseEnvelope[None]: ...
+@overload
+def SetAsMain(api: SyncInvokerProtocol, id: int, *, validate: Literal[False]) -> ResponseEnvelope[None]: ...
+@overload
+def SetAsMain(api: SyncRequestProtocol, id: int, *, validate: Literal[True] = True) -> ResponseEnvelope[None]: ...
+@overload
+def SetAsMain(api: SyncRequestProtocol, id: int, *, validate: Literal[False]) -> ResponseEnvelope[None]: ...

symfwebapi-2.1.26.20/SymfWebAPI/WebAPI/Interface/BankAccounts/Interfaces/IBankAccountsController/_common.py

@@ -0,0 +1,46 @@
+from __future__ import annotations
+
+from typing import Any
+
+from SymfWebAPI.operations import serialize_request_body
+
+def _prepare_Get(*, id) -> tuple[dict[str, Any] | None, Any]:
+    params: dict[str, Any] = {}
+    params["id"] = id
+    data = None
+    return params or None, data
+
+def _prepare_GetListByContractor(*, contractorId) -> tuple[dict[str, Any] | None, Any]:
+    params: dict[str, Any] = {}
+    params["contractorId"] = contractorId
+    data = None
+    return params or None, data
+
+def _prepare_GetListByContractorByContractorCode(*, contractorCode) -> tuple[dict[str, Any] | None, Any]:
+    params: dict[str, Any] = {}
+    params["contractorCode"] = contractorCode
+    data = None
+    return params or None, data
+
+def _prepare_Insert(*, contractorId, bankAccount = None, validate: bool = True) -> tuple[dict[str, Any] | None, Any]:
+    params: dict[str, Any] = {}
+    params["contractorId"] = contractorId
+    data = serialize_request_body(bankAccount, prefer_model_dump=True, validate=validate, body_name='bankAccount') if bankAccount is not None else None
+    return params or None, data
+
+def _prepare_InsertByBankAccountContractorCode(*, contractorCode, bankAccount = None, validate: bool = True) -> tuple[dict[str, Any] | None, Any]:
+    params: dict[str, Any] = {}
+    params["contractorCode"] = contractorCode
+    data = serialize_request_body(bankAccount, prefer_model_dump=True, validate=validate, body_name='bankAccount') if bankAccount is not None else None
+    return params or None, data
+
+def _prepare_Update(*, bankAccount = None, validate: bool = True) -> tuple[dict[str, Any] | None, Any]:
+    params: dict[str, Any] = {}
+    data = serialize_request_body(bankAccount, prefer_model_dump=True, validate=validate, body_name='bankAccount') if bankAccount is not None else None
+    return params or None, data
+
+def _prepare_SetAsMain(*, id) -> tuple[dict[str, Any] | None, Any]:
+    params: dict[str, Any] = {}
+    params["id"] = id
+    data = None
+    return params or None, data

symfwebapi-2.1.26.20/SymfWebAPI/WebAPI/Interface/BankAccounts/Interfaces/IBankAccountsController/_ops.py

@@ -0,0 +1,32 @@
+from __future__ import annotations
+
+from typing import Any, List
+from pydantic import TypeAdapter
+from SymfWebAPI.operations import build_none_operation, build_raw_operation, build_typed_operation
+from SymfWebAPI.WebAPI.Interface.BankAccounts.ViewModels import BankAccount
+
+_ADAPTER_Get = TypeAdapter(BankAccount)
+OP_Get = build_typed_operation(method='GET', path='/api/BankAccounts', adapter=_ADAPTER_Get)
+OP_Get_RAW = build_raw_operation(method='GET', path='/api/BankAccounts')
+
+_ADAPTER_GetListByContractor = TypeAdapter(List[BankAccount])
+OP_GetListByContractor = build_typed_operation(method='GET', path='/api/BankAccounts', adapter=_ADAPTER_GetListByContractor)
+OP_GetListByContractor_RAW = build_raw_operation(method='GET', path='/api/BankAccounts')
+
+_ADAPTER_GetListByContractorByContractorCode = TypeAdapter(List[BankAccount])
+OP_GetListByContractorByContractorCode = build_typed_operation(method='GET', path='/api/BankAccounts', adapter=_ADAPTER_GetListByContractorByContractorCode)
+OP_GetListByContractorByContractorCode_RAW = build_raw_operation(method='GET', path='/api/BankAccounts')
+
+_ADAPTER_Insert = TypeAdapter(BankAccount)
+OP_Insert = build_typed_operation(method='POST', path='/api/BankAccounts/Create', adapter=_ADAPTER_Insert)
+OP_Insert_RAW = build_raw_operation(method='POST', path='/api/BankAccounts/Create')
+
+_ADAPTER_InsertByBankAccountContractorCode = TypeAdapter(BankAccount)
+OP_InsertByBankAccountContractorCode = build_typed_operation(method='POST', path='/api/BankAccounts/Create', adapter=_ADAPTER_InsertByBankAccountContractorCode)
+OP_InsertByBankAccountContractorCode_RAW = build_raw_operation(method='POST', path='/api/BankAccounts/Create')
+
+OP_Update = build_none_operation(method='PUT', path='/api/BankAccounts/Update')
+OP_Update_RAW = build_raw_operation(method='PUT', path='/api/BankAccounts/Update')
+
+OP_SetAsMain = build_none_operation(method='PATCH', path='/api/BankAccounts/SetAsMain')
+OP_SetAsMain_RAW = build_raw_operation(method='PATCH', path='/api/BankAccounts/SetAsMain')