Merge pull request #149 from specklesystems/izzy/null-units-hotfix

fix(units): warn and don't set for invalid args

specklepy/objects/base.py

@@ -207,7 +207,7 @@ class Base(_RegisteringBase):
             try:
                 attr.__set__(self, value)
             except AttributeError:
-                pass  # the prop probably doesn't have a setter
+                return  # the prop probably doesn't have a setter
         super().__setattr__(name, value)
 
     @classmethod
@@ -252,6 +252,9 @@ class Base(_RegisteringBase):
         if t is None:
             return value
 
+        if value is None:
+            return None
+
         if t.__module__ == "typing":
             origin = getattr(t, "__origin__")
             t = (
@@ -310,7 +313,9 @@ class Base(_RegisteringBase):
 
     @units.setter
     def units(self, value: str):
-        self._units = get_units_from_string(value)
+        units = get_units_from_string(value)
+        if units:
+            self._units = units
 
     def get_member_names(self) -> List[str]:
         """Get all of the property names on this object, dynamic or not"""

specklepy/objects/other.py

@@ -1,7 +1,28 @@
+from typing import List
+from specklepy.objects.geometry import Point, Vector
 from .base import Base
 
 OTHER = "Objects.Other."
 
+IDENTITY_TRANSFORM = [
+    1.0,
+    0.0,
+    0.0,
+    0.0,
+    0.0,
+    1.0,
+    0.0,
+    0.0,
+    0.0,
+    0.0,
+    1.0,
+    0.0,
+    0.0,
+    0.0,
+    0.0,
+    1.0,
+]
+
 
 class RenderMaterial(Base, speckle_type=OTHER + "RenderMaterial"):
     name: str = None
@@ -10,3 +31,169 @@ class RenderMaterial(Base, speckle_type=OTHER + "RenderMaterial"):
     roughness: float = 1
     diffuse: int = -2894893  # light gray arbg
     emissive: int = -16777216  # black arbg
+
+
+class Transform(
+    Base,
+    speckle_type=OTHER + "Transform",
+    serialize_ignore={"translation", "scaling", "is_identity"},
+):
+    """The 4x4 transformation matrix
+
+    The 3x3 sub-matrix determines scaling.
+    The 4th column defines translation, where the last value is a divisor (usually equal to 1).
+    """
+
+    _value: List[float] = None
+
+    @property
+    def value(self) -> List[float]:
+        """The transform matrix represented as a flat list of 16 floats"""
+        return self._value
+
+    @value.setter
+    def value(self, value: List[float]) -> None:
+        try:
+            value = [float(x) for x in value]
+        except (ValueError, TypeError):
+            raise ValueError(
+                f"Could not create a Transform object with the requested value. Input must be a 16 element list of numbers. Value provided: {value}"
+            )
+        if len(value) != 16:
+            raise ValueError(
+                f"Could not create a Transform object: input list should be 16 floats long, but was {len(value)} long"
+            )
+
+        self._value = value
+
+    @property
+    def translation(self) -> List[float]:
+        """The final column of the matrix which defines the translation"""
+        return [self._value[i] for i in (3, 7, 11, 15)]
+
+    @property
+    def scaling(self) -> List[float]:
+        """The 3x3 scaling sub-matrix"""
+        return [self._value[i] for i in (0, 1, 2, 4, 5, 6, 8, 9, 10)]
+
+    @property
+    def is_identity(self) -> bool:
+        return self.value == IDENTITY_TRANSFORM
+
+    def apply_to_point(self, point: Point) -> Point:
+        """Transform a single speckle Point
+
+        Arguments:
+            point {Point} -- the speckle Point to transform
+
+        Returns:
+            Point -- a new transformed point
+        """
+        coords = self.apply_to_point_value([point.x, point.y, point.z])
+        return Point(x=coords[0], y=coords[1], z=coords[2], units=point.units)
+
+    def apply_to_point_value(self, point_value: List[float]) -> List[float]:
+        """Transform a list of three floats representing a point
+
+        Arguments:
+            point_value {List[float]} -- a list of 3 floats
+
+        Returns:
+            List[float] -- the list with the transform applied
+        """
+        transformed = [
+            point_value[0] * self._value[i]
+            + point_value[1] * self._value[i + 1]
+            + point_value[2] * self._value[i + 2]
+            + self._value[i + 3]
+            for i in range(0, 15, 4)
+        ]
+
+        return [transformed[i] / transformed[3] for i in range(3)]
+
+    def apply_to_points(self, points: List[Point]) -> List[Point]:
+        """Transform a list of speckle Points
+
+        Arguments:
+            points {List[Point]} -- the list of speckle Points to transform
+
+        Returns:
+            List[Point] -- a new list of transformed points
+        """
+        return [self.apply_to_point(point) for point in points]
+
+    def apply_to_points_values(self, points_value: List[float]) -> List[float]:
+        """Transform a list of speckle Points
+
+        Arguments:
+            points {List[float]} -- a flat list of floats representing points to transform
+
+        Returns:
+            List[float] -- a new transformed list
+        """
+        if len(points_value) % 3 != 0:
+            raise ValueError(
+                "Cannot apply transform as the points list is malformed: expected length to be multiple of 3"
+            )
+        transformed = []
+        for i in range(0, len(points_value), 3):
+            transformed.extend(self.apply_to_point_value(points_value[i : i + 3]))
+
+        return transformed
+
+    def apply_to_vector(self, vector: Vector) -> Vector:
+        """Transform a single speckle Vector
+
+        Arguments:
+            point {Vector} -- the speckle Vector to transform
+
+        Returns:
+            Vector -- a new transformed point
+        """
+        coords = self.apply_to_vector_value([vector.x, vector.y, vector.z])
+        return Vector(x=coords[0], y=coords[1], z=coords[2], units=vector.units)
+
+    def apply_to_vector_value(self, vector_value: List[float]) -> List[float]:
+        """Transform a list of three floats representing a vector
+
+        Arguments:
+            vector_value {List[float]} -- a list of 3 floats
+
+        Returns:
+            List[float] -- the list with the transform applied
+        """
+        return [
+            vector_value[0] * self._value[i]
+            + vector_value[1] * self._value[i + 1]
+            + vector_value[2] * self._value[i + 2]
+            for i in range(0, 15, 4)
+        ][:3]
+
+    @classmethod
+    def from_list(cls, value: List[float] = None) -> "Transform":
+        """Returns a Transform object from a list of 16 numbers. If no value is provided, an identity transform will be returned.
+
+        Arguments:
+            value {List[float]} -- the matrix as a flat list of 16 numbers (defaults to the identity transform)
+
+        Returns:
+            Transform -- a complete transform object
+        """
+        if not value:
+            value = IDENTITY_TRANSFORM
+        return cls(value=value)
+
+
+class BlockDefinition(
+    Base, speckle_type=OTHER + "BlockDefinition", detachable={"geometry"}
+):
+    name: str = None
+    basePoint: Point = None
+    geometry: List[Base] = None
+
+
+class BlockInstance(
+    Base, speckle_type=OTHER + "BlockInstance", detachable={"blockDefinition"}
+):
+    blockDefinition: BlockDefinition = None
+    transform: Transform = None

specklepy/objects/units.py

@@ -1,4 +1,5 @@
-from specklepy.logging.exceptions import SpeckleException
+from warnings import warn
+from specklepy.logging.exceptions import SpeckleException, SpeckleWarning
 
 UNITS = ["mm", "cm", "m", "in", "ft", "yd", "mi"]
 
@@ -28,6 +29,12 @@ UNITS_ENCODINGS = {
 
 
 def get_units_from_string(unit: str):
+    if not isinstance(unit, str):
+        warn(
+            f"Invalid units: expected type str but received {type(unit)} ({unit}). Skipping - no units will be set.",
+            SpeckleWarning,
+        )
+        return
     unit = str.lower(unit)
     for name, alternates in UNITS_STRINGS.items():
         if unit in alternates:

specklepy/serialization/base_object_serializer.py

@@ -60,14 +60,19 @@ class BaseObjectSerializer:
             chunkable = False
             detach = False
 
-            # skip nulls or props marked to be ignored with "__" or "_"
-            if value is None or prop.startswith(("__", "_")):
+            # skip props marked to be ignored with "__" or "_"
+            if prop.startswith(("__", "_")):
                 continue
 
             # don't prepopulate id as this will mess up hashing
             if prop == "id":
                 continue
 
+            # allow serialisation of nulls
+            if value is None:
+                object_builder[prop] = value
+                continue
+
             # only bother with chunking and detaching if there is a write transport
             if self.write_transports:
                 dynamic_chunk_match = prop.startswith("@") and re.match(

tests/test_base.py

@@ -77,6 +77,18 @@ def test_speckle_type_cannot_be_set(base: Base) -> None:
     assert base.speckle_type == "Base"
 
 
+def test_setting_units():
+    b = Base(units="foot")
+    assert b.units == "ft"
+
+    with pytest.raises(SpeckleException):
+        b.units = "big"
+
+    b.units = None  # invalid args are skipped
+    b.units = 7
+    assert b.units == "ft"
+
+
 def test_base_of_custom_speckle_type() -> None:
     b1 = Base.of_type("BirdHouse", name="Tweety's Crib")
     assert b1.speckle_type == "BirdHouse"

tests/test_transforms.py

@@ -0,0 +1,132 @@
+from typing import List
+import pytest
+from specklepy.api import operations
+from specklepy.objects.geometry import Point, Vector
+from specklepy.objects.other import (
+    Transform,
+    BlockInstance,
+    BlockDefinition,
+    IDENTITY_TRANSFORM,
+)
+
+
+@pytest.fixture()
+def point():
+    return Point(x=1, y=10, z=2)
+
+
+@pytest.fixture()
+def points():
+    return [Point(x=1 + i, y=10 + i, z=2 + i) for i in range(5)]
+
+
+@pytest.fixture()
+def point_value():
+    return [1, 10, 2]
+
+
+@pytest.fixture()
+def points_values():
+    coords = []
+    for i in range(5):
+        coords.extend([1 + i, 10 + i, 2 + 1])
+    return coords
+
+
+@pytest.fixture()
+def vector():
+    return Vector(x=1, y=10, z=2)
+
+
+@pytest.fixture()
+def vector_value():
+    return [1, 1, 2]
+
+
+@pytest.fixture()
+def transform():
+    """Translates to [1, 2, 0] and scales z by 0.5"""
+    return Transform.from_list(
+        [
+            1.0,
+            0.0,
+            0.0,
+            1.0,
+            0.0,
+            1.0,
+            0.0,
+            2.0,
+            0.0,
+            0.0,
+            0.5,
+            0.0,
+            0.0,
+            0.0,
+            0.0,
+            1.0,
+        ]
+    )
+
+
+def test_point_transform(point: Point, transform: Transform):
+    new_point = transform.apply_to_point(point)
+
+    assert new_point.x == point.x + 1
+    assert new_point.y == point.y + 2
+    assert new_point.z == point.z * 0.5
+
+
+def test_points_transform(points: List[Point], transform: Transform):
+    new_points = transform.apply_to_points(points)
+
+    for (i, new_point) in enumerate(new_points):
+        assert new_point.x == points[i].x + 1
+        assert new_point.y == points[i].y + 2
+        assert new_point.z == points[i].z * 0.5
+
+
+def test_point_value_transform(point_value: List[float], transform: Transform):
+    new_coords = transform.apply_to_point_value(point_value)
+
+    assert new_coords[0] == point_value[0] + 1
+    assert new_coords[1] == point_value[1] + 2
+    assert new_coords[2] == point_value[2] * 0.5
+
+
+def test_points_values_transform(points_values: List[float], transform: Transform):
+    new_coords = transform.apply_to_points_values(points_values)
+
+    for i in range(0, len(points_values), 3):
+        assert new_coords[i] == points_values[i] + 1
+        assert new_coords[i + 1] == points_values[i + 1] + 2
+        assert new_coords[i + 2] == points_values[i + 2] * 0.5
+
+
+def test_vector_transform(vector: Vector, transform: Transform):
+    new_vector = transform.apply_to_vector(vector)
+
+    assert new_vector.x == vector.x
+    assert new_vector.y == vector.y
+    assert new_vector.z == vector.z * 0.5
+
+
+def test_vector_value_transform(vector_value: List[float], transform: Transform):
+    new_coords = transform.apply_to_vector_value(vector_value)
+
+    assert new_coords[0] == vector_value[0]
+    assert new_coords[1] == vector_value[1]
+    assert new_coords[2] == vector_value[2] * 0.5
+
+
+def test_transform_fails_with_malformed_value():
+    with pytest.raises(ValueError):
+        Transform.from_list("asdf")
+    with pytest.raises(ValueError):
+        Transform.from_list([7, 8, 9])
+
+
+def test_transform_serialisation(transform: Transform):
+    serialized = operations.serialize(transform)
+    deserialized = operations.deserialize(serialized)
+
+    assert transform.get_id() == deserialized.get_id()