nortl 1.4.0__py3-none-any.whl

nortl/core/renderers/operations/base.py

@@ -0,0 +1,111 @@
+"""Base classes for renderers."""
+
+from abc import ABCMeta, abstractmethod
+from typing import Optional, Protocol, Union
+
+__all__ = [
+    'SingleRenderer',
+    'SliceRenderer',
+    'TwoSideRenderer',
+]
+
+
+class Renderable(Protocol):
+    @property
+    def is_primitive(self) -> bool: ...
+
+    def render(self, target: Optional[str] = None) -> str: ...
+
+
+class SingleContainerProto(Protocol):
+    @property
+    def value(self) -> Renderable: ...
+
+
+class TwoSideContainerProto(Protocol):
+    @property
+    def left(self) -> Renderable: ...
+
+    @property
+    def right(self) -> Renderable: ...
+
+
+class SliceContainerProto(Protocol):
+    @property
+    def value(self) -> Renderable: ...
+
+    @property
+    def index(self) -> Union[int, slice]: ...
+
+
+class RendererABC(metaclass=ABCMeta):
+    """Abstract baseclass for renderers."""
+
+    @abstractmethod
+    def __call__(self, target: Optional[str] = None) -> str:
+        """Render value to target language.
+
+        Arguments:
+            target: Target language.
+        """
+
+
+class SingleRenderer(RendererABC):
+    """Base class for renderers for operations with a single value."""
+
+    def __init__(self, container: SingleContainerProto) -> None:
+        """Initialize the renderer.
+
+        Arguments:
+            container: Operation wrapper container for the renderer.
+        """
+        self.container = container
+
+    @property
+    def value(self) -> Renderable:
+        """Value to which the operation is applied."""
+        return self.container.value
+
+
+class TwoSideRenderer(RendererABC):
+    """Base class for renderers for operations with two values."""
+
+    def __init__(self, container: TwoSideContainerProto) -> None:
+        """Initialize the renderer.
+
+        Arguments:
+            container: Operation wrapper container for the renderer.
+        """
+        self.container = container
+
+    @property
+    def left(self) -> Renderable:
+        """Left or first value for the operation."""
+        return self.container.left
+
+    @property
+    def right(self) -> Renderable:
+        """Right or second value for the operation."""
+        return self.container.right
+
+
+class SliceRenderer(RendererABC):
+    """Base class for renderers for slicing operations."""
+
+    def __init__(self, container: SliceContainerProto) -> None:
+        """Initialize the renderer.
+
+        Arguments:
+            container: Operation wrapper container for the renderer.
+        """
+        self.container = container
+
+    @property
+    def value(self) -> Renderable:
+        """Value to which the slice is applied."""
+        return self.container.value
+
+    @property
+    def index(self) -> Union[int, slice]:
+        """Slicing index."""
+        return self.container.index

nortl/core/renderers/operations/comparison.py

@@ -0,0 +1,44 @@
+"""Comparison operations."""
+
+from typing import Optional
+
+from nortl.core.renderers.operations.base import TwoSideRenderer
+
+__all__ = [
+    'Equality',
+    'Greater',
+    'GreaterOrEqual',
+    'Less',
+    'LessOrEqual',
+    'Unequality',
+]
+
+
+class Equality(TwoSideRenderer):
+    def __call__(self, target: Optional[str] = None) -> str:
+        return f'({self.left} == {self.right})'
+
+
+class Unequality(TwoSideRenderer):
+    def __call__(self, target: Optional[str] = None) -> str:
+        return f'({self.left} != {self.right})'
+
+
+class Less(TwoSideRenderer):
+    def __call__(self, target: Optional[str] = None) -> str:
+        return f'({self.left} < {self.right})'
+
+
+class LessOrEqual(TwoSideRenderer):
+    def __call__(self, target: Optional[str] = None) -> str:
+        return f'({self.left} <= {self.right})'
+
+
+class Greater(TwoSideRenderer):
+    def __call__(self, target: Optional[str] = None) -> str:
+        return f'({self.left} > {self.right})'
+
+
+class GreaterOrEqual(TwoSideRenderer):
+    def __call__(self, target: Optional[str] = None) -> str:
+        return f'({self.left} >= {self.right})'

nortl/core/renderers/operations/logic.py

@@ -0,0 +1,38 @@
+"""Logic operations."""
+
+from typing import Optional
+
+from nortl.core.renderers.operations.base import TwoSideRenderer
+
+__all__ = [
+    'And',
+    'ExclusiveOr',
+    'LeftShift',
+    'Or',
+    'RightShift',
+]
+
+
+class And(TwoSideRenderer):
+    def __call__(self, target: Optional[str] = None) -> str:
+        return f'({self.left} & {self.right})'
+
+
+class Or(TwoSideRenderer):
+    def __call__(self, target: Optional[str] = None) -> str:
+        return f'({self.left} | {self.right})'
+
+
+class ExclusiveOr(TwoSideRenderer):
+    def __call__(self, target: Optional[str] = None) -> str:
+        return f'({self.left} ^ {self.right})'
+
+
+class LeftShift(TwoSideRenderer):
+    def __call__(self, target: Optional[str] = None) -> str:
+        return f'({self.left} << {self.right})'
+
+
+class RightShift(TwoSideRenderer):
+    def __call__(self, target: Optional[str] = None) -> str:
+        return f'({self.left} >> {self.right})'

nortl/core/renderers/operations/misc.py

@@ -0,0 +1,26 @@
+"""Miscellaneous operations."""
+
+from typing import Optional
+
+from nortl.core.renderers.operations.base import SingleRenderer
+
+__all__ = [
+    'Inversion',
+    'Negative',
+    'Positive',
+]
+
+
+class Negative(SingleRenderer):
+    def __call__(self, target: Optional[str] = None) -> str:
+        return f'-{self.value}'
+
+
+class Positive(SingleRenderer):
+    def __call__(self, target: Optional[str] = None) -> str:
+        return f'+{self.value}'
+
+
+class Inversion(SingleRenderer):
+    def __call__(self, target: Optional[str] = None) -> str:
+        return f'~({self.value})'

nortl/core/renderers/operations/slice.py

@@ -0,0 +1,30 @@
+"""Contant value."""
+
+from typing import Optional
+
+from nortl.core.renderers.operations.base import SliceRenderer
+
+__all__ = [
+    'Slice',
+]
+
+
+class Slice(SliceRenderer):
+    def __call__(self, target: Optional[str] = None) -> str:
+        if self.value.is_primitive:
+            if isinstance(self.index, int):
+                return f'{self.value}[{self.index}]'
+            else:
+                return f'{self.value}[{self.index.start}:{self.index.stop}]'
+        else:
+            if isinstance(self.index, int):
+                mask = 1
+                offset = self.index
+            else:
+                mask = 2 ** (max(self.index.start, self.index.stop) - min(self.index.start, self.index.stop) + 1) - 1
+                offset = self.index.stop
+
+            if offset != 0:
+                return f'(({self.value} >> {offset}) & {mask})'
+            else:
+                return f'({self.value} & {mask})'