serverish 1.1.0__tar.gz

serverish-1.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Akond Lab
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

serverish-1.1.0/PKG-INFO

@@ -0,0 +1,65 @@
+Metadata-Version: 2.1
+Name: serverish
+Version: 1.1.0
+Summary: helpers for server alike projects
+Home-page: https://github.com/AkondLab/serverish
+Author: Mikołaj Kałuszyński
+Requires-Python: >=3.8,<4.0
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Provides-Extra: dns
+Provides-Extra: messenger
+Requires-Dist: aiodns (>=3.1.1,<4.0.0) ; extra == "dns"
+Requires-Dist: jsonschema (>=4.20.0,<5.0.0)
+Requires-Dist: nats-py (>=2.7.2,<3.0.0) ; extra == "messenger"
+Requires-Dist: param (>=2.1.0,<3.0.0)
+Project-URL: Repository, https://github.com/AkondLab/serverish
+Description-Content-Type: text/markdown
+
+# serverish - helpers for server alike projects
+[![CI](https://github.com/AkondLab/serverish/actions/workflows/test-ci.yml/badge.svg)](https://github.com/AkondLab/serverish/actions/workflows/test-ci.yml)
+
+## Features
+* Component management
+* Singletons
+* Connections management and diagnostics
+* NATS based Messenger
+
+See [`doc` directory](doc/) for more documentation.
+
+## Optional (extras) dependencies
+In order to use Messenger, you have to add extra 'messenger' to your `project.toml` serveris dependency, e.g.:
+```toml
+serverish = {git="https://github.com/AkondLab/serverish.git", extras=["messenger"], branch="master"}
+```
+or specify dpendency with extras in the `pip` convention: `serverish[messenger]`.
+this will install `nats-py` package.
+
+## Plans
+- Decorators `@messenger.sub(subject)` (Web framework style)
+- Progress with automatic increment for known durations e.g. `pro_pub.update(completed=1, when=+20)`
+- Pytest fixtures for NATS on CI
+
+## Changes
+* 1.1 Switches to `param` 2.* nad `py-nats` 1.7.*. Also, publisher may reraise exceptions or ignore them.
+* 1.0  Changes NATS subscriptions to pull only
+* 0.12 Extends messges metdata of `nats` section, Handles reconnection of subscriptions, 
+* 0.11 Extends, tasks, NATS connection tracking and messenger opening options (`Messenger.open`)
+* 0.10 Adds timestamp to journal messages and extablishes schema for journal messages.
+* 0.9.1 Makes dependency to aiodns optional.
+* 0.9.0 Introduces Logging handler for passing standard logging messages to the Messenger.
+* 0.8 Introduces journal publishing/reading API.
+* 0.7 Includes progress tracking messages in the Messenger API.
+* 0.6 introduces breaking changes in the Messenger API:
+  * Convenience functions `get_xxxxx()` returning publishers/readers are synchronous now. Remove `await`-ing for their results.
+  * Change of signature of the callback for `MsgRpcResponder.register_function` for `Rpc->None`.  
+
+
+## Credits
+This package uses some code and ideas from the [rich](https://github.com/Textualize/rich) package (Copyright (c) 2020 Will McGugan).
+
+

serverish-1.1.0/README.md

@@ -0,0 +1,42 @@
+# serverish - helpers for server alike projects
+[![CI](https://github.com/AkondLab/serverish/actions/workflows/test-ci.yml/badge.svg)](https://github.com/AkondLab/serverish/actions/workflows/test-ci.yml)
+
+## Features
+* Component management
+* Singletons
+* Connections management and diagnostics
+* NATS based Messenger
+
+See [`doc` directory](doc/) for more documentation.
+
+## Optional (extras) dependencies
+In order to use Messenger, you have to add extra 'messenger' to your `project.toml` serveris dependency, e.g.:
+```toml
+serverish = {git="https://github.com/AkondLab/serverish.git", extras=["messenger"], branch="master"}
+```
+or specify dpendency with extras in the `pip` convention: `serverish[messenger]`.
+this will install `nats-py` package.
+
+## Plans
+- Decorators `@messenger.sub(subject)` (Web framework style)
+- Progress with automatic increment for known durations e.g. `pro_pub.update(completed=1, when=+20)`
+- Pytest fixtures for NATS on CI
+
+## Changes
+* 1.1 Switches to `param` 2.* nad `py-nats` 1.7.*. Also, publisher may reraise exceptions or ignore them.
+* 1.0  Changes NATS subscriptions to pull only
+* 0.12 Extends messges metdata of `nats` section, Handles reconnection of subscriptions, 
+* 0.11 Extends, tasks, NATS connection tracking and messenger opening options (`Messenger.open`)
+* 0.10 Adds timestamp to journal messages and extablishes schema for journal messages.
+* 0.9.1 Makes dependency to aiodns optional.
+* 0.9.0 Introduces Logging handler for passing standard logging messages to the Messenger.
+* 0.8 Introduces journal publishing/reading API.
+* 0.7 Includes progress tracking messages in the Messenger API.
+* 0.6 introduces breaking changes in the Messenger API:
+  * Convenience functions `get_xxxxx()` returning publishers/readers are synchronous now. Remove `await`-ing for their results.
+  * Change of signature of the callback for `MsgRpcResponder.register_function` for `Rpc->None`.  
+
+
+## Credits
+This package uses some code and ideas from the [rich](https://github.com/Textualize/rich) package (Copyright (c) 2020 Will McGugan).
+

serverish-1.1.0/pyproject.toml

@@ -0,0 +1,33 @@
+[tool.poetry]
+name = "serverish"
+version = "1.1.0"
+description = "helpers for server alike projects"
+authors = ["Mikołaj Kałuszyński", "MMME team"]
+readme = "README.md"
+repository = "https://github.com/AkondLab/serverish"
+include = ["serverish/schema/*"]
+
+[tool.poetry.dependencies]
+python = "^3.8"
+aiodns = {version="^3.1.1", optional=true}
+param = "^2.1.0"
+nats-py = { version = "^2.7.2", optional= true}
+jsonschema = "^4.20.0"
+
+[tool.poetry.extras]
+messenger = ["nats-py"]
+dns = ["aiodns"]
+
+
+[tool.poetry.group.dev.dependencies]
+pytest = "^7.4.0"
+pytest-asyncio = "^0.21.0"
+nats-py = "^2.6.0"
+jupyter = "*"
+rich = "^13.5.2"
+aiodns = "^3.1.1"
+
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"

serverish-1.1.0/serverish/base/__init__.py

@@ -0,0 +1,5 @@
+from .status import Status, StatusEnum
+from .task_manager import create_task, TaskManager, Task
+from .asyncio_util_functions import wait_for_psce
+from .exceptions import *
+from .datetime import *

serverish-1.1.0/serverish/base/asyncio_util_functions.py

@@ -0,0 +1,25 @@
+import asyncio
+from contextlib import suppress
+
+
+async def wait_for_psce(fut, timeout):
+    """
+    Meaning: psce - prevent silent cancel error \n
+    This is a changed method 'wait_for()' from library 'asyncio' that prevents 'CancelledError' from being ignored
+    while the internal task is finished. \n
+    Description of the problem: the base method 'wait_for()' also works in such a way that when the inner task
+    is finished or there is no place for it to stop, function 'wait_for()' will return the result even if the inner
+    task is canceled, so the 'CancelledError' will not be propagated higher. This method prevents this situation.
+
+    :param fut: future oc coroutine
+    :param timeout: timeout, czn be float or int number
+    """
+    task = asyncio.ensure_future(fut)
+    try:
+        return await asyncio.shield(asyncio.wait_for(task, timeout=timeout))
+    except asyncio.CancelledError:
+        task.cancel()
+        with suppress(asyncio.CancelledError):
+            await task
+        raise
+

serverish-1.1.0/serverish/base/collector.py

@@ -0,0 +1,35 @@
+import logging
+
+import param
+
+from serverish.base.manageable import Manageable
+
+logger = logging.getLogger(__name__.rsplit('.')[-1])
+
+class Collector(Manageable):
+    """Has manageable children"""
+    # children: list[Manageable] = None
+    children_by_name: dict[str, Manageable] = param.Dict(default=dict(), allow_None=False, doc='Children by name')
+    children_names: dict[Manageable, str] = param.Dict(default=dict(), allow_None=False, doc='Names by child')
+
+    def ensure_parenting(self, child: Manageable):
+        try:
+            name = self.children_names[child]
+        except KeyError:
+            name = child.name
+        self.children_by_name[name] = child
+        self.children_names[child] = name
+        child.parent = self
+
+    def remove_child(self, child: Manageable):
+        try:
+            name = self.children_names[child]
+        except KeyError:
+            name = child.name
+        del self.children_by_name[name]
+        del self.children_names[child]
+        child.parent = None
+
+    @property
+    def children(self):
+        return self.children_by_name.values()

serverish-1.1.0/serverish/base/datetime.py

@@ -0,0 +1,67 @@
+""" Those functions are used to convert datetime objects to array representation
+(7-element list, similar to time tuple) and vice versa.
+
+This representation is chosen for serializing datetime to JSON as fast and easy to process.
+We are using list instead of tuple for smooth conversion to/from JSON.
+
+The meaning of the elements of the array is as follows:
+[year, month, day, hour, minute, second, microsecond]
+Time is in UTC.
+This is compatible with the datetime constructor, e.g.:
+   dt = datetime(*array, tzinfo=timezone.utc)
+but you have also the convenience function:
+    dt = dt_from_array(array)
+to do the same preserving None.
+"""
+
+from __future__ import annotations
+
+from datetime import datetime
+from datetime import timezone
+from typing import Sequence
+
+
+def dt_to_array(dt: datetime | None) -> list | None:
+    if dt is None:
+        return None
+    else:
+        dt = dt.astimezone(timezone.utc)
+        return [dt.year, dt.month, dt.day, dt.hour, dt.minute, dt.second, dt.microsecond]
+
+
+def dt_from_array(t: Sequence | None) -> datetime | None:
+    if not t:
+        return None
+    try:
+        return datetime(*t, tzinfo=timezone.utc)
+    except TypeError:  # Old 9-position format?
+        return datetime(*t[:7])
+
+
+def dt_ensure_array(dt: datetime | Sequence | float | None) -> list | None:
+    """Supports datetime, array, float (POSIX timestamp) and None"""
+    if dt is None:
+        return None
+    elif isinstance(dt, datetime):
+        return dt_to_array(dt)
+    elif isinstance(dt, float):
+        return dt_to_array(datetime.fromtimestamp(dt, timezone.utc))
+    else:
+        return list(dt)
+
+
+def dt_ensure_datetime(dt: datetime | Sequence | float | None) -> datetime | None:
+    """Supports datetime, array, float (POSIX timestamp) and None"""
+    if isinstance(dt, datetime) or dt is None:
+        return dt
+    elif isinstance(dt, float):
+        return datetime.fromtimestamp(dt, timezone.utc)
+    else:
+        return dt_from_array(dt)
+
+
+def dt_utcnow_array() -> list:
+    dt = datetime.now(timezone.utc)
+    return dt_to_array(dt)
+
+

serverish-1.1.0/serverish/base/exceptions.py

@@ -0,0 +1,28 @@
+class MessengerCannotConnect(Exception):
+    pass
+
+class MessengerNotConnected(Exception):
+    pass
+
+class MessengerReaderStopped(Exception):
+    pass
+
+class MessengerRequestNoResponse(Exception):
+    pass
+class MessengerRequestNoResponders(MessengerRequestNoResponse):
+    pass
+
+class MessengerRequestJetStreamSubject(MessengerRequestNoResponse):
+    def __init__(self, subject:str) -> None:
+        super().__init__(f'Subject {subject} probably declared in JestStream stream. '
+                         f'Use pure NATS core subjects for RPC')
+
+
+class MessengerRequestCanceled(MessengerRequestNoResponse):
+    pass
+
+class MessengerRequestTimeout(MessengerRequestNoResponse):
+    pass
+
+class MessengerRequestNoResultYet(MessengerRequestNoResponse):
+    pass

serverish-1.1.0/serverish/base/fifoset.py

@@ -0,0 +1,42 @@
+# This is generic class implementing a set of specified capacity.
+# When the capacity is reach during the insertion of a new element,
+# the oldest element is removed from the set.
+
+from typing import TypeVar, Generic
+from collections import deque
+
+
+# The type T of the set elements:
+T = TypeVar('T')
+
+
+class FifoSet(Generic[T]):
+    def __init__(self, capacity: int):
+        self.capacity = capacity
+        self.cache = set()
+        self.order = deque()
+
+    def __contains__(self, item: T) -> bool:
+        return item in self.cache
+
+    def __len__(self) -> int:
+        return len(self.cache)
+
+    def __iter__(self):
+        return iter(self.cache)
+
+    def add(self, item: T):
+        if item in self.cache:
+            return
+        if len(self.cache) >= self.capacity:
+            self.cache.remove(self.order.popleft())
+        self.cache.add(item)
+        self.order.append(item)
+
+    def remove(self, item: T):
+        self.cache.remove(item)
+        self.order.remove(item)
+
+    def clear(self):
+        self.cache.clear()
+        self.order.clear()

serverish-1.1.0/serverish/base/hasstatuses.py

@@ -0,0 +1,208 @@
+from __future__ import annotations
+import asyncio
+import logging
+from typing import Callable, Awaitable, Union
+
+import param
+
+from serverish.base.collector import Collector
+from serverish.base.manageable import Manageable
+from serverish.base.status import Status, StatusEnum
+
+logger = logging.getLogger(__name__.rsplit('.')[-1])
+
+CheckMethodType = Callable[[], Union[Awaitable[Status], Status]]
+
+class HasStatuses(Manageable):
+    """Controls the resource
+
+    Parameters
+    ----------
+    status : dict[str, Status], optional
+        Statuses of the resource, by default None
+
+    """
+    @staticmethod
+    def diagnose_dummy_ok() -> Status:
+        """Dummy diagnosis, returns StatusEnum.ok"""
+        return Status.new_ok(msg='Dummy OK')
+
+    status = param.Dict(default={}, doc='A dictionary to hold status information')
+
+    def __init__(self, name: str = None, parent: Collector = None, **kwargs) -> None:
+        self.check_methods: dict[str, CheckMethodType] = {'main': self.diagnose_dummy_ok}
+
+        super().__init__(name, parent, **kwargs)
+
+    def set_check_methods(self, **methods: CheckMethodType) -> None:
+        """Sets check methods
+
+        Methods are called in order, values of later methods may be deduced from earlier ones:
+        if some method returns StatusEnum.ok, or StatusEnum.na, we deduce that the result of all later methods
+        is the same.
+        E.g. if 'ping' is OK, we deduce that 'dns' is OK too.
+        One can force all diagnotics to be run by setting no_deduce=True in diagnose() call.
+
+
+        Args:
+            **methods (dict[str, CheckMethodType]): Dict of asynchronous methods
+        """
+        self.check_methods = methods
+
+    def add_check_methods(self, at_beginning: bool,
+                          **methods: CheckMethodType) -> None:
+        """Adds check methods
+
+        Methods are called in order, values of later methods may be deduced from earlier ones:
+        if some method returns StatusEnum.ok, or StatusEnum.na, we deduce that the result of all later methods
+        is the same.
+        E.g. if 'ping' is OK, we deduce that 'dns' is OK too.
+        One can force all diagnotics to be run by setting no_deduce=True in diagnose() call.
+
+        Args:
+            at_beginning (bool): If True, adds methods at the beginning of the list.
+            **methods (dict[str, Callable]): Dict of asynchronous methods to add
+        """
+        if at_beginning:
+            self.check_methods = {**methods, **self.check_methods}
+        else:
+            self.check_methods = {**self.check_methods, **methods}
+
+    def set_status(self, key: str, value: Status | None) -> None:
+        """Sets status of the resource
+
+        A resource can have multiple statuses, e.g. 'main', 'dns', 'http', etc.
+        Args:
+            key (str): Status name
+            value (Status): Status object
+        """
+        if self.status is None:
+            self.status = {}
+        if value is None:
+            self.status.pop(key, None)
+        else:
+            self.status[key] = value
+
+    async def diagnose(self, no_deduce: bool = False) -> dict[str, Status]:
+        """Diagnoses the object
+
+        Diagnose by calling check methods and setting statuses.
+        Methods are called in order, values of later methods may be deduced from earlier ones:
+        if some method returns StatusEnum.ok, or StatusEnum.na, we deduce that the result of all later methods
+        is the same.
+        E.g. if 'ping' is OK, we deduce that 'dns' is OK too.
+
+        One can force all diagnotics to be run by setting no_deduce=True.
+
+        Args:
+            no_deduce (bool, optional): If True, don't deduce statuses from other statuses. Defaults to False.
+        """
+
+        async def calc_state(m):
+            if asyncio.iscoroutinefunction(m):
+                return await m()
+            else:
+                return m()
+
+        if no_deduce:
+            checking_tasks = [calc_state(m) for m in self.check_methods.values()]
+            res = await asyncio.gather(*checking_tasks)
+        else:
+            res = []
+            deduced_status: Status | None = None
+            deduced_name: str | None = None
+            for n, m in self.check_methods.items():
+                if deduced_status is not None:
+                    r = Status.deduced(deduced_status, f'Deduced from {deduced_name}')
+                else:
+                    r = await calc_state(m)
+                    if r.deduce_other:
+                        deduced_status = r
+                        deduced_name = n
+                res.append(r)
+        return {n: r for n, r in zip(self.check_methods.keys(), res)}
+
+    def diagnose_sync(self, no_deduce: bool = False) -> dict[str, Status]:
+        """Diagnoses the object skipping async methods
+
+        Diagnose by calling check methods and setting statuses.
+        Methods are called in order, values of later methods may be deduced from earlier ones:
+        if some method returns StatusEnum.ok, or StatusEnum.na, we deduce that the result of all later methods
+        is the same.
+        E.g. if 'ping' is OK, we deduce that 'dns' is OK too.
+
+        One can force all diagnotics to be run by setting no_deduce=True.
+
+        Args:
+            no_deduce (bool, optional): If True, don't deduce statuses from other statuses. Defaults to False.
+        """
+
+        def calc_state(m):
+            if asyncio.iscoroutinefunction(m):
+                return Status.new_na(msg='Skipped async test')
+            else:
+                return m()
+
+        if no_deduce:
+            res = [calc_state(m) for m in self.check_methods.values()]
+        else:
+            res = []
+            deduced_status: Status | None = None
+            deduced_name: str | None = None
+            for n, m in self.check_methods.items():
+                if deduced_status is not None:
+                    r = Status.deduced(deduced_status, f'Deduced from {deduced_name}')
+                else:
+                    r = calc_state(m)
+                    if r.deduce_other:
+                        deduced_status = r
+                        deduced_name = n
+                res.append(r)
+        return {n: r for n, r in zip(self.check_methods.keys(), res)}
+
+    async def update_statuses(self, no_deduce = False) -> None:
+        """Updates statuses of the resource
+
+        Args:
+            no_deduce (bool, optional): If True, don't deduce statuses from other statuses. Defaults to False.
+
+        Calls diagnose() and sets statuses
+        """
+        statuses = await self.diagnose(no_deduce=no_deduce)
+        for n, s in statuses.items():
+            self.set_status(n, s)
+
+    def update_sync_statuses(self, no_deduce = False) -> None:
+        """Updates statuses of the resource skipping async methods
+
+        Args:
+            no_deduce (bool, optional): If True, don't deduce statuses from other statuses. Defaults to False.
+
+        Calls diagnose() and sets statuses
+        """
+        statuses = self.diagnose_sync(no_deduce=no_deduce)
+        for n, s in statuses.items():
+            self.set_status(n, s)
+
+    def point_of_failure(self) -> (str | None, Status | None):
+        """Returns the most low-level failed status - most probably the point of failure
+
+        Returns:
+            (str, Status): Name and status of the most low-level failed status
+        """
+
+        for k, s in reversed(self.status.items()):
+            if s == StatusEnum.fail:
+                return k, s
+        return None, None
+
+    def format_status(self) -> str:
+        n, s = self.point_of_failure()
+        if s is None:
+            return 'OK'
+        else:
+            return f'Failed {n} ({s.msg})'
+
+    def status_ok(self) -> bool:
+        """Returns True if no failed statuses"""
+        return self.point_of_failure()[1] is None

serverish-1.1.0/serverish/base/idmanger.py

@@ -0,0 +1,60 @@
+import logging
+
+from serverish.base.singleton import Singleton
+
+logger = logging.getLogger(__name__.rsplit('.')[-1])
+
+
+def gen_id(name: str):
+    """Generates unique ID for the prefix name"""
+    ids = IdManager()
+    return ids.get_id(name)
+
+
+def gen_uid(name: str, length: int = 10):
+    """Generates "unique" hex ID of given length with the prefix name
+
+    Uses uuid4 and URL safe base64 encoding to generate unique ID
+    """
+    return IdManager.get_uid(name, length)
+
+
+class IdManager(Singleton):
+    """Manages unique IDs"""
+    ids_counters = {}
+
+    def get_id(self, name: str) -> str:
+        """Returns unique ID for the prefix name
+
+        name may contain format specifiers, e.g. 'obj-{:04d}', if present, counter will
+        be formatted with the specifier.
+        If there is no specifier, if counter is zero, `name` will be returned, otherwise
+        `name-<counter>` will be returned.
+        """
+        if name not in self.ids_counters:
+            self.ids_counters[name] = 0
+        self.ids_counters[name] += 1
+
+        if '{' not in name:
+            if self.ids_counters[name] == 1:
+                ret = name
+            else:
+                ret = f'{name}-{self.ids_counters[name]}'
+        else:
+            ret = name.format(self.ids_counters[name])
+        return ret
+
+    def get_ids(self, name: str, count: int) -> list[str]:
+        """Returns generator of unique IDs for the name"""
+        for _ in range(count):
+            yield self.get_id(name)
+
+    @staticmethod
+    def get_uid(name: str, length: int = 10) -> str:
+        """Returns "unique" hex ID of given length with the prefix name
+
+        Uses uuid4 and URL safe base64 encoding to generate unique ID
+        """
+        import uuid
+        import base64
+        return f'{name}{base64.urlsafe_b64encode(uuid.uuid4().bytes).decode()[:length]}'

serverish-1.1.0/serverish/base/manageable.py

@@ -0,0 +1,40 @@
+from __future__ import annotations
+import logging
+from typing import TYPE_CHECKING
+
+import param
+
+
+if TYPE_CHECKING:
+    from serverish.base.collector import Collector
+
+logger = logging.getLogger(__name__.rsplit('.')[-1])
+
+
+class Manageable(param.Parameterized):
+    """ Manageable object
+
+    Manageable object is an object that can be managed by a 'parent' collector."""
+
+    def __init__(self, name: str = None, parent: Collector = None, **kwargs) -> None:
+        self.parent: Collector = parent
+        from serverish.base.idmanger import gen_uid, gen_id
+        if name is None:
+            name = gen_uid(f'{self.__class__.__name__}_')
+        else:
+            name = gen_id(name)
+        super().__init__(name=name, **kwargs)
+        if parent is not None:
+            self.parent.ensure_parenting(self)
+
+    def remove_parent(self):
+        """Removes parent"""
+        if self.parent is not None:
+            self.parent.remove_child(self)
+            self.parent = None
+
+    def set_parent(self, parent: Collector):
+        """Sets parent"""
+        self.remove_parent()
+        self.parent = parent
+        self.parent.ensure_parenting(self)