DipsScripting 9.1.0__py3-none-any.whl

dips/CustomHistogramOptionsVal.py

@@ -0,0 +1,103 @@
+"""Generated wrapper for CustomHistogramOptions protobuf message."""
+
+from typing import Any, Optional, List, Dict
+from . import DipsAPI_pb2
+
+from .ProtobufCollectionWrappers import _ProtobufListWrapper, _ProtobufMapWrapper
+
+from .CustomRangeVal import CustomRangeVal
+from .StatisticalDistributionFilterVal import StatisticalDistributionFilterVal
+
+class CustomHistogramOptionsVal:
+    """Simple wrapper for CustomHistogramOptions with Pythonic getters and setters."""
+
+    _proto_class = DipsAPI_pb2.CustomHistogramOptions
+
+
+    def __init__(self, custom_range: Optional[CustomRangeVal] = None, distribution_filter: Optional[StatisticalDistributionFilterVal] = None, proto_message: Optional[Any] = None):
+        """Initialize the CustomHistogramOptions wrapper."""
+        # Initialize the protobuf message
+        if proto_message is not None:
+            self._proto_message = proto_message
+        else:
+            self._proto_message = self._proto_class()
+
+        if custom_range is not None:
+            self._proto_message.CustomRange.CopyFrom(custom_range.to_proto())
+            self._custom_range_wrapper = custom_range
+        if distribution_filter is not None:
+            self._proto_message.DistributionFilter.CopyFrom(distribution_filter.to_proto())
+            self._distribution_filter_wrapper = distribution_filter
+
+
+    # Properties
+
+    @property
+    def custom_range(self) -> CustomRangeVal:
+        """Get the CustomRange field as a wrapper."""
+        if not hasattr(self, '_custom_range_wrapper'):
+            self._custom_range_wrapper = CustomRangeVal(proto_message=self._proto_message.CustomRange)
+        return self._custom_range_wrapper
+    
+    @custom_range.setter
+    def custom_range(self, value: CustomRangeVal) -> None:
+        """Set the CustomRange field to a wrapper."""
+        self._proto_message.CustomRange.CopyFrom(value.to_proto())
+        # Update the cached wrapper if it exists
+        if hasattr(self, '_custom_range_wrapper'):
+            self._custom_range_wrapper._proto_message.CopyFrom(self._proto_message.CustomRange)
+
+
+    @property
+    def apply_distribution_filter(self) -> bool:
+        """Get the ApplyDistributionFilter field value."""
+        return self._proto_message.ApplyDistributionFilter
+    
+    @apply_distribution_filter.setter
+    def apply_distribution_filter(self, value: bool) -> None:
+        """Set the ApplyDistributionFilter field value."""
+        self._proto_message.ApplyDistributionFilter = value
+
+
+    @property
+    def distribution_filter(self) -> StatisticalDistributionFilterVal:
+        """Get the DistributionFilter field as a wrapper."""
+        if not hasattr(self, '_distribution_filter_wrapper'):
+            self._distribution_filter_wrapper = StatisticalDistributionFilterVal(proto_message=self._proto_message.DistributionFilter)
+        return self._distribution_filter_wrapper
+    
+    @distribution_filter.setter
+    def distribution_filter(self, value: StatisticalDistributionFilterVal) -> None:
+        """Set the DistributionFilter field to a wrapper."""
+        self._proto_message.DistributionFilter.CopyFrom(value.to_proto())
+        # Update the cached wrapper if it exists
+        if hasattr(self, '_distribution_filter_wrapper'):
+            self._distribution_filter_wrapper._proto_message.CopyFrom(self._proto_message.DistributionFilter)
+
+
+    # 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/CustomRangeVal.py

@@ -0,0 +1,84 @@
+"""Generated wrapper for CustomRange protobuf message."""
+
+from typing import Any, Optional, List, Dict
+from . import DipsAPI_pb2
+
+from .ProtobufCollectionWrappers import _ProtobufListWrapper, _ProtobufMapWrapper
+
+class CustomRangeVal:
+    """Simple wrapper for CustomRange with Pythonic getters and setters."""
+
+    _proto_class = DipsAPI_pb2.CustomRange
+
+
+    def __init__(self, proto_message: Optional[Any] = None):
+        """Initialize the CustomRange 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 apply_custom_range(self) -> bool:
+        """Get the ApplyCustomRange field value."""
+        return self._proto_message.ApplyCustomRange
+    
+    @apply_custom_range.setter
+    def apply_custom_range(self, value: bool) -> None:
+        """Set the ApplyCustomRange field value."""
+        self._proto_message.ApplyCustomRange = value
+
+
+    @property
+    def min(self) -> float:
+        """Get the Min field value."""
+        return self._proto_message.Min
+    
+    @min.setter
+    def min(self, value: float) -> None:
+        """Set the Min field value."""
+        self._proto_message.Min = value
+
+
+    @property
+    def max(self) -> float:
+        """Get the Max field value."""
+        return self._proto_message.Max
+    
+    @max.setter
+    def max(self, value: float) -> None:
+        """Set the Max field value."""
+        self._proto_message.Max = 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/CustomRowRawDataVal.py

@@ -0,0 +1,74 @@
+"""Generated wrapper for CustomRowRawData protobuf message."""
+
+from typing import Any, Optional, List, Dict
+from . import DipsAPI_pb2
+
+from .ProtobufCollectionWrappers import _ProtobufListWrapper, _ProtobufMapWrapper
+
+class CustomRowRawDataVal:
+    """Simple wrapper for CustomRowRawData with Pythonic getters and setters."""
+
+    _proto_class = DipsAPI_pb2.CustomRowRawData
+
+
+    def __init__(self, proto_message: Optional[Any] = None):
+        """Initialize the CustomRowRawData 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 raw_data(self) -> Dict[int, str]:
+        """Get the RawData field as a Python dictionary."""
+        if not hasattr(self, '_raw_data_wrapper'):
+            self._raw_data_wrapper = _ProtobufMapWrapper(self._proto_message.RawData)
+        return self._raw_data_wrapper
+    
+    @raw_data.setter
+    def raw_data(self, value: Dict[int, str]) -> None:
+        """Set the RawData field to a Python dictionary."""
+        if not isinstance(value, (dict, _ProtobufMapWrapper)):
+            raise TypeError(f"Expected dict or _ProtobufMapWrapper, got {type(value).__name__}")
+        self._proto_message.RawData.clear()
+        if isinstance(value, _ProtobufMapWrapper):
+            self._proto_message.RawData.update(value._proto_field)
+        else:
+            self._proto_message.RawData.update(value)
+        # Update the cached wrapper if it exists
+        if hasattr(self, '_raw_data_wrapper'):
+            self._raw_data_wrapper._proto_field.clear()
+            self._raw_data_wrapper._proto_field.update(self._proto_message.RawData)
+
+
+    # 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/DataDescriptorVal.py

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

@@ -0,0 +1,23 @@
+from typing import List
+from . import DipsAPI_pb2_grpc
+from . import DipsAPI_pb2
+from .DataFilterVal import DataFilterVal
+
+class DataFilterRef:
+    def __init__(self, channelToConnectOn, ref: DipsAPI_pb2.ProtoReference_DataFilter):
+        self.__modelRef = ref
+        self.__refManagerStub = DipsAPI_pb2_grpc.nSameModuleReferenceAccessorStub(channelToConnectOn)
+        self.__channelToConnectOn = channelToConnectOn
+        
+    
+    def GetValue(self) -> DataFilterVal:
+        bytes = self.__refManagerStub.GetValue(self.__modelRef.ID)
+        ret = DipsAPI_pb2.DataFilter()
+        ret.MergeFromString(bytes.data)
+        return DataFilterVal.from_proto(ret)
+    
+    def get_model_ref(self):
+        """Get the underlying model reference for direct protobuf operations."""
+        return self.__modelRef
+    
+ 

dips/DataFilterVal.py

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

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

@@ -0,0 +1,62 @@
+"""Generated wrapper for DataIdentifier protobuf message."""
+
+from typing import Any, Optional, List, Dict
+from . import DipsAPI_pb2
+
+from .ProtobufCollectionWrappers import _ProtobufListWrapper, _ProtobufMapWrapper
+
+class DataIdentifierVal:
+    """Simple wrapper for DataIdentifier with Pythonic getters and setters."""
+
+    _proto_class = DipsAPI_pb2.DataIdentifier
+
+
+    def __init__(self, proto_message: Optional[Any] = None):
+        """Initialize the DataIdentifier 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 data_name(self) -> str:
+        """Get the DataName field value."""
+        return self._proto_message.DataName
+    
+    @data_name.setter
+    def data_name(self, value: str) -> None:
+        """Set the DataName field value."""
+        self._proto_message.DataName = 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})"