cognite-neat 1.0.25__py3-none-any.whl → 1.0.27__py3-none-any.whl

cognite/neat/_client/statistics_api.py

@@ -1,9 +1,14 @@
-from cognite.neat._client.api import NeatAPI
-from cognite.neat._client.data_classes import StatisticsResponse
-from cognite.neat._utils.http_client import ParametersRequest
+from cognite.neat._utils.http_client import HTTPClient, ParametersRequest
 
+from .config import NeatClientConfig
+from .data_classes import StatisticsResponse
+
+
+class StatisticsAPI:
+    def __init__(self, neat_config: NeatClientConfig, http_client: HTTPClient) -> None:
+        self._config = neat_config
+        self._http_client = http_client
 
-class StatisticsAPI(NeatAPI):
     def project(self) -> StatisticsResponse:
         """Retrieve project-wide usage data and limits.
 

cognite/neat/_client/views_api.py

@@ -2,46 +2,45 @@ from __future__ import annotations
 
 from collections.abc import Sequence
 
-from cognite.neat._data_model.models.dms import DataModelBody, ViewReference, ViewRequest, ViewResponse
-from cognite.neat._utils.collection import chunker_sequence
-from cognite.neat._utils.http_client import ItemIDBody, ItemsRequest, ParametersRequest
-from cognite.neat._utils.useful_types import PrimitiveType
+from cognite.neat._data_model.models.dms import ViewReference, ViewRequest, ViewResponse
+from cognite.neat._utils.http_client import HTTPClient, SuccessResponse
 
-from .api import NeatAPI
+from .api import Endpoint, NeatAPI
+from .config import NeatClientConfig
 from .data_classes import PagedResponse
+from .filters import ViewFilter
 
 
 class ViewsAPI(NeatAPI):
-    ENDPOINT = "/models/views"
-    LIST_REQUEST_LIMIT = 1000
+    def __init__(self, neat_config: NeatClientConfig, http_client: HTTPClient) -> None:
+        super().__init__(
+            neat_config,
+            http_client,
+            endpoint_map={
+                "apply": Endpoint("POST", "/models/views", item_limit=100),
+                "retrieve": Endpoint("POST", "/models/views/byids", item_limit=100),
+                "delete": Endpoint("POST", "/models/views/delete", item_limit=100),
+                "list": Endpoint("GET", "/models/views", item_limit=1000),
+            },
+        )
+
+    def _validate_page_response(self, response: SuccessResponse) -> PagedResponse[ViewResponse]:
+        return PagedResponse[ViewResponse].model_validate_json(response.body)
+
+    def _validate_id_response(self, response: SuccessResponse) -> list[ViewReference]:
+        return PagedResponse[ViewReference].model_validate_json(response.body).items
 
     def apply(self, items: Sequence[ViewRequest]) -> list[ViewResponse]:
         """Create or update views in CDF Project.
+
         Args:
             items: List of ViewRequest objects to create or update.
         Returns:
             List of ViewResponse objects.
         """
-        if not items:
-            return []
-        if len(items) > 100:
-            raise ValueError("Cannot apply more than 100 views at once.")
-        result = self._http_client.request_with_retries(
-            ItemsRequest(
-                endpoint_url=self._config.create_api_url(self.ENDPOINT),
-                method="POST",
-                body=DataModelBody(items=items),
-            )
-        )
-        result.raise_for_status()
-        result = PagedResponse[ViewResponse].model_validate_json(result.success_response.body)
-        return result.items
+        return self._request_item_response(items, "apply")
 
-    def retrieve(
-        self,
-        items: list[ViewReference],
-        include_inherited_properties: bool = True,
-    ) -> list[ViewResponse]:
+    def retrieve(self, items: list[ViewReference], include_inherited_properties: bool = True) -> list[ViewResponse]:
         """Retrieve views by their identifiers.
 
         Args:
@@ -51,42 +50,20 @@ class ViewsAPI(NeatAPI):
         Returns:
             List of ViewResponse objects.
         """
-        results: list[ViewResponse] = []
-        for chunk in chunker_sequence(items, 100):
-            batch = self._http_client.request_with_retries(
-                ItemsRequest(
-                    endpoint_url=self._config.create_api_url(f"{self.ENDPOINT}/byids"),
-                    method="POST",
-                    body=ItemIDBody(items=chunk),
-                    parameters={"includeInheritedProperties": include_inherited_properties},
-                )
-            )
-            batch.raise_for_status()
-            result = PagedResponse[ViewResponse].model_validate_json(batch.success_response.body)
-            results.extend(result.items)
-        return results
+        return self._request_item_response(
+            items, "retrieve", extra_body={"includeInheritedProperties": include_inherited_properties}
+        )
 
     def delete(self, items: list[ViewReference]) -> list[ViewReference]:
         """Delete views by their identifiers.
 
         Args:
             items: List of (space, external_id, version) tuples identifying the views to delete.
+
+        Returns:
+            List of ViewReference objects representing the deleted views.
         """
-        if not items:
-            return []
-        if len(items) > 100:
-            raise ValueError("Cannot delete more than 100 views at once.")
-
-        result = self._http_client.request_with_retries(
-            ItemsRequest(
-                endpoint_url=self._config.create_api_url(f"{self.ENDPOINT}/delete"),
-                method="POST",
-                body=ItemIDBody(items=items),
-            )
-        )
-        result.raise_for_status()
-        result = PagedResponse[ViewReference].model_validate_json(result.success_response.body)
-        return result.items
+        return self._request_id_response(items, "delete")
 
     def list(
         self,
@@ -108,37 +85,10 @@ class ViewsAPI(NeatAPI):
         Returns:
             List of ViewResponse objects.
         """
-        if limit is not None and limit < 0:
-            raise ValueError("Limit must be non-negative.")
-        elif limit is not None and limit == 0:
-            return []
-        parameters: dict[str, PrimitiveType] = {
-            "allVersions": all_versions,
-            "includeInheritedProperties": include_inherited_properties,
-            "includeGlobal": include_global,
-        }
-        if space is not None:
-            parameters["space"] = space
-        cursor: str | None = None
-        view_responses: list[ViewResponse] = []
-        while True:
-            if cursor is not None:
-                parameters["cursor"] = cursor
-            if limit is None:
-                parameters["limit"] = self.LIST_REQUEST_LIMIT
-            else:
-                parameters["limit"] = min(self.LIST_REQUEST_LIMIT, limit - len(view_responses))
-            result = self._http_client.request_with_retries(
-                ParametersRequest(
-                    endpoint_url=self._config.create_api_url(self.ENDPOINT),
-                    method="GET",
-                    parameters=parameters,
-                )
-            )
-            result.raise_for_status()
-            result = PagedResponse[ViewResponse].model_validate_json(result.success_response.body)
-            view_responses.extend(result.items)
-            cursor = result.next_cursor
-            if cursor is None or (limit is not None and len(view_responses) >= limit):
-                break
-        return view_responses
+        filter = ViewFilter(
+            space=space,
+            all_versions=all_versions,
+            include_inherited_properties=include_inherited_properties,
+            include_global=include_global,
+        )
+        return self._list(limit=limit, params=filter.dump())

cognite/neat/_config.py

@@ -105,6 +105,7 @@ class AlphaFlagConfig(ConfigModel):
         default=False,
         description="If enabled, Neat will run experimental validators that are still in alpha stage.",
     )
+    enable_cdf_analysis: bool = Field(default=False, description="If enabled, neat.cdf endpoint will be available.")
 
     def __setattr__(self, key: str, value: Any) -> None:
         """Set attribute value or raise AttributeError."""

cognite/neat/_data_model/models/dms/_base.py

@@ -22,6 +22,9 @@ class WriteableResource(Resource, Generic[T_Resource], ABC):
         raise NotImplementedError()
 
 
+T_Response = TypeVar("T_Response", bound=WriteableResource)
+
+
 class APIResource(Generic[T_Reference], ABC):
     """Base class for all API data modeling resources."""
 

cognite/neat/_data_model/models/dms/_limits.py

@@ -9,6 +9,7 @@ class SpaceLimit(BaseModel):
     """Limits for spaces."""
 
     limit: int = 100
+    count: int = 0
 
 
 class ListablePropertyLimits(BaseModel):
@@ -51,6 +52,7 @@ class ContainerLimits(BaseModel):
     """Limits for containers."""
 
     limit: int = 1_000
+    count: int = 0
     properties: ContainerPropertyLimits = Field(default_factory=ContainerPropertyLimits)
 
 
@@ -58,6 +60,7 @@ class ViewLimits(BaseModel):
     """Limits for views."""
 
     limit: int = 2_000
+    count: int = 0
     versions: int = 100
     properties: int = 300
     implements: int = 10
@@ -68,6 +71,7 @@ class DataModelLimits(BaseModel):
     """Limits for data models."""
 
     limit: int = 500
+    count: int = 0
     versions: int = Field(100, description="Limit of versions per data model.")
     views: int = Field(100, description="Limit of views per data model.")
 

cognite/neat/_session/_cdf.py

@@ -0,0 +1,36 @@
+# /Users/nikola/repos/neat/cognite/neat/_session/_cdf.py
+import uuid
+
+from cognite.neat._client import NeatClient
+from cognite.neat._config import NeatConfig
+from cognite.neat._store._store import NeatStore
+
+from ._html._render import render
+
+
+class CDF:
+    """Read from a data source into NeatSession graph store."""
+
+    def __init__(self, store: NeatStore, client: NeatClient, config: NeatConfig) -> None:
+        self._store = store
+        self._client = client
+        self._config = config
+
+    def _repr_html_(self) -> str:
+        """Generate HTML representation of CDF schema statistics."""
+        unique_id = str(uuid.uuid4())[:8]
+
+        return render(
+            "statistics",
+            {
+                "unique_id": unique_id,
+                "spaces_current": self._store.cdf_limits.spaces.count,
+                "spaces_limit": self._store.cdf_limits.spaces.limit,
+                "containers_current": self._store.cdf_limits.containers.count,
+                "containers_limit": self._store.cdf_limits.containers.limit,
+                "views_current": self._store.cdf_limits.views.count,
+                "views_limit": self._store.cdf_limits.views.limit,
+                "data_models_current": self._store.cdf_limits.data_models.count,
+                "data_models_limit": self._store.cdf_limits.data_models.limit,
+            },
+        )

cognite/neat/_session/_html/_render.py

@@ -4,13 +4,13 @@ from . import static, templates
 
 ENCODING = "utf-8"
 
-Template: TypeAlias = Literal["issues", "deployment"]
+Template: TypeAlias = Literal["issues", "deployment", "statistics"]
 
 
-def render(template_name: Literal["issues", "deployment"], variables: dict[str, Any]) -> str:
+def render(template_name: Literal["issues", "deployment", "statistics"], variables: dict[str, Any]) -> str:
     """Generate HTML content from a template and variables."""
 
-    if template_name not in ["issues", "deployment"]:
+    if template_name not in ["issues", "deployment", "statistics"]:
         raise ValueError(f"Unknown template name: {template_name}")
 
     variables["SHARED_CSS"] = static.shared_style.read_text(encoding=ENCODING)
@@ -25,6 +25,11 @@ def render(template_name: Literal["issues", "deployment"], variables: dict[str,
         variables["SCRIPTS"] = static.deployment_scripts.read_text(encoding=ENCODING)
         variables["SPECIFIC_CSS"] = static.deployment_style.read_text(encoding=ENCODING)
 
+    elif template_name == "statistics":
+        template = templates.statistics.read_text(encoding=ENCODING)
+        variables["SCRIPTS"] = static.statistics_scripts.read_text(encoding=ENCODING)
+        variables["SPECIFIC_CSS"] = static.statistics_style.read_text(encoding=ENCODING)
+
     for key, value in variables.items():
         template = template.replace(f"{{{{{key}}}}}", str(value))
     return template

cognite/neat/_session/_html/static/__init__.py

@@ -6,3 +6,6 @@ issues_scripts = Path(__file__).parent / "issues.js"
 
 deployment_style = Path(__file__).parent / "deployment.css"
 deployment_scripts = Path(__file__).parent / "deployment.js"
+
+statistics_style = Path(__file__).parent / "statistics.css"
+statistics_scripts = Path(__file__).parent / "statistics.js"

cognite/neat/_session/_html/static/statistics.css

@@ -0,0 +1,163 @@
+.statistics-container {
+    font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+    padding: 20px;
+    background: var(--bg-secondary);
+    border-radius: 8px;
+    color: var(--text-primary);
+    transition: all 0.3s ease;
+}
+
+.statistics-header {
+    margin-bottom: 24px;
+    position: relative;
+}
+
+.statistics-title {
+    margin: 0 0 8px 0;
+    font-size: 24px;
+    font-weight: 600;
+    color: var(--text-primary);
+}
+
+.statistics-subtitle {
+    margin: 0;
+    font-size: 14px;
+    color: var(--text-secondary);
+}
+
+.theme-toggle {
+    position: absolute;
+    top: 0;
+    right: 0;
+    padding: 8px 12px;
+    background: var(--bg-primary);
+    border: 2px solid var(--border-color);
+    border-radius: 6px;
+    color: var(--text-primary);
+    cursor: pointer;
+    display: flex;
+    align-items: center;
+    gap: 6px;
+    font-size: 13px;
+    font-weight: 500;
+    transition: all 0.2s;
+    box-shadow: 0 1px 3px rgba(0, 0, 0, 0.1);
+}
+
+.theme-toggle:hover {
+    background: var(--hover-bg);
+    border-color: var(--text-secondary);
+    box-shadow: 0 2px 4px rgba(0, 0, 0, 0.15);
+}
+
+.theme-toggle:active {
+    transform: scale(0.98);
+}
+
+.statistics-grid {
+    display: grid;
+    grid-template-columns: repeat(auto-fit, minmax(280px, 1fr));
+    gap: 16px;
+    margin-bottom: 20px;
+}
+
+.stat-card {
+    background: var(--bg-primary);
+    padding: 16px;
+    border-radius: 6px;
+    box-shadow: 0 1px 3px rgba(0, 0, 0, 0.1);
+    border: 1px solid var(--border-light);
+    transition: all 0.3s ease;
+}
+
+.stat-label {
+    margin: 0 0 12px 0;
+    font-size: 14px;
+    color: var(--text-secondary);
+    text-transform: uppercase;
+    letter-spacing: 0.5px;
+    font-weight: 600;
+}
+
+.stat-value {
+    display: flex;
+    align-items: baseline;
+    margin-bottom: 12px;
+}
+
+.stat-current {
+    font-size: 28px;
+    font-weight: bold;
+    color: var(--text-primary);
+}
+
+.stat-limit {
+    color: var(--text-muted);
+    margin-left: 8px;
+    font-size: 14px;
+}
+
+.stat-progress-bg {
+    background: var(--border-light);
+    border-radius: 4px;
+    height: 8px;
+    overflow: hidden;
+    margin-bottom: 8px;
+}
+
+.stat-progress-bar {
+    height: 100%;
+    transition: width 0.3s ease, background 0.3s ease;
+    background: #10b981;
+}
+
+.stat-usage {
+    font-size: 12px;
+    font-weight: 500;
+    color: #10b981;
+    transition: color 0.3s ease;
+}
+
+.statistics-additional {
+    background: var(--bg-primary);
+    padding: 16px;
+    border-radius: 6px;
+    box-shadow: 0 1px 3px rgba(0, 0, 0, 0.1);
+    border: 1px solid var(--border-light);
+    transition: all 0.3s ease;
+}
+
+.additional-title {
+    margin: 0 0 12px 0;
+    font-size: 14px;
+    color: var(--text-secondary);
+    text-transform: uppercase;
+    letter-spacing: 0.5px;
+    font-weight: 600;
+}
+
+.additional-content {
+    display: grid;
+    grid-template-columns: 1fr 1fr;
+    gap: 12px;
+}
+
+.component-item {
+    color: var(--text-primary);
+    transition: color 0.3s ease;
+}
+
+.component-item strong {
+    color: var(--text-primary);
+}
+
+.component-value {
+    color: #0066cc;
+    font-weight: 600;
+    margin-left: 8px;
+    transition: color 0.3s ease;
+}
+
+.dark-mode .component-value {
+    color: #60a5fa;
+}

cognite/neat/_session/_html/static/statistics.js

@@ -0,0 +1,108 @@
+function initializeStatistics(uniqueId) {
+    /**
+     * Initialize stat cards with data from attributes and apply colors.
+     * Supports light/dark mode with color schema from shared CSS.
+     * Uses uniqueId to support multiple instances on the same page.
+     */
+
+    function getColor(percentage) {
+        if (percentage < 50) return '#10b981';    // green
+        if (percentage < 80) return '#f59e0b';    // amber
+        return '#ef4444';                         // red
+    }
+
+    function renderCards() {
+        const container = document.getElementById('statisticsContainer-' + uniqueId);
+        if (!container) return;
+
+        const cards = container.querySelectorAll('.stat-card');
+
+        cards.forEach(card => {
+            // Skip if already rendered
+            if (card.querySelector('.stat-label')) return;
+
+            const current = parseInt(card.dataset.current);
+            const limit = parseInt(card.dataset.limit);
+            const label = card.dataset.label;
+            const percentage = (current / limit * 100) || 0;
+            const color = getColor(percentage);
+
+            // Build card HTML
+            card.innerHTML = `
+                <h3 class="stat-label">${label}</h3>
+                <div class="stat-value">
+                    <span class="stat-current">${current}</span>
+                    <span class="stat-limit">/ ${limit}</span>
+                </div>
+                <div class="stat-progress-bg">
+                    <div class="stat-progress-bar" style="background: ${color}; width: ${Math.min(percentage, 100)}%;"></div>
+                </div>
+                <div class="stat-usage" style="color: ${color};">${percentage.toFixed(1)}% used</div>
+            `;
+        });
+    }
+
+    function setupThemeToggle() {
+        const container = document.getElementById('statisticsContainer-' + uniqueId);
+        if (!container) return;
+
+        // Check if theme toggle already exists
+        if (container.querySelector('.theme-toggle')) return;
+
+        // Create theme toggle button
+        const header = container.querySelector('.statistics-header');
+        if (!header) return;
+
+        const themeToggle = document.createElement('button');
+        themeToggle.className = 'theme-toggle';
+        themeToggle.id = 'themeToggleStats-' + uniqueId;
+        themeToggle.innerHTML = '<span id="themeIcon-' + uniqueId + '">🌙</span><span id="themeText-' + uniqueId + '">Dark</span>';
+
+        header.appendChild(themeToggle);
+
+        // Load saved theme preference
+        const storageKey = 'neat-statistics-theme-' + uniqueId;
+        const savedTheme = localStorage.getItem(storageKey) || 'light';
+
+        // Toggle theme on button click
+        themeToggle.addEventListener('click', () => {
+            const isDarkMode = container.classList.contains('dark-mode');
+            const newTheme = isDarkMode ? 'light' : 'dark';
+            applyTheme(newTheme);
+            localStorage.setItem(storageKey, newTheme);
+        });
+
+        function applyTheme(theme) {
+            const isDark = theme === 'dark';
+            const themeIcon = document.querySelector('#themeIcon-' + uniqueId);
+            const themeText = document.querySelector('#themeText-' + uniqueId);
+
+            if (isDark) {
+                container.classList.add('dark-mode');
+                if (themeIcon) themeIcon.textContent = '☀️';
+                if (themeText) themeText.textContent = 'Light';
+            } else {
+                container.classList.remove('dark-mode');
+                if (themeIcon) themeIcon.textContent = '🌙';
+                if (themeText) themeText.textContent = 'Dark';
+            }
+        }
+
+        // Apply initial theme
+        applyTheme(savedTheme);
+    }
+
+    // Render cards and setup theme toggle
+    renderCards();
+    setupThemeToggle();
+}
+
+// Call immediately with uniqueId for Jupyter notebooks
+initializeStatistics(uniqueId);
+
+// Also try on DOMContentLoaded for regular HTML pages
+if (document.readyState === 'loading') {
+    document.addEventListener('DOMContentLoaded', function() {
+        initializeStatistics(uniqueId);
+    });
+}

cognite/neat/_session/_html/templates/__init__.py

@@ -2,3 +2,4 @@ from pathlib import Path
 
 issues = Path(__file__).parent / "issues.html"
 deployment = Path(__file__).parent / "deployment.html"
+statistics = Path(__file__).parent / "statistics.html"

cognite/neat/_session/_html/templates/statistics.html

@@ -0,0 +1,26 @@
+<style>
+{{SHARED_CSS}}
+{{SPECIFIC_CSS}}
+</style>
+
+<div class="statistics-container" id="statisticsContainer-{{unique_id}}">
+    <div class="statistics-header">
+        <h2 class="statistics-title">CDF DMS Statistics</h2>
+        <p class="statistics-subtitle">Project usage and limits overview</p>
+    </div>
+
+    <div class="statistics-grid">
+        <div class="stat-card" data-current="{{spaces_current}}" data-limit="{{spaces_limit}}" data-label="Spaces"></div>
+        <div class="stat-card" data-current="{{containers_current}}" data-limit="{{containers_limit}}" data-label="Containers"></div>
+        <div class="stat-card" data-current="{{views_current}}" data-limit="{{views_limit}}" data-label="Views"></div>
+        <div class="stat-card" data-current="{{data_models_current}}" data-limit="{{data_models_limit}}" data-label="Data Models"></div>
+    </div>
+
+</div>
+
+<script>
+(function() {
+    const uniqueId = '{{unique_id}}';
+    {{SCRIPTS}}
+})();
+</script>

cognite/neat/_session/_session.py

@@ -10,6 +10,7 @@ from cognite.neat._state_machine import EmptyState, PhysicalState
 from cognite.neat._store import NeatStore
 from cognite.neat._utils.http_client import ParametersRequest, SuccessResponse
 
+from ._cdf import CDF
 from ._issues import Issues
 from ._physical import PhysicalDataModel
 from ._result import Result
@@ -51,6 +52,9 @@ class NeatSession:
         self.issues = Issues(self._store)
         self.result = Result(self._store)
 
+        if self._config.alpha.enable_cdf_analysis:
+            self.cdf = CDF(self._store, self._client, self._config)
+
         collector = Collector()
         if collector.can_collect:
             collector.collect("initSession", {"mode": self._config.modeling.mode})

cognite/neat/_utils/_reader.py

@@ -6,7 +6,7 @@ from pathlib import Path
 from typing import IO, Any, TextIO
 from urllib.parse import urlparse
 
-import requests
+import httpx
 
 
 class NeatReader(ABC):
@@ -124,24 +124,24 @@ class HttpFileReader(NeatReader):
         return self.path
 
     def read_text(self) -> str:
-        response = requests.get(self._url)
+        response = httpx.get(self._url)
         response.raise_for_status()
         return response.text
 
     def read_bytes(self) -> bytes:
-        response = requests.get(self._url)
+        response = httpx.get(self._url)
         response.raise_for_status()
         return response.content
 
     def size(self) -> int:
-        response = requests.head(self._url)
+        response = httpx.head(self._url)
         response.raise_for_status()
         return int(response.headers["Content-Length"])
 
     def iterate(self, chunk_size: int) -> Iterable[str]:
-        with requests.get(self._url, stream=True) as response:
+        with httpx.stream("GET", self._url) as response:
             response.raise_for_status()
-            for chunk in response.iter_content(chunk_size):
+            for chunk in response.iter_bytes(chunk_size):
                 yield chunk.decode("utf-8")
 
     def __enter__(self) -> IO:
@@ -151,7 +151,7 @@ class HttpFileReader(NeatReader):
         return self._url
 
     def exists(self) -> bool:
-        response = requests.head(self._url)
+        response = httpx.head(self._url)
         return 200 <= response.status_code < 400
 
     def materialize_path(self) -> Path: