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

robosystems_client/models/graph_usage_response.py

@@ -1,17 +1,18 @@
 from collections.abc import Mapping
-from typing import TYPE_CHECKING, Any, TypeVar
+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.graph_usage_response_query_statistics import (
-    GraphUsageResponseQueryStatistics,
-  )
-  from ..models.graph_usage_response_recent_activity import (
-    GraphUsageResponseRecentActivity,
+  from ..models.credit_summary import CreditSummary
+  from ..models.graph_usage_response_recent_events_item import (
+    GraphUsageResponseRecentEventsItem,
   )
-  from ..models.graph_usage_response_storage_usage import GraphUsageResponseStorageUsage
+  from ..models.performance_insights import PerformanceInsights
+  from ..models.storage_summary import StorageSummary
 
 
 T = TypeVar("T", bound="GraphUsageResponse")
@@ -23,77 +24,173 @@ class GraphUsageResponse:
 
   Attributes:
       graph_id (str): Graph database identifier
-      storage_usage (GraphUsageResponseStorageUsage): Storage usage information
-      query_statistics (GraphUsageResponseQueryStatistics): Query statistics
-      recent_activity (GraphUsageResponseRecentActivity): Recent activity summary
+      time_range (str): Time range for usage data
       timestamp (str): Usage collection timestamp
+      storage_summary (Union['StorageSummary', None, Unset]): Storage usage summary
+      credit_summary (Union['CreditSummary', None, Unset]): Credit consumption summary
+      performance_insights (Union['PerformanceInsights', None, Unset]): Performance analytics
+      recent_events (Union[Unset, list['GraphUsageResponseRecentEventsItem']]): Recent usage events
   """
 
   graph_id: str
-  storage_usage: "GraphUsageResponseStorageUsage"
-  query_statistics: "GraphUsageResponseQueryStatistics"
-  recent_activity: "GraphUsageResponseRecentActivity"
+  time_range: str
   timestamp: str
+  storage_summary: Union["StorageSummary", None, Unset] = UNSET
+  credit_summary: Union["CreditSummary", None, Unset] = UNSET
+  performance_insights: Union["PerformanceInsights", None, Unset] = UNSET
+  recent_events: Union[Unset, list["GraphUsageResponseRecentEventsItem"]] = UNSET
   additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
 
   def to_dict(self) -> dict[str, Any]:
-    graph_id = self.graph_id
+    from ..models.credit_summary import CreditSummary
+    from ..models.performance_insights import PerformanceInsights
+    from ..models.storage_summary import StorageSummary
 
-    storage_usage = self.storage_usage.to_dict()
-
-    query_statistics = self.query_statistics.to_dict()
+    graph_id = self.graph_id
 
-    recent_activity = self.recent_activity.to_dict()
+    time_range = self.time_range
 
     timestamp = self.timestamp
 
+    storage_summary: Union[None, Unset, dict[str, Any]]
+    if isinstance(self.storage_summary, Unset):
+      storage_summary = UNSET
+    elif isinstance(self.storage_summary, StorageSummary):
+      storage_summary = self.storage_summary.to_dict()
+    else:
+      storage_summary = self.storage_summary
+
+    credit_summary: Union[None, Unset, dict[str, Any]]
+    if isinstance(self.credit_summary, Unset):
+      credit_summary = UNSET
+    elif isinstance(self.credit_summary, CreditSummary):
+      credit_summary = self.credit_summary.to_dict()
+    else:
+      credit_summary = self.credit_summary
+
+    performance_insights: Union[None, Unset, dict[str, Any]]
+    if isinstance(self.performance_insights, Unset):
+      performance_insights = UNSET
+    elif isinstance(self.performance_insights, PerformanceInsights):
+      performance_insights = self.performance_insights.to_dict()
+    else:
+      performance_insights = self.performance_insights
+
+    recent_events: Union[Unset, list[dict[str, Any]]] = UNSET
+    if not isinstance(self.recent_events, Unset):
+      recent_events = []
+      for recent_events_item_data in self.recent_events:
+        recent_events_item = recent_events_item_data.to_dict()
+        recent_events.append(recent_events_item)
+
     field_dict: dict[str, Any] = {}
     field_dict.update(self.additional_properties)
     field_dict.update(
       {
         "graph_id": graph_id,
-        "storage_usage": storage_usage,
-        "query_statistics": query_statistics,
-        "recent_activity": recent_activity,
+        "time_range": time_range,
         "timestamp": timestamp,
       }
     )
+    if storage_summary is not UNSET:
+      field_dict["storage_summary"] = storage_summary
+    if credit_summary is not UNSET:
+      field_dict["credit_summary"] = credit_summary
+    if performance_insights is not UNSET:
+      field_dict["performance_insights"] = performance_insights
+    if recent_events is not UNSET:
+      field_dict["recent_events"] = recent_events
 
     return field_dict
 
   @classmethod
   def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
-    from ..models.graph_usage_response_query_statistics import (
-      GraphUsageResponseQueryStatistics,
-    )
-    from ..models.graph_usage_response_recent_activity import (
-      GraphUsageResponseRecentActivity,
-    )
-    from ..models.graph_usage_response_storage_usage import (
-      GraphUsageResponseStorageUsage,
+    from ..models.credit_summary import CreditSummary
+    from ..models.graph_usage_response_recent_events_item import (
+      GraphUsageResponseRecentEventsItem,
     )
+    from ..models.performance_insights import PerformanceInsights
+    from ..models.storage_summary import StorageSummary
 
     d = dict(src_dict)
     graph_id = d.pop("graph_id")
 
-    storage_usage = GraphUsageResponseStorageUsage.from_dict(d.pop("storage_usage"))
+    time_range = d.pop("time_range")
 
-    query_statistics = GraphUsageResponseQueryStatistics.from_dict(
-      d.pop("query_statistics")
-    )
+    timestamp = d.pop("timestamp")
 
-    recent_activity = GraphUsageResponseRecentActivity.from_dict(
-      d.pop("recent_activity")
+    def _parse_storage_summary(data: object) -> Union["StorageSummary", None, Unset]:
+      if data is None:
+        return data
+      if isinstance(data, Unset):
+        return data
+      try:
+        if not isinstance(data, dict):
+          raise TypeError()
+        storage_summary_type_0 = StorageSummary.from_dict(data)
+
+        return storage_summary_type_0
+      except:  # noqa: E722
+        pass
+      return cast(Union["StorageSummary", None, Unset], data)
+
+    storage_summary = _parse_storage_summary(d.pop("storage_summary", UNSET))
+
+    def _parse_credit_summary(data: object) -> Union["CreditSummary", None, Unset]:
+      if data is None:
+        return data
+      if isinstance(data, Unset):
+        return data
+      try:
+        if not isinstance(data, dict):
+          raise TypeError()
+        credit_summary_type_0 = CreditSummary.from_dict(data)
+
+        return credit_summary_type_0
+      except:  # noqa: E722
+        pass
+      return cast(Union["CreditSummary", None, Unset], data)
+
+    credit_summary = _parse_credit_summary(d.pop("credit_summary", UNSET))
+
+    def _parse_performance_insights(
+      data: object,
+    ) -> Union["PerformanceInsights", None, Unset]:
+      if data is None:
+        return data
+      if isinstance(data, Unset):
+        return data
+      try:
+        if not isinstance(data, dict):
+          raise TypeError()
+        performance_insights_type_0 = PerformanceInsights.from_dict(data)
+
+        return performance_insights_type_0
+      except:  # noqa: E722
+        pass
+      return cast(Union["PerformanceInsights", None, Unset], data)
+
+    performance_insights = _parse_performance_insights(
+      d.pop("performance_insights", UNSET)
     )
 
-    timestamp = d.pop("timestamp")
+    recent_events = []
+    _recent_events = d.pop("recent_events", UNSET)
+    for recent_events_item_data in _recent_events or []:
+      recent_events_item = GraphUsageResponseRecentEventsItem.from_dict(
+        recent_events_item_data
+      )
+
+      recent_events.append(recent_events_item)
 
     graph_usage_response = cls(
       graph_id=graph_id,
-      storage_usage=storage_usage,
-      query_statistics=query_statistics,
-      recent_activity=recent_activity,
+      time_range=time_range,
       timestamp=timestamp,
+      storage_summary=storage_summary,
+      credit_summary=credit_summary,
+      performance_insights=performance_insights,
+      recent_events=recent_events,
     )
 
     graph_usage_response.additional_properties = d

robosystems_client/models/{user_analytics_response_limits.py → graph_usage_response_recent_events_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="UserAnalyticsResponseLimits")
+T = TypeVar("T", bound="GraphUsageResponseRecentEventsItem")
 
 
 @_attrs_define
-class UserAnalyticsResponseLimits:
-  """Current limits and restrictions"""
+class GraphUsageResponseRecentEventsItem:
+  """ """
 
   additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
 
@@ -22,10 +22,10 @@ class UserAnalyticsResponseLimits:
   @classmethod
   def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
     d = dict(src_dict)
-    user_analytics_response_limits = cls()
+    graph_usage_response_recent_events_item = cls()
 
-    user_analytics_response_limits.additional_properties = d
-    return user_analytics_response_limits
+    graph_usage_response_recent_events_item.additional_properties = d
+    return graph_usage_response_recent_events_item
 
   @property
   def additional_keys(self) -> list[str]:

robosystems_client/models/invoice.py

@@ -0,0 +1,244 @@
+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="Invoice")
+
+
+@_attrs_define
+class Invoice:
+  """Invoice information.
+
+  Attributes:
+      id (str): Invoice ID
+      status (str): Invoice status (paid, open, void, uncollectible)
+      amount_due (int): Amount due in cents
+      amount_paid (int): Amount paid in cents
+      currency (str): Currency code (usd)
+      created (str): Invoice creation date (ISO format)
+      line_items (list['InvoiceLineItem']): Invoice line items
+      number (Union[None, Unset, str]): Invoice number
+      due_date (Union[None, Unset, str]): Invoice due date (ISO format)
+      paid_at (Union[None, Unset, str]): Payment date (ISO format)
+      invoice_pdf (Union[None, Unset, str]): PDF download URL
+      hosted_invoice_url (Union[None, Unset, str]): Hosted invoice URL
+      subscription_id (Union[None, Unset, str]): Associated subscription ID
+  """
+
+  id: str
+  status: str
+  amount_due: int
+  amount_paid: int
+  currency: str
+  created: str
+  line_items: list["InvoiceLineItem"]
+  number: Union[None, Unset, str] = UNSET
+  due_date: Union[None, Unset, str] = UNSET
+  paid_at: Union[None, Unset, str] = UNSET
+  invoice_pdf: Union[None, Unset, str] = UNSET
+  hosted_invoice_url: Union[None, Unset, str] = UNSET
+  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]:
+    id = self.id
+
+    status = self.status
+
+    amount_due = self.amount_due
+
+    amount_paid = self.amount_paid
+
+    currency = self.currency
+
+    created = self.created
+
+    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)
+
+    number: Union[None, Unset, str]
+    if isinstance(self.number, Unset):
+      number = UNSET
+    else:
+      number = self.number
+
+    due_date: Union[None, Unset, str]
+    if isinstance(self.due_date, Unset):
+      due_date = UNSET
+    else:
+      due_date = self.due_date
+
+    paid_at: Union[None, Unset, str]
+    if isinstance(self.paid_at, Unset):
+      paid_at = UNSET
+    else:
+      paid_at = self.paid_at
+
+    invoice_pdf: Union[None, Unset, str]
+    if isinstance(self.invoice_pdf, Unset):
+      invoice_pdf = UNSET
+    else:
+      invoice_pdf = self.invoice_pdf
+
+    hosted_invoice_url: Union[None, Unset, str]
+    if isinstance(self.hosted_invoice_url, Unset):
+      hosted_invoice_url = UNSET
+    else:
+      hosted_invoice_url = self.hosted_invoice_url
+
+    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(
+      {
+        "id": id,
+        "status": status,
+        "amount_due": amount_due,
+        "amount_paid": amount_paid,
+        "currency": currency,
+        "created": created,
+        "line_items": line_items,
+      }
+    )
+    if number is not UNSET:
+      field_dict["number"] = number
+    if due_date is not UNSET:
+      field_dict["due_date"] = due_date
+    if paid_at is not UNSET:
+      field_dict["paid_at"] = paid_at
+    if invoice_pdf is not UNSET:
+      field_dict["invoice_pdf"] = invoice_pdf
+    if hosted_invoice_url is not UNSET:
+      field_dict["hosted_invoice_url"] = hosted_invoice_url
+    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)
+    id = d.pop("id")
+
+    status = d.pop("status")
+
+    amount_due = d.pop("amount_due")
+
+    amount_paid = d.pop("amount_paid")
+
+    currency = d.pop("currency")
+
+    created = d.pop("created")
+
+    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_number(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)
+
+    number = _parse_number(d.pop("number", UNSET))
+
+    def _parse_due_date(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)
+
+    due_date = _parse_due_date(d.pop("due_date", UNSET))
+
+    def _parse_paid_at(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)
+
+    paid_at = _parse_paid_at(d.pop("paid_at", UNSET))
+
+    def _parse_invoice_pdf(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)
+
+    invoice_pdf = _parse_invoice_pdf(d.pop("invoice_pdf", UNSET))
+
+    def _parse_hosted_invoice_url(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)
+
+    hosted_invoice_url = _parse_hosted_invoice_url(d.pop("hosted_invoice_url", UNSET))
+
+    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))
+
+    invoice = cls(
+      id=id,
+      status=status,
+      amount_due=amount_due,
+      amount_paid=amount_paid,
+      currency=currency,
+      created=created,
+      line_items=line_items,
+      number=number,
+      due_date=due_date,
+      paid_at=paid_at,
+      invoice_pdf=invoice_pdf,
+      hosted_invoice_url=hosted_invoice_url,
+      subscription_id=subscription_id,
+    )
+
+    invoice.additional_properties = d
+    return 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

robosystems_client/models/invoice_line_item.py

@@ -0,0 +1,118 @@
+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="InvoiceLineItem")
+
+
+@_attrs_define
+class InvoiceLineItem:
+  """Invoice line item.
+
+  Attributes:
+      description (str): Line item description
+      amount (int): Amount in cents
+      quantity (int): Quantity
+      period_start (Union[None, Unset, str]): Billing period start
+      period_end (Union[None, Unset, str]): Billing period end
+  """
+
+  description: str
+  amount: int
+  quantity: int
+  period_start: Union[None, Unset, str] = UNSET
+  period_end: Union[None, Unset, str] = UNSET
+  additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+  def to_dict(self) -> dict[str, Any]:
+    description = self.description
+
+    amount = self.amount
+
+    quantity = self.quantity
+
+    period_start: Union[None, Unset, str]
+    if isinstance(self.period_start, Unset):
+      period_start = UNSET
+    else:
+      period_start = self.period_start
+
+    period_end: Union[None, Unset, str]
+    if isinstance(self.period_end, Unset):
+      period_end = UNSET
+    else:
+      period_end = self.period_end
+
+    field_dict: dict[str, Any] = {}
+    field_dict.update(self.additional_properties)
+    field_dict.update(
+      {
+        "description": description,
+        "amount": amount,
+        "quantity": quantity,
+      }
+    )
+    if period_start is not UNSET:
+      field_dict["period_start"] = period_start
+    if period_end is not UNSET:
+      field_dict["period_end"] = period_end
+
+    return field_dict
+
+  @classmethod
+  def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+    d = dict(src_dict)
+    description = d.pop("description")
+
+    amount = d.pop("amount")
+
+    quantity = d.pop("quantity")
+
+    def _parse_period_start(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)
+
+    period_start = _parse_period_start(d.pop("period_start", UNSET))
+
+    def _parse_period_end(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)
+
+    period_end = _parse_period_end(d.pop("period_end", UNSET))
+
+    invoice_line_item = cls(
+      description=description,
+      amount=amount,
+      quantity=quantity,
+      period_start=period_start,
+      period_end=period_end,
+    )
+
+    invoice_line_item.additional_properties = d
+    return invoice_line_item
+
+  @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