ourskyai-node-platform-api 1.3.9821__py3-none-any.whl

ourskyai_node_platform_api/models/v1_update_filter_request.py

@@ -0,0 +1,74 @@
+# coding: utf-8
+
+"""
+    OurSky
+
+    Node Platform API
+
+    The version of the OpenAPI document: 1.3.9821
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+
+
+from pydantic import BaseModel, Field, StrictInt
+from ourskyai_node_platform_api.models.v1_filter_type import V1FilterType
+
+class V1UpdateFilterRequest(BaseModel):
+    """
+    Request to update the filter type configuration for a specific wheel position.  # noqa: E501
+    """
+    position: StrictInt = Field(..., description="Filter wheel slot position to update as a zero-based index. Valid values range from 0 to (capacity - 1).")
+    type: V1FilterType = Field(...)
+    __properties = ["position", "type"]
+
+    class Config:
+        """Pydantic configuration"""
+        allow_population_by_field_name = True
+        validate_assignment = True
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.dict(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> V1UpdateFilterRequest:
+        """Create an instance of V1UpdateFilterRequest from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self):
+        """Returns the dictionary representation of the model using alias"""
+        _dict = self.dict(by_alias=True,
+                          exclude={
+                          },
+                          exclude_none=True)
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: dict) -> V1UpdateFilterRequest:
+        """Create an instance of V1UpdateFilterRequest from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return V1UpdateFilterRequest.parse_obj(obj)
+
+        _obj = V1UpdateFilterRequest.parse_obj({
+            "position": obj.get("position"),
+            "type": obj.get("type")
+        })
+        return _obj
+
+

ourskyai_node_platform_api/models/v1_video.py

@@ -0,0 +1,105 @@
+# coding: utf-8
+
+"""
+    OurSky
+
+    Node Platform API
+
+    The version of the OpenAPI document: 1.3.9821
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from datetime import datetime
+from typing import Optional, Union
+from pydantic import BaseModel, Field, StrictBool, StrictFloat, StrictInt, StrictStr
+from ourskyai_node_platform_api.models.video_codec import VideoCodec
+from ourskyai_node_platform_api.models.video_container_format import VideoContainerFormat
+
+class V1Video(BaseModel):
+    """
+    Complete metadata for a recorded video including capture settings, file information, codec details, and timing data. Use this object to understand the recording parameters and locate the video file.  # noqa: E501
+    """
+    id: StrictStr = Field(..., description="Unique identifier for this video recording. Use this ID for any video-specific operations such as download or deletion.")
+    camera_id: StrictStr = Field(..., alias="cameraId", description="Identifier of the camera that recorded this video. Useful for filtering videos by camera source.")
+    exposure_count: Optional[StrictInt] = Field(None, alias="exposureCount", description="Total number of individual frames or exposures contained in the video file. Useful for estimating total integration time.")
+    saved_from_deletion: StrictBool = Field(..., alias="savedFromDeletion", description="Indicates whether this video has been marked as saved to prevent automatic deletion. True means the video is protected from storage cleanup operations.")
+    exposure_seconds: Optional[Union[StrictFloat, StrictInt]] = Field(None, alias="exposureSeconds", description="Exposure duration in seconds for each individual frame in the video. Longer exposures capture more light per frame but reduce the effective frame rate.")
+    frame_seconds: Optional[Union[StrictFloat, StrictInt]] = Field(None, alias="frameSeconds", description="Duration in seconds between the start of consecutive frames. This determines the effective capture rate and may differ from exposure time if there is readout overhead.")
+    gain: Optional[StrictInt] = Field(None, description="Sensor gain setting that was applied during recording. Higher values indicate more signal amplification was used.")
+    binning: Optional[StrictInt] = Field(None, description="Pixel binning factor that was used during recording. A value of 1 indicates full resolution capture.")
+    offset: Optional[StrictInt] = Field(None, description="Sensor offset or black level setting that was applied during recording.")
+    file_path: StrictStr = Field(..., alias="filePath", description="Absolute file system path where the video file is stored on the node. Use this path for direct file access or to construct download URLs.")
+    file_size_mb: Union[StrictFloat, StrictInt] = Field(..., alias="fileSizeMb", description="Size of the video file in megabytes. Useful for estimating download times and managing storage space.")
+    codec: VideoCodec = Field(...)
+    container_format: VideoContainerFormat = Field(..., alias="containerFormat")
+    capture_started_at: datetime = Field(..., alias="captureStartedAt", description="ISO 8601 timestamp indicating when video recording began and the first frame was captured.")
+    capture_ended_at: datetime = Field(..., alias="captureEndedAt", description="ISO 8601 timestamp indicating when video recording ended and the last frame was captured.")
+    created_at: datetime = Field(..., alias="createdAt", description="ISO 8601 timestamp indicating when this video record was created in the database. Used for pagination with the before parameter.")
+    updated_at: datetime = Field(..., alias="updatedAt", description="ISO 8601 timestamp indicating when this video record was last modified.")
+    __properties = ["id", "cameraId", "exposureCount", "savedFromDeletion", "exposureSeconds", "frameSeconds", "gain", "binning", "offset", "filePath", "fileSizeMb", "codec", "containerFormat", "captureStartedAt", "captureEndedAt", "createdAt", "updatedAt"]
+
+    class Config:
+        """Pydantic configuration"""
+        allow_population_by_field_name = True
+        validate_assignment = True
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.dict(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> V1Video:
+        """Create an instance of V1Video from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self):
+        """Returns the dictionary representation of the model using alias"""
+        _dict = self.dict(by_alias=True,
+                          exclude={
+                          },
+                          exclude_none=True)
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: dict) -> V1Video:
+        """Create an instance of V1Video from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return V1Video.parse_obj(obj)
+
+        _obj = V1Video.parse_obj({
+            "id": obj.get("id"),
+            "camera_id": obj.get("cameraId"),
+            "exposure_count": obj.get("exposureCount"),
+            "saved_from_deletion": obj.get("savedFromDeletion"),
+            "exposure_seconds": obj.get("exposureSeconds"),
+            "frame_seconds": obj.get("frameSeconds"),
+            "gain": obj.get("gain"),
+            "binning": obj.get("binning"),
+            "offset": obj.get("offset"),
+            "file_path": obj.get("filePath"),
+            "file_size_mb": obj.get("fileSizeMb"),
+            "codec": obj.get("codec"),
+            "container_format": obj.get("containerFormat"),
+            "capture_started_at": obj.get("captureStartedAt"),
+            "capture_ended_at": obj.get("captureEndedAt"),
+            "created_at": obj.get("createdAt"),
+            "updated_at": obj.get("updatedAt")
+        })
+        return _obj
+
+

ourskyai_node_platform_api/models/v1_videos.py

@@ -0,0 +1,79 @@
+# coding: utf-8
+
+"""
+    OurSky
+
+    Node Platform API
+
+    The version of the OpenAPI document: 1.3.9821
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+
+from typing import List
+from pydantic import BaseModel, Field, conlist
+from ourskyai_node_platform_api.models.v1_video import V1Video
+
+class V1Videos(BaseModel):
+    """
+    Container object holding a paginated list of recorded videos. Use the before parameter with the last video's createdAt timestamp to retrieve the next page of results.  # noqa: E501
+    """
+    videos: conlist(V1Video) = Field(..., description="Array of video metadata objects sorted by creation time in descending order (newest first). May be empty if no videos match the query criteria.")
+    __properties = ["videos"]
+
+    class Config:
+        """Pydantic configuration"""
+        allow_population_by_field_name = True
+        validate_assignment = True
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.dict(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> V1Videos:
+        """Create an instance of V1Videos from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self):
+        """Returns the dictionary representation of the model using alias"""
+        _dict = self.dict(by_alias=True,
+                          exclude={
+                          },
+                          exclude_none=True)
+        # override the default output from pydantic by calling `to_dict()` of each item in videos (list)
+        _items = []
+        if self.videos:
+            for _item in self.videos:
+                if _item:
+                    _items.append(_item.to_dict())
+            _dict['videos'] = _items
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: dict) -> V1Videos:
+        """Create an instance of V1Videos from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return V1Videos.parse_obj(obj)
+
+        _obj = V1Videos.parse_obj({
+            "videos": [V1Video.from_dict(_item) for _item in obj.get("videos")] if obj.get("videos") is not None else None
+        })
+        return _obj
+
+

ourskyai_node_platform_api/models/v1_weather_forecast.py

@@ -0,0 +1,85 @@
+# coding: utf-8
+
+"""
+    OurSky
+
+    Node Platform API
+
+    The version of the OpenAPI document: 1.3.9821
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+
+from typing import List, Optional
+from pydantic import BaseModel, conlist
+from ourskyai_node_platform_api.models.v1_weather_forecast_city import V1WeatherForecastCity
+from ourskyai_node_platform_api.models.v1_weather_forecast_item import V1WeatherForecastItem
+
+class V1WeatherForecast(BaseModel):
+    """
+    V1WeatherForecast
+    """
+    city: Optional[V1WeatherForecastCity] = None
+    days: Optional[conlist(V1WeatherForecastItem)] = None
+    __properties = ["city", "days"]
+
+    class Config:
+        """Pydantic configuration"""
+        allow_population_by_field_name = True
+        validate_assignment = True
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.dict(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> V1WeatherForecast:
+        """Create an instance of V1WeatherForecast from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self):
+        """Returns the dictionary representation of the model using alias"""
+        _dict = self.dict(by_alias=True,
+                          exclude={
+                          },
+                          exclude_none=True)
+        # override the default output from pydantic by calling `to_dict()` of city
+        if self.city:
+            _dict['city'] = self.city.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of each item in days (list)
+        _items = []
+        if self.days:
+            for _item in self.days:
+                if _item:
+                    _items.append(_item.to_dict())
+            _dict['days'] = _items
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: dict) -> V1WeatherForecast:
+        """Create an instance of V1WeatherForecast from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return V1WeatherForecast.parse_obj(obj)
+
+        _obj = V1WeatherForecast.parse_obj({
+            "city": V1WeatherForecastCity.from_dict(obj.get("city")) if obj.get("city") is not None else None,
+            "days": [V1WeatherForecastItem.from_dict(_item) for _item in obj.get("days")] if obj.get("days") is not None else None
+        })
+        return _obj
+
+

ourskyai_node_platform_api/models/v1_weather_forecast_city.py

@@ -0,0 +1,73 @@
+# coding: utf-8
+
+"""
+    OurSky
+
+    Node Platform API
+
+    The version of the OpenAPI document: 1.3.9821
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+
+from typing import Optional
+from pydantic import BaseModel, Field, StrictStr
+
+class V1WeatherForecastCity(BaseModel):
+    """
+    V1WeatherForecastCity
+    """
+    name: Optional[StrictStr] = Field(None, description="City name")
+    country: Optional[StrictStr] = Field(None, description="Country code")
+    __properties = ["name", "country"]
+
+    class Config:
+        """Pydantic configuration"""
+        allow_population_by_field_name = True
+        validate_assignment = True
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.dict(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> V1WeatherForecastCity:
+        """Create an instance of V1WeatherForecastCity from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self):
+        """Returns the dictionary representation of the model using alias"""
+        _dict = self.dict(by_alias=True,
+                          exclude={
+                          },
+                          exclude_none=True)
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: dict) -> V1WeatherForecastCity:
+        """Create an instance of V1WeatherForecastCity from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return V1WeatherForecastCity.parse_obj(obj)
+
+        _obj = V1WeatherForecastCity.parse_obj({
+            "name": obj.get("name"),
+            "country": obj.get("country")
+        })
+        return _obj
+
+

ourskyai_node_platform_api/models/v1_weather_forecast_item.py

@@ -0,0 +1,103 @@
+# coding: utf-8
+
+"""
+    OurSky
+
+    Node Platform API
+
+    The version of the OpenAPI document: 1.3.9821
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+
+from typing import List, Optional, Union
+from pydantic import BaseModel, Field, StrictFloat, StrictInt, conlist
+from ourskyai_node_platform_api.models.v1_weather_forecast_temperature import V1WeatherForecastTemperature
+from ourskyai_node_platform_api.models.v1_weather_forecast_weather import V1WeatherForecastWeather
+
+class V1WeatherForecastItem(BaseModel):
+    """
+    V1WeatherForecastItem
+    """
+    timestamp: Optional[StrictInt] = Field(None, description="Timestamp of the weather data in UNIX timestamp")
+    sunrise: Optional[StrictInt] = Field(None, description="Sunrise time in UNIX timestamp")
+    sunset: Optional[StrictInt] = Field(None, description="Sunset time in UNIX timestamp")
+    temperature: Optional[V1WeatherForecastTemperature] = None
+    humidity: Optional[StrictInt] = Field(None, description="Humidity percentage")
+    weather: Optional[conlist(V1WeatherForecastWeather)] = None
+    speed: Optional[Union[StrictFloat, StrictInt]] = Field(None, description="Wind speed in m/s")
+    deg: Optional[StrictInt] = Field(None, description="Wind direction in degrees")
+    clouds: Optional[StrictInt] = Field(None, description="Cloudiness percentage")
+    pop: Optional[Union[StrictFloat, StrictInt]] = Field(None, description="Probability of precipitation in %")
+    rain: Optional[Union[StrictFloat, StrictInt]] = Field(None, description="Rain volume for the last 3 hours in mm/h")
+    __properties = ["timestamp", "sunrise", "sunset", "temperature", "humidity", "weather", "speed", "deg", "clouds", "pop", "rain"]
+
+    class Config:
+        """Pydantic configuration"""
+        allow_population_by_field_name = True
+        validate_assignment = True
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.dict(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> V1WeatherForecastItem:
+        """Create an instance of V1WeatherForecastItem from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self):
+        """Returns the dictionary representation of the model using alias"""
+        _dict = self.dict(by_alias=True,
+                          exclude={
+                          },
+                          exclude_none=True)
+        # override the default output from pydantic by calling `to_dict()` of temperature
+        if self.temperature:
+            _dict['temperature'] = self.temperature.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of each item in weather (list)
+        _items = []
+        if self.weather:
+            for _item in self.weather:
+                if _item:
+                    _items.append(_item.to_dict())
+            _dict['weather'] = _items
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: dict) -> V1WeatherForecastItem:
+        """Create an instance of V1WeatherForecastItem from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return V1WeatherForecastItem.parse_obj(obj)
+
+        _obj = V1WeatherForecastItem.parse_obj({
+            "timestamp": obj.get("timestamp"),
+            "sunrise": obj.get("sunrise"),
+            "sunset": obj.get("sunset"),
+            "temperature": V1WeatherForecastTemperature.from_dict(obj.get("temperature")) if obj.get("temperature") is not None else None,
+            "humidity": obj.get("humidity"),
+            "weather": [V1WeatherForecastWeather.from_dict(_item) for _item in obj.get("weather")] if obj.get("weather") is not None else None,
+            "speed": obj.get("speed"),
+            "deg": obj.get("deg"),
+            "clouds": obj.get("clouds"),
+            "pop": obj.get("pop"),
+            "rain": obj.get("rain")
+        })
+        return _obj
+
+

ourskyai_node_platform_api/models/v1_weather_forecast_temperature.py

@@ -0,0 +1,77 @@
+# coding: utf-8
+
+"""
+    OurSky
+
+    Node Platform API
+
+    The version of the OpenAPI document: 1.3.9821
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+
+from typing import Optional, Union
+from pydantic import BaseModel, Field, StrictFloat, StrictInt
+
+class V1WeatherForecastTemperature(BaseModel):
+    """
+    V1WeatherForecastTemperature
+    """
+    day: Optional[Union[StrictFloat, StrictInt]] = Field(None, description="Day temperature in Celcius")
+    min: Optional[Union[StrictFloat, StrictInt]] = Field(None, description="Minimum temperature in Celcius")
+    max: Optional[Union[StrictFloat, StrictInt]] = Field(None, description="Maximum temperature in Celcius")
+    night: Optional[Union[StrictFloat, StrictInt]] = Field(None, description="Night temperature in Celcius")
+    __properties = ["day", "min", "max", "night"]
+
+    class Config:
+        """Pydantic configuration"""
+        allow_population_by_field_name = True
+        validate_assignment = True
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.dict(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> V1WeatherForecastTemperature:
+        """Create an instance of V1WeatherForecastTemperature from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self):
+        """Returns the dictionary representation of the model using alias"""
+        _dict = self.dict(by_alias=True,
+                          exclude={
+                          },
+                          exclude_none=True)
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: dict) -> V1WeatherForecastTemperature:
+        """Create an instance of V1WeatherForecastTemperature from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return V1WeatherForecastTemperature.parse_obj(obj)
+
+        _obj = V1WeatherForecastTemperature.parse_obj({
+            "day": obj.get("day"),
+            "min": obj.get("min"),
+            "max": obj.get("max"),
+            "night": obj.get("night")
+        })
+        return _obj
+
+

ourskyai_node_platform_api/models/v1_weather_forecast_weather.py

@@ -0,0 +1,77 @@
+# coding: utf-8
+
+"""
+    OurSky
+
+    Node Platform API
+
+    The version of the OpenAPI document: 1.3.9821
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+
+from typing import Optional
+from pydantic import BaseModel, Field, StrictInt, StrictStr
+
+class V1WeatherForecastWeather(BaseModel):
+    """
+    V1WeatherForecastWeather
+    """
+    id: Optional[StrictInt] = Field(None, description="Weather condition id")
+    main: Optional[StrictStr] = Field(None, description="Group of weather parameters")
+    description: Optional[StrictStr] = Field(None, description="Weather condition description")
+    icon: Optional[StrictStr] = Field(None, description="Weather icon id")
+    __properties = ["id", "main", "description", "icon"]
+
+    class Config:
+        """Pydantic configuration"""
+        allow_population_by_field_name = True
+        validate_assignment = True
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.dict(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> V1WeatherForecastWeather:
+        """Create an instance of V1WeatherForecastWeather from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self):
+        """Returns the dictionary representation of the model using alias"""
+        _dict = self.dict(by_alias=True,
+                          exclude={
+                          },
+                          exclude_none=True)
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: dict) -> V1WeatherForecastWeather:
+        """Create an instance of V1WeatherForecastWeather from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return V1WeatherForecastWeather.parse_obj(obj)
+
+        _obj = V1WeatherForecastWeather.parse_obj({
+            "id": obj.get("id"),
+            "main": obj.get("main"),
+            "description": obj.get("description"),
+            "icon": obj.get("icon")
+        })
+        return _obj
+
+