poelis-sdk 0.3.2__tar.gz → 0.3.4__tar.gz

{poelis_sdk-0.3.2 → poelis_sdk-0.3.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: poelis-sdk
-Version: 0.3.2
+Version: 0.3.4
 Summary: Official Python SDK for Poelis
 Project-URL: Homepage, https://poelis.com
 Project-URL: Source, https://github.com/PoelisTechnologies/poelis-python-sdk

{poelis_sdk-0.3.2 → poelis_sdk-0.3.4}/pyproject.toml

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

{poelis_sdk-0.3.2 → poelis_sdk-0.3.4}/src/poelis_sdk/__init__.py

@@ -7,7 +7,7 @@ metadata so it stays in sync with ``pyproject.toml`` without manual edits.
 from importlib import metadata
 
 from .client import PoelisClient
-from .logging import configure_logging, quiet_logging, verbose_logging, debug_logging, get_logger
+from .logging import configure_logging, debug_logging, get_logger, quiet_logging, verbose_logging
 
 __all__ = ["PoelisClient", "__version__", "configure_logging", "quiet_logging", "verbose_logging", "debug_logging", "get_logger"]
 

{poelis_sdk-0.3.2 → poelis_sdk-0.3.4}/src/poelis_sdk/_transport.py

@@ -1,12 +1,20 @@
 from __future__ import annotations
 
-from typing import Any, Dict, Mapping, Optional
 import os
-import time
 import random
+import time
+from typing import Any, Dict, Mapping, Optional
+
 import httpx
 
-from .exceptions import ClientError, HTTPError, NotFoundError, RateLimitError, ServerError, UnauthorizedError
+from .exceptions import (
+    ClientError,
+    HTTPError,
+    NotFoundError,
+    RateLimitError,
+    ServerError,
+    UnauthorizedError,
+)
 
 """HTTP transport abstraction for the Poelis SDK.
 

{poelis_sdk-0.3.2 → poelis_sdk-0.3.4}/src/poelis_sdk/browser.py

@@ -1,9 +1,9 @@
 from __future__ import annotations
 
-from typing import Any, Dict, List, Optional
-from types import MethodType
 import re
 import time
+from types import MethodType
+from typing import Any, Dict, List, Optional
 
 from .org_validation import get_organization_context_message
 
@@ -140,39 +140,77 @@ class _Node:
             self._props_loaded_at = time.time()
             return self._props_cache
         # Try direct properties(itemId: ...) first; fallback to searchProperties
-        q = (
-            "query($iid: ID!) {\n"
+        # Attempt 1: query with parsedValue support
+        q_parsed = (
+            "query($iid: ID!) \n"
             "  properties(itemId: $iid) {\n"
             "    __typename\n"
-            "    ... on NumericProperty { integerPart exponent category }\n"
-            "    ... on TextProperty { value }\n"
-            "    ... on DateProperty { value }\n"
+            "    ... on NumericProperty { id name category value parsedValue }\n"
+            "    ... on TextProperty { id name value parsedValue }\n"
+            "    ... on DateProperty { id name value }\n"
             "  }\n"
             "}"
         )
         try:
-            r = self._client._transport.graphql(q, {"iid": self._id})
+            r = self._client._transport.graphql(q_parsed, {"iid": self._id})
             r.raise_for_status()
             data = r.json()
             if "errors" in data:
-                raise RuntimeError(data["errors"])  # trigger fallback
+                raise RuntimeError(data["errors"])  # try value-only shape
             self._props_cache = data.get("data", {}).get("properties", []) or []
             self._props_loaded_at = time.time()
         except Exception:
-            q2 = (
-                "query($iid: ID!, $limit: Int!, $offset: Int!) {\n"
-                "  searchProperties(q: \"*\", itemId: $iid, limit: $limit, offset: $offset) {\n"
-                "    hits { id workspaceId productId itemId propertyType name category value owner }\n"
+            # Attempt 2: value-only, legacy compatible
+            q_value_only = (
+                "query($iid: ID!) \n"
+                "  properties(itemId: $iid) {\n"
+                "    __typename\n"
+                "    ... on NumericProperty { id name category value }\n"
+                "    ... on TextProperty { id name value }\n"
+                "    ... on DateProperty { id name value }\n"
                 "  }\n"
                 "}"
             )
-            r2 = self._client._transport.graphql(q2, {"iid": self._id, "limit": 100, "offset": 0})
-            r2.raise_for_status()
-            data2 = r2.json()
-            if "errors" in data2:
-                raise RuntimeError(data2["errors"])  # propagate
-            self._props_cache = data2.get("data", {}).get("searchProperties", {}).get("hits", []) or []
-            self._props_loaded_at = time.time()
+            try:
+                r = self._client._transport.graphql(q_value_only, {"iid": self._id})
+                r.raise_for_status()
+                data = r.json()
+                if "errors" in data:
+                    raise RuntimeError(data["errors"])  # trigger fallback to search
+                self._props_cache = data.get("data", {}).get("properties", []) or []
+                self._props_loaded_at = time.time()
+            except Exception:
+                # Fallback to searchProperties
+                q2_parsed = (
+                    "query($iid: ID!, $limit: Int!, $offset: Int!) {\n"
+                    "  searchProperties(q: \"*\", itemId: $iid, limit: $limit, offset: $offset) {\n"
+                    "    hits { id workspaceId productId itemId propertyType name category value parsedValue owner }\n"
+                    "  }\n"
+                    "}"
+                )
+                try:
+                    r2 = self._client._transport.graphql(q2_parsed, {"iid": self._id, "limit": 100, "offset": 0})
+                    r2.raise_for_status()
+                    data2 = r2.json()
+                    if "errors" in data2:
+                        raise RuntimeError(data2["errors"])  # try minimal
+                    self._props_cache = data2.get("data", {}).get("searchProperties", {}).get("hits", []) or []
+                    self._props_loaded_at = time.time()
+                except Exception:
+                    q2_min = (
+                        "query($iid: ID!, $limit: Int!, $offset: Int!) {\n"
+                        "  searchProperties(q: \"*\", itemId: $iid, limit: $limit, offset: $offset) {\n"
+                        "    hits { id workspaceId productId itemId propertyType name category value owner }\n"
+                        "  }\n"
+                        "}"
+                    )
+                    r3 = self._client._transport.graphql(q2_min, {"iid": self._id, "limit": 100, "offset": 0})
+                    r3.raise_for_status()
+                    data3 = r3.json()
+                    if "errors" in data3:
+                        raise RuntimeError(data3["errors"])  # propagate
+                    self._props_cache = data3.get("data", {}).get("searchProperties", {}).get("hits", []) or []
+                    self._props_loaded_at = time.time()
         return self._props_cache
 
     def _props_key_map(self) -> Dict[str, Dict[str, Any]]:
@@ -419,6 +457,10 @@ class _PropWrapper:
     @property
     def value(self) -> Any:  # type: ignore[override]
         p = self._raw
+        # Use parsedValue if available (new backend feature)
+        if "parsedValue" in p:
+            return p["parsedValue"]
+        # Fallback to legacy parsing logic for backward compatibility
         # searchProperties shape
         if "numericValue" in p and p.get("numericValue") is not None:
             return p["numericValue"]

{poelis_sdk-0.3.2 → poelis_sdk-0.3.4}/src/poelis_sdk/client.py

@@ -1,16 +1,17 @@
 from __future__ import annotations
 
-from typing import Optional
 import os
+from typing import Optional
 
 from pydantic import BaseModel, Field, HttpUrl
+
 from ._transport import Transport
-from .products import ProductsClient
+from .browser import Browser
 from .items import ItemsClient
+from .logging import quiet_logging
+from .products import ProductsClient
 from .search import SearchClient
 from .workspaces import WorkspacesClient
-from .browser import Browser
-from .logging import quiet_logging
 
 """Core client for the Poelis Python SDK.
 

{poelis_sdk-0.3.2 → poelis_sdk-0.3.4}/src/poelis_sdk/items.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import Generator, Any, Optional, Dict, List
+from typing import Any, Dict, Generator, List, Optional
 
 from ._transport import Transport
 

poelis_sdk-0.3.4/src/poelis_sdk/models.py

@@ -0,0 +1,130 @@
+from __future__ import annotations
+
+from typing import Any, List, Optional, Union
+
+from pydantic import BaseModel, Field
+
+"""Pydantic models for SDK resources."""
+
+
+class Product(BaseModel):
+    """Product resource representation."""
+
+    id: str = Field(min_length=1)
+    name: str = Field(min_length=1)
+    workspaceId: Optional[str] = None
+    code: Optional[str] = None
+    description: Optional[str] = None
+
+
+class PaginatedProducts(BaseModel):
+    """Paginated response for products list."""
+
+    data: list[Product]
+    limit: int
+    offset: int
+
+
+class PropertyValue(BaseModel):
+    """Base class for property values with typed access."""
+    
+    raw_value: str = Field(alias="value")
+    parsed_value: Optional[Any] = Field(alias="parsedValue", default=None)
+    
+    @property
+    def value(self) -> Any:
+        """Get the properly typed value, falling back to raw string if parsing failed."""
+        return self.parsed_value if self.parsed_value is not None else self.raw_value
+
+
+class NumericProperty(BaseModel):
+    """Numeric property representation."""
+    
+    id: str = Field(min_length=1)
+    item_id: str = Field(alias="itemId", min_length=1)
+    position: float
+    name: str = Field(min_length=1)
+    value: str
+    category: str
+    display_unit: Optional[str] = Field(alias="displayUnit", default=None)
+    owner: str = Field(min_length=1)
+    type: str = Field(min_length=1)
+    parsed_value: Optional[Union[int, float, List[Any], str]] = Field(alias="parsedValue", default=None)
+    
+    @property
+    def typed_value(self) -> Union[int, float, List[Any], str]:
+        """Get the properly typed value, falling back to raw string if parsing failed."""
+        return self.parsed_value if self.parsed_value is not None else self.value
+
+
+class TextProperty(BaseModel):
+    """Text property representation."""
+    
+    id: str = Field(min_length=1)
+    item_id: str = Field(alias="itemId", min_length=1)
+    position: float
+    name: str = Field(min_length=1)
+    value: str
+    owner: str = Field(min_length=1)
+    type: str = Field(min_length=1)
+    parsed_value: Optional[Union[int, float, List[Any], str]] = Field(alias="parsedValue", default=None)
+    
+    @property
+    def typed_value(self) -> Union[int, float, List[Any], str]:
+        """Get the properly typed value, falling back to raw string if parsing failed."""
+        return self.parsed_value if self.parsed_value is not None else self.value
+
+
+class DateProperty(BaseModel):
+    """Date property representation."""
+    
+    id: str = Field(min_length=1)
+    item_id: str = Field(alias="itemId", min_length=1)
+    position: float
+    name: str = Field(min_length=1)
+    value: str
+    owner: str = Field(min_length=1)
+    type: str = Field(min_length=1)
+    parsed_value: Optional[str] = Field(alias="parsedValue", default=None)
+    
+    @property
+    def typed_value(self) -> str:
+        """Get the properly typed value, falling back to raw string if parsing failed."""
+        return self.parsed_value if self.parsed_value is not None else self.value
+
+
+class PropertySearchResult(BaseModel):
+    """Property search result with unified fields across all property types."""
+    
+    id: str = Field(min_length=1)
+    workspace_id: str = Field(alias="workspaceId", min_length=1)
+    product_id: str = Field(alias="productId", min_length=1)
+    item_id: str = Field(alias="itemId", min_length=1)
+    property_type: str = Field(alias="propertyType", min_length=1)
+    name: str = Field(min_length=1)
+    category: Optional[str] = None
+    display_unit: Optional[str] = Field(alias="displayUnit", default=None)
+    value: Any  # Raw value from GraphQL
+    parsed_value: Optional[Union[int, float, List[Any], str]] = Field(alias="parsedValue", default=None)
+    owner: str = Field(min_length=1)
+    created_by: str = Field(alias="createdBy", min_length=1)
+    created_at: str = Field(alias="createdAt", min_length=1)
+    updated_at: str = Field(alias="updatedAt", min_length=1)
+    
+    @property
+    def typed_value(self) -> Union[int, float, List[Any], str]:
+        """Get the properly typed value, falling back to raw string if parsing failed."""
+        return self.parsed_value if self.parsed_value is not None else self.value
+
+
+class PropertySearchResponse(BaseModel):
+    """Response for property search queries."""
+    
+    query: str
+    hits: List[PropertySearchResult]
+    total: int
+    limit: int
+    offset: int
+    processing_time_ms: int = Field(alias="processingTimeMs")
+
+

{poelis_sdk-0.3.2 → poelis_sdk-0.3.4}/src/poelis_sdk/products.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import Generator, Optional, TYPE_CHECKING
+from typing import TYPE_CHECKING, Generator, Optional
 
 from ._transport import Transport
 from .models import PaginatedProducts, Product

{poelis_sdk-0.3.2 → poelis_sdk-0.3.4}/src/poelis_sdk/search.py

@@ -54,7 +54,7 @@ class SearchClient:
             "query($q: String!, $ws: ID, $pid: ID, $iid: ID, $ptype: String, $cat: String, $limit: Int!, $offset: Int!, $sort: String) {\n"
             "  searchProperties(q: $q, workspaceId: $ws, productId: $pid, itemId: $iid, propertyType: $ptype, category: $cat, limit: $limit, offset: $offset, sort: $sort) {\n"
             "    query total limit offset processingTimeMs\n"
-            "    hits { id workspaceId productId itemId propertyType name category value owner }\n"
+            "    hits { id workspaceId productId itemId propertyType name category value parsedValue owner }\n"
             "  }\n"
             "}"
         )

{poelis_sdk-0.3.2 → poelis_sdk-0.3.4}/src/poelis_sdk/workspaces.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 from typing import Any, Dict, List, Optional
 
 from ._transport import Transport
-from .org_validation import validate_workspace_organization, filter_by_organization
+from .org_validation import filter_by_organization, validate_workspace_organization
 
 """Workspaces GraphQL client."""
 

{poelis_sdk-0.3.2 → poelis_sdk-0.3.4}/tests/test_integration_smoke.py

@@ -6,6 +6,7 @@ Skips by default unless POELIS_API_KEY and POELIS_ORG_ID are set.
 from __future__ import annotations
 
 import os
+
 import pytest
 
 from poelis_sdk import PoelisClient

poelis_sdk-0.3.4/tests/test_typed_properties.py

@@ -0,0 +1,212 @@
+"""Tests for typed property values functionality."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from poelis_sdk.browser import _PropWrapper
+from poelis_sdk.models import DateProperty, NumericProperty, PropertySearchResult, TextProperty
+
+if TYPE_CHECKING:
+    from _pytest.capture import CaptureFixture  # noqa: F401
+    from _pytest.fixtures import FixtureRequest  # noqa: F401
+    from _pytest.logging import LogCaptureFixture  # noqa: F401
+    from _pytest.monkeypatch import MonkeyPatch  # noqa: F401
+    from pytest_mock.plugin import MockerFixture  # noqa: F401
+
+
+class TestTypedPropertyModels:
+    """Test Pydantic models for typed property values."""
+
+    def test_numeric_property_with_parsed_value(self) -> None:
+        """Test NumericProperty model with parsedValue field."""
+        prop_data = {
+            "id": "prop1",
+            "itemId": "item1",
+            "position": 1.0,
+            "name": "Weight",
+            "value": "42.5",
+            "category": "Physical",
+            "displayUnit": "kg",
+            "owner": "user1",
+            "type": "numeric",
+            "parsedValue": 42.5
+        }
+        
+        prop = NumericProperty(**prop_data)
+        assert prop.typed_value == 42.5
+        assert isinstance(prop.typed_value, float)
+        assert prop.value == "42.5"  # Raw value remains string
+
+    def test_numeric_property_without_parsed_value(self) -> None:
+        """Test NumericProperty model without parsedValue field (fallback)."""
+        prop_data = {
+            "id": "prop1",
+            "itemId": "item1",
+            "position": 1.0,
+            "name": "Weight",
+            "value": "42.5",
+            "category": "Physical",
+            "displayUnit": "kg",
+            "owner": "user1",
+            "type": "numeric"
+        }
+        
+        prop = NumericProperty(**prop_data)
+        assert prop.typed_value == "42.5"  # Falls back to raw string
+        assert prop.value == "42.5"
+
+    def test_text_property_with_parsed_array(self) -> None:
+        """Test TextProperty model with parsed array value."""
+        prop_data = {
+            "id": "prop2",
+            "itemId": "item1",
+            "position": 2.0,
+            "name": "Tags",
+            "value": '["tag1", "tag2", "tag3"]',
+            "owner": "user1",
+            "type": "text",
+            "parsedValue": ["tag1", "tag2", "tag3"]
+        }
+        
+        prop = TextProperty(**prop_data)
+        assert prop.typed_value == ["tag1", "tag2", "tag3"]
+        assert isinstance(prop.typed_value, list)
+        assert prop.value == '["tag1", "tag2", "tag3"]'  # Raw value remains string
+
+    def test_text_property_with_parsed_integer(self) -> None:
+        """Test TextProperty model with parsed integer value."""
+        prop_data = {
+            "id": "prop3",
+            "itemId": "item1",
+            "position": 3.0,
+            "name": "Count",
+            "value": "100",
+            "owner": "user1",
+            "type": "text",
+            "parsedValue": 100
+        }
+        
+        prop = TextProperty(**prop_data)
+        assert prop.typed_value == 100
+        assert isinstance(prop.typed_value, int)
+        assert prop.value == "100"  # Raw value remains string
+
+    def test_date_property_with_parsed_value(self) -> None:
+        """Test DateProperty model with parsedValue field."""
+        prop_data = {
+            "id": "prop4",
+            "itemId": "item1",
+            "position": 4.0,
+            "name": "Created Date",
+            "value": "2024-01-15",
+            "owner": "user1",
+            "type": "date",
+            "parsedValue": "2024-01-15"
+        }
+        
+        prop = DateProperty(**prop_data)
+        assert prop.typed_value == "2024-01-15"
+        assert isinstance(prop.typed_value, str)
+        assert prop.value == "2024-01-15"
+
+    def test_property_search_result_with_parsed_value(self) -> None:
+        """Test PropertySearchResult model with parsedValue field."""
+        result_data = {
+            "id": "prop5",
+            "workspaceId": "ws1",
+            "productId": "prod1",
+            "itemId": "item1",
+            "propertyType": "numeric",
+            "name": "Temperature",
+            "category": "Environmental",
+            "displayUnit": "°C",
+            "value": "25.3",
+            "parsedValue": 25.3,
+            "owner": "user1",
+            "createdBy": "user1",
+            "createdAt": "2024-01-15T10:00:00Z",
+            "updatedAt": "2024-01-15T10:00:00Z"
+        }
+        
+        result = PropertySearchResult(**result_data)
+        assert result.typed_value == 25.3
+        assert isinstance(result.typed_value, float)
+        assert result.value == "25.3"  # Raw value remains string
+
+
+class TestPropWrapper:
+    """Test _PropWrapper class with typed values."""
+
+    def test_prop_wrapper_with_parsed_value(self) -> None:
+        """Test _PropWrapper with parsedValue field."""
+        prop_data = {
+            "id": "prop1",
+            "name": "Weight",
+            "value": "42.5",
+            "parsedValue": 42.5,
+            "category": "Physical"
+        }
+        
+        wrapper = _PropWrapper(prop_data)
+        assert wrapper.value == 42.5
+        assert isinstance(wrapper.value, float)
+        assert wrapper.category == "Physical"
+
+    def test_prop_wrapper_without_parsed_value_fallback(self) -> None:
+        """Test _PropWrapper fallback when parsedValue is not available."""
+        prop_data = {
+            "id": "prop1",
+            "name": "Weight",
+            "value": "42.5",
+            "category": "Physical"
+        }
+        
+        wrapper = _PropWrapper(prop_data)
+        assert wrapper.value == "42.5"  # Falls back to raw value
+        assert isinstance(wrapper.value, str)
+        assert wrapper.category == "Physical"
+
+    def test_prop_wrapper_with_parsed_array(self) -> None:
+        """Test _PropWrapper with parsed array value."""
+        prop_data = {
+            "id": "prop2",
+            "name": "Tags",
+            "value": '["tag1", "tag2"]',
+            "parsedValue": ["tag1", "tag2"],
+            "category": "Metadata"
+        }
+        
+        wrapper = _PropWrapper(prop_data)
+        assert wrapper.value == ["tag1", "tag2"]
+        assert isinstance(wrapper.value, list)
+        assert wrapper.category == "Metadata"
+
+    def test_prop_wrapper_legacy_numeric_parsing(self) -> None:
+        """Test _PropWrapper with legacy numeric parsing (integerPart/exponent)."""
+        prop_data = {
+            "id": "prop3",
+            "name": "Legacy Numeric",
+            "integerPart": 42,
+            "exponent": 1,
+            "category": "Legacy"
+        }
+        
+        wrapper = _PropWrapper(prop_data)
+        assert wrapper.value == 420  # 42 * 10^1
+        assert isinstance(wrapper.value, int)
+        assert wrapper.category == "Legacy"
+
+    def test_prop_wrapper_legacy_search_properties(self) -> None:
+        """Test _PropWrapper with legacy searchProperties format."""
+        prop_data = {
+            "id": "prop4",
+            "name": "Search Numeric",
+            "numericValue": 123.45,
+            "category": "Search"
+        }
+        
+        wrapper = _PropWrapper(prop_data)
+        assert wrapper.value == 123.45
+        assert isinstance(wrapper.value, float)
+        assert wrapper.category == "Search"

{poelis_sdk-0.3.2 → poelis_sdk-0.3.4}/uv.lock

@@ -538,7 +538,7 @@ wheels = [
 
 [[package]]
 name = "poelis-sdk"
-version = "0.3.2"
+version = "0.3.4"
 source = { editable = "." }
 dependencies = [
     { name = "build" },

poelis_sdk-0.3.2/src/poelis_sdk/models.py

@@ -1,27 +0,0 @@
-from __future__ import annotations
-
-from typing import Optional
-
-from pydantic import BaseModel, Field
-
-"""Pydantic models for SDK resources."""
-
-
-class Product(BaseModel):
-    """Product resource representation."""
-
-    id: str = Field(min_length=1)
-    name: str = Field(min_length=1)
-    workspaceId: Optional[str] = None
-    code: Optional[str] = None
-    description: Optional[str] = None
-
-
-class PaginatedProducts(BaseModel):
-    """Paginated response for products list."""
-
-    data: list[Product]
-    limit: int
-    offset: int
-
-

{poelis_sdk-0.3.2 → poelis_sdk-0.3.4}/src/tests/test_client_basic.py

@@ -8,7 +8,6 @@ from __future__ import annotations
 
 from typing import TYPE_CHECKING
 
-
 from poelis_sdk import PoelisClient
 
 if TYPE_CHECKING:
@@ -37,6 +36,7 @@ def test_client_api_key_headers(monkeypatch: "MonkeyPatch") -> None:
     """When api_key and org_id are provided, use API key and X-Poelis-Org headers by default."""
 
     import httpx
+
     from poelis_sdk.client import Transport as _T
 
     class _Tpt(httpx.BaseTransport):

{poelis_sdk-0.3.2 → poelis_sdk-0.3.4}/tests/test_browser_navigation.py

@@ -5,8 +5,8 @@ These tests avoid reliance on IPython and focus on programmatic APIs.
 
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Any, Dict
 import json
+from typing import TYPE_CHECKING, Any, Dict
 
 import httpx