QT-PyQt-PySide-Custom-Widgets-Pro 1.1.0__py3-none-any.whl

custom_widgets_pro/__init__.py

@@ -0,0 +1,73 @@
+########################################################################
+## SPINN DESIGN CODE
+# WEBSITE: customwidgets.org
+########################################################################
+"""custom-widgets-pro - commercial Pro widgets for QT-PyQt-PySide-Custom-Widgets.
+
+Proprietary. Requires a valid entitlement to develop with (a licence token from
+your Spinn UI account portal, issued for a Stripe subscription or an active
+Patreon membership). Applications you ship run royalty-free. See LICENSE and
+the free-core docs (docs/design/commercial-product.md).
+"""
+import os
+import sys
+import warnings
+from importlib import import_module
+
+from ._version import __version__
+from ._license import (check_license, require_license, activate,
+                       LicenseError, LicenseStatus)
+from ._catalog import pro_catalog
+
+# The Qt-backed widgets load lazily (PEP 562). Importing any submodule runs
+# this __init__ first, so an eager `.datatable` import here would drag qtpy ->
+# the whole GUI stack into *every* entry point - including the
+# `custom-widgets-pro` licence CLI, which then could not run at all unless the
+# free core and PySide were both installed and healthy. A licence command must
+# work on a broken Qt install; that is often exactly why someone is running it.
+# `_license` and `_catalog` stay eager: both are pure stdlib.
+_LAZY_WIDGETS = (
+    "QCustomDataTablePro", "VirtualDataTableModel", "GroupRole",
+    "DataProvider", "ListDataProvider", "CallableDataProvider",
+    "export_csv", "export_xlsx", "export_table",
+    "GroupingEngine", "GroupRow", "aggregate", "AGGREGATORS",
+    "pivot_table", "PIVOT_COL_PREFIX", "TOTAL_KEY",
+)
+
+
+def __getattr__(name):
+    """Resolve the Qt-backed names on first use, then cache them in globals()
+    so later lookups hit the module dict and never come back here."""
+    if name not in _LAZY_WIDGETS:
+        raise AttributeError(
+            "module %r has no attribute %r" % (__name__, name))
+    value = getattr(import_module(".datatable", __name__), name)
+    globals()[name] = value
+    return value
+
+
+def __dir__():
+    return sorted(__all__)
+
+__all__ = [
+    "QCustomDataTablePro",
+    "VirtualDataTableModel", "GroupRole",
+    "DataProvider", "ListDataProvider", "CallableDataProvider",
+    "export_csv", "export_xlsx", "export_table",
+    "GroupingEngine", "GroupRow", "aggregate", "AGGREGATORS",
+    "pivot_table", "PIVOT_COL_PREFIX", "TOTAL_KEY",
+    "check_license", "require_license", "activate", "LicenseError", "LicenseStatus",
+    "pro_catalog", "__version__",
+]
+
+# Dev-time entitlement check on import: warn once if unlicensed, but do NOT
+# raise - eval/trial and CI of the source tree stay importable. Build/release
+# tooling calls require_license() to hard-gate. The `custom-widgets-pro` CLI
+# reports entitlement itself, so suppress the duplicate import-time warning
+# there (it manages the licence; it should not scold about it).
+_status = check_license()
+if not _status.valid and os.path.basename(sys.argv[0] or "") != "custom-widgets-pro":
+    warnings.warn(
+        "custom-widgets-pro: %s Running in unlicensed dev/eval mode." % _status.reason,
+        stacklevel=2,
+    )

custom_widgets_pro/_catalog.py

@@ -0,0 +1,25 @@
+########################################################################
+## SPINN DESIGN CODE
+# WEBSITE: customwidgets.org
+########################################################################
+"""Machine-readable catalog of Pro widgets, aggregated from each widget's
+``__catalog__`` descriptor. Mirrors the free core's catalog hooks so an agent
+(via MCP) can introspect Pro widgets - their props, variants and tokens - the
+same way it does core widgets.
+"""
+
+_REGISTRY = []
+
+
+def register(widget_cls):
+    """Register a Pro widget class that exposes ``__catalog__``. Usable as a
+    decorator."""
+    entry = getattr(widget_cls, "__catalog__", None)
+    if entry is not None and entry not in _REGISTRY:
+        _REGISTRY.append(entry)
+    return widget_cls
+
+
+def pro_catalog():
+    """Return the list of registered Pro widget catalog descriptors."""
+    return list(_REGISTRY)

custom_widgets_pro/_cli.py

@@ -0,0 +1,132 @@
+########################################################################
+## SPINN DESIGN CODE
+# WEBSITE: customwidgets.org
+########################################################################
+"""Command-line entry point for custom-widgets-pro entitlement management.
+
+Installed as the ``custom-widgets-pro`` console script (see [project.scripts]
+in pyproject.toml). Thin wrapper over ``_license`` - it validates the licence
+token from your account portal against the billing API, caches the signed
+result, and reports status. Shipped apps stay royalty-free and never call this.
+
+    custom-widgets-pro status
+    custom-widgets-pro activate <licence-token>
+    custom-widgets-pro deactivate
+"""
+import argparse
+import os
+import sys
+
+from ._version import __version__
+from . import _license
+from ._license import activate, check_license, ENV_API, ENV_KEY
+
+PROG = "custom-widgets-pro"
+
+
+def _print_status(status):
+    """Human-readable one-block summary of a LicenseStatus."""
+    print("%s entitlement: %s" % (PROG, "valid" if status.valid else "not valid"))
+    print("  source     : %s" % status.source)
+    if status.plan_name or status.tier:
+        print("  plan       : %s" % (status.plan_name or status.tier))
+    if status.expires:
+        print("  expires    : %s" % status.expires)
+    if status.max_devices:
+        print("  devices    : up to %s" % status.max_devices)
+    print("  detail     : %s" % status.reason)
+    print("  server     : %s" % _license._api_base())
+    print("  cache      : %s" % _license._config_path())
+
+
+def _cmd_status(args):
+    status = check_license(refresh=args.refresh)
+    _print_status(status)
+    return 0 if status.valid else 1
+
+
+def _cmd_activate(args):
+    if args.api_url:
+        os.environ[ENV_API] = args.api_url
+    token = _license._resolve_token(args.token)
+    if not token:
+        print("error: provide the licence token from your account portal "
+              "(or set %s)" % ENV_KEY, file=sys.stderr)
+        return 2
+
+    print("Validating licence against %s ..." % _license._api_base())
+    status = activate(token=token)
+    _print_status(status)
+    if status.valid:
+        print("\nActivated. This machine is now entitled to develop with Pro.")
+        return 0
+    print("\nActivation failed. Nothing was cached.", file=sys.stderr)
+    return 1
+
+
+def _cmd_deactivate(args):
+    """Drop the local cache and stored token. This does not free the device
+    seat on the server - that is done from the account portal, which is the
+    only place holding the user credentials needed to release it. The device
+    id is deliberately kept, so re-activating reuses the same seat."""
+    path = _license._config_path()
+    _license._cached_status = None
+    removed = False
+    for target in (path, _license._token_path()):
+        try:
+            os.remove(target)
+            removed = True
+        except FileNotFoundError:
+            pass
+        except OSError as exc:
+            print("error: could not remove %s: %s" % (target, exc),
+                  file=sys.stderr)
+            return 1
+    if removed:
+        print("Removed local entitlement cache: %s" % path)
+    else:
+        print("No local entitlement cache to remove (%s)" % path)
+    print("Note: to free this device's seat, deactivate it in your account "
+          "portal.")
+    return 0
+
+
+def build_parser():
+    p = argparse.ArgumentParser(
+        prog=PROG,
+        description="Manage your custom-widgets-pro developer entitlement.")
+    p.add_argument("--version", action="version",
+                   version="%s %s" % (PROG, __version__))
+    sub = p.add_subparsers(dest="command")
+
+    s = sub.add_parser("status", help="show the current entitlement status")
+    s.add_argument("--refresh", action="store_true",
+                   help="force online re-validation (skip the cache)")
+    s.set_defaults(func=_cmd_status)
+
+    a = sub.add_parser("activate",
+                       help="validate your licence token online and cache it")
+    a.add_argument("token", nargs="?",
+                   help="licence token from your account portal")
+    a.add_argument("--api-url", metavar="URL",
+                   help="override the billing API base URL (staging / self-host)")
+    a.set_defaults(func=_cmd_activate)
+
+    d = sub.add_parser("deactivate",
+                       help="remove the local entitlement cache (log out)")
+    d.set_defaults(func=_cmd_deactivate)
+
+    return p
+
+
+def main(argv=None):
+    parser = build_parser()
+    args = parser.parse_args(argv)
+    if not getattr(args, "func", None):
+        parser.print_help()
+        return 0
+    return args.func(args)
+
+
+if __name__ == "__main__":
+    sys.exit(main())

custom_widgets_pro/_license.py

@@ -0,0 +1,419 @@
+########################################################################
+## SPINN DESIGN CODE
+# WEBSITE: customwidgets.org
+########################################################################
+"""Dev-time entitlement check for custom-widgets-pro.
+
+Enforcement is **development-time only**. A valid entitlement is required to
+*develop and build* with the Pro widgets; applications you ship run
+**royalty-free** and must never call back here.
+
+Entitlement is a single **licence token** issued by the Spinn UI account portal
+and validated against our own billing API. The server is the only authority on
+who is entitled: it already resolves Stripe subscriptions *and* Patreon
+memberships into the same ``license_tokens`` table, so the client never talks to
+a payment provider. There is deliberately no Gumroad / LemonSqueezy /
+Patreon-direct path here - selling through a third-party storefront was
+considered and rejected in favour of owning billing.
+
+Verification uses only the Python standard library (``urllib``) so the Pro
+package pulls in no extra runtime dependency. A validated entitlement is cached
+to a signed local file with an **offline grace** period and **perpetual
+fallback** (the covered version keeps working after a subscription lapses).
+Enforcement is deliberately soft at runtime - the real teeth are native
+compilation of the shipped wheels plus the licence agreement.
+
+Configuration:
+  CUSTOM_WIDGETS_PRO_LICENSE   licence token from the account portal
+  CUSTOM_WIDGETS_PRO_API_URL   billing API base URL (staging / self-host)
+  CUSTOM_WIDGETS_PRO_NO_CHECK  opt-out (CI of licensed users)
+"""
+import hashlib
+import hmac
+import json
+import os
+import platform
+import sys
+import time
+import urllib.error
+import urllib.request
+import uuid
+
+ENV_KEY = "CUSTOM_WIDGETS_PRO_LICENSE"          # licence token
+ENV_API = "CUSTOM_WIDGETS_PRO_API_URL"          # billing API base URL
+ENV_DISABLE = "CUSTOM_WIDGETS_PRO_NO_CHECK"     # opt-out for CI of licensed users
+
+# The billing API that issues and validates tokens. Env-overridable so a build
+# can be pointed at a staging or self-hosted server.
+_DEFAULT_API_URL = "https://billing.customwidgets.org"
+_VALIDATE_PATH = "/api/licenses/validate"
+
+_GRACE_DAYS = 14                                 # offline grace once validated
+_HTTP_TIMEOUT = 8                                # seconds per API call
+_CACHE_VERSION = 2                               # v1 cached store/Patreon grants
+# Obfuscation-grade only: the cache signature deters casual hand-editing, not a
+# determined attacker (a client-side key can't be secret). Enforcement is soft
+# by design; the real protection is native compilation + the licence agreement.
+_CACHE_HMAC_KEY = b"custom-widgets-pro/entitlement-cache/v1"
+
+_cached_status = None                            # process-level memo
+
+
+class LicenseError(RuntimeError):
+    """Raised by require_license() when no valid entitlement is present."""
+
+
+class _NetworkError(Exception):
+    """Internal: the API could not be reached (offline / timeout)."""
+
+
+class LicenseStatus(object):
+    def __init__(self, valid, source="none", tier=None, reason="",
+                 commercial=None, expires=None, plan_name=None,
+                 max_devices=None):
+        self.valid = valid          # bool
+        self.source = source        # "runtime" | "server" | "cache" | "none"
+        self.tier = tier            # plan slug, e.g. "pro" / "studio" / "lifetime"
+        self.reason = reason        # human-readable explanation
+        self.commercial = commercial  # reserved; the server owns entitlement now
+        self.expires = expires      # ISO date string, or None for perpetual
+        self.plan_name = plan_name  # display name, e.g. "Pro Yearly"
+        self.max_devices = max_devices  # seat count; 0 == unlimited
+
+    def __bool__(self):
+        return self.valid
+
+    def __repr__(self):
+        return ("LicenseStatus(valid=%r, source=%r, tier=%r, expires=%r)"
+                % (self.valid, self.source, self.tier, self.expires))
+
+
+def is_frozen():
+    """True when running inside a packaged/shipped app (PyInstaller, Nuitka,
+    cx_Freeze). Shipped apps are royalty-free, so the check is skipped."""
+    return bool(getattr(sys, "frozen", False) or
+                globals().get("__compiled__") or
+                getattr(sys, "_MEIPASS", None))
+
+
+def _config_dir():
+    base = os.environ.get("XDG_CONFIG_HOME") or os.path.expanduser("~/.config")
+    return os.path.join(base, "custom-widgets-pro")
+
+
+def _config_path():
+    return os.path.join(_config_dir(), "license.json")
+
+
+def _token_path():
+    return os.path.join(_config_dir(), "token")
+
+
+def _store_token(token):
+    """Persist the validated token so re-validation (after the offline grace
+    lapses, or on ``status --refresh``) doesn't ask the user for it again.
+    Written 0600 - it is a bearer credential."""
+    path = _token_path()
+    try:
+        os.makedirs(_config_dir(), exist_ok=True)
+        fd = os.open(path, os.O_WRONLY | os.O_CREAT | os.O_TRUNC, 0o600)
+        with os.fdopen(fd, "w") as fh:
+            fh.write(token)
+    except OSError:
+        pass
+
+
+def _stored_token():
+    try:
+        with open(_token_path()) as fh:
+            return fh.read().strip()
+    except OSError:
+        return ""
+
+
+def _resolve_token(explicit=None):
+    """Token resolution order: explicit argument, environment, stored file."""
+    return (explicit or os.environ.get(ENV_KEY) or _stored_token() or "").strip()
+
+
+def _api_base():
+    return (os.environ.get(ENV_API) or _DEFAULT_API_URL).rstrip("/")
+
+
+def _installed_version():
+    try:
+        # Straight from `_version`, never `from custom_widgets_pro import ...`:
+        # the latter re-enters the package __init__ and used to report a
+        # hand-maintained string that had drifted from the built version.
+        from ._version import __version__
+        return __version__
+    except Exception:
+        return "0.0.0"
+
+
+def _version_tuple(v):
+    out = []
+    for part in str(v).split("."):
+        digits = "".join(ch for ch in part if ch.isdigit())
+        out.append(int(digits) if digits else 0)
+    return tuple(out) or (0,)
+
+
+# ---------------------------------------------------------------------- #
+## Device identity (the server enforces per-plan seat counts)
+# ---------------------------------------------------------------------- #
+def _device_identity():
+    """A stable (id, name) pair for this machine.
+
+    The id is persisted rather than derived from hardware: hostnames and MAC
+    addresses change (docks, VPNs, renames), and a shifting id would silently
+    burn a seat on every change. Generated once, kept beside the cache."""
+    id_file = os.path.join(_config_dir(), "device_id")
+    try:
+        with open(id_file) as fh:
+            device_id = fh.read().strip()
+    except OSError:
+        device_id = ""
+
+    if not device_id:
+        device_id = uuid.uuid4().hex
+        try:
+            os.makedirs(_config_dir(), exist_ok=True)
+            with open(id_file, "w") as fh:
+                fh.write(device_id)
+        except OSError:
+            # Read-only home: carry on with an ephemeral id. The server treats
+            # it as a new device, which is the safe direction.
+            pass
+
+    name = "%s (%s)" % (platform.node() or "unknown", platform.system())
+    return device_id, name
+
+
+# ---------------------------------------------------------------------- #
+## HTTP (stdlib only; monkeypatched in tests)
+# ---------------------------------------------------------------------- #
+def _http_json(method, url, data=None, headers=None, timeout=_HTTP_TIMEOUT):
+    """Make a JSON HTTP request. Returns (status_code, parsed_body). Raises
+    _NetworkError when the endpoint can't be reached. HTTP 4xx/5xx with a JSON
+    body are returned (not raised) so callers can read error details.
+
+    ``data`` is serialised as a JSON body - the API parses ``php://input`` as
+    JSON and ignores form-encoded input."""
+    hdrs = {"Accept": "application/json", "User-Agent": "custom-widgets-pro"}
+    if headers:
+        hdrs.update(headers)
+    body = None
+    if data is not None:
+        body = json.dumps(data).encode("utf-8")
+        hdrs["Content-Type"] = "application/json"
+    req = urllib.request.Request(url, data=body, headers=hdrs, method=method)
+    try:
+        with urllib.request.urlopen(req, timeout=timeout) as resp:
+            raw = resp.read().decode("utf-8", "replace")
+            code = resp.getcode()
+    except urllib.error.HTTPError as exc:
+        raw = exc.read().decode("utf-8", "replace")
+        code = exc.code
+    except (urllib.error.URLError, TimeoutError, OSError) as exc:
+        raise _NetworkError(str(exc))
+    try:
+        return code, (json.loads(raw) if raw else {})
+    except ValueError:
+        return code, {}
+
+
+# ---------------------------------------------------------------------- #
+## Token verification against our own billing API
+# ---------------------------------------------------------------------- #
+def _verify_token(token):
+    """Validate a licence token against the billing API, claiming a device seat.
+    Returns a LicenseStatus; raises _NetworkError when offline."""
+    if not token or len(token.strip()) < 8:
+        return LicenseStatus(False, "server", reason="malformed licence token")
+    token = token.strip()
+    device_id, device_name = _device_identity()
+
+    code, body = _http_json(
+        "POST", _api_base() + _VALIDATE_PATH,
+        data={"token": token, "device_id": device_id,
+              "device_name": device_name})
+
+    # The API envelope is {status, message, data}; errors carry only a message.
+    message = body.get("message") or ""
+    data = body.get("data") or {}
+
+    if code == 409:
+        # Seat limit. Distinct from "invalid" - the token is good, the machine
+        # just can't have a seat until one is freed from the portal.
+        return LicenseStatus(False, "server",
+                             reason=message or "device seat limit reached")
+    if code == 403:
+        return LicenseStatus(False, "server",
+                             reason=message or "licence token invalid or expired")
+    if code >= 400 or not data.get("valid"):
+        return LicenseStatus(False, "server",
+                             reason=message or "licence token rejected")
+
+    status = LicenseStatus(
+        True, "server",
+        tier=data.get("plan") or "pro",
+        plan_name=data.get("plan_name"),
+        expires=data.get("expires"),
+        max_devices=data.get("max_devices"),
+        reason="licence validated (%s)" % (data.get("plan_name")
+                                           or data.get("plan") or "pro"))
+    _write_cache(status)
+    _store_token(token)
+    return status
+
+
+# ---------------------------------------------------------------------- #
+## Local cache (offline grace + perpetual fallback), tamper-evident
+# ---------------------------------------------------------------------- #
+def _canonical(payload):
+    return json.dumps(payload, sort_keys=True, separators=(",", ":"))
+
+
+def _sign(payload):
+    return hmac.new(_CACHE_HMAC_KEY, _canonical(payload).encode("utf-8"),
+                    hashlib.sha256).hexdigest()
+
+
+def _write_cache(status):
+    try:
+        payload = {
+            "v": _CACHE_VERSION,
+            "source": status.source,
+            "tier": status.tier,
+            "plan_name": status.plan_name,
+            "expires": status.expires,
+            "max_devices": status.max_devices,
+            "validated_at": int(time.time()),
+            "covered_version": _installed_version(),
+        }
+        path = _config_path()
+        os.makedirs(os.path.dirname(path), exist_ok=True)
+        with open(path, "w") as fh:
+            json.dump({"payload": payload, "sig": _sign(payload)}, fh)
+    except OSError:
+        pass
+
+
+def _read_cache():
+    try:
+        with open(_config_path()) as fh:
+            doc = json.load(fh)
+    except (OSError, ValueError):
+        return LicenseStatus(False, "cache", reason="no cached entitlement")
+    payload = doc.get("payload") or {}
+    sig = doc.get("sig") or ""
+    if not hmac.compare_digest(sig, _sign(payload)):
+        return LicenseStatus(False, "cache",
+                             reason="cached entitlement tampered / invalid")
+    if payload.get("v") != _CACHE_VERSION:
+        # A v1 cache recorded a Gumroad/LemonSqueezy/Patreon grant that this
+        # build can no longer refresh. Force one online validation.
+        return LicenseStatus(False, "cache",
+                             reason="cached entitlement predates the current "
+                                    "licensing scheme; re-activate once online")
+    validated_at = payload.get("validated_at", 0)
+    covered = payload.get("covered_version", "0")
+    common = dict(tier=payload.get("tier"), plan_name=payload.get("plan_name"),
+                  expires=payload.get("expires"),
+                  max_devices=payload.get("max_devices"))
+    fresh = (time.time() - validated_at) <= _GRACE_DAYS * 86400
+    perpetual = _version_tuple(_installed_version()) <= _version_tuple(covered)
+    if fresh:
+        return LicenseStatus(True, "cache",
+                             reason="cached entitlement (offline grace)", **common)
+    if perpetual:
+        return LicenseStatus(True, "cache",
+                             reason="perpetual fallback (covers installed version)",
+                             **common)
+    return LicenseStatus(False, "cache",
+                         reason="cached entitlement expired; re-validate online")
+
+
+# ---------------------------------------------------------------------- #
+## Public API
+# ---------------------------------------------------------------------- #
+def check_license(refresh=False):
+    """Resolve the current entitlement without raising. Memoised per process.
+
+    Order: royalty-free runtime / opt-out -> a valid signed cache (so normal dev
+    doesn't hit the network) -> online validation of the token in the
+    environment (which then caches). ``refresh=True`` skips the memo and the
+    cache shortcut and forces online re-validation."""
+    global _cached_status
+    if _cached_status is not None and not refresh:
+        return _cached_status
+
+    if is_frozen() or os.environ.get(ENV_DISABLE):
+        _cached_status = LicenseStatus(True, "runtime",
+                                       reason="royalty-free runtime / check disabled")
+        return _cached_status
+
+    if not refresh:
+        cached = _read_cache()
+        if cached.valid:
+            _cached_status = cached
+            return _cached_status
+
+    token = _resolve_token()
+    if token:
+        try:
+            status = _verify_token(token)
+            if status.valid:
+                _cached_status = status
+                return _cached_status
+            _cached_status = status   # e.g. expired / revoked / seat limit
+            return _cached_status
+        except _NetworkError:
+            cached = _read_cache()    # offline: lean on the cache
+            if cached.valid:
+                _cached_status = cached
+                return _cached_status
+            _cached_status = LicenseStatus(
+                False, "none",
+                reason="offline and no valid cached entitlement; "
+                       "connect once to activate")
+            return _cached_status
+
+    _cached_status = LicenseStatus(
+        False, "none",
+        reason=("no entitlement - run 'custom-widgets-pro activate <token>' with "
+                "the licence token from your account portal, or set %s. "
+                "Unlicensed dev/eval mode." % ENV_KEY))
+    return _cached_status
+
+
+def activate(token=None):
+    """Validate a licence token **online now** and cache the result. Backs the
+    ``custom-widgets-pro activate <token>`` flow. Returns a LicenseStatus
+    (raises nothing; a network failure yields an invalid status with a reason)."""
+    global _cached_status
+    token = _resolve_token(token)
+    if not token:
+        return LicenseStatus(
+            False, "none",
+            reason="provide the licence token from your account portal")
+    try:
+        status = _verify_token(token)
+    except _NetworkError as exc:
+        return LicenseStatus(False, "none",
+                             reason="could not reach the licence server: %s" % exc)
+    if status.valid:
+        _cached_status = status
+    return status
+
+
+def require_license(feature=None):
+    """Raise LicenseError if there is no valid entitlement. Use to gate a Pro
+    feature/build step. Not called at shipped-app runtime."""
+    status = check_license()
+    if not status.valid:
+        what = (" for %r" % feature) if feature else ""
+        raise LicenseError("custom-widgets-pro entitlement required%s: %s"
+                           % (what, status.reason))
+    return status

custom_widgets_pro/_version.py

@@ -0,0 +1,14 @@
+########################################################################
+## SPINN DESIGN CODE
+# WEBSITE: customwidgets.org
+########################################################################
+"""Single source of truth for the package version.
+
+Deliberately a standalone module with **no imports**: the licence CLI and
+``_license`` both need the version string without dragging in Qt, and
+``importlib.metadata`` is unavailable when running against the source tree.
+
+Keep in step with ``version`` in pyproject.toml - ``tests/test_version.py``
+fails the build if the two ever drift.
+"""
+__version__ = "1.1.0"

custom_widgets_pro/datatable/__init__.py

@@ -0,0 +1,17 @@
+from .datatable_pro import QCustomDataTablePro
+from .virtual_model import VirtualDataTableModel, GroupRole
+from .provider import DataProvider, ListDataProvider, CallableDataProvider
+from .export import export_csv, export_xlsx, export_table
+from .frozen_view import FrozenHostView
+from .grouping import GroupingEngine, GroupRow, aggregate, AGGREGATORS
+from .pivot import pivot_table, PIVOT_COL_PREFIX, TOTAL_KEY
+
+__all__ = [
+    "QCustomDataTablePro",
+    "VirtualDataTableModel", "GroupRole",
+    "DataProvider", "ListDataProvider", "CallableDataProvider",
+    "export_csv", "export_xlsx", "export_table",
+    "FrozenHostView",
+    "GroupingEngine", "GroupRow", "aggregate", "AGGREGATORS",
+    "pivot_table", "PIVOT_COL_PREFIX", "TOTAL_KEY",
+]