buildzr 0.0.7__py3-none-any.whl → 0.0.9__py3-none-any.whl

buildzr/dsl/dsl.py

@@ -3,9 +3,10 @@ import buildzr
 from .factory import GenerateId
 from typing_extensions import (
     Self,
-    TypeGuard,
     TypeIs,
 )
+from collections import deque
+from contextvars import ContextVar
 from typing import (
     Any,
     Union,
@@ -16,35 +17,26 @@ from typing import (
     Optional,
     Generic,
     TypeVar,
-    Protocol,
     Callable,
     Iterable,
     Literal,
     cast,
-    overload,
-    Sequence,
     Type,
 )
 
 from buildzr.sinks.interfaces import Sink
-
 from buildzr.dsl.interfaces import (
     DslWorkspaceElement,
     DslElement,
     DslViewElement,
     DslViewsElement,
-    DslFluentSink,
-    TSrc, TDst,
-    TParent, TChild,
 )
 from buildzr.dsl.relations import (
-    _is_software_fluent_relationship,
-    _is_container_fluent_relationship,
-    _Relationship,
-    _RelationshipDescription,
-    _FluentRelationship,
     DslElementRelationOverrides,
+    DslRelationship,
+    _Relationship,
 )
+from buildzr.dsl.color import Color
 
 def _child_name_transform(name: str) -> str:
     return name.lower().replace(' ', '_')
@@ -58,6 +50,11 @@ class TypedDynamicAttribute(Generic[TypedModel]):
     def __getattr__(self, name: str) -> TypedModel:
         return cast(TypedModel, self._dynamic_attributes.get(name))
 
+_current_workspace: ContextVar[Optional['Workspace']] = ContextVar('current_workspace', default=None)
+_current_group_stack: ContextVar[List['Group']] = ContextVar('current_group', default=[])
+_current_software_system: ContextVar[Optional['SoftwareSystem']] = ContextVar('current_software_system', default=None)
+_current_container: ContextVar[Optional['Container']] = ContextVar('current_container', default=None)
+
 class Workspace(DslWorkspaceElement):
     """
     Represents a Structurizr workspace, which is a wrapper for a software architecture model, views, and documentation.
@@ -75,11 +72,21 @@ class Workspace(DslWorkspaceElement):
     def children(self) -> Optional[List[Union['Person', 'SoftwareSystem']]]:
         return self._children
 
-    def __init__(self, name: str, description: str="", scope: Literal['landscape', 'software_system', None]='software_system') -> None:
+    def __init__(
+            self,
+            name: str,
+            description: str="",
+            scope: Literal['landscape', 'software_system', None]='software_system',
+            implied_relationships: bool=False,
+            group_separator: str='/',
+        ) -> None:
+
         self._m = buildzr.models.Workspace()
         self._parent = None
         self._children: Optional[List[Union['Person', 'SoftwareSystem']]] = []
         self._dynamic_attrs: Dict[str, Union['Person', 'SoftwareSystem']] = {}
+        self._use_implied_relationships = implied_relationships
+        self._group_separator = group_separator
         self.model.id = GenerateId.for_workspace()
         self.model.name = name
         self.model.description = description
@@ -102,58 +109,57 @@ class Workspace(DslWorkspaceElement):
             scope=scope_mapper[scope],
         )
 
-    def _contains_group(
-        self,
-        name: str,
-        *models: Union[
-            'Person',
-            'SoftwareSystem',
-            _FluentRelationship['SoftwareSystem'],
-            _FluentRelationship['Container'],
-        ]
-    ) -> None:
+        self.model.model.properties = {
+            'structurizr.groupSeparator': group_separator,
+        }
 
-        def recursive_group_name_assign(software_system: 'SoftwareSystem') -> None:
-            software_system.model.group = name
-            for container in software_system.children:
-                container.model.group = name
-                for component in container.children:
-                    component.model.group = name
-
-        for model in models:
-            if isinstance(model, Person):
-                model.model.group = name
-            elif isinstance(model, SoftwareSystem):
-                recursive_group_name_assign(model)
-            elif _is_software_fluent_relationship(model):
-                recursive_group_name_assign(model._parent)
-            elif _is_container_fluent_relationship(model):
-                recursive_group_name_assign(model._parent._parent)
-
-        self.contains(*models)
-
-    def contains(
-        self,
-        *models: Union[
-            'Group',
-            'Person',
-            'SoftwareSystem',
-            _FluentRelationship['SoftwareSystem'],
-            _FluentRelationship['Container'],
-        ]) -> _FluentRelationship['Workspace']:
-
-        for model in models:
-            if isinstance(model, Group):
-                self._contains_group(model._name, *model._elements)
-            elif isinstance(model, Person):
-                self.add_element(model)
-            elif isinstance(model, SoftwareSystem):
-                self.add_element(model)
-            elif _is_software_fluent_relationship(model):
-                self.add_element(model._parent)
-            elif _is_container_fluent_relationship(model):
-                self.add_element(model._parent._parent)
-        return _FluentRelationship['Workspace'](self)
+    def __enter__(self) -> Self:
+        self._token = _current_workspace.set(self)
+        return self
+
+    def __exit__(self, exc_type: Optional[Type[BaseException]], exc_value: Optional[BaseException], traceback: Optional[Any]) -> None:
+
+        from buildzr.dsl.explorer import Explorer
+
+        # Process implied relationships:
+        # If we have relationship s >> do >> a.b, then create s >> do >> a.
+        # If we have relationship s.ss >> do >> a.b.c, then create s.ss >> do >> a.b and s.ss >> do >> a.
+        # And so on...
+        if self._use_implied_relationships:
+            explorer = Explorer(self)
+            relationships = list(explorer.walk_relationships())
+            for relationship in relationships:
+                source = relationship.source
+                destination = relationship.destination
+                destination_parent = destination.parent
+
+                while destination_parent is not None and \
+                      isinstance(source, DslElement) and \
+                      not isinstance(source.model, buildzr.models.Workspace) and \
+                      not isinstance(destination_parent, DslWorkspaceElement):
+
+                    if destination_parent is source.parent:
+                        break
+
+                    rels = source.model.relationships
+
+                    if rels:
+                        already_exists = any(
+                            r.destinationId == destination_parent.model.id and
+                            r.description == relationship.model.description and
+                            r.technology == relationship.model.technology
+                            for r in rels
+                        )
+                        if not already_exists:
+                            r = source.uses(
+                                destination_parent,
+                                description=relationship.model.description,
+                                technology=relationship.model.technology,
+                            )
+                            r.model.linkedRelationshipId = relationship.model.id
+                        destination_parent = destination_parent.parent
+
+        _current_workspace.reset(self._token)
 
     def person(self) -> TypedDynamicAttribute['Person']:
         return TypedDynamicAttribute['Person'](self._dynamic_attrs)
@@ -161,34 +167,68 @@ class Workspace(DslWorkspaceElement):
     def software_system(self) -> TypedDynamicAttribute['SoftwareSystem']:
         return TypedDynamicAttribute['SoftwareSystem'](self._dynamic_attrs)
 
-    def add_element(self, element: Union['Person', 'SoftwareSystem']) -> None:
-        if isinstance(element, Person):
-            self._m.model.people.append(element._m)
-            element._parent = self
-            self._dynamic_attrs[_child_name_transform(element.model.name)] = element
-            if element._label:
-                self._dynamic_attrs[_child_name_transform(element._label)] = element
-            self._children.append(element)
-        elif isinstance(element, SoftwareSystem):
-            self._m.model.softwareSystems.append(element._m)
-            element._parent = self
-            self._dynamic_attrs[_child_name_transform(element.model.name)] = element
-            if element._label:
-                self._dynamic_attrs[_child_name_transform(element._label)] = element
-            self._children.append(element)
+    def add_model(self, model: Union['Person', 'SoftwareSystem']) -> None:
+        if isinstance(model, Person):
+            self._m.model.people.append(model._m)
+            model._parent = self
+            self._add_dynamic_attr(model.model.name, model)
+            self._children.append(model)
+        elif isinstance(model, SoftwareSystem):
+            self._m.model.softwareSystems.append(model._m)
+            model._parent = self
+            self._add_dynamic_attr(model.model.name, model)
+            self._children.append(model)
         else:
-            raise ValueError('Invalid element type: Trying to add an element of type {} to a workspace.'.format(type(element)))
+            raise ValueError('Invalid element type: Trying to add an element of type {} to a workspace.'.format(type(model)))
 
-    def with_views(
-        self,
-        *views: Union[
-            'SystemLandscapeView',
+    def apply_views( self, *views: Union[ 'SystemLandscapeView',
             'SystemContextView',
             'ContainerView',
             'ComponentView',
         ]
-    ) -> '_FluentSink':
-        return Views(self).contains(*views)
+    ) -> None:
+        Views(self).add_views(*views)
+
+    def apply_style( self,
+        style: Union['StyleElements', 'StyleRelationships'],
+    ) -> None:
+
+        style._parent = self
+
+        if not self.model.views:
+            self.model.views = buildzr.models.Views()
+        if not self.model.views.configuration:
+            self.model.views.configuration = buildzr.models.Configuration()
+        if not self.model.views.configuration.styles:
+            self.model.views.configuration.styles = buildzr.models.Styles()
+
+        if isinstance(style, StyleElements):
+            if self.model.views.configuration.styles.elements:
+                self.model.views.configuration.styles.elements.extend(style.model)
+            else:
+                self.model.views.configuration.styles.elements = style.model
+        elif isinstance(style, StyleRelationships):
+            if self.model.views.configuration.styles.relationships:
+                self.model.views.configuration.styles.relationships.extend(style.model)
+            else:
+                self.model.views.configuration.styles.relationships = style.model
+
+    def to_json(self, path: str) -> None:
+        from buildzr.sinks.json_sink import JsonSink, JsonSinkConfig
+        sink = JsonSink()
+        sink.write(workspace=self.model, config=JsonSinkConfig(path=path))
+
+    def _add_dynamic_attr(self, name: str, model: Union['Person', 'SoftwareSystem']) -> None:
+        if isinstance(model, Person):
+            self._dynamic_attrs[_child_name_transform(name)] = model
+            if model._label:
+                self._dynamic_attrs[_child_name_transform(model._label)] = model
+        elif isinstance(model, SoftwareSystem):
+            self._dynamic_attrs[_child_name_transform(name)] = model
+            if model._label:
+                self._dynamic_attrs[_child_name_transform(model._label)] = model
+        else:
+            raise ValueError('Invalid element type: Trying to add an element of type {} to a workspace.'.format(type(model)))
 
     def __getattr__(self, name: str) -> Union['Person', 'SoftwareSystem']:
         return self._dynamic_attrs[name]
@@ -232,16 +272,22 @@ class SoftwareSystem(DslElementRelationOverrides[
     def destinations(self) -> List[DslElement]:
         return self._destinations
 
+    @property
+    def relationships(self) -> Set[_Relationship]:
+        return self._relationships
+
     @property
     def tags(self) -> Set[str]:
         return self._tags
 
     def __init__(self, name: str, description: str="", tags: Set[str]=set(), properties: Dict[str, Any]=dict()) -> None:
         self._m = buildzr.models.SoftwareSystem()
+        self.model.containers = []
         self._parent: Optional[Workspace] = None
         self._children: Optional[List['Container']] = []
         self._sources: List[DslElement] = []
         self._destinations: List[DslElement] = []
+        self._relationships: Set[_Relationship] = set()
         self._tags = {'Element', 'Software System'}.union(tags)
         self._dynamic_attrs: Dict[str, 'Container'] = {}
         self._label: Optional[str] = None
@@ -251,37 +297,41 @@ class SoftwareSystem(DslElementRelationOverrides[
         self.model.tags = ','.join(self._tags)
         self.model.properties = properties
 
-    def contains(
-        self,
-        *containers: Union['Container', _FluentRelationship['Container']]
-    ) -> _FluentRelationship['SoftwareSystem']:
-        if not self.model.containers:
-            self.model.containers = []
-
-        for child in containers:
-            if isinstance(child, Container):
-                self.add_element(child)
-            elif _is_container_fluent_relationship(child):
-                self.add_element(child._parent)
-        return _FluentRelationship['SoftwareSystem'](self)
+        workspace = _current_workspace.get()
+        if workspace is not None:
+            workspace.add_model(self)
+            workspace._add_dynamic_attr(self.model.name, self)
 
-    def labeled(self, label: str) -> 'SoftwareSystem':
-        self._label = label
+        stack = _current_group_stack.get()
+        if stack:
+            stack[-1].add_element(self)
+
+    def __enter__(self) -> Self:
+        self._token = _current_software_system.set(self)
         return self
 
+    def __exit__(self, exc_type: Optional[Type[BaseException]], exc_value: Optional[BaseException], traceback: Optional[Any]) -> None:
+        _current_software_system.reset(self._token)
+
     def container(self) -> TypedDynamicAttribute['Container']:
         return TypedDynamicAttribute['Container'](self._dynamic_attrs)
 
-    def add_element(self, element: 'Container') -> None:
-        if isinstance(element, Container):
-            self.model.containers.append(element.model)
-            element._parent = self
-            self._dynamic_attrs[_child_name_transform(element.model.name)] = element
-            if element._label:
-                self._dynamic_attrs[_child_name_transform(element._label)] = element
-            self._children.append(element)
+    def add_container(self, container: 'Container') -> None:
+        if isinstance(container, Container):
+            self.model.containers.append(container.model)
+            container._parent = self
+            self._add_dynamic_attr(container.model.name, container)
+            self._children.append(container)
         else:
-            raise ValueError('Invalid element type: Trying to add an element of type {} to a software system.'.format(type(element)))
+            raise ValueError('Invalid element type: Trying to add an element of type {} to a software system.'.format(type(container)))
+
+    def _add_dynamic_attr(self, name: str, model: 'Container') -> None:
+        if isinstance(model, Container):
+            self._dynamic_attrs[_child_name_transform(name)] = model
+            if model._label:
+                self._dynamic_attrs[_child_name_transform(model._label)] = model
+        else:
+            raise ValueError('Invalid element type: Trying to add an element of type {} to a software system.'.format(type(model)))
 
     def __getattr__(self, name: str) -> 'Container':
         return self._dynamic_attrs[name]
@@ -292,6 +342,13 @@ class SoftwareSystem(DslElementRelationOverrides[
     def __dir__(self) -> Iterable[str]:
         return list(super().__dir__()) + list(self._dynamic_attrs.keys())
 
+    def labeled(self, label: str) -> 'SoftwareSystem':
+        self._label = label
+        workspace = _current_workspace.get()
+        if workspace is not None:
+            workspace._add_dynamic_attr(label, self)
+        return self
+
 class Person(DslElementRelationOverrides[
     'Person',
     Union[
@@ -329,6 +386,10 @@ class Person(DslElementRelationOverrides[
     def destinations(self) -> List[DslElement]:
         return self._destinations
 
+    @property
+    def relationships(self) -> Set[_Relationship]:
+        return self._relationships
+
     @property
     def tags(self) -> Set[str]:
         return self._tags
@@ -338,6 +399,7 @@ class Person(DslElementRelationOverrides[
         self._parent: Optional[Workspace] = None
         self._sources: List[DslElement] = []
         self._destinations: List[DslElement] = []
+        self._relationships: Set[_Relationship] = set()
         self._tags = {'Element', 'Person'}.union(tags)
         self._label: Optional[str] = None
         self.model.id = GenerateId.for_element()
@@ -347,8 +409,19 @@ class Person(DslElementRelationOverrides[
         self.model.tags = ','.join(self._tags)
         self.model.properties = properties
 
+        workspace = _current_workspace.get()
+        if workspace is not None:
+            workspace.add_model(self)
+
+        stack = _current_group_stack.get()
+        if stack:
+            stack[-1].add_element(self)
+
     def labeled(self, label: str) -> 'Person':
         self._label = label
+        workspace = _current_workspace.get()
+        if workspace is not None:
+            workspace._add_dynamic_attr(label, self)
         return self
 
 class Container(DslElementRelationOverrides[
@@ -384,23 +457,22 @@ class Container(DslElementRelationOverrides[
     def destinations(self) -> List[DslElement]:
         return self._destinations
 
+    @property
+    def relationships(self) -> Set[_Relationship]:
+        return self._relationships
+
     @property
     def tags(self) -> Set[str]:
         return self._tags
 
-    def contains(self, *components: 'Component') -> _FluentRelationship['Container']:
-        if not self.model.components:
-            self.model.components = []
-        for component in components:
-            self.add_element(component)
-        return _FluentRelationship['Container'](self)
-
     def __init__(self, name: str, description: str="", technology: str="", tags: Set[str]=set(), properties: Dict[str, Any]=dict()) -> None:
         self._m = buildzr.models.Container()
+        self.model.components = []
         self._parent: Optional[SoftwareSystem] = None
         self._children: Optional[List['Component']] = []
         self._sources: List[DslElement] = []
         self._destinations: List[DslElement] = []
+        self._relationships: Set[_Relationship] = set()
         self._tags = {'Element', 'Container'}.union(tags)
         self._dynamic_attrs: Dict[str, 'Component'] = {}
         self._label: Optional[str] = None
@@ -412,23 +484,48 @@ class Container(DslElementRelationOverrides[
         self.model.tags = ','.join(self._tags)
         self.model.properties = properties
 
+        software_system = _current_software_system.get()
+        if software_system is not None:
+            software_system.add_container(self)
+            software_system._add_dynamic_attr(self.model.name, self)
+
+        stack = _current_group_stack.get()
+        if stack:
+            stack[-1].add_element(self)
+
+    def __enter__(self) -> Self:
+        self._token = _current_container.set(self)
+        return self
+
+    def __exit__(self, exc_type: Optional[Type[BaseException]], exc_value: Optional[BaseException], traceback: Optional[Any]) -> None:
+        _current_container.reset(self._token)
+
     def labeled(self, label: str) -> 'Container':
         self._label = label
+        software_system = _current_software_system.get()
+        if software_system is not None:
+            software_system._add_dynamic_attr(label, self)
         return self
 
     def component(self) -> TypedDynamicAttribute['Component']:
         return TypedDynamicAttribute['Component'](self._dynamic_attrs)
 
-    def add_element(self, element: 'Component') -> None:
-        if isinstance(element, Component):
-            self.model.components.append(element.model)
-            element._parent = self
-            self._dynamic_attrs[_child_name_transform(element.model.name)] = element
-            if element._label:
-                self._dynamic_attrs[_child_name_transform(element._label)] = element
-            self._children.append(element)
+    def add_component(self, component: 'Component') -> None:
+        if isinstance(component, Component):
+            self.model.components.append(component.model)
+            component._parent = self
+            self._add_dynamic_attr(component.model.name, component)
+            self._children.append(component)
         else:
-            raise ValueError('Invalid element type: Trying to add an element of type {} to a container.'.format(type(element)))
+            raise ValueError('Invalid element type: Trying to add an element of type {} to a container.'.format(type(component)))
+
+    def _add_dynamic_attr(self, name: str, model: 'Component') -> None:
+        if isinstance(model, Component):
+            self._dynamic_attrs[_child_name_transform(name)] = model
+            if model._label:
+                self._dynamic_attrs[_child_name_transform(model._label)] = model
+        else:
+            raise ValueError('Invalid element type: Trying to add an element of type {} to a container.'.format(type(model)))
 
     def __getattr__(self, name: str) -> 'Component':
         return self._dynamic_attrs[name]
@@ -472,6 +569,10 @@ class Component(DslElementRelationOverrides[
     def destinations(self) -> List[DslElement]:
         return self._destinations
 
+    @property
+    def relationships(self) -> Set[_Relationship]:
+        return self._relationships
+
     @property
     def tags(self) -> Set[str]:
         return self._tags
@@ -481,6 +582,7 @@ class Component(DslElementRelationOverrides[
         self._parent: Optional[Container] = None
         self._sources: List[DslElement] = []
         self._destinations: List[DslElement] = []
+        self._relationships: Set[_Relationship] = set()
         self._tags = {'Element', 'Component'}.union(tags)
         self._label: Optional[str] = None
         self.model.id = GenerateId.for_element()
@@ -491,8 +593,20 @@ class Component(DslElementRelationOverrides[
         self.model.tags = ','.join(self._tags)
         self.model.properties = properties
 
+        container = _current_container.get()
+        if container is not None:
+            container.add_component(self)
+            container._add_dynamic_attr(self.model.name, self)
+
+        stack = _current_group_stack.get()
+        if stack:
+            stack[-1].add_element(self)
+
     def labeled(self, label: str) -> 'Component':
         self._label = label
+        container = _current_container.get()
+        if container is not None:
+            container._add_dynamic_attr(label, self)
         return self
 
 class Group:
@@ -500,27 +614,60 @@ class Group:
     def __init__(
         self,
         name: str,
-        *elements: Union[
-            Person,
-            SoftwareSystem,
-            _FluentRelationship[SoftwareSystem],
-            _FluentRelationship[Container],
-    ]) -> None:
+        workspace: Optional[Workspace]=None,
+    ) -> None:
+
+        if not workspace:
+            workspace = _current_workspace.get()
+            if workspace is not None:
+                self._group_separator = workspace._group_separator
+
+        self._group_separator = workspace._group_separator
         self._name = name
-        self._elements = elements
 
-class _FluentSink(DslFluentSink):
+        if len(self._group_separator) > 1:
+            raise ValueError('Group separator must be a single character.')
 
-    def __init__(self, workspace: Workspace) -> None:
-        self._workspace = workspace
+        if self._group_separator in self._name:
+            raise ValueError('Group name cannot contain the group separator.')
 
-    def to_json(self, path: str) -> None:
-        from buildzr.sinks.json_sink import JsonSink, JsonSinkConfig
-        sink = JsonSink()
-        sink.write(workspace=self._workspace.model, config=JsonSinkConfig(path=path))
+        stack = _current_group_stack.get()
+        new_stack = stack.copy()
+        new_stack.extend([self])
 
-    def get_workspace(self) -> Workspace:
-        return self._workspace
+        self._full_name = self._group_separator.join([group._name for group in new_stack])
+
+    def full_name(self) -> str:
+        return self._full_name
+
+    def add_element(
+        self,
+        model: Union[
+            'Person',
+            'SoftwareSystem',
+            'Container',
+            'Component',
+        ]
+    ) -> None:
+
+
+        model.model.group = self._full_name
+
+    def __enter__(self) -> Self:
+        stack = _current_group_stack.get() # stack: a/b
+        stack.extend([self]) # stack: a/b -> a/b/self
+        self._token = _current_group_stack.set(stack)
+        return self
+
+    def __exit__(
+        self,
+        exc_type: Optional[Type[BaseException]],
+        exc_value: Optional[BaseException],
+        traceback: Optional[Any]
+    ) -> None:
+        stack = _current_group_stack.get()
+        stack.pop() # stack: a/b/self -> a/b
+        _current_group_stack.reset(self._token)
 
 _RankDirection = Literal['tb', 'bt', 'lr', 'rl']
 
@@ -607,10 +754,10 @@ class SystemLandscapeView(DslViewElement):
         description: str,
         auto_layout: _AutoLayout='tb',
         title: Optional[str]=None,
-        include_elements: List[Callable[[Workspace, Element], bool]]=[],
-        exclude_elements: List[Callable[[Workspace, Element], bool]]=[],
-        include_relationships: List[Callable[[Workspace, Relationship], bool]]=[],
-        exclude_relationships: List[Callable[[Workspace, Relationship], bool]]=[],
+        include_elements: List[Union[DslElement, Callable[[Workspace, Element], bool]]]=[],
+        exclude_elements: List[Union[DslElement, Callable[[Workspace, Element], bool]]]=[],
+        include_relationships: List[Union[DslElement, Callable[[Workspace, Relationship], bool]]]=[],
+        exclude_relationships: List[Union[DslElement, Callable[[Workspace, Relationship], bool]]]=[],
         properties: Optional[Dict[str, str]]=None,
     ) -> None:
         self._m = buildzr.models.SystemLandscapeView()
@@ -628,6 +775,10 @@ class SystemLandscapeView(DslViewElement):
         self._include_relationships = include_relationships
         self._exclude_relationships = exclude_relationships
 
+        workspace = _current_workspace.get()
+        if workspace is not None:
+            workspace.apply_views(self)
+
     def _on_added(self) -> None:
 
         from buildzr.dsl.expression import Expression, Element, Relationship
@@ -642,17 +793,17 @@ class SystemLandscapeView(DslViewElement):
 
         workspace = self._parent._parent
 
-        include_view_elements_filter: List[Callable[[Workspace, Element], bool]] = [
+        include_view_elements_filter: List[Union[DslElement, Callable[[Workspace, Element], bool]]] = [
             lambda w, e: e.type == Person,
             lambda w, e: e.type == SoftwareSystem
         ]
 
-        exclude_view_elements_filter: List[Callable[[Workspace, Element], bool]] = [
+        exclude_view_elements_filter: List[Union[DslElement, Callable[[Workspace, Element], bool]]] = [
             lambda w, e: e.type == Container,
             lambda w, e: e.type == Component,
         ]
 
-        include_view_relationships_filter: List[Callable[[Workspace, Relationship], bool]] = [
+        include_view_relationships_filter: List[Union[DslElement, Callable[[Workspace, Relationship], bool]]] = [
             lambda w, r: r.source.type == Person,
             lambda w, r: r.source.type == SoftwareSystem,
             lambda w, r: r.destination.type == Person,
@@ -703,15 +854,15 @@ class SystemContextView(DslViewElement):
 
     def __init__(
         self,
-        software_system_selector: Callable[[Workspace], SoftwareSystem],
+        software_system_selector: Union[SoftwareSystem, Callable[[Workspace], SoftwareSystem]],
         key: str,
         description: str,
         auto_layout: _AutoLayout='tb',
         title: Optional[str]=None,
-        include_elements: List[Callable[[Workspace, Element], bool]]=[],
-        exclude_elements: List[Callable[[Workspace, Element], bool]]=[],
-        include_relationships: List[Callable[[Workspace, Relationship], bool]]=[],
-        exclude_relationships: List[Callable[[Workspace, Relationship], bool]]=[],
+        include_elements: List[Union[DslElement, Callable[[Workspace, Element], bool]]]=[],
+        exclude_elements: List[Union[DslElement, Callable[[Workspace, Element], bool]]]=[],
+        include_relationships: List[Union[DslElement, Callable[[Workspace, Relationship], bool]]]=[],
+        exclude_relationships: List[Union[DslElement, Callable[[Workspace, Relationship], bool]]]=[],
         properties: Optional[Dict[str, str]]=None,
     ) -> None:
         self._m = buildzr.models.SystemContextView()
@@ -730,20 +881,27 @@ class SystemContextView(DslViewElement):
         self._include_relationships = include_relationships
         self._exclude_relationships = exclude_relationships
 
+        workspace = _current_workspace.get()
+        if workspace is not None:
+            workspace.apply_views(self)
+
     def _on_added(self) -> None:
 
         from buildzr.dsl.expression import Expression, Element, Relationship
         from buildzr.models import ElementView, RelationshipView
 
-        software_system = self._selector(self._parent._parent)
+        if isinstance(self._selector, SoftwareSystem):
+            software_system = self._selector
+        else:
+            software_system = self._selector(self._parent._parent)
         self._m.softwareSystemId = software_system.model.id
-        view_elements_filter: List[Callable[[Workspace, Element], bool]] = [
+        view_elements_filter: List[Union[DslElement, Callable[[Workspace, Element], bool]]] = [
             lambda w, e: e == software_system,
             lambda w, e: software_system.model.id in e.sources.ids,
             lambda w, e: software_system.model.id in e.destinations.ids,
         ]
 
-        view_relationships_filter: List[Callable[[Workspace, Relationship], bool]] = [
+        view_relationships_filter: List[Union[DslElement, Callable[[Workspace, Relationship], bool]]] = [
             lambda w, r: software_system == r.source,
             lambda w, r: software_system == r.destination,
         ]
@@ -789,15 +947,15 @@ class ContainerView(DslViewElement):
 
     def __init__(
         self,
-        software_system_selector: Callable[[Workspace], SoftwareSystem],
+        software_system_selector: Union[SoftwareSystem, Callable[[Workspace], SoftwareSystem]],
         key: str,
         description: str,
         auto_layout: _AutoLayout='tb',
         title: Optional[str]=None,
-        include_elements: List[Callable[[Workspace, Element], bool]]=[],
-        exclude_elements: List[Callable[[Workspace, Element], bool]]=[],
-        include_relationships: List[Callable[[Workspace, Relationship], bool]]=[],
-        exclude_relationships: List[Callable[[Workspace, Relationship], bool]]=[],
+        include_elements: List[Union[DslElement, Callable[[Workspace, Element], bool]]]=[],
+        exclude_elements: List[Union[DslElement, Callable[[Workspace, Element], bool]]]=[],
+        include_relationships: List[Union[DslElement, Callable[[Workspace, Relationship], bool]]]=[],
+        exclude_relationships: List[Union[DslElement, Callable[[Workspace, Relationship], bool]]]=[],
         properties: Optional[Dict[str, str]]=None,
     ) -> None:
         self._m = buildzr.models.ContainerView()
@@ -816,23 +974,30 @@ class ContainerView(DslViewElement):
         self._include_relationships = include_relationships
         self._exclude_relationships = exclude_relationships
 
+        workspace = _current_workspace.get()
+        if workspace is not None:
+            workspace.apply_views(self)
+
     def _on_added(self) -> None:
 
         from buildzr.dsl.expression import Expression, Element, Relationship
         from buildzr.models import ElementView, RelationshipView
 
-        software_system = self._selector(self._parent._parent)
+        if isinstance(self._selector, SoftwareSystem):
+            software_system = self._selector
+        else:
+            software_system = self._selector(self._parent._parent)
         self._m.softwareSystemId = software_system.model.id
 
         container_ids = { container.model.id for container in software_system.children}
 
-        view_elements_filter: List[Callable[[Workspace, Element], bool]] = [
+        view_elements_filter: List[Union[DslElement, Callable[[Workspace, Element], bool]]] = [
             lambda w, e: e.parent == software_system,
             lambda w, e: any(container_ids.intersection({ id for id in e.sources.ids })),
             lambda w, e: any(container_ids.intersection({ id for id in e.destinations.ids })),
         ]
 
-        view_relationships_filter: List[Callable[[Workspace, Relationship], bool]] = [
+        view_relationships_filter: List[Union[DslElement, Callable[[Workspace, Relationship], bool]]] = [
             lambda w, r: software_system == r.source.parent,
             lambda w, r: software_system == r.destination.parent,
         ]
@@ -878,15 +1043,15 @@ class ComponentView(DslViewElement):
 
     def __init__(
         self,
-        container_selector: Callable[[Workspace], Container],
+        container_selector: Union[Container, Callable[[Workspace], Container]],
         key: str,
         description: str,
         auto_layout: _AutoLayout='tb',
         title: Optional[str]=None,
-        include_elements: List[Callable[[Workspace, Element], bool]]=[],
-        exclude_elements: List[Callable[[Workspace, Element], bool]]=[],
-        include_relationships: List[Callable[[Workspace, Relationship], bool]]=[],
-        exclude_relationships: List[Callable[[Workspace, Relationship], bool]]=[],
+        include_elements: List[Union[DslElement, Callable[[Workspace, Element], bool]]]=[],
+        exclude_elements: List[Union[DslElement, Callable[[Workspace, Element], bool]]]=[],
+        include_relationships: List[Union[DslElement, Callable[[Workspace, Relationship], bool]]]=[],
+        exclude_relationships: List[Union[DslElement, Callable[[Workspace, Relationship], bool]]]=[],
         properties: Optional[Dict[str, str]]=None,
     ) -> None:
         self._m = buildzr.models.ComponentView()
@@ -905,23 +1070,30 @@ class ComponentView(DslViewElement):
         self._include_relationships = include_relationships
         self._exclude_relationships = exclude_relationships
 
+        workspace = _current_workspace.get()
+        if workspace is not None:
+            workspace.apply_views(self)
+
     def _on_added(self) -> None:
 
         from buildzr.dsl.expression import Expression, Element, Relationship
         from buildzr.models import ElementView, RelationshipView
 
-        container = self._selector(self._parent._parent)
+        if isinstance(self._selector, Container):
+            container = self._selector
+        else:
+            container = self._selector(self._parent._parent)
         self._m.containerId = container.model.id
 
         component_ids = { component.model.id for component in container.children }
 
-        view_elements_filter: List[Callable[[Workspace, Element], bool]] = [
+        view_elements_filter: List[Union[DslElement, Callable[[Workspace, Element], bool]]] = [
             lambda w, e: e.parent == container,
             lambda w, e: any(component_ids.intersection({ id for id in e.sources.ids })),
             lambda w, e: any(component_ids.intersection({ id for id in e.destinations.ids })),
         ]
 
-        view_relationships_filter: List[Callable[[Workspace, Relationship], bool]] = [
+        view_relationships_filter: List[Union[DslElement, Callable[[Workspace, Relationship], bool]]] = [
             lambda w, r: container == r.source.parent,
             lambda w, r: container == r.destination.parent,
         ]
@@ -955,6 +1127,9 @@ class ComponentView(DslViewElement):
 
 class Views(DslViewsElement):
 
+    # TODO: Make this view a "hidden" class -- it's not a "first class citizen"
+    # in buildzr DSL.
+
     @property
     def model(self) -> buildzr.models.Views:
         return self._m
@@ -971,10 +1146,10 @@ class Views(DslViewsElement):
         self._parent = workspace
         self._parent._m.views = self._m
 
-    def contains(
+    def add_views(
         self,
         *views: DslViewElement
-    ) -> _FluentSink:
+    ) -> None:
 
         for view in views:
             if isinstance(view, SystemLandscapeView):
@@ -1008,10 +1183,282 @@ class Views(DslViewsElement):
             else:
                 raise NotImplementedError("The view {0} is currently not supported", type(view))
 
-        return _FluentSink(self._parent)
-
     def get_workspace(self) -> Workspace:
         """
         Get the `Workspace` which contain this views definition.
         """
-        return self._parent
+        return self._parent
+
+class StyleElements:
+
+    from buildzr.dsl.expression import Element
+
+    Shapes = Union[
+        Literal['Box'],
+        Literal['RoundedBox'],
+        Literal['Circle'],
+        Literal['Ellipse'],
+        Literal['Hexagon'],
+        Literal['Cylinder'],
+        Literal['Pipe'],
+        Literal['Person'],
+        Literal['Robot'],
+        Literal['Folder'],
+        Literal['WebBrowser'],
+        Literal['MobileDevicePortrait'],
+        Literal['MobileDeviceLandscape'],
+        Literal['Component'],
+    ]
+
+    @property
+    def model(self) -> List[buildzr.models.ElementStyle]:
+        return self._m
+
+    @property
+    def parent(self) -> Optional[Workspace]:
+        return self._parent
+
+    # TODO: Validate arguments with pydantic.
+    def __init__(
+            self,
+            on: List[Union[
+                DslElement,
+                Group,
+                Callable[[Workspace, Element], bool],
+                Type[Union['Person', 'SoftwareSystem', 'Container', 'Component']],
+                str
+            ]],
+            shape: Optional[Shapes]=None,
+            icon: Optional[str]=None,
+            width: Optional[int]=None,
+            height: Optional[int]=None,
+            background: Optional[Union['str', Tuple[int, int, int], Color]]=None,
+            color: Optional[Union['str', Tuple[int, int, int], Color]]=None,
+            stroke: Optional[Union[str, Tuple[int, int, int], Color]]=None,
+            stroke_width: Optional[int]=None,
+            font_size: Optional[int]=None,
+            border: Optional[Literal['solid', 'dashed', 'dotted']]=None,
+            opacity: Optional[int]=None,
+            metadata: Optional[bool]=None,
+            description: Optional[bool]=None,
+    ) -> None:
+
+        # How the tag is populated depends on each element type in the
+        # `elemenets`.
+        # - If the element is a `DslElement`, then we create a unique tag
+        #   specifically to help the stylizer identify that specific element.
+        #   For example, if the element has an id `3`, then we should create a
+        #   tag, say, `style-element-3`.
+        # - If the element is a `Group`, then we simply make create the tag
+        #   based on the group name and its nested path. For example,
+        #   `Group:Company 1/Department 1`.
+        # - If the element is a `Callable[[Workspace, Element], bool]`, we just
+        #   run the function to filter out all the elements that matches the
+        #   description, and create a unique tag for all of the filtered
+        #   elements.
+        # - If the element is a `Type[Union['Person', 'SoftwareSystem', 'Container', 'Component']]`,
+        #   we create a tag based on the class name. This is based on the fact
+        #   that the default tag for each element is the element's type.
+        # - If the element is a `str`, we just use the string as the tag.
+        #   This is useful for when you want to apply a style to all elements
+        #   with a specific tag, just like in the original Structurizr DSL.
+        #
+        # Note that a new `buildzr.models.ElementStyle` is created for each
+        # item, not for each of `StyleElements` instance. This makes the styling
+        # makes more concise and flexible.
+
+        from buildzr.dsl.expression import Element
+        from uuid import uuid4
+
+        if background:
+            assert Color.is_valid_color(background), "Invalid background color: {}".format(background)
+        if color:
+            assert Color.is_valid_color(color), "Invalid color: {}".format(color)
+        if stroke:
+            assert Color.is_valid_color(stroke), "Invalid stroke color: {}".format(stroke)
+
+        self._m: List[buildzr.models.ElementStyle] = []
+        self._parent: Optional[Workspace] = None
+
+        workspace = _current_workspace.get()
+        if workspace is not None:
+            self._parent = workspace
+
+        self._elements = on
+
+        border_enum: Dict[str, buildzr.models.Border] = {
+            'solid': buildzr.models.Border.Solid,
+            'dashed': buildzr.models.Border.Dashed,
+            'dotted': buildzr.models.Border.Dotted,
+        }
+
+        shape_enum: Dict[str, buildzr.models.Shape] = {
+            'Box': buildzr.models.Shape.Box,
+            'RoundedBox': buildzr.models.Shape.RoundedBox,
+            'Circle': buildzr.models.Shape.Circle,
+            'Ellipse': buildzr.models.Shape.Ellipse,
+            'Hexagon': buildzr.models.Shape.Hexagon,
+            'Cylinder': buildzr.models.Shape.Cylinder,
+            'Pipe': buildzr.models.Shape.Pipe,
+            'Person': buildzr.models.Shape.Person,
+            'Robot': buildzr.models.Shape.Robot,
+            'Folder': buildzr.models.Shape.Folder,
+            'WebBrowser': buildzr.models.Shape.WebBrowser,
+            'MobileDevicePortrait': buildzr.models.Shape.MobileDevicePortrait,
+            'MobileDeviceLandscape': buildzr.models.Shape.MobileDeviceLandscape,
+            'Component': buildzr.models.Shape.Component,
+        }
+
+        # A single unique element to be applied to all elements
+        # affected by this style.
+        element_tag = "buildzr-styleelements-{}".format(uuid4().hex)
+
+        for element in self._elements:
+
+            element_style = buildzr.models.ElementStyle()
+            element_style.shape = shape_enum[shape] if shape else None
+            element_style.icon = icon
+            element_style.width = width
+            element_style.height = height
+            element_style.background = Color(background).to_hex() if background else None
+            element_style.color = Color(color).to_hex() if color else None
+            element_style.stroke = Color(stroke).to_hex() if stroke else None
+            element_style.strokeWidth = stroke_width
+            element_style.fontSize = font_size
+            element_style.border = border_enum[border] if border else None
+            element_style.opacity = opacity
+            element_style.metadata = metadata
+            element_style.description = description
+
+            if isinstance(element, DslElement) and not isinstance(element.model, buildzr.models.Workspace):
+                element_style.tag = element_tag
+                element.add_tags(element_tag)
+            elif isinstance(element, Group):
+                element_style.tag = f"Group:{element.full_name()}"
+            elif isinstance(element, type):
+                element_style.tag = f"{element.__name__}"
+            elif isinstance(element, str):
+                element_style.tag = element
+            elif callable(element):
+                from buildzr.dsl.expression import Element, Expression
+                if self._parent:
+                    matched_elems = Expression(include_elements=[element]).elements(self._parent)
+                    for e in matched_elems:
+                        element_style.tag = element_tag
+                        e.add_tags(element_tag)
+                else:
+                    raise ValueError("Cannot use callable to select elements to style without a Workspace.")
+            self._m.append(element_style)
+
+        workspace = _current_workspace.get()
+        if workspace is not None:
+            workspace.apply_style(self)
+
+class StyleRelationships:
+
+    from buildzr.dsl.expression import Relationship
+
+    @property
+    def model(self) -> List[buildzr.models.RelationshipStyle]:
+        return self._m
+
+    @property
+    def parent(self) -> Optional[Workspace]:
+        return self._parent
+
+    def __init__(
+        self,
+        on: Optional[List[Union[
+            DslRelationship,
+            Group,
+            Callable[[Workspace, Relationship], bool],
+            str
+        ]]]=None,
+        thickness: Optional[int]=None,
+        color: Optional[Union[str, Tuple[int, int, int], Color]]=None,
+        routing: Optional[Literal['Direct', 'Orthogonal', 'Curved']]=None,
+        font_size: Optional[int]=None,
+        width: Optional[int]=None,
+        dashed: Optional[bool]=None,
+        position: Optional[int]=None,
+        opacity: Optional[int]=None,
+    ) -> None:
+
+        from uuid import uuid4
+
+        if color is not None:
+            assert Color.is_valid_color(color), "Invalid color: {}".format(color)
+
+        routing_enum: Dict[str, buildzr.models.Routing1] = {
+            'Direct': buildzr.models.Routing1.Direct,
+            'Orthogonal': buildzr.models.Routing1.Orthogonal,
+            'Curved': buildzr.models.Routing1.Curved,
+        }
+
+        self._m: List[buildzr.models.RelationshipStyle] = []
+        self._parent: Optional[Workspace] = None
+
+        workspace = _current_workspace.get()
+        if workspace is not None:
+            self._parent = workspace
+
+        # A single unique tag to be applied to all relationships
+        # affected by this style.
+        relation_tag = "buildzr-stylerelationships-{}".format(uuid4().hex)
+
+        if on is None:
+            self._m.append(buildzr.models.RelationshipStyle(
+                thickness=thickness,
+                color=Color(color).to_hex() if color else None,
+                routing=routing_enum[routing] if routing else None,
+                fontSize=font_size,
+                width=width,
+                dashed=dashed,
+                position=position,
+                opacity=opacity,
+                tag="Relationship",
+            ))
+        else:
+            for relationship in on:
+
+                relationship_style = buildzr.models.RelationshipStyle()
+                relationship_style.thickness = thickness
+                relationship_style.color = Color(color).to_hex() if color else None
+                relationship_style.routing = routing_enum[routing] if routing else None
+                relationship_style.fontSize = font_size
+                relationship_style.width = width
+                relationship_style.dashed = dashed
+                relationship_style.position = position
+                relationship_style.opacity = opacity
+
+                if isinstance(relationship, DslRelationship):
+                    relationship.add_tags(relation_tag)
+                    relationship_style.tag = relation_tag
+                elif isinstance(relationship, Group):
+                    from buildzr.dsl.expression import Expression
+                    if self._parent:
+                        rels = Expression(include_relationships=[
+                            lambda w, r: r.source.group == relationship.full_name() and \
+                                         r.destination.group == relationship.full_name()
+                        ]).relationships(self._parent)
+                        for r in rels:
+                            r.add_tags(relation_tag)
+                        relationship_style.tag = relation_tag
+                    else:
+                        raise ValueError("Cannot use callable to select elements to style without a Workspace.")
+                elif isinstance(relationship, str):
+                    relationship_style.tag = relationship
+                elif callable(relationship):
+                    from buildzr.dsl.expression import Expression
+                    if self._parent:
+                        matched_rels = Expression(include_relationships=[relationship]).relationships(self._parent)
+                        for matched_rel in matched_rels:
+                            matched_rel.add_tags(relation_tag)
+                            relationship_style.tag = relation_tag
+                    else:
+                        raise ValueError("Cannot use callable to select elements to style without a Workspace.")
+                self._m.append(relationship_style)
+
+        workspace = _current_workspace.get()
+        if workspace is not None:
+            workspace.apply_style(self)