disermo 0.0.1__py3-none-any.whl

disermo/__init__.py

@@ -0,0 +1,7 @@
+from . import checks  # noqa
+from . import notifiers  # noqa
+from . import storage  # noqa
+from .checks import Check  # noqa
+from .node import Node  # noqa
+
+__version__ = "0.0.1"

disermo/checks/__init__.py

@@ -0,0 +1,5 @@
+from .base import Check  # noqa
+from . import remote  # noqa
+from . import sensors  # noqa
+from . import storage  # noqa
+from . import system  # noqa

disermo/checks/base.py

@@ -0,0 +1,83 @@
+"""
+Checks
+"""
+from __future__ import annotations
+from typing import List, Dict, Any, TypeVar
+
+from ..constants import Status
+from ..notifiers import Notifier
+from ..utils import camel_to_sentence
+
+
+T = TypeVar('T', bound='Check')
+
+
+class Check:
+    uid: str
+    label: str
+    subchecks: List[Check]
+    notifiers: List[Notifier]
+    status: Status
+    data: Dict[str, Any]
+
+    def __init__(self, label: str = None) -> None:
+        if label is None:
+            label = self.default_label
+        self.label = label
+        self.uid = self.get_uid()
+        self.subchecks = []
+        self.notifiers = []
+
+        self.status = Status.DISABLED
+        self.data = {}
+
+    def __repr__(self):
+        return f'<{type(self).__name__}: {self.uid}>'
+
+    @property
+    def class_id(self) -> str:
+        """
+        Default the class ID to the class name, but expect subclasses to
+        override with a string
+        """
+        return type(self).__name__.lower()
+
+    @property
+    def default_label(self) -> str:
+        """
+        Default the label to the class name, but expect subclasses to override
+        with a string
+        """
+        return camel_to_sentence(type(self).__name__)
+
+    def get_uid(self) -> str:
+        return f'{self.class_id}'
+
+    def add(self: T, *subchecks) -> T:
+        self.subchecks.extend(subchecks)
+        return self
+
+    def run(self) -> Status:
+        """
+        Run the check of this node, and of all its subchecks
+
+        The resulting status is the worst status for this node and all subnodes
+        """
+        self.update()
+        worst: Status = self.status
+        for check in self.subchecks:
+            result: Status = check.run()
+            if result > worst:
+                worst = result
+
+        # The status of this node is the worst found
+        self.status = worst
+        return worst
+
+    def update(self) -> None:
+        self.status = Status.DISABLED
+        self.data = {}
+
+    def notify(self: T, *notifiers: Notifier) -> T:
+        self.notifiers.extend(notifiers)
+        return self

disermo/checks/remote.py

@@ -0,0 +1,123 @@
+"""
+Checks which perform remote requests
+"""
+from dataclasses import dataclass, field
+from http.client import HTTPResponse
+import socket
+from typing import cast, Union
+from urllib.request import urlopen
+from urllib.error import HTTPError, URLError
+
+from ..constants import Status
+from ..utils import Timer
+from .base import Check
+
+
+# Default timeout, in seconds
+DEFAULT_TIMEOUT = 10
+
+# Error code for failed connection
+# This should be outside the standard HTTP error codes, so it is differentiated
+STATUS_FAILED = 0
+
+
+@dataclass
+class Response:
+    """
+    Wrapper for an urllib Response
+    """
+    raw: Union[HTTPResponse, HTTPError]
+    _content: str = field(init=False, repr=False)
+
+    @property
+    def code(self):
+        return self.raw.code
+
+    @property
+    def content(self):
+        if self._content is None:
+            self._content = self.raw.read().decode('utf-8')
+        return self._content
+
+
+class Web(Check):
+    url: str
+    timeout: float
+    status_code: int = 200
+    content_contains: Union[str, None]
+
+    def __init__(
+        self,
+        url: str,
+        label: str = None,
+        timeout: float = DEFAULT_TIMEOUT,
+        status_code: int = 200,
+        content_contains: str = None,
+    ):
+        super().__init__(label)
+        self.url = url
+        self.timeout = timeout
+        self.status_code = status_code
+        self.content_contains = content_contains
+
+    def update(self) -> None:
+        # Clean data, assuming we're going to fail
+        self.data = {
+            'status': STATUS_FAILED,
+        }
+
+        # Make the request
+        timer = Timer()
+        try:
+            raw_response: HTTPResponse = cast(
+                HTTPResponse,
+                urlopen(
+                    self.url,
+                    timeout=self.timeout,
+                ),
+            )
+
+        except HTTPError as e_response:
+            # HTTP error - should be expected, analyse below
+            response = Response(raw=e_response)
+
+        except URLError as e:
+            # Unable to connect - not expected, raise immediately
+            self.status = Status.ERROR
+            self.data['error'] = f'Could not reach server: {e.reason}'
+            return
+
+        except Exception as e:
+            # Most likely here is socket.timeout for HTTPS
+            self.status = Status.ERROR
+            self.data['error'] = f'Could not reach server: {e}'
+            return
+
+        else:
+            # Successful request
+            response = Response(raw=raw_response)
+
+        finally:
+            # All checks log their elapsed time
+            self.data['elapsed'] = timer.elapsed()
+
+        # Update status code to that returned by server
+        self.data['status'] = response.code
+
+        if response.code != self.status_code:
+            self.status = Status.ERROR
+            self.data['error'] = (
+                f'Expected status {self.status_code}, '
+                f'instead found {response.code}.'
+            )
+            return
+
+        if (
+            self.content_contains and
+            self.content_contains not in response.content
+        ):
+            self.status = Status.ERROR
+            self.data['error'] = 'Expected content not found'
+            return
+
+        self.status = Status.OK

disermo/checks/sensors.py

@@ -0,0 +1,5 @@
+from .base import Check
+
+
+class CPUTemperature(Check):
+    pass

disermo/checks/storage.py

@@ -0,0 +1,49 @@
+"""
+Storage checks
+"""
+from __future__ import annotations
+import os
+
+from ..constants import Status
+from .base import Check
+
+
+DEFAULT_WARNING = 0.1
+DEFAULT_ERROR = 0.05
+
+
+class FreeSpace(Check):
+    drive: str
+    warning: float
+    error: float
+
+    def __init__(
+        self,
+        drive: str,
+        label: str = None,
+        warning: float = DEFAULT_WARNING,
+        error: float = DEFAULT_ERROR,
+    ) -> None:
+        super().__init__(label)
+        self.drive = drive
+        self.warning = warning
+        self.error = error
+
+    def update(self) -> None:
+        data = os.statvfs(self.drive)
+        total_bytes = data.f_frsize * data.f_blocks
+        # free_bytes = data.f_frsize * data.f_bfree
+        allowed_bytes = data.f_frsize * data.f_bavail
+        percent_free = allowed_bytes / total_bytes
+
+        self.data = {
+            'total': total_bytes,
+            'free': allowed_bytes,
+        }
+
+        if percent_free < self.error:
+            self.status = Status.ERROR
+        elif percent_free < self.warning:
+            self.status = Status.WARN
+        else:
+            self.status = Status.OK

disermo/checks/system.py

@@ -0,0 +1,5 @@
+from .base import Check
+
+
+class Load(Check):
+    pass

disermo/constants.py

@@ -0,0 +1,11 @@
+"""
+Disermo constants
+"""
+from .utils import OrderedEnum
+
+
+class Status(OrderedEnum):
+    DISABLED = 0
+    OK = 1
+    WARN = 2
+    ERROR = 3

disermo/node.py

@@ -0,0 +1,83 @@
+"""
+Node object
+"""
+from collections import defaultdict
+from typing import List, DefaultDict, Iterator, Tuple
+
+from .checks.base import Check
+from .constants import Status
+from .notifiers import Notifier
+from .storage import Storage
+
+
+class Node(Check):
+    def check(self, storage: Storage) -> Status:
+        """
+        Run the checks and notify
+        """
+        status: Status = super().run()
+
+        # Collect flat list of all checks
+        checks: List[Check] = list(self.iter_flat_checks())
+
+        # Collect notifiers
+        notifiers: DefaultDict[Notifier, List[Check]] = defaultdict(list)
+        for check in checks:
+            for notifier in check.notifiers:
+                notifiers[notifier].append(check)
+
+        # Load storage so notifiers understand status context
+        storage.load()
+
+        # Call notifiers
+        for notifier, notifier_checks in notifiers.items():
+            notifier.process(self, storage, notifier_checks)
+
+        # Store statuses for trend spotting
+        for check in checks:
+            storage.set(check.uid, check.status)
+        storage.save()
+
+        return status
+
+    def iter_flat_checks(self) -> Iterator[Check]:
+        """
+        Generator to return a flat list of the node tree, starting with self
+        """
+        checks: List[Check] = [self]
+        while checks:
+            check = checks.pop(0)
+            checks = check.subchecks + checks
+            yield check
+
+    def iter_flat_depth_checks(self) -> Iterator[Tuple[Check, int]]:
+        """
+        Generator to return a flat list of (check, depth) pairs of the node
+        tree, starting with self, where depth is a 0-indexed depth (0 is self)
+        """
+        checks: List[Tuple[Check, int]] = [(self, 0)]
+        while checks:
+            check, depth = checks.pop(0)
+            checks = [
+                (subcheck, depth + 1)
+                for subcheck in check.subchecks
+            ] + checks
+            yield (check, depth)
+
+    def iter_flat_labelled_checks(self) -> Iterator[Tuple[Check, List[str]]]:
+        """
+        Generator to return a flat list of (check, labels) pairs of the node
+        tree, starting with self, where ``labels`` is a list of all parent
+        labels, in order oldest first
+        """
+        checks: List[Tuple[Check, List[str]]] = [(self, [self.label])]
+        while checks:
+            # Look at next and search its children
+            check, label = checks.pop(0)
+            checks = [
+                (subcheck, label + [subcheck.label])
+                for subcheck in check.subchecks
+            ] + checks
+
+            # See if we've found one
+            yield (check, label)

disermo/notifiers/__init__.py

@@ -0,0 +1,3 @@
+from .base import Notifier  # noqa
+from .email import Email  # noqa
+from .stream import Stream  # noqa

disermo/notifiers/base.py

@@ -0,0 +1,107 @@
+"""
+Base class for all notifiers
+"""
+from typing import TYPE_CHECKING, List
+
+if TYPE_CHECKING:  # pragma: no cover
+    from ..checks import Check
+    from ..constants import Status
+    from ..node import Node
+    from ..storage import Storage, GroupedStatus
+
+
+DEFAULT_TREND_LIMIT = 5
+
+
+class Notifier:
+    def process(
+        self,
+        node: 'Node',
+        storage: 'Storage',
+        checks: 'List[Check]',
+    ) -> None:
+        """
+        Process a set of checks
+
+        Filters the checks and passes notifiable ones on to send()
+        """
+        # Get list of checks with something worth notifying
+        notifiable = [
+            check for check in checks
+            if self.test(storage, check)
+        ]
+
+        # Send the notification(s) out
+        self.send(node, notifiable)
+
+    def test(self, storage: 'Storage', check: 'Check') -> bool:
+        """
+        Subclasses will perform tests to see if notification is required.
+
+        This base class will just pass all notifications through
+        """
+        return True
+
+    def send(self, node: 'Node', checks: 'List[Check]') -> None:
+        raise NotImplementedError()  # pragma: no cover
+
+
+class TrendNotifier(Notifier):
+    after: int
+
+    def __init__(self, after: int = DEFAULT_TREND_LIMIT):
+        self.after = after
+
+    def test(self, storage: 'Storage', check: 'Check') -> bool:
+        """
+        Performs any tests to see if the notification is required.
+
+        Looking for a change which occurred {self.after} ago
+        """
+        uid: str = check.uid
+        status: Status = check.status
+        generator: GroupedStatus = storage.get(key=uid, grouped=True)
+
+        # Get first (newest) status
+        first_status: Status
+        first_count: int
+        try:
+            first_status, first_count = next(generator)
+        except StopIteration:
+            # Nothing on the stack
+            if self.after <= 1:
+                return True
+            return False
+
+        # See if this is starting or continuing a trend
+        if first_status == status:
+            if first_count >= self.after:
+                # Continuing trend - no change
+                return False
+
+            elif first_count + 1 == self.after:
+                # This next one will start a new trend
+                # But what about the previous trend; is this actually a change?
+                past_status: Status
+                past_count: int
+                for past_status, past_count in generator:
+                    if past_count >= self.after:
+                        # Found the previous trend
+                        if past_status == status:
+                            # This is returning to an old trend - no change
+                            return False
+                        else:
+                            # This is starting a new trend
+                            return True
+
+                # Haven't found a previous trend - this is starting a new one
+                return True
+
+        else:
+            # Status doesn't match, it can't be a trend...
+            if self.after <= 1:
+                # ... unless we start a new trend immediately
+                return True
+
+        # Have not started a new trend yet - either a new status, or not enough
+        return False

disermo/notifiers/email.py

@@ -0,0 +1,64 @@
+"""
+Email notifier
+"""
+from email.mime.text import MIMEText
+import smtplib
+from typing import TYPE_CHECKING, List, Tuple
+
+from .base import TrendNotifier
+
+if TYPE_CHECKING:
+    from ..checks import Check
+    from ..node import Node
+
+
+class Email(TrendNotifier):
+    to_addr: str
+    from_addr: str
+
+    template_subject = '''[Disermo] {name} => {status}'''
+    template_body = '''{summary}'''
+    template_body_summary = '''{check}: {status}'''
+
+    def __init__(self, to_addr: str, from_addr: str, **kwargs) -> None:
+        super().__init__(**kwargs)
+        self.to_addr = to_addr
+        self.from_addr = from_addr
+
+    def send(self, node: 'Node', checks: 'List[Check]') -> None:
+        if not checks:
+            return
+
+        subject = self.template_subject.format(
+            name=node.label,
+            status=node.status,
+        )
+
+        # Generate full labels
+        found: List[Tuple[Check, List[str]]] = [
+            (check, label)
+            for check, label in node.iter_flat_labelled_checks()
+            if check in checks
+        ]
+
+        # Render summary
+        summary = '\n'.join([
+            self.template_body_summary.format(
+                check=' > '.join(label),
+                status=check.status.name.title(),
+            )
+            for check, label in found
+        ])
+
+        body = self.template_body.format(
+            summary=summary,
+        )
+
+        msg = MIMEText(body)
+        msg['Subject'] = subject
+        msg['To'] = self.to_addr
+        msg['From'] = self.from_addr
+
+        s = smtplib.SMTP('localhost')
+        s.send_message(msg)
+        s.quit()

disermo/notifiers/stream.py

@@ -0,0 +1,25 @@
+"""
+Stream notifier
+"""
+from typing import TYPE_CHECKING, List, TextIO
+
+from .base import Notifier
+
+if TYPE_CHECKING:  # pragma: no cover
+    from ..checks import Check
+    from ..node import Node
+
+
+class Stream(Notifier):
+    stream: TextIO
+
+    def __init__(self, stream: TextIO):
+        self.stream = stream
+
+    def send(self, node: 'Node', checks: 'List[Check]') -> None:
+        check: Check
+        depth: int
+        for check, depth in node.iter_flat_depth_checks():
+            self.stream.write(
+                f'{"  " * depth}{check.label}: {check.status.name.title()}\n'
+            )

disermo/storage/__init__.py

@@ -0,0 +1,2 @@
+from .base import Storage, GroupedStatus, FlatStatus  # noqa
+from .csv import CSV  # noqa

disermo/storage/base.py

@@ -0,0 +1,72 @@
+"""
+Storage base
+"""
+from collections import defaultdict
+from typing import DefaultDict, List, Tuple, Iterator, overload
+from typing_extensions import Literal
+
+from ..constants import Status
+
+
+GroupedStatus = Iterator[Tuple[Status, int]]
+FlatStatus = Iterator[Status]
+
+
+class Storage:
+    """
+    Store recent statuses
+    """
+    path: str
+    data: DefaultDict[str, List[Tuple[Status, int]]]
+    max_memory: int
+
+    def __init__(self, max_memory: int = 10) -> None:
+        self.data = defaultdict(list)
+        self.max_memory = max_memory
+
+    def load(self) -> None:
+        raise NotImplementedError()  # pragma: no cover
+
+    def save(self) -> None:
+        raise NotImplementedError()  # pragma: no cover
+
+    def set(self, key: str, status: Status) -> None:
+        """
+        Add a status to the memory
+        """
+        count = 1
+        if self.data[key]:
+            last_status: Status
+            last_count: int
+            last_status, last_count = self.data[key][-1]
+            if last_status == status:
+                # Increment the last status rather than creating a new one
+                self.data[key].pop()
+                count = last_count + 1
+
+        self.data[key].append((status, count))
+
+        # Assert max memory
+        if len(self.data[key]) > self.max_memory:
+            self.data[key] = self.data[key][-self.max_memory:]
+
+    @overload
+    def get(self, key: str, grouped: Literal[False]) -> FlatStatus:
+        pass  # pragma: no cover
+
+    @overload  # noqa: F811 until flake8 supports PEP 484
+    def get(self, key: str, grouped: Literal[True]) -> GroupedStatus:
+        pass  # pragma: no cover
+
+    def get(self, key, grouped=False):  # noqa: E501,F811 until flake8 supports PEP 484
+        """
+        Generator to return stored statuses, with most recent first
+        """
+        status: Status
+        count: int
+        for status, count in reversed(self.data[key]):
+            if grouped:
+                yield status, count
+            else:
+                for i in range(count):
+                    yield status

disermo/storage/csv.py

@@ -0,0 +1,47 @@
+"""
+CSV storage
+"""
+import csv
+import os
+
+from ..constants import Status
+from .base import Storage
+
+
+class CSV(Storage):
+    """
+    Store records in CSV format:
+
+        key,status|count,status|count,...
+
+    with oldest status first
+    """
+    SEPARATOR = '|'
+
+    def __init__(self, path: str, max_memory: int = 10) -> None:
+        super().__init__(max_memory=max_memory)
+        self.path = path
+
+    def load(self) -> None:
+        if not os.path.exists(self.path):
+            return
+
+        with open(self.path, 'r') as file:
+            reader = csv.reader(file)
+            for row in reader:
+                self.data[row[0]] = [
+                    (Status(int(status)), int(count))
+                    for (status, count) in [
+                        cell.split(self.SEPARATOR, 1)
+                        for cell in row[1:]
+                    ]
+                ]
+
+    def save(self) -> None:
+        with open(self.path, 'w') as file:
+            writer = csv.writer(file)
+            for key, values in self.data.items():
+                writer.writerow([key] + [
+                    f'{status.value}{self.SEPARATOR}{count}'
+                    for status, count in values
+                ])

disermo/utils.py

@@ -0,0 +1,61 @@
+"""
+Generic utility functions
+"""
+from enum import Enum
+import re
+import time
+
+
+_re_camel_to_sentence = re.compile(r'([A-Z]+(?=[A-Z][a-z]|$)|[A-Z][a-z])')
+
+
+class OrderedEnum(Enum):  # pragma: no cover - comes from python docs
+    """
+    Ordered enum to allow value comparison, from python docs
+    """
+    def __ge__(self, other):
+        if self.__class__ is other.__class__:
+            return self.value >= other.value
+        return NotImplemented
+
+    def __gt__(self, other):
+        if self.__class__ is other.__class__:
+            return self.value > other.value
+        return NotImplemented
+
+    def __le__(self, other):
+        if self.__class__ is other.__class__:
+            return self.value <= other.value
+        return NotImplemented
+
+    def __lt__(self, other):
+        if self.__class__ is other.__class__:
+            return self.value < other.value
+        return NotImplemented
+
+
+def camel_to_sentence(val: str) -> str:
+    """
+    Given a camelCase, convert it into Sentence case
+
+    It is acroynm-aware
+    """
+    if not val:
+        return ''
+
+    words = [
+        word if all([char.isupper() for char in word]) else word.lower()
+        for word in _re_camel_to_sentence.sub(r' \1', val).split(' ')
+        if word
+    ]
+
+    sentence = ' '.join(words)
+    return f'{sentence[0].upper()}{sentence[1:]}'
+
+
+class Timer:
+    def __init__(self):
+        self.start = time.time()
+
+    def elapsed(self):
+        return time.time() - self.start

disermo-0.0.1.dist-info/METADATA

@@ -0,0 +1,72 @@
+Metadata-Version: 2.4
+Name: disermo
+Version: 0.0.1
+Summary: Self hosted server monitoring
+Author-email: Richard Terry <code@radiac.net>
+License-Expression: BSD-3-Clause
+Project-URL: Homepage, https://github.com/radiac/disermo
+Project-URL: Documentation, https://disermo.readthedocs.io/en/latest/
+Project-URL: Repository, https://github.com/radiac/disermo
+Project-URL: Issues, https://github.com/radiac/disermo/issues
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: System Administrators
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: System :: Monitoring
+Requires-Python: >=3.8
+Description-Content-Type: text/x-rst
+License-File: LICENSE
+Requires-Dist: typing_extensions
+Dynamic: license-file
+
+=======
+Disermo
+=======
+
+Self hosted server monitoring.
+
+
+Installation
+============
+
+Install from PyPI::
+
+    pip install disermo
+
+This requires Python 3.8 or later.
+
+
+Development
+===========
+
+During development, install in a virtual environment::
+
+    mkdir disermo
+    cd disermo
+    git clone <path-to-repo> repo
+    python3 -m venv venv
+    . venv/bin/activate
+    pip install pip-tools
+    cd repo
+    pip-sync
+
+
+Quickstart
+==========
+
+Create a Disermo script based on ``example.py``.
+
+To run it::
+
+    /path/to/venv/bin/python /path/to/repo/example.py
+
+
+Tests
+=====
+
+To run tests::
+
+    cd disermo/repo
+    . ../venv/bin/activate
+    pytest --flake8 --mypy --cov=disermo --cov-report=term --cov-report=html

disermo-0.0.1.dist-info/RECORD

@@ -0,0 +1,22 @@
+disermo/__init__.py,sha256=7zpEy5zjgyVlyIfkApAJUUN6y5LkEhNjo7JiH5iACvM,179
+disermo/constants.py,sha256=STm8odd1CrRY6XwVEddwyzkQAGYfW3hom-zFNRAXfd0,141
+disermo/node.py,sha256=LaYhno9ucWCOSCyr34nI8eAyKntaXuyuiIxDxqIkqgw,2675
+disermo/utils.py,sha256=iMpXG-0_Wy9NwKPkQNRafVg2INZlFcqQt5r0FVNff_0,1473
+disermo/checks/__init__.py,sha256=4AAkhhWojk5u0bQKMLy4slcQAXiG7l1xY6dHj6M6Trc,150
+disermo/checks/base.py,sha256=eyrS0OZFEu9aSu0t0bSO8sMMpKbumT28LV57YG4Wu0g,2066
+disermo/checks/remote.py,sha256=0pQV9srEW8FPUPMrCovlCEYIeWBKw2h4wmQFyCzqFuY,3263
+disermo/checks/sensors.py,sha256=6sUi81VfLRU86T-4k9eTZxNm7Afp2c6q69T5dW0TLZ4,64
+disermo/checks/storage.py,sha256=9OYkJW1t_QLLq5zrOern9accXM9fHi5wOSZAKBtUBpo,1126
+disermo/checks/system.py,sha256=MNswaVpnbvDqxB4JTj4lH5Uweeq1_4jOGlt5cU7pNj0,54
+disermo/notifiers/__init__.py,sha256=4OzrWFTs1vdiw3NZN47t9clIvkq3UNhScSElYax-JO0,103
+disermo/notifiers/base.py,sha256=xt9xzoGhy2IFo3eHy9NWYr28OdJom0AlDjo8Wno1SZo,3292
+disermo/notifiers/email.py,sha256=YUq8ZnzG4D_Ft5JlMzyWyGoSF1naX_a0QuPL1W239Fc,1617
+disermo/notifiers/stream.py,sha256=q6dGwQZYrFlAfvkdmptlL-6jFIRJom-Oj6WUH3I6q6Q,600
+disermo/storage/__init__.py,sha256=OdTXE90YWG3YU6bMqlnPuLmwYG2EcevMqAbcyT62wRI,90
+disermo/storage/base.py,sha256=u1TfrAzIl9cqRAlhlv5LIkfvO0bk4e89dURGFlg8a_c,2074
+disermo/storage/csv.py,sha256=K9Al4ZQbtcPR283dYGfOisoPaj4JZ-JQd37i2UH9Dd4,1210
+disermo-0.0.1.dist-info/licenses/LICENSE,sha256=irwtcC7DeK8IxEZ_wGUGmNAqgea3K958MGHGHsKCfHE,1505
+disermo-0.0.1.dist-info/METADATA,sha256=zikAwklXMM7I3GQWQ44O4AHf2hgvpVQOe8B6TkQmIWg,1539
+disermo-0.0.1.dist-info/WHEEL,sha256=mOdXR9C3wMVov7cSY8PY-XCzo3SmmWCHvGQr5csJoao,91
+disermo-0.0.1.dist-info/top_level.txt,sha256=F4z0dBujonipf-15c6DDyCixVSHhgXIBnXOLnWmoRvE,8
+disermo-0.0.1.dist-info/RECORD,,

disermo-0.0.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.2.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

disermo-0.0.1.dist-info/licenses/LICENSE

@@ -0,0 +1,28 @@
+BSD 3-Clause License
+
+Copyright (c) 2019-2026, Richard Terry
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

disermo-0.0.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+disermo