crypticorn 2.16.0__py3-none-any.whl → 2.17.0rc2__py3-none-any.whl

crypticorn/metrics/client/api/indicators_api.py

@@ -25,6 +25,24 @@ from crypticorn.metrics.client.api_client import ApiClient, RequestSerialized
 from crypticorn.metrics.client.api_response import ApiResponse
 from crypticorn.metrics.client.rest import RESTResponseType
 
+# Import async_to_sync for sync methods
+try:
+    from asgiref.sync import async_to_sync
+
+    _HAS_ASGIREF = True
+except ImportError:
+    _HAS_ASGIREF = False
+
+    def async_to_sync(async_func):
+        """Fallback decorator that raises an error if asgiref is not available."""
+
+        def wrapper(*args, **kwargs):
+            raise ImportError(
+                "asgiref is required for sync methods. Install with: pip install asgiref"
+            )
+
+        return wrapper
+
 
 class IndicatorsApi:
     """NOTE: This class is auto generated by OpenAPI Generator
@@ -33,13 +51,189 @@ class IndicatorsApi:
     Do not edit the class manually.
     """
 
-    def __init__(self, api_client=None) -> None:
+    def __init__(self, api_client=None, is_sync: bool = False) -> None:
         if api_client is None:
             api_client = ApiClient.get_default()
         self.api_client = api_client
+        self.is_sync = is_sync
 
     @validate_call
-    async def get_ker_indicator(
+    def get_ker_indicator(
+        self,
+        symbol: Annotated[
+            StrictStr, Field(description="Symbol to fetch KER indicator for")
+        ],
+        market: Annotated[
+            Optional[MarketType], Field(description="Market. Defaults to futures.")
+        ] = None,
+        period: Annotated[
+            Optional[StrictInt], Field(description="KER indicator period")
+        ] = None,
+        timestamp: Annotated[
+            Optional[StrictInt],
+            Field(description="Timestamp for which to fetch KER indicator"),
+        ] = None,
+        _request_timeout: Union[
+            None,
+            Annotated[StrictFloat, Field(gt=0)],
+            Tuple[
+                Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]
+            ],
+        ] = None,
+        _request_auth: Optional[Dict[StrictStr, Any]] = None,
+        _content_type: Optional[StrictStr] = None,
+        _headers: Optional[Dict[StrictStr, Any]] = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+    ) -> Dict[str, object]:
+        """Get Ker Indicator
+
+        This method can work in both sync and async modes based on the is_sync flag.
+        """
+        if self.is_sync:
+            return self._get_ker_indicator_sync(
+                symbol=symbol,
+                market=market,
+                period=period,
+                timestamp=timestamp,
+                _request_timeout=_request_timeout,
+                _request_auth=_request_auth,
+                _content_type=_content_type,
+                _headers=_headers,
+                _host_index=_host_index,
+            )
+
+        else:
+            return self._get_ker_indicator_async(
+                symbol=symbol,
+                market=market,
+                period=period,
+                timestamp=timestamp,
+                _request_timeout=_request_timeout,
+                _request_auth=_request_auth,
+                _content_type=_content_type,
+                _headers=_headers,
+                _host_index=_host_index,
+            )
+
+    @validate_call
+    def get_ker_indicator_with_http_info(
+        self,
+        symbol: Annotated[
+            StrictStr, Field(description="Symbol to fetch KER indicator for")
+        ],
+        market: Annotated[
+            Optional[MarketType], Field(description="Market. Defaults to futures.")
+        ] = None,
+        period: Annotated[
+            Optional[StrictInt], Field(description="KER indicator period")
+        ] = None,
+        timestamp: Annotated[
+            Optional[StrictInt],
+            Field(description="Timestamp for which to fetch KER indicator"),
+        ] = None,
+        _request_timeout: Union[
+            None,
+            Annotated[StrictFloat, Field(gt=0)],
+            Tuple[
+                Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]
+            ],
+        ] = None,
+        _request_auth: Optional[Dict[StrictStr, Any]] = None,
+        _content_type: Optional[StrictStr] = None,
+        _headers: Optional[Dict[StrictStr, Any]] = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+    ) -> ApiResponse[Dict[str, object]]:
+        """Get Ker Indicator with HTTP info
+
+        This method can work in both sync and async modes based on the is_sync flag.
+        """
+        if self.is_sync:
+            return self._get_ker_indicator_sync_with_http_info(
+                symbol=symbol,
+                market=market,
+                period=period,
+                timestamp=timestamp,
+                _request_timeout=_request_timeout,
+                _request_auth=_request_auth,
+                _content_type=_content_type,
+                _headers=_headers,
+                _host_index=_host_index,
+            )
+
+        else:
+            return self._get_ker_indicator_async_with_http_info(
+                symbol=symbol,
+                market=market,
+                period=period,
+                timestamp=timestamp,
+                _request_timeout=_request_timeout,
+                _request_auth=_request_auth,
+                _content_type=_content_type,
+                _headers=_headers,
+                _host_index=_host_index,
+            )
+
+    @validate_call
+    def get_ker_indicator_without_preload_content(
+        self,
+        symbol: Annotated[
+            StrictStr, Field(description="Symbol to fetch KER indicator for")
+        ],
+        market: Annotated[
+            Optional[MarketType], Field(description="Market. Defaults to futures.")
+        ] = None,
+        period: Annotated[
+            Optional[StrictInt], Field(description="KER indicator period")
+        ] = None,
+        timestamp: Annotated[
+            Optional[StrictInt],
+            Field(description="Timestamp for which to fetch KER indicator"),
+        ] = None,
+        _request_timeout: Union[
+            None,
+            Annotated[StrictFloat, Field(gt=0)],
+            Tuple[
+                Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]
+            ],
+        ] = None,
+        _request_auth: Optional[Dict[StrictStr, Any]] = None,
+        _content_type: Optional[StrictStr] = None,
+        _headers: Optional[Dict[StrictStr, Any]] = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+    ) -> RESTResponseType:
+        """Get Ker Indicator without preloading content
+
+        This method can work in both sync and async modes based on the is_sync flag.
+        """
+        if self.is_sync:
+            return self._get_ker_indicator_sync_without_preload_content(
+                symbol=symbol,
+                market=market,
+                period=period,
+                timestamp=timestamp,
+                _request_timeout=_request_timeout,
+                _request_auth=_request_auth,
+                _content_type=_content_type,
+                _headers=_headers,
+                _host_index=_host_index,
+            )
+
+        else:
+            return self._get_ker_indicator_async_without_preload_content(
+                symbol=symbol,
+                market=market,
+                period=period,
+                timestamp=timestamp,
+                _request_timeout=_request_timeout,
+                _request_auth=_request_auth,
+                _content_type=_content_type,
+                _headers=_headers,
+                _host_index=_host_index,
+            )
+
+    # Private async implementation methods
+    @validate_call
+    async def _get_ker_indicator_async(
         self,
         symbol: Annotated[
             StrictStr, Field(description="Symbol to fetch KER indicator for")
@@ -124,7 +318,7 @@ class IndicatorsApi:
         ).data
 
     @validate_call
-    async def get_ker_indicator_with_http_info(
+    async def _get_ker_indicator_async_with_http_info(
         self,
         symbol: Annotated[
             StrictStr, Field(description="Symbol to fetch KER indicator for")
@@ -204,12 +398,11 @@ class IndicatorsApi:
         )
         await response_data.read()
         return self.api_client.response_deserialize(
-            response_data=response_data,
-            response_types_map=_response_types_map,
+            response_data=response_data, response_types_map=_response_types_map
         )
 
     @validate_call
-    async def get_ker_indicator_without_preload_content(
+    async def _get_ker_indicator_async_without_preload_content(
         self,
         symbol: Annotated[
             StrictStr, Field(description="Symbol to fetch KER indicator for")
@@ -287,7 +480,131 @@ class IndicatorsApi:
         response_data = await self.api_client.call_api(
             *_param, _request_timeout=_request_timeout
         )
-        return response_data.response
+        return response_data
+
+    # Private sync implementation methods
+    @validate_call
+    def _get_ker_indicator_sync(
+        self,
+        symbol: Annotated[
+            StrictStr, Field(description="Symbol to fetch KER indicator for")
+        ],
+        market: Annotated[
+            Optional[MarketType], Field(description="Market. Defaults to futures.")
+        ] = None,
+        period: Annotated[
+            Optional[StrictInt], Field(description="KER indicator period")
+        ] = None,
+        timestamp: Annotated[
+            Optional[StrictInt],
+            Field(description="Timestamp for which to fetch KER indicator"),
+        ] = None,
+        _request_timeout: Union[
+            None,
+            Annotated[StrictFloat, Field(gt=0)],
+            Tuple[
+                Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]
+            ],
+        ] = None,
+        _request_auth: Optional[Dict[StrictStr, Any]] = None,
+        _content_type: Optional[StrictStr] = None,
+        _headers: Optional[Dict[StrictStr, Any]] = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+    ) -> Dict[str, object]:
+        """Synchronous version of get_ker_indicator"""
+        return async_to_sync(self._get_ker_indicator_async)(
+            symbol=symbol,
+            market=market,
+            period=period,
+            timestamp=timestamp,
+            _request_timeout=_request_timeout,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index,
+        )
+
+    @validate_call
+    def _get_ker_indicator_sync_with_http_info(
+        self,
+        symbol: Annotated[
+            StrictStr, Field(description="Symbol to fetch KER indicator for")
+        ],
+        market: Annotated[
+            Optional[MarketType], Field(description="Market. Defaults to futures.")
+        ] = None,
+        period: Annotated[
+            Optional[StrictInt], Field(description="KER indicator period")
+        ] = None,
+        timestamp: Annotated[
+            Optional[StrictInt],
+            Field(description="Timestamp for which to fetch KER indicator"),
+        ] = None,
+        _request_timeout: Union[
+            None,
+            Annotated[StrictFloat, Field(gt=0)],
+            Tuple[
+                Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]
+            ],
+        ] = None,
+        _request_auth: Optional[Dict[StrictStr, Any]] = None,
+        _content_type: Optional[StrictStr] = None,
+        _headers: Optional[Dict[StrictStr, Any]] = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+    ) -> ApiResponse[Dict[str, object]]:
+        """Synchronous version of get_ker_indicator_with_http_info"""
+        return async_to_sync(self._get_ker_indicator_async_with_http_info)(
+            symbol=symbol,
+            market=market,
+            period=period,
+            timestamp=timestamp,
+            _request_timeout=_request_timeout,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index,
+        )
+
+    @validate_call
+    def _get_ker_indicator_sync_without_preload_content(
+        self,
+        symbol: Annotated[
+            StrictStr, Field(description="Symbol to fetch KER indicator for")
+        ],
+        market: Annotated[
+            Optional[MarketType], Field(description="Market. Defaults to futures.")
+        ] = None,
+        period: Annotated[
+            Optional[StrictInt], Field(description="KER indicator period")
+        ] = None,
+        timestamp: Annotated[
+            Optional[StrictInt],
+            Field(description="Timestamp for which to fetch KER indicator"),
+        ] = None,
+        _request_timeout: Union[
+            None,
+            Annotated[StrictFloat, Field(gt=0)],
+            Tuple[
+                Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]
+            ],
+        ] = None,
+        _request_auth: Optional[Dict[StrictStr, Any]] = None,
+        _content_type: Optional[StrictStr] = None,
+        _headers: Optional[Dict[StrictStr, Any]] = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+    ) -> RESTResponseType:
+        """Synchronous version of get_ker_indicator_without_preload_content"""
+        return async_to_sync(self._get_ker_indicator_async_without_preload_content)(
+            symbol=symbol,
+            market=market,
+            period=period,
+            timestamp=timestamp,
+            _request_timeout=_request_timeout,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index,
+        )
 
     def _get_ker_indicator_serialize(
         self,
@@ -361,7 +678,188 @@ class IndicatorsApi:
         )
 
     @validate_call
-    async def get_sma_indicator(
+    def get_sma_indicator(
+        self,
+        symbol: Annotated[
+            StrictStr, Field(description="Symbol to fetch SMA indicator for")
+        ],
+        market: Annotated[
+            Optional[MarketType],
+            Field(description="The market type to use for the SMA indicator"),
+        ] = None,
+        period: Annotated[
+            Optional[StrictInt],
+            Field(description="The period to use for the SMA indicator"),
+        ] = None,
+        timestamp: Annotated[
+            Optional[StrictInt],
+            Field(description="The timestamp for which to fetch the SMA indicator"),
+        ] = None,
+        _request_timeout: Union[
+            None,
+            Annotated[StrictFloat, Field(gt=0)],
+            Tuple[
+                Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]
+            ],
+        ] = None,
+        _request_auth: Optional[Dict[StrictStr, Any]] = None,
+        _content_type: Optional[StrictStr] = None,
+        _headers: Optional[Dict[StrictStr, Any]] = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+    ) -> Dict[str, object]:
+        """Get Sma Indicator
+
+        This method can work in both sync and async modes based on the is_sync flag.
+        """
+        if self.is_sync:
+            return self._get_sma_indicator_sync(
+                symbol=symbol,
+                market=market,
+                period=period,
+                timestamp=timestamp,
+                _request_timeout=_request_timeout,
+                _request_auth=_request_auth,
+                _content_type=_content_type,
+                _headers=_headers,
+                _host_index=_host_index,
+            )
+
+        else:
+            return self._get_sma_indicator_async(
+                symbol=symbol,
+                market=market,
+                period=period,
+                timestamp=timestamp,
+                _request_timeout=_request_timeout,
+                _request_auth=_request_auth,
+                _content_type=_content_type,
+                _headers=_headers,
+                _host_index=_host_index,
+            )
+
+    @validate_call
+    def get_sma_indicator_with_http_info(
+        self,
+        symbol: Annotated[
+            StrictStr, Field(description="Symbol to fetch SMA indicator for")
+        ],
+        market: Annotated[
+            Optional[MarketType],
+            Field(description="The market type to use for the SMA indicator"),
+        ] = None,
+        period: Annotated[
+            Optional[StrictInt],
+            Field(description="The period to use for the SMA indicator"),
+        ] = None,
+        timestamp: Annotated[
+            Optional[StrictInt],
+            Field(description="The timestamp for which to fetch the SMA indicator"),
+        ] = None,
+        _request_timeout: Union[
+            None,
+            Annotated[StrictFloat, Field(gt=0)],
+            Tuple[
+                Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]
+            ],
+        ] = None,
+        _request_auth: Optional[Dict[StrictStr, Any]] = None,
+        _content_type: Optional[StrictStr] = None,
+        _headers: Optional[Dict[StrictStr, Any]] = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+    ) -> ApiResponse[Dict[str, object]]:
+        """Get Sma Indicator with HTTP info
+
+        This method can work in both sync and async modes based on the is_sync flag.
+        """
+        if self.is_sync:
+            return self._get_sma_indicator_sync_with_http_info(
+                symbol=symbol,
+                market=market,
+                period=period,
+                timestamp=timestamp,
+                _request_timeout=_request_timeout,
+                _request_auth=_request_auth,
+                _content_type=_content_type,
+                _headers=_headers,
+                _host_index=_host_index,
+            )
+
+        else:
+            return self._get_sma_indicator_async_with_http_info(
+                symbol=symbol,
+                market=market,
+                period=period,
+                timestamp=timestamp,
+                _request_timeout=_request_timeout,
+                _request_auth=_request_auth,
+                _content_type=_content_type,
+                _headers=_headers,
+                _host_index=_host_index,
+            )
+
+    @validate_call
+    def get_sma_indicator_without_preload_content(
+        self,
+        symbol: Annotated[
+            StrictStr, Field(description="Symbol to fetch SMA indicator for")
+        ],
+        market: Annotated[
+            Optional[MarketType],
+            Field(description="The market type to use for the SMA indicator"),
+        ] = None,
+        period: Annotated[
+            Optional[StrictInt],
+            Field(description="The period to use for the SMA indicator"),
+        ] = None,
+        timestamp: Annotated[
+            Optional[StrictInt],
+            Field(description="The timestamp for which to fetch the SMA indicator"),
+        ] = None,
+        _request_timeout: Union[
+            None,
+            Annotated[StrictFloat, Field(gt=0)],
+            Tuple[
+                Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]
+            ],
+        ] = None,
+        _request_auth: Optional[Dict[StrictStr, Any]] = None,
+        _content_type: Optional[StrictStr] = None,
+        _headers: Optional[Dict[StrictStr, Any]] = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+    ) -> RESTResponseType:
+        """Get Sma Indicator without preloading content
+
+        This method can work in both sync and async modes based on the is_sync flag.
+        """
+        if self.is_sync:
+            return self._get_sma_indicator_sync_without_preload_content(
+                symbol=symbol,
+                market=market,
+                period=period,
+                timestamp=timestamp,
+                _request_timeout=_request_timeout,
+                _request_auth=_request_auth,
+                _content_type=_content_type,
+                _headers=_headers,
+                _host_index=_host_index,
+            )
+
+        else:
+            return self._get_sma_indicator_async_without_preload_content(
+                symbol=symbol,
+                market=market,
+                period=period,
+                timestamp=timestamp,
+                _request_timeout=_request_timeout,
+                _request_auth=_request_auth,
+                _content_type=_content_type,
+                _headers=_headers,
+                _host_index=_host_index,
+            )
+
+    # Private async implementation methods
+    @validate_call
+    async def _get_sma_indicator_async(
         self,
         symbol: Annotated[
             StrictStr, Field(description="Symbol to fetch SMA indicator for")
@@ -448,7 +946,7 @@ class IndicatorsApi:
         ).data
 
     @validate_call
-    async def get_sma_indicator_with_http_info(
+    async def _get_sma_indicator_async_with_http_info(
         self,
         symbol: Annotated[
             StrictStr, Field(description="Symbol to fetch SMA indicator for")
@@ -530,12 +1028,11 @@ class IndicatorsApi:
         )
         await response_data.read()
         return self.api_client.response_deserialize(
-            response_data=response_data,
-            response_types_map=_response_types_map,
+            response_data=response_data, response_types_map=_response_types_map
         )
 
     @validate_call
-    async def get_sma_indicator_without_preload_content(
+    async def _get_sma_indicator_async_without_preload_content(
         self,
         symbol: Annotated[
             StrictStr, Field(description="Symbol to fetch SMA indicator for")
@@ -615,7 +1112,137 @@ class IndicatorsApi:
         response_data = await self.api_client.call_api(
             *_param, _request_timeout=_request_timeout
         )
-        return response_data.response
+        return response_data
+
+    # Private sync implementation methods
+    @validate_call
+    def _get_sma_indicator_sync(
+        self,
+        symbol: Annotated[
+            StrictStr, Field(description="Symbol to fetch SMA indicator for")
+        ],
+        market: Annotated[
+            Optional[MarketType],
+            Field(description="The market type to use for the SMA indicator"),
+        ] = None,
+        period: Annotated[
+            Optional[StrictInt],
+            Field(description="The period to use for the SMA indicator"),
+        ] = None,
+        timestamp: Annotated[
+            Optional[StrictInt],
+            Field(description="The timestamp for which to fetch the SMA indicator"),
+        ] = None,
+        _request_timeout: Union[
+            None,
+            Annotated[StrictFloat, Field(gt=0)],
+            Tuple[
+                Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]
+            ],
+        ] = None,
+        _request_auth: Optional[Dict[StrictStr, Any]] = None,
+        _content_type: Optional[StrictStr] = None,
+        _headers: Optional[Dict[StrictStr, Any]] = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+    ) -> Dict[str, object]:
+        """Synchronous version of get_sma_indicator"""
+        return async_to_sync(self._get_sma_indicator_async)(
+            symbol=symbol,
+            market=market,
+            period=period,
+            timestamp=timestamp,
+            _request_timeout=_request_timeout,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index,
+        )
+
+    @validate_call
+    def _get_sma_indicator_sync_with_http_info(
+        self,
+        symbol: Annotated[
+            StrictStr, Field(description="Symbol to fetch SMA indicator for")
+        ],
+        market: Annotated[
+            Optional[MarketType],
+            Field(description="The market type to use for the SMA indicator"),
+        ] = None,
+        period: Annotated[
+            Optional[StrictInt],
+            Field(description="The period to use for the SMA indicator"),
+        ] = None,
+        timestamp: Annotated[
+            Optional[StrictInt],
+            Field(description="The timestamp for which to fetch the SMA indicator"),
+        ] = None,
+        _request_timeout: Union[
+            None,
+            Annotated[StrictFloat, Field(gt=0)],
+            Tuple[
+                Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]
+            ],
+        ] = None,
+        _request_auth: Optional[Dict[StrictStr, Any]] = None,
+        _content_type: Optional[StrictStr] = None,
+        _headers: Optional[Dict[StrictStr, Any]] = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+    ) -> ApiResponse[Dict[str, object]]:
+        """Synchronous version of get_sma_indicator_with_http_info"""
+        return async_to_sync(self._get_sma_indicator_async_with_http_info)(
+            symbol=symbol,
+            market=market,
+            period=period,
+            timestamp=timestamp,
+            _request_timeout=_request_timeout,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index,
+        )
+
+    @validate_call
+    def _get_sma_indicator_sync_without_preload_content(
+        self,
+        symbol: Annotated[
+            StrictStr, Field(description="Symbol to fetch SMA indicator for")
+        ],
+        market: Annotated[
+            Optional[MarketType],
+            Field(description="The market type to use for the SMA indicator"),
+        ] = None,
+        period: Annotated[
+            Optional[StrictInt],
+            Field(description="The period to use for the SMA indicator"),
+        ] = None,
+        timestamp: Annotated[
+            Optional[StrictInt],
+            Field(description="The timestamp for which to fetch the SMA indicator"),
+        ] = None,
+        _request_timeout: Union[
+            None,
+            Annotated[StrictFloat, Field(gt=0)],
+            Tuple[
+                Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]
+            ],
+        ] = None,
+        _request_auth: Optional[Dict[StrictStr, Any]] = None,
+        _content_type: Optional[StrictStr] = None,
+        _headers: Optional[Dict[StrictStr, Any]] = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+    ) -> RESTResponseType:
+        """Synchronous version of get_sma_indicator_without_preload_content"""
+        return async_to_sync(self._get_sma_indicator_async_without_preload_content)(
+            symbol=symbol,
+            market=market,
+            period=period,
+            timestamp=timestamp,
+            _request_timeout=_request_timeout,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index,
+        )
 
     def _get_sma_indicator_serialize(
         self,