webrockets 0.1.1__cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl

webrockets/__init__.py

@@ -0,0 +1,35 @@
+# ruff: noqa: E402, I001
+# Import order matters: webrockets must be imported first to avoid circular imports
+from typing import Literal, TypedDict
+from .webrockets import *
+from .utils import noop
+from .auth import BaseAuthentication
+
+
+class _RedisBrokerConfigOptional(TypedDict, total=False):
+    url: str  # default: "redis://localhost:6379"
+    channel: str  # default: "ws_broadcast"
+
+
+class RedisBrokerConfig(_RedisBrokerConfigOptional):
+    type: Literal["redis"]
+
+
+class _AmqpBrokerConfigOptional(TypedDict, total=False):
+    url: str  # default: "amqp://localhost:5672"
+    exchange: str  # default: "ws_broadcast"
+    queue: str | None  # default: auto-generated UUID
+    routing_key: str  # default: "#"
+
+
+class AmqpBrokerConfig(_AmqpBrokerConfigOptional):
+    type: Literal["amqp"]
+
+
+BrokerConfig = RedisBrokerConfig | AmqpBrokerConfig
+
+__all__ = ["noop", "BaseAuthentication", "BrokerConfig"]
+
+__doc__ = webrockets.__doc__
+if hasattr(webrockets, "__all__"):
+    __all__ += webrockets.__all__

webrockets/__init__.pyi

@@ -0,0 +1,215 @@
+from collections.abc import Callable, Coroutine, Iterable
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Generic,
+    Literal,
+    TypedDict,
+    TypeVar,
+    overload,
+)
+
+from webrockets.auth import BaseAuthentication
+
+if TYPE_CHECKING:
+    from pydantic import BaseModel
+
+# Type aliases for Match parameters
+MatchKey = str | Iterable[str]
+MatchValue = str | int | Literal["*"] | Iterable[str | int | Literal["*"]]
+
+class _RedisBrokerConfigOptional(TypedDict, total=False):
+    url: str  # default: "redis://localhost:6379"
+    channel: str  # default: "ws_broadcast"
+
+class RedisBrokerConfig(_RedisBrokerConfigOptional):
+    type: Literal["redis"]
+
+class _AmqpBrokerConfigOptional(TypedDict, total=False):
+    url: str  # default: "amqp://localhost:5672"
+    exchange: str  # default: "ws_broadcast"
+    queue: str | None  # default: auto-generated UUID
+    routing_key: str  # default: "#"
+
+class AmqpBrokerConfig(_AmqpBrokerConfigOptional):
+    type: Literal["amqp"]
+
+BrokerConfig = RedisBrokerConfig | AmqpBrokerConfig
+
+class BaseConnection:
+    path: str
+    query_string: str
+    headers: dict[str, str]
+    cookies: dict[str, str]
+    user: Any | None
+
+    def __init__(
+        self,
+        path: str,
+        query_string: str,
+        headers: dict[str, str],
+        cookies: dict[str, str],
+    ) -> None: ...
+    def get_cookie(self, name: str) -> str | None: ...
+    def get_header(self, name: str) -> str | None: ...
+
+class IncomingConnection(BaseConnection): ...
+
+class Connection(BaseConnection):
+    def send(self, msg: str | bytes) -> None: ...
+    async def asend(self, msg: str | bytes) -> None: ...
+    def close(self, code: int = 1000, reason: str = "") -> None: ...
+    async def aclose(self, code: int = 1000, reason: str = "") -> None: ...
+    def broadcast(
+        self, groups: list[str], msg: str | bytes, exclude_self: bool = False
+    ) -> None: ...
+    async def abroadcast(
+        self, groups: list[str], msg: str | bytes, exclude_self: bool = False
+    ) -> None: ...
+    def join(self, group: str) -> bool:
+        """Join a group dynamically. Returns True if newly joined, False if already a member."""
+        ...
+    def leave(self, group: str) -> bool:
+        """Leave a group dynamically. Returns True if was a member, False otherwise."""
+        ...
+    def groups(self) -> list[str]:
+        """Get all groups this connection belongs to."""
+        ...
+    def group_size(self, group: str) -> int:
+        """Get the number of connections in a group."""
+        ...
+
+T_Connection = TypeVar("T_Connection", bound=IncomingConnection | Connection)
+T_Schema = TypeVar("T_Schema", bound="BaseModel" | str)
+
+class ConnectDecorator(Generic[T_Connection]):
+    def __call__(
+        self, func: Callable[[T_Connection], None | Coroutine[Any, Any, None]]
+    ) -> Callable[[T_Connection], None | Coroutine[Any, Any, None]]: ...
+
+class ReceiveDecorator(Generic[T_Schema]):
+    def __call__(
+        self, func: Callable[[Connection, T_Schema], None | Coroutine[Any, Any, None]]
+    ) -> Callable[[Connection, T_Schema], None | Coroutine[Any, Any, None]]: ...
+
+class Match:
+    """
+    Pattern matcher for receive handlers.
+
+    Supports matching on JSON message fields with:
+    - Single or multiple keys: Match("type", ...) or Match(["type", "action"], ...)
+    - Single or multiple values: Match(..., "message") or Match(..., ["msg", "notify"])
+    - Integer values: Match("code", 1) or Match("code", [1, 2, 3])
+    - Wildcard matching: Match("type", "*") matches any value
+    - Mixed types: Match("type", ["message", 1, "*"])
+
+    Args:
+        key: Field name(s) to match on (string or iterable of strings)
+        value: Value(s) to match (string, int, "*" for wildcard, or iterable)
+        remove_key: If True, removes the matched key from the JSON before passing to handler
+    """
+
+    key: list[str]
+    value: list[str | int]
+    remove_key: bool
+
+    def __init__(
+        self,
+        key: MatchKey,
+        value: MatchValue,
+        *,
+        remove_key: bool = False,
+    ) -> None: ...
+
+class WebsocketRoute:
+    path: str
+    default_group: str | None
+    authentication_classes: list[BaseAuthentication] | None = None
+
+    @overload
+    def connect(
+        self,
+        when: Literal["before"],
+    ) -> ConnectDecorator[IncomingConnection]: ...
+    @overload
+    def connect(
+        self,
+        when: Literal["after"],
+    ) -> ConnectDecorator[Connection]: ...
+    @overload
+    def receive(
+        self,
+        func: Callable[[Connection, str | bytes], None | Coroutine[Any, Any, None]],
+        /,
+    ) -> Callable[[Connection, str | bytes], None | Coroutine[Any, Any, None]]: ...
+    @overload
+    def receive(
+        self,
+        /,
+        match: Match,
+    ) -> ReceiveDecorator[str]: ...
+    @overload
+    def receive(
+        self,
+        /,
+        match: Match,
+        schema: type[T_Schema],
+    ) -> ReceiveDecorator[T_Schema]: ...
+    def disconnect(
+        self,
+        func: Callable[[Connection, int | None, str | None], None | Coroutine[Any, Any, None]],
+    ) -> Callable[[Connection, int | None, str | None], None | Coroutine[Any, Any, None]]: ...
+
+class WebsocketServer:
+    def __init__(
+        self,
+        host: str = "0.0.0.0",
+        port: int = 46290,
+        broker: BrokerConfig | None = None,
+    ) -> None: ...
+    def start(self) -> None: ...
+    def stop(self) -> None: ...
+    def create_route(
+        self,
+        path: str,
+        default_group: str | None = None,
+        authentication_classes: list[BaseAuthentication] | None = None,
+    ) -> WebsocketRoute: ...
+    def addr(self) -> str: ...
+
+# Broker functions for external broadcasting (e.g., from Django views, Celery tasks)
+def setup_broadcast(config: BrokerConfig) -> None:
+    """
+    Initialize the broadcaster with a broker configuration.
+    Must be called before using broadcast() or abroadcast().
+    """
+    ...
+
+def reset_broadcast() -> None:
+    """
+    Reset the broadcaster, allowing setup_broadcast() to be called again.
+    Primarily useful for testing when switching between broker configurations.
+    """
+    ...
+
+def broadcast(groups: list[str], message: str) -> None:
+    """
+    Publish a message to the specified groups via the configured broker.
+    This is a blocking call that publishes synchronously.
+
+    Args:
+        groups: List of group names to broadcast to
+        message: The message payload (typically JSON string)
+    """
+    ...
+
+async def abroadcast(groups: list[str], message: str) -> None:
+    """
+    Async version of broadcast().
+    Publish a message to the specified groups via the configured broker.
+
+    Args:
+        groups: List of group names to broadcast to
+        message: The message payload (typically JSON string)
+    """
+    ...

webrockets/apps.py

@@ -0,0 +1,22 @@
+import importlib
+
+if importlib.util.find_spec("django") is None:
+    raise ImportError(
+        'Django is required to use apps.py. Install with: pip install "webrockets[django]"'
+    )
+
+from django.apps import AppConfig
+
+
+class WsRsAppConfig(AppConfig):
+    name = "webrockets"
+    verbose_name = "webrockets"
+
+    def ready(self) -> None:
+        from django.conf import settings
+
+        broker_config = getattr(settings, "WEBSOCKET_BROKER", None)
+        if broker_config:
+            from webrockets import setup_broadcast
+
+            setup_broadcast(broker_config)

webrockets/auth.py

@@ -0,0 +1,50 @@
+from abc import ABC, abstractmethod
+from typing import Any
+
+from webrockets import IncomingConnection
+
+
+class AuthenticationFailed(Exception):
+    """
+    Exception raised when authentication fails.
+    """
+
+    def __init__(self, detail: str = "Authentication failed", close_code: int = 4003):
+        self.detail = detail
+        self.close_code = close_code
+        super().__init__(detail)
+
+
+class BaseAuthentication(ABC):
+    """
+    Base class for WebSocket authentication.
+
+    All authentication classes should extend this class and implement
+    the `authenticate` method.
+
+    Example usage:
+        class TokenAuthentication(BaseAuthentication):
+            def authenticate(self, conn: IncommingConnection) -> Any:
+                token = conn.get_header("Authorization")
+                if not token:
+                    raise AuthenticationFailed("No token provided")
+                user = validate_token(token)
+                return user
+    """
+
+    @abstractmethod
+    def authenticate(self, conn: IncomingConnection) -> Any | None:
+        """
+        Authenticate the WebSocket connection request.
+
+        Args:
+            conn: IncommingConnection containing headers, cookies, path, and query string.
+
+        Returns:
+            A user if authentication succeeds.
+            Return None to skip this authenticator and try the next one.
+
+        Raises:
+            AuthenticationFailed: If authentication explicitly fails.
+        """
+        pass

webrockets/auth.pyi

@@ -0,0 +1,13 @@
+from abc import ABC, abstractmethod
+from typing import Any
+
+from webrockets import IncomingConnection
+
+class AuthenticationFailed(Exception):
+    detail: str
+    close_code: int
+    def __init__(self, detail: str = "Authentication failed", close_code: int = 4003) -> None: ...
+
+class BaseAuthentication(ABC):
+    @abstractmethod
+    def authenticate(self, conn: IncomingConnection) -> Any | None: ...

webrockets/django/__init__.py

@@ -0,0 +1,33 @@
+import importlib.util
+
+from webrockets import WebsocketServer
+
+if importlib.util.find_spec("django") is None:
+    raise ImportError(
+        'Django is required for webrockets.django. Install with: pip install "webrockets[django]"'
+    )
+
+from django.conf import settings
+
+from .auth import (
+    AuthenticationFailed,
+    CookieTokenAuthentication,
+    HeaderTokenAuthentication,
+    QueryStringTokenAuthentication,
+    SessionAuthentication,
+)
+
+server = WebsocketServer(
+    getattr(settings, "WEBSOCKET_HOST", "0.0.0.0"),
+    getattr(settings, "WEBSOCKET_PORT", 46290),
+    getattr(settings, "WEBSOCKET_BROKER", None),
+)
+
+__all__ = [
+    "AuthenticationFailed",
+    "SessionAuthentication",
+    "CookieTokenAuthentication",
+    "HeaderTokenAuthentication",
+    "QueryStringTokenAuthentication",
+    "server",
+]

webrockets/django/__init__.pyi

@@ -0,0 +1,3 @@
+from webrockets import WebsocketServer
+
+server: WebsocketServer

webrockets/django/auth.py

@@ -0,0 +1,181 @@
+from types import SimpleNamespace
+from typing import Any
+from urllib.parse import parse_qs
+
+from django.conf import settings
+from django.contrib import auth
+from django.utils.module_loading import import_string
+
+from webrockets import IncomingConnection
+from webrockets.auth import AuthenticationFailed, BaseAuthentication
+
+
+class SessionAuthentication(BaseAuthentication):
+    def __init__(self, session_cookie_name: str | None = None):
+        """
+        Initialize SessionAuthentication.
+
+        Args:
+            session_cookie_name: Name of the session cookie. If None, uses
+                                 Django's SESSION_COOKIE_NAME setting.
+        """
+        self._session_cookie_name = session_cookie_name
+
+    @property
+    def session_cookie_name(self) -> str:
+        if self._session_cookie_name:
+            return self._session_cookie_name
+        return getattr(settings, "SESSION_COOKIE_NAME", "sessionid")
+
+    def _get_session_store(self):
+        engine = getattr(settings, "SESSION_ENGINE", "django.contrib.sessions.backends.db")
+        return import_string(f"{engine}.SessionStore")
+
+    def authenticate(self, conn: IncomingConnection) -> Any | None:
+        session_id = conn.get_cookie(self.session_cookie_name)
+        if not session_id:
+            raise AuthenticationFailed("No session cookie found", close_code=4001)
+
+        SessionStore = self._get_session_store()
+        session = SessionStore(session_key=session_id)
+
+        request = SimpleNamespace(session=session)
+        user = auth.get_user(request)
+        if not user.is_authenticated:
+            raise AuthenticationFailed("No authenticated user in session", close_code=4001)
+
+        return user
+
+
+class CookieTokenAuthentication(BaseAuthentication):
+    """
+    Authentication class that reads a token from a cookie.
+
+    This is useful for JWT tokens stored in HTTP-only cookies.
+    Users must implement the `validate_token` method or provide a validator function.
+
+    Example:
+        class JWTCookieAuth(CookieTokenAuthentication):
+            cookie_name = "jwt_token"
+
+            def validate_token(self, token: str) -> Any:
+                payload = jwt.decode(token, settings.SECRET_KEY, algorithms=["HS256"])
+                return User.objects.get(pk=payload["user_id"])
+    """
+
+    cookie_name: str = "auth_token"
+
+    def authenticate(self, conn: IncomingConnection) -> Any | None:
+        token = conn.get_cookie(self.cookie_name)
+        if not token:
+            raise AuthenticationFailed(f"No {self.cookie_name} cookie found", close_code=4001)
+
+        user = self.validate_token(token)
+        return user
+
+    def validate_token(self, token: str) -> Any:
+        """
+        Validate the token and return the user.
+
+        Override this method in subclasses to implement token validation.
+
+        Args:
+            token: The token string from the cookie.
+
+        Returns:
+            The authenticated user object.
+
+        Raises:
+            AuthenticationFailed: If the token is invalid.
+        """
+        raise NotImplementedError("Subclasses must implement validate_token()")
+
+
+class HeaderTokenAuthentication(BaseAuthentication):
+    """
+    Authentication class that reads a token from an HTTP header.
+
+    Note: WebSocket connections from browsers cannot set custom headers
+    in the initial handshake. This is primarily useful for non-browser clients
+    or when using query parameters as a fallback.
+
+    For browser-based JWT authentication, consider:
+    - Using CookieTokenAuthentication with HTTP-only cookies
+    - Passing tokens via query string (QueryStringTokenAuthentication)
+    - Performing authentication after connection via message protocol
+
+    Example for non-browser clients:
+        class BearerTokenAuth(HeaderTokenAuthentication):
+            header_name = "authorization"
+            keyword = "Bearer"
+
+            def validate_token(self, token: str) -> Any:
+                return verify_and_get_user(token)
+    """
+
+    header_name: str = "authorization"
+    keyword: str = "Bearer"
+
+    def authenticate(self, conn: IncomingConnection) -> Any | None:
+        auth_header = conn.get_header(self.header_name)
+        if not auth_header:
+            raise AuthenticationFailed(f"No {self.header_name} header found", close_code=4001)
+
+        parts = auth_header.split()
+        if len(parts) != 2 or parts[0].lower() != self.keyword.lower():
+            raise AuthenticationFailed(f"Invalid {self.header_name} header format", close_code=4001)
+
+        token = parts[1]
+        user = self.validate_token(token)
+        return user
+
+    def validate_token(self, token: str) -> Any:
+        """
+        Validate the token and return the user.
+
+        Override this method in subclasses to implement token validation.
+        """
+        raise NotImplementedError("Subclasses must implement validate_token()")
+
+
+class QueryStringTokenAuthentication(BaseAuthentication):
+    """
+    Authentication class that reads a token from the query string.
+
+    This is useful for browser-based WebSocket connections where custom headers
+    cannot be set. The token is passed as a URL parameter.
+
+    Example URL: ws://example.com/chat/?token=your-jwt-token
+
+    Note: Query string tokens may be logged in server access logs.
+    Consider using short-lived tokens for this authentication method.
+
+    Example:
+        class JWTQueryAuth(QueryStringTokenAuthentication):
+            query_param = "token"
+
+            def validate_token(self, token: str) -> Any:
+                payload = jwt.decode(token, settings.SECRET_KEY, algorithms=["HS256"])
+                return User.objects.get(pk=payload["user_id"])
+    """
+
+    query_param: str = "token"
+
+    def authenticate(self, conn: IncomingConnection) -> Any | None:
+        params = parse_qs(conn.query_string)
+        tokens = params.get(self.query_param, [])
+
+        if not tokens:
+            raise AuthenticationFailed(f"No {self.query_param} in query string", close_code=4001)
+
+        token = tokens[0]
+        user = self.validate_token(token)
+        return user
+
+    def validate_token(self, token: str) -> Any:
+        """
+        Validate the token and return the user.
+
+        Override this method in subclasses to implement token validation.
+        """
+        raise NotImplementedError("Subclasses must implement validate_token()")

webrockets/django/auth.pyi

@@ -0,0 +1,26 @@
+from typing import Any
+
+from webrockets import IncomingConnection
+from webrockets.auth import BaseAuthentication
+
+class SessionAuthentication(BaseAuthentication):
+    def __init__(self, session_cookie_name: str | None = None) -> None: ...
+    @property
+    def session_cookie_name(self) -> str: ...
+    def authenticate(self, conn: IncomingConnection) -> Any | None: ...
+
+class CookieTokenAuthentication(BaseAuthentication):
+    cookie_name: str
+    def authenticate(self, conn: IncomingConnection) -> Any | None: ...
+    def validate_token(self, token: str) -> Any: ...
+
+class HeaderTokenAuthentication(BaseAuthentication):
+    header_name: str
+    keyword: str
+    def authenticate(self, conn: IncomingConnection) -> Any | None: ...
+    def validate_token(self, token: str) -> Any: ...
+
+class QueryStringTokenAuthentication(BaseAuthentication):
+    query_param: str
+    def authenticate(self, conn: IncomingConnection) -> Any | None: ...
+    def validate_token(self, token: str) -> Any: ...

webrockets/management/commands/runwebsockets.py

@@ -0,0 +1,49 @@
+import importlib
+import logging
+
+if importlib.util.find_spec("django") is None:
+    raise ImportError(
+        'Django is required to use runwebsockets command. Install with: pip install "webrockets[django]"'
+    )
+
+from django.core.management.base import BaseCommand
+from django.utils.module_loading import autodiscover_modules
+
+from webrockets.django import server
+
+LOG_LEVELS = {
+    "debug": logging.DEBUG,
+    "info": logging.INFO,
+    "warning": logging.WARNING,
+    "error": logging.ERROR,
+    "critical": logging.CRITICAL,
+}
+
+
+class Command(BaseCommand):
+    help = "Start the webrockets WebSocket server"
+
+    def add_arguments(self, parser):
+        parser.add_argument(
+            "--log-level",
+            type=str,
+            choices=LOG_LEVELS.keys(),
+            default=None,
+            help="Set the log level for webrockets (debug, info, warning, error, critical)",
+        )
+
+    def handle(self, *args, **options):
+        if options["log_level"]:
+            level = LOG_LEVELS[options["log_level"]]
+            logger = logging.getLogger("webrockets")
+            logger.setLevel(level)
+            if not logger.handlers:
+                handler = logging.StreamHandler()
+                handler.setFormatter(
+                    logging.Formatter("%(asctime)s %(levelname)s %(name)s: %(message)s")
+                )
+                logger.addHandler(handler)
+                logger.propagate = False
+
+        autodiscover_modules("websockets", "sockets", "sse", "views")
+        server.start()

webrockets/utils.py

@@ -0,0 +1,2 @@
+async def noop():
+    pass

webrockets-0.1.1.dist-info/METADATA

@@ -0,0 +1,12 @@
+Metadata-Version: 2.4
+Name: webrockets
+Version: 0.1.1
+Classifier: Programming Language :: Rust
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Requires-Dist: django>=4.2 ; extra == 'django'
+Requires-Dist: pydantic>=2.0 ; extra == 'schema'
+Provides-Extra: django
+Provides-Extra: schema
+License-File: LICENSE.md
+Requires-Python: >=3.10

webrockets-0.1.1.dist-info/RECORD

@@ -0,0 +1,19 @@
+webrockets/__init__.py,sha256=yVVqsX_32sccg7F0iLxN-8_kT7Bn_D98oa5-8R-HXUA,1004
+webrockets/__init__.pyi,sha256=t6278tRPmbYEaF6NXGv9itLsb-1IuLiGxISFl1txxkY,6766
+webrockets/apps.py,sha256=ba3I6aEq7UYUW5JeeJaWKEAUFRPOJE2zZtxQ3UHuZxs,572
+webrockets/auth.py,sha256=uWoHreBSMIjyZNLElxdCwBgoNDJLnbzecrtqqfmCbG4,1475
+webrockets/auth.pyi,sha256=cDFtZ-YPmMmG04NRuA_3Ysr_ZO3NorRwLemtXzIr_3A,401
+webrockets/django/__init__.py,sha256=dKYx6rWpGVVywVKRbLA5gbViAPq6526ueNW6QkxsOBc,814
+webrockets/django/__init__.pyi,sha256=YkvLn1DouBIUrwgmOnFtFCExA0SkZBfuQAllXouTOfk,64
+webrockets/django/auth.py,sha256=RYuoFS6E4cKrsq2IkwcgzGTw6NiNgGMURAt8NyWHM6w,6358
+webrockets/django/auth.pyi,sha256=xfzqc3705P3bXshhiUjhU_TMV5Kk01uAy4VYvQUPXPc,993
+webrockets/management/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+webrockets/management/commands/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+webrockets/management/commands/runwebsockets.py,sha256=9VvxiWBl_o-AA5xBjphWYR0BJPMJDhf8ll_-l4BXZtA,1522
+webrockets/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+webrockets/utils.py,sha256=QgvZ19wfhim8gRHIyZ62U031lchLmvh0r6JSa1VMmso,27
+webrockets/webrockets.cpython-310-aarch64-linux-gnu.so,sha256=sJ5VaT1K8FiZxMnQ7RVPUWvxZw_nztBcvv4pCCl7NQ4,4081456
+webrockets-0.1.1.dist-info/METADATA,sha256=n8uz2WZJdSeLWER6V6UsISR0txs_-l3EuWBtkEbtkjk,427
+webrockets-0.1.1.dist-info/WHEEL,sha256=RB6BklbQly-nkZ92dlo_PD8Q-04KsWFjgp4lJ2wl33k,149
+webrockets-0.1.1.dist-info/licenses/LICENSE.md,sha256=enjfNwKVg0wUKgkHasdFANY3j36T-Coc71PwEzvvjoI,1076
+webrockets-0.1.1.dist-info/RECORD,,

webrockets-0.1.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: maturin (1.11.5)
+Root-Is-Purelib: false
+Tag: cp310-cp310-manylinux_2_17_aarch64
+Tag: cp310-cp310-manylinux2014_aarch64

webrockets-0.1.1.dist-info/licenses/LICENSE.md

@@ -0,0 +1,8 @@
+Copyright (c) 2026 Konstantinos Artopoulos
+
+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.
+