Update to new version : 0.3.0.0

Author: github-actions[bot]

underautomation/staubli/__init__.py

@@ -0,0 +1,7 @@
+import clr
+import os
+
+_dll_path = os.path.realpath(os.path.join(os.path.dirname(__file__), 'lib', 'UnderAutomation.Staubli.dll'))
+clr.AddReference(_dll_path)
+
+__author__ = 'UnderAutomation'

underautomation/staubli/common/soap_connect_parameters.py

@@ -1,21 +1,37 @@
 import typing
 from underautomation.staubli.soap.internal.soap_connect_parameters_base import SoapConnectParametersBase
-import clr
-import os
-clr.AddReference(os.path.realpath(os.path.join(os.path.dirname(__file__), "..",  'lib', 'UnderAutomation.Staubli.dll')))
 from UnderAutomation.Staubli.Common import SoapConnectParameters as soap_connect_parameters
 
 class SoapConnectParameters(SoapConnectParametersBase):
+	'''SOAP connection parameters for communicating with the Staubli robot controller.'''
 	def __init__(self, _internal = 0):
 		if(_internal == 0):
 			self._instance = soap_connect_parameters()
 		else:
 			self._instance = _internal
+
 	@property
 	def enable(self) -> bool:
+		'''Should use this service (default: true)'''
 		return self._instance.Enable
+
 	@enable.setter
 	def enable(self, value: bool):
 		self._instance.Enable = value
 
-SoapConnectParameters.defaul_t__port = SoapConnectParameters(soap_connect_parameters.DEFAULT_PORT)
+	def __str__(self):
+		return self._instance.ToString() if self._instance is not None else ""
+
+	def __repr__(self):
+		return self.__str__()
+
+	def __eq__(self, other) -> bool:
+		if not isinstance(other, SoapConnectParameters):
+			NotImplemented
+		return self._instance.Equals(other._instance)
+
+	def __hash__(self) -> int:
+		return self._instance.GetHashCode() if self._instance is not None else 0
+
+# Default port for SOAP service
+SoapConnectParameters.DEFAULT_PORT = soap_connect_parameters.DEFAULT_PORT

underautomation/staubli/connection_parameters.py

@@ -1,31 +1,59 @@
 import typing
 from underautomation.staubli.common.soap_connect_parameters import SoapConnectParameters
-import clr
-import os
-clr.AddReference(os.path.realpath(os.path.join(os.path.dirname(__file__),  'lib', 'UnderAutomation.Staubli.dll')))
 from UnderAutomation.Staubli import ConnectionParameters as connection_parameters
 
 class ConnectionParameters:
+	'''Connection parameters'''
 	def __init__(self, address: str, _internal = 0):
+		'''Instanciate a new connection parameters with a specified address'''
 		if(_internal == 0):
 			self._instance = connection_parameters(address)
 		else:
 			self._instance = _internal
+
+	def equals(self, obj: typing.Any) -> bool:
+		return self._instance.Equals(obj)
+
+	def get_hash_code(self) -> int:
+		return self._instance.GetHashCode()
+
 	@property
 	def address(self) -> str:
+		'''Address of the robot (IP or host name)'''
 		return self._instance.Address
+
 	@address.setter
 	def address(self, value: str):
 		self._instance.Address = value
+
 	@property
 	def ping_before_connect(self) -> bool:
+		'''Send a ping command before initializing any connections'''
 		return self._instance.PingBeforeConnect
+
 	@ping_before_connect.setter
 	def ping_before_connect(self, value: bool):
 		self._instance.PingBeforeConnect = value
+
 	@property
 	def soap(self) -> SoapConnectParameters:
+		'''Soap connection parameters'''
 		return SoapConnectParameters(self._instance.Soap)
+
 	@soap.setter
 	def soap(self, value: SoapConnectParameters):
 		self._instance.Soap = value._instance if value else None
+
+	def __str__(self):
+		return self._instance.ToString() if self._instance is not None else ""
+
+	def __repr__(self):
+		return self.__str__()
+
+	def __eq__(self, other) -> bool:
+		if not isinstance(other, ConnectionParameters):
+			NotImplemented
+		return self._instance.Equals(other._instance)
+
+	def __hash__(self) -> int:
+		return self._instance.GetHashCode() if self._instance is not None else 0

underautomation/staubli/lib/UnderAutomation.Staubli.dll

@@ -1 +1 @@
-0.2.1.1
+0.3.0.0

underautomation/staubli/lib/version.txt

@@ -1,16 +1,30 @@
 import typing
 from underautomation.staubli.license.license_info import LicenseInfo
-import clr
-import os
-clr.AddReference(os.path.realpath(os.path.join(os.path.dirname(__file__), "..",  'lib', 'UnderAutomation.Staubli.dll')))
 from UnderAutomation.Staubli.License import InvalidLicenseException as invalid_license_exception
 
 class InvalidLicenseException:
+	'''Exception thrown while using the product if the license is not valid.'''
 	def __init__(self, _internal = 0):
 		if(_internal == 0):
 			self._instance = invalid_license_exception()
 		else:
 			self._instance = _internal
+
 	@property
 	def license_info(self) -> LicenseInfo:
+		'''The license that causes this exception'''
 		return LicenseInfo(None, None, self._instance.LicenseInfo)
+
+	def __str__(self):
+		return self._instance.ToString() if self._instance is not None else ""
+
+	def __repr__(self):
+		return self.__str__()
+
+	def __eq__(self, other) -> bool:
+		if not isinstance(other, InvalidLicenseException):
+			NotImplemented
+		return self._instance.Equals(other._instance)
+
+	def __hash__(self) -> int:
+		return self._instance.GetHashCode() if self._instance is not None else 0

underautomation/staubli/license/invalid_license_exception.py

@@ -1,53 +1,92 @@
 import typing
 from datetime import datetime, timedelta
 from underautomation.staubli.license.license_state import LicenseState
-import clr
-import os
-clr.AddReference(os.path.realpath(os.path.join(os.path.dirname(__file__), "..",  'lib', 'UnderAutomation.Staubli.dll')))
 from UnderAutomation.Staubli.License import LicenseInfo as license_info
 from UnderAutomation.Staubli.License import LicenseState as license_state
 
 class LicenseInfo:
+	'''Information about a license key'''
 	def __init__(self, licenseIdentifier: str, licenseKey: str, _internal = 0):
+		'''Create a new LicenseInfo instance to retrieve informations about a pair of identifier/key This class should not be used to register your product. Please use static function RegisterLicense to specify your license.
+
+		:param licenseIdentifier: The name of your organization (null for trial version)
+		:param licenseKey: The key, associated to the identifier, supplied by UnderAutomation (null for trial version)
+		'''
 		if(_internal == 0):
 			self._instance = license_info(licenseIdentifier, licenseKey)
 		else:
 			self._instance = _internal
-	def __repr__(self):
-		return self._instance.ToString() if self._instance is not None else ""
+
 	@property
 	def is_licensed(self) -> bool:
+		'''True if the license state is Licensed, Trial or ExtraTrial ; false otherwise'''
 		return self._instance.IsLicensed
+
 	@property
 	def license_key(self) -> str:
+		'''The license key supplied by UnderAutomation (null for trial period)'''
 		return self._instance.LicenseKey
+
 	@property
 	def product(self) -> str:
+		'''Commercial name of this .NET Software library'''
 		return self._instance.Product
+
 	@property
 	def evaluation_days_left(self) -> int | None:
+		'''Remaining days of the trial period. Null if the product is licensed. It could be negative if the trial period is ended since several days.'''
 		return self._instance.EvaluationDaysLeft
+
 	@property
 	def evaluation_start_date(self) -> datetime:
+		'''The date the trial period starts. If the product is licensed, the date of the library first use.'''
 		return datetime(1, 1, 1) + timedelta(microseconds=self._instance.EvaluationStartDate.Ticks // 10)
+
 	@property
 	def licensee(self) -> str:
+		'''Name of your organisation'''
 		return self._instance.Licensee
+
 	@property
 	def trial_period_expiration_date(self) -> datetime | None:
+		'''The date the product will expire. Null if the product is licensed.'''
 		return None if self._instance.TrialPeriodExpirationDate is None else datetime(1, 1, 1) + timedelta(microseconds=self._instance.TrialPeriodExpirationDate.Ticks // 10)
+
 	@property
 	def state(self) -> LicenseState:
-		return LicenseState(self._instance.State)
+		'''The current license state'''
+		return LicenseState(int(self._instance.State))
+
 	@property
 	def product_release_date(self) -> datetime:
+		'''The date this version of the product was released.'''
 		return datetime(1, 1, 1) + timedelta(microseconds=self._instance.ProductReleaseDate.Ticks // 10)
+
 	@property
 	def maintenance_years(self) -> int:
+		'''Number of maintenance years included in your license'''
 		return self._instance.MaintenanceYears
+
 	@property
 	def license_issued_date(self) -> datetime | None:
+		'''The date you get the license'''
 		return None if self._instance.LicenseIssuedDate is None else datetime(1, 1, 1) + timedelta(microseconds=self._instance.LicenseIssuedDate.Ticks // 10)
+
 	@property
 	def maintenance_expiration_date(self) -> datetime | None:
+		'''The date your maintenance contract end and you no longer can use this license with newer versions.'''
 		return None if self._instance.MaintenanceExpirationDate is None else datetime(1, 1, 1) + timedelta(microseconds=self._instance.MaintenanceExpirationDate.Ticks // 10)
+
+	def __str__(self):
+		return self._instance.ToString() if self._instance is not None else ""
+
+	def __repr__(self):
+		return self.__str__()
+
+	def __eq__(self, other) -> bool:
+		if not isinstance(other, LicenseInfo):
+			NotImplemented
+		return self._instance.Equals(other._instance)
+
+	def __hash__(self) -> int:
+		return self._instance.GetHashCode() if self._instance is not None else 0

underautomation/staubli/license/license_info.py

@@ -1,18 +1,10 @@
-import clr
-import os
-clr.AddReference(os.path.realpath(os.path.join(os.path.dirname(__file__), "..",  'lib', 'UnderAutomation.Staubli.dll')))
-from UnderAutomation.Staubli.License import LicenseState as license_state
+from enum import IntEnum
 
-class LicenseState(int):
-	Invalid = int(license_state.Invalid)
-	Trial = int(license_state.Trial)
-	ExtraTrial = int(license_state.ExtraTrial)
-	Expired = int(license_state.Expired)
-	MaintenanceNeeded = int(license_state.MaintenanceNeeded)
-	Licensed = int(license_state.Licensed)
-
-	def __repr__(self):
-		for name, value in vars(LicenseState).items():
-			if not name.startswith('_') and isinstance(value, int) and value == self:
-				return name
-		return str(int(self))
+class LicenseState(IntEnum):
+	'''States that can take a license'''
+	Invalid = 0 # The pair License Identifier and License Key are incompatible, you cannot use the library
+	Trial = 1 # The library is in a trial period, you can use the library
+	ExtraTrial = 2 # The library is in an extra trial period, you can use the library
+	Expired = 3 # The trial period as expired, you no more can use the library
+	MaintenanceNeeded = 4 # Your license does not allow you to use such a recent release. Please buy maintenance to use this version
+	Licensed = 5 # Congratulations, the library is licensed.

underautomation/staubli/license/license_state.py

@@ -1,16 +1,8 @@
-import clr
-import os
-clr.AddReference(os.path.realpath(os.path.join(os.path.dirname(__file__), "..", "..",  'lib', 'UnderAutomation.Staubli.dll')))
-from UnderAutomation.Staubli.Soap.Data import AboveBelowConfig as above_below_config
+from enum import IntEnum
 
-class AboveBelowConfig(int):
-	Same = int(above_below_config.Same)
-	Above = int(above_below_config.Above)
-	Below = int(above_below_config.Below)
-	Free = int(above_below_config.Free)
-
-	def __repr__(self):
-		for name, value in vars(AboveBelowConfig).items():
-			if not name.startswith('_') and isinstance(value, int) and value == self:
-				return name
-		return str(int(self))
+class AboveBelowConfig(IntEnum):
+	'''Configuration for above/below joint orientation.'''
+	Same = 0 # Keep the same configuration as the current one.
+	Above = 1 # Above configuration.
+	Below = 2 # Below configuration.
+	Free = 3 # Free configuration (no constraint).

underautomation/staubli/soap/data/above_below_config.py

@@ -1,36 +1,62 @@
 import typing
 from underautomation.staubli.soap.data.shoulder_config import ShoulderConfig
 from underautomation.staubli.soap.data.positive_negative_config import PositiveNegativeConfig
-import clr
-import os
-clr.AddReference(os.path.realpath(os.path.join(os.path.dirname(__file__), "..", "..",  'lib', 'UnderAutomation.Staubli.dll')))
 from UnderAutomation.Staubli.Soap.Data import AnthroConfig as anthro_config
 from UnderAutomation.Staubli.Soap.Data import ShoulderConfig as shoulder_config
 from UnderAutomation.Staubli.Soap.Data import PositiveNegativeConfig as positive_negative_config
 
 class AnthroConfig:
+	'''Configuration for an anthropomorphic robot (shoulder, elbow, wrist).'''
 	def __init__(self, _internal = 0):
+		'''Initializes a new instance of the AnthroConfig class.'''
 		if(_internal == 0):
 			self._instance = anthro_config()
 		else:
 			self._instance = _internal
-	def __repr__(self):
-		return self._instance.ToString() if self._instance is not None else ""
+
+	def equals(self, obj: typing.Any) -> bool:
+		return self._instance.Equals(obj)
+
+	def get_hash_code(self) -> int:
+		return self._instance.GetHashCode()
+
 	@property
 	def shoulder(self) -> ShoulderConfig:
-		return ShoulderConfig(self._instance.Shoulder)
+		'''Shoulder configuration.'''
+		return ShoulderConfig(int(self._instance.Shoulder))
+
 	@shoulder.setter
 	def shoulder(self, value: ShoulderConfig):
 		self._instance.Shoulder = shoulder_config(int(value))
+
 	@property
 	def elbow(self) -> PositiveNegativeConfig:
-		return PositiveNegativeConfig(self._instance.Elbow)
+		'''Elbow configuration.'''
+		return PositiveNegativeConfig(int(self._instance.Elbow))
+
 	@elbow.setter
 	def elbow(self, value: PositiveNegativeConfig):
 		self._instance.Elbow = positive_negative_config(int(value))
+
 	@property
 	def wrist(self) -> PositiveNegativeConfig:
-		return PositiveNegativeConfig(self._instance.Wrist)
+		'''Wrist configuration.'''
+		return PositiveNegativeConfig(int(self._instance.Wrist))
+
 	@wrist.setter
 	def wrist(self, value: PositiveNegativeConfig):
 		self._instance.Wrist = positive_negative_config(int(value))
+
+	def __str__(self):
+		return self._instance.ToString() if self._instance is not None else ""
+
+	def __repr__(self):
+		return self.__str__()
+
+	def __eq__(self, other) -> bool:
+		if not isinstance(other, AnthroConfig):
+			NotImplemented
+		return self._instance.Equals(other._instance)
+
+	def __hash__(self) -> int:
+		return self._instance.GetHashCode() if self._instance is not None else 0