poelis-sdk 0.1.8__tar.gz → 0.2.0__tar.gz

{poelis_sdk-0.1.8 → poelis_sdk-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: poelis-sdk
-Version: 0.1.8
+Version: 0.2.0
 Summary: Official Python SDK for Poelis
 Project-URL: Homepage, https://poelis.com
 Project-URL: Source, https://github.com/PoelisTechnologies/poelis-python-sdk
@@ -42,22 +42,6 @@ client = PoelisClient(
     api_key="poelis_live_A1B2C3...",    # Organization Settings → API Keys
     org_id="tenant_uci_001",            # same section
 )
-
-# Workspaces → Products
-workspaces = client.workspaces.list(limit=10, offset=0)
-ws_id = workspaces[0]["id"]
-
-page = client.products.list_by_workspace(workspace_id=ws_id, limit=10, offset=0)
-print([p.name for p in page.data])
-
-# Items for a product
-pid = page.data[0].id
-items = client.items.list_by_product(product_id=pid, limit=10, offset=0)
-print([i.get("name") for i in items])
-
-# Property search
-props = client.search.properties(q="*", workspace_id=ws_id, limit=10, offset=0)
-print(props["total"], len(props["hits"]))
 ```
 
 ## Configuration
@@ -73,7 +57,6 @@ print(props["total"], len(props["hits"]))
 ```bash
 export POELIS_API_KEY=poelis_live_A1B2C3...
 export POELIS_ORG_ID=tenant_id_001
-# POELIS_BASE_URL is optional - defaults to the managed GCP endpoint
 ```
 
 

{poelis_sdk-0.1.8 → poelis_sdk-0.2.0}/README.md

@@ -19,22 +19,6 @@ client = PoelisClient(
     api_key="poelis_live_A1B2C3...",    # Organization Settings → API Keys
     org_id="tenant_uci_001",            # same section
 )
-
-# Workspaces → Products
-workspaces = client.workspaces.list(limit=10, offset=0)
-ws_id = workspaces[0]["id"]
-
-page = client.products.list_by_workspace(workspace_id=ws_id, limit=10, offset=0)
-print([p.name for p in page.data])
-
-# Items for a product
-pid = page.data[0].id
-items = client.items.list_by_product(product_id=pid, limit=10, offset=0)
-print([i.get("name") for i in items])
-
-# Property search
-props = client.search.properties(q="*", workspace_id=ws_id, limit=10, offset=0)
-print(props["total"], len(props["hits"]))
 ```
 
 ## Configuration
@@ -50,7 +34,6 @@ print(props["total"], len(props["hits"]))
 ```bash
 export POELIS_API_KEY=poelis_live_A1B2C3...
 export POELIS_ORG_ID=tenant_id_001
-# POELIS_BASE_URL is optional - defaults to the managed GCP endpoint
 ```
 
 

poelis_sdk-0.2.0/notebooks/try_poelis_sdk.ipynb

@@ -0,0 +1,220 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Poelis Python SDK Tutorial\n",
+    "\n",
+    "Welcome to the Poelis Python SDK tutorial! This notebook will guide you through setting up and using the SDK to interact with the Poelis API.\n",
+    "\n",
+    "## What is Poelis?\n",
+    "\n",
+    "Poelis is a platform for managing hierarchical data structures, products, items, and their properties. The Python SDK provides a convenient way to interact with the Poelis API from your Python applications.\n",
+    "\n",
+    "## Table of Contents\n",
+    "\n",
+    "1. [Installation](#Installation)\n",
+    "2. [Authentication Setup](#Authentication-Setup)\n",
+    "3. [Basic Client Setup](#Basic-Client-Setup)\n",
+    "4. [Browser Interface](#Browser-Interface)\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 1. Installation\n",
+    "\n",
+    "First, let's install the Poelis Python SDK. The SDK requires Python 3.11 or higher.\n",
+    "\n",
+    "```bash\n",
+    "pip install -U poelis-sdk\n",
+    "```\n",
+    "\n",
+    "### Requirements\n",
+    "- Python >= 3.11\n",
+    "- Access to a Poelis API endpoint\n",
+    "- Valid API credentials (API key + organization ID)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!pip install -U poelis-sdk"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Import the SDK\n",
+    "from poelis_sdk import PoelisClient\n",
+    "\n",
+    "# Check if the SDK is properly installed\n",
+    "print(\"Poelis SDK imported successfully!\")\n",
+    "print(f\"PoelisClient class: {PoelisClient}\")\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 2. Authentication Setup\n",
+    "\n",
+    "Before you can use the SDK, you need to obtain your API credentials from the Poelis web interface.\n",
+    "\n",
+    "### Getting Your Credentials\n",
+    "\n",
+    "1. **Navigate to Organization Settings → API Keys** in the Poelis web interface\n",
+    "2. **Create a new API key**:\n",
+    "   - Choose a descriptive name\n",
+    "   - Select appropriate scopes\n",
+    "   - Copy the key immediately\n",
+    "3. **Note your Organization ID** (displayed in the same section)\n",
+    "\n",
+    "### Environment Variables (Recommended)\n",
+    "\n",
+    "For security, store your credentials as environment variables:\n",
+    "\n",
+    "```bash\n",
+    "export POELIS_API_KEY=poelis_live_A1B2C3...\n",
+    "export POELIS_ORG_ID=org_id_001\n",
+    "```\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 3. Basic Client Setup\n",
+    "\n",
+    "There are two ways to initialize the Poelis client:\n",
+    "\n",
+    "### Method 1: Direct Initialization (Simplified)\n",
+    "\n",
+    "```python\n",
+    "# Simple usage with defaults\n",
+    "client = PoelisClient(\n",
+    "    api_key=\"poelis_live_A1B2C3...\",\n",
+    "    org_id=\"tenant_id_001\"\n",
+    ")\n",
+    "```\n",
+    "\n",
+    "### Method 2: From Environment Variables (Recommended)\n",
+    "\n",
+    "```python\n",
+    "client = PoelisClient.from_env()\n",
+    "```\n",
+    "\n",
+    "This method automatically reads the `POELIS_API_KEY` and `POELIS_ORG_ID` environment variables.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Example: Initialize client (replace with your actual credentials)\n",
+    "# For this demo, we'll use placeholder values\n",
+    "# In practice, use environment variables or replace with your actual credentials\n",
+    "\n",
+    "try:\n",
+    "    # Try to initialize from environment variables first\n",
+    "    client = PoelisClient.from_env()\n",
+    "    print(\"✅ Client initialized from environment variables\")\n",
+    "    print(f\"Base URL: {client.base_url}\")\n",
+    "    print(f\"Organization ID: {client.org_id}\")\n",
+    "except ValueError as e:\n",
+    "    print(f\"❌ Environment variables not set: {e}\")\n",
+    "    print(\"Please set POELIS_API_KEY and POELIS_ORG_ID (POELIS_BASE_URL is optional)\")\n",
+    "    \n",
+    "# Fallback to manual initialization (replace with your credentials)\n",
+    "client = PoelisClient(\n",
+    "    api_key=\"your_api_key_here\",\n",
+    "    org_id=\"your_org_id_here\"\n",
+    ")\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 4. Browser Interface - Interactive Exploration\n",
+    "\n",
+    "The Poelis SDK provides a powerful **browser interface** for interactive exploration of your data hierarchy. This is often the best way to start exploring your data!\n",
+    "\n",
+    "### What is the Browser Interface?\n",
+    "\n",
+    "The browser interface allows you to navigate through your data using **dot notation** and **tab completion**:\n",
+    "- `client.browser` - Start here\n",
+    "- `client.browser.<workspace>` - Access a specific workspace\n",
+    "- `client.browser.<workspace>.<product>` - Access a specific product\n",
+    "- `client.browser.<workspace>.<product>.<item>` - Access a specific item\n",
+    "- And so on...\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from poelis_sdk import PoelisClient\n",
+    "\n",
+    "# 1) Create the client\n",
+    "client = PoelisClient(\n",
+    "    api_key=\"YOUR_API_KEY\",\n",
+    "    org_id=\"YOUR_ORG_ID\",\n",
+    ")\n",
+    "\n",
+    "# 2) Explore with TAB (completion is installed automatically when accessing client.browser):\n",
+    "# - Type: client.browser. and press TAB to see workspaces\n",
+    "# - Then: client.browser.<workspace>. and TAB to see products\n",
+    "# - Then: client.browser.<workspace>.<product>. and TAB to see items\n",
+    "# - On an item, TAB shows child items and property keys\n",
+    "\n",
+    "# 3) Access a property’s value and category via dot paths\n",
+    "# Example (replace names with your actual names shown by TAB):\n",
+    "workspace = client.browser.UH2_Workspace\n",
+    "val = workspace.LH2_Tank.cold_box.clv.mass.value\n",
+    "cat = workspace.LH2_Tank.cold_box.clv.mass.category\n",
+    "\n",
+    "print(\"property value:\", val)\n",
+    "print(\"property category:\", cat)\n",
+    "\n",
+    "# 4) Go deeper into child items if needed (TAB will suggest only item/property names)\n",
+    "inner = client.browser.UH2_Workspace.LH2_Tank.inner_tank"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.13"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

{poelis_sdk-0.1.8 → poelis_sdk-0.2.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "poelis-sdk"
-version = "0.1.8"
+version = "0.2.0"
 description = "Official Python SDK for Poelis"
 readme = "README.md"
 requires-python = ">=3.11"

{poelis_sdk-0.1.8 → poelis_sdk-0.2.0}/src/poelis_sdk/browser.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 from typing import Any, Dict, List, Optional
+from types import MethodType
 import re
 
 from .org_validation import get_organization_context_message
@@ -12,6 +13,10 @@ with optional property listing on items. Designed for notebook UX.
 """
 
 
+# Internal guard to avoid repeated completer installation
+_AUTO_COMPLETER_INSTALLED: bool = False
+
+
 class _Node:
     def __init__(self, client: Any, level: str, parent: Optional["_Node"], node_id: Optional[str], name: Optional[str]) -> None:
         self._client = client
@@ -33,34 +38,37 @@ class _Node:
     def __dir__(self) -> List[str]:  # pragma: no cover - notebook UX
         # Ensure children are loaded so TAB shows options immediately
         self._load_children()
-        keys = list(self._children_cache.keys()) + ["properties", "id", "name", "refresh", "names", "props"]
+        keys = list(self._children_cache.keys())
         if self._level == "item":
             # Include property names directly on item for suggestions
             prop_keys = list(self._props_key_map().keys())
             keys.extend(prop_keys)
-        return sorted(keys)
+        return sorted(set(keys))
 
-    @property
-    def id(self) -> Optional[str]:
-        return self._id
-
-    @property
-    def name(self) -> Optional[str]:
-        return self._name
-
-    def refresh(self) -> "_Node":
+    # Intentionally no public id/name/refresh to keep suggestions minimal
+    def _refresh(self) -> "_Node":
         self._children_cache.clear()
         self._props_cache = None
         return self
 
-    def names(self) -> List[str]:
-        """Return display names of children at this level (forces a lazy load)."""
+    def _names(self) -> List[str]:
+        """Return display names of children at this level (internal)."""
         self._load_children()
         return [child._name or "" for child in self._children_cache.values()]
 
+    def _suggest(self) -> List[str]:
+        """Return suggested attribute names for interactive usage.
+
+        Only child keys are returned; for item level, property keys are also included.
+        """
+        self._load_children()
+        suggestions: List[str] = list(self._children_cache.keys())
+        if self._level == "item":
+            suggestions.extend(list(self._props_key_map().keys()))
+        return sorted(set(suggestions))
+
     def __getattr__(self, attr: str) -> Any:
-        if attr in {"properties", "id", "name", "refresh"}:
-            return object.__getattribute__(self, attr)
+        # No public properties/id/name/refresh
         if attr == "props":  # item-level properties pseudo-node
             if self._level != "item":
                 raise AttributeError("props")
@@ -92,18 +100,17 @@ class _Node:
             return self._children_cache[safe]
         raise KeyError(key)
 
-    @property
-    def properties(self) -> List[Dict[str, Any]]:
+    def _properties(self) -> List[Dict[str, Any]]:
         if self._props_cache is not None:
             return self._props_cache
         if self._level != "item":
             self._props_cache = []
             return self._props_cache
-        # Try direct properties(item_id: ...) first; fallback to searchProperties
+        # Try direct properties(itemId: ...) first; fallback to searchProperties
         q = (
             "query($iid: ID!) {\n"
-            "  properties(item_id: $iid) {\n"
-            "    __typename id name owner\n"
+            "  properties(itemId: $iid) {\n"
+            "    __typename\n"
             "    ... on NumericProperty { integerPart exponent category }\n"
             "    ... on TextProperty { value }\n"
             "    ... on DateProperty { value }\n"
@@ -121,7 +128,7 @@ class _Node:
             q2 = (
                 "query($iid: ID!, $limit: Int!, $offset: Int!) {\n"
                 "  searchProperties(q: \"*\", itemId: $iid, limit: $limit, offset: $offset) {\n"
-                "    hits { id name propertyType category textValue numericValue dateValue owner }\n"
+                "    hits { id workspaceId productId itemId propertyType name category value owner }\n"
                 "  }\n"
                 "}"
             )
@@ -138,10 +145,20 @@ class _Node:
         out: Dict[str, Dict[str, Any]] = {}
         if self._level != "item":
             return out
-        props = self.properties
-        for pr in props:
-            display = pr.get("name") or pr.get("id")
+        props = self._properties()
+        used_names: Dict[str, int] = {}
+        for i, pr in enumerate(props):
+            # Try to get name from various possible fields
+            display = pr.get("name") or pr.get("id") or pr.get("category") or f"property_{i}"
             safe = _safe_key(str(display))
+            
+            # Handle duplicate names by adding a suffix
+            if safe in used_names:
+                used_names[safe] += 1
+                safe = f"{safe}_{used_names[safe]}"
+            else:
+                used_names[safe] = 0
+                
             out[safe] = _PropWrapper(pr)
         return out
 
@@ -178,7 +195,7 @@ class _Node:
                 return
             q = (
                 "query($pid: ID!, $parent: ID!, $limit: Int!, $offset: Int!) {\n"
-                "  items(productId: $pid, parentItemId: $parent, limit: $limit, offset: $offset) { id name code description productId parentId owner }\n"
+                "  items(productId: $pid, parentItemId: $parent, limit: $limit, offset: $offset) { id name code description productId parentId owner position }\n"
                 "}"
             )
             r = self._client._transport.graphql(q, {"pid": pid, "parent": self._id, "limit": 1000, "offset": 0})
@@ -201,6 +218,15 @@ class Browser:
 
     def __init__(self, client: Any) -> None:
         self._root = _Node(client, "root", None, None, None)
+        # Best-effort: auto-enable curated completion in interactive shells
+        global _AUTO_COMPLETER_INSTALLED
+        if not _AUTO_COMPLETER_INSTALLED:
+            try:
+                if enable_dynamic_completion():
+                    _AUTO_COMPLETER_INSTALLED = True
+            except Exception:
+                # Non-interactive or IPython not available; ignore silently
+                pass
 
     def __getattr__(self, attr: str) -> Any:  # pragma: no cover - notebook UX
         return getattr(self._root, attr)
@@ -217,7 +243,15 @@ class Browser:
     def __dir__(self) -> list[str]:  # pragma: no cover - notebook UX
         # Ensure children are loaded so TAB shows options
         self._root._load_children()
-        return sorted([*self._root._children_cache.keys(), "names"]) 
+        return sorted([*self._root._children_cache.keys()]) 
+
+    def _names(self) -> List[str]:
+        """Return display names of root-level children (workspaces)."""
+        return self._root._names()
+
+    # keep suggest internal so it doesn't appear in help/dir
+    def _suggest(self) -> List[str]:
+        return self._root._suggest()
 
 
 def _safe_key(name: str) -> str:
@@ -245,16 +279,28 @@ class _PropsNode:
     def _ensure_loaded(self) -> None:
         if self._children_cache:
             return
-        props = self._item.properties
-        for pr in props:
-            display = pr.get("name") or pr.get("id")
+        props = self._item._properties()
+        used_names: Dict[str, int] = {}
+        names_list = []
+        for i, pr in enumerate(props):
+            # Try to get name from various possible fields
+            display = pr.get("name") or pr.get("id") or pr.get("category") or f"property_{i}"
             safe = _safe_key(str(display))
+            
+            # Handle duplicate names by adding a suffix
+            if safe in used_names:
+                used_names[safe] += 1
+                safe = f"{safe}_{used_names[safe]}"
+            else:
+                used_names[safe] = 0
+                
             self._children_cache[safe] = _PropWrapper(pr)
-        self._names = [p.get("name") or p.get("id") for p in props]
+            names_list.append(display)
+        self._names = names_list
 
     def __dir__(self) -> List[str]:  # pragma: no cover - notebook UX
         self._ensure_loaded()
-        return sorted(list(self._children_cache.keys()) + ["names"]) 
+        return sorted(list(self._children_cache.keys())) 
 
     def names(self) -> List[str]:
         self._ensure_loaded()
@@ -272,13 +318,21 @@ class _PropsNode:
             return self._children_cache[key]
         # match by display name
         for safe, data in self._children_cache.items():
-            if data.raw.get("name") == key:
-                return data
+            try:
+                if getattr(data, "_raw", {}).get("name") == key:  # type: ignore[arg-type]
+                    return data
+            except Exception:
+                continue
         safe = _safe_key(key)
         if safe in self._children_cache:
             return self._children_cache[safe]
         raise KeyError(key)
 
+    # keep suggest internal so it doesn't appear in help/dir
+    def _suggest(self) -> List[str]:
+        self._ensure_loaded()
+        return sorted(list(self._children_cache.keys()))
+
 
 class _PropWrapper:
     """Lightweight accessor for a property dict, exposing `.value` and `.raw`.
@@ -289,10 +343,6 @@ class _PropWrapper:
     def __init__(self, prop: Dict[str, Any]) -> None:
         self._raw = prop
 
-    @property
-    def raw(self) -> Dict[str, Any]:
-        return self._raw
-
     @property
     def value(self) -> Any:  # type: ignore[override]
         p = self._raw
@@ -315,8 +365,123 @@ class _PropWrapper:
             return p.get("value")
         return None
 
+    @property
+    def category(self) -> Optional[str]:
+        p = self._raw
+        cat = p.get("category")
+        return str(cat) if cat is not None else None
+
+    def __dir__(self) -> List[str]:  # pragma: no cover - notebook UX
+        # Expose only the minimal attributes for browsing
+        return ["value", "category"]
+
     def __repr__(self) -> str:  # pragma: no cover - notebook UX
         name = self._raw.get("name") or self._raw.get("id")
         return f"<property {name}: {self.value}>"
 
 
+
+def enable_dynamic_completion() -> bool:
+    """Enable dynamic attribute completion in IPython/Jupyter environments.
+
+    This helper attempts to configure IPython to use runtime-based completion
+    (disabling Jedi) so that our dynamic `__dir__` and `suggest()` methods are
+    respected by TAB completion. Returns True if an interactive shell was found
+    and configured, False otherwise.
+    """
+
+    try:
+        # Deferred import to avoid hard dependency
+        from IPython import get_ipython  # type: ignore
+    except Exception:
+        return False
+
+    ip = None
+    try:
+        ip = get_ipython()  # type: ignore[assignment]
+    except Exception:
+        ip = None
+    if ip is None:
+        return False
+
+    enabled = False
+    # Best-effort configuration: rely on IPython's fallback (non-Jedi) completer
+    try:
+        if hasattr(ip, "Completer") and hasattr(ip.Completer, "use_jedi"):
+            # Disable Jedi to let IPython consult __dir__ dynamically
+            ip.Completer.use_jedi = False  # type: ignore[assignment]
+            # Greedy completion improves attribute completion depth
+            if hasattr(ip.Completer, "greedy"):
+                ip.Completer.greedy = True  # type: ignore[assignment]
+            enabled = True
+    except Exception:
+        pass
+
+    # Additionally, install a lightweight attribute completer that uses suggest()
+    try:
+        comp = getattr(ip, "Completer", None)
+        if comp is not None and hasattr(comp, "attr_matches"):
+            orig_attr_matches = comp.attr_matches  # type: ignore[attr-defined]
+
+            def _poelis_attr_matches(self: Any, text: str) -> List[str]:  # pragma: no cover - interactive behavior
+                try:
+                    # text is like "client.browser.uh2.pr" → split at last dot
+                    obj_expr, _, prefix = text.rpartition(".")
+                    if not obj_expr:
+                        return orig_attr_matches(text)  # type: ignore[operator]
+                    # Evaluate the object in the user namespace
+                    ns = getattr(self, "namespace", {})
+                    obj_val = eval(obj_expr, ns, ns)
+
+                    # For Poelis browser objects, show ONLY our curated suggestions
+                    from_types = (Browser, _Node, _PropsNode, _PropWrapper)
+                    if isinstance(obj_val, from_types):
+                        # Build suggestion list
+                        if isinstance(obj_val, _PropWrapper):
+                            sugg: List[str] = ["value", "category"]
+                        elif hasattr(obj_val, "_suggest"):
+                            sugg = list(getattr(obj_val, "_suggest")())  # type: ignore[no-untyped-call]
+                        else:
+                            sugg = list(dir(obj_val))
+                        # Filter by prefix and format matches as full attribute paths
+                        out: List[str] = []
+                        for s in sugg:
+                            if not prefix or str(s).startswith(prefix):
+                                out.append(f"{obj_expr}.{s}")
+                        return out
+
+                    # Otherwise, fall back to default behavior
+                    return orig_attr_matches(text)  # type: ignore[operator]
+                except Exception:
+                    # fall back to original on any error
+                    return orig_attr_matches(text)  # type: ignore[operator]
+
+            comp.attr_matches = MethodType(_poelis_attr_matches, comp)  # type: ignore[assignment]
+            enabled = True
+    except Exception:
+        pass
+
+    # Also register as a high-priority matcher in IPCompleter.matchers
+    try:
+        comp = getattr(ip, "Completer", None)
+        if comp is not None and hasattr(comp, "matchers") and not getattr(comp, "_poelis_matcher_installed", False):
+            orig_attr_matches = comp.attr_matches  # type: ignore[attr-defined]
+
+            def _poelis_matcher(self: Any, text: str) -> List[str]:  # pragma: no cover - interactive behavior
+                # Delegate to our attribute logic for dotted expressions; otherwise empty
+                if "." in text:
+                    try:
+                        return self.attr_matches(text)  # type: ignore[operator]
+                    except Exception:
+                        return orig_attr_matches(text)  # type: ignore[operator]
+                return []
+
+            # Prepend our matcher so it's consulted early
+            comp.matchers.insert(0, MethodType(_poelis_matcher, comp))  # type: ignore[arg-type]
+            setattr(comp, "_poelis_matcher_installed", True)
+            enabled = True
+    except Exception:
+        pass
+
+    return bool(enabled)
+