DipsScripting 9.1.0__py3-none-any.whl

dips/ValidatableResult_ProtoReference_TextToolEntityInfoVal.py

@@ -0,0 +1,86 @@
+"""Generated wrapper for ValidatableResult_ProtoReference_TextToolEntityInfo protobuf message."""
+
+from typing import Any, Optional, List, Dict
+from . import DipsAPI_pb2
+
+from .ProtobufCollectionWrappers import _ProtobufListWrapper, _ProtobufMapWrapper
+
+from .ValidationErrorVal import ValidationErrorVal
+from .TextToolEntityInfoRef import TextToolEntityInfoRef
+
+class ValidatableResult_ProtoReference_TextToolEntityInfoVal:
+    """Simple wrapper for ValidatableResult_ProtoReference_TextToolEntityInfo with Pythonic getters and setters."""
+
+    _proto_class = DipsAPI_pb2.ValidatableResult_ProtoReference_TextToolEntityInfo
+
+
+    def __init__(self, result: Optional[TextToolEntityInfoRef] = None, proto_message: Optional[Any] = None, channel_to_connect_on: Optional[Any] = None):
+        """Initialize the ValidatableResult_ProtoReference_TextToolEntityInfo 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) -> TextToolEntityInfoRef:
+        """Get the Result field as a reference."""
+        return TextToolEntityInfoRef(self.__channelToConnectOn, self._proto_message.Result)
+    
+    @result.setter
+    def result(self, value: TextToolEntityInfoRef) -> 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})"

dips/ValidatableResult_ProtoReference_TrendLineToolEntityInfoVal.py

@@ -0,0 +1,86 @@
+"""Generated wrapper for ValidatableResult_ProtoReference_TrendLineToolEntityInfo protobuf message."""
+
+from typing import Any, Optional, List, Dict
+from . import DipsAPI_pb2
+
+from .ProtobufCollectionWrappers import _ProtobufListWrapper, _ProtobufMapWrapper
+
+from .ValidationErrorVal import ValidationErrorVal
+from .TrendLineToolEntityInfoRef import TrendLineToolEntityInfoRef
+
+class ValidatableResult_ProtoReference_TrendLineToolEntityInfoVal:
+    """Simple wrapper for ValidatableResult_ProtoReference_TrendLineToolEntityInfo with Pythonic getters and setters."""
+
+    _proto_class = DipsAPI_pb2.ValidatableResult_ProtoReference_TrendLineToolEntityInfo
+
+
+    def __init__(self, result: Optional[TrendLineToolEntityInfoRef] = None, proto_message: Optional[Any] = None, channel_to_connect_on: Optional[Any] = None):
+        """Initialize the ValidatableResult_ProtoReference_TrendLineToolEntityInfo 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) -> TrendLineToolEntityInfoRef:
+        """Get the Result field as a reference."""
+        return TrendLineToolEntityInfoRef(self.__channelToConnectOn, self._proto_message.Result)
+    
+    @result.setter
+    def result(self, value: TrendLineToolEntityInfoRef) -> 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})"

dips/ValidationErrorVal.py

@@ -0,0 +1,73 @@
+"""Generated wrapper for ValidationError protobuf message."""
+
+from typing import Any, Optional, List, Dict
+from . import DipsAPI_pb2
+
+from .ProtobufCollectionWrappers import _ProtobufListWrapper, _ProtobufMapWrapper
+
+class ValidationErrorVal:
+    """Simple wrapper for ValidationError with Pythonic getters and setters."""
+
+    _proto_class = DipsAPI_pb2.ValidationError
+
+
+    def __init__(self, proto_message: Optional[Any] = None):
+        """Initialize the ValidationError 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 property_name(self) -> str:
+        """Get the PropertyName field value."""
+        return self._proto_message.PropertyName
+    
+    @property_name.setter
+    def property_name(self, value: str) -> None:
+        """Set the PropertyName field value."""
+        self._proto_message.PropertyName = value
+
+
+    @property
+    def error_message(self) -> str:
+        """Get the ErrorMessage field value."""
+        return self._proto_message.ErrorMessage
+    
+    @error_message.setter
+    def error_message(self, value: str) -> None:
+        """Set the ErrorMessage field value."""
+        self._proto_message.ErrorMessage = 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/Vector2DVal.py

@@ -0,0 +1,73 @@
+"""Generated wrapper for Vector2D protobuf message."""
+
+from typing import Any, Optional, List, Dict
+from . import DipsAPI_pb2
+
+from .ProtobufCollectionWrappers import _ProtobufListWrapper, _ProtobufMapWrapper
+
+class Vector2DVal:
+    """Simple wrapper for Vector2D with Pythonic getters and setters."""
+
+    _proto_class = DipsAPI_pb2.Vector2D
+
+
+    def __init__(self, proto_message: Optional[Any] = None):
+        """Initialize the Vector2D 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 x(self) -> float:
+        """Get the X field value."""
+        return self._proto_message.X
+    
+    @x.setter
+    def x(self, value: float) -> None:
+        """Set the X field value."""
+        self._proto_message.X = value
+
+
+    @property
+    def y(self) -> float:
+        """Get the Y field value."""
+        return self._proto_message.Y
+    
+    @y.setter
+    def y(self, value: float) -> None:
+        """Set the Y field value."""
+        self._proto_message.Y = 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/Vector3Val.py

@@ -0,0 +1,84 @@
+"""Generated wrapper for Vector3 protobuf message."""
+
+from typing import Any, Optional, List, Dict
+from . import DipsAPI_pb2
+
+from .ProtobufCollectionWrappers import _ProtobufListWrapper, _ProtobufMapWrapper
+
+class Vector3Val:
+    """Simple wrapper for Vector3 with Pythonic getters and setters."""
+
+    _proto_class = DipsAPI_pb2.Vector3
+
+
+    def __init__(self, proto_message: Optional[Any] = None):
+        """Initialize the Vector3 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 x(self) -> float:
+        """Get the X field value."""
+        return self._proto_message.X
+    
+    @x.setter
+    def x(self, value: float) -> None:
+        """Set the X field value."""
+        self._proto_message.X = value
+
+
+    @property
+    def y(self) -> float:
+        """Get the Y field value."""
+        return self._proto_message.Y
+    
+    @y.setter
+    def y(self, value: float) -> None:
+        """Set the Y field value."""
+        self._proto_message.Y = value
+
+
+    @property
+    def z(self) -> float:
+        """Get the Z field value."""
+        return self._proto_message.Z
+    
+    @z.setter
+    def z(self, value: float) -> None:
+        """Set the Z field value."""
+        self._proto_message.Z = 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/VectorDensityContourSettingsVal.py

@@ -0,0 +1,73 @@
+"""Generated wrapper for VectorDensityContourSettings protobuf message."""
+
+from typing import Any, Optional, List, Dict
+from . import DipsAPI_pb2
+
+from .ProtobufCollectionWrappers import _ProtobufListWrapper, _ProtobufMapWrapper
+
+class VectorDensityContourSettingsVal:
+    """Simple wrapper for VectorDensityContourSettings with Pythonic getters and setters."""
+
+    _proto_class = DipsAPI_pb2.VectorDensityContourSettings
+
+
+    def __init__(self, proto_message: Optional[Any] = None):
+        """Initialize the VectorDensityContourSettings 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 density_distribution(self) -> Any:
+        """Get the DensityDistribution field value."""
+        return self._proto_message.DensityDistribution
+    
+    @density_distribution.setter
+    def density_distribution(self, value: Any) -> None:
+        """Set the DensityDistribution field value."""
+        self._proto_message.DensityDistribution = value
+
+
+    @property
+    def count_circle_size_percent(self) -> float:
+        """Get the CountCircleSizePercent field value."""
+        return self._proto_message.CountCircleSizePercent
+    
+    @count_circle_size_percent.setter
+    def count_circle_size_percent(self, value: float) -> None:
+        """Set the CountCircleSizePercent field value."""
+        self._proto_message.CountCircleSizePercent = 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/WeightingSettingsVal.py

@@ -0,0 +1,83 @@
+"""Generated wrapper for WeightingSettings protobuf message."""
+
+from typing import Any, Optional, List, Dict
+from . import DipsAPI_pb2
+
+from .ProtobufCollectionWrappers import _ProtobufListWrapper, _ProtobufMapWrapper
+
+from .AngleDataVal import AngleDataVal
+
+class WeightingSettingsVal:
+    """Simple wrapper for WeightingSettings with Pythonic getters and setters."""
+
+    _proto_class = DipsAPI_pb2.WeightingSettings
+
+
+    def __init__(self, minimum_bias_angle: Optional[AngleDataVal] = None, proto_message: Optional[Any] = None):
+        """Initialize the WeightingSettings wrapper."""
+        # Initialize the protobuf message
+        if proto_message is not None:
+            self._proto_message = proto_message
+        else:
+            self._proto_message = self._proto_class()
+
+        if minimum_bias_angle is not None:
+            self._proto_message.MinimumBiasAngle.CopyFrom(minimum_bias_angle.to_proto())
+            self._minimum_bias_angle_wrapper = minimum_bias_angle
+
+
+    # Properties
+
+    @property
+    def weighting_option(self) -> Any:
+        """Get the WeightingOption field value."""
+        return self._proto_message.WeightingOption
+    
+    @weighting_option.setter
+    def weighting_option(self, value: Any) -> None:
+        """Set the WeightingOption field value."""
+        self._proto_message.WeightingOption = value
+
+
+    @property
+    def minimum_bias_angle(self) -> AngleDataVal:
+        """Get the MinimumBiasAngle field as a wrapper."""
+        if not hasattr(self, '_minimum_bias_angle_wrapper'):
+            self._minimum_bias_angle_wrapper = AngleDataVal(proto_message=self._proto_message.MinimumBiasAngle)
+        return self._minimum_bias_angle_wrapper
+    
+    @minimum_bias_angle.setter
+    def minimum_bias_angle(self, value: AngleDataVal) -> None:
+        """Set the MinimumBiasAngle field to a wrapper."""
+        self._proto_message.MinimumBiasAngle.CopyFrom(value.to_proto())
+        # Update the cached wrapper if it exists
+        if hasattr(self, '_minimum_bias_angle_wrapper'):
+            self._minimum_bias_angle_wrapper._proto_message.CopyFrom(self._proto_message.MinimumBiasAngle)
+
+
+    # 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/WrappedFreehandWindowVal.py

@@ -0,0 +1,102 @@
+"""Generated wrapper for WrappedFreehandWindow protobuf message."""
+
+from typing import Any, Optional, List, Dict
+from . import DipsAPI_pb2
+
+from .ProtobufCollectionWrappers import _ProtobufListWrapper, _ProtobufMapWrapper
+
+from .FreehandWindowVal import FreehandWindowVal
+
+class WrappedFreehandWindowVal:
+    """Simple wrapper for WrappedFreehandWindow with Pythonic getters and setters."""
+
+    _proto_class = DipsAPI_pb2.WrappedFreehandWindow
+
+
+    def __init__(self, primary_window: Optional[FreehandWindowVal] = None, secondary_window: Optional[FreehandWindowVal] = None, proto_message: Optional[Any] = None):
+        """Initialize the WrappedFreehandWindow wrapper."""
+        # Initialize the protobuf message
+        if proto_message is not None:
+            self._proto_message = proto_message
+        else:
+            self._proto_message = self._proto_class()
+
+        if primary_window is not None:
+            self._proto_message.PrimaryWindow.CopyFrom(primary_window.to_proto())
+            self._primary_window_wrapper = primary_window
+        if secondary_window is not None:
+            self._proto_message.SecondaryWindow.CopyFrom(secondary_window.to_proto())
+            self._secondary_window_wrapper = secondary_window
+
+
+    # Properties
+
+    @property
+    def id(self) -> str:
+        """Get the ID field value."""
+        return self._proto_message.ID
+    
+    @id.setter
+    def id(self, value: str) -> None:
+        """Set the ID field value."""
+        self._proto_message.ID = value
+
+
+    @property
+    def primary_window(self) -> FreehandWindowVal:
+        """Get the PrimaryWindow field as a wrapper."""
+        if not hasattr(self, '_primary_window_wrapper'):
+            self._primary_window_wrapper = FreehandWindowVal(proto_message=self._proto_message.PrimaryWindow)
+        return self._primary_window_wrapper
+    
+    @primary_window.setter
+    def primary_window(self, value: FreehandWindowVal) -> None:
+        """Set the PrimaryWindow field to a wrapper."""
+        self._proto_message.PrimaryWindow.CopyFrom(value.to_proto())
+        # Update the cached wrapper if it exists
+        if hasattr(self, '_primary_window_wrapper'):
+            self._primary_window_wrapper._proto_message.CopyFrom(self._proto_message.PrimaryWindow)
+
+
+    @property
+    def secondary_window(self) -> FreehandWindowVal:
+        """Get the SecondaryWindow field as a wrapper."""
+        if not hasattr(self, '_secondary_window_wrapper'):
+            self._secondary_window_wrapper = FreehandWindowVal(proto_message=self._proto_message.SecondaryWindow)
+        return self._secondary_window_wrapper
+    
+    @secondary_window.setter
+    def secondary_window(self, value: FreehandWindowVal) -> None:
+        """Set the SecondaryWindow field to a wrapper."""
+        self._proto_message.SecondaryWindow.CopyFrom(value.to_proto())
+        # Update the cached wrapper if it exists
+        if hasattr(self, '_secondary_window_wrapper'):
+            self._secondary_window_wrapper._proto_message.CopyFrom(self._proto_message.SecondaryWindow)
+
+
+    # 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/__init__.py

@@ -0,0 +1,29 @@
+"""
+Dips Python API
+
+Public API for interacting with Dips application via gRPC.
+"""
+
+# Main application interface
+from .DipsApp import DipsApp
+
+# Built-in data formatters and descriptors
+from .BuiltInDataFormatters import *
+from .BuiltInDataDescriptors import *
+
+# Re-export commonly used protobuf modules for convenience
+from . import DipsAPI_pb2
+from . import DipsAPI_pb2_grpc
+
+# Optionally expose commonly used classes - uncomment if desired
+# from .ProjStubRef import ProjStubRef
+# from .OrientationDataSetRef import OrientationDataSetRef
+# from .SetEntityInfoRef import SetEntityInfoRef
+# etc.
+
+__all__ = [
+    'DipsApp',
+    'DipsAPI_pb2',
+    'DipsAPI_pb2_grpc',
+    # Add other public exports here
+]