mywebapi-sdk 0.3.0__py3-none-any.whl

cplugin_webapi_sdk/_generated/models/mt4_symbol_day_sessions.py

@@ -0,0 +1,171 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, TypeVar, BinaryIO, TextIO, TYPE_CHECKING, Generator
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..types import UNSET, Unset
+
+from ..types import UNSET, Unset
+from typing import cast
+
+if TYPE_CHECKING:
+  from ..models.mt4_symbol_session import MT4SymbolSession
+
+
+
+
+
+T = TypeVar("T", bound="MT4SymbolDaySessions")
+
+
+
+@_attrs_define
+class MT4SymbolDaySessions:
+    """ v2 DTO bundling the Quote and Trade sessions for one weekday on a symbol.
+    `DayOfWeek` follows the .NET convention: 0=Sunday, 1=Monday, ..., 6=Saturday.
+
+        Attributes:
+            day_of_week (int | Unset): Day of week: 0=Sunday ... 6=Saturday (.NET DayOfWeek numeric)
+            quote_overnight (int | Unset): Whether quote sessions roll over midnight
+            trade_overnight (int | Unset): Whether trade sessions roll over midnight
+            quote (list[MT4SymbolSession] | None | Unset): Up to three quote (price) session windows for the day
+            trade (list[MT4SymbolSession] | None | Unset): Up to three trade (order acceptance) session windows for the day
+     """
+
+    day_of_week: int | Unset = UNSET
+    quote_overnight: int | Unset = UNSET
+    trade_overnight: int | Unset = UNSET
+    quote: list[MT4SymbolSession] | None | Unset = UNSET
+    trade: list[MT4SymbolSession] | None | Unset = UNSET
+
+
+
+
+
+    def to_dict(self) -> dict[str, Any]:
+        from ..models.mt4_symbol_session import MT4SymbolSession
+        day_of_week = self.day_of_week
+
+        quote_overnight = self.quote_overnight
+
+        trade_overnight = self.trade_overnight
+
+        quote: list[dict[str, Any]] | None | Unset
+        if isinstance(self.quote, Unset):
+            quote = UNSET
+        elif isinstance(self.quote, list):
+            quote = []
+            for quote_type_0_item_data in self.quote:
+                quote_type_0_item = quote_type_0_item_data.to_dict()
+                quote.append(quote_type_0_item)
+
+
+        else:
+            quote = self.quote
+
+        trade: list[dict[str, Any]] | None | Unset
+        if isinstance(self.trade, Unset):
+            trade = UNSET
+        elif isinstance(self.trade, list):
+            trade = []
+            for trade_type_0_item_data in self.trade:
+                trade_type_0_item = trade_type_0_item_data.to_dict()
+                trade.append(trade_type_0_item)
+
+
+        else:
+            trade = self.trade
+
+
+        field_dict: dict[str, Any] = {}
+
+        field_dict.update({
+        })
+        if day_of_week is not UNSET:
+            field_dict["dayOfWeek"] = day_of_week
+        if quote_overnight is not UNSET:
+            field_dict["quoteOvernight"] = quote_overnight
+        if trade_overnight is not UNSET:
+            field_dict["tradeOvernight"] = trade_overnight
+        if quote is not UNSET:
+            field_dict["quote"] = quote
+        if trade is not UNSET:
+            field_dict["trade"] = trade
+
+        return field_dict
+
+
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.mt4_symbol_session import MT4SymbolSession
+        d = dict(src_dict)
+        day_of_week = d.pop("dayOfWeek", UNSET)
+
+        quote_overnight = d.pop("quoteOvernight", UNSET)
+
+        trade_overnight = d.pop("tradeOvernight", UNSET)
+
+        def _parse_quote(data: object) -> list[MT4SymbolSession] | None | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            try:
+                if not isinstance(data, list):
+                    raise TypeError()
+                quote_type_0 = []
+                _quote_type_0 = data
+                for quote_type_0_item_data in (_quote_type_0):
+                    quote_type_0_item = MT4SymbolSession.from_dict(quote_type_0_item_data)
+
+
+
+                    quote_type_0.append(quote_type_0_item)
+
+                return quote_type_0
+            except (TypeError, ValueError, AttributeError, KeyError):
+                pass
+            return cast(list[MT4SymbolSession] | None | Unset, data)
+
+        quote = _parse_quote(d.pop("quote", UNSET))
+
+
+        def _parse_trade(data: object) -> list[MT4SymbolSession] | None | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            try:
+                if not isinstance(data, list):
+                    raise TypeError()
+                trade_type_0 = []
+                _trade_type_0 = data
+                for trade_type_0_item_data in (_trade_type_0):
+                    trade_type_0_item = MT4SymbolSession.from_dict(trade_type_0_item_data)
+
+
+
+                    trade_type_0.append(trade_type_0_item)
+
+                return trade_type_0
+            except (TypeError, ValueError, AttributeError, KeyError):
+                pass
+            return cast(list[MT4SymbolSession] | None | Unset, data)
+
+        trade = _parse_trade(d.pop("trade", UNSET))
+
+
+        mt4_symbol_day_sessions = cls(
+            day_of_week=day_of_week,
+            quote_overnight=quote_overnight,
+            trade_overnight=trade_overnight,
+            quote=quote,
+            trade=trade,
+        )
+
+        return mt4_symbol_day_sessions
+

cplugin_webapi_sdk/_generated/models/mt4_symbol_day_sessions_list_api_response.py

@@ -0,0 +1,180 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, TypeVar, BinaryIO, TextIO, TYPE_CHECKING, Generator
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..types import UNSET, Unset
+
+from ..types import UNSET, Unset
+from typing import cast
+
+if TYPE_CHECKING:
+  from ..models.api_error import ApiError
+  from ..models.api_meta import ApiMeta
+  from ..models.mt4_symbol_day_sessions import MT4SymbolDaySessions
+
+
+
+
+
+T = TypeVar("T", bound="MT4SymbolDaySessionsListApiResponse")
+
+
+
+@_attrs_define
+class MT4SymbolDaySessionsListApiResponse:
+    """ Unified v2 response envelope: data is the payload (null on error); error is the
+    error object (null on success, always serialised); meta contains response metadata
+    (activityId and optional paging). HTTP status is always 200.
+
+        Attributes:
+            data (list[MT4SymbolDaySessions] | None | Unset):
+            error (ApiError | None | Unset): v2 error body. Code is the stable transport error code; ManagerCode is the raw
+                MT4
+                ResultCode (serialized as a string for a known enum member, or as a number for an
+                unrecognised value returned by MT4); Message is a human-readable description.
+            meta (ApiMeta | None | Unset): Response metadata. ActivityId is the W3C trace-id for correlation in Seq/SigNoz.
+                Paging is present only on paginated list responses; otherwise it is omitted —
+                the global JSON context policy serialises null fields, so we override that here
+                with System.Text.Json.Serialization.JsonIgnoreCondition.WhenWritingNull.
+     """
+
+    data: list[MT4SymbolDaySessions] | None | Unset = UNSET
+    error: ApiError | None | Unset = UNSET
+    meta: ApiMeta | None | Unset = UNSET
+
+
+
+
+
+    def to_dict(self) -> dict[str, Any]:
+        from ..models.api_error import ApiError
+        from ..models.api_meta import ApiMeta
+        from ..models.mt4_symbol_day_sessions import MT4SymbolDaySessions
+        data: list[dict[str, Any]] | None | Unset
+        if isinstance(self.data, Unset):
+            data = UNSET
+        elif isinstance(self.data, list):
+            data = []
+            for data_type_0_item_data in self.data:
+                data_type_0_item = data_type_0_item_data.to_dict()
+                data.append(data_type_0_item)
+
+
+        else:
+            data = self.data
+
+        error: dict[str, Any] | None | Unset
+        if isinstance(self.error, Unset):
+            error = UNSET
+        elif isinstance(self.error, ApiError):
+            error = self.error.to_dict()
+        else:
+            error = self.error
+
+        meta: dict[str, Any] | None | Unset
+        if isinstance(self.meta, Unset):
+            meta = UNSET
+        elif isinstance(self.meta, ApiMeta):
+            meta = self.meta.to_dict()
+        else:
+            meta = self.meta
+
+
+        field_dict: dict[str, Any] = {}
+
+        field_dict.update({
+        })
+        if data is not UNSET:
+            field_dict["data"] = data
+        if error is not UNSET:
+            field_dict["error"] = error
+        if meta is not UNSET:
+            field_dict["meta"] = meta
+
+        return field_dict
+
+
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.api_error import ApiError
+        from ..models.api_meta import ApiMeta
+        from ..models.mt4_symbol_day_sessions import MT4SymbolDaySessions
+        d = dict(src_dict)
+        def _parse_data(data: object) -> list[MT4SymbolDaySessions] | None | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            try:
+                if not isinstance(data, list):
+                    raise TypeError()
+                data_type_0 = []
+                _data_type_0 = data
+                for data_type_0_item_data in (_data_type_0):
+                    data_type_0_item = MT4SymbolDaySessions.from_dict(data_type_0_item_data)
+
+
+
+                    data_type_0.append(data_type_0_item)
+
+                return data_type_0
+            except (TypeError, ValueError, AttributeError, KeyError):
+                pass
+            return cast(list[MT4SymbolDaySessions] | None | Unset, data)
+
+        data = _parse_data(d.pop("data", UNSET))
+
+
+        def _parse_error(data: object) -> ApiError | None | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            try:
+                if not isinstance(data, dict):
+                    raise TypeError()
+                error_type_1 = ApiError.from_dict(data)
+
+
+
+                return error_type_1
+            except (TypeError, ValueError, AttributeError, KeyError):
+                pass
+            return cast(ApiError | None | Unset, data)
+
+        error = _parse_error(d.pop("error", UNSET))
+
+
+        def _parse_meta(data: object) -> ApiMeta | None | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            try:
+                if not isinstance(data, dict):
+                    raise TypeError()
+                meta_type_1 = ApiMeta.from_dict(data)
+
+
+
+                return meta_type_1
+            except (TypeError, ValueError, AttributeError, KeyError):
+                pass
+            return cast(ApiMeta | None | Unset, data)
+
+        meta = _parse_meta(d.pop("meta", UNSET))
+
+
+        mt4_symbol_day_sessions_list_api_response = cls(
+            data=data,
+            error=error,
+            meta=meta,
+        )
+
+        return mt4_symbol_day_sessions_list_api_response
+

cplugin_webapi_sdk/_generated/models/mt4_symbol_group.py

@@ -0,0 +1,99 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, TypeVar, BinaryIO, TextIO, TYPE_CHECKING, Generator
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..types import UNSET, Unset
+
+from ..types import UNSET, Unset
+from typing import cast
+
+
+
+
+
+
+T = TypeVar("T", bound="MT4SymbolGroup")
+
+
+
+@_attrs_define
+class MT4SymbolGroup:
+    """ v2 DTO describing a single MT4 symbol group (security category).
+    Mirrors the wrapper's ConSymbolGroup — which only carries Name and
+    Description as fixed-size ANSI fields. There is no ProfitCurrency on
+    the MT4-side group struct (that lives on per-symbol settings, not on
+    the group level), so the DTO faithfully exposes only what exists.
+
+        Attributes:
+            name (None | str | Unset): Group name (e.g. "Forex", "CFD", "Metals")
+            description (None | str | Unset): Human-readable description of the group
+     """
+
+    name: None | str | Unset = UNSET
+    description: None | str | Unset = UNSET
+
+
+
+
+
+    def to_dict(self) -> dict[str, Any]:
+        name: None | str | Unset
+        if isinstance(self.name, Unset):
+            name = UNSET
+        else:
+            name = self.name
+
+        description: None | str | Unset
+        if isinstance(self.description, Unset):
+            description = UNSET
+        else:
+            description = self.description
+
+
+        field_dict: dict[str, Any] = {}
+
+        field_dict.update({
+        })
+        if name is not UNSET:
+            field_dict["name"] = name
+        if description is not UNSET:
+            field_dict["description"] = description
+
+        return field_dict
+
+
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        def _parse_name(data: object) -> None | str | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(None | str | Unset, data)
+
+        name = _parse_name(d.pop("name", UNSET))
+
+
+        def _parse_description(data: object) -> None | str | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(None | str | Unset, data)
+
+        description = _parse_description(d.pop("description", UNSET))
+
+
+        mt4_symbol_group = cls(
+            name=name,
+            description=description,
+        )
+
+        return mt4_symbol_group
+

cplugin_webapi_sdk/_generated/models/mt4_symbol_group_api_response.py

@@ -0,0 +1,174 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, TypeVar, BinaryIO, TextIO, TYPE_CHECKING, Generator
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..types import UNSET, Unset
+
+from ..types import UNSET, Unset
+from typing import cast
+
+if TYPE_CHECKING:
+  from ..models.api_error import ApiError
+  from ..models.api_meta import ApiMeta
+  from ..models.mt4_symbol_group import MT4SymbolGroup
+
+
+
+
+
+T = TypeVar("T", bound="MT4SymbolGroupApiResponse")
+
+
+
+@_attrs_define
+class MT4SymbolGroupApiResponse:
+    """ Unified v2 response envelope: data is the payload (null on error); error is the
+    error object (null on success, always serialised); meta contains response metadata
+    (activityId and optional paging). HTTP status is always 200.
+
+        Attributes:
+            data (MT4SymbolGroup | None | Unset): v2 DTO describing a single MT4 symbol group (security category).
+                Mirrors the wrapper's ConSymbolGroup — which only carries Name and
+                Description as fixed-size ANSI fields. There is no ProfitCurrency on
+                the MT4-side group struct (that lives on per-symbol settings, not on
+                the group level), so the DTO faithfully exposes only what exists.
+            error (ApiError | None | Unset): v2 error body. Code is the stable transport error code; ManagerCode is the raw
+                MT4
+                ResultCode (serialized as a string for a known enum member, or as a number for an
+                unrecognised value returned by MT4); Message is a human-readable description.
+            meta (ApiMeta | None | Unset): Response metadata. ActivityId is the W3C trace-id for correlation in Seq/SigNoz.
+                Paging is present only on paginated list responses; otherwise it is omitted —
+                the global JSON context policy serialises null fields, so we override that here
+                with System.Text.Json.Serialization.JsonIgnoreCondition.WhenWritingNull.
+     """
+
+    data: MT4SymbolGroup | None | Unset = UNSET
+    error: ApiError | None | Unset = UNSET
+    meta: ApiMeta | None | Unset = UNSET
+
+
+
+
+
+    def to_dict(self) -> dict[str, Any]:
+        from ..models.api_error import ApiError
+        from ..models.api_meta import ApiMeta
+        from ..models.mt4_symbol_group import MT4SymbolGroup
+        data: dict[str, Any] | None | Unset
+        if isinstance(self.data, Unset):
+            data = UNSET
+        elif isinstance(self.data, MT4SymbolGroup):
+            data = self.data.to_dict()
+        else:
+            data = self.data
+
+        error: dict[str, Any] | None | Unset
+        if isinstance(self.error, Unset):
+            error = UNSET
+        elif isinstance(self.error, ApiError):
+            error = self.error.to_dict()
+        else:
+            error = self.error
+
+        meta: dict[str, Any] | None | Unset
+        if isinstance(self.meta, Unset):
+            meta = UNSET
+        elif isinstance(self.meta, ApiMeta):
+            meta = self.meta.to_dict()
+        else:
+            meta = self.meta
+
+
+        field_dict: dict[str, Any] = {}
+
+        field_dict.update({
+        })
+        if data is not UNSET:
+            field_dict["data"] = data
+        if error is not UNSET:
+            field_dict["error"] = error
+        if meta is not UNSET:
+            field_dict["meta"] = meta
+
+        return field_dict
+
+
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.api_error import ApiError
+        from ..models.api_meta import ApiMeta
+        from ..models.mt4_symbol_group import MT4SymbolGroup
+        d = dict(src_dict)
+        def _parse_data(data: object) -> MT4SymbolGroup | None | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            try:
+                if not isinstance(data, dict):
+                    raise TypeError()
+                data_type_1 = MT4SymbolGroup.from_dict(data)
+
+
+
+                return data_type_1
+            except (TypeError, ValueError, AttributeError, KeyError):
+                pass
+            return cast(MT4SymbolGroup | None | Unset, data)
+
+        data = _parse_data(d.pop("data", UNSET))
+
+
+        def _parse_error(data: object) -> ApiError | None | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            try:
+                if not isinstance(data, dict):
+                    raise TypeError()
+                error_type_1 = ApiError.from_dict(data)
+
+
+
+                return error_type_1
+            except (TypeError, ValueError, AttributeError, KeyError):
+                pass
+            return cast(ApiError | None | Unset, data)
+
+        error = _parse_error(d.pop("error", UNSET))
+
+
+        def _parse_meta(data: object) -> ApiMeta | None | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            try:
+                if not isinstance(data, dict):
+                    raise TypeError()
+                meta_type_1 = ApiMeta.from_dict(data)
+
+
+
+                return meta_type_1
+            except (TypeError, ValueError, AttributeError, KeyError):
+                pass
+            return cast(ApiMeta | None | Unset, data)
+
+        meta = _parse_meta(d.pop("meta", UNSET))
+
+
+        mt4_symbol_group_api_response = cls(
+            data=data,
+            error=error,
+            meta=meta,
+        )
+
+        return mt4_symbol_group_api_response
+