robosystems-client 0.2.9__py3-none-any.whl → 0.2.11__py3-none-any.whl

robosystems_client/models/invoices_response.py

@@ -0,0 +1,90 @@
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+if TYPE_CHECKING:
+  from ..models.invoice import Invoice
+
+
+T = TypeVar("T", bound="InvoicesResponse")
+
+
+@_attrs_define
+class InvoicesResponse:
+  """Response for invoice list.
+
+  Attributes:
+      invoices (list['Invoice']): List of invoices
+      total_count (int): Total number of invoices
+      has_more (bool): Whether more invoices are available
+  """
+
+  invoices: list["Invoice"]
+  total_count: int
+  has_more: bool
+  additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+  def to_dict(self) -> dict[str, Any]:
+    invoices = []
+    for invoices_item_data in self.invoices:
+      invoices_item = invoices_item_data.to_dict()
+      invoices.append(invoices_item)
+
+    total_count = self.total_count
+
+    has_more = self.has_more
+
+    field_dict: dict[str, Any] = {}
+    field_dict.update(self.additional_properties)
+    field_dict.update(
+      {
+        "invoices": invoices,
+        "total_count": total_count,
+        "has_more": has_more,
+      }
+    )
+
+    return field_dict
+
+  @classmethod
+  def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+    from ..models.invoice import Invoice
+
+    d = dict(src_dict)
+    invoices = []
+    _invoices = d.pop("invoices")
+    for invoices_item_data in _invoices:
+      invoices_item = Invoice.from_dict(invoices_item_data)
+
+      invoices.append(invoices_item)
+
+    total_count = d.pop("total_count")
+
+    has_more = d.pop("has_more")
+
+    invoices_response = cls(
+      invoices=invoices,
+      total_count=total_count,
+      has_more=has_more,
+    )
+
+    invoices_response.additional_properties = d
+    return invoices_response
+
+  @property
+  def additional_keys(self) -> list[str]:
+    return list(self.additional_properties.keys())
+
+  def __getitem__(self, key: str) -> Any:
+    return self.additional_properties[key]
+
+  def __setitem__(self, key: str, value: Any) -> None:
+    self.additional_properties[key] = value
+
+  def __delitem__(self, key: str) -> None:
+    del self.additional_properties[key]
+
+  def __contains__(self, key: str) -> bool:
+    return key in self.additional_properties

robosystems_client/models/payment_method.py

@@ -0,0 +1,158 @@
+from collections.abc import Mapping
+from typing import Any, TypeVar, Union, cast
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="PaymentMethod")
+
+
+@_attrs_define
+class PaymentMethod:
+  """Payment method information.
+
+  Attributes:
+      id (str): Payment method ID
+      type_ (str): Payment method type (card, bank_account, etc.)
+      is_default (bool): Whether this is the default payment method
+      brand (Union[None, Unset, str]): Card brand (visa, mastercard, etc.)
+      last4 (Union[None, Unset, str]): Last 4 digits
+      exp_month (Union[None, Unset, int]): Expiration month
+      exp_year (Union[None, Unset, int]): Expiration year
+  """
+
+  id: str
+  type_: str
+  is_default: bool
+  brand: Union[None, Unset, str] = UNSET
+  last4: Union[None, Unset, str] = UNSET
+  exp_month: Union[None, Unset, int] = UNSET
+  exp_year: Union[None, Unset, int] = UNSET
+  additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+  def to_dict(self) -> dict[str, Any]:
+    id = self.id
+
+    type_ = self.type_
+
+    is_default = self.is_default
+
+    brand: Union[None, Unset, str]
+    if isinstance(self.brand, Unset):
+      brand = UNSET
+    else:
+      brand = self.brand
+
+    last4: Union[None, Unset, str]
+    if isinstance(self.last4, Unset):
+      last4 = UNSET
+    else:
+      last4 = self.last4
+
+    exp_month: Union[None, Unset, int]
+    if isinstance(self.exp_month, Unset):
+      exp_month = UNSET
+    else:
+      exp_month = self.exp_month
+
+    exp_year: Union[None, Unset, int]
+    if isinstance(self.exp_year, Unset):
+      exp_year = UNSET
+    else:
+      exp_year = self.exp_year
+
+    field_dict: dict[str, Any] = {}
+    field_dict.update(self.additional_properties)
+    field_dict.update(
+      {
+        "id": id,
+        "type": type_,
+        "is_default": is_default,
+      }
+    )
+    if brand is not UNSET:
+      field_dict["brand"] = brand
+    if last4 is not UNSET:
+      field_dict["last4"] = last4
+    if exp_month is not UNSET:
+      field_dict["exp_month"] = exp_month
+    if exp_year is not UNSET:
+      field_dict["exp_year"] = exp_year
+
+    return field_dict
+
+  @classmethod
+  def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+    d = dict(src_dict)
+    id = d.pop("id")
+
+    type_ = d.pop("type")
+
+    is_default = d.pop("is_default")
+
+    def _parse_brand(data: object) -> Union[None, Unset, str]:
+      if data is None:
+        return data
+      if isinstance(data, Unset):
+        return data
+      return cast(Union[None, Unset, str], data)
+
+    brand = _parse_brand(d.pop("brand", UNSET))
+
+    def _parse_last4(data: object) -> Union[None, Unset, str]:
+      if data is None:
+        return data
+      if isinstance(data, Unset):
+        return data
+      return cast(Union[None, Unset, str], data)
+
+    last4 = _parse_last4(d.pop("last4", UNSET))
+
+    def _parse_exp_month(data: object) -> Union[None, Unset, int]:
+      if data is None:
+        return data
+      if isinstance(data, Unset):
+        return data
+      return cast(Union[None, Unset, int], data)
+
+    exp_month = _parse_exp_month(d.pop("exp_month", UNSET))
+
+    def _parse_exp_year(data: object) -> Union[None, Unset, int]:
+      if data is None:
+        return data
+      if isinstance(data, Unset):
+        return data
+      return cast(Union[None, Unset, int], data)
+
+    exp_year = _parse_exp_year(d.pop("exp_year", UNSET))
+
+    payment_method = cls(
+      id=id,
+      type_=type_,
+      is_default=is_default,
+      brand=brand,
+      last4=last4,
+      exp_month=exp_month,
+      exp_year=exp_year,
+    )
+
+    payment_method.additional_properties = d
+    return payment_method
+
+  @property
+  def additional_keys(self) -> list[str]:
+    return list(self.additional_properties.keys())
+
+  def __getitem__(self, key: str) -> Any:
+    return self.additional_properties[key]
+
+  def __setitem__(self, key: str, value: Any) -> None:
+    self.additional_properties[key] = value
+
+  def __delitem__(self, key: str) -> None:
+    del self.additional_properties[key]
+
+  def __contains__(self, key: str) -> bool:
+    return key in self.additional_properties

robosystems_client/models/performance_insights.py

@@ -0,0 +1,120 @@
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+if TYPE_CHECKING:
+  from ..models.performance_insights_operation_stats import (
+    PerformanceInsightsOperationStats,
+  )
+  from ..models.performance_insights_slow_queries_item import (
+    PerformanceInsightsSlowQueriesItem,
+  )
+
+
+T = TypeVar("T", bound="PerformanceInsights")
+
+
+@_attrs_define
+class PerformanceInsights:
+  """Performance analytics.
+
+  Attributes:
+      analysis_period_days (int): Analysis period in days
+      total_operations (int): Total operations analyzed
+      operation_stats (PerformanceInsightsOperationStats): Performance stats by operation type
+      slow_queries (list['PerformanceInsightsSlowQueriesItem']): Top slow queries (over 5 seconds)
+      performance_score (int): Performance score (0-100)
+  """
+
+  analysis_period_days: int
+  total_operations: int
+  operation_stats: "PerformanceInsightsOperationStats"
+  slow_queries: list["PerformanceInsightsSlowQueriesItem"]
+  performance_score: int
+  additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+  def to_dict(self) -> dict[str, Any]:
+    analysis_period_days = self.analysis_period_days
+
+    total_operations = self.total_operations
+
+    operation_stats = self.operation_stats.to_dict()
+
+    slow_queries = []
+    for slow_queries_item_data in self.slow_queries:
+      slow_queries_item = slow_queries_item_data.to_dict()
+      slow_queries.append(slow_queries_item)
+
+    performance_score = self.performance_score
+
+    field_dict: dict[str, Any] = {}
+    field_dict.update(self.additional_properties)
+    field_dict.update(
+      {
+        "analysis_period_days": analysis_period_days,
+        "total_operations": total_operations,
+        "operation_stats": operation_stats,
+        "slow_queries": slow_queries,
+        "performance_score": performance_score,
+      }
+    )
+
+    return field_dict
+
+  @classmethod
+  def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+    from ..models.performance_insights_operation_stats import (
+      PerformanceInsightsOperationStats,
+    )
+    from ..models.performance_insights_slow_queries_item import (
+      PerformanceInsightsSlowQueriesItem,
+    )
+
+    d = dict(src_dict)
+    analysis_period_days = d.pop("analysis_period_days")
+
+    total_operations = d.pop("total_operations")
+
+    operation_stats = PerformanceInsightsOperationStats.from_dict(
+      d.pop("operation_stats")
+    )
+
+    slow_queries = []
+    _slow_queries = d.pop("slow_queries")
+    for slow_queries_item_data in _slow_queries:
+      slow_queries_item = PerformanceInsightsSlowQueriesItem.from_dict(
+        slow_queries_item_data
+      )
+
+      slow_queries.append(slow_queries_item)
+
+    performance_score = d.pop("performance_score")
+
+    performance_insights = cls(
+      analysis_period_days=analysis_period_days,
+      total_operations=total_operations,
+      operation_stats=operation_stats,
+      slow_queries=slow_queries,
+      performance_score=performance_score,
+    )
+
+    performance_insights.additional_properties = d
+    return performance_insights
+
+  @property
+  def additional_keys(self) -> list[str]:
+    return list(self.additional_properties.keys())
+
+  def __getitem__(self, key: str) -> Any:
+    return self.additional_properties[key]
+
+  def __setitem__(self, key: str, value: Any) -> None:
+    self.additional_properties[key] = value
+
+  def __delitem__(self, key: str) -> None:
+    del self.additional_properties[key]
+
+  def __contains__(self, key: str) -> bool:
+    return key in self.additional_properties

robosystems_client/models/{graph_usage_response_recent_activity.py → performance_insights_operation_stats.py}

@@ -4,12 +4,12 @@ from typing import Any, TypeVar
 from attrs import define as _attrs_define
 from attrs import field as _attrs_field
 
-T = TypeVar("T", bound="GraphUsageResponseRecentActivity")
+T = TypeVar("T", bound="PerformanceInsightsOperationStats")
 
 
 @_attrs_define
-class GraphUsageResponseRecentActivity:
-  """Recent activity summary"""
+class PerformanceInsightsOperationStats:
+  """Performance stats by operation type"""
 
   additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
 
@@ -22,10 +22,10 @@ class GraphUsageResponseRecentActivity:
   @classmethod
   def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
     d = dict(src_dict)
-    graph_usage_response_recent_activity = cls()
+    performance_insights_operation_stats = cls()
 
-    graph_usage_response_recent_activity.additional_properties = d
-    return graph_usage_response_recent_activity
+    performance_insights_operation_stats.additional_properties = d
+    return performance_insights_operation_stats
 
   @property
   def additional_keys(self) -> list[str]:

robosystems_client/models/{user_analytics_response_api_usage.py → performance_insights_slow_queries_item.py}

@@ -4,12 +4,12 @@ from typing import Any, TypeVar
 from attrs import define as _attrs_define
 from attrs import field as _attrs_field
 
-T = TypeVar("T", bound="UserAnalyticsResponseApiUsage")
+T = TypeVar("T", bound="PerformanceInsightsSlowQueriesItem")
 
 
 @_attrs_define
-class UserAnalyticsResponseApiUsage:
-  """API usage statistics"""
+class PerformanceInsightsSlowQueriesItem:
+  """ """
 
   additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
 
@@ -22,10 +22,10 @@ class UserAnalyticsResponseApiUsage:
   @classmethod
   def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
     d = dict(src_dict)
-    user_analytics_response_api_usage = cls()
+    performance_insights_slow_queries_item = cls()
 
-    user_analytics_response_api_usage.additional_properties = d
-    return user_analytics_response_api_usage
+    performance_insights_slow_queries_item.additional_properties = d
+    return performance_insights_slow_queries_item
 
   @property
   def additional_keys(self) -> list[str]:

robosystems_client/models/storage_summary.py

@@ -0,0 +1,100 @@
+from collections.abc import Mapping
+from typing import Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+T = TypeVar("T", bound="StorageSummary")
+
+
+@_attrs_define
+class StorageSummary:
+  """Storage usage summary.
+
+  Attributes:
+      graph_tier (str): Subscription tier
+      avg_storage_gb (float): Average storage in GB
+      max_storage_gb (float): Peak storage in GB
+      min_storage_gb (float): Minimum storage in GB
+      total_gb_hours (float): Total GB-hours for billing
+      measurement_count (int): Number of measurements taken
+  """
+
+  graph_tier: str
+  avg_storage_gb: float
+  max_storage_gb: float
+  min_storage_gb: float
+  total_gb_hours: float
+  measurement_count: int
+  additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+  def to_dict(self) -> dict[str, Any]:
+    graph_tier = self.graph_tier
+
+    avg_storage_gb = self.avg_storage_gb
+
+    max_storage_gb = self.max_storage_gb
+
+    min_storage_gb = self.min_storage_gb
+
+    total_gb_hours = self.total_gb_hours
+
+    measurement_count = self.measurement_count
+
+    field_dict: dict[str, Any] = {}
+    field_dict.update(self.additional_properties)
+    field_dict.update(
+      {
+        "graph_tier": graph_tier,
+        "avg_storage_gb": avg_storage_gb,
+        "max_storage_gb": max_storage_gb,
+        "min_storage_gb": min_storage_gb,
+        "total_gb_hours": total_gb_hours,
+        "measurement_count": measurement_count,
+      }
+    )
+
+    return field_dict
+
+  @classmethod
+  def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+    d = dict(src_dict)
+    graph_tier = d.pop("graph_tier")
+
+    avg_storage_gb = d.pop("avg_storage_gb")
+
+    max_storage_gb = d.pop("max_storage_gb")
+
+    min_storage_gb = d.pop("min_storage_gb")
+
+    total_gb_hours = d.pop("total_gb_hours")
+
+    measurement_count = d.pop("measurement_count")
+
+    storage_summary = cls(
+      graph_tier=graph_tier,
+      avg_storage_gb=avg_storage_gb,
+      max_storage_gb=max_storage_gb,
+      min_storage_gb=min_storage_gb,
+      total_gb_hours=total_gb_hours,
+      measurement_count=measurement_count,
+    )
+
+    storage_summary.additional_properties = d
+    return storage_summary
+
+  @property
+  def additional_keys(self) -> list[str]:
+    return list(self.additional_properties.keys())
+
+  def __getitem__(self, key: str) -> Any:
+    return self.additional_properties[key]
+
+  def __setitem__(self, key: str, value: Any) -> None:
+    self.additional_properties[key] = value
+
+  def __delitem__(self, key: str) -> None:
+    del self.additional_properties[key]
+
+  def __contains__(self, key: str) -> bool:
+    return key in self.additional_properties

robosystems_client/models/upcoming_invoice.py

@@ -0,0 +1,128 @@
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any, TypeVar, Union, cast
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..types import UNSET, Unset
+
+if TYPE_CHECKING:
+  from ..models.invoice_line_item import InvoiceLineItem
+
+
+T = TypeVar("T", bound="UpcomingInvoice")
+
+
+@_attrs_define
+class UpcomingInvoice:
+  """Upcoming invoice preview.
+
+  Attributes:
+      amount_due (int): Estimated amount due in cents
+      currency (str): Currency code
+      period_start (str): Billing period start
+      period_end (str): Billing period end
+      line_items (list['InvoiceLineItem']): Estimated line items
+      subscription_id (Union[None, Unset, str]): Associated subscription ID
+  """
+
+  amount_due: int
+  currency: str
+  period_start: str
+  period_end: str
+  line_items: list["InvoiceLineItem"]
+  subscription_id: Union[None, Unset, str] = UNSET
+  additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+  def to_dict(self) -> dict[str, Any]:
+    amount_due = self.amount_due
+
+    currency = self.currency
+
+    period_start = self.period_start
+
+    period_end = self.period_end
+
+    line_items = []
+    for line_items_item_data in self.line_items:
+      line_items_item = line_items_item_data.to_dict()
+      line_items.append(line_items_item)
+
+    subscription_id: Union[None, Unset, str]
+    if isinstance(self.subscription_id, Unset):
+      subscription_id = UNSET
+    else:
+      subscription_id = self.subscription_id
+
+    field_dict: dict[str, Any] = {}
+    field_dict.update(self.additional_properties)
+    field_dict.update(
+      {
+        "amount_due": amount_due,
+        "currency": currency,
+        "period_start": period_start,
+        "period_end": period_end,
+        "line_items": line_items,
+      }
+    )
+    if subscription_id is not UNSET:
+      field_dict["subscription_id"] = subscription_id
+
+    return field_dict
+
+  @classmethod
+  def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+    from ..models.invoice_line_item import InvoiceLineItem
+
+    d = dict(src_dict)
+    amount_due = d.pop("amount_due")
+
+    currency = d.pop("currency")
+
+    period_start = d.pop("period_start")
+
+    period_end = d.pop("period_end")
+
+    line_items = []
+    _line_items = d.pop("line_items")
+    for line_items_item_data in _line_items:
+      line_items_item = InvoiceLineItem.from_dict(line_items_item_data)
+
+      line_items.append(line_items_item)
+
+    def _parse_subscription_id(data: object) -> Union[None, Unset, str]:
+      if data is None:
+        return data
+      if isinstance(data, Unset):
+        return data
+      return cast(Union[None, Unset, str], data)
+
+    subscription_id = _parse_subscription_id(d.pop("subscription_id", UNSET))
+
+    upcoming_invoice = cls(
+      amount_due=amount_due,
+      currency=currency,
+      period_start=period_start,
+      period_end=period_end,
+      line_items=line_items,
+      subscription_id=subscription_id,
+    )
+
+    upcoming_invoice.additional_properties = d
+    return upcoming_invoice
+
+  @property
+  def additional_keys(self) -> list[str]:
+    return list(self.additional_properties.keys())
+
+  def __getitem__(self, key: str) -> Any:
+    return self.additional_properties[key]
+
+  def __setitem__(self, key: str, value: Any) -> None:
+    self.additional_properties[key] = value
+
+  def __delitem__(self, key: str) -> None:
+    del self.additional_properties[key]
+
+  def __contains__(self, key: str) -> bool:
+    return key in self.additional_properties