stormlibpp 0.2.0__tar.gz → 0.3.0__tar.gz

{stormlibpp-0.2.0 → stormlibpp-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: stormlibpp
-Version: 0.2.0
+Version: 0.3.0
 Summary: The stormlibpp Python package
 Author: John Gorman
 License: MIT License

{stormlibpp-0.2.0 → stormlibpp-0.3.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "stormlibpp"
-version = "0.2.0"
+version = "0.3.0"
 description = "The stormlibpp Python package"
 readme = "README.md"
 requires-python = ">=3.11"

{stormlibpp-0.2.0 → stormlibpp-0.3.0}/src/stormlibpp/__init__.py

@@ -29,9 +29,10 @@ are briefly described below:
 
 """
 
-__version__ = "0.2.0"
+__version__ = "0.3.0"
 
 from . import errors
 from . import utils
+from .node import StormNode
 from .stormpkg import StormPkg
 from .telepath import (genDefaultTelepathRetn, TelepathRetn)

stormlibpp-0.3.0/src/stormlibpp/node.py

@@ -0,0 +1,197 @@
+"""Work with storm:node objects in Python."""
+
+
+from types import SimpleNamespace
+from typing import Any, Self, TypedDict
+
+
+NodeForm = str
+"""A valid syn:form value."""
+
+
+class NodeVals(TypedDict):
+    """The items a Node can have in the second part of packed NodeTuple."""
+
+    iden: str
+    nodedata: dict[str, Any]
+    props: dict[str, Any]
+    tags: dict[str, Any]
+    tagprops: dict[str, Any]
+
+
+NodeDef = tuple[NodeForm, str]
+"""A nodes definition, the node's form and primary value."""
+
+NodeTuple = tuple[NodeDef, NodeVals]
+"""A packed node, this is what get's sent from Storm to a Telepath endpoint.
+
+Or what get's returned from a Cortex's Python APIs.
+"""
+
+
+class ItemContainer:
+    """Hold key/value items in a SimpleNamespace.
+
+    Keys must be strings.
+
+    Supports ``obj['item']`` (and ``obj['item'] = 'val'``) notation.
+
+    When "getting" an item with ``__getitem__``, that doesn't exist in the
+    container, ``None`` is returned instead of raising an exception.
+
+    Calling ``dir`` on this object will only return names for items this object
+    "holds" instead of all parts of this object.
+
+    Supports checking if an item is "held" via the ``in`` operator.
+
+    Supports iteration of items in the SimpleNamespace. Each iteration returns
+    a tuple of the item name followed by the item value.
+
+    Implements only magic methods, and all of them operate on the underlying
+    SimpleNamespace. To convert this object to a ``dict`` of the items it holds,
+    call ``vars`` on an instance.
+    """
+
+    def __init__(self, /, **kwargs) -> None:
+        self.__ns = SimpleNamespace(**kwargs)
+    
+    def __contains__(self, __name: str) -> bool:
+        return __name in dir(self)
+
+    @property
+    def __dict__(self):
+        return self.__ns.__dict__
+
+    def __dir__(self) -> list[str]:
+        return [val for val in dir(self.__ns) if not val.startswith("_")]
+
+    def __iter__(self) -> Any:
+        for item in dir(self):
+            yield (item, self[item])
+
+    def __getitem__(self, __name: str) -> Any:
+        return getattr(self.__ns, __name, None)
+
+    def __repr__(self) -> str:
+        return repr(self.__ns).replace("namespace", self.__class__.__name__)
+
+    def __setitem__(self, __name: str, __value: str) -> None:
+        setattr(self.__ns, __name, __value)
+
+
+class Props(ItemContainer):
+    """Properties of a StormNode."""
+
+
+class Tags(ItemContainer):
+    """Tags of a StormNode."""
+
+
+
+class StormNode:
+    """A storm:node Storm object that is in a Python runtime.
+
+    It supports "unpacking" the node into this object, edits to the object, and
+    repacking of the node to be sent back to Storm.
+
+    This node can be created purely from Python code rather than a packed
+    ``storm:node`` object. Use the ``__init__`` directly instead of ``unpack``.
+    This allows the creation of a new node in Python that can be passed back to
+    Storm.
+
+    The intent is to represent an object that can be read from and written back
+    to a Cortex. It isn't meant to provide the same API that a ``storm:node``
+    has in Storm.
+    """
+
+    def __init__(
+        self,
+        form: NodeForm,
+        value: Any,
+        /,
+        iden: str = "",
+        tags: dict = {},
+        props: dict = {},
+        nodedata: dict = {},
+        tagprops: dict = {},
+        **kwargs,
+    ) -> None:
+
+        self._form = form
+        self._value = value
+
+        self._tags = Props(**tags)
+        self._props = Tags(**props)
+
+        self.iden = iden
+        self.nodedata = nodedata
+        self.tagprops = tagprops
+
+        # Not really sure if this is needed, but saving it for now.
+        self._xtras = kwargs
+
+    @property
+    def form(self) -> str:
+        """The form of this Node."""
+
+        return self._form
+
+    @property
+    def value(self) -> str:
+        """The value of this Node."""
+
+        return self._value
+
+    @property
+    def tags(self):
+        """The tags of this Node."""
+
+        return self._tags
+
+    @property
+    def props(self):
+        """The properties of this Node."""
+
+        return self._props
+
+    @property
+    def nodevals(self):
+        """The NodeVals dict this Node would have in a NodeTuple."""
+
+        return NodeVals(
+            iden=self.iden,
+            tagprops=self.tagprops,
+            nodedata=self.nodedata,
+            props=vars(self.props),
+            tags=vars(self.tags),
+        )
+
+    @classmethod
+    def unpack(cls, packedtup: NodeTuple) -> Self:
+        form, name = packedtup[0]
+        vals = NodeVals(**packedtup[1])
+        return cls(
+            form,
+            name,
+            **vals
+        )
+
+    def pack(self) -> NodeTuple:
+        return ((self.form, self.value), self.nodevals)
+
+    def addTag(self, tag, timestamps: tuple = (None, None)) -> None:
+        if tag in self._tags and timestamps != (None, None) and self._tags[tag] != timestamps:
+            self._tags[tag] = timestamps
+        elif tag not in self._tags:
+            self._tags[tag] = timestamps
+
+    def addTags(self, tags, timestamps: tuple = (None, None)) -> None:
+        for tag in tags:
+            self.addTag(tag, timestamps=timestamps)
+
+    def addProp(self, propname: str, propval: Any) -> None:
+        self._props[propname] = propval
+
+    def addProps(self, props: dict[str, Any]) -> None:
+        for propname, propval in props.items():
+            self._props[propname] = propval

{stormlibpp-0.2.0 → stormlibpp-0.3.0}/src/stormlibpp.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: stormlibpp
-Version: 0.2.0
+Version: 0.3.0
 Summary: The stormlibpp Python package
 Author: John Gorman
 License: MIT License

{stormlibpp-0.2.0 → stormlibpp-0.3.0}/src/stormlibpp.egg-info/SOURCES.txt

@@ -12,6 +12,7 @@ src/stormlibpp.egg-info/SOURCES.txt
 src/stormlibpp.egg-info/dependency_links.txt
 src/stormlibpp.egg-info/requires.txt
 src/stormlibpp.egg-info/top_level.txt
+tests/test_node.py
 tests/test_stormpkg.py
 tests/test_telepath.py
 tests/test_utils.py

stormlibpp-0.3.0/tests/test_node.py

@@ -0,0 +1,43 @@
+"""Tests for stormlibpp.node."""
+
+
+import stormlibpp
+
+
+PACKED_NODE = (('it:app:yara:rule', '5d0292d99a7da59a3a119e193f140143'), {'iden': '57ce731580ed6976b608e87dfc7f2ece81790f2cb8cdaf958013c738b28cd56e', 'tags': {'test': (None, None), 'test.tag': (None, None)}, 'props': {'.created': 1687720565352, 'text': 'rule dummy { condition: true }', 'name': 'dummy', 'enabled': 1}, 'tagprops': {}, 'nodedata': {}})
+
+
+class TestNode:
+
+    def test_packing(self):
+        node = stormlibpp.StormNode.unpack(PACKED_NODE)
+        assert node.pack() == PACKED_NODE
+
+    def test_add_tags(self):
+        tags = ["#test.othertag", "#atag"]
+        node = stormlibpp.StormNode.unpack(PACKED_NODE)
+        node.addTags(tags)
+
+        for tag in tags:
+            assert tag in node.tags
+
+        assert dir(node.tags) == [item[0] for item in iter(node.tags)]
+
+    def test_add_props(self):
+        props = {'prop': 'test', 'other': 'value'}
+        node = stormlibpp.StormNode.unpack(PACKED_NODE)
+        node.addProps(props)
+
+        for prop in props:
+            assert prop in node.props
+
+        for propname, propval in node.props:
+            if propname in props:
+                assert props[propname] == propval
+
+    def test_values(self):
+        node = stormlibpp.StormNode.unpack(PACKED_NODE)
+        
+        assert node.form == PACKED_NODE[0][0]
+        assert node.value == PACKED_NODE[0][1]
+        assert node.nodevals == PACKED_NODE[1]

stormlibpp-0.2.0/src/stormlibpp/node.py

@@ -1,13 +0,0 @@
-class PackedNode:
-    """A "packed" storm:node Storm object that is in a Python runtime.
-
-    It supports "unpacking" the node into this object, edits to the object, and
-    repacking of the node to be sent back to Storm.
-
-    This node can be created purely from Python code rather than a packed
-    ``storm:node`` object. Use the ``__init__`` directly instead of ``unpack``.
-    This allows the creation of a new node in Python that can be passed back to
-    Storm.
-    """
-
-    raise NotImplementedError