Added create container grpc method

Signed-off-by: Ilyas Niyazov <i.niyazov@yadro.com>

frostfs_sdk/models/dto/container.py

@@ -0,0 +1,25 @@
+from dataclasses import dataclass, field
+from typing import Dict, Optional
+import uuid
+
+from frostfs_sdk.models.enums.basic_acl import BasicAcl
+from frostfs_sdk.models.dto.placement_policy import PlacementPolicy
+
+
+
+@dataclass
+class Container:
+    basicAcl: BasicAcl
+    placementPolicy: PlacementPolicy
+    nonce: uuid.UUID = field(default_factory=uuid.uuid4)
+    version: Optional[str] = None
+    attributes: Dict[str, str] = field(default_factory=dict)
+
+    def __init__(self, basicAcl: BasicAcl, placementPolicy: PlacementPolicy):
+        self.basicAcl = basicAcl
+        self.placementPolicy = placementPolicy
+
+
+@dataclass
+class ContainerId:
+    value: str

frostfs_sdk/models/dto/filter.py

@@ -0,0 +1,14 @@
+from dataclasses import dataclass
+
+from frostfs_sdk.models.enums.filter_operation import FilterOperation
+
+
+@dataclass(frozen=True)
+class Filter:
+    """
+    Data Transfer Object for Filter configuration
+    """
+    name: str
+    key: str
+    operation: FilterOperation
+    value: str

frostfs_sdk/models/dto/placement_policy.py

@@ -0,0 +1,9 @@
+from dataclasses import dataclass
+from typing import List
+
+from frostfs_sdk.models.dto.replica import Replica
+
+@dataclass
+class PlacementPolicy:
+    replicas: List[Replica]
+    unique: bool

frostfs_sdk/models/dto/replica.py

@@ -0,0 +1,12 @@
+from dataclasses import dataclass, field
+
+
+EMPTY_STRING = ""
+
+@dataclass
+class Replica:
+    count: int
+    selector: str = field(default=EMPTY_STRING)
+
+    def __post_init__(self):
+        self.selector = self.selector if self.selector else EMPTY_STRING

frostfs_sdk/models/dto/selector.py

@@ -0,0 +1,15 @@
+from dataclasses import dataclass
+
+from frostfs_sdk.models.enums.selector_clause import SelectorClause
+
+
+@dataclass(frozen=True)
+class Selector:
+    """
+    Data Transfer Object for Selector configuration
+    """
+    name: str
+    count: int
+    clause: SelectorClause
+    attribute: str
+    filter: str

frostfs_sdk/models/dto/session_token.py

@@ -0,0 +1,5 @@
+from dataclasses import dataclass
+
+@dataclass(frozen=True)
+class SessionToken:
+    token: bytes

frostfs_sdk/models/enums/basic_acl.py

@@ -0,0 +1,7 @@
+from enum import Enum
+
+class BasicAcl(Enum):
+    PRIVATE = 0x1C8C8CCC
+    PUBLIC_RO = 0x1FBF8CFF
+    PUBLIC_RW = 0x1FBFBFFF
+    PUBLIC_APPEND = 0x1FBF9FFF

frostfs_sdk/models/enums/filter_operation.py

@@ -0,0 +1,42 @@
+class FilterOperation:
+    """
+    Enum for filter operations with integer value mapping
+    """
+    OPERATION_UNSPECIFIED = 0
+    EQ = 1
+    NE = 2
+    GT = 3
+    GE = 4
+    LT = 5
+    LE = 6
+    OR = 7
+    AND = 8
+    NOT = 9
+    LIKE = 10
+
+    _value_map = {
+        0: OPERATION_UNSPECIFIED,
+        1: EQ,
+        2: NE,
+        3: GT,
+        4: GE,
+        5: LT,
+        6: LE,
+        7: OR,
+        8: AND,
+        9: NOT,
+        10: LIKE
+    }
+
+    @classmethod
+    def get(cls, value: int) -> 'FilterOperation':
+        """
+        Get enum instance by integer value
+        
+        Args:
+            value: Integer value of the operation
+            
+        Returns:
+            Corresponding FilterOperation instance
+        """
+        return cls._value_map.get(value)

frostfs_sdk/models/enums/selector_clause.py

@@ -0,0 +1,26 @@
+class SelectorClause:
+    """
+    Enum for selector clauses with integer value mapping
+    """
+    CLAUSE_UNSPECIFIED = 0
+    SAME = 1
+    DISTINCT = 2
+
+    _value_map = {
+        0: CLAUSE_UNSPECIFIED,
+        1: SAME,
+        2: DISTINCT
+    }
+
+    @classmethod
+    def get(cls, value: int) -> 'SelectorClause':
+        """
+        Get enum instance by integer value
+        
+        Args:
+            value: Integer value of the clause
+            
+        Returns:
+            Corresponding SelectorClause instance
+        """
+        return cls._value_map.get(value)

frostfs_sdk/models/mappers/container_mapper.py

@@ -0,0 +1,65 @@
+from typing import ByteString, Optional
+
+from frostfs_sdk.models.mappers.placement_policy_mapper import PlacementPolicyMapper
+import protos.models.container.types_pb2 as types_pb2_container
+from frostfs_sdk.models.dto.container import Container
+
+
+class ContainerMapper:
+    @staticmethod
+    def to_grpc_message(container: Container) -> Optional[types_pb2_container.Container]:
+        """
+        Converts Container DTO to gRPC message
+        
+        Args:
+            container: Container DTO object
+            
+        Returns:
+            gRPC Container message builder
+        """
+        if not container:
+            return None
+        
+        attributes = [
+            types_pb2_container.Container.Attribute(key=k, value=v)
+            for k, v in container.attributes.items()
+        ]
+        
+        grpc_container = types_pb2_container.Container(
+            # nonce=ByteString.copy(container.nonce),
+            placement_policy=PlacementPolicyMapper.to_grpc_message(container.placementPolicy),
+            attributes=attributes
+
+        )
+        
+        # if container.owner_id:
+        #     grpc_container.owner_id = OwnerIdMapper.to_grpc_message(container.owner_id)
+            
+        # if container.version:
+        #     grpc_container.version = VersionMapper.to_grpc_message(container.version)
+            
+        return grpc_container
+
+    @staticmethod
+    def to_model(container_grpc: types_pb2_container.Container) -> Optional[Container]:
+        """
+        Converts gRPC message to Container DTO
+        
+        Args:
+            container_grpc: gRPC Container message
+            
+        Returns:
+            Container DTO object
+        """
+        if not container_grpc or container_grpc.ByteSize() == 0:
+            return None
+        
+        attributes = {attr.key: attr.value for attr in container_grpc.attributes}
+        
+        return Container(
+            # nonce=UuidUtils.as_uuid(container_grpc.nonce.to_bytes()),
+            placement_policy=PlacementPolicyMapper.to_model(container_grpc.placement_policy),
+            # version=VersionMapper.to_model(container_grpc.version),
+            # owner_id=OwnerIdMapper.to_model(container_grpc.owner_id),
+            attributes=attributes
+        )

frostfs_sdk/models/mappers/filter_mapper.py

@@ -0,0 +1,60 @@
+from typing import List, Optional
+
+from frostfs_sdk.models.enums.filter_operation import FilterOperation
+from frostfs_sdk.models.dto.filter import Filter
+import protos.models.netmap.types_pb2 as types_pb2_netmap
+
+
+class FilterMapper:
+    @staticmethod
+    def to_grpc_messages(filters: List[Filter]) -> List[types_pb2_netmap.Filter]:
+        """
+        Converts list of Filter DTOs to gRPC messages with nested conversion
+        """
+        if not filters:
+            return []
+        
+        return [FilterMapper.to_grpc_message(f) for f in filters]
+
+    @staticmethod
+    def to_grpc_message(filter_dto: Filter) -> types_pb2_netmap.Filter:
+        """
+        Converts Filter DTO to gRPC message with nested filters
+        """
+
+        operation = types_pb2_netmap.Filter.Operation.Value(filter_dto.operation.value)        
+        return types_pb2_netmap.Filter(
+            name=filter_dto.name,
+            key=filter_dto.key,
+            op=operation,
+            value=filter_dto.value,
+            filters=FilterMapper.to_grpc_messages(filter_dto.filters)
+        )
+
+    @staticmethod
+    def to_models(filters_grpc: List[types_pb2_netmap.Filter]) -> Optional[List[Filter]]:
+        """
+        Converts gRPC messages to Filter DTOs with nested conversion
+        """
+        if not filters_grpc:
+            return None
+        
+        return [FilterMapper.to_model(f) for f in filters_grpc]
+
+    @staticmethod
+    def to_model(filter_grpc: types_pb2_netmap.Filter) -> Optional[Filter]:
+        """
+        Converts gRPC message to Filter DTO with nested filters
+        """
+        if not filter_grpc or filter_grpc.ByteSize() == 0:
+            return None
+        
+        operation = FilterOperation(filter_grpc.op)
+        
+        return Filter(
+            name=filter_grpc.name,
+            key=filter_grpc.key,
+            operation=operation,
+            value=filter_grpc.value,
+            filters=FilterMapper.to_models(filter_grpc.filters)
+        )

frostfs_sdk/models/mappers/placement_policy_mapper.py

@@ -0,0 +1,50 @@
+from typing import Optional
+from frostfs_sdk.models.mappers.filter_mapper import FilterMapper
+import protos.models.netmap.types_pb2 as types_pb2_netmap
+from frostfs_sdk.models.dto.placement_policy import PlacementPolicy
+
+
+class PlacementPolicyMapper:
+    @staticmethod
+    def to_grpc_message(policy: PlacementPolicy) -> Optional[types_pb2_netmap.PlacementPolicy]:
+        """
+        Converts PlacementPolicy DTO to gRPC message
+        
+        Args:
+            policy: PlacementPolicy DTO object
+            
+        Returns:
+            gRPC PlacementPolicy message
+        """
+        if not policy:
+            return None
+        
+        return types_pb2_netmap.PlacementPolicy(
+            unique=policy.unique,
+            container_backup_factor=policy.backup_factor,
+            filters=FilterMapper.to_grpc_messages(policy.filters),
+            # selectors=SelectorMapper.to_grpc_messages(policy.selectors),
+            # replicas=ReplicaMapper.to_grpc_messages(policy.replicas)
+        )
+
+    @staticmethod
+    def to_model(policy_grpc: types_pb2_netmap.PlacementPolicy) -> Optional[PlacementPolicy]:
+        """
+        Converts gRPC message to PlacementPolicy DTO
+        
+        Args:
+            policy_grpc: gRPC PlacementPolicy message
+            
+        Returns:
+            PlacementPolicy DTO object
+        """
+        if not policy_grpc or policy_grpc.ByteSize() == 0:
+            return None
+        
+        return PlacementPolicy(
+            # replicas=ReplicaMapper.to_models(policy_grpc.replicas),
+            unique=policy_grpc.unique,
+            backup_factor=policy_grpc.container_backup_factor,
+            filters=FilterMapper.to_models(policy_grpc.filters),
+            # selectors=SelectorMapper.to_models(policy_grpc.selectors)
+        )