simple-module-core 0.0.1__py3-none-any.whl

simple_module_core/menu.py

@@ -0,0 +1,89 @@
+"""Menu system — modules contribute menu items, filtered by user roles."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from enum import StrEnum
+from typing import Literal
+
+MenuItemMethod = Literal["get", "post"]
+
+
+class MenuSection(StrEnum):
+    """Where the menu item appears in the UI."""
+
+    SIDEBAR = "sidebar"
+    ADMIN_SIDEBAR = "adminSidebar"
+    NAVBAR = "navbar"
+    USER_DROPDOWN = "userDropdown"
+
+
+@dataclass(frozen=True)
+class MenuItem:
+    """A single navigation entry."""
+
+    label: str
+    url: str
+    icon: str = ""
+    order: int = 0
+    section: MenuSection = MenuSection.SIDEBAR
+    requires_auth: bool = True
+    roles: list[str] = field(default_factory=list)
+    """Empty list = visible to all authenticated users."""
+    method: MenuItemMethod = "get"
+    """HTTP method used when the item is activated. ``"post"`` renders as an
+    Inertia form submission so the target endpoint can be POST-only (e.g. logout)."""
+
+
+class MenuRegistry:
+    """Collects menu items from all modules and filters them per-request."""
+
+    def __init__(self) -> None:
+        self._items: list[MenuItem] = []
+        self._sorted: list[MenuItem] | None = None
+
+    def _invalidate(self) -> None:
+        self._sorted = None
+
+    def add(self, item: MenuItem) -> None:
+        self._items.append(item)
+        self._invalidate()
+
+    def add_many(self, items: list[MenuItem]) -> None:
+        self._items.extend(items)
+        self._invalidate()
+
+    @property
+    def all_items(self) -> list[MenuItem]:
+        if self._sorted is None:
+            self._sorted = sorted(self._items, key=lambda i: i.order)
+        return self._sorted
+
+    def get_for_user(
+        self,
+        *,
+        is_authenticated: bool,
+        roles: list[str] | None = None,
+    ) -> dict[str, list[dict]]:
+        """Return menu items grouped by section, filtered by auth/roles.
+
+        Returns a dict ready to be serialized into Inertia shared props.
+        """
+        roles = roles or []
+        result: dict[str, list[dict]] = {s.value: [] for s in MenuSection}
+
+        for item in self.all_items:
+            if item.requires_auth and not is_authenticated:
+                continue
+            if item.roles and not any(r in item.roles for r in roles):
+                continue
+            result[item.section.value].append(
+                {
+                    "label": item.label,
+                    "url": item.url,
+                    "icon": item.icon,
+                    "method": item.method,
+                }
+            )
+
+        return result

simple_module_core/module.py

@@ -0,0 +1,179 @@
+"""Module base class and metadata."""
+
+from __future__ import annotations
+
+from abc import ABC
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from fastapi import APIRouter, FastAPI
+
+    from simple_module_core.events import EventBus
+    from simple_module_core.feature_flags import FeatureFlagRegistry
+    from simple_module_core.health import HealthRegistry
+    from simple_module_core.menu import MenuRegistry
+    from simple_module_core.permissions import PermissionRegistry
+
+
+@dataclass(frozen=True)
+class ModuleMeta:
+    """Metadata describing a module."""
+
+    name: str
+    route_prefix: str = ""
+    view_prefix: str = ""
+    depends_on: list[str] = field(default_factory=list)
+    version: str = "1.0.0"
+    requires_framework: str | None = None
+    """PEP 440 specifier for the framework API version this module supports.
+
+    Example: ``">=1.0,<2.0"``. When set, the module is rejected at boot if the
+    installed ``simple_module_core.FRAMEWORK_API_VERSION`` does not satisfy it.
+    When ``None``, no compatibility check is performed (legacy modules).
+    """
+
+
+class ModuleBase(ABC):
+    """Base class for all modules.
+
+    Subclasses override only the methods they need.
+    Every method has a default no-op implementation.
+
+    Hook execution order during app boot:
+
+        Phase 1: Bootstrap
+          - Load framework Settings
+          - Discover & topological-sort modules
+          - Run diagnostics (dev only)
+
+        Phase 2: App creation
+          - Create FastAPI app
+          - Store framework registries + settings on app.state
+
+        Phase 3: Module settings
+          - register_settings(app)
+
+        Phase 4: Module registrations
+          - register_menu_items(registry)
+          - register_permissions(registry)
+          - register_feature_flags(registry)
+          - register_event_handlers(bus)
+          - register_health_checks(registry)
+
+        Phase 5: Database
+          - init_db() -> DatabaseState
+          - register_listeners(db_state)
+
+        Phase 6: App wiring
+          - Inertia setup
+          - register_exception_handlers(app)
+          - Middleware pipeline (register_middleware per module)
+          - register_routes(api_router, view_router)
+          - Mount health router + static files
+
+        Phase 7: Runtime (async)
+          - on_startup(app) — per module, in dependency order
+          - on_shutdown(app) — per module, reverse order
+    """
+
+    meta: ModuleMeta
+
+    # ── Settings ─────────────────────────────────────────────
+
+    def register_settings(self, app: FastAPI) -> None:
+        """Load module-specific settings and store on ``app.state``.
+
+        Called before all other registration hooks. Convention:
+        store as ``app.state.<module_name_lower>_settings``.
+        """
+
+    # ── Service Registration ──────────────────────────────────
+
+    def register_routes(
+        self,
+        api_router: APIRouter,
+        view_router: APIRouter,
+    ) -> None:
+        """Register API endpoints and Inertia view routes."""
+
+    def register_menu_items(self, registry: MenuRegistry) -> None:
+        """Contribute menu items visible in the UI."""
+
+    def register_permissions(self, registry: PermissionRegistry) -> None:
+        """Declare permissions this module uses."""
+
+    def register_feature_flags(self, registry: FeatureFlagRegistry) -> None:
+        """Declare feature flags this module exposes."""
+
+    def register_event_handlers(self, bus: EventBus) -> None:
+        """Subscribe to events published by other modules."""
+
+    def register_health_checks(self, registry: HealthRegistry) -> None:
+        """Contribute health checks for the ``/health/ready`` endpoint."""
+
+    def register_middleware(self, app: FastAPI) -> None:
+        """Add middleware to the application.
+
+        Called after core middleware (session, security headers) positioning
+        is established but before the app starts.  Modules that need to
+        inject middleware (e.g. auth) override this method.
+        """
+
+    def register_exception_handlers(self, app: FastAPI) -> None:
+        """Register custom exception handlers on the application.
+
+        Called after framework exception handlers are set up.
+        """
+
+    # ── Asset contribution (templates & static files) ─────────
+
+    def template_dirs(self) -> list[Path]:
+        """Return Jinja2 template directories this module contributes.
+
+        The host aggregates all modules' template dirs (plus its own) into the
+        Jinja2 loader, so templates in ``<module>/templates/`` become resolvable
+        from any module. Return an empty list (default) to contribute none.
+
+        Each path is typically computed via
+        ``importlib.resources.files(__package__) / "templates"`` so it resolves
+        correctly when the module is installed as a PyPI package.
+        """
+        return []
+
+    def static_mounts(self) -> dict[str, Path]:
+        """Return static file mounts this module contributes.
+
+        Mapping of URL prefix → filesystem directory. The host mounts each entry
+        via ``StaticFiles`` during app boot. Convention: prefix with
+        ``/modules/<name>/static`` to avoid collisions with the host's own
+        ``/static`` mount. Return an empty dict (default) to contribute none.
+        """
+        return {}
+
+    def locale_dirs(self) -> dict[str, Path]:
+        """Return ``{namespace: directory}`` mapping for locale JSON files.
+
+        Default returns an empty dict. Override to contribute a module's
+        locales::
+
+            return {
+                "products": importlib.resources.files(__package__) / "locales"
+            }
+
+        The namespace becomes the key prefix in the merged i18n registry.
+        A file ``locales/en.json`` containing ``{"browse": {"title": "X"}}``
+        becomes the key ``products.browse.title`` at runtime.
+
+        Convention: use the module's lowercase name as the namespace.
+        """
+        return {}
+
+    # ── Lifecycle ─────────────────────────────────────────────
+
+    async def on_startup(self, app: FastAPI) -> None:
+        """Called after all modules are registered, during app startup."""
+
+    async def on_shutdown(self, app: FastAPI) -> None:
+        """Called during app shutdown."""

simple_module_core/permissions.py

@@ -0,0 +1,121 @@
+"""Permission registry — modules declare the permissions they use."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+
+WILDCARD = "*"
+
+# Default role→permission mapping. Admin gets all permissions via the wildcard.
+# Additional mappings are added at registration time via PermissionRegistry.map_role.
+DEFAULT_ROLE_PERMISSIONS: dict[str, list[str]] = {
+    "admin": [WILDCARD],
+}
+
+
+@dataclass
+class PermissionGroup:
+    """A named group of related permissions (typically one per module)."""
+
+    name: str
+    permissions: list[str] = field(default_factory=list)
+
+
+class PermissionRegistry:
+    """Central registry of all permissions across all modules.
+
+    Effectively immutable after module-registration (boot phase). The computed
+    views ``all_permissions`` and ``role_map`` are read on every authenticated
+    request by ``InertiaLayoutDataMiddleware`` — cache them and invalidate on
+    every mutation.
+    """
+
+    def __init__(self) -> None:
+        self._groups: dict[str, PermissionGroup] = {}
+        self._role_map: dict[str, set[str]] = {}
+        self._all_permissions_cache: list[str] | None = None
+        self._role_map_cache: dict[str, list[str]] | None = None
+
+    def _invalidate(self) -> None:
+        self._all_permissions_cache = None
+        self._role_map_cache = None
+
+    def add_group(self, name: str, permissions: list[str]) -> None:
+        """Register a group of related permissions."""
+        if name in self._groups:
+            self._groups[name].permissions.extend(permissions)
+        else:
+            self._groups[name] = PermissionGroup(name=name, permissions=list(permissions))
+        self._invalidate()
+
+    def add(self, permission: str) -> None:
+        """Register a single permission (auto-grouped by prefix before '.')."""
+        group_name = permission.split(".")[0] if "." in permission else "general"
+        if group_name not in self._groups:
+            self._groups[group_name] = PermissionGroup(name=group_name)
+        if permission not in self._groups[group_name].permissions:
+            self._groups[group_name].permissions.append(permission)
+        self._invalidate()
+
+    @property
+    def all_permissions(self) -> list[str]:
+        """All registered permission strings, sorted."""
+        if self._all_permissions_cache is None:
+            perms: set[str] = set()
+            for group in self._groups.values():
+                perms.update(group.permissions)
+            self._all_permissions_cache = sorted(perms)
+        return self._all_permissions_cache
+
+    @property
+    def groups(self) -> list[PermissionGroup]:
+        return list(self._groups.values())
+
+    def has(self, permission: str) -> bool:
+        return any(permission in g.permissions for g in self._groups.values())
+
+    def map_role(self, role: str, permissions: list[str]) -> None:
+        """Register a role→permission mapping.
+
+        Merges *permissions* into the existing set for *role* so that multiple
+        calls from different modules accumulate rather than overwrite.
+        """
+        if role not in self._role_map:
+            self._role_map[role] = set()
+        self._role_map[role].update(permissions)
+        self._invalidate()
+
+    @property
+    def role_map(self) -> dict[str, list[str]]:
+        """Merged role→permission mapping (``DEFAULT_ROLE_PERMISSIONS`` + module maps)."""
+        if self._role_map_cache is None:
+            merged: dict[str, list[str]] = {
+                role: list(perms) for role, perms in DEFAULT_ROLE_PERMISSIONS.items()
+            }
+            for role, perms in self._role_map.items():
+                if role in merged:
+                    merged[role] = list(set(merged[role]) | perms)
+                else:
+                    merged[role] = list(perms)
+            self._role_map_cache = merged
+        return self._role_map_cache
+
+    def get_permissions_for_roles(
+        self,
+        roles: list[str],
+        role_permission_map: dict[str, list[str]] | None = None,
+    ) -> set[str]:
+        """Resolve permissions for a set of roles.
+
+        If role_permission_map is None, 'admin' gets all permissions,
+        other roles get none. Override for richer mapping.
+        """
+        if role_permission_map is None:
+            if "admin" in roles:
+                return set(self.all_permissions)
+            return set()
+
+        result: set[str] = set()
+        for role in roles:
+            result.update(role_permission_map.get(role, []))
+        return result

simple_module_core/services.py

@@ -0,0 +1,45 @@
+"""Framework-scoped singleton container.
+
+Stored as ``app.state.sm`` during :func:`create_app`. Consumers read
+``request.app.state.sm.<field>`` instead of reaching for loose
+``app.state`` attributes — gives us typing, discoverability, and a
+single place to see what the framework owns.
+
+Frozen + slotted by design: Services is built once at boot and never
+mutated. Slots reject attribute additions, which is how the previous
+``app.state`` shape grew unbounded.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from inertia import InertiaConfig
+    from simple_module_db.session import DatabaseState
+    from simple_module_hosting.settings import Settings
+
+    from simple_module_core.events import EventBus
+    from simple_module_core.feature_flags import FeatureFlagRegistry
+    from simple_module_core.health import HealthRegistry
+    from simple_module_core.i18n import I18nRegistry
+    from simple_module_core.menu import MenuRegistry
+    from simple_module_core.module import ModuleBase
+    from simple_module_core.permissions import PermissionRegistry
+
+
+@dataclass(frozen=True, slots=True)
+class Services:
+    """Framework singletons. One slot per owner, read-only after boot."""
+
+    settings: Settings
+    db: DatabaseState
+    event_bus: EventBus
+    menu_registry: MenuRegistry
+    permissions: PermissionRegistry
+    feature_flags: FeatureFlagRegistry
+    health_registry: HealthRegistry
+    i18n_registry: I18nRegistry
+    inertia_config: InertiaConfig
+    modules: tuple[ModuleBase, ...]

simple_module_core/versioning.py

@@ -0,0 +1,67 @@
+"""Framework API version compatibility checks for modules."""
+
+from __future__ import annotations
+
+import logging
+from collections.abc import Sequence
+
+from packaging.specifiers import InvalidSpecifier, SpecifierSet
+from packaging.version import Version
+
+from simple_module_core.exceptions import FrameworkVersionError
+from simple_module_core.module import ModuleBase
+
+logger = logging.getLogger(__name__)
+
+FRAMEWORK_API_VERSION = "1.0.0"
+"""Current public API version of simple_module_core.
+
+Modules declare a compatible range via ``ModuleMeta.requires_framework``
+(PEP 440 specifier, e.g. ``">=1.0,<2.0"``). Bumping this constant's major
+component signals a breaking change in the module contract — ``ModuleBase``,
+registries, the event bus, ``create_module_base``, or the model mixins.
+"""
+
+# Pre-parsed for the default compatibility check so boot doesn't re-parse
+# this constant on every call. The custom-version path below still parses
+# caller-supplied strings lazily.
+_FRAMEWORK_VERSION = Version(FRAMEWORK_API_VERSION)
+
+
+def check_framework_compatibility(
+    modules: Sequence[ModuleBase],
+    framework_version: str = FRAMEWORK_API_VERSION,
+) -> None:
+    """Fail fast if any module's ``requires_framework`` spec rejects the framework version.
+
+    Modules with ``requires_framework=None`` are skipped (unversioned modules pass).
+    Malformed specifiers are reported as failures rather than letting a cryptic
+    ``InvalidSpecifier`` bubble up from deep inside ``packaging``.
+    """
+    current = (
+        _FRAMEWORK_VERSION
+        if framework_version == FRAMEWORK_API_VERSION
+        else Version(framework_version)
+    )
+    failures: list[tuple[str, str, str]] = []
+
+    for mod in modules:
+        spec_str = mod.meta.requires_framework
+        if spec_str is None:
+            continue
+        try:
+            spec = SpecifierSet(spec_str)
+        except InvalidSpecifier as exc:
+            failures.append((mod.meta.name, spec_str, f"invalid version specifier ({exc})"))
+            continue
+        if current not in spec:
+            failures.append(
+                (
+                    mod.meta.name,
+                    spec_str,
+                    f"framework {framework_version} does not satisfy '{spec_str}'",
+                )
+            )
+
+    if failures:
+        raise FrameworkVersionError(framework_version, failures)

simple_module_core-0.0.1.dist-info/METADATA

@@ -0,0 +1,85 @@
+Metadata-Version: 2.4
+Name: simple_module_core
+Version: 0.0.1
+Summary: Module-system primitives for the simple_module framework — ModuleBase, discovery, diagnostics, events
+Project-URL: Homepage, https://github.com/antosubash/simple_module_python
+Project-URL: Repository, https://github.com/antosubash/simple_module_python
+Project-URL: Issues, https://github.com/antosubash/simple_module_python/issues
+Project-URL: Changelog, https://github.com/antosubash/simple_module_python/blob/main/CHANGELOG.md
+Author-email: Anto Subash <antosubash@live.com>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: fastapi,modular-monolith,module-discovery,plugin-system,simple-module
+Classifier: Development Status :: 3 - Alpha
+Classifier: Framework :: FastAPI
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Internet :: WWW/HTTP
+Classifier: Topic :: Software Development :: Libraries :: Application Frameworks
+Classifier: Typing :: Typed
+Requires-Python: >=3.12
+Requires-Dist: babel>=2.14
+Requires-Dist: fastapi>=0.115
+Requires-Dist: packaging>=23.0
+Requires-Dist: pydantic-settings>=2.0
+Requires-Dist: pydantic>=2.0
+Requires-Dist: pyee>=12.0
+Description-Content-Type: text/markdown
+
+# simple_module_core
+
+Module-system primitives for the [simple_module](https://github.com/antosubash/simple_module_python) framework — a modular-monolith for Python/FastAPI where each feature is a plugin package discovered at boot.
+
+This package defines `ModuleBase`, the `ModuleMeta` descriptor, the `discover_modules()` entry-point loader, topological dependency sorting, event bus primitives, and the diagnostic codes (`SM001`–`SM017`) used by `make doctor`.
+
+## Install
+
+```bash
+pip install simple_module_core
+```
+
+You usually don't install this directly — it's pulled in by `simple_module_hosting` and every `simple_module_*` module.
+
+## What it provides
+
+- `ModuleBase` — the subclass every module extends to opt into lifecycle hooks.
+- `ModuleMeta` — required `meta = ModuleMeta(name=..., depends_on=...)` attribute on each module.
+- `discover_modules()` — loads all `[project.entry-points.simple_module]` modules, topologically sorts by `depends_on`.
+- Diagnostic registry — `SM001` missing meta, `SM003` orphan page, `SM008` duplicate name, `SM009` framework→plugin coupling violation, and ~ten others.
+- Tiny event-bus (`pyee`) for decoupled module-to-module communication.
+
+## Usage
+
+```python
+# modules/orders/orders/module.py
+from simple_module_core import ModuleBase, ModuleMeta
+
+
+class OrdersModule(ModuleBase):
+    meta = ModuleMeta(name="orders", depends_on=["users"])
+
+    def register_routes(self, api_router, view_router):
+        from .endpoints import api, views
+        api_router.include_router(api.router)
+        view_router.include_router(views.router)
+```
+
+And in `pyproject.toml`:
+
+```toml
+[project.entry-points.simple_module]
+orders = "orders.module:OrdersModule"
+```
+
+The host's `discover_modules()` call picks this up automatically at boot.
+
+## Depends on
+
+- `fastapi`, `pydantic`, `pydantic-settings`, `pyee`, `babel`, `packaging`
+
+## License
+
+MIT — see [LICENSE](https://github.com/antosubash/simple_module_python/blob/main/LICENSE).

simple_module_core-0.0.1.dist-info/RECORD

@@ -0,0 +1,29 @@
+simple_module_core/__init__.py,sha256=e1Sf0Hy2YgOt_bl4Fs8-6qwSXWwAfbartRXQr5Z1vss,2087
+simple_module_core/__main__.py,sha256=98rf_b9GsbcYoHvU9q3aondBuHvxVO-VMJPuohb0XNc,3096
+simple_module_core/discovery.py,sha256=oeib4kJJXwqe0y5HczyMIRbubPHXerHv4RYRTYsuR3s,6776
+simple_module_core/dotenv.py,sha256=ubQ-hS-yMnBXkW1Sh0yTgLzlcHPOZ1P78VJXCJ7N2fM,1461
+simple_module_core/environments.py,sha256=OY7Hy9FcGjit3RRnROxUJHynMi5Wq9G1_zrjwYb0Jfw,663
+simple_module_core/events.py,sha256=3klVq41t08hHs6rp59FolnH0gJQjiyvTiuWAaBEgm7k,3015
+simple_module_core/exceptions.py,sha256=X8MEs-NodkS5tTcaO24BjOeAkmWXdODRGukE6ys1q64,2034
+simple_module_core/feature_flags.py,sha256=I2nkIX6dEvG8in9N4JR3VrDnCTG8y1pWzM3KJJK3FiU,6666
+simple_module_core/health.py,sha256=UPeWmjh607JnKG1XXnOiGKa4HHxd5x51EZR8HfuyRyU,982
+simple_module_core/i18n.py,sha256=shpcg7k8IVNofiwxo30jhZ-tBzRG8XWiz2PP20CPFdw,10247
+simple_module_core/menu.py,sha256=toaNvXzO-gL0bvpckSOGRWRavVy70BPH0lOQd_ZCfFE,2586
+simple_module_core/module.py,sha256=CiaaAjFbf3dp-BJEti9W_Y3cPULG5paNAUk45TCxd-E,6588
+simple_module_core/permissions.py,sha256=Z_QRC6WL1IyKjbeWWxj-RbyGJLwZU2H2NwBNrpwdHTg,4517
+simple_module_core/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+simple_module_core/services.py,sha256=_BmZCT18ZaXMT1qif0CCt7Fi6mB7i2MqbniYleC5RBs,1585
+simple_module_core/versioning.py,sha256=ii7gF5gcO1FV7qw0J86ksRS49kh3GMhUcoyX0Nrm0_g,2361
+simple_module_core/diagnostics/__init__.py,sha256=t2RX37e9rIlBST-KJ2jysuniAZ0Eq-SuV2PvUnIdbio,874
+simple_module_core/diagnostics/_coupling.py,sha256=xrS5yteuLIobxwBahxCRkCw3WopIG8WYdGZfkBAsB3Q,3023
+simple_module_core/diagnostics/_i18n.py,sha256=DVthcWRee-zlR1BLemV3HYxFYZXTkVL9Kj2dqoE3iUQ,4852
+simple_module_core/diagnostics/_inertia_api.py,sha256=OuvxaR7CKen-a5RVaKoPNobxrbIHuyU2SQ7ZBlLfUCw,2839
+simple_module_core/diagnostics/_js_workspace.py,sha256=004aYAFHbP31j3Iy8x-0l_1Sj1f4CeIR35LO1sfxEIM,1250
+simple_module_core/diagnostics/_migration.py,sha256=7D1kE88kDy7bZgu4y9oAJexVg3zb6i6fsZQJEJJsZpk,1528
+simple_module_core/diagnostics/_module.py,sha256=fQTBZ1y0NajB6b8mhOEu-IknTjnRaVdYtYCo-CeTOr0,10165
+simple_module_core/diagnostics/_runner.py,sha256=E9NraAj_3i5CCoRA-5PcpWxf-Tk0GdXtx_jEcbWrfmI,2892
+simple_module_core/diagnostics/_types.py,sha256=EQucVU24ktuxqupot3Gf10HolFmdmM-QDwPL6tolJJc,886
+simple_module_core-0.0.1.dist-info/METADATA,sha256=1G2stmMayQBX87RItlTYgGOFy5AbsD7uWC-t2LUPI1k,3377
+simple_module_core-0.0.1.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+simple_module_core-0.0.1.dist-info/licenses/LICENSE,sha256=Yn66lhLklsF5p7pa85_ksQrJ79Q-FgOaUAHevLBjer4,1068
+simple_module_core-0.0.1.dist-info/RECORD,,

simple_module_core-0.0.1.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.29.0
+Root-Is-Purelib: true
+Tag: py3-none-any

simple_module_core-0.0.1.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Anto Subash
+
+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.