Merge pull request #375 from specklesystems/dogukan/test_migration
fix: migration of existing tests
This commit is contained in:
Dogukan Karatas
@@ -0,0 +1,9 @@
|
||||
from specklepy.objects.geometry import Point, Line
|
||||
from specklepy.objects.models.units import Units
|
||||
|
||||
p_1 = Point(x=0, y=0, z=0, units=Units.m)
|
||||
p_2 = Point(x=3, y=0, z=0, units=Units.m)
|
||||
|
||||
line = Line(start=p_1, end=p_2, units=Units.m)
|
||||
line.length = line.calculate_length()
|
||||
print(line.length)
|
||||
@@ -1,15 +0,0 @@
|
||||
from typing import Optional
|
||||
|
||||
from specklepy.objects.base import Base
|
||||
|
||||
|
||||
class CRS(Base, speckle_type="Objects.GIS.CRS"):
|
||||
"""A Coordinate Reference System stored in wkt format"""
|
||||
|
||||
name: Optional[str] = None
|
||||
authority_id: Optional[str] = None
|
||||
wkt: Optional[str] = None
|
||||
units_native: Optional[str] = None
|
||||
offset_x: Optional[float] = None
|
||||
offset_y: Optional[float] = None
|
||||
rotation: Optional[float] = None
|
||||
@@ -1,24 +0,0 @@
|
||||
"""Builtin Speckle object kit."""
|
||||
|
||||
from specklepy.objects.GIS.CRS import CRS
|
||||
from specklepy.objects.GIS.geometry import (
|
||||
GisLineElement,
|
||||
GisPointElement,
|
||||
GisPolygonElement,
|
||||
GisPolygonGeometry,
|
||||
GisRasterElement,
|
||||
PolygonGeometry,
|
||||
)
|
||||
from specklepy.objects.GIS.layers import RasterLayer, VectorLayer
|
||||
|
||||
__all__ = [
|
||||
"VectorLayer",
|
||||
"RasterLayer",
|
||||
"GisPolygonGeometry",
|
||||
"PolygonGeometry",
|
||||
"GisPolygonElement",
|
||||
"GisLineElement",
|
||||
"GisPointElement",
|
||||
"GisRasterElement",
|
||||
"CRS",
|
||||
]
|
||||
@@ -1,74 +0,0 @@
|
||||
from typing import List, Optional, Union
|
||||
|
||||
from specklepy.objects.base import Base
|
||||
from specklepy.objects.geometry import (
|
||||
Arc,
|
||||
Circle,
|
||||
Line,
|
||||
Mesh,
|
||||
Point,
|
||||
Polycurve,
|
||||
Polyline,
|
||||
)
|
||||
|
||||
|
||||
class PolygonGeometry(Base, speckle_type="Objects.GIS.PolygonGeometry"):
|
||||
"""GIS Polygon Geometry"""
|
||||
|
||||
boundary: Optional[Polyline]
|
||||
voids: Optional[List[Polyline]]
|
||||
|
||||
|
||||
GisPolygonGeometry = PolygonGeometry
|
||||
|
||||
|
||||
class GisPolygonElement(Base, speckle_type="Objects.GIS.PolygonElement"):
|
||||
"""GIS Polygon element"""
|
||||
|
||||
geometry: Optional[List[GisPolygonGeometry]] = None
|
||||
attributes: Optional[Base] = None
|
||||
|
||||
|
||||
class GisLineElement(Base, speckle_type="Objects.GIS.LineElement"):
|
||||
"""GIS Polyline element"""
|
||||
|
||||
geometry: Optional[List[Union[Polyline, Arc, Line, Circle, Polycurve]]] = None
|
||||
attributes: Optional[Base] = None
|
||||
|
||||
|
||||
class GisPointElement(Base, speckle_type="Objects.GIS.PointElement"):
|
||||
"""GIS Point element"""
|
||||
|
||||
geometry: Optional[List[Point]] = None
|
||||
attributes: Optional[Base] = None
|
||||
|
||||
|
||||
class GisRasterElement(
|
||||
Base, speckle_type="Objects.GIS.RasterElement", detachable={"displayValue"}
|
||||
):
|
||||
"""GIS Raster element"""
|
||||
|
||||
band_count: Optional[int] = None
|
||||
band_names: Optional[List[str]] = None
|
||||
x_origin: Optional[float] = None
|
||||
y_origin: Optional[float] = None
|
||||
x_size: Optional[int] = None
|
||||
y_size: Optional[int] = None
|
||||
x_resolution: Optional[float] = None
|
||||
y_resolution: Optional[float] = None
|
||||
noDataValue: Optional[List[float]] = None
|
||||
displayValue: Optional[List[Mesh]] = None
|
||||
|
||||
|
||||
class GisTopography(
|
||||
GisRasterElement,
|
||||
speckle_type="Objects.GIS.GisTopography",
|
||||
detachable={"displayValue"},
|
||||
):
|
||||
"""GIS Raster element with 3d Topography representation"""
|
||||
|
||||
|
||||
class GisNonGeometryElement(Base, speckle_type="Objects.GIS.NonGeometryElement"):
|
||||
"""GIS Table feature"""
|
||||
|
||||
attributes: Optional[Base] = None
|
||||
@@ -1,142 +0,0 @@
|
||||
from typing import Any, Dict, List, Optional, Union
|
||||
|
||||
from deprecated import deprecated
|
||||
|
||||
from specklepy.objects.base import Base
|
||||
from specklepy.objects.GIS.CRS import CRS
|
||||
from specklepy.objects.other import Collection
|
||||
|
||||
|
||||
@deprecated(version="2.15", reason="Use VectorLayer or RasterLayer instead")
|
||||
class Layer(Base, detachable={"features"}):
|
||||
"""A GIS Layer"""
|
||||
|
||||
def __init__(
|
||||
self,
|
||||
name: Optional[str] = None,
|
||||
crs: Optional[CRS] = None,
|
||||
units: str = "m",
|
||||
features: Optional[List[Base]] = None,
|
||||
layerType: str = "None",
|
||||
geomType: str = "None",
|
||||
renderer: Optional[Dict[str, Any]] = None,
|
||||
**kwargs,
|
||||
) -> None:
|
||||
super().__init__(**kwargs)
|
||||
self.name = name
|
||||
self.crs = crs
|
||||
self.units = units
|
||||
self.type = layerType
|
||||
self.features = features or []
|
||||
self.geomType = geomType
|
||||
self.renderer = renderer or {}
|
||||
|
||||
|
||||
@deprecated(version="2.16", reason="Use VectorLayer or RasterLayer instead")
|
||||
class VectorLayer(
|
||||
Collection,
|
||||
detachable={"elements"},
|
||||
speckle_type="VectorLayer",
|
||||
serialize_ignore={"features"},
|
||||
):
|
||||
"""GIS Vector Layer"""
|
||||
|
||||
name: Optional[str] = None
|
||||
crs: Optional[Union[CRS, Base]] = None
|
||||
units: Optional[str] = None
|
||||
elements: Optional[List[Base]] = None
|
||||
attributes: Optional[Base] = None
|
||||
geomType: Optional[str] = "None"
|
||||
renderer: Optional[Dict[str, Any]] = None
|
||||
collectionType = "VectorLayer"
|
||||
|
||||
@property
|
||||
@deprecated(version="2.14", reason="Use elements")
|
||||
def features(self) -> Optional[List[Base]]:
|
||||
return self.elements
|
||||
|
||||
@features.setter
|
||||
def features(self, value: Optional[List[Base]]) -> None:
|
||||
self.elements = value
|
||||
|
||||
|
||||
@deprecated(version="2.16", reason="Use VectorLayer or RasterLayer instead")
|
||||
class RasterLayer(
|
||||
Collection,
|
||||
detachable={"elements"},
|
||||
speckle_type="RasterLayer",
|
||||
serialize_ignore={"features"},
|
||||
):
|
||||
"""GIS Raster Layer"""
|
||||
|
||||
name: Optional[str] = None
|
||||
crs: Optional[Union[CRS, Base]] = None
|
||||
units: Optional[str] = None
|
||||
rasterCrs: Optional[Union[CRS, Base]] = None
|
||||
elements: Optional[List[Base]] = None
|
||||
geomType: Optional[str] = "None"
|
||||
renderer: Optional[Dict[str, Any]] = None
|
||||
collectionType = "RasterLayer"
|
||||
|
||||
@property
|
||||
@deprecated(version="2.14", reason="Use elements")
|
||||
def features(self) -> Optional[List[Base]]:
|
||||
return self.elements
|
||||
|
||||
@features.setter
|
||||
def features(self, value: Optional[List[Base]]) -> None:
|
||||
self.elements = value
|
||||
|
||||
|
||||
class VectorLayer( # noqa: F811
|
||||
Collection,
|
||||
detachable={"elements"},
|
||||
speckle_type="Objects.GIS.VectorLayer",
|
||||
serialize_ignore={"features"},
|
||||
):
|
||||
"""GIS Vector Layer"""
|
||||
|
||||
name: Optional[str] = None
|
||||
crs: Optional[Union[CRS, Base]] = None
|
||||
units: Optional[str] = None
|
||||
elements: Optional[List[Base]] = None
|
||||
attributes: Optional[Base] = None
|
||||
geomType: Optional[str] = "None"
|
||||
renderer: Optional[Dict[str, Any]] = None
|
||||
collectionType = "VectorLayer"
|
||||
|
||||
@property
|
||||
@deprecated(version="2.14", reason="Use elements")
|
||||
def features(self) -> Optional[List[Base]]:
|
||||
return self.elements
|
||||
|
||||
@features.setter
|
||||
def features(self, value: Optional[List[Base]]) -> None:
|
||||
self.elements = value
|
||||
|
||||
|
||||
class RasterLayer( # noqa: F811
|
||||
Collection,
|
||||
detachable={"elements"},
|
||||
speckle_type="Objects.GIS.RasterLayer",
|
||||
serialize_ignore={"features"},
|
||||
):
|
||||
"""GIS Raster Layer"""
|
||||
|
||||
name: Optional[str] = None
|
||||
crs: Optional[Union[CRS, Base]] = None
|
||||
units: Optional[str] = None
|
||||
rasterCrs: Optional[Union[CRS, Base]] = None
|
||||
elements: Optional[List[Base]] = None
|
||||
geomType: Optional[str] = "None"
|
||||
renderer: Optional[Dict[str, Any]] = None
|
||||
collectionType = "RasterLayer"
|
||||
|
||||
@property
|
||||
@deprecated(version="2.14", reason="Use elements")
|
||||
def features(self) -> Optional[List[Base]]:
|
||||
return self.elements
|
||||
|
||||
@features.setter
|
||||
def features(self, value: Optional[List[Base]]) -> None:
|
||||
self.elements = value
|
||||
@@ -1,23 +0,0 @@
|
||||
"""Builtin Speckle object kit."""
|
||||
|
||||
# from specklepy.objects import (
|
||||
# GIS,
|
||||
# encoding,
|
||||
# geometry,
|
||||
# other,
|
||||
# primitive,
|
||||
# structural,
|
||||
# units,
|
||||
# )
|
||||
from specklepy.objects.base import Base
|
||||
|
||||
__all__ = [
|
||||
"Base",
|
||||
# "encoding",
|
||||
# "geometry",
|
||||
# "other",
|
||||
# "units",
|
||||
# "structural",
|
||||
# "primitive",
|
||||
# "GIS",
|
||||
]
|
||||
@@ -1,595 +0,0 @@
|
||||
import contextlib
|
||||
from enum import Enum
|
||||
from inspect import isclass
|
||||
from typing import (
|
||||
Any,
|
||||
ClassVar,
|
||||
Dict,
|
||||
ForwardRef,
|
||||
List,
|
||||
Optional,
|
||||
Set,
|
||||
Tuple,
|
||||
Type,
|
||||
Union,
|
||||
get_type_hints,
|
||||
)
|
||||
from warnings import warn
|
||||
|
||||
from stringcase import pascalcase
|
||||
|
||||
from specklepy.logging.exceptions import SpeckleException, SpeckleInvalidUnitException
|
||||
from specklepy.objects_v2.units import Units
|
||||
from specklepy.transports.memory import MemoryTransport
|
||||
|
||||
PRIMITIVES = (int, float, str, bool)
|
||||
|
||||
# to remove from dir() when calling get_member_names()
|
||||
REMOVE_FROM_DIR = {
|
||||
"Config",
|
||||
"_Base__dict_helper",
|
||||
"__annotations__",
|
||||
"__class__",
|
||||
"__delattr__",
|
||||
"__dict__",
|
||||
"__dir__",
|
||||
"__doc__",
|
||||
"__eq__",
|
||||
"__format__",
|
||||
"__ge__",
|
||||
"__getattribute__",
|
||||
"__getitem__",
|
||||
"__gt__",
|
||||
"__hash__",
|
||||
"__init__",
|
||||
"__init_subclass__",
|
||||
"__le__",
|
||||
"__lt__",
|
||||
"__module__",
|
||||
"__ne__",
|
||||
"__new__",
|
||||
"__reduce__",
|
||||
"__reduce_ex__",
|
||||
"__repr__",
|
||||
"__setattr__",
|
||||
"__setitem__",
|
||||
"__sizeof__",
|
||||
"__str__",
|
||||
"__subclasshook__",
|
||||
"__weakref__",
|
||||
"_chunk_size_default",
|
||||
"_chunkable",
|
||||
"_count_descendants",
|
||||
"_attr_types",
|
||||
"_detachable",
|
||||
"_handle_object_count",
|
||||
"_type_check",
|
||||
"_type_registry",
|
||||
"_units",
|
||||
"add_chunkable_attrs",
|
||||
"add_detachable_attrs",
|
||||
"get_children_count",
|
||||
"get_dynamic_member_names",
|
||||
"get_id",
|
||||
"get_member_names",
|
||||
"get_registered_type",
|
||||
"get_typed_member_names",
|
||||
"to_dict",
|
||||
"update_forward_refs",
|
||||
"validate_prop_name",
|
||||
"from_list",
|
||||
"to_list",
|
||||
}
|
||||
|
||||
|
||||
class _RegisteringBase:
|
||||
"""
|
||||
Private Base model for Speckle types.
|
||||
|
||||
This is an implementation detail, please do not use this outside this module.
|
||||
|
||||
This class provides automatic registration of `speckle_type` into a global,
|
||||
(class level) registry for each subclassing type.
|
||||
The type registry is a base for accurate type based (de)serialization.
|
||||
"""
|
||||
|
||||
speckle_type: ClassVar[str]
|
||||
_speckle_type_override: ClassVar[Optional[str]] = None
|
||||
_speckle_namespace: ClassVar[Optional[str]] = None
|
||||
_type_registry: ClassVar[Dict[str, Type["Base"]]] = {}
|
||||
_attr_types: ClassVar[Dict[str, Type]] = {}
|
||||
# dict of chunkable props and their max chunk size
|
||||
_chunkable: Dict[str, int] = {}
|
||||
_chunk_size_default: int = 1000
|
||||
_detachable: Set[str] = set() # list of defined detachable props
|
||||
_serialize_ignore: Set[str] = set()
|
||||
|
||||
@classmethod
|
||||
def get_registered_type(cls, speckle_type: str) -> Optional[Type["Base"]]:
|
||||
"""Get the registered type from the protected mapping via the `speckle_type`"""
|
||||
for full_name in reversed(speckle_type.split(":")):
|
||||
maybe_type = cls._type_registry.get(full_name, None)
|
||||
if maybe_type:
|
||||
return maybe_type
|
||||
return None
|
||||
|
||||
@classmethod
|
||||
def _determine_speckle_type(cls) -> str:
|
||||
"""
|
||||
This method brings the speckle_type construction in par with Speckle-sharp/Core.
|
||||
|
||||
The implementation differs, because in Core the basis of the speckle_type if
|
||||
type.FullName, which includes the dotnet namespace name too.
|
||||
Copying that behavior is hard in python, where the concept of namespaces
|
||||
means something entirely different.
|
||||
|
||||
So we enabled a speckle_type override mechanism, that enables
|
||||
"""
|
||||
base_name = "Base"
|
||||
if cls.__name__ == base_name:
|
||||
return base_name
|
||||
|
||||
bases = [
|
||||
b._full_name()
|
||||
for b in reversed(cls.mro())
|
||||
if issubclass(b, Base) and b.__name__ != base_name
|
||||
]
|
||||
return ":".join(bases)
|
||||
|
||||
@classmethod
|
||||
def _full_name(cls) -> str:
|
||||
base_name = "Base"
|
||||
if cls.__name__ == base_name:
|
||||
return base_name
|
||||
|
||||
if cls._speckle_type_override:
|
||||
return cls._speckle_type_override
|
||||
|
||||
# convert the module names to PascalCase to match c# namespace naming convention
|
||||
# also drop specklepy from the beginning
|
||||
namespace = ".".join(
|
||||
pascalcase(m)
|
||||
for m in filter(lambda name: name != "specklepy", cls.__module__.split("."))
|
||||
)
|
||||
return f"{namespace}.{cls.__name__}"
|
||||
|
||||
def __init_subclass__(
|
||||
cls,
|
||||
speckle_type: Optional[str] = None,
|
||||
chunkable: Optional[Dict[str, int]] = None,
|
||||
detachable: Optional[Set[str]] = None,
|
||||
serialize_ignore: Optional[Set[str]] = None,
|
||||
**kwargs: Dict[str, Any],
|
||||
):
|
||||
"""
|
||||
Hook into subclass type creation.
|
||||
|
||||
This is provides a mechanism to hook into the event of the subclass type object
|
||||
initialization. This is reused to register each subclassing type into a class
|
||||
level dictionary.
|
||||
"""
|
||||
# if not speckle_type:
|
||||
# raise Exception("no type")
|
||||
cls._speckle_type_override = speckle_type
|
||||
cls.speckle_type = cls._determine_speckle_type()
|
||||
# cls.speckle_type = speckle_type
|
||||
if cls._full_name() in cls._type_registry:
|
||||
raise ValueError(
|
||||
f"The speckle_type: {speckle_type} is already registered for type: "
|
||||
f"{cls._type_registry[cls._full_name()].__name__}. "
|
||||
"Please choose a different type name."
|
||||
)
|
||||
cls._type_registry[cls._full_name()] = cls # type: ignore
|
||||
try:
|
||||
cls._attr_types = get_type_hints(cls)
|
||||
except Exception:
|
||||
cls._attr_types = getattr(cls, "__annotations__", {})
|
||||
if chunkable:
|
||||
chunkable = {k: v for k, v in chunkable.items() if isinstance(v, int)}
|
||||
cls._chunkable = dict(cls._chunkable, **chunkable)
|
||||
if detachable:
|
||||
cls._detachable = cls._detachable.union(detachable)
|
||||
if serialize_ignore:
|
||||
cls._serialize_ignore = cls._serialize_ignore.union(serialize_ignore)
|
||||
# we know, that the super here is object, that takes no args on init subclass
|
||||
return super().__init_subclass__()
|
||||
|
||||
|
||||
# T = TypeVar("T")
|
||||
|
||||
# how i wish the code below would be correct, but we're also parsing into floats
|
||||
# and converting into strings if the original type is string, but the value isn't
|
||||
# def _validate_type(t: type, value: T) -> Tuple[bool, T]:
|
||||
|
||||
|
||||
def _validate_type(t: Optional[type], value: Any) -> Tuple[bool, Any]:
|
||||
# this should be reworked. Its only ok to return null for Optionals...
|
||||
# if t is None and value is None:
|
||||
if value is None:
|
||||
return True, value
|
||||
|
||||
# after fixing the None t above, this should be
|
||||
# if t is Any:
|
||||
# if t is None:
|
||||
|
||||
if t is None or t is Any:
|
||||
return True, value
|
||||
|
||||
if isclass(t) and issubclass(t, Enum):
|
||||
if isinstance(value, t):
|
||||
return True, value
|
||||
if value in t._value2member_map_:
|
||||
return True, t(value)
|
||||
|
||||
if getattr(t, "__module__", None) == "typing":
|
||||
if isinstance(t, ForwardRef):
|
||||
return True, value
|
||||
|
||||
origin = t.__origin__
|
||||
# below is what in nicer for >= py38
|
||||
# origin = get_origin(t)
|
||||
|
||||
# recursive validation for Unions on both types preferring the fist type
|
||||
if origin is Union:
|
||||
# below is what in nicer for >= py38
|
||||
# t_1, t_2 = get_args(t)
|
||||
args = t.__args__ # type: ignore
|
||||
for arg_t in args:
|
||||
t_success, t_value = _validate_type(arg_t, value)
|
||||
if t_success:
|
||||
return True, t_value
|
||||
return False, value
|
||||
if origin is dict:
|
||||
if not isinstance(value, dict):
|
||||
return False, value
|
||||
if value == {}:
|
||||
return True, value
|
||||
if not getattr(t, "__args__", None):
|
||||
return True, value
|
||||
t_key, t_value = t.__args__ # type: ignore
|
||||
|
||||
if (
|
||||
getattr(t_key, "__name__", None),
|
||||
getattr(t_value, "__name__", None),
|
||||
) == ("KT", "VT"):
|
||||
return True, value
|
||||
# we're only checking the first item, but the for loop and return after
|
||||
# evaluating the first item is the fastest way
|
||||
for dict_key, dict_value in value.items():
|
||||
valid_key, _ = _validate_type(t_key, dict_key)
|
||||
valid_value, _ = _validate_type(t_value, dict_value)
|
||||
|
||||
if valid_key and valid_value:
|
||||
return True, value
|
||||
return False, value
|
||||
|
||||
if origin is list:
|
||||
if not isinstance(value, list):
|
||||
return False, value
|
||||
if value == []:
|
||||
return True, value
|
||||
if not hasattr(t, "__args__"):
|
||||
return True, value
|
||||
t_items = t.__args__[0] # type: ignore
|
||||
if getattr(t_items, "__name__", None) == "T":
|
||||
return True, value
|
||||
first_item_valid, _ = _validate_type(t_items, value[0])
|
||||
if first_item_valid:
|
||||
return True, value
|
||||
return False, value
|
||||
|
||||
if origin is tuple:
|
||||
if not isinstance(value, tuple):
|
||||
return False, value
|
||||
if not hasattr(t, "__args__"):
|
||||
return True, value
|
||||
args = t.__args__ # type: ignore
|
||||
if args == tuple():
|
||||
return True, value
|
||||
# we're not checking for empty tuple, cause tuple lengths must match
|
||||
if len(args) != len(value):
|
||||
return False, value
|
||||
values = []
|
||||
for t_item, v_item in zip(args, value, strict=True):
|
||||
item_valid, item_value = _validate_type(t_item, v_item)
|
||||
if not item_valid:
|
||||
return False, value
|
||||
values.append(item_value)
|
||||
return True, tuple(values)
|
||||
|
||||
if origin is set:
|
||||
if not isinstance(value, set):
|
||||
return False, value
|
||||
if not hasattr(t, "__args__"):
|
||||
return True, value
|
||||
t_items = t.__args__[0] # type: ignore
|
||||
first_item_valid, _ = _validate_type(t_items, next(iter(value)))
|
||||
if first_item_valid:
|
||||
return True, value
|
||||
return False, value
|
||||
|
||||
if isinstance(value, t):
|
||||
return True, value
|
||||
|
||||
with contextlib.suppress(ValueError, TypeError):
|
||||
if t is float and value is not None:
|
||||
return True, float(value)
|
||||
# TODO: dafuq, i had to add this not list check
|
||||
# but it would also fail for objects and other complex values
|
||||
if t is str and value and not isinstance(value, list):
|
||||
return True, str(value)
|
||||
|
||||
return False, value
|
||||
|
||||
|
||||
class Base(_RegisteringBase, speckle_type="Base"):
|
||||
# id: Union[str, None] = None
|
||||
# totalChildrenCount: Union[int, None] = None
|
||||
# applicationId: Union[str, None] = None
|
||||
_units: Union[None, str] = None
|
||||
|
||||
def __init__(
|
||||
self,
|
||||
id: str | None = None,
|
||||
# totalChildrenCount: Union[int, None] = None,
|
||||
applicationId: str | None = None,
|
||||
**kwargs,
|
||||
) -> None:
|
||||
self.id = id
|
||||
# self.totalChildrenCount = totalChildrenCount
|
||||
self.applicationId = applicationId
|
||||
super().__init__()
|
||||
for k, v in kwargs.items():
|
||||
self.__setattr__(k, v)
|
||||
|
||||
def __repr__(self) -> str:
|
||||
return (
|
||||
f"{self.__class__.__name__}(id: {self.id}, "
|
||||
f"speckle_type: {self.speckle_type}, "
|
||||
# f"totalChildrenCount: {self.totalChildrenCount})"
|
||||
)
|
||||
|
||||
def __str__(self) -> str:
|
||||
return self.__repr__()
|
||||
|
||||
@classmethod
|
||||
def of_type(cls, speckle_type: str, **kwargs) -> "Base":
|
||||
"""
|
||||
Get a plain Base object with a specified speckle_type.
|
||||
|
||||
The speckle_type is protected and cannot be overwritten on a class instance.
|
||||
This is to prevent problems with receiving in other platforms or connectors.
|
||||
However, if you really need a base with a different type, here is a helper
|
||||
to do that for you.
|
||||
|
||||
This is used in the deserialisation of unknown types so their speckle_type
|
||||
can be preserved.
|
||||
"""
|
||||
b = cls(**kwargs)
|
||||
b.__dict__.update(speckle_type=speckle_type)
|
||||
return b
|
||||
|
||||
def __setitem__(self, name: str, value: Any) -> None:
|
||||
self.validate_prop_name(name)
|
||||
self.__dict__[name] = value
|
||||
|
||||
def __getitem__(self, name: str) -> Any:
|
||||
return self.__dict__[name]
|
||||
|
||||
def __setattr__(self, name: str, value: Any) -> None:
|
||||
"""
|
||||
Type checking, guard attribute, and property set mechanism.
|
||||
|
||||
The `speckle_type` is a protected class attribute it must not be overridden.
|
||||
|
||||
This also performs a type check if the attribute is type hinted.
|
||||
"""
|
||||
if name == "speckle_type":
|
||||
# not sure if we should raise an exception here??
|
||||
# raise SpeckleException(
|
||||
# "Cannot override the `speckle_type`."
|
||||
# "This is set manually by the class or on deserialisation"
|
||||
# )
|
||||
return
|
||||
# if value is not None:
|
||||
value = self._type_check(name, value)
|
||||
attr = getattr(self.__class__, name, None)
|
||||
if isinstance(attr, property):
|
||||
try:
|
||||
attr.__set__(self, value)
|
||||
except AttributeError:
|
||||
return # the prop probably doesn't have a setter
|
||||
super().__setattr__(name, value)
|
||||
|
||||
@classmethod
|
||||
def update_forward_refs(cls) -> None:
|
||||
"""
|
||||
Attempts to populate the internal defined types dict for type checking
|
||||
sometime after defining the class.
|
||||
This is already done when defining the class, but can be called
|
||||
again if references to undefined types were
|
||||
included.
|
||||
|
||||
See `objects.geometry` for an example of how this is used with
|
||||
the Brep class definitions.
|
||||
"""
|
||||
try:
|
||||
cls._attr_types = get_type_hints(cls)
|
||||
except Exception as e:
|
||||
warn(
|
||||
f"Could not update forward refs for class {cls.__name__}: {e}",
|
||||
stacklevel=2,
|
||||
)
|
||||
|
||||
@classmethod
|
||||
def validate_prop_name(cls, name: str) -> None:
|
||||
"""Validator for dynamic attribute names."""
|
||||
if name in {"", "@"}:
|
||||
raise ValueError("Invalid Name: Base member names cannot be empty strings")
|
||||
if name.startswith("@@"):
|
||||
raise ValueError(
|
||||
"Invalid Name: Base member names cannot start with more than one '@'",
|
||||
)
|
||||
if "." in name or "/" in name:
|
||||
raise ValueError(
|
||||
"Invalid Name: Base member names cannot contain characters '.' or '/'",
|
||||
)
|
||||
|
||||
def _type_check(self, name: str, value: Any) -> Any:
|
||||
"""
|
||||
Lightweight type checking of values before setting them
|
||||
|
||||
NOTE: Does not check subscripted types within generics as the performance hit
|
||||
of checking each item within a given collection isn't worth it.
|
||||
Eg if you have a type Dict[str, float],
|
||||
we will only check if the value you're trying to set is a dict.
|
||||
"""
|
||||
types = getattr(self, "_attr_types", {})
|
||||
t = types.get(name, None)
|
||||
|
||||
valid, checked_value = _validate_type(t, value)
|
||||
|
||||
if valid:
|
||||
return checked_value
|
||||
|
||||
raise SpeckleException(
|
||||
f"Cannot set '{self.__class__.__name__}.{name}':"
|
||||
f"it expects type '{str(t)}',"
|
||||
f"but received type '{type(value).__name__}'"
|
||||
)
|
||||
|
||||
def add_chunkable_attrs(self, **kwargs: int) -> None:
|
||||
"""
|
||||
Mark defined attributes as chunkable for serialisation
|
||||
|
||||
Arguments:
|
||||
kwargs {int} -- the name of the attribute as the keyword
|
||||
and the chunk size as the arg
|
||||
"""
|
||||
chunkable = {k: v for k, v in kwargs.items() if isinstance(v, int)}
|
||||
self._chunkable = dict(self._chunkable, **chunkable)
|
||||
|
||||
def add_detachable_attrs(self, names: Set[str]) -> None:
|
||||
"""
|
||||
Mark defined attributes as detachable for serialisation
|
||||
|
||||
Arguments:
|
||||
names {Set[str]} -- the names of the attributes to detach as a set of string
|
||||
"""
|
||||
self._detachable = self._detachable.union(names)
|
||||
|
||||
@property
|
||||
def units(self) -> Union[str, None]:
|
||||
return self._units
|
||||
|
||||
@units.setter
|
||||
def units(self, value: Union[str, Units, None]):
|
||||
"""
|
||||
While this property accepts any string value,
|
||||
geometry expects units to be specific strings (see Units enum)
|
||||
"""
|
||||
if isinstance(value, str) or value is None:
|
||||
self._units = value
|
||||
elif isinstance(value, Units):
|
||||
self._units = value.value
|
||||
else:
|
||||
raise SpeckleInvalidUnitException(
|
||||
f"Unknown type {type(value)} received for units"
|
||||
)
|
||||
|
||||
def get_member_names(self) -> List[str]:
|
||||
"""Get all of the property names on this object, dynamic or not"""
|
||||
attr_dir = list(set(dir(self)) - REMOVE_FROM_DIR)
|
||||
return [
|
||||
name
|
||||
for name in attr_dir
|
||||
if not name.startswith("_") and not callable(getattr(self, name))
|
||||
]
|
||||
|
||||
def get_serializable_attributes(self) -> List[str]:
|
||||
"""Get the attributes that should be serialized"""
|
||||
return sorted(list(set(self.get_member_names()) - self._serialize_ignore))
|
||||
|
||||
def get_typed_member_names(self) -> List[str]:
|
||||
"""Get all of the names of the defined (typed) properties of this object"""
|
||||
return list(self._attr_types.keys())
|
||||
|
||||
def get_dynamic_member_names(self) -> List[str]:
|
||||
"""Get all of the names of the dynamic properties of this object"""
|
||||
return list(set(self.__dict__.keys()) - set(self._attr_types.keys()))
|
||||
|
||||
def get_children_count(self) -> int:
|
||||
"""Get the total count of children Base objects"""
|
||||
parsed = []
|
||||
return 1 + self._count_descendants(self, parsed)
|
||||
|
||||
def get_id(self, decompose: bool = False) -> str:
|
||||
"""
|
||||
Gets the id (a unique hash) of this object.
|
||||
⚠️ This method fully serializes the object which,
|
||||
in the case of large objects (with many sub-objects), has a tangible cost.
|
||||
Avoid using it!
|
||||
|
||||
Note: the hash of a decomposed object differs from that of a
|
||||
non-decomposed object
|
||||
|
||||
Arguments:
|
||||
decompose {bool} -- if True, will decompose the object in
|
||||
the process of hashing it
|
||||
|
||||
Returns:
|
||||
str -- the hash (id) of the fully serialized object
|
||||
"""
|
||||
from specklepy.serialization.base_object_serializer import BaseObjectSerializer
|
||||
|
||||
serializer = BaseObjectSerializer()
|
||||
if decompose:
|
||||
serializer.write_transports = [MemoryTransport()]
|
||||
return serializer.traverse_base(self)[0]
|
||||
|
||||
def _count_descendants(self, base: "Base", parsed: List) -> int:
|
||||
if base in parsed:
|
||||
return 0
|
||||
parsed.append(base)
|
||||
|
||||
return sum(
|
||||
self._handle_object_count(value, parsed)
|
||||
for name, value in base.get_member_names()
|
||||
if not name.startswith("@")
|
||||
)
|
||||
|
||||
def _handle_object_count(self, obj: Any, parsed: List) -> int:
|
||||
# pylint: disable=isinstance-second-argument-not-valid-type
|
||||
count = 0
|
||||
if obj is None:
|
||||
return count
|
||||
if isinstance(obj, "Base"):
|
||||
count += 1
|
||||
count += self._count_descendants(obj, parsed)
|
||||
return count
|
||||
elif isinstance(obj, list):
|
||||
for item in obj:
|
||||
if isinstance(item, "Base"):
|
||||
count += 1
|
||||
count += self._count_descendants(item, parsed)
|
||||
else:
|
||||
count += self._handle_object_count(item, parsed)
|
||||
elif isinstance(obj, dict):
|
||||
for _, value in obj.items():
|
||||
if isinstance(value, "Base"):
|
||||
count += 1
|
||||
count += self._count_descendants(value, parsed)
|
||||
else:
|
||||
count += self._handle_object_count(value, parsed)
|
||||
return count
|
||||
|
||||
|
||||
Base.update_forward_refs()
|
||||
|
||||
|
||||
class DataChunk(Base, speckle_type="Speckle.Core.Models.DataChunk"):
|
||||
data: Union[List[Any], None] = None
|
||||
|
||||
def __init__(self) -> None:
|
||||
super().__init__()
|
||||
self.data = []
|
||||
@@ -1,131 +0,0 @@
|
||||
from enum import Enum
|
||||
from typing import Any, Callable, Dict, List, Optional, Type
|
||||
|
||||
from specklepy.logging.exceptions import SpeckleException
|
||||
from specklepy.objects.base import Base
|
||||
|
||||
|
||||
class CurveTypeEncoding(int, Enum):
|
||||
Arc = 0
|
||||
Circle = 1
|
||||
Curve = 2
|
||||
Ellipse = 3
|
||||
Line = 4
|
||||
Polyline = 5
|
||||
Polycurve = 6
|
||||
|
||||
@property
|
||||
def object_class(self) -> Type:
|
||||
from . import geometry
|
||||
|
||||
if self == self.Arc:
|
||||
return geometry.Arc
|
||||
elif self == self.Circle:
|
||||
return geometry.Circle
|
||||
elif self == self.Curve:
|
||||
return geometry.Curve
|
||||
elif self == self.Ellipse:
|
||||
return geometry.Ellipse
|
||||
elif self == self.Line:
|
||||
return geometry.Line
|
||||
elif self == self.Polyline:
|
||||
return geometry.Polyline
|
||||
elif self == self.Polycurve:
|
||||
return geometry.Polycurve
|
||||
raise SpeckleException(
|
||||
f"No corresponding object class for CurveTypeEncoding: {self}"
|
||||
)
|
||||
|
||||
|
||||
def curve_from_list(args: List[float]):
|
||||
curve_type = CurveTypeEncoding(args[0])
|
||||
return curve_type.object_class.from_list(args)
|
||||
|
||||
|
||||
class ObjectArray:
|
||||
def __init__(self, data: Optional[list] = None) -> None:
|
||||
self.data = data or []
|
||||
|
||||
@classmethod
|
||||
def from_objects(cls, objects: List[Base]) -> "ObjectArray":
|
||||
data_list = cls()
|
||||
if not objects:
|
||||
return data_list
|
||||
|
||||
speckle_type = objects[0].speckle_type
|
||||
|
||||
for obj in objects:
|
||||
if speckle_type != obj.speckle_type:
|
||||
raise SpeckleException(
|
||||
"All objects in chunk should have the same speckle_type. "
|
||||
f"Found {speckle_type} and {obj.speckle_type}"
|
||||
)
|
||||
data_list.encode_object(obj=obj)
|
||||
|
||||
return data_list
|
||||
|
||||
@staticmethod
|
||||
def decode_data(
|
||||
data: List[Any], decoder: Callable[[List[Any]], Base], **kwargs: Dict[str, Any]
|
||||
) -> List[Base]:
|
||||
bases: List[Base] = []
|
||||
if not data:
|
||||
return bases
|
||||
index = 0
|
||||
while index < len(data):
|
||||
item_length = int(data[index])
|
||||
item_start = index + 1
|
||||
item_end = item_start + item_length
|
||||
item_data = data[item_start:item_end]
|
||||
index = item_end
|
||||
decoded_data = decoder(item_data, **kwargs)
|
||||
bases.append(decoded_data)
|
||||
|
||||
return bases
|
||||
|
||||
def decode(self, decoder: Callable[[List[Any]], Any], **kwargs: Dict[str, Any]):
|
||||
return self.decode_data(data=self.data, decoder=decoder, **kwargs)
|
||||
|
||||
def encode_object(self, obj: Base):
|
||||
encoded = obj.to_list()
|
||||
encoded.insert(0, len(encoded))
|
||||
self.data.extend(encoded)
|
||||
|
||||
|
||||
class CurveArray(ObjectArray):
|
||||
@classmethod
|
||||
def from_curve(cls, curve: Base) -> "CurveArray":
|
||||
crv_array = cls()
|
||||
crv_array.data = curve.to_list()
|
||||
return crv_array
|
||||
|
||||
@classmethod
|
||||
def from_curves(cls, curves: List[Base]) -> "CurveArray":
|
||||
data = []
|
||||
for curve in curves:
|
||||
curve_list = curve.to_list()
|
||||
curve_list.insert(0, len(curve_list))
|
||||
data.extend(curve_list)
|
||||
crv_array = cls()
|
||||
crv_array.data = data
|
||||
return crv_array
|
||||
|
||||
@staticmethod
|
||||
def curve_from_list(args: List[float]) -> Base:
|
||||
curve_type = CurveTypeEncoding(args[0])
|
||||
return curve_type.object_class.from_list(args)
|
||||
|
||||
@property
|
||||
def type(self) -> CurveTypeEncoding:
|
||||
return CurveTypeEncoding(self.data[0])
|
||||
|
||||
def to_curve(self) -> Base:
|
||||
return self.type.object_class.from_list(self.data)
|
||||
|
||||
@classmethod
|
||||
def _curve_decoder(cls, data: List[float]) -> Base:
|
||||
crv_array = cls(data)
|
||||
return crv_array.to_curve()
|
||||
|
||||
def to_curves(self) -> List[Base]:
|
||||
return self.decode(decoder=self._curve_decoder)
|
||||
@@ -1,948 +0,0 @@
|
||||
from enum import Enum
|
||||
from typing import Any, List, Optional
|
||||
|
||||
from specklepy.objects_v2.base import Base
|
||||
from specklepy.objects_v2.encoding import CurveArray, CurveTypeEncoding, ObjectArray
|
||||
from specklepy.objects_v2.primitive import Interval
|
||||
from specklepy.objects_v2.units import get_encoding_from_units, get_units_from_encoding
|
||||
|
||||
GEOMETRY = "Objects.Geometry."
|
||||
|
||||
|
||||
class Point(Base, speckle_type=GEOMETRY + "Point"):
|
||||
x: float = 0.0
|
||||
y: float = 0.0
|
||||
z: float = 0.0
|
||||
|
||||
def __repr__(self) -> str:
|
||||
return (
|
||||
f"{self.__class__.__name__}(x: {self.x}, y: {self.y}, z: {self.z}, id:"
|
||||
f" {self.id}, speckle_type: {self.speckle_type})"
|
||||
)
|
||||
|
||||
@classmethod
|
||||
def from_list(cls, args: List[float]) -> "Point":
|
||||
"""
|
||||
Create a new Point from a list of three floats
|
||||
representing the x, y, and z coordinates
|
||||
"""
|
||||
return cls(x=args[0], y=args[1], z=args[2])
|
||||
|
||||
def to_list(self) -> List[Any]:
|
||||
return [self.x, self.y, self.z]
|
||||
|
||||
@classmethod
|
||||
def from_coords(cls, x: float = 0.0, y: float = 0.0, z: float = 0.0):
|
||||
"""Create a new Point from x, y, and z values"""
|
||||
pt = Point()
|
||||
pt.x, pt.y, pt.z = x, y, z
|
||||
return pt
|
||||
|
||||
|
||||
class Pointcloud(
|
||||
Base,
|
||||
speckle_type=GEOMETRY + "Pointcloud",
|
||||
chunkable={"points": 31250, "colors": 62500, "sizes": 62500},
|
||||
):
|
||||
points: Optional[List[float]] = None
|
||||
colors: Optional[List[int]] = None
|
||||
sizes: Optional[List[float]] = None
|
||||
bbox: Optional["Box"] = None
|
||||
|
||||
|
||||
class Vector(Base, speckle_type=GEOMETRY + "Vector"):
|
||||
x: float = 0.0
|
||||
y: float = 0.0
|
||||
z: float = 0.0
|
||||
applicationId: Optional[str] = None
|
||||
|
||||
def __repr__(self) -> str:
|
||||
return (
|
||||
f"{self.__class__.__name__} "
|
||||
"(x: {self.x}, y: {self.y}, z: {self.z}, id: {self.id}, "
|
||||
"speckle_type: {self.speckle_type})"
|
||||
)
|
||||
|
||||
@classmethod
|
||||
def from_list(cls, args: List[float]) -> "Vector":
|
||||
"""
|
||||
Create from a list of three floats representing the x, y, and z coordinates.
|
||||
"""
|
||||
return cls(x=args[0], y=args[1], z=args[2])
|
||||
|
||||
def to_list(self) -> List[float]:
|
||||
return [self.x, self.y, self.z]
|
||||
|
||||
@classmethod
|
||||
def from_coords(cls, x: float = 0.0, y: float = 0.0, z: float = 0.0) -> "Vector":
|
||||
"""Create a new Point from x, y, and z values"""
|
||||
v = Vector()
|
||||
v.x, v.y, v.z = x, y, z
|
||||
return v
|
||||
|
||||
|
||||
class ControlPoint(Point, speckle_type=GEOMETRY + "ControlPoint"):
|
||||
weight: Optional[float] = None
|
||||
|
||||
|
||||
class Plane(Base, speckle_type=GEOMETRY + "Plane"):
|
||||
origin: Point = Point()
|
||||
normal: Vector = Vector()
|
||||
xdir: Vector = Vector()
|
||||
ydir: Vector = Vector()
|
||||
|
||||
@classmethod
|
||||
def from_list(cls, args: List[Any]) -> "Plane":
|
||||
return cls(
|
||||
origin=Point.from_list(args[:3]),
|
||||
normal=Vector.from_list(args[3:6]),
|
||||
xdir=Vector.from_list(args[6:9]),
|
||||
ydir=Vector.from_list(args[9:12]),
|
||||
units=get_units_from_encoding(args[-1]),
|
||||
)
|
||||
|
||||
def to_list(self) -> List[Any]:
|
||||
return [
|
||||
*self.origin.to_list(),
|
||||
*self.normal.to_list(),
|
||||
*self.xdir.to_list(),
|
||||
*self.ydir.to_list(),
|
||||
get_encoding_from_units(self._units),
|
||||
]
|
||||
|
||||
|
||||
class Box(Base, speckle_type=GEOMETRY + "Box"):
|
||||
basePlane: Plane = Plane()
|
||||
xSize: Interval = Interval()
|
||||
ySize: Interval = Interval()
|
||||
zSize: Interval = Interval()
|
||||
area: Optional[float] = None
|
||||
volume: Optional[float] = None
|
||||
|
||||
|
||||
class Line(Base, speckle_type=GEOMETRY + "Line"):
|
||||
start: Point = Point()
|
||||
end: Optional[Point] = None
|
||||
domain: Optional[Interval] = None
|
||||
bbox: Optional[Box] = None
|
||||
length: Optional[float] = None
|
||||
|
||||
@classmethod
|
||||
def from_list(cls, args: List[Any]) -> "Line":
|
||||
return cls(
|
||||
start=Point.from_list(args[1:4]),
|
||||
end=Point.from_list(args[4:7]),
|
||||
domain=Interval.from_list(args[7:10]),
|
||||
units=get_units_from_encoding(args[-1]),
|
||||
)
|
||||
|
||||
def to_list(self) -> List[Any]:
|
||||
domain = self.domain.to_list() if self.domain else [0, 1]
|
||||
return [
|
||||
CurveTypeEncoding.Line.value,
|
||||
*self.start.to_list(),
|
||||
*self.end.to_list(),
|
||||
*domain,
|
||||
get_encoding_from_units(self._units),
|
||||
]
|
||||
|
||||
|
||||
class Arc(Base, speckle_type=GEOMETRY + "Arc"):
|
||||
radius: Optional[float] = None
|
||||
startAngle: Optional[float] = None
|
||||
endAngle: Optional[float] = None
|
||||
angleRadians: Optional[float] = None
|
||||
plane: Optional[Plane] = None
|
||||
domain: Optional[Interval] = None
|
||||
startPoint: Optional[Point] = None
|
||||
midPoint: Optional[Point] = None
|
||||
endPoint: Optional[Point] = None
|
||||
bbox: Optional[Box] = None
|
||||
area: Optional[float] = None
|
||||
length: Optional[float] = None
|
||||
|
||||
@classmethod
|
||||
def from_list(cls, args: List[Any]) -> "Arc":
|
||||
return cls(
|
||||
radius=args[1],
|
||||
startAngle=args[2],
|
||||
endAngle=args[3],
|
||||
angleRadians=args[4],
|
||||
domain=Interval.from_list(args[5:7]),
|
||||
plane=Plane.from_list(args[7:20]),
|
||||
startPoint=Point.from_list(args[20:23]),
|
||||
midPoint=Point.from_list(args[23:26]),
|
||||
endPoint=Point.from_list(args[26:29]),
|
||||
units=get_units_from_encoding(args[-1]),
|
||||
)
|
||||
|
||||
def to_list(self) -> List[Any]:
|
||||
return [
|
||||
CurveTypeEncoding.Arc.value,
|
||||
self.radius,
|
||||
self.startAngle,
|
||||
self.endAngle,
|
||||
self.angleRadians,
|
||||
*self.domain.to_list(),
|
||||
*self.plane.to_list(),
|
||||
*self.startPoint.to_list(),
|
||||
*self.midPoint.to_list(),
|
||||
*self.endPoint.to_list(),
|
||||
get_encoding_from_units(self._units),
|
||||
]
|
||||
|
||||
|
||||
class Circle(Base, speckle_type=GEOMETRY + "Circle"):
|
||||
radius: Optional[float] = None
|
||||
plane: Optional[Plane] = None
|
||||
domain: Optional[Interval] = None
|
||||
bbox: Optional[Box] = None
|
||||
area: Optional[float] = None
|
||||
length: Optional[float] = None
|
||||
|
||||
@classmethod
|
||||
def from_list(cls, args: List[Any]) -> "Circle":
|
||||
return cls(
|
||||
radius=args[1],
|
||||
domain=Interval.from_list(args[2:4]),
|
||||
plane=Plane.from_list(args[4:17]),
|
||||
units=get_units_from_encoding(args[-1]),
|
||||
)
|
||||
|
||||
def to_list(self) -> List[Any]:
|
||||
return [
|
||||
CurveTypeEncoding.Circle.value,
|
||||
self.radius,
|
||||
*self.domain.to_list(),
|
||||
*self.plane.to_list(),
|
||||
get_encoding_from_units(self._units),
|
||||
]
|
||||
|
||||
|
||||
class Ellipse(Base, speckle_type=GEOMETRY + "Ellipse"):
|
||||
firstRadius: Optional[float] = None
|
||||
secondRadius: Optional[float] = None
|
||||
plane: Optional[Plane] = None
|
||||
domain: Optional[Interval] = None
|
||||
trimDomain: Optional[Interval] = None
|
||||
bbox: Optional[Box] = None
|
||||
area: Optional[float] = None
|
||||
length: Optional[float] = None
|
||||
|
||||
@classmethod
|
||||
def from_list(cls, args: List[Any]) -> "Ellipse":
|
||||
return cls(
|
||||
firstRadius=args[1],
|
||||
secondRadius=args[2],
|
||||
domain=Interval.from_list(args[3:5]),
|
||||
plane=Plane.from_list(args[5:18]),
|
||||
units=get_units_from_encoding(args[-1]),
|
||||
)
|
||||
|
||||
def to_list(self) -> List[Any]:
|
||||
return [
|
||||
CurveTypeEncoding.Ellipse.value,
|
||||
self.firstRadius,
|
||||
self.secondRadius,
|
||||
*self.domain.to_list(),
|
||||
*self.plane.to_list(),
|
||||
get_encoding_from_units(self._units),
|
||||
]
|
||||
|
||||
|
||||
class Polyline(Base, speckle_type=GEOMETRY + "Polyline", chunkable={"value": 20000}):
|
||||
value: Optional[List[float]] = None
|
||||
closed: Optional[bool] = None
|
||||
domain: Optional[Interval] = None
|
||||
bbox: Optional[Box] = None
|
||||
area: Optional[float] = None
|
||||
length: Optional[float] = None
|
||||
|
||||
@classmethod
|
||||
def from_points(cls, points: List[Point]):
|
||||
"""Create a new Polyline from a list of Points"""
|
||||
polyline = cls()
|
||||
polyline.units = points[0].units
|
||||
polyline.value = []
|
||||
for point in points:
|
||||
polyline.value.extend([point.x, point.y, point.z])
|
||||
return polyline
|
||||
|
||||
@classmethod
|
||||
def from_list(cls, args: List[Any]) -> "Polyline":
|
||||
point_count = args[4]
|
||||
return cls(
|
||||
closed=bool(args[1]),
|
||||
domain=Interval.from_list(args[2:4]),
|
||||
value=args[5 : 5 + point_count],
|
||||
units=get_units_from_encoding(args[-1]),
|
||||
)
|
||||
|
||||
def to_list(self) -> List[Any]:
|
||||
return [
|
||||
CurveTypeEncoding.Polyline.value,
|
||||
int(self.closed),
|
||||
*self.domain.to_list(),
|
||||
len(self.value),
|
||||
*self.value,
|
||||
get_encoding_from_units(self._units),
|
||||
]
|
||||
|
||||
def as_points(self) -> List[Point]:
|
||||
"""Converts the `value` attribute to a list of Points"""
|
||||
if not self.value:
|
||||
return
|
||||
|
||||
if len(self.value) % 3:
|
||||
raise ValueError("Points array malformed: length%3 != 0.")
|
||||
|
||||
values = iter(self.value)
|
||||
return [
|
||||
Point(x=v, y=next(values), z=next(values), units=self.units) for v in values
|
||||
]
|
||||
|
||||
|
||||
class SpiralType(Enum):
|
||||
Biquadratic = 0
|
||||
BiquadraticParabola = 1
|
||||
Bloss = 2
|
||||
Clothoid = 3
|
||||
Cosine = 4
|
||||
Cubic = 5
|
||||
CubicParabola = 6
|
||||
Radioid = 7
|
||||
Sinusoid = 8
|
||||
Unknown = 9
|
||||
|
||||
|
||||
class Spiral(Base, speckle_type=GEOMETRY + "Spiral", detachable={"displayValue"}):
|
||||
startPoint: Optional[Point] = None
|
||||
endPoint: Optional[Point]
|
||||
plane: Optional[Plane]
|
||||
turns: Optional[float]
|
||||
pitchAxis: Optional[Vector] = Vector()
|
||||
pitch: float = 0
|
||||
spiralType: Optional[SpiralType] = None
|
||||
displayValue: Optional[Polyline] = None
|
||||
bbox: Optional[Box] = None
|
||||
length: Optional[float] = None
|
||||
domain: Optional[Interval] = None
|
||||
|
||||
|
||||
class Curve(
|
||||
Base,
|
||||
speckle_type=GEOMETRY + "Curve",
|
||||
chunkable={"points": 20000, "weights": 20000, "knots": 20000},
|
||||
):
|
||||
degree: Optional[int] = None
|
||||
periodic: Optional[bool] = None
|
||||
rational: Optional[bool] = None
|
||||
points: Optional[List[float]] = None
|
||||
weights: Optional[List[float]] = None
|
||||
knots: Optional[List[float]] = None
|
||||
domain: Optional[Interval] = None
|
||||
displayValue: Optional[Polyline] = None
|
||||
closed: Optional[bool] = None
|
||||
bbox: Optional[Box] = None
|
||||
area: Optional[float] = None
|
||||
length: Optional[float] = None
|
||||
|
||||
def as_points(self) -> List[Point]:
|
||||
"""Converts the `value` attribute to a list of Points"""
|
||||
if not self.points:
|
||||
return
|
||||
|
||||
if len(self.points) % 3:
|
||||
raise ValueError("Points array malformed: length%3 != 0.")
|
||||
|
||||
values = iter(self.points)
|
||||
return [
|
||||
Point(x=v, y=next(values), z=next(values), units=self.units) for v in values
|
||||
]
|
||||
|
||||
@classmethod
|
||||
def from_list(cls, args: List[Any]) -> "Curve":
|
||||
point_count = int(args[7])
|
||||
weights_count = int(args[8])
|
||||
knots_count = int(args[9])
|
||||
|
||||
points_start = 10
|
||||
weights_start = 10 + point_count
|
||||
knots_start = weights_start + weights_count
|
||||
knots_end = knots_start + knots_count
|
||||
|
||||
return cls(
|
||||
degree=int(args[1]),
|
||||
periodic=bool(args[2]),
|
||||
rational=bool(args[3]),
|
||||
closed=bool(args[4]),
|
||||
domain=Interval.from_list(args[5:7]),
|
||||
points=args[points_start:weights_start],
|
||||
weights=args[weights_start:knots_start],
|
||||
knots=args[knots_start:knots_end],
|
||||
units=get_units_from_encoding(args[-1]),
|
||||
)
|
||||
|
||||
def to_list(self) -> List[Any]:
|
||||
return [
|
||||
CurveTypeEncoding.Curve.value,
|
||||
self.degree,
|
||||
int(self.periodic),
|
||||
int(self.rational),
|
||||
int(self.closed),
|
||||
*self.domain.to_list(),
|
||||
len(self.points),
|
||||
len(self.weights),
|
||||
len(self.knots),
|
||||
*self.points,
|
||||
*self.weights,
|
||||
*self.knots,
|
||||
get_encoding_from_units(self._units),
|
||||
]
|
||||
|
||||
|
||||
class Polycurve(Base, speckle_type=GEOMETRY + "Polycurve"):
|
||||
segments: Optional[List[Base]] = None
|
||||
domain: Optional[Interval] = None
|
||||
closed: Optional[bool] = None
|
||||
bbox: Optional[Box] = None
|
||||
area: Optional[float] = None
|
||||
length: Optional[float] = None
|
||||
|
||||
@classmethod
|
||||
def from_list(cls, args: List[Any]) -> "Polycurve":
|
||||
curve_arrays = CurveArray(args[5:-1])
|
||||
return cls(
|
||||
closed=bool(args[1]),
|
||||
domain=Interval.from_list(args[2:4]),
|
||||
segments=curve_arrays.to_curves(),
|
||||
units=get_units_from_encoding(args[-1]),
|
||||
)
|
||||
|
||||
def to_list(self) -> List[Any]:
|
||||
curve_array = CurveArray.from_curves(self.segments).data
|
||||
return [
|
||||
CurveTypeEncoding.Polycurve.value,
|
||||
int(self.closed),
|
||||
*self.domain.to_list(),
|
||||
len(curve_array),
|
||||
*curve_array,
|
||||
get_encoding_from_units(self._units),
|
||||
]
|
||||
|
||||
|
||||
class Extrusion(Base, speckle_type=GEOMETRY + "Extrusion"):
|
||||
capped: Optional[bool] = None
|
||||
profile: Optional[Base] = None
|
||||
pathStart: Optional[Point] = None
|
||||
pathEnd: Optional[Point] = None
|
||||
pathCurve: Optional[Base] = None
|
||||
pathTangent: Optional[Base] = None
|
||||
profiles: Optional[List[Base]] = None
|
||||
length: Optional[float] = None
|
||||
area: Optional[float] = None
|
||||
volume: Optional[float] = None
|
||||
bbox: Optional[Box] = None
|
||||
|
||||
|
||||
class Mesh(
|
||||
Base,
|
||||
speckle_type=GEOMETRY + "Mesh",
|
||||
chunkable={
|
||||
"vertices": 2000,
|
||||
"faces": 2000,
|
||||
"colors": 2000,
|
||||
"textureCoordinates": 2000,
|
||||
},
|
||||
):
|
||||
vertices: Optional[List[float]] = None
|
||||
faces: Optional[List[int]] = None
|
||||
colors: Optional[List[int]] = None
|
||||
textureCoordinates: Optional[List[float]] = None
|
||||
bbox: Optional[Box] = None
|
||||
area: Optional[float] = None
|
||||
volume: Optional[float] = None
|
||||
|
||||
@classmethod
|
||||
def create(
|
||||
cls,
|
||||
vertices: List[float],
|
||||
faces: List[int],
|
||||
colors: Optional[List[int]] = None,
|
||||
texture_coordinates: Optional[List[float]] = None,
|
||||
) -> "Mesh":
|
||||
"""
|
||||
Create a new Mesh from lists representing its vertices, faces,
|
||||
colors (optional), and texture coordinates (optional).
|
||||
|
||||
This will initialise empty lists for colors and texture coordinates
|
||||
if you do not provide any.
|
||||
"""
|
||||
return cls(
|
||||
vertices=vertices,
|
||||
faces=faces,
|
||||
colors=colors or [],
|
||||
textureCoordinates=texture_coordinates or [],
|
||||
)
|
||||
|
||||
|
||||
class Surface(Base, speckle_type=GEOMETRY + "Surface"):
|
||||
degreeU: Optional[int] = None
|
||||
degreeV: Optional[int] = None
|
||||
rational: Optional[bool] = None
|
||||
area: Optional[float] = None
|
||||
pointData: Optional[List[float]] = None
|
||||
countU: Optional[int] = None
|
||||
countV: Optional[int] = None
|
||||
bbox: Optional[Box] = None
|
||||
closedU: Optional[bool] = None
|
||||
closedV: Optional[bool] = None
|
||||
domainU: Optional[Interval] = None
|
||||
domainV: Optional[Interval] = None
|
||||
knotsU: Optional[List[float]] = None
|
||||
knotsV: Optional[List[float]] = None
|
||||
|
||||
@classmethod
|
||||
def from_list(cls, args: List[Any]) -> "Surface":
|
||||
point_count = int(args[11])
|
||||
knots_u_count = int(args[12])
|
||||
knots_v_count = int(args[13])
|
||||
|
||||
start_point_data = 14
|
||||
start_knots_u = start_point_data + point_count
|
||||
start_knots_v = start_knots_u + knots_u_count
|
||||
|
||||
return cls(
|
||||
degreeU=int(args[0]),
|
||||
degreeV=int(args[1]),
|
||||
countU=int(args[2]),
|
||||
countV=int(args[3]),
|
||||
rational=bool(args[4]),
|
||||
closedU=bool(args[5]),
|
||||
closedV=bool(args[6]),
|
||||
domainU=Interval(start=args[7], end=args[8]),
|
||||
domainV=Interval(start=args[9], end=args[10]),
|
||||
pointData=args[start_point_data:start_knots_u],
|
||||
knotsU=args[start_knots_u:start_knots_v],
|
||||
knotsV=args[start_knots_v : start_knots_v + knots_v_count],
|
||||
units=get_units_from_encoding(args[-1]),
|
||||
)
|
||||
|
||||
def to_list(self) -> List[Any]:
|
||||
return [
|
||||
self.degreeU,
|
||||
self.degreeV,
|
||||
self.countU,
|
||||
self.countV,
|
||||
int(self.rational),
|
||||
int(self.closedU),
|
||||
int(self.closedV),
|
||||
*self.domainU.to_list(),
|
||||
*self.domainV.to_list(),
|
||||
len(self.pointData),
|
||||
len(self.knotsU),
|
||||
len(self.knotsV),
|
||||
*self.pointData,
|
||||
*self.knotsU,
|
||||
*self.knotsV,
|
||||
get_encoding_from_units(self._units),
|
||||
]
|
||||
|
||||
|
||||
class BrepFace(Base, speckle_type=GEOMETRY + "BrepFace"):
|
||||
_Brep: Optional["Brep"] = None
|
||||
SurfaceIndex: Optional[int] = None
|
||||
OuterLoopIndex: Optional[int] = None
|
||||
OrientationReversed: Optional[bool] = None
|
||||
LoopIndices: Optional[List[int]] = None
|
||||
|
||||
@property
|
||||
def _outer_loop(self):
|
||||
return self._Brep.Loops[self.OuterLoopIndex] # pylint: disable=no-member
|
||||
|
||||
@property
|
||||
def _surface(self):
|
||||
return self._Brep.Surfaces[self.SurfaceIndex] # pylint: disable=no-member
|
||||
|
||||
@property
|
||||
def _loops(self):
|
||||
if self.LoopIndices:
|
||||
# pylint: disable=not-an-iterable, no-member
|
||||
return [self._Brep.Loops[i] for i in self.LoopIndices]
|
||||
|
||||
@classmethod
|
||||
def from_list(cls, args: List[Any], brep: "Brep" = None) -> "BrepFace":
|
||||
return cls(
|
||||
_Brep=brep,
|
||||
SurfaceIndex=args[0],
|
||||
OuterLoopIndex=args[1],
|
||||
OrientationReversed=bool(args[2]),
|
||||
LoopIndices=args[3:],
|
||||
)
|
||||
|
||||
def to_list(self) -> List[Any]:
|
||||
return [
|
||||
self.SurfaceIndex,
|
||||
self.OuterLoopIndex,
|
||||
int(self.OrientationReversed),
|
||||
*self.LoopIndices,
|
||||
]
|
||||
|
||||
|
||||
class BrepEdge(Base, speckle_type=GEOMETRY + "BrepEdge"):
|
||||
_Brep: Optional["Brep"] = None
|
||||
Curve3dIndex: Optional[int] = None
|
||||
TrimIndices: Optional[List[int]] = None
|
||||
StartIndex: Optional[int] = None
|
||||
EndIndex: Optional[int] = None
|
||||
ProxyCurveIsReversed: Optional[bool] = None
|
||||
Domain: Optional[Interval] = None
|
||||
|
||||
@property
|
||||
def _start_vertex(self):
|
||||
return self._Brep.Vertices[self.StartIndex]
|
||||
|
||||
@property
|
||||
def _end_vertex(self):
|
||||
return self._Brep.Vertices[self.EndIndex]
|
||||
|
||||
@property
|
||||
def _trims(self):
|
||||
if self.TrimIndices:
|
||||
# pylint: disable=not-an-iterable
|
||||
return [self._Brep.Trims[i] for i in self.TrimIndices]
|
||||
|
||||
@property
|
||||
def _curve(self):
|
||||
return self._Brep.Curve3D[self.Curve3dIndex]
|
||||
|
||||
@classmethod
|
||||
def from_list(cls, args: List[Any], brep: "Brep" = None) -> "BrepEdge":
|
||||
domain_start = args[4]
|
||||
domain_end = args[5]
|
||||
domain = (
|
||||
Interval(start=domain_start, end=domain_end)
|
||||
if None not in (domain_start, domain_end)
|
||||
else None
|
||||
)
|
||||
return cls(
|
||||
_Brep=brep,
|
||||
Curve3dIndex=int(args[0]),
|
||||
TrimIndices=[int(t) for t in args[6:]],
|
||||
StartIndex=int(args[1]),
|
||||
EndIndex=int(args[2]),
|
||||
ProxyCurveIsReversed=bool(args[3]),
|
||||
Domain=domain,
|
||||
)
|
||||
|
||||
def to_list(self) -> List[Any]:
|
||||
return [
|
||||
self.Curve3dIndex,
|
||||
self.StartIndex,
|
||||
self.EndIndex,
|
||||
int(self.ProxyCurveIsReversed),
|
||||
self.Domain.start,
|
||||
self.Domain.end,
|
||||
*self.TrimIndices,
|
||||
]
|
||||
|
||||
|
||||
class BrepLoopType(int, Enum):
|
||||
Unknown = 0
|
||||
Outer = 1
|
||||
Inner = 2
|
||||
Slit = 3
|
||||
CurveOnSurface = 4
|
||||
PointOnSurface = 5
|
||||
|
||||
|
||||
class BrepLoop(Base, speckle_type=GEOMETRY + "BrepLoop"):
|
||||
_Brep: Optional["Brep"] = None
|
||||
FaceIndex: Optional[Optional[int]] = None
|
||||
TrimIndices: Optional[List[int]] = None
|
||||
Type: Optional[BrepLoopType] = None
|
||||
|
||||
@property
|
||||
def _face(self):
|
||||
return self._Brep.Faces[self.FaceIndex]
|
||||
|
||||
@property
|
||||
def _trims(self):
|
||||
if self.TrimIndices:
|
||||
# pylint: disable=not-an-iterable
|
||||
return [self._Brep.Trims[i] for i in self.TrimIndices]
|
||||
|
||||
@classmethod
|
||||
def from_list(cls, args: List[any], brep: "Brep" = None):
|
||||
return cls(
|
||||
_Brep=brep,
|
||||
FaceIndex=args[0],
|
||||
Type=BrepLoopType(args[1]),
|
||||
TrimIndices=args[2:],
|
||||
)
|
||||
|
||||
def to_list(self) -> List[int]:
|
||||
return [
|
||||
self.FaceIndex,
|
||||
self.Type.value,
|
||||
*self.TrimIndices,
|
||||
]
|
||||
|
||||
|
||||
class BrepTrimType(int, Enum):
|
||||
Unknown = 0
|
||||
Boundary = 1
|
||||
Mated = 2
|
||||
Seam = 3
|
||||
Singular = 4
|
||||
CurveOnSurface = 5
|
||||
PointOnSurface = 6
|
||||
Slit = 7
|
||||
|
||||
|
||||
class BrepTrim(Base, speckle_type=GEOMETRY + "BrepTrim"):
|
||||
_Brep: Optional["Brep"] = None
|
||||
EdgeIndex: Optional[int] = None
|
||||
StartIndex: Optional[int] = None
|
||||
EndIndex: Optional[int] = None
|
||||
FaceIndex: Optional[int] = None
|
||||
LoopIndex: Optional[int] = None
|
||||
CurveIndex: Optional[int] = None
|
||||
IsoStatus: Optional[int] = None
|
||||
TrimType: Optional[BrepTrimType] = None
|
||||
IsReversed: Optional[bool] = None
|
||||
Domain: Optional[Interval] = None
|
||||
|
||||
@property
|
||||
def _face(self):
|
||||
if self._Brep:
|
||||
return self._Brep.Faces[self.FaceIndex] # pylint: disable=no-member
|
||||
|
||||
@property
|
||||
def _loop(self):
|
||||
if self._Brep:
|
||||
return self._Brep.Loops[self.LoopIndex] # pylint: disable=no-member
|
||||
|
||||
@property
|
||||
def _edge(self):
|
||||
if self._Brep:
|
||||
# pylint: disable=no-member
|
||||
return self._Brep.Edges[self.EdgeIndex] if self.EdgeIndex != -1 else None
|
||||
|
||||
@property
|
||||
def _curve_2d(self):
|
||||
if self._Brep:
|
||||
return self._Brep.Curve2D[self.CurveIndex] # pylint: disable=no-member
|
||||
|
||||
@classmethod
|
||||
def from_list(cls, args: List[Any], brep: "Brep" = None) -> "BrepTrim":
|
||||
return cls(
|
||||
_Brep=brep,
|
||||
EdgeIndex=args[0],
|
||||
StartIndex=args[1],
|
||||
EndIndex=args[2],
|
||||
FaceIndex=args[3],
|
||||
LoopIndex=args[4],
|
||||
CurveIndex=args[5],
|
||||
IsoStatus=args[6],
|
||||
TrimType=BrepTrimType(args[7]),
|
||||
IsReversed=bool(args[8]),
|
||||
)
|
||||
|
||||
def to_list(self) -> List[Any]:
|
||||
return [
|
||||
self.EdgeIndex,
|
||||
self.StartIndex,
|
||||
self.EndIndex,
|
||||
self.FaceIndex,
|
||||
self.LoopIndex,
|
||||
self.CurveIndex,
|
||||
self.IsoStatus,
|
||||
self.TrimType.value,
|
||||
int(self.IsReversed),
|
||||
]
|
||||
|
||||
|
||||
class Brep(
|
||||
Base,
|
||||
speckle_type=GEOMETRY + "Brep",
|
||||
chunkable={
|
||||
"SurfacesValue": 31250,
|
||||
"Curve3DValues": 31250,
|
||||
"Curve2DValues": 31250,
|
||||
"VerticesValue": 31250,
|
||||
"EdgesValue": 62500,
|
||||
"LoopsValue": 62500,
|
||||
"FacesValue": 62500,
|
||||
"TrimsValue": 62500,
|
||||
},
|
||||
detachable={"displayValue"},
|
||||
serialize_ignore={
|
||||
"Surfaces",
|
||||
"Curve3D",
|
||||
"Curve2D",
|
||||
"Vertices",
|
||||
"Trims",
|
||||
"Edges",
|
||||
"Loops",
|
||||
"Faces",
|
||||
},
|
||||
):
|
||||
provenance: Optional[str] = None
|
||||
bbox: Optional[Box] = None
|
||||
area: Optional[float] = None
|
||||
volume: Optional[float] = None
|
||||
_displayValue: Optional[List[Mesh]] = None
|
||||
Surfaces: Optional[List[Surface]] = None
|
||||
Curve3D: Optional[List[Base]] = None
|
||||
Curve2D: Optional[List[Base]] = None
|
||||
Vertices: Optional[List[Point]] = None
|
||||
Edges: Optional[List[BrepEdge]] = None
|
||||
Loops: Optional[List[BrepLoop]] = None
|
||||
Faces: Optional[List[BrepFace]] = None
|
||||
Trims: Optional[List[BrepTrim]] = None
|
||||
IsClosed: Optional[bool] = None
|
||||
Orientation: Optional[int] = None
|
||||
|
||||
def _inject_self_into_children(self, children: Optional[List[Base]]) -> List[Base]:
|
||||
if children is None:
|
||||
return children
|
||||
|
||||
for child in children:
|
||||
child._Brep = self # pylint: disable=protected-access
|
||||
return children
|
||||
|
||||
# set as prop for now for backwards compatibility
|
||||
@property
|
||||
def displayValue(self) -> List[Mesh]:
|
||||
return self._displayValue
|
||||
|
||||
@displayValue.setter
|
||||
def displayValue(self, value):
|
||||
if isinstance(value, Mesh):
|
||||
self._displayValue = [value]
|
||||
elif isinstance(value, list):
|
||||
self._displayValue = value
|
||||
|
||||
@property
|
||||
def EdgesValue(self) -> List[BrepEdge]:
|
||||
return None if self.Edges is None else ObjectArray.from_objects(self.Edges).data
|
||||
|
||||
@EdgesValue.setter
|
||||
def EdgesValue(self, value: List[float]):
|
||||
if not value:
|
||||
return
|
||||
|
||||
self.Edges = ObjectArray.decode_data(value, BrepEdge.from_list, brep=self)
|
||||
|
||||
@property
|
||||
def LoopsValue(self) -> List[BrepLoop]:
|
||||
return None if self.Loops is None else ObjectArray.from_objects(self.Loops).data
|
||||
|
||||
@LoopsValue.setter
|
||||
def LoopsValue(self, value: List[int]):
|
||||
if not value:
|
||||
return
|
||||
|
||||
self.Loops = ObjectArray.decode_data(value, BrepLoop.from_list, brep=self)
|
||||
|
||||
@property
|
||||
def FacesValue(self) -> List[int]:
|
||||
return None if self.Faces is None else ObjectArray.from_objects(self.Faces).data
|
||||
|
||||
@FacesValue.setter
|
||||
def FacesValue(self, value: List[int]):
|
||||
if not value:
|
||||
return
|
||||
|
||||
self.Faces = ObjectArray.decode_data(value, BrepFace.from_list, brep=self)
|
||||
|
||||
@property
|
||||
def SurfacesValue(self) -> List[float]:
|
||||
return (
|
||||
None
|
||||
if self.Surfaces is None
|
||||
else ObjectArray.from_objects(self.Surfaces).data
|
||||
)
|
||||
|
||||
@SurfacesValue.setter
|
||||
def SurfacesValue(self, value: List[float]):
|
||||
if not value:
|
||||
return
|
||||
|
||||
self.Surfaces = ObjectArray.decode_data(value, Surface.from_list)
|
||||
|
||||
@property
|
||||
def Curve3DValues(self) -> List[float]:
|
||||
return (
|
||||
None if self.Curve3D is None else CurveArray.from_curves(self.Curve3D).data
|
||||
)
|
||||
|
||||
@Curve3DValues.setter
|
||||
def Curve3DValues(self, value: List[float]):
|
||||
crv_array = CurveArray(value)
|
||||
self.Curve3D = crv_array.to_curves()
|
||||
|
||||
@property
|
||||
def Curve2DValues(self) -> List[Base]:
|
||||
return (
|
||||
None if self.Curve2D is None else CurveArray.from_curves(self.Curve2D).data
|
||||
)
|
||||
|
||||
@Curve2DValues.setter
|
||||
def Curve2DValues(self, value: List[float]):
|
||||
crv_array = CurveArray(value)
|
||||
self.Curve2D = crv_array.to_curves()
|
||||
|
||||
@property
|
||||
def VerticesValue(self) -> List[Point]:
|
||||
if self.Vertices is None:
|
||||
return None
|
||||
encoded_unit = get_encoding_from_units(self.Vertices[0].units)
|
||||
values = [encoded_unit]
|
||||
for vertex in self.Vertices:
|
||||
values.extend(vertex.to_list())
|
||||
return values
|
||||
|
||||
@VerticesValue.setter
|
||||
def VerticesValue(self, value: List[float]):
|
||||
value = value.copy()
|
||||
units = get_units_from_encoding(value.pop(0))
|
||||
|
||||
vertices = []
|
||||
|
||||
for i in range(0, len(value), 3):
|
||||
vertex = Point.from_list(value[i : i + 3])
|
||||
vertex.units = units
|
||||
vertices.append(vertex)
|
||||
|
||||
self.Vertices = vertices
|
||||
|
||||
# TODO: can this be consistent with loops, edges, faces, curves,
|
||||
# etc and prepend with the chunk list? needs to happen in sharp first
|
||||
@property
|
||||
def TrimsValue(self) -> List[float]:
|
||||
# return None if self.Trims is None else
|
||||
# ObjectArray.from_objects(self.Trims).data
|
||||
if not self.Trims:
|
||||
return
|
||||
value = []
|
||||
for trim in self.Trims:
|
||||
value.extend(trim.to_list())
|
||||
return value
|
||||
|
||||
@TrimsValue.setter
|
||||
def TrimsValue(self, value: List[float]):
|
||||
if not value:
|
||||
return
|
||||
|
||||
# self.Trims = ObjectArray.decode_data(value, BrepTrim.from_list, brep=self)
|
||||
self.Trims = [
|
||||
BrepTrim.from_list(value[i : i + 9], self) for i in range(0, len(value), 9)
|
||||
]
|
||||
|
||||
|
||||
BrepEdge.update_forward_refs()
|
||||
BrepLoop.update_forward_refs()
|
||||
BrepTrim.update_forward_refs()
|
||||
BrepFace.update_forward_refs()
|
||||
@@ -1,311 +0,0 @@
|
||||
from typing import Any, List, Optional
|
||||
|
||||
from deprecated import deprecated
|
||||
|
||||
from specklepy.objects.geometry import Plane, Point, Polyline, Vector
|
||||
|
||||
from .base import Base
|
||||
|
||||
OTHER = "Objects.Other."
|
||||
OTHER_REVIT = OTHER + "Revit."
|
||||
|
||||
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 Material(Base, speckle_type=OTHER + "Material"):
|
||||
"""Generic class for materials containing generic parameters."""
|
||||
|
||||
name: Optional[str] = None
|
||||
|
||||
|
||||
class RevitMaterial(Material, speckle_type="Objects.Other.Revit." + "RevitMaterial"):
|
||||
materialCategory: Optional[str] = None
|
||||
materialClass: Optional[str] = None
|
||||
shininess: Optional[int] = None
|
||||
smoothness: Optional[int] = None
|
||||
transparency: Optional[int] = None
|
||||
parameters: Optional[Base] = None
|
||||
|
||||
|
||||
class RenderMaterial(Base, speckle_type=OTHER + "RenderMaterial"):
|
||||
name: Optional[str] = None
|
||||
opacity: float = 1
|
||||
metalness: float = 0
|
||||
roughness: float = 1
|
||||
diffuse: int = -2894893 # light gray arbg
|
||||
emissive: int = -16777216 # black arbg
|
||||
|
||||
|
||||
class MaterialQuantity(Base, speckle_type=OTHER + "MaterialQuantity"):
|
||||
material: Optional[Material] = None
|
||||
volume: Optional[float] = None
|
||||
area: Optional[float] = None
|
||||
|
||||
|
||||
class DisplayStyle(Base, speckle_type=OTHER + "DisplayStyle"):
|
||||
"""
|
||||
Minimal display style class.
|
||||
Developed primarily for display styles in Rhino and AutoCAD.
|
||||
Rhino object attributes uses OpenNURBS definition for linetypes and lineweights.
|
||||
"""
|
||||
|
||||
name: Optional[str] = None
|
||||
color: int = -2894893 # light gray arbg
|
||||
linetype: Optional[str] = None
|
||||
lineweight: float = 0
|
||||
|
||||
|
||||
class Text(Base, speckle_type=OTHER + "Text"):
|
||||
"""
|
||||
Text object to render it on viewer.
|
||||
"""
|
||||
|
||||
plane: Plane
|
||||
value: str
|
||||
height: float
|
||||
rotation: float
|
||||
displayValue: Optional[List[Polyline]] = None
|
||||
richText: Optional[str] = None
|
||||
|
||||
|
||||
class Transform(
|
||||
Base,
|
||||
speckle_type=OTHER + "Transform",
|
||||
serialize_ignore={"translation", "scaling", "is_identity", "value"},
|
||||
):
|
||||
"""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: Optional[List[float]] = None
|
||||
|
||||
@property
|
||||
@deprecated(version="2.12", reason="Use matrix")
|
||||
def value(self) -> List[float]:
|
||||
return self._value
|
||||
|
||||
@value.setter
|
||||
def value(self, value: List[float]) -> None:
|
||||
self.matrix = value
|
||||
|
||||
@property
|
||||
def matrix(self) -> List[float]:
|
||||
"""The transform matrix represented as a flat list of 16 floats"""
|
||||
return self._value
|
||||
|
||||
@matrix.setter
|
||||
def matrix(self, value: List[float]) -> None:
|
||||
try:
|
||||
value = [float(x) for x in value]
|
||||
except (ValueError, TypeError) as error:
|
||||
raise ValueError(
|
||||
"Could not create a Transform object with the requested value. Input"
|
||||
f" must be a 16 element list of numbers. Value provided: {value}"
|
||||
) from error
|
||||
|
||||
if len(value) != 16:
|
||||
raise ValueError(
|
||||
"Could not create a Transform object: input list should be 16 floats"
|
||||
f" 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: Optional[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: Optional[str] = None
|
||||
basePoint: Optional[Point] = None
|
||||
geometry: Optional[List[Base]] = None
|
||||
|
||||
|
||||
class Instance(Base, speckle_type=OTHER + "Instance", detachable={"definition"}):
|
||||
transform: Optional[Transform] = None
|
||||
definition: Optional[Base] = None
|
||||
|
||||
|
||||
class BlockInstance(
|
||||
Instance, speckle_type=OTHER + "BlockInstance", serialize_ignore={"blockDefinition"}
|
||||
):
|
||||
@property
|
||||
@deprecated(version="2.13", reason="Use definition")
|
||||
def blockDefinition(self) -> Optional[BlockDefinition]:
|
||||
if isinstance(self.definition, BlockDefinition):
|
||||
return self.definition
|
||||
return None
|
||||
|
||||
@blockDefinition.setter
|
||||
def blockDefinition(self, value: Optional[BlockDefinition]) -> None:
|
||||
self.definition = value
|
||||
|
||||
|
||||
class RevitInstance(Instance, speckle_type=OTHER_REVIT + "RevitInstance"):
|
||||
level: Optional[Base] = None
|
||||
facingFlipped: bool
|
||||
handFlipped: bool
|
||||
parameters: Optional[Base] = None
|
||||
elementId: Optional[str]
|
||||
|
||||
|
||||
# TODO: prob move this into a built elements module, but just trialling this for now
|
||||
class RevitParameter(Base, speckle_type="Objects.BuiltElements.Revit.Parameter"):
|
||||
name: Optional[str] = None
|
||||
value: Any = None
|
||||
applicationUnitType: Optional[str] = None # eg UnitType UT_Length
|
||||
applicationUnit: Optional[str] = None # DisplayUnitType eg DUT_MILLIMITERS
|
||||
applicationInternalName: Optional[str] = (
|
||||
None # BuiltInParameterName or GUID for shared parameter
|
||||
)
|
||||
isShared: bool = False
|
||||
isReadOnly: bool = False
|
||||
isTypeParameter: bool = False
|
||||
|
||||
|
||||
class Collection(
|
||||
Base, speckle_type="Speckle.Core.Models.Collection", detachable={"elements"}
|
||||
):
|
||||
name: Optional[str] = None
|
||||
collectionType: Optional[str] = None
|
||||
elements: Optional[List[Base]] = None
|
||||
@@ -1,25 +0,0 @@
|
||||
from typing import Any, List
|
||||
|
||||
from specklepy.objects.base import Base
|
||||
|
||||
NAMESPACE = "Objects.Primitive"
|
||||
|
||||
|
||||
class Interval(Base, speckle_type=f"{NAMESPACE}.Interval"):
|
||||
start: float = 0.0
|
||||
end: float = 0.0
|
||||
|
||||
def length(self):
|
||||
return abs(self.start - self.end)
|
||||
|
||||
@classmethod
|
||||
def from_list(cls, args: List[Any]) -> "Interval":
|
||||
return cls(start=args[0], end=args[1])
|
||||
|
||||
def to_list(self) -> List[Any]:
|
||||
return [self.start, self.end]
|
||||
|
||||
|
||||
class Interval2d(Base, speckle_type=f"{NAMESPACE}.Interval2d"):
|
||||
u: Interval
|
||||
v: Interval
|
||||
@@ -1,142 +0,0 @@
|
||||
"""Builtin Speckle object kit."""
|
||||
|
||||
from specklepy.objects.structural.analysis import (
|
||||
Model,
|
||||
ModelInfo,
|
||||
ModelSettings,
|
||||
ModelUnits,
|
||||
)
|
||||
from specklepy.objects.structural.axis import Axis, AxisType
|
||||
from specklepy.objects.structural.geometry import (
|
||||
Element1D,
|
||||
Element2D,
|
||||
Element3D,
|
||||
ElementType1D,
|
||||
ElementType2D,
|
||||
ElementType3D,
|
||||
Node,
|
||||
Restraint,
|
||||
)
|
||||
from specklepy.objects.structural.loading import (
|
||||
ActionType,
|
||||
BeamLoadType,
|
||||
CombinationType,
|
||||
FaceLoadType,
|
||||
Load,
|
||||
LoadAxisType,
|
||||
LoadBeam,
|
||||
LoadCase,
|
||||
LoadCombinations,
|
||||
LoadDirection,
|
||||
LoadDirection2D,
|
||||
LoadFace,
|
||||
LoadGravity,
|
||||
LoadNode,
|
||||
LoadType,
|
||||
)
|
||||
from specklepy.objects.structural.materials import (
|
||||
Concrete,
|
||||
MaterialType,
|
||||
Steel,
|
||||
StructuralMaterial,
|
||||
Timber,
|
||||
)
|
||||
from specklepy.objects.structural.properties import (
|
||||
BaseReferencePoint,
|
||||
MemberType,
|
||||
Property,
|
||||
Property1D,
|
||||
Property2D,
|
||||
Property3D,
|
||||
PropertyDamper,
|
||||
PropertyMass,
|
||||
PropertySpring,
|
||||
PropertyType2D,
|
||||
PropertyType3D,
|
||||
PropertyTypeDamper,
|
||||
PropertyTypeSpring,
|
||||
ReferenceSurface,
|
||||
ReferenceSurfaceEnum,
|
||||
SectionProfile,
|
||||
ShapeType,
|
||||
shapeType,
|
||||
)
|
||||
from specklepy.objects.structural.results import (
|
||||
Result,
|
||||
Result1D,
|
||||
Result2D,
|
||||
Result3D,
|
||||
ResultGlobal,
|
||||
ResultNode,
|
||||
ResultSet1D,
|
||||
ResultSet2D,
|
||||
ResultSet3D,
|
||||
ResultSetAll,
|
||||
ResultSetNode,
|
||||
)
|
||||
|
||||
__all__ = [
|
||||
"Element1D",
|
||||
"Element2D",
|
||||
"Element3D",
|
||||
"ElementType1D",
|
||||
"ElementType2D",
|
||||
"ElementType3D",
|
||||
"AxisType",
|
||||
"Axis",
|
||||
"Node",
|
||||
"Restraint",
|
||||
"Load",
|
||||
"LoadType",
|
||||
"ActionType",
|
||||
"BeamLoadType",
|
||||
"FaceLoadType",
|
||||
"LoadDirection",
|
||||
"LoadDirection2D",
|
||||
"LoadAxisType",
|
||||
"CombinationType",
|
||||
"LoadBeam",
|
||||
"LoadCase",
|
||||
"LoadCombinations",
|
||||
"LoadFace",
|
||||
"LoadGravity",
|
||||
"LoadNode",
|
||||
"Model",
|
||||
"ModelInfo",
|
||||
"ModelSettings",
|
||||
"ModelUnits",
|
||||
"MaterialType",
|
||||
"Concrete",
|
||||
"StructuralMaterial",
|
||||
"Steel",
|
||||
"Timber",
|
||||
"Property",
|
||||
"Property1D",
|
||||
"Property2D",
|
||||
"Property3D",
|
||||
"PropertyDamper",
|
||||
"PropertyMass",
|
||||
"PropertySpring",
|
||||
"SectionProfile",
|
||||
"MemberType",
|
||||
"BaseReferencePoint",
|
||||
"ReferenceSurface",
|
||||
"PropertyType2D",
|
||||
"PropertyType3D",
|
||||
"ShapeType",
|
||||
"PropertyTypeSpring",
|
||||
"PropertyTypeDamper",
|
||||
"ReferenceSurfaceEnum",
|
||||
"shapeType",
|
||||
"Result",
|
||||
"Result1D",
|
||||
"ResultSet1D",
|
||||
"Result2D",
|
||||
"ResultSet2D",
|
||||
"Result3D",
|
||||
"ResultSet3D",
|
||||
"ResultGlobal",
|
||||
"ResultSetNode",
|
||||
"ResultNode",
|
||||
"ResultSetAll",
|
||||
]
|
||||
@@ -1,49 +0,0 @@
|
||||
from typing import List, Optional
|
||||
|
||||
from specklepy.objects.base import Base
|
||||
|
||||
STRUCTURAL_ANALYSIS = "Objects.Structural.Analysis."
|
||||
|
||||
|
||||
class ModelUnits(Base, speckle_type=STRUCTURAL_ANALYSIS + "ModelUnits"):
|
||||
length: Optional[str] = None
|
||||
sections: Optional[str] = None
|
||||
displacements: Optional[str] = None
|
||||
stress: Optional[str] = None
|
||||
force: Optional[str] = None
|
||||
mass: Optional[str] = None
|
||||
time: Optional[str] = None
|
||||
temperature: Optional[str] = None
|
||||
velocity: Optional[str] = None
|
||||
acceleration: Optional[str] = None
|
||||
energy: Optional[str] = None
|
||||
angle: Optional[str] = None
|
||||
strain: Optional[str] = None
|
||||
|
||||
|
||||
class ModelSettings(Base, speckle_type=STRUCTURAL_ANALYSIS + "ModelSettings"):
|
||||
modelUnits: Optional[ModelUnits] = None
|
||||
steelCode: Optional[str] = None
|
||||
concreteCode: Optional[str] = None
|
||||
coincidenceTolerance: float = 0.0
|
||||
|
||||
|
||||
class ModelInfo(Base, speckle_type=STRUCTURAL_ANALYSIS + "ModelInfo"):
|
||||
name: Optional[str] = None
|
||||
description: Optional[str] = None
|
||||
projectNumber: Optional[str] = None
|
||||
projectName: Optional[str] = None
|
||||
settings: Optional[ModelSettings] = None
|
||||
initials: Optional[str] = None
|
||||
application: Optional[str] = None
|
||||
|
||||
|
||||
class Model(Base, speckle_type=STRUCTURAL_ANALYSIS + "Model"):
|
||||
specs: Optional[ModelInfo] = None
|
||||
nodes: Optional[List] = None
|
||||
elements: Optional[List] = None
|
||||
loads: Optional[List] = None
|
||||
restraints: Optional[List] = None
|
||||
properties: Optional[List] = None
|
||||
materials: Optional[List] = None
|
||||
layerDescription: Optional[str] = None
|
||||
@@ -1,17 +0,0 @@
|
||||
from enum import Enum
|
||||
from typing import Optional
|
||||
|
||||
from specklepy.objects.base import Base
|
||||
from specklepy.objects.geometry import Plane
|
||||
|
||||
|
||||
class AxisType(int, Enum):
|
||||
Cartesian = 0
|
||||
Cylindrical = 1
|
||||
Spherical = 2
|
||||
|
||||
|
||||
class Axis(Base, speckle_type="Objects.Structural.Geometry.Axis"):
|
||||
name: Optional[str] = None
|
||||
axisType: Optional[AxisType] = None
|
||||
plane: Optional[Plane] = None
|
||||
@@ -1,110 +0,0 @@
|
||||
from enum import Enum
|
||||
from typing import List, Optional
|
||||
|
||||
from specklepy.objects.base import Base
|
||||
from specklepy.objects.geometry import Line, Mesh, Plane, Point, Vector
|
||||
from specklepy.objects.structural.axis import Axis
|
||||
from specklepy.objects.structural.properties import (
|
||||
Property1D,
|
||||
Property2D,
|
||||
Property3D,
|
||||
PropertyDamper,
|
||||
PropertyMass,
|
||||
PropertySpring,
|
||||
)
|
||||
|
||||
STRUCTURAL_GEOMETRY = "Objects.Structural.Geometry"
|
||||
|
||||
|
||||
class ElementType1D(int, Enum):
|
||||
Beam = 0
|
||||
Brace = 1
|
||||
Bar = 2
|
||||
Column = 3
|
||||
Rod = 4
|
||||
Spring = 5
|
||||
Tie = 6
|
||||
Strut = 7
|
||||
Link = 8
|
||||
Damper = 9
|
||||
Cable = 10
|
||||
Spacer = 11
|
||||
Other = 12
|
||||
Null = 13
|
||||
|
||||
|
||||
class ElementType2D(int, Enum):
|
||||
Quad4 = 0
|
||||
Quad8 = 1
|
||||
Triangle3 = 2
|
||||
Triangle6 = 3
|
||||
|
||||
|
||||
class ElementType3D(int, Enum):
|
||||
Brick8 = 0
|
||||
Wedge6 = 1
|
||||
Pyramid5 = 2
|
||||
Tetra4 = 3
|
||||
|
||||
|
||||
class Restraint(Base, speckle_type=STRUCTURAL_GEOMETRY + ".Restraint"):
|
||||
code: Optional[str] = None
|
||||
stiffnessX: float = 0.0
|
||||
stiffnessY: float = 0.0
|
||||
stiffnessZ: float = 0.0
|
||||
stiffnessXX: float = 0.0
|
||||
stiffnessYY: float = 0.0
|
||||
stiffnessZZ: float = 0.0
|
||||
|
||||
|
||||
class Node(Base, speckle_type=STRUCTURAL_GEOMETRY + ".Node"):
|
||||
name: Optional[str] = None
|
||||
basePoint: Optional[Point] = None
|
||||
constraintAxis: Optional[Axis] = None
|
||||
restraint: Optional[Restraint] = None
|
||||
springProperty: Optional[PropertySpring] = None
|
||||
massProperty: Optional[PropertyMass] = None
|
||||
damperProperty: Optional[PropertyDamper] = None
|
||||
|
||||
|
||||
class Element1D(Base, speckle_type=STRUCTURAL_GEOMETRY + ".Element1D"):
|
||||
name: Optional[str] = None
|
||||
baseLine: Optional[Line] = None
|
||||
property: Optional[Property1D] = None
|
||||
type: Optional[ElementType1D] = None
|
||||
end1Releases: Optional[Restraint] = None
|
||||
end2Releases: Optional[Restraint] = None
|
||||
end1Offset: Optional[Vector] = None
|
||||
end2Offset: Optional[Vector] = None
|
||||
orientationNode: Optional[Node] = None
|
||||
orinetationAngle: float = 0.0
|
||||
localAxis: Optional[Plane] = None
|
||||
parent: Optional[Base] = None
|
||||
end1Node: Optional[Node] = None
|
||||
end2Node: Optional[Node] = None
|
||||
topology: Optional[List] = None
|
||||
displayMesh: Optional[Mesh] = None
|
||||
|
||||
|
||||
class Element2D(Base, speckle_type=STRUCTURAL_GEOMETRY + ".Element2D"):
|
||||
name: Optional[str] = None
|
||||
property: Optional[Property2D] = None
|
||||
type: Optional[ElementType2D] = None
|
||||
offset: float = 0.0
|
||||
orientationAngle: float = 0.0
|
||||
parent: Optional[Base] = None
|
||||
topology: Optional[List] = None
|
||||
displayMesh: Optional[Mesh] = None
|
||||
|
||||
|
||||
class Element3D(Base, speckle_type=STRUCTURAL_GEOMETRY + ".Element3D"):
|
||||
name: Optional[str] = None
|
||||
baseMesh: Optional[Mesh] = None
|
||||
property: Optional[Property3D] = None
|
||||
type: Optional[ElementType3D] = None
|
||||
orientationAngle: float = 0.0
|
||||
parent: Optional[Base] = None
|
||||
topology: List
|
||||
|
||||
|
||||
# class Storey needs ependency on built elements first
|
||||
@@ -1,137 +0,0 @@
|
||||
from enum import Enum
|
||||
from typing import List, Optional
|
||||
|
||||
from specklepy.objects.base import Base
|
||||
from specklepy.objects.geometry import Vector
|
||||
from specklepy.objects.structural.axis import Axis
|
||||
|
||||
STRUCTURAL_LOADING = "Objects.Structural.Loading."
|
||||
|
||||
|
||||
class LoadType(int, Enum):
|
||||
none = 0
|
||||
Dead = 1
|
||||
SuperDead = 2
|
||||
Soil = 3
|
||||
Live = 4
|
||||
LiveRoof = 5
|
||||
ReducibleLive = 6
|
||||
Wind = 7
|
||||
Snow = 8
|
||||
Rain = 9
|
||||
Thermal = 10
|
||||
Notional = 11
|
||||
Prestress = 12
|
||||
Equivalent = 13
|
||||
Accidental = 14
|
||||
SeismicRSA = 15
|
||||
SeismicAccTorsion = 16
|
||||
SeismicStatic = 17
|
||||
Other = 18
|
||||
|
||||
|
||||
class ActionType(int, Enum):
|
||||
none = 0
|
||||
Permanent = 1
|
||||
Variable = 2
|
||||
Accidental = 3
|
||||
|
||||
|
||||
class BeamLoadType(int, Enum):
|
||||
Point = 0
|
||||
Uniform = 1
|
||||
Linear = 2
|
||||
Patch = 3
|
||||
TriLinear = 4
|
||||
|
||||
|
||||
class FaceLoadType(int, Enum):
|
||||
Constant = 0
|
||||
Variable = 1
|
||||
Point = 2
|
||||
|
||||
|
||||
class LoadDirection2D(int, Enum):
|
||||
X = 0
|
||||
Y = 1
|
||||
Z = 2
|
||||
|
||||
|
||||
class LoadDirection(int, Enum):
|
||||
X = 0
|
||||
Y = 1
|
||||
Z = 2
|
||||
XX = 3
|
||||
YY = 4
|
||||
ZZ = 5
|
||||
|
||||
|
||||
class LoadAxisType(int, Enum):
|
||||
Global = 0
|
||||
Local = 1 # local element axes
|
||||
DeformedLocal = (
|
||||
2 # element local axis that is embedded in the element as it deforms
|
||||
)
|
||||
|
||||
|
||||
class CombinationType(int, Enum):
|
||||
LinearAdd = 0
|
||||
Envelope = 1
|
||||
AbsoluteAdd = 2
|
||||
SRSS = 3
|
||||
RangeAdd = 4
|
||||
|
||||
|
||||
class LoadCase(Base, speckle_type=STRUCTURAL_LOADING + "LoadCase"):
|
||||
name: Optional[str] = None
|
||||
loadType: Optional[LoadType] = None
|
||||
group: Optional[str] = None
|
||||
actionType: Optional[ActionType] = None
|
||||
description: Optional[str] = None
|
||||
|
||||
|
||||
class Load(Base, speckle_type=STRUCTURAL_LOADING + "Load"):
|
||||
name: Optional[str] = None
|
||||
loadCase: Optional[LoadCase] = None
|
||||
|
||||
|
||||
class LoadBeam(Load, speckle_type=STRUCTURAL_LOADING + "LoadBeam"):
|
||||
elements: Optional[List] = None
|
||||
loadType: Optional[BeamLoadType] = None
|
||||
direction: Optional[LoadDirection] = None
|
||||
loadAxis: Optional[Axis] = None
|
||||
loadAxisType: Optional[LoadAxisType] = None
|
||||
isProjected: Optional[bool] = None
|
||||
values: Optional[List] = None
|
||||
positions: Optional[List] = None
|
||||
|
||||
|
||||
class LoadCombinations(Base, speckle_type=STRUCTURAL_LOADING + "LoadCombination"):
|
||||
name: Optional[str] = None
|
||||
loadCases: List
|
||||
loadFactors: List
|
||||
combinationType: CombinationType
|
||||
|
||||
|
||||
class LoadFace(Load, speckle_type=STRUCTURAL_LOADING + "LoadFace"):
|
||||
elements: Optional[List] = None
|
||||
loadType: Optional[FaceLoadType] = None
|
||||
direction: Optional[LoadDirection2D] = None
|
||||
loadAxis: Optional[Axis] = None
|
||||
loadAxisType: Optional[LoadAxisType] = None
|
||||
isProjected: Optional[bool] = None
|
||||
values: Optional[List] = None
|
||||
positions: Optional[List] = None
|
||||
|
||||
|
||||
class LoadGravity(Load, speckle_type=STRUCTURAL_LOADING + "LoadGravity"):
|
||||
elements: Optional[List] = None
|
||||
nodes: Optional[List] = None
|
||||
gravityFactors: Optional[Vector] = None
|
||||
|
||||
|
||||
class LoadNode(Load, speckle_type=STRUCTURAL_LOADING + "LoadNode"):
|
||||
nodes: Optional[List] = None
|
||||
loadAxis: Optional[Axis] = None
|
||||
direction: Optional[LoadDirection] = None
|
||||
value: float = 0.0
|
||||
@@ -1,61 +0,0 @@
|
||||
from enum import Enum
|
||||
from typing import Optional
|
||||
|
||||
from specklepy.objects.base import Base
|
||||
|
||||
STRUCTURAL_MATERIALS = "Objects.Structural.Materials"
|
||||
|
||||
|
||||
class MaterialType(int, Enum):
|
||||
Concrete = 0
|
||||
Steel = 1
|
||||
Timber = 2
|
||||
Aluminium = 3
|
||||
Masonry = 4
|
||||
FRP = 5
|
||||
Glass = 6
|
||||
Fabric = 7
|
||||
Rebar = 8
|
||||
Tendon = 9
|
||||
ColdFormed = 10
|
||||
Other = 11
|
||||
|
||||
|
||||
class StructuralMaterial(
|
||||
Base, speckle_type=STRUCTURAL_MATERIALS + ".StructuralMaterial"
|
||||
):
|
||||
name: Optional[str] = None
|
||||
grade: Optional[str] = None
|
||||
materialType: Optional[MaterialType] = None
|
||||
designCode: Optional[str] = None
|
||||
codeYear: Optional[str] = None
|
||||
strength: float = 0.0
|
||||
elasticModulus: float = 0.0
|
||||
poissonsRatio: float = 0.0
|
||||
shearModulus: float = 0.0
|
||||
density: float = 0.0
|
||||
thermalExpansivity: float = 0.0
|
||||
dampingRatio: float = 0.0
|
||||
cost: float = 0.0
|
||||
materialSafetyFactor: float = 0.0
|
||||
|
||||
|
||||
class Concrete(StructuralMaterial):
|
||||
compressiveStrength: float = 0.0
|
||||
tensileStrength: float = 0.0
|
||||
flexuralStrength: float = 0.0
|
||||
maxCompressiveStrain: float = 0.0
|
||||
maxTensileStrain: float = 0.0
|
||||
maxAggregateSize: float = 0.0
|
||||
lightweight: Optional[bool] = None
|
||||
|
||||
|
||||
class Steel(StructuralMaterial, speckle_type=STRUCTURAL_MATERIALS + ".Steel"):
|
||||
yieldStrength: float = 0.0
|
||||
ultimateStrength: float = 0.0
|
||||
maxStrain: float = 0.0
|
||||
strainHardeningModulus: float = 0.0
|
||||
|
||||
|
||||
class Timber(StructuralMaterial, speckle_type=STRUCTURAL_MATERIALS + ".Timber"):
|
||||
species: Optional[str] = None
|
||||
@@ -1,212 +0,0 @@
|
||||
from enum import Enum
|
||||
from typing import Optional
|
||||
|
||||
from specklepy.objects.base import Base
|
||||
from specklepy.objects.structural.axis import Axis
|
||||
from specklepy.objects.structural.materials import StructuralMaterial
|
||||
|
||||
STRUCTURAL_PROPERTY = "Objects.Structural.Properties"
|
||||
|
||||
|
||||
class MemberType(int, Enum):
|
||||
Beam = 0
|
||||
Column = 1
|
||||
Generic1D = 2
|
||||
Slab = 3
|
||||
Wall = 4
|
||||
Generic2D = 5
|
||||
VoidCutter1D = 6
|
||||
VoidCutter2D = 7
|
||||
|
||||
|
||||
class BaseReferencePoint(int, Enum):
|
||||
Centroid = 0
|
||||
TopLeft = 1
|
||||
TopCentre = 2
|
||||
TopRight = 3
|
||||
MidLeft = 4
|
||||
MidRight = 5
|
||||
BotLeft = 6
|
||||
BotCentre = 7
|
||||
BotRight = 8
|
||||
|
||||
|
||||
class ReferenceSurface(int, Enum):
|
||||
Top = 0
|
||||
Middle = 1
|
||||
Bottom = 2
|
||||
|
||||
|
||||
class PropertyType2D(int, Enum):
|
||||
Stress = 0
|
||||
Fabric = 1
|
||||
Plate = 2
|
||||
Shell = 3
|
||||
Curved = 4
|
||||
Wall = 5
|
||||
Strain = 6
|
||||
Axi = 7
|
||||
Load = 8
|
||||
|
||||
|
||||
class PropertyType3D(int, Enum):
|
||||
Solid = 0
|
||||
Infinite = 1
|
||||
|
||||
|
||||
class ShapeType(int, Enum):
|
||||
Rectangular = 0
|
||||
Circular = 1
|
||||
I = 2 # noqa: E741
|
||||
Tee = 3
|
||||
Angle = 4
|
||||
Channel = 5
|
||||
Perimeter = 6
|
||||
Box = 7
|
||||
Catalogue = 8
|
||||
Explicit = 9
|
||||
Undefined = 10
|
||||
|
||||
|
||||
class PropertyTypeSpring(int, Enum):
|
||||
Axial = 0
|
||||
Torsional = 1
|
||||
General = 2
|
||||
Matrix = 3
|
||||
TensionOnly = 4
|
||||
CompressionOnly = 5
|
||||
Connector = 6
|
||||
LockUp = 7
|
||||
Gap = 8
|
||||
Friction = 9
|
||||
|
||||
|
||||
class PropertyTypeDamper(int, Enum):
|
||||
Axial = 0
|
||||
Torsional = 1
|
||||
General = 2
|
||||
|
||||
|
||||
class Property(Base, speckle_type=STRUCTURAL_PROPERTY):
|
||||
name: Optional[str] = None
|
||||
|
||||
|
||||
class SectionProfile(
|
||||
Base, speckle_type=STRUCTURAL_PROPERTY + ".Profiles.SectionProfile"
|
||||
):
|
||||
name: Optional[str] = None
|
||||
shapeType: Optional[ShapeType] = None
|
||||
area: float = 0.0
|
||||
Iyy: float = 0.0
|
||||
Izz: float = 0.0
|
||||
J: float = 0.0
|
||||
Ky: float = 0.0
|
||||
weight: float = 0.0
|
||||
|
||||
|
||||
class Property1D(Property, speckle_type=STRUCTURAL_PROPERTY + ".Property1D"):
|
||||
memberType: Optional[MemberType] = None
|
||||
material: Optional[StructuralMaterial] = None
|
||||
profile: Optional[SectionProfile] = None
|
||||
referencePoint: Optional[BaseReferencePoint] = None
|
||||
offsetY: float = 0.0
|
||||
offsetZ: float = 0.0
|
||||
|
||||
|
||||
class Property2D(Property, speckle_type=STRUCTURAL_PROPERTY + ".Property2D"):
|
||||
type: Optional[PropertyType2D] = None
|
||||
thickness: float = 0.0
|
||||
material: Optional[StructuralMaterial] = None
|
||||
orientationAxis: Optional[Axis] = None
|
||||
refSurface: Optional[ReferenceSurface] = None
|
||||
zOffset: float = 0.0
|
||||
modifierInPlane: float = 0.0
|
||||
modifierBending: float = 0.0
|
||||
modifierShear: float = 0.0
|
||||
modifierVolume: float = 0.0
|
||||
|
||||
|
||||
class Property3D(Property, speckle_type=STRUCTURAL_PROPERTY + ".Property3D"):
|
||||
type: Optional[PropertyType3D] = None
|
||||
material: Optional[StructuralMaterial] = None
|
||||
orientationAxis: Optional[Axis] = None
|
||||
|
||||
|
||||
class PropertyDamper(Property, speckle_type=STRUCTURAL_PROPERTY + ".PropertyDamper"):
|
||||
damperType: Optional[PropertyTypeDamper] = None
|
||||
dampingX: float = 0.0
|
||||
dampingY: float = 0.0
|
||||
dampingZ: float = 0.0
|
||||
dampingXX: float = 0.0
|
||||
dampingYY: float = 0.0
|
||||
dampingZZ: float = 0.0
|
||||
|
||||
|
||||
class PropertyMass(Property, speckle_type=STRUCTURAL_PROPERTY + ".PropertyMass"):
|
||||
mass: float = 0.0
|
||||
inertiaXX: float = 0.0
|
||||
inertiaYY: float = 0.0
|
||||
inertiaZZ: float = 0.0
|
||||
inertiaXY: float = 0.0
|
||||
inertiaYZ: float = 0.0
|
||||
inertiaZX: float = 0.0
|
||||
massModified: Optional[bool] = None
|
||||
massModifierX: float = 0.0
|
||||
massModifierY: float = 0.0
|
||||
massModifierZ: float = 0.0
|
||||
|
||||
|
||||
class PropertySpring(Property, speckle_type=STRUCTURAL_PROPERTY + ".PropertySpring"):
|
||||
springType: Optional[PropertyTypeSpring] = None
|
||||
springCurveX: float = 0.0
|
||||
stiffnessX: float = 0.0
|
||||
springCurveY: float = 0.0
|
||||
stiffnessY: float = 0.0
|
||||
springCurveZ: float = 0.0
|
||||
stiffnessZ: float = 0.0
|
||||
springCurveXX: float = 0.0
|
||||
stiffnessXX: float = 0.0
|
||||
springCurveYY: float = 0.0
|
||||
stiffnessYY: float = 0.0
|
||||
springCurveZZ: float = 0.0
|
||||
stiffnessZZ: float = 0.0
|
||||
dampingRatio: float = 0.0
|
||||
dampingX: float = 0.0
|
||||
dampingY: float = 0.0
|
||||
dampingZ: float = 0.0
|
||||
dampingXX: float = 0.0
|
||||
dampingYY: float = 0.0
|
||||
dampingZZ: float = 0.0
|
||||
matrix: float = 0.0
|
||||
postiveLockup: float = 0.0
|
||||
frictionCoefficient: float = 0.0
|
||||
|
||||
|
||||
class ReferenceSurfaceEnum(int, Enum):
|
||||
Concrete = 0
|
||||
Steel = 1
|
||||
Timber = 2
|
||||
Aluminium = 3
|
||||
Masonry = 4
|
||||
FRP = 5
|
||||
Glass = 6
|
||||
Fabric = 7
|
||||
Rebar = 8
|
||||
Tendon = 9
|
||||
ColdFormed = 10
|
||||
Other = 11
|
||||
|
||||
|
||||
class shapeType(int, Enum):
|
||||
Concrete = 0
|
||||
Steel = 1
|
||||
Timber = 2
|
||||
Aluminium = 3
|
||||
Masonry = 4
|
||||
FRP = 5
|
||||
Glass = 6
|
||||
Fabric = 7
|
||||
Rebar = 8
|
||||
Tendon = 9
|
||||
ColdFormed = 10
|
||||
Other = 11
|
||||
@@ -1,172 +0,0 @@
|
||||
from typing import List, Optional
|
||||
|
||||
from specklepy.objects.base import Base
|
||||
from specklepy.objects.structural.analysis import Model
|
||||
from specklepy.objects.structural.geometry import Element1D, Element2D, Element3D, Node
|
||||
|
||||
STRUCTURAL_RESULTS = "Objects.Structural.Results."
|
||||
|
||||
|
||||
class Result(Base, speckle_type=STRUCTURAL_RESULTS + "Result"):
|
||||
resultCase: Optional[Base] = None
|
||||
permutation: Optional[str] = None
|
||||
description: Optional[str] = None
|
||||
|
||||
|
||||
class ResultSet1D(Result, speckle_type=STRUCTURAL_RESULTS + "ResultSet1D"):
|
||||
results1D: List
|
||||
|
||||
|
||||
class Result1D(Result, speckle_type=STRUCTURAL_RESULTS + "Result1D"):
|
||||
element: Optional[Element1D] = None
|
||||
position: Optional[float] = None
|
||||
dispX: Optional[float] = None
|
||||
dispY: Optional[float] = None
|
||||
dispZ: Optional[float] = None
|
||||
rotXX: Optional[float] = None
|
||||
rotYY: Optional[float] = None
|
||||
rotZZ: Optional[float] = None
|
||||
forceX: Optional[float] = None
|
||||
forceY: Optional[float] = None
|
||||
forceZ: Optional[float] = None
|
||||
momentXX: Optional[float] = None
|
||||
momentYY: Optional[float] = None
|
||||
momentZZ: Optional[float] = None
|
||||
axialStress: Optional[float] = None
|
||||
shearStressY: Optional[float] = None
|
||||
shearStressZ: Optional[float] = None
|
||||
bendingStressYPos: Optional[float] = None
|
||||
bendingStressYNeg: Optional[float] = None
|
||||
bendingStressZPos: Optional[float] = None
|
||||
bendingStressZNeg: Optional[float] = None
|
||||
combinedStressMax: Optional[float] = None
|
||||
combinedStressMin: Optional[float] = None
|
||||
|
||||
|
||||
class ResultSet2D(Result, speckle_type=STRUCTURAL_RESULTS + "ResultSet2D"):
|
||||
results2D: List
|
||||
|
||||
|
||||
class Result2D(Result, speckle_type=STRUCTURAL_RESULTS + "Result2D"):
|
||||
element: Optional[Element2D] = None
|
||||
position: List
|
||||
dispX: Optional[float] = None
|
||||
dispY: Optional[float] = None
|
||||
dispZ: Optional[float] = None
|
||||
forceXX: Optional[float] = None
|
||||
forceYY: Optional[float] = None
|
||||
forceXY: Optional[float] = None
|
||||
momentXX: Optional[float] = None
|
||||
momentYY: Optional[float] = None
|
||||
momentXY: Optional[float] = None
|
||||
shearX: Optional[float] = None
|
||||
shearY: Optional[float] = None
|
||||
stressTopXX: Optional[float] = None
|
||||
stressTopYY: Optional[float] = None
|
||||
stressTopZZ: Optional[float] = None
|
||||
stressTopXY: Optional[float] = None
|
||||
stressTopYZ: Optional[float] = None
|
||||
stressTopZX: Optional[float] = None
|
||||
stressMidXX: Optional[float] = None
|
||||
stressMidYY: Optional[float] = None
|
||||
stressMidZZ: Optional[float] = None
|
||||
stressMidXY: Optional[float] = None
|
||||
stressMidYZ: Optional[float] = None
|
||||
stressMidZX: Optional[float] = None
|
||||
stressBotXX: Optional[float] = None
|
||||
stressBotYY: Optional[float] = None
|
||||
stressBotZZ: Optional[float] = None
|
||||
stressBotXY: Optional[float] = None
|
||||
stressBotYZ: Optional[float] = None
|
||||
stressBotZX: Optional[float] = None
|
||||
|
||||
|
||||
class ResultSet3D(Result, speckle_type=STRUCTURAL_RESULTS + "ResultSet3D"):
|
||||
results3D: List
|
||||
|
||||
|
||||
class Result3D(Result, speckle_type=STRUCTURAL_RESULTS + "Result3D"):
|
||||
element: Optional[Element3D] = None
|
||||
position: List
|
||||
dispX: Optional[float] = None
|
||||
dispY: Optional[float] = None
|
||||
dispZ: Optional[float] = None
|
||||
stressXX: Optional[float] = None
|
||||
stressYY: Optional[float] = None
|
||||
stressZZ: Optional[float] = None
|
||||
stressXY: Optional[float] = None
|
||||
stressYZ: Optional[float] = None
|
||||
stressZX: Optional[float] = None
|
||||
|
||||
|
||||
class ResultGlobal(Result, speckle_type=STRUCTURAL_RESULTS + "ResultGlobal"):
|
||||
model: Optional[Model] = None
|
||||
loadX: Optional[float] = None
|
||||
loadY: Optional[float] = None
|
||||
loadZ: Optional[float] = None
|
||||
loadXX: Optional[float] = None
|
||||
loadYY: Optional[float] = None
|
||||
loadZZ: Optional[float] = None
|
||||
reactionX: Optional[float] = None
|
||||
reactionY: Optional[float] = None
|
||||
reactionZ: Optional[float] = None
|
||||
reactionXX: Optional[float] = None
|
||||
reactionYY: Optional[float] = None
|
||||
reactionZZ: Optional[float] = None
|
||||
mode: Optional[float] = None
|
||||
frequency: Optional[float] = None
|
||||
loadFactor: Optional[float] = None
|
||||
modalStiffness: Optional[float] = None
|
||||
modalGeoStiffness: Optional[float] = None
|
||||
effMassX: Optional[float] = None
|
||||
effMassY: Optional[float] = None
|
||||
effMassZ: Optional[float] = None
|
||||
effMassXX: Optional[float] = None
|
||||
effMassYY: Optional[float] = None
|
||||
effMassZZ: Optional[float] = None
|
||||
|
||||
|
||||
class ResultSetNode(Result, speckle_type=STRUCTURAL_RESULTS + "ResultSetNode"):
|
||||
resultsNode: List
|
||||
|
||||
|
||||
class ResultNode(Result, speckle_type=STRUCTURAL_RESULTS + " ResultNode"):
|
||||
node: Optional[Node] = None
|
||||
dispX: Optional[float] = None
|
||||
dispY: Optional[float] = None
|
||||
dispZ: Optional[float] = None
|
||||
rotXX: Optional[float] = None
|
||||
rotYY: Optional[float] = None
|
||||
rotZZ: Optional[float] = None
|
||||
reactionX: Optional[float] = None
|
||||
reactionY: Optional[float] = None
|
||||
reactionZ: Optional[float] = None
|
||||
reactionXX: Optional[float] = None
|
||||
reactionYY: Optional[float] = None
|
||||
reactionZZ: Optional[float] = None
|
||||
constraintX: Optional[float] = None
|
||||
constraintY: Optional[float] = None
|
||||
constraintZ: Optional[float] = None
|
||||
constraintXX: Optional[float] = None
|
||||
constraintYY: Optional[float] = None
|
||||
constraintZZ: Optional[float] = None
|
||||
velX: Optional[float] = None
|
||||
velY: Optional[float] = None
|
||||
velZ: Optional[float] = None
|
||||
velXX: Optional[float] = None
|
||||
velYY: Optional[float] = None
|
||||
velZZ: Optional[float] = None
|
||||
accX: Optional[float] = None
|
||||
accY: Optional[float] = None
|
||||
accZ: Optional[float] = None
|
||||
accXX: Optional[float] = None
|
||||
accYY: Optional[float] = None
|
||||
accZZ: Optional[float] = None
|
||||
|
||||
|
||||
class ResultSetAll(Base, speckle_type=None):
|
||||
resultSet1D: Optional[ResultSet1D] = None
|
||||
resultSet2D: Optional[ResultSet2D] = None
|
||||
resultSet3D: Optional[ResultSet3D] = None
|
||||
resultsGlobal: Optional[ResultGlobal] = None
|
||||
resultsNode: Optional[ResultSetNode] = None
|
||||
@@ -1,124 +0,0 @@
|
||||
from enum import Enum
|
||||
from typing import Union
|
||||
|
||||
from specklepy.logging.exceptions import SpeckleException, SpeckleInvalidUnitException
|
||||
|
||||
__all__ = [
|
||||
"Units",
|
||||
"get_encoding_from_units",
|
||||
"get_units_from_encoding",
|
||||
"get_units_from_string",
|
||||
]
|
||||
|
||||
|
||||
class Units(Enum):
|
||||
mm = "mm"
|
||||
cm = "cm"
|
||||
m = "m"
|
||||
km = "km"
|
||||
inches = "in"
|
||||
feet = "ft"
|
||||
yards = "yd"
|
||||
miles = "mi"
|
||||
none = "none"
|
||||
|
||||
|
||||
UNITS_STRINGS = {
|
||||
Units.mm: ["mm", "mil", "millimeters", "millimetres"],
|
||||
Units.cm: ["cm", "centimetre", "centimeter", "centimetres", "centimeters"],
|
||||
Units.m: ["m", "meter", "meters", "metre", "metres"],
|
||||
Units.km: ["km", "kilometer", "kilometre", "kilometers", "kilometres"],
|
||||
Units.inches: ["in", "inch", "inches"],
|
||||
Units.feet: ["ft", "foot", "feet"],
|
||||
Units.yards: ["yd", "yard", "yards"],
|
||||
Units.miles: ["mi", "mile", "miles"],
|
||||
Units.none: ["none", "null"],
|
||||
}
|
||||
|
||||
|
||||
UNITS_ENCODINGS = {
|
||||
Units.none: 0,
|
||||
None: 0,
|
||||
Units.mm: 1,
|
||||
Units.cm: 2,
|
||||
Units.m: 3,
|
||||
Units.km: 4,
|
||||
Units.inches: 5,
|
||||
Units.feet: 6,
|
||||
Units.yards: 7,
|
||||
Units.miles: 8,
|
||||
}
|
||||
|
||||
|
||||
UNIT_SCALE = {
|
||||
Units.none: 1,
|
||||
Units.mm: 0.001,
|
||||
Units.cm: 0.01,
|
||||
Units.m: 1.0,
|
||||
Units.km: 1000.0,
|
||||
Units.inches: 0.0254,
|
||||
Units.feet: 0.3048,
|
||||
Units.yards: 0.9144,
|
||||
Units.miles: 1609.340,
|
||||
}
|
||||
"""Unit scaling factor to meters"""
|
||||
|
||||
|
||||
def get_units_from_string(unit: str) -> Units:
|
||||
if not isinstance(unit, str):
|
||||
raise SpeckleInvalidUnitException(unit)
|
||||
unit = str.lower(unit)
|
||||
for name, alternates in UNITS_STRINGS.items():
|
||||
if unit in alternates:
|
||||
return name
|
||||
raise SpeckleInvalidUnitException(unit)
|
||||
|
||||
|
||||
def get_units_from_encoding(unit: int) -> Units:
|
||||
for name, encoding in UNITS_ENCODINGS.items():
|
||||
if unit == encoding:
|
||||
return name or Units.none
|
||||
|
||||
raise SpeckleException(
|
||||
message=(
|
||||
f"Could not understand what unit {unit} is referring to."
|
||||
f"Please enter a valid unit encoding (eg {UNITS_ENCODINGS})."
|
||||
)
|
||||
)
|
||||
|
||||
|
||||
def get_encoding_from_units(unit: Union[Units, str, None]):
|
||||
maybe_sanitized_unit = unit
|
||||
if isinstance(unit, str):
|
||||
for unit_enum, aliases in UNITS_STRINGS.items():
|
||||
if unit in aliases:
|
||||
maybe_sanitized_unit = unit_enum
|
||||
try:
|
||||
return UNITS_ENCODINGS[maybe_sanitized_unit]
|
||||
except KeyError as e:
|
||||
raise SpeckleException(
|
||||
message=(
|
||||
f"No encoding exists for unit {maybe_sanitized_unit}."
|
||||
f"Please enter a valid unit to encode (eg {UNITS_ENCODINGS})."
|
||||
)
|
||||
) from e
|
||||
|
||||
|
||||
def get_scale_factor_from_string(fromUnits: str, toUnits: str) -> float:
|
||||
"""Returns a scalar to convert distance values from one unit system to another"""
|
||||
return get_scale_factor(
|
||||
get_units_from_string(fromUnits), get_units_from_string(toUnits)
|
||||
)
|
||||
|
||||
|
||||
def get_scale_factor(fromUnits: Units, toUnits: Units) -> float:
|
||||
"""Returns a scalar to convert distance values from one unit system to another"""
|
||||
return get_scale_factor_to_meters(fromUnits) / get_scale_factor_to_meters(toUnits)
|
||||
|
||||
|
||||
def get_scale_factor_to_meters(fromUnits: Units) -> float:
|
||||
"""Returns a scalar to convert distance values from one unit system to meters"""
|
||||
if fromUnits not in UNIT_SCALE:
|
||||
raise ValueError(f"Invalid units provided: {fromUnits}")
|
||||
|
||||
return UNIT_SCALE[fromUnits]
|
||||
@@ -1,47 +0,0 @@
|
||||
import pytest
|
||||
|
||||
from specklepy.api.models import Stream
|
||||
from specklepy.objects import Base
|
||||
from specklepy.objects.encoding import ObjectArray
|
||||
from specklepy.serialization.base_object_serializer import BaseObjectSerializer
|
||||
from specklepy.transports.sqlite import SQLiteTransport
|
||||
|
||||
|
||||
class TestObject:
|
||||
@pytest.fixture(scope="module")
|
||||
def stream(self, client):
|
||||
stream = Stream(
|
||||
name="a sample stream for testing",
|
||||
description="a stream created for testing",
|
||||
isPublic=True,
|
||||
)
|
||||
stream.id = client.stream.create(
|
||||
stream.name, stream.description, stream.isPublic
|
||||
)
|
||||
return stream
|
||||
|
||||
def test_object_create(self, client, stream, base):
|
||||
transport = SQLiteTransport()
|
||||
s = BaseObjectSerializer(write_transports=[transport], read_transport=transport)
|
||||
_, base_dict = s.traverse_base(base)
|
||||
obj_id = client.object.create(stream_id=stream.id, objects=[base_dict])[0]
|
||||
|
||||
assert isinstance(obj_id, str)
|
||||
assert base_dict["@detach"]["speckle_type"] == "reference"
|
||||
assert obj_id == base.get_id(True)
|
||||
|
||||
def test_object_get(self, client, stream, base):
|
||||
fetched_base = client.object.get(
|
||||
stream_id=stream.id, object_id=base.get_id(True)
|
||||
)
|
||||
|
||||
assert isinstance(fetched_base, Base)
|
||||
assert fetched_base.name == base.name
|
||||
assert isinstance(fetched_base.vertices, list)
|
||||
# assert fetched_base["@detach"]["speckle_type"] == "reference"
|
||||
|
||||
def test_object_array_decoder(self):
|
||||
array = ObjectArray()
|
||||
array.data = [5, 1, 1, 1, 1, 1, 4, 1, 1, 1, 1, 3, 1, 1, 1, 2, 1, 1, 1, 1]
|
||||
|
||||
assert array.decode(decoder=sum) == [5, 4, 3, 2, 1]
|
||||
@@ -12,7 +12,7 @@ from specklepy.core.api.inputs.version_inputs import CreateVersionInput
|
||||
from specklepy.core.api.models import Stream, Version
|
||||
from specklepy.logging import metrics
|
||||
from specklepy.objects.base import Base
|
||||
from specklepy.objects.fakemesh import FakeDirection, FakeMesh
|
||||
from .fakemesh import FakeMesh, FakeDirection
|
||||
from specklepy.objects.geometry import Point
|
||||
from specklepy.transports.server.server import ServerTransport
|
||||
|
||||
@@ -44,7 +44,8 @@ def seed_user(host: str) -> Dict[str, str]:
|
||||
if not r.ok:
|
||||
raise Exception(f"Cannot seed user: {r.reason}")
|
||||
redirect_url = urlparse(r.headers.get("location"))
|
||||
access_code = parse_qs(redirect_url.query)["access_code"][0] # type: ignore
|
||||
access_code = parse_qs(redirect_url.query)[
|
||||
"access_code"][0] # type: ignore
|
||||
|
||||
r_tokens = requests.post(
|
||||
url=f"http://{host}/auth/token",
|
||||
@@ -113,7 +114,8 @@ def sample_stream(client: SpeckleClient) -> Stream:
|
||||
description="a stream created for testing",
|
||||
isPublic=True,
|
||||
)
|
||||
stream.id = client.stream.create(stream.name, stream.description, stream.isPublic)
|
||||
stream.id = client.stream.create(
|
||||
stream.name, stream.description, stream.isPublic)
|
||||
return stream
|
||||
|
||||
|
||||
|
||||
@@ -3,7 +3,7 @@ from typing import List, Optional
|
||||
|
||||
from specklepy.objects.geometry import Point
|
||||
|
||||
from .base import Base
|
||||
from specklepy.objects.base import Base
|
||||
|
||||
CHUNKABLE_PROPS = {
|
||||
"vertices": 100,
|
||||
@@ -3,8 +3,8 @@ import json
|
||||
import pytest
|
||||
|
||||
from specklepy.api import operations
|
||||
from specklepy.objects import Base
|
||||
from specklepy.objects.fakemesh import FakeMesh
|
||||
from specklepy.objects.base import Base
|
||||
from .fakemesh import FakeMesh
|
||||
from specklepy.objects.geometry import Point
|
||||
from specklepy.transports.memory import MemoryTransport
|
||||
from specklepy.transports.server import ServerTransport
|
||||
|
||||
@@ -6,8 +6,8 @@ import pytest
|
||||
|
||||
from specklepy.api import operations
|
||||
from specklepy.logging.exceptions import SpeckleException, SpeckleInvalidUnitException
|
||||
from specklepy.objects_v2.base import Base
|
||||
from specklepy.objects_v2.units import Units
|
||||
from specklepy.objects.base import Base
|
||||
from specklepy.objects.models.units import Units
|
||||
|
||||
|
||||
@pytest.mark.parametrize(
|
||||
|
||||
@@ -1,523 +0,0 @@
|
||||
# pylint: disable=redefined-outer-name
|
||||
import json
|
||||
|
||||
import pytest
|
||||
|
||||
from specklepy.api import operations
|
||||
from specklepy.logging.exceptions import SpeckleException
|
||||
from specklepy.objects.base import Base
|
||||
from specklepy.objects_v2.encoding import CurveArray, ObjectArray
|
||||
from specklepy.objects_v2.geometry import (
|
||||
Arc,
|
||||
Box,
|
||||
Brep,
|
||||
BrepEdge,
|
||||
BrepFace,
|
||||
BrepLoop,
|
||||
BrepLoopType,
|
||||
BrepTrim,
|
||||
BrepTrimType,
|
||||
Circle,
|
||||
Curve,
|
||||
Ellipse,
|
||||
Interval,
|
||||
Line,
|
||||
Mesh,
|
||||
Plane,
|
||||
Point,
|
||||
Polycurve,
|
||||
Polyline,
|
||||
Surface,
|
||||
Vector,
|
||||
)
|
||||
from specklepy.objects_v2.units import Units
|
||||
from specklepy.transports.memory import MemoryTransport
|
||||
|
||||
|
||||
@pytest.fixture()
|
||||
def interval():
|
||||
return Interval(start=0, end=5)
|
||||
|
||||
|
||||
@pytest.fixture()
|
||||
def point():
|
||||
return Point(x=1, y=10, z=0)
|
||||
|
||||
|
||||
@pytest.fixture()
|
||||
def vector():
|
||||
return Vector(x=1, y=32, z=10)
|
||||
|
||||
|
||||
@pytest.fixture()
|
||||
def plane(point, vector):
|
||||
return Plane(origin=point, normal=vector, xdir=vector, ydir=vector, units="m")
|
||||
|
||||
|
||||
@pytest.fixture()
|
||||
def box(plane, interval):
|
||||
return Box(
|
||||
basePlane=plane,
|
||||
ySize=interval,
|
||||
zSize=interval,
|
||||
xSize=interval,
|
||||
area=20.4,
|
||||
volume=44.2,
|
||||
)
|
||||
|
||||
|
||||
@pytest.fixture()
|
||||
def line(point, interval):
|
||||
return Line(
|
||||
start=point,
|
||||
end=point,
|
||||
domain=interval,
|
||||
units="none",
|
||||
# These attributes are not handled in C#
|
||||
# bbox=None,
|
||||
# length=None
|
||||
)
|
||||
|
||||
|
||||
@pytest.fixture()
|
||||
def arc(plane, interval, point):
|
||||
return Arc(
|
||||
radius=2.3,
|
||||
startAngle=22.1,
|
||||
endAngle=44.5,
|
||||
angleRadians=33,
|
||||
plane=plane,
|
||||
domain=interval,
|
||||
units="m",
|
||||
startPoint=point,
|
||||
midPoint=point,
|
||||
endPoint=point,
|
||||
# These attributes are not handled in C#
|
||||
# bbox=None,
|
||||
# area=None,
|
||||
# length=None,
|
||||
)
|
||||
|
||||
|
||||
@pytest.fixture()
|
||||
def circle(plane, interval):
|
||||
return Circle(
|
||||
radius=22,
|
||||
plane=plane,
|
||||
domain=interval,
|
||||
units="m",
|
||||
# These attributes are not handled in C#
|
||||
# bbox=None,
|
||||
# area=None,
|
||||
# length=None,
|
||||
)
|
||||
|
||||
|
||||
@pytest.fixture()
|
||||
def ellipse(plane, interval):
|
||||
return Ellipse(
|
||||
firstRadius=34,
|
||||
secondRadius=22,
|
||||
plane=plane,
|
||||
domain=interval,
|
||||
units="m",
|
||||
# These attributes are not handled in C#
|
||||
# trimDomain=None,
|
||||
# bbox=None,
|
||||
# area=None,
|
||||
# length=None,
|
||||
)
|
||||
|
||||
|
||||
@pytest.fixture()
|
||||
def polyline(interval):
|
||||
return Polyline(
|
||||
value=[22, 44, 54.3, 99, 232, 21],
|
||||
closed=True,
|
||||
domain=interval,
|
||||
units="m",
|
||||
# These attributes are not handled in C#
|
||||
# bbox=None,
|
||||
# area=None,
|
||||
# length=None,
|
||||
)
|
||||
|
||||
|
||||
@pytest.fixture()
|
||||
def curve(interval):
|
||||
return Curve(
|
||||
degree=90,
|
||||
periodic=True,
|
||||
rational=False,
|
||||
closed=True,
|
||||
domain=interval,
|
||||
points=[23, 21, 44, 43, 56, 76, 1, 3, 2],
|
||||
weights=[23, 11, 23],
|
||||
knots=[22, 45, 76, 11],
|
||||
units="m",
|
||||
# These attributes are not handled in C#
|
||||
# displayValue=None,
|
||||
# bbox=None,
|
||||
# area=None,
|
||||
# length=None,
|
||||
)
|
||||
|
||||
|
||||
@pytest.fixture()
|
||||
def polycurve(interval, curve, polyline):
|
||||
return Polycurve(
|
||||
segments=[curve, polyline],
|
||||
domain=interval,
|
||||
closed=True,
|
||||
units="m",
|
||||
# These attributes are not handled in C#
|
||||
# bbox=None,
|
||||
# area=None,
|
||||
# length=None
|
||||
)
|
||||
|
||||
|
||||
@pytest.fixture()
|
||||
def mesh(box):
|
||||
return Mesh(
|
||||
vertices=[2, 1, 2, 4, 77.3, 5, 33, 4, 2],
|
||||
faces=[1, 2, 3, 4, 5, 6, 7],
|
||||
colors=[111, 222, 333, 444, 555, 666, 777],
|
||||
bbox=box,
|
||||
area=233,
|
||||
volume=232.2,
|
||||
)
|
||||
|
||||
|
||||
@pytest.fixture()
|
||||
def surface(interval):
|
||||
return Surface(
|
||||
degreeU=33,
|
||||
degreeV=44,
|
||||
rational=True,
|
||||
pointData=[1, 2.2, 3, 4, 5, 6, 7, 8, 9],
|
||||
countU=3,
|
||||
countV=4,
|
||||
closedU=True,
|
||||
closedV=False,
|
||||
domainU=interval,
|
||||
domainV=interval,
|
||||
knotsU=[1.1, 2.2, 3.3, 4.4],
|
||||
knotsV=[9, 8, 7, 6, 5, 4.4],
|
||||
units="m",
|
||||
# These attributes are not handled in C#
|
||||
# bbox=None,
|
||||
# area=None,
|
||||
)
|
||||
|
||||
|
||||
@pytest.fixture()
|
||||
def brep_face():
|
||||
return BrepFace(
|
||||
SurfaceIndex=3,
|
||||
LoopIndices=[1, 2, 3, 4],
|
||||
OuterLoopIndex=2,
|
||||
OrientationReversed=False,
|
||||
)
|
||||
|
||||
|
||||
@pytest.fixture()
|
||||
def brep_edge(interval):
|
||||
return BrepEdge(
|
||||
Curve3dIndex=2,
|
||||
TrimIndices=[4, 5, 6, 7],
|
||||
StartIndex=2,
|
||||
EndIndex=6,
|
||||
ProxyCurveIsReversed=True,
|
||||
Domain=interval,
|
||||
)
|
||||
|
||||
|
||||
@pytest.fixture()
|
||||
def brep_loop():
|
||||
return BrepLoop(FaceIndex=5, TrimIndices=[3, 4, 5], Type=BrepLoopType.Unknown)
|
||||
|
||||
|
||||
@pytest.fixture()
|
||||
def brep_trim():
|
||||
return BrepTrim(
|
||||
EdgeIndex=3,
|
||||
StartIndex=4,
|
||||
EndIndex=6,
|
||||
FaceIndex=1,
|
||||
LoopIndex=4,
|
||||
CurveIndex=7,
|
||||
IsoStatus=6,
|
||||
TrimType=BrepTrimType.Mated,
|
||||
IsReversed=False,
|
||||
# These attributes are not handled in C#
|
||||
# Domain=None,
|
||||
)
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def brep(
|
||||
mesh,
|
||||
box,
|
||||
surface,
|
||||
curve,
|
||||
polyline,
|
||||
circle,
|
||||
point,
|
||||
brep_edge,
|
||||
brep_loop,
|
||||
brep_trim,
|
||||
brep_face,
|
||||
):
|
||||
return Brep(
|
||||
provenance="pytest",
|
||||
bbox=box,
|
||||
area=32,
|
||||
volume=54,
|
||||
displayValue=mesh,
|
||||
Surfaces=[surface, surface, surface],
|
||||
Curve3D=[curve, polyline],
|
||||
Curve2D=[circle],
|
||||
Vertices=[point, point, point, point],
|
||||
Edges=[brep_edge],
|
||||
Loops=[brep_loop, brep_loop],
|
||||
Trims=[brep_trim],
|
||||
Faces=[brep_face, brep_face],
|
||||
IsClosed=False,
|
||||
Orientation=3,
|
||||
)
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def geometry_objects_dict(
|
||||
point,
|
||||
vector,
|
||||
plane,
|
||||
line,
|
||||
arc,
|
||||
circle,
|
||||
ellipse,
|
||||
polyline,
|
||||
curve,
|
||||
polycurve,
|
||||
surface,
|
||||
brep_trim,
|
||||
):
|
||||
return {
|
||||
"point": point,
|
||||
"vector": vector,
|
||||
"plane": plane,
|
||||
"line": line,
|
||||
"arc": arc,
|
||||
"circle": circle,
|
||||
"ellipse": ellipse,
|
||||
"polyline": polyline,
|
||||
"curve": curve,
|
||||
"polycurve": polycurve,
|
||||
"surface": surface,
|
||||
"brep_trim": brep_trim,
|
||||
}
|
||||
|
||||
|
||||
@pytest.mark.parametrize(
|
||||
"object_name",
|
||||
[
|
||||
"point",
|
||||
"vector",
|
||||
"plane",
|
||||
"line",
|
||||
"arc",
|
||||
"circle",
|
||||
"ellipse",
|
||||
"polyline",
|
||||
"curve",
|
||||
"polycurve",
|
||||
"surface",
|
||||
"brep_trim",
|
||||
],
|
||||
)
|
||||
def test_to_and_from_list(object_name: str, geometry_objects_dict):
|
||||
obj = geometry_objects_dict[object_name]
|
||||
assert hasattr(obj, "to_list")
|
||||
assert hasattr(obj, "from_list")
|
||||
|
||||
chunks = obj.to_list()
|
||||
assert isinstance(chunks, list)
|
||||
|
||||
object_class = obj.__class__
|
||||
decoded_object: Base = object_class.from_list(chunks)
|
||||
assert decoded_object.get_id() == obj.get_id()
|
||||
|
||||
|
||||
def test_brep_surfaces_value_serialization(surface):
|
||||
brep = Brep()
|
||||
assert brep.Surfaces is None
|
||||
assert brep.SurfacesValue is None
|
||||
brep.Surfaces = [surface, surface]
|
||||
assert brep.SurfacesValue == ObjectArray.from_objects([surface, surface]).data
|
||||
|
||||
brep.SurfacesValue = ObjectArray.from_objects([surface]).data
|
||||
assert len(brep.Surfaces) == 1
|
||||
assert brep.Surfaces[0].get_id() == surface.get_id()
|
||||
|
||||
|
||||
def test_brep_curve2d_values_serialization(curve, polyline, circle):
|
||||
brep = Brep()
|
||||
assert brep.Curve2D is None
|
||||
assert brep.Curve2DValues is None
|
||||
brep.Curve2D = [curve, polyline]
|
||||
assert brep.Curve2DValues == CurveArray.from_curves([curve, polyline]).data
|
||||
|
||||
brep.Curve2DValues = CurveArray.from_curves([circle]).data
|
||||
assert len(brep.Curve2D) == 1
|
||||
assert brep.Curve2D[0].get_id() == circle.get_id()
|
||||
|
||||
|
||||
def test_brep_curve3d_values_serialization(curve, polyline, circle):
|
||||
brep = Brep()
|
||||
assert brep.Curve3D is None
|
||||
assert brep.Curve3DValues is None
|
||||
brep.Curve3D = [curve, polyline]
|
||||
assert brep.Curve3DValues == CurveArray.from_curves([curve, polyline]).data
|
||||
|
||||
brep.Curve3DValues = CurveArray.from_curves([circle]).data
|
||||
assert len(brep.Curve3D) == 1
|
||||
assert brep.Curve3D[0].get_id() == circle.get_id()
|
||||
|
||||
|
||||
def test_brep_vertices_values_serialization():
|
||||
brep = Brep()
|
||||
brep.VerticesValue = [1, 1, 1, 1, 2, 2, 2, 3, 3, 3]
|
||||
assert brep.Vertices[0].get_id() == Point(x=1, y=1, z=1, units=Units.mm).get_id()
|
||||
assert brep.Vertices[1].get_id() == Point(x=2, y=2, z=2, units=Units.mm).get_id()
|
||||
assert brep.Vertices[2].get_id() == Point(x=3, y=3, z=3, units=Units.mm).get_id()
|
||||
|
||||
|
||||
def test_trims_value_serialization():
|
||||
brep = Brep()
|
||||
brep.TrimsValue = [
|
||||
0,
|
||||
0,
|
||||
0,
|
||||
0,
|
||||
0,
|
||||
0,
|
||||
1,
|
||||
1,
|
||||
0,
|
||||
1,
|
||||
0,
|
||||
0,
|
||||
0,
|
||||
0,
|
||||
1,
|
||||
2,
|
||||
1,
|
||||
1,
|
||||
]
|
||||
|
||||
assert (
|
||||
brep.Trims[0].get_id()
|
||||
== BrepTrim(
|
||||
EdgeIndex=0,
|
||||
StartIndex=0,
|
||||
EndIndex=0,
|
||||
FaceIndex=0,
|
||||
LoopIndex=0,
|
||||
CurveIndex=0,
|
||||
IsoStatus=1,
|
||||
TrimType=BrepTrimType.Boundary,
|
||||
IsReversed=False,
|
||||
).get_id()
|
||||
)
|
||||
|
||||
assert (
|
||||
brep.Trims[1].get_id()
|
||||
== BrepTrim(
|
||||
EdgeIndex=1,
|
||||
StartIndex=0,
|
||||
EndIndex=0,
|
||||
FaceIndex=0,
|
||||
LoopIndex=0,
|
||||
CurveIndex=1,
|
||||
IsoStatus=2,
|
||||
TrimType=BrepTrimType.Boundary,
|
||||
IsReversed=True,
|
||||
).get_id()
|
||||
)
|
||||
|
||||
|
||||
def test_loops_value_serialization():
|
||||
brep = Brep()
|
||||
brep.LoopsValue = [6, 0, 1, 0, 1, 2, 3]
|
||||
|
||||
assert brep == brep.Loops[0]._Brep # pylint: disable=protected-access
|
||||
assert (
|
||||
brep.Loops[0].get_id()
|
||||
== BrepLoop(
|
||||
FaceIndex=0, Type=BrepLoopType(1), TrimIndices=[0, 1, 2, 3]
|
||||
).get_id()
|
||||
)
|
||||
|
||||
|
||||
def test_edges_value_serialization():
|
||||
brep = Brep()
|
||||
brep.EdgesValue = [8, 0, 0, 1, 0, -8.13345756858629, 8.13345756858629, 1, 3]
|
||||
|
||||
assert brep == brep.Edges[0]._Brep # pylint: disable=protected-access
|
||||
assert (
|
||||
brep.Edges[0].get_id()
|
||||
== BrepEdge(
|
||||
Curve3dIndex=0,
|
||||
StartIndex=0,
|
||||
EndIndex=1,
|
||||
ProxyCurveIsReversed=False,
|
||||
Domain=Interval(start=-8.13345756858629, end=8.13345756858629),
|
||||
TrimIndices=[1, 3],
|
||||
).get_id()
|
||||
)
|
||||
|
||||
|
||||
def test_faces_value_serialization():
|
||||
brep = Brep()
|
||||
brep.FacesValue = [4, 0, 0, 1, 0]
|
||||
|
||||
assert brep == brep.Faces[0]._Brep # pylint: disable=protected-access
|
||||
assert (
|
||||
brep.Faces[0].get_id()
|
||||
== BrepFace(
|
||||
SurfaceIndex=0, OuterLoopIndex=0, OrientationReversed=True, LoopIndices=[0]
|
||||
).get_id()
|
||||
)
|
||||
|
||||
|
||||
def test_serialized_brep_attributes(brep: Brep):
|
||||
transport = MemoryTransport()
|
||||
serialized = operations.serialize(brep, [transport])
|
||||
serialized_dict = json.loads(serialized)
|
||||
|
||||
removed_keys = [
|
||||
"Surfaces",
|
||||
"Curve3D",
|
||||
"Curve2D",
|
||||
"Vertices",
|
||||
"Trims",
|
||||
"Loops",
|
||||
"Edges",
|
||||
"Faces",
|
||||
]
|
||||
|
||||
for k in removed_keys:
|
||||
assert k not in serialized_dict
|
||||
|
||||
|
||||
def test_mesh_create():
|
||||
vertices = [2, 1, 2, 4, 77.3, 5, 33, 4, 2]
|
||||
faces = [1, 2, 3, 4, 5, 6, 7]
|
||||
mesh = Mesh.create(vertices, faces)
|
||||
|
||||
with pytest.raises(SpeckleException):
|
||||
bad_mesh = Mesh.create(vertices=7, faces=faces) # noqa: F841
|
||||
|
||||
assert mesh.vertices == vertices
|
||||
assert mesh.textureCoordinates == []
|
||||
@@ -2,8 +2,8 @@ from dataclasses import dataclass
|
||||
from typing import Dict, List, Optional
|
||||
from unittest import TestCase
|
||||
|
||||
from specklepy.objects_v2 import Base
|
||||
from specklepy.objects_v2.graph_traversal.traversal import GraphTraversal, TraversalRule
|
||||
from specklepy.objects.base import Base
|
||||
from specklepy.objects.graph_traversal.traversal import GraphTraversal, TraversalRule
|
||||
|
||||
|
||||
@dataclass()
|
||||
@@ -100,6 +100,7 @@ class GraphTraversalTests(TestCase):
|
||||
for context in GraphTraversal([traverse_lists_rule]).traverse(test_case)
|
||||
]
|
||||
|
||||
self.assertCountEqual(ret, [test_case, expected_traverse, expected_traverse])
|
||||
self.assertCountEqual(
|
||||
ret, [test_case, expected_traverse, expected_traverse])
|
||||
self.assertNotIn(expected_ignore, ret)
|
||||
self.assertEqual(len(ret), 3)
|
||||
|
||||
@@ -2,8 +2,7 @@ from typing import Type
|
||||
|
||||
import pytest
|
||||
|
||||
from specklepy.objects_v2.base import Base
|
||||
from specklepy.objects_v2.structural import Concrete
|
||||
from specklepy.objects.base import Base
|
||||
|
||||
|
||||
class Foo(Base):
|
||||
@@ -28,10 +27,6 @@ class Baz(Bar):
|
||||
Baz,
|
||||
"Tests.Unit.TestRegisteringBase.Foo:Custom.Bar:Tests.Unit.TestRegisteringBase.Baz",
|
||||
),
|
||||
(
|
||||
Concrete,
|
||||
"Objects.Structural.Materials.StructuralMaterial:Objects.Structural.Materials.Concrete",
|
||||
),
|
||||
],
|
||||
)
|
||||
def test_determine_speckle_type(klass: Type[Base], speckle_type: str):
|
||||
@@ -43,7 +38,6 @@ def test_determine_speckle_type(klass: Type[Base], speckle_type: str):
|
||||
[
|
||||
(Base, "Base"),
|
||||
(Foo, "Tests.Unit.TestRegisteringBase.Foo"),
|
||||
(Concrete, "Objects.Structural.Materials.Concrete"),
|
||||
],
|
||||
)
|
||||
def test_full_name(klass: Type[Base], fully_qualified_name: str):
|
||||
|
||||
@@ -1,143 +0,0 @@
|
||||
import pytest
|
||||
|
||||
from specklepy.objects_v2.geometry import Line, Mesh, Point, Vector
|
||||
from specklepy.objects_v2.structural.analysis import Model
|
||||
from specklepy.objects_v2.structural.geometry import (
|
||||
Element1D,
|
||||
Element2D,
|
||||
ElementType1D,
|
||||
ElementType2D,
|
||||
Node,
|
||||
Restraint,
|
||||
)
|
||||
from specklepy.objects_v2.structural.loading import LoadGravity
|
||||
from specklepy.objects_v2.structural.materials import StructuralMaterial
|
||||
from specklepy.objects_v2.structural.properties import (
|
||||
MemberType,
|
||||
Property1D,
|
||||
Property2D,
|
||||
SectionProfile,
|
||||
ShapeType,
|
||||
)
|
||||
|
||||
|
||||
@pytest.fixture()
|
||||
def point():
|
||||
return Point(x=1, y=10, z=0)
|
||||
|
||||
|
||||
@pytest.fixture()
|
||||
def vector():
|
||||
return Vector(x=0, y=0, z=-1)
|
||||
|
||||
|
||||
@pytest.fixture()
|
||||
def line(point, interval):
|
||||
return Line(
|
||||
start=point,
|
||||
end=point,
|
||||
domain=interval,
|
||||
# These attributes are not handled in C#
|
||||
# bbox=None,
|
||||
# length=None
|
||||
)
|
||||
|
||||
|
||||
@pytest.fixture()
|
||||
def mesh(box):
|
||||
return Mesh(
|
||||
vertices=[2, 1, 2, 4, 77.3, 5, 33, 4, 2],
|
||||
faces=[1, 2, 3, 4, 5, 6, 7],
|
||||
colors=[111, 222, 333, 444, 555, 666, 777],
|
||||
bbox=box,
|
||||
area=233,
|
||||
volume=232.2,
|
||||
)
|
||||
|
||||
|
||||
@pytest.fixture()
|
||||
def restraint():
|
||||
return Restraint(code="FFFFFF")
|
||||
|
||||
|
||||
@pytest.fixture()
|
||||
def node(restraint, point):
|
||||
return Node(basePoint=point, restraint=restraint, name="node1")
|
||||
|
||||
|
||||
@pytest.fixture()
|
||||
def material():
|
||||
return StructuralMaterial(name="TestMaterial")
|
||||
|
||||
|
||||
@pytest.fixture()
|
||||
def memberType():
|
||||
return MemberType(0)
|
||||
|
||||
|
||||
@pytest.fixture()
|
||||
def shapeType():
|
||||
return ShapeType(8)
|
||||
|
||||
|
||||
@pytest.fixture()
|
||||
def sectionProfile(shapeType):
|
||||
return SectionProfile(name="Test", shapeType=shapeType)
|
||||
|
||||
|
||||
@pytest.fixture()
|
||||
def property1D(memberType, sectionProfile, material):
|
||||
return Property1D(
|
||||
Material=material,
|
||||
SectionProfile=sectionProfile,
|
||||
memberType=memberType,
|
||||
)
|
||||
|
||||
|
||||
@pytest.fixture()
|
||||
def elementType1D():
|
||||
return ElementType1D(0)
|
||||
|
||||
|
||||
@pytest.fixture()
|
||||
def element1D(line, restraint, elementType1D, property1D):
|
||||
return Element1D(
|
||||
baseLine=line,
|
||||
end1Releases=restraint,
|
||||
end2Releases=restraint,
|
||||
type=elementType1D,
|
||||
property=property1D,
|
||||
)
|
||||
|
||||
|
||||
@pytest.fixture()
|
||||
def property2D(material):
|
||||
return Property2D(Material=material)
|
||||
|
||||
|
||||
@pytest.fixture()
|
||||
def elementType2D():
|
||||
return ElementType2D(0)
|
||||
|
||||
|
||||
@pytest.fixture()
|
||||
def element2D(point, elementType2D):
|
||||
return Element2D(
|
||||
topology=[point],
|
||||
type=elementType2D,
|
||||
)
|
||||
|
||||
|
||||
@pytest.fixture()
|
||||
def loadGravity(element1D, element2D, vector):
|
||||
return LoadGravity(elements=[element1D, element2D], gravityFactors=vector)
|
||||
|
||||
|
||||
@pytest.fixture()
|
||||
def model(loadGravity, element1D, element2D, material, property1D, property2D):
|
||||
return Model(
|
||||
loads=[loadGravity],
|
||||
elements=[element1D, element2D],
|
||||
materials=[material],
|
||||
properties=[property1D, property2D],
|
||||
)
|
||||
@@ -1,129 +0,0 @@
|
||||
from typing import List
|
||||
|
||||
import pytest
|
||||
|
||||
from specklepy.api import operations
|
||||
from specklepy.objects_v2.geometry import Point, Vector
|
||||
from specklepy.objects_v2.other import 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()
|
||||
@@ -1,9 +1,11 @@
|
||||
from typing import List
|
||||
from dataclasses import dataclass
|
||||
|
||||
from specklepy.objects_v2.base import Base
|
||||
from specklepy.objects.base import Base
|
||||
from specklepy.serialization.base_object_serializer import BaseObjectSerializer
|
||||
|
||||
|
||||
@dataclass(kw_only=True)
|
||||
class FakeBase(Base):
|
||||
foo: List[str]
|
||||
bar: int
|
||||
|
||||
@@ -3,8 +3,8 @@ from typing import Any, Dict, List, Optional, Set, Tuple, Union
|
||||
|
||||
import pytest
|
||||
|
||||
from specklepy.objects_v2.base import Base, _validate_type
|
||||
from specklepy.objects_v2.primitive import Interval
|
||||
from specklepy.objects.base import Base, _validate_type
|
||||
from specklepy.objects.primitive import Interval
|
||||
|
||||
test_base = Base()
|
||||
|
||||
@@ -87,7 +87,8 @@ fake_bases = [FakeBase("foo"), FakeBase("bar")]
|
||||
(Tuple, (1, "foo", "bar"), True, (1, "foo", "bar")),
|
||||
# given our current rules, this is the reality. Its just sad...
|
||||
(Tuple[str, str, str], (1, "foo", "bar"), True, ("1", "foo", "bar")),
|
||||
(Tuple[str, Optional[str], str], (1, None, "bar"), True, ("1", None, "bar")),
|
||||
(Tuple[str, Optional[str], str],
|
||||
(1, None, "bar"), True, ("1", None, "bar")),
|
||||
(Set[bool], set([1, 2]), False, set([1, 2])),
|
||||
(Set[int], set([1, 2]), True, set([1, 2])),
|
||||
(Set[int], set([None, 2]), True, set([None, 2])),
|
||||
@@ -99,7 +100,8 @@ fake_bases = [FakeBase("foo"), FakeBase("bar")]
|
||||
(Optional[Union[List[int], List[FakeBase]]], None, True, None),
|
||||
(Optional[Union[List[int], List[FakeBase]]], "foo", False, "foo"),
|
||||
(Union[List[int], List[FakeBase], None], "foo", False, "foo"),
|
||||
(Optional[Union[List[int], List[FakeBase]]], [1, 2, 3], True, [1, 2, 3]),
|
||||
(Optional[Union[List[int], List[FakeBase]]],
|
||||
[1, 2, 3], True, [1, 2, 3]),
|
||||
(
|
||||
Optional[Union[List[int], List[FakeBase]]],
|
||||
fake_bases,
|
||||
@@ -113,7 +115,8 @@ fake_bases = [FakeBase("foo"), FakeBase("bar")]
|
||||
True,
|
||||
{"foo": 1.0, "bar": 2.0},
|
||||
),
|
||||
(Union[float, Dict[str, float]], {"foo": "bar"}, False, {"foo": "bar"}),
|
||||
(Union[float, Dict[str, float]], {
|
||||
"foo": "bar"}, False, {"foo": "bar"}),
|
||||
],
|
||||
)
|
||||
def test_validate_type(
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
import pytest
|
||||
|
||||
from specklepy.objects_v2.units import Units, get_scale_factor
|
||||
from specklepy.objects.models.units import Units, get_scale_factor
|
||||
|
||||
|
||||
@pytest.mark.parametrize(
|
||||
|
||||
Reference in New Issue
Block a user