robosystems-client 0.2.8__py3-none-any.whl → 0.2.10__py3-none-any.whl

robosystems_client/models/graph_subscription_response.py

@@ -0,0 +1,200 @@
+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="GraphSubscriptionResponse")
+
+
+@_attrs_define
+class GraphSubscriptionResponse:
+  """Response for graph or repository subscription details.
+
+  Attributes:
+      id (str): Subscription ID
+      resource_type (str): Resource type (graph or repository)
+      resource_id (str): Resource identifier
+      plan_name (str): Current plan name
+      billing_interval (str): Billing interval
+      status (str): Subscription status
+      base_price_cents (int): Base price in cents
+      created_at (str): Creation timestamp
+      current_period_start (Union[None, Unset, str]): Current billing period start
+      current_period_end (Union[None, Unset, str]): Current billing period end
+      started_at (Union[None, Unset, str]): Subscription start date
+      canceled_at (Union[None, Unset, str]): Cancellation date
+  """
+
+  id: str
+  resource_type: str
+  resource_id: str
+  plan_name: str
+  billing_interval: str
+  status: str
+  base_price_cents: int
+  created_at: str
+  current_period_start: Union[None, Unset, str] = UNSET
+  current_period_end: Union[None, Unset, str] = UNSET
+  started_at: Union[None, Unset, str] = UNSET
+  canceled_at: 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
+
+    resource_type = self.resource_type
+
+    resource_id = self.resource_id
+
+    plan_name = self.plan_name
+
+    billing_interval = self.billing_interval
+
+    status = self.status
+
+    base_price_cents = self.base_price_cents
+
+    created_at = self.created_at
+
+    current_period_start: Union[None, Unset, str]
+    if isinstance(self.current_period_start, Unset):
+      current_period_start = UNSET
+    else:
+      current_period_start = self.current_period_start
+
+    current_period_end: Union[None, Unset, str]
+    if isinstance(self.current_period_end, Unset):
+      current_period_end = UNSET
+    else:
+      current_period_end = self.current_period_end
+
+    started_at: Union[None, Unset, str]
+    if isinstance(self.started_at, Unset):
+      started_at = UNSET
+    else:
+      started_at = self.started_at
+
+    canceled_at: Union[None, Unset, str]
+    if isinstance(self.canceled_at, Unset):
+      canceled_at = UNSET
+    else:
+      canceled_at = self.canceled_at
+
+    field_dict: dict[str, Any] = {}
+    field_dict.update(self.additional_properties)
+    field_dict.update(
+      {
+        "id": id,
+        "resource_type": resource_type,
+        "resource_id": resource_id,
+        "plan_name": plan_name,
+        "billing_interval": billing_interval,
+        "status": status,
+        "base_price_cents": base_price_cents,
+        "created_at": created_at,
+      }
+    )
+    if current_period_start is not UNSET:
+      field_dict["current_period_start"] = current_period_start
+    if current_period_end is not UNSET:
+      field_dict["current_period_end"] = current_period_end
+    if started_at is not UNSET:
+      field_dict["started_at"] = started_at
+    if canceled_at is not UNSET:
+      field_dict["canceled_at"] = canceled_at
+
+    return field_dict
+
+  @classmethod
+  def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+    d = dict(src_dict)
+    id = d.pop("id")
+
+    resource_type = d.pop("resource_type")
+
+    resource_id = d.pop("resource_id")
+
+    plan_name = d.pop("plan_name")
+
+    billing_interval = d.pop("billing_interval")
+
+    status = d.pop("status")
+
+    base_price_cents = d.pop("base_price_cents")
+
+    created_at = d.pop("created_at")
+
+    def _parse_current_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)
+
+    current_period_start = _parse_current_period_start(
+      d.pop("current_period_start", UNSET)
+    )
+
+    def _parse_current_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)
+
+    current_period_end = _parse_current_period_end(d.pop("current_period_end", UNSET))
+
+    def _parse_started_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)
+
+    started_at = _parse_started_at(d.pop("started_at", UNSET))
+
+    def _parse_canceled_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)
+
+    canceled_at = _parse_canceled_at(d.pop("canceled_at", UNSET))
+
+    graph_subscription_response = cls(
+      id=id,
+      resource_type=resource_type,
+      resource_id=resource_id,
+      plan_name=plan_name,
+      billing_interval=billing_interval,
+      status=status,
+      base_price_cents=base_price_cents,
+      created_at=created_at,
+      current_period_start=current_period_start,
+      current_period_end=current_period_end,
+      started_at=started_at,
+      canceled_at=canceled_at,
+    )
+
+    graph_subscription_response.additional_properties = d
+    return graph_subscription_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/graph_tier_instance.py

@@ -13,13 +13,13 @@ class GraphTierInstance:
 
   Attributes:
       type_ (str): Instance type identifier
-      memory_mb (int): Memory in megabytes
-      databases_per_instance (int): Databases per instance
+      memory_mb (int): Memory allocated to your graph in megabytes
+      is_multitenant (bool): Whether this tier shares infrastructure with other graphs
   """
 
   type_: str
   memory_mb: int
-  databases_per_instance: int
+  is_multitenant: bool
   additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
 
   def to_dict(self) -> dict[str, Any]:
@@ -27,7 +27,7 @@ class GraphTierInstance:
 
     memory_mb = self.memory_mb
 
-    databases_per_instance = self.databases_per_instance
+    is_multitenant = self.is_multitenant
 
     field_dict: dict[str, Any] = {}
     field_dict.update(self.additional_properties)
@@ -35,7 +35,7 @@ class GraphTierInstance:
       {
         "type": type_,
         "memory_mb": memory_mb,
-        "databases_per_instance": databases_per_instance,
+        "is_multitenant": is_multitenant,
       }
     )
 
@@ -48,12 +48,12 @@ class GraphTierInstance:
 
     memory_mb = d.pop("memory_mb")
 
-    databases_per_instance = d.pop("databases_per_instance")
+    is_multitenant = d.pop("is_multitenant")
 
     graph_tier_instance = cls(
       type_=type_,
       memory_mb=memory_mb,
-      databases_per_instance=databases_per_instance,
+      is_multitenant=is_multitenant,
     )
 
     graph_tier_instance.additional_properties = d

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/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]: