DipsScripting 9.1.0__py3-none-any.whl

dips/TraverseEntityVisibilityVal.py

@@ -0,0 +1,100 @@
+"""Generated wrapper for TraverseEntityVisibility protobuf message."""
+
+from typing import Any, Optional, List, Dict
+from . import DipsAPI_pb2
+
+from .ProtobufCollectionWrappers import _ProtobufListWrapper, _ProtobufMapWrapper
+
+from .TraverseEntityOptionsVal import TraverseEntityOptionsVal
+from .OrientationDataSetRef import OrientationDataSetRef
+
+class TraverseEntityVisibilityVal:
+    """Simple wrapper for TraverseEntityVisibility with Pythonic getters and setters."""
+
+    _proto_class = DipsAPI_pb2.TraverseEntityVisibility
+
+
+    def __init__(self, options: Optional[TraverseEntityOptionsVal] = None, traverse_entity_reference: Optional[OrientationDataSetRef] = None, proto_message: Optional[Any] = None, channel_to_connect_on: Optional[Any] = None):
+        """Initialize the TraverseEntityVisibility wrapper."""
+        # Initialize the protobuf message
+        if proto_message is not None:
+            self._proto_message = proto_message
+        else:
+            self._proto_message = self._proto_class()
+
+        # Store channel for reference types
+        self.__channelToConnectOn = channel_to_connect_on
+
+        if options is not None:
+            self._proto_message.Options.CopyFrom(options.to_proto())
+            self._options_wrapper = options
+        if traverse_entity_reference is not None:
+            self.traverse_entity_reference = traverse_entity_reference
+
+
+    # Properties
+
+    @property
+    def is_visible(self) -> bool:
+        """Get the IsVisible field value."""
+        return self._proto_message.IsVisible
+    
+    @is_visible.setter
+    def is_visible(self, value: bool) -> None:
+        """Set the IsVisible field value."""
+        self._proto_message.IsVisible = value
+
+
+    @property
+    def options(self) -> TraverseEntityOptionsVal:
+        """Get the Options field as a wrapper."""
+        if not hasattr(self, '_options_wrapper'):
+            self._options_wrapper = TraverseEntityOptionsVal(proto_message=self._proto_message.Options)
+        return self._options_wrapper
+    
+    @options.setter
+    def options(self, value: TraverseEntityOptionsVal) -> None:
+        """Set the Options field to a wrapper."""
+        self._proto_message.Options.CopyFrom(value.to_proto())
+        # Update the cached wrapper if it exists
+        if hasattr(self, '_options_wrapper'):
+            self._options_wrapper._proto_message.CopyFrom(self._proto_message.Options)
+
+
+    @property
+    def traverse_entity_reference(self) -> OrientationDataSetRef:
+        """Get the TraverseEntityReference field as a reference."""
+        return OrientationDataSetRef(self.__channelToConnectOn, self._proto_message.TraverseEntityReference)
+    
+    @traverse_entity_reference.setter
+    def traverse_entity_reference(self, value: OrientationDataSetRef) -> None:
+        """Set the TraverseEntityReference field to a reference."""
+        self._proto_message.TraverseEntityReference.CopyFrom(value.get_model_ref())
+
+
+    # Utility methods
+
+    def to_proto(self):
+        """Get the underlying protobuf message."""
+        return self._proto_message
+    
+    @classmethod
+    def from_proto(cls, proto_message):
+        """Create wrapper from existing protobuf message."""
+        wrapper = cls()
+        wrapper._proto_message.CopyFrom(proto_message)
+        return wrapper
+    
+    def copy(self):
+        """Create a copy of this wrapper."""
+        new_wrapper = self.__class__()
+        new_wrapper._proto_message.CopyFrom(self._proto_message)
+        return new_wrapper
+    
+    def __str__(self) -> str:
+        """String representation."""
+        return f"{self.__class__.__name__}({self._proto_message})"
+    
+    def __repr__(self) -> str:
+        """Detailed string representation."""
+        return f"{self.__class__.__name__}({self._proto_message})"

dips/TrendLineToolEntityInfoRef.py

@@ -0,0 +1,43 @@
+from typing import List
+from . import DipsAPI_pb2_grpc
+from . import DipsAPI_pb2
+from .TrendLineToolEntityInfoVal import TrendLineToolEntityInfoVal
+from .TrendLineToolEntityInfoVal import TrendLineToolEntityInfoVal
+from .ValidatableResultVal import ValidatableResultVal
+
+class TrendLineToolEntityInfoRef:
+    def __init__(self, channelToConnectOn, ref: DipsAPI_pb2.ProtoReference_TrendLineToolEntityInfo):
+        self.__modelRef = ref
+        self.__refManagerStub = DipsAPI_pb2_grpc.nSameModuleReferenceAccessorStub(channelToConnectOn)
+        self.__channelToConnectOn = channelToConnectOn
+        self.__EntityServicesStubLocal = DipsAPI_pb2_grpc.EntityServicesStub(channelToConnectOn)
+
+    
+    def GetValue(self) -> TrendLineToolEntityInfoVal:
+        bytes = self.__refManagerStub.GetValue(self.__modelRef.ID)
+        ret = DipsAPI_pb2.TrendLineToolEntityInfo()
+        ret.MergeFromString(bytes.data)
+        return TrendLineToolEntityInfoVal.from_proto(ret)
+    
+    def get_model_ref(self):
+        """Get the underlying model reference for direct protobuf operations."""
+        return self.__modelRef
+    
+    def RemoveTrendLineTool(self):
+        functionParam = DipsAPI_pb2.ProtoMemberFunction_ProtoReference_TrendLineToolEntityInfo(This=self.__modelRef)
+        ret = self.__EntityServicesStubLocal.RemoveTrendLineTool(functionParam)
+        
+
+    def SetTrendLineToolVisibility(self,  Boolean: bool):
+        functionParam = DipsAPI_pb2.ProtoMemberFunction_ProtoReference_TrendLineToolEntityInfo_Boolean(This=self.__modelRef,  Input1=Boolean)
+        ret = self.__EntityServicesStubLocal.SetTrendLineToolVisibility(functionParam)
+        
+
+    def UpdateTrendLineTool(self,  TrendLineToolEntityInfo: TrendLineToolEntityInfoVal) -> ValidatableResultVal:
+        functionParam = DipsAPI_pb2.ProtoMemberFunction_ProtoReference_TrendLineToolEntityInfo_TrendLineToolEntityInfo(This=self.__modelRef,  Input1=(TrendLineToolEntityInfo.to_proto() if hasattr(TrendLineToolEntityInfo, 'to_proto') else TrendLineToolEntityInfo))
+        ret = self.__EntityServicesStubLocal.UpdateTrendLineTool(functionParam)
+        
+        return ValidatableResultVal.from_proto(ret)
+        
+
+ 

dips/TrendLineToolEntityInfoVal.py

@@ -0,0 +1,114 @@
+"""Generated wrapper for TrendLineToolEntityInfo protobuf message."""
+
+from typing import Any, Optional, List, Dict
+from . import DipsAPI_pb2
+
+from .ProtobufCollectionWrappers import _ProtobufListWrapper, _ProtobufMapWrapper
+
+from .AngleDataVal import AngleDataVal
+from .ColorSurrogateVal import ColorSurrogateVal
+
+class TrendLineToolEntityInfoVal:
+    """Simple wrapper for TrendLineToolEntityInfo with Pythonic getters and setters."""
+
+    _proto_class = DipsAPI_pb2.TrendLineToolEntityInfo
+
+
+    def __init__(self, color: Optional[ColorSurrogateVal] = None, trend: Optional[AngleDataVal] = None, proto_message: Optional[Any] = None):
+        """Initialize the TrendLineToolEntityInfo wrapper."""
+        # Initialize the protobuf message
+        if proto_message is not None:
+            self._proto_message = proto_message
+        else:
+            self._proto_message = self._proto_class()
+
+        if color is not None:
+            self._proto_message.Color.CopyFrom(color.to_proto())
+            self._color_wrapper = color
+        if trend is not None:
+            self._proto_message.Trend.CopyFrom(trend.to_proto())
+            self._trend_wrapper = trend
+
+
+    # Properties
+
+    @property
+    def is_visible(self) -> bool:
+        """Get the IsVisible field value."""
+        return self._proto_message.IsVisible
+    
+    @is_visible.setter
+    def is_visible(self, value: bool) -> None:
+        """Set the IsVisible field value."""
+        self._proto_message.IsVisible = value
+
+
+    @property
+    def name(self) -> str:
+        """Get the Name field value."""
+        return self._proto_message.Name
+    
+    @name.setter
+    def name(self, value: str) -> None:
+        """Set the Name field value."""
+        self._proto_message.Name = value
+
+
+    @property
+    def color(self) -> ColorSurrogateVal:
+        """Get the Color field as a wrapper."""
+        if not hasattr(self, '_color_wrapper'):
+            self._color_wrapper = ColorSurrogateVal(proto_message=self._proto_message.Color)
+        return self._color_wrapper
+    
+    @color.setter
+    def color(self, value: ColorSurrogateVal) -> None:
+        """Set the Color field to a wrapper."""
+        self._proto_message.Color.CopyFrom(value.to_proto())
+        # Update the cached wrapper if it exists
+        if hasattr(self, '_color_wrapper'):
+            self._color_wrapper._proto_message.CopyFrom(self._proto_message.Color)
+
+
+    @property
+    def trend(self) -> AngleDataVal:
+        """Get the Trend field as a wrapper."""
+        if not hasattr(self, '_trend_wrapper'):
+            self._trend_wrapper = AngleDataVal(proto_message=self._proto_message.Trend)
+        return self._trend_wrapper
+    
+    @trend.setter
+    def trend(self, value: AngleDataVal) -> None:
+        """Set the Trend field to a wrapper."""
+        self._proto_message.Trend.CopyFrom(value.to_proto())
+        # Update the cached wrapper if it exists
+        if hasattr(self, '_trend_wrapper'):
+            self._trend_wrapper._proto_message.CopyFrom(self._proto_message.Trend)
+
+
+    # Utility methods
+
+    def to_proto(self):
+        """Get the underlying protobuf message."""
+        return self._proto_message
+    
+    @classmethod
+    def from_proto(cls, proto_message):
+        """Create wrapper from existing protobuf message."""
+        wrapper = cls()
+        wrapper._proto_message.CopyFrom(proto_message)
+        return wrapper
+    
+    def copy(self):
+        """Create a copy of this wrapper."""
+        new_wrapper = self.__class__()
+        new_wrapper._proto_message.CopyFrom(self._proto_message)
+        return new_wrapper
+    
+    def __str__(self) -> str:
+        """String representation."""
+        return f"{self.__class__.__name__}({self._proto_message})"
+    
+    def __repr__(self) -> str:
+        """Detailed string representation."""
+        return f"{self.__class__.__name__}({self._proto_message})"

dips/TrendPlungeVal.py

@@ -0,0 +1,91 @@
+"""Generated wrapper for TrendPlunge protobuf message."""
+
+from typing import Any, Optional, List, Dict
+from . import DipsAPI_pb2
+
+from .ProtobufCollectionWrappers import _ProtobufListWrapper, _ProtobufMapWrapper
+
+from .AngleDataVal import AngleDataVal
+
+class TrendPlungeVal:
+    """Simple wrapper for TrendPlunge with Pythonic getters and setters."""
+
+    _proto_class = DipsAPI_pb2.TrendPlunge
+
+
+    def __init__(self, trend: Optional[AngleDataVal] = None, plunge: Optional[AngleDataVal] = None, proto_message: Optional[Any] = None):
+        """Initialize the TrendPlunge wrapper."""
+        # Initialize the protobuf message
+        if proto_message is not None:
+            self._proto_message = proto_message
+        else:
+            self._proto_message = self._proto_class()
+
+        if trend is not None:
+            self._proto_message.Trend.CopyFrom(trend.to_proto())
+            self._trend_wrapper = trend
+        if plunge is not None:
+            self._proto_message.Plunge.CopyFrom(plunge.to_proto())
+            self._plunge_wrapper = plunge
+
+
+    # Properties
+
+    @property
+    def trend(self) -> AngleDataVal:
+        """Get the Trend field as a wrapper."""
+        if not hasattr(self, '_trend_wrapper'):
+            self._trend_wrapper = AngleDataVal(proto_message=self._proto_message.Trend)
+        return self._trend_wrapper
+    
+    @trend.setter
+    def trend(self, value: AngleDataVal) -> None:
+        """Set the Trend field to a wrapper."""
+        self._proto_message.Trend.CopyFrom(value.to_proto())
+        # Update the cached wrapper if it exists
+        if hasattr(self, '_trend_wrapper'):
+            self._trend_wrapper._proto_message.CopyFrom(self._proto_message.Trend)
+
+
+    @property
+    def plunge(self) -> AngleDataVal:
+        """Get the Plunge field as a wrapper."""
+        if not hasattr(self, '_plunge_wrapper'):
+            self._plunge_wrapper = AngleDataVal(proto_message=self._proto_message.Plunge)
+        return self._plunge_wrapper
+    
+    @plunge.setter
+    def plunge(self, value: AngleDataVal) -> None:
+        """Set the Plunge field to a wrapper."""
+        self._proto_message.Plunge.CopyFrom(value.to_proto())
+        # Update the cached wrapper if it exists
+        if hasattr(self, '_plunge_wrapper'):
+            self._plunge_wrapper._proto_message.CopyFrom(self._proto_message.Plunge)
+
+
+    # Utility methods
+
+    def to_proto(self):
+        """Get the underlying protobuf message."""
+        return self._proto_message
+    
+    @classmethod
+    def from_proto(cls, proto_message):
+        """Create wrapper from existing protobuf message."""
+        wrapper = cls()
+        wrapper._proto_message.CopyFrom(proto_message)
+        return wrapper
+    
+    def copy(self):
+        """Create a copy of this wrapper."""
+        new_wrapper = self.__class__()
+        new_wrapper._proto_message.CopyFrom(self._proto_message)
+        return new_wrapper
+    
+    def __str__(self) -> str:
+        """String representation."""
+        return f"{self.__class__.__name__}({self._proto_message})"
+    
+    def __repr__(self) -> str:
+        """Detailed string representation."""
+        return f"{self.__class__.__name__}({self._proto_message})"

dips/UnitSystemResultVal.py

@@ -0,0 +1,62 @@
+"""Generated wrapper for UnitSystemResult protobuf message."""
+
+from typing import Any, Optional, List, Dict
+from . import DipsAPI_pb2
+
+from .ProtobufCollectionWrappers import _ProtobufListWrapper, _ProtobufMapWrapper
+
+class UnitSystemResultVal:
+    """Simple wrapper for UnitSystemResult with Pythonic getters and setters."""
+
+    _proto_class = DipsAPI_pb2.UnitSystemResult
+
+
+    def __init__(self, proto_message: Optional[Any] = None):
+        """Initialize the UnitSystemResult wrapper."""
+        # Initialize the protobuf message
+        if proto_message is not None:
+            self._proto_message = proto_message
+        else:
+            self._proto_message = self._proto_class()
+
+
+
+    # Properties
+
+    @property
+    def value(self) -> Any:
+        """Get the Value field value."""
+        return self._proto_message.Value
+    
+    @value.setter
+    def value(self, value: Any) -> None:
+        """Set the Value field value."""
+        self._proto_message.Value = value
+
+
+    # Utility methods
+
+    def to_proto(self):
+        """Get the underlying protobuf message."""
+        return self._proto_message
+    
+    @classmethod
+    def from_proto(cls, proto_message):
+        """Create wrapper from existing protobuf message."""
+        wrapper = cls()
+        wrapper._proto_message.CopyFrom(proto_message)
+        return wrapper
+    
+    def copy(self):
+        """Create a copy of this wrapper."""
+        new_wrapper = self.__class__()
+        new_wrapper._proto_message.CopyFrom(self._proto_message)
+        return new_wrapper
+    
+    def __str__(self) -> str:
+        """String representation."""
+        return f"{self.__class__.__name__}({self._proto_message})"
+    
+    def __repr__(self) -> str:
+        """Detailed string representation."""
+        return f"{self.__class__.__name__}({self._proto_message})"

dips/UserPlaneEntityOptionsVal.py

@@ -0,0 +1,100 @@
+"""Generated wrapper for UserPlaneEntityOptions protobuf message."""
+
+from typing import Any, Optional, List, Dict
+from . import DipsAPI_pb2
+
+from .ProtobufCollectionWrappers import _ProtobufListWrapper, _ProtobufMapWrapper
+
+from .LineationVal import LineationVal
+from .PlaneOptionsVal import PlaneOptionsVal
+
+class UserPlaneEntityOptionsVal:
+    """Simple wrapper for UserPlaneEntityOptions with Pythonic getters and setters."""
+
+    _proto_class = DipsAPI_pb2.UserPlaneEntityOptions
+
+
+    def __init__(self, plane_options: Optional[PlaneOptionsVal] = None, proto_message: Optional[Any] = None):
+        """Initialize the UserPlaneEntityOptions wrapper."""
+        # Initialize the protobuf message
+        if proto_message is not None:
+            self._proto_message = proto_message
+        else:
+            self._proto_message = self._proto_class()
+
+        if plane_options is not None:
+            self._proto_message.PlaneOptions.CopyFrom(plane_options.to_proto())
+            self._plane_options_wrapper = plane_options
+
+
+    # Properties
+
+    @property
+    def plane_options(self) -> PlaneOptionsVal:
+        """Get the PlaneOptions field as a wrapper."""
+        if not hasattr(self, '_plane_options_wrapper'):
+            self._plane_options_wrapper = PlaneOptionsVal(proto_message=self._proto_message.PlaneOptions)
+        return self._plane_options_wrapper
+    
+    @plane_options.setter
+    def plane_options(self, value: PlaneOptionsVal) -> None:
+        """Set the PlaneOptions field to a wrapper."""
+        self._proto_message.PlaneOptions.CopyFrom(value.to_proto())
+        # Update the cached wrapper if it exists
+        if hasattr(self, '_plane_options_wrapper'):
+            self._plane_options_wrapper._proto_message.CopyFrom(self._proto_message.PlaneOptions)
+
+
+    @property
+    def show_lineations(self) -> bool:
+        """Get the ShowLineations field value."""
+        return self._proto_message.ShowLineations
+    
+    @show_lineations.setter
+    def show_lineations(self, value: bool) -> None:
+        """Set the ShowLineations field value."""
+        self._proto_message.ShowLineations = value
+
+
+    @property
+    def lineations(self) -> List[LineationVal]:
+        """Get the Lineations field as a list of wrappers."""
+        return _ProtobufListWrapper(self._proto_message.Lineations, LineationVal)
+    
+    @lineations.setter
+    def lineations(self, value: List[LineationVal]) -> None:
+        """Set the Lineations field to a list of wrappers."""
+        if not isinstance(value, (list, tuple)):
+            raise TypeError(f"Expected list or tuple, got {type(value).__name__}")
+        # Clear the repeated field using slice assignment
+        self._proto_message.Lineations[:] = []
+        for item in value:
+            self._proto_message.Lineations.append(item.to_proto())
+
+
+    # Utility methods
+
+    def to_proto(self):
+        """Get the underlying protobuf message."""
+        return self._proto_message
+    
+    @classmethod
+    def from_proto(cls, proto_message):
+        """Create wrapper from existing protobuf message."""
+        wrapper = cls()
+        wrapper._proto_message.CopyFrom(proto_message)
+        return wrapper
+    
+    def copy(self):
+        """Create a copy of this wrapper."""
+        new_wrapper = self.__class__()
+        new_wrapper._proto_message.CopyFrom(self._proto_message)
+        return new_wrapper
+    
+    def __str__(self) -> str:
+        """String representation."""
+        return f"{self.__class__.__name__}({self._proto_message})"
+    
+    def __repr__(self) -> str:
+        """Detailed string representation."""
+        return f"{self.__class__.__name__}({self._proto_message})"

dips/ValidatableResultVal.py

@@ -0,0 +1,69 @@
+"""Generated wrapper for ValidatableResult protobuf message."""
+
+from typing import Any, Optional, List, Dict
+from . import DipsAPI_pb2
+
+from .ProtobufCollectionWrappers import _ProtobufListWrapper, _ProtobufMapWrapper
+
+from .ValidationErrorVal import ValidationErrorVal
+
+class ValidatableResultVal:
+    """Simple wrapper for ValidatableResult with Pythonic getters and setters."""
+
+    _proto_class = DipsAPI_pb2.ValidatableResult
+
+
+    def __init__(self, proto_message: Optional[Any] = None):
+        """Initialize the ValidatableResult wrapper."""
+        # Initialize the protobuf message
+        if proto_message is not None:
+            self._proto_message = proto_message
+        else:
+            self._proto_message = self._proto_class()
+
+
+
+    # Properties
+
+    @property
+    def errors(self) -> List[ValidationErrorVal]:
+        """Get the Errors field as a list of wrappers."""
+        return _ProtobufListWrapper(self._proto_message.Errors, ValidationErrorVal)
+    
+    @errors.setter
+    def errors(self, value: List[ValidationErrorVal]) -> None:
+        """Set the Errors field to a list of wrappers."""
+        if not isinstance(value, (list, tuple)):
+            raise TypeError(f"Expected list or tuple, got {type(value).__name__}")
+        # Clear the repeated field using slice assignment
+        self._proto_message.Errors[:] = []
+        for item in value:
+            self._proto_message.Errors.append(item.to_proto())
+
+
+    # Utility methods
+
+    def to_proto(self):
+        """Get the underlying protobuf message."""
+        return self._proto_message
+    
+    @classmethod
+    def from_proto(cls, proto_message):
+        """Create wrapper from existing protobuf message."""
+        wrapper = cls()
+        wrapper._proto_message.CopyFrom(proto_message)
+        return wrapper
+    
+    def copy(self):
+        """Create a copy of this wrapper."""
+        new_wrapper = self.__class__()
+        new_wrapper._proto_message.CopyFrom(self._proto_message)
+        return new_wrapper
+    
+    def __str__(self) -> str:
+        """String representation."""
+        return f"{self.__class__.__name__}({self._proto_message})"
+    
+    def __repr__(self) -> str:
+        """Detailed string representation."""
+        return f"{self.__class__.__name__}({self._proto_message})"

dips/ValidatableResult_ProtoReference_ArrowToolEntityInfoVal.py

@@ -0,0 +1,86 @@
+"""Generated wrapper for ValidatableResult_ProtoReference_ArrowToolEntityInfo protobuf message."""
+
+from typing import Any, Optional, List, Dict
+from . import DipsAPI_pb2
+
+from .ProtobufCollectionWrappers import _ProtobufListWrapper, _ProtobufMapWrapper
+
+from .ValidationErrorVal import ValidationErrorVal
+from .ArrowToolEntityInfoRef import ArrowToolEntityInfoRef
+
+class ValidatableResult_ProtoReference_ArrowToolEntityInfoVal:
+    """Simple wrapper for ValidatableResult_ProtoReference_ArrowToolEntityInfo with Pythonic getters and setters."""
+
+    _proto_class = DipsAPI_pb2.ValidatableResult_ProtoReference_ArrowToolEntityInfo
+
+
+    def __init__(self, result: Optional[ArrowToolEntityInfoRef] = None, proto_message: Optional[Any] = None, channel_to_connect_on: Optional[Any] = None):
+        """Initialize the ValidatableResult_ProtoReference_ArrowToolEntityInfo wrapper."""
+        # Initialize the protobuf message
+        if proto_message is not None:
+            self._proto_message = proto_message
+        else:
+            self._proto_message = self._proto_class()
+
+        # Store channel for reference types
+        self.__channelToConnectOn = channel_to_connect_on
+
+        if result is not None:
+            self.result = result
+
+
+    # Properties
+
+    @property
+    def errors(self) -> List[ValidationErrorVal]:
+        """Get the Errors field as a list of wrappers."""
+        return _ProtobufListWrapper(self._proto_message.Errors, ValidationErrorVal)
+    
+    @errors.setter
+    def errors(self, value: List[ValidationErrorVal]) -> None:
+        """Set the Errors field to a list of wrappers."""
+        if not isinstance(value, (list, tuple)):
+            raise TypeError(f"Expected list or tuple, got {type(value).__name__}")
+        # Clear the repeated field using slice assignment
+        self._proto_message.Errors[:] = []
+        for item in value:
+            self._proto_message.Errors.append(item.to_proto())
+
+
+    @property
+    def result(self) -> ArrowToolEntityInfoRef:
+        """Get the Result field as a reference."""
+        return ArrowToolEntityInfoRef(self.__channelToConnectOn, self._proto_message.Result)
+    
+    @result.setter
+    def result(self, value: ArrowToolEntityInfoRef) -> None:
+        """Set the Result field to a reference."""
+        self._proto_message.Result.CopyFrom(value.get_model_ref())
+
+
+    # Utility methods
+
+    def to_proto(self):
+        """Get the underlying protobuf message."""
+        return self._proto_message
+    
+    @classmethod
+    def from_proto(cls, proto_message):
+        """Create wrapper from existing protobuf message."""
+        wrapper = cls()
+        wrapper._proto_message.CopyFrom(proto_message)
+        return wrapper
+    
+    def copy(self):
+        """Create a copy of this wrapper."""
+        new_wrapper = self.__class__()
+        new_wrapper._proto_message.CopyFrom(self._proto_message)
+        return new_wrapper
+    
+    def __str__(self) -> str:
+        """String representation."""
+        return f"{self.__class__.__name__}({self._proto_message})"
+    
+    def __repr__(self) -> str:
+        """Detailed string representation."""
+        return f"{self.__class__.__name__}({self._proto_message})"