robosystems-client 0.1.10__py3-none-any.whl → 0.1.12__py3-none-any.whl

robosystems_client/models/subgraph_response.py

@@ -0,0 +1,279 @@
+import datetime
+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 dateutil.parser import isoparse
+
+from ..models.subgraph_type import SubgraphType
+from ..types import UNSET, Unset
+
+if TYPE_CHECKING:
+  from ..models.subgraph_response_metadata_type_0 import SubgraphResponseMetadataType0
+
+
+T = TypeVar("T", bound="SubgraphResponse")
+
+
+@_attrs_define
+class SubgraphResponse:
+  """Response model for a subgraph.
+
+  Attributes:
+      graph_id (str): Full subgraph identifier (e.g., kg123_dev)
+      parent_graph_id (str): Parent graph identifier
+      subgraph_index (int): Numeric index of the subgraph
+      subgraph_name (str): Alphanumeric name of the subgraph
+      display_name (str): Human-readable display name
+      subgraph_type (SubgraphType): Types of subgraphs.
+      status (str): Current status of the subgraph
+      created_at (datetime.datetime): When the subgraph was created
+      updated_at (datetime.datetime): When the subgraph was last updated
+      description (Union[None, Unset, str]): Description of the subgraph's purpose
+      size_mb (Union[None, Unset, float]): Size of the subgraph database in megabytes
+      node_count (Union[None, Unset, int]): Number of nodes in the subgraph
+      edge_count (Union[None, Unset, int]): Number of edges in the subgraph
+      last_accessed (Union[None, Unset, datetime.datetime]): When the subgraph was last accessed
+      metadata (Union['SubgraphResponseMetadataType0', None, Unset]): Additional metadata for the subgraph
+  """
+
+  graph_id: str
+  parent_graph_id: str
+  subgraph_index: int
+  subgraph_name: str
+  display_name: str
+  subgraph_type: SubgraphType
+  status: str
+  created_at: datetime.datetime
+  updated_at: datetime.datetime
+  description: Union[None, Unset, str] = UNSET
+  size_mb: Union[None, Unset, float] = UNSET
+  node_count: Union[None, Unset, int] = UNSET
+  edge_count: Union[None, Unset, int] = UNSET
+  last_accessed: Union[None, Unset, datetime.datetime] = UNSET
+  metadata: Union["SubgraphResponseMetadataType0", None, Unset] = UNSET
+  additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+  def to_dict(self) -> dict[str, Any]:
+    from ..models.subgraph_response_metadata_type_0 import SubgraphResponseMetadataType0
+
+    graph_id = self.graph_id
+
+    parent_graph_id = self.parent_graph_id
+
+    subgraph_index = self.subgraph_index
+
+    subgraph_name = self.subgraph_name
+
+    display_name = self.display_name
+
+    subgraph_type = self.subgraph_type.value
+
+    status = self.status
+
+    created_at = self.created_at.isoformat()
+
+    updated_at = self.updated_at.isoformat()
+
+    description: Union[None, Unset, str]
+    if isinstance(self.description, Unset):
+      description = UNSET
+    else:
+      description = self.description
+
+    size_mb: Union[None, Unset, float]
+    if isinstance(self.size_mb, Unset):
+      size_mb = UNSET
+    else:
+      size_mb = self.size_mb
+
+    node_count: Union[None, Unset, int]
+    if isinstance(self.node_count, Unset):
+      node_count = UNSET
+    else:
+      node_count = self.node_count
+
+    edge_count: Union[None, Unset, int]
+    if isinstance(self.edge_count, Unset):
+      edge_count = UNSET
+    else:
+      edge_count = self.edge_count
+
+    last_accessed: Union[None, Unset, str]
+    if isinstance(self.last_accessed, Unset):
+      last_accessed = UNSET
+    elif isinstance(self.last_accessed, datetime.datetime):
+      last_accessed = self.last_accessed.isoformat()
+    else:
+      last_accessed = self.last_accessed
+
+    metadata: Union[None, Unset, dict[str, Any]]
+    if isinstance(self.metadata, Unset):
+      metadata = UNSET
+    elif isinstance(self.metadata, SubgraphResponseMetadataType0):
+      metadata = self.metadata.to_dict()
+    else:
+      metadata = self.metadata
+
+    field_dict: dict[str, Any] = {}
+    field_dict.update(self.additional_properties)
+    field_dict.update(
+      {
+        "graph_id": graph_id,
+        "parent_graph_id": parent_graph_id,
+        "subgraph_index": subgraph_index,
+        "subgraph_name": subgraph_name,
+        "display_name": display_name,
+        "subgraph_type": subgraph_type,
+        "status": status,
+        "created_at": created_at,
+        "updated_at": updated_at,
+      }
+    )
+    if description is not UNSET:
+      field_dict["description"] = description
+    if size_mb is not UNSET:
+      field_dict["size_mb"] = size_mb
+    if node_count is not UNSET:
+      field_dict["node_count"] = node_count
+    if edge_count is not UNSET:
+      field_dict["edge_count"] = edge_count
+    if last_accessed is not UNSET:
+      field_dict["last_accessed"] = last_accessed
+    if metadata is not UNSET:
+      field_dict["metadata"] = metadata
+
+    return field_dict
+
+  @classmethod
+  def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+    from ..models.subgraph_response_metadata_type_0 import SubgraphResponseMetadataType0
+
+    d = dict(src_dict)
+    graph_id = d.pop("graph_id")
+
+    parent_graph_id = d.pop("parent_graph_id")
+
+    subgraph_index = d.pop("subgraph_index")
+
+    subgraph_name = d.pop("subgraph_name")
+
+    display_name = d.pop("display_name")
+
+    subgraph_type = SubgraphType(d.pop("subgraph_type"))
+
+    status = d.pop("status")
+
+    created_at = isoparse(d.pop("created_at"))
+
+    updated_at = isoparse(d.pop("updated_at"))
+
+    def _parse_description(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)
+
+    description = _parse_description(d.pop("description", UNSET))
+
+    def _parse_size_mb(data: object) -> Union[None, Unset, float]:
+      if data is None:
+        return data
+      if isinstance(data, Unset):
+        return data
+      return cast(Union[None, Unset, float], data)
+
+    size_mb = _parse_size_mb(d.pop("size_mb", UNSET))
+
+    def _parse_node_count(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)
+
+    node_count = _parse_node_count(d.pop("node_count", UNSET))
+
+    def _parse_edge_count(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)
+
+    edge_count = _parse_edge_count(d.pop("edge_count", UNSET))
+
+    def _parse_last_accessed(data: object) -> Union[None, Unset, datetime.datetime]:
+      if data is None:
+        return data
+      if isinstance(data, Unset):
+        return data
+      try:
+        if not isinstance(data, str):
+          raise TypeError()
+        last_accessed_type_0 = isoparse(data)
+
+        return last_accessed_type_0
+      except:  # noqa: E722
+        pass
+      return cast(Union[None, Unset, datetime.datetime], data)
+
+    last_accessed = _parse_last_accessed(d.pop("last_accessed", UNSET))
+
+    def _parse_metadata(
+      data: object,
+    ) -> Union["SubgraphResponseMetadataType0", None, Unset]:
+      if data is None:
+        return data
+      if isinstance(data, Unset):
+        return data
+      try:
+        if not isinstance(data, dict):
+          raise TypeError()
+        metadata_type_0 = SubgraphResponseMetadataType0.from_dict(data)
+
+        return metadata_type_0
+      except:  # noqa: E722
+        pass
+      return cast(Union["SubgraphResponseMetadataType0", None, Unset], data)
+
+    metadata = _parse_metadata(d.pop("metadata", UNSET))
+
+    subgraph_response = cls(
+      graph_id=graph_id,
+      parent_graph_id=parent_graph_id,
+      subgraph_index=subgraph_index,
+      subgraph_name=subgraph_name,
+      display_name=display_name,
+      subgraph_type=subgraph_type,
+      status=status,
+      created_at=created_at,
+      updated_at=updated_at,
+      description=description,
+      size_mb=size_mb,
+      node_count=node_count,
+      edge_count=edge_count,
+      last_accessed=last_accessed,
+      metadata=metadata,
+    )
+
+    subgraph_response.additional_properties = d
+    return subgraph_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/{get_mcp_health_response_getmcphealth.py → subgraph_response_metadata_type_0.py}

@@ -4,11 +4,11 @@ from typing import Any, TypeVar
 from attrs import define as _attrs_define
 from attrs import field as _attrs_field
 
-T = TypeVar("T", bound="GetMCPHealthResponseGetmcphealth")
+T = TypeVar("T", bound="SubgraphResponseMetadataType0")
 
 
 @_attrs_define
-class GetMCPHealthResponseGetmcphealth:
+class SubgraphResponseMetadataType0:
   """ """
 
   additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
@@ -22,10 +22,10 @@ class GetMCPHealthResponseGetmcphealth:
   @classmethod
   def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
     d = dict(src_dict)
-    get_mcp_health_response_getmcphealth = cls()
+    subgraph_response_metadata_type_0 = cls()
 
-    get_mcp_health_response_getmcphealth.additional_properties = d
-    return get_mcp_health_response_getmcphealth
+    subgraph_response_metadata_type_0.additional_properties = d
+    return subgraph_response_metadata_type_0
 
   @property
   def additional_keys(self) -> list[str]:

robosystems_client/models/subgraph_summary.py

@@ -0,0 +1,155 @@
+import datetime
+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 dateutil.parser import isoparse
+
+from ..models.subgraph_type import SubgraphType
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="SubgraphSummary")
+
+
+@_attrs_define
+class SubgraphSummary:
+  """Summary model for listing subgraphs.
+
+  Attributes:
+      graph_id (str): Full subgraph identifier
+      subgraph_name (str): Alphanumeric name
+      display_name (str): Human-readable name
+      subgraph_type (SubgraphType): Types of subgraphs.
+      status (str): Current status
+      created_at (datetime.datetime): Creation timestamp
+      size_mb (Union[None, Unset, float]): Size in megabytes
+      last_accessed (Union[None, Unset, datetime.datetime]): Last access timestamp
+  """
+
+  graph_id: str
+  subgraph_name: str
+  display_name: str
+  subgraph_type: SubgraphType
+  status: str
+  created_at: datetime.datetime
+  size_mb: Union[None, Unset, float] = UNSET
+  last_accessed: Union[None, Unset, datetime.datetime] = UNSET
+  additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+  def to_dict(self) -> dict[str, Any]:
+    graph_id = self.graph_id
+
+    subgraph_name = self.subgraph_name
+
+    display_name = self.display_name
+
+    subgraph_type = self.subgraph_type.value
+
+    status = self.status
+
+    created_at = self.created_at.isoformat()
+
+    size_mb: Union[None, Unset, float]
+    if isinstance(self.size_mb, Unset):
+      size_mb = UNSET
+    else:
+      size_mb = self.size_mb
+
+    last_accessed: Union[None, Unset, str]
+    if isinstance(self.last_accessed, Unset):
+      last_accessed = UNSET
+    elif isinstance(self.last_accessed, datetime.datetime):
+      last_accessed = self.last_accessed.isoformat()
+    else:
+      last_accessed = self.last_accessed
+
+    field_dict: dict[str, Any] = {}
+    field_dict.update(self.additional_properties)
+    field_dict.update(
+      {
+        "graph_id": graph_id,
+        "subgraph_name": subgraph_name,
+        "display_name": display_name,
+        "subgraph_type": subgraph_type,
+        "status": status,
+        "created_at": created_at,
+      }
+    )
+    if size_mb is not UNSET:
+      field_dict["size_mb"] = size_mb
+    if last_accessed is not UNSET:
+      field_dict["last_accessed"] = last_accessed
+
+    return field_dict
+
+  @classmethod
+  def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+    d = dict(src_dict)
+    graph_id = d.pop("graph_id")
+
+    subgraph_name = d.pop("subgraph_name")
+
+    display_name = d.pop("display_name")
+
+    subgraph_type = SubgraphType(d.pop("subgraph_type"))
+
+    status = d.pop("status")
+
+    created_at = isoparse(d.pop("created_at"))
+
+    def _parse_size_mb(data: object) -> Union[None, Unset, float]:
+      if data is None:
+        return data
+      if isinstance(data, Unset):
+        return data
+      return cast(Union[None, Unset, float], data)
+
+    size_mb = _parse_size_mb(d.pop("size_mb", UNSET))
+
+    def _parse_last_accessed(data: object) -> Union[None, Unset, datetime.datetime]:
+      if data is None:
+        return data
+      if isinstance(data, Unset):
+        return data
+      try:
+        if not isinstance(data, str):
+          raise TypeError()
+        last_accessed_type_0 = isoparse(data)
+
+        return last_accessed_type_0
+      except:  # noqa: E722
+        pass
+      return cast(Union[None, Unset, datetime.datetime], data)
+
+    last_accessed = _parse_last_accessed(d.pop("last_accessed", UNSET))
+
+    subgraph_summary = cls(
+      graph_id=graph_id,
+      subgraph_name=subgraph_name,
+      display_name=display_name,
+      subgraph_type=subgraph_type,
+      status=status,
+      created_at=created_at,
+      size_mb=size_mb,
+      last_accessed=last_accessed,
+    )
+
+    subgraph_summary.additional_properties = d
+    return subgraph_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/subgraph_type.py

@@ -0,0 +1,11 @@
+from enum import Enum
+
+
+class SubgraphType(str, Enum):
+  MEMORY = "memory"
+  STATIC = "static"
+  TEMPORAL = "temporal"
+  VERSIONED = "versioned"
+
+  def __str__(self) -> str:
+    return str(self.value)

robosystems_client/models/subscription_info.py

@@ -23,12 +23,10 @@ class SubscriptionInfo:
       addon_type (str): Add-on type
       addon_tier (str): Subscription tier
       is_active (bool): Whether subscription is active
-      is_trial (bool): Whether this is a trial subscription
       activated_at (str): Activation date (ISO format)
       monthly_price_cents (int): Monthly price in cents
       features (list[str]): List of features
       metadata (SubscriptionInfoMetadata): Additional metadata
-      trial_ends_at (Union[None, Unset, str]): Trial expiration date (ISO format)
       expires_at (Union[None, Unset, str]): Expiration date (ISO format)
   """
 
@@ -37,12 +35,10 @@ class SubscriptionInfo:
   addon_type: str
   addon_tier: str
   is_active: bool
-  is_trial: bool
   activated_at: str
   monthly_price_cents: int
   features: list[str]
   metadata: "SubscriptionInfoMetadata"
-  trial_ends_at: Union[None, Unset, str] = UNSET
   expires_at: Union[None, Unset, str] = UNSET
   additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
 
@@ -57,8 +53,6 @@ class SubscriptionInfo:
 
     is_active = self.is_active
 
-    is_trial = self.is_trial
-
     activated_at = self.activated_at
 
     monthly_price_cents = self.monthly_price_cents
@@ -67,12 +61,6 @@ class SubscriptionInfo:
 
     metadata = self.metadata.to_dict()
 
-    trial_ends_at: Union[None, Unset, str]
-    if isinstance(self.trial_ends_at, Unset):
-      trial_ends_at = UNSET
-    else:
-      trial_ends_at = self.trial_ends_at
-
     expires_at: Union[None, Unset, str]
     if isinstance(self.expires_at, Unset):
       expires_at = UNSET
@@ -88,15 +76,12 @@ class SubscriptionInfo:
         "addon_type": addon_type,
         "addon_tier": addon_tier,
         "is_active": is_active,
-        "is_trial": is_trial,
         "activated_at": activated_at,
         "monthly_price_cents": monthly_price_cents,
         "features": features,
         "metadata": metadata,
       }
     )
-    if trial_ends_at is not UNSET:
-      field_dict["trial_ends_at"] = trial_ends_at
     if expires_at is not UNSET:
       field_dict["expires_at"] = expires_at
 
@@ -117,8 +102,6 @@ class SubscriptionInfo:
 
     is_active = d.pop("is_active")
 
-    is_trial = d.pop("is_trial")
-
     activated_at = d.pop("activated_at")
 
     monthly_price_cents = d.pop("monthly_price_cents")
@@ -127,15 +110,6 @@ class SubscriptionInfo:
 
     metadata = SubscriptionInfoMetadata.from_dict(d.pop("metadata"))
 
-    def _parse_trial_ends_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)
-
-    trial_ends_at = _parse_trial_ends_at(d.pop("trial_ends_at", UNSET))
-
     def _parse_expires_at(data: object) -> Union[None, Unset, str]:
       if data is None:
         return data
@@ -151,12 +125,10 @@ class SubscriptionInfo:
       addon_type=addon_type,
       addon_tier=addon_tier,
       is_active=is_active,
-      is_trial=is_trial,
       activated_at=activated_at,
       monthly_price_cents=monthly_price_cents,
       features=features,
       metadata=metadata,
-      trial_ends_at=trial_ends_at,
       expires_at=expires_at,
     )
 

robosystems_client/models/subscription_request.py

@@ -18,12 +18,10 @@ class SubscriptionRequest:
   Attributes:
       repository_type (RepositoryType): Types of shared repositories.
       repository_plan (Union[Unset, RepositoryPlan]): Repository access plans for shared data.
-      is_trial (Union[Unset, bool]): Start with trial period Default: False.
   """
 
   repository_type: RepositoryType
   repository_plan: Union[Unset, RepositoryPlan] = UNSET
-  is_trial: Union[Unset, bool] = False
   additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
 
   def to_dict(self) -> dict[str, Any]:
@@ -33,8 +31,6 @@ class SubscriptionRequest:
     if not isinstance(self.repository_plan, Unset):
       repository_plan = self.repository_plan.value
 
-    is_trial = self.is_trial
-
     field_dict: dict[str, Any] = {}
     field_dict.update(self.additional_properties)
     field_dict.update(
@@ -44,8 +40,6 @@ class SubscriptionRequest:
     )
     if repository_plan is not UNSET:
       field_dict["repository_plan"] = repository_plan
-    if is_trial is not UNSET:
-      field_dict["is_trial"] = is_trial
 
     return field_dict
 
@@ -61,12 +55,9 @@ class SubscriptionRequest:
     else:
       repository_plan = RepositoryPlan(_repository_plan)
 
-    is_trial = d.pop("is_trial", UNSET)
-
     subscription_request = cls(
       repository_type=repository_type,
       repository_plan=repository_plan,
-      is_trial=is_trial,
     )
 
     subscription_request.additional_properties = d

robosystems_client/models/subscription_response.py

@@ -18,12 +18,10 @@ class SubscriptionResponse:
   Attributes:
       message (str): Success message
       subscription (SubscriptionInfo): User subscription information.
-      trial_period (int): Trial period in days
   """
 
   message: str
   subscription: "SubscriptionInfo"
-  trial_period: int
   additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
 
   def to_dict(self) -> dict[str, Any]:
@@ -31,15 +29,12 @@ class SubscriptionResponse:
 
     subscription = self.subscription.to_dict()
 
-    trial_period = self.trial_period
-
     field_dict: dict[str, Any] = {}
     field_dict.update(self.additional_properties)
     field_dict.update(
       {
         "message": message,
         "subscription": subscription,
-        "trial_period": trial_period,
       }
     )
 
@@ -54,12 +49,9 @@ class SubscriptionResponse:
 
     subscription = SubscriptionInfo.from_dict(d.pop("subscription"))
 
-    trial_period = d.pop("trial_period")
-
     subscription_response = cls(
       message=message,
       subscription=subscription,
-      trial_period=trial_period,
     )
 
     subscription_response.additional_properties = d

robosystems_client/sdk-config.yaml

@@ -1,5 +1,5 @@
 class_name: RoboSystemsClient
 package_name: robosystems_client
 project_name: robosystems-sdk
-package_description: "Python SDK for RoboSystems financial graph database API"
+package_description: "Python Client for RoboSystems financial graph database API"
 package_version: "0.1.0"

{robosystems_client-0.1.10.dist-info → robosystems_client-0.1.12.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: robosystems-client
-Version: 0.1.10
+Version: 0.1.12
 Summary: Python Client for RoboSystems financial graph database API
 Author: Harbinger FinLab
 License: MIT