diffdelta 0.1.0__tar.gz

diffdelta-0.1.0/PKG-INFO

@@ -0,0 +1,25 @@
+Metadata-Version: 2.4
+Name: diffdelta
+Version: 0.1.0
+Summary: Python client for DiffDelta — agent-ready intelligence feeds
+Author-email: DiffDelta <human@diffdelta.io>
+License: MIT
+Project-URL: Homepage, https://diffdelta.io
+Project-URL: Documentation, https://diffdelta.io/#quickstart
+Project-URL: Repository, https://github.com/diffdelta/diffdelta-python
+Project-URL: Issues, https://github.com/diffdelta/diffdelta-python/issues
+Keywords: diffdelta,ai-agents,security,changefeed,intelligence
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Security
+Classifier: Topic :: Software Development :: Libraries
+Requires-Python: >=3.8
+Requires-Dist: requests>=2.25.0

diffdelta-0.1.0/diffdelta/__init__.py

@@ -0,0 +1,17 @@
+"""
+DiffDelta — Agent-ready intelligence feeds.
+
+    from diffdelta import DiffDelta
+
+    dd = DiffDelta()
+    for item in dd.poll(tags=["security"]):
+        print(f"{item.source}: {item.headline}")
+
+Full docs: https://diffdelta.io/#quickstart
+"""
+
+from diffdelta.client import DiffDelta
+from diffdelta.models import FeedItem, SourceInfo, Feed, Head
+
+__version__ = "0.1.0"
+__all__ = ["DiffDelta", "FeedItem", "SourceInfo", "Feed", "Head"]

diffdelta-0.1.0/diffdelta/client.py

@@ -0,0 +1,327 @@
+"""DiffDelta client — the main interface for polling intelligence feeds."""
+
+from __future__ import annotations
+
+import time
+from typing import Any, Callable, Dict, List, Optional, Sequence
+
+import requests
+
+from diffdelta.cursor import CursorStore
+from diffdelta.models import Feed, FeedItem, Head, SourceInfo
+
+DEFAULT_BASE_URL = "https://diffdelta.io"
+DEFAULT_TIMEOUT = 15  # seconds
+
+
+class DiffDelta:
+    """Client for polling DiffDelta intelligence feeds.
+
+    Usage::
+
+        from diffdelta import DiffDelta
+
+        dd = DiffDelta()
+
+        # Poll for new items across all sources
+        for item in dd.poll():
+            print(f"{item.source}: {item.headline}")
+
+        # Poll only security sources
+        for item in dd.poll(tags=["security"]):
+            print(f"🚨 {item.headline}")
+
+        # Poll a specific source
+        for item in dd.poll_source("cisa_kev"):
+            print(item.headline)
+
+    Args:
+        base_url: DiffDelta API base URL. Defaults to https://diffdelta.io.
+        api_key: Optional Pro/Enterprise API key (dd_live_...).
+        cursor_path: Path to cursor persistence file. Set to None to disable persistence.
+        timeout: HTTP request timeout in seconds.
+    """
+
+    def __init__(
+        self,
+        base_url: str = DEFAULT_BASE_URL,
+        api_key: Optional[str] = None,
+        cursor_path: Optional[str] = "",  # "" = default path, None = disabled
+        timeout: int = DEFAULT_TIMEOUT,
+    ) -> None:
+        self.base_url = base_url.rstrip("/")
+        self.api_key = api_key
+        self.timeout = timeout
+
+        # Set up cursor persistence
+        if cursor_path is None:
+            self._cursors: Optional[CursorStore] = None
+        else:
+            self._cursors = CursorStore(cursor_path if cursor_path else None)
+
+        # Set up HTTP session
+        self._session = requests.Session()
+        self._session.headers["User-Agent"] = "diffdelta-python/0.1.0"
+        if self.api_key:
+            self._session.headers["X-DiffDelta-Key"] = self.api_key
+
+    # ── Core polling ──
+
+    def poll(
+        self,
+        tags: Optional[List[str]] = None,
+        sources: Optional[List[str]] = None,
+        buckets: Optional[List[str]] = None,
+    ) -> List[FeedItem]:
+        """Poll the global feed for new items since last poll.
+
+        Checks head.json first (400 bytes). Only fetches the full feed
+        if the cursor has changed. Automatically saves the new cursor.
+
+        Args:
+            tags: Filter items to these tags (e.g. ["security"]).
+            sources: Filter items to these source IDs (e.g. ["cisa_kev", "nist_nvd"]).
+            buckets: Which buckets to return. Defaults to ["new", "updated"].
+                     Use ["new", "updated", "removed"] to include removals.
+
+        Returns:
+            List of FeedItem objects that are new since your last poll.
+            Empty list if nothing has changed.
+        """
+        if buckets is None:
+            buckets = ["new", "updated"]
+
+        cursor_key = "global"
+        return self._poll_feed(
+            head_url=f"{self.base_url}/diff/head.json",
+            latest_url=f"{self.base_url}/diff/latest.json",
+            cursor_key=cursor_key,
+            tags=tags,
+            sources=sources,
+            buckets=buckets,
+        )
+
+    def poll_source(
+        self,
+        source_id: str,
+        buckets: Optional[List[str]] = None,
+    ) -> List[FeedItem]:
+        """Poll a specific source for new items since last poll.
+
+        More efficient than poll() with sources= filter if you only
+        care about one source, since it fetches a smaller payload.
+
+        Args:
+            source_id: Source identifier (e.g. "cisa_kev").
+            buckets: Which buckets to return. Defaults to ["new", "updated"].
+
+        Returns:
+            List of FeedItem objects that are new since your last poll.
+        """
+        if buckets is None:
+            buckets = ["new", "updated"]
+
+        cursor_key = f"source:{source_id}"
+        return self._poll_feed(
+            head_url=f"{self.base_url}/diff/source/{source_id}/head.json",
+            latest_url=f"{self.base_url}/diff/source/{source_id}/latest.json",
+            cursor_key=cursor_key,
+            tags=None,
+            sources=None,
+            buckets=buckets,
+        )
+
+    def _poll_feed(
+        self,
+        head_url: str,
+        latest_url: str,
+        cursor_key: str,
+        tags: Optional[List[str]],
+        sources: Optional[List[str]],
+        buckets: List[str],
+    ) -> List[FeedItem]:
+        """Internal: poll a feed with cursor comparison."""
+        # Step 1: Fetch head.json (~400 bytes)
+        head = self.head(head_url)
+
+        # Step 2: Compare cursor
+        stored_cursor = self._cursors.get(cursor_key) if self._cursors else None
+
+        if stored_cursor and stored_cursor == head.cursor:
+            # Nothing changed — return empty list
+            return []
+
+        # Step 3: Fetch full feed
+        feed = self.fetch_feed(latest_url)
+
+        # Step 4: Save new cursor
+        if self._cursors and feed.cursor:
+            self._cursors.set(cursor_key, feed.cursor)
+
+        # Step 5: Filter and return
+        items = []
+        for item in feed.items:
+            # Filter by bucket
+            if item.bucket not in buckets:
+                continue
+
+            # Filter by source
+            if sources and item.source not in sources:
+                continue
+
+            # Filter by tags (requires knowing source tags — use source index)
+            if tags:
+                # We need source metadata to filter by tags
+                # Load source info if we haven't yet
+                source_tags = self._get_source_tags()
+                item_tags = source_tags.get(item.source, [])
+                if not any(t in item_tags for t in tags):
+                    continue
+
+            items.append(item)
+
+        return items
+
+    # ── Low-level fetch methods ──
+
+    def head(self, url: Optional[str] = None) -> Head:
+        """Fetch a head.json pointer.
+
+        Args:
+            url: Full URL to head.json. Defaults to global head.
+
+        Returns:
+            Head object with cursor, hash, and metadata.
+        """
+        if url is None:
+            url = f"{self.base_url}/diff/head.json"
+        data = self._get_json(url)
+        return Head.from_raw(data)
+
+    def fetch_feed(self, url: Optional[str] = None) -> Feed:
+        """Fetch a full latest.json feed.
+
+        Args:
+            url: Full URL to latest.json. Defaults to global latest.
+
+        Returns:
+            Feed object with all items, buckets, and metadata.
+        """
+        if url is None:
+            url = f"{self.base_url}/diff/latest.json"
+        data = self._get_json(url)
+        return Feed.from_raw(data)
+
+    def sources(self) -> List[SourceInfo]:
+        """List all available DiffDelta sources.
+
+        Returns:
+            List of SourceInfo objects with metadata about each source.
+        """
+        data = self._get_json(f"{self.base_url}/diff/sources.json")
+        return [SourceInfo.from_raw(s) for s in data.get("sources", [])]
+
+    # ── Continuous monitoring ──
+
+    def watch(
+        self,
+        callback: Callable[[FeedItem], None],
+        tags: Optional[List[str]] = None,
+        sources: Optional[List[str]] = None,
+        interval: Optional[int] = None,
+        buckets: Optional[List[str]] = None,
+    ) -> None:
+        """Continuously poll and call a function for each new item.
+
+        This runs an infinite loop. Use Ctrl+C to stop, or run in a thread.
+
+        Args:
+            callback: Function called for each new FeedItem.
+            tags: Filter to these tags.
+            sources: Filter to these source IDs.
+            interval: Seconds between polls. Defaults to feed's TTL (usually 900s).
+            buckets: Which buckets to process. Defaults to ["new", "updated"].
+
+        Example::
+
+            def handle(item):
+                print(f"🚨 {item.source}: {item.headline}")
+                # send_slack_alert(item)
+
+            dd = DiffDelta()
+            dd.watch(handle, tags=["security"])  # Runs forever
+        """
+        if buckets is None:
+            buckets = ["new", "updated"]
+
+        # Determine polling interval from feed TTL if not specified
+        if interval is None:
+            try:
+                h = self.head()
+                interval = max(h.ttl_sec, 60)  # At least 60 seconds
+            except Exception:
+                interval = 900  # Default 15 minutes
+
+        print(f"[diffdelta] Watching for changes every {interval}s...")
+        print(f"[diffdelta] Press Ctrl+C to stop.")
+
+        while True:
+            try:
+                items = self.poll(tags=tags, sources=sources, buckets=buckets)
+                if items:
+                    print(f"[diffdelta] {len(items)} new item(s) found.")
+                    for item in items:
+                        callback(item)
+                else:
+                    print(f"[diffdelta] No changes.")
+            except KeyboardInterrupt:
+                print("\n[diffdelta] Stopped.")
+                break
+            except Exception as e:
+                print(f"[diffdelta] Error: {e}. Retrying in {interval}s...")
+
+            try:
+                time.sleep(interval)
+            except KeyboardInterrupt:
+                print("\n[diffdelta] Stopped.")
+                break
+
+    # ── Cursor management ──
+
+    def reset_cursors(self, source_id: Optional[str] = None) -> None:
+        """Reset stored cursors so the next poll returns all current items.
+
+        Args:
+            source_id: Reset cursor for a specific source. None = reset all.
+        """
+        if self._cursors:
+            if source_id:
+                self._cursors.clear(f"source:{source_id}")
+            else:
+                self._cursors.clear()
+
+    # ── Internal ──
+
+    _source_tags_cache: Optional[Dict[str, List[str]]] = None
+
+    def _get_source_tags(self) -> Dict[str, List[str]]:
+        """Cache source → tags mapping for tag-based filtering."""
+        if self._source_tags_cache is None:
+            try:
+                all_sources = self.sources()
+                self._source_tags_cache = {
+                    s.source_id: s.tags for s in all_sources
+                }
+            except Exception:
+                self._source_tags_cache = {}
+        return self._source_tags_cache
+
+    def _get_json(self, url: str) -> Dict[str, Any]:
+        """Fetch a URL and return parsed JSON."""
+        resp = self._session.get(url, timeout=self.timeout)
+        resp.raise_for_status()
+        return resp.json()
+
+    def __repr__(self) -> str:
+        tier = "pro" if self.api_key else "free"
+        return f"DiffDelta(base_url={self.base_url!r}, tier={tier!r})"

diffdelta-0.1.0/diffdelta/cursor.py

@@ -0,0 +1,68 @@
+"""Cursor persistence — automatically saves and loads polling state."""
+
+from __future__ import annotations
+
+import json
+import os
+from pathlib import Path
+from typing import Dict, Optional
+
+
+DEFAULT_CURSOR_DIR = os.path.join(Path.home(), ".diffdelta")
+DEFAULT_CURSOR_FILE = "cursors.json"
+
+
+class CursorStore:
+    """Persists cursors to a local JSON file so bots survive restarts.
+
+    By default, cursors are saved to ~/.diffdelta/cursors.json.
+    Each feed URL gets its own cursor entry.
+    """
+
+    def __init__(self, path: Optional[str] = None) -> None:
+        if path:
+            self._path = path
+        else:
+            self._path = os.path.join(DEFAULT_CURSOR_DIR, DEFAULT_CURSOR_FILE)
+
+        self._cursors: Dict[str, str] = {}
+        self._load()
+
+    def get(self, key: str) -> Optional[str]:
+        """Get the stored cursor for a feed key."""
+        return self._cursors.get(key)
+
+    def set(self, key: str, cursor: str) -> None:
+        """Save a cursor and persist to disk."""
+        self._cursors[key] = cursor
+        self._save()
+
+    def clear(self, key: Optional[str] = None) -> None:
+        """Clear cursor(s). If key is None, clears all cursors."""
+        if key:
+            self._cursors.pop(key, None)
+        else:
+            self._cursors.clear()
+        self._save()
+
+    def _load(self) -> None:
+        """Load cursors from disk."""
+        try:
+            if os.path.exists(self._path):
+                with open(self._path, "r") as f:
+                    data = json.load(f)
+                if isinstance(data, dict):
+                    self._cursors = data
+        except (json.JSONDecodeError, OSError):
+            # Corrupted file — start fresh
+            self._cursors = {}
+
+    def _save(self) -> None:
+        """Persist cursors to disk."""
+        try:
+            os.makedirs(os.path.dirname(self._path), exist_ok=True)
+            with open(self._path, "w") as f:
+                json.dump(self._cursors, f, indent=2)
+        except OSError:
+            # Can't write — silently continue (in-memory only)
+            pass

diffdelta-0.1.0/diffdelta/models.py

@@ -0,0 +1,186 @@
+"""Data models for DiffDelta feeds."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from datetime import datetime
+from typing import Any, Dict, List, Optional
+
+
+@dataclass
+class FeedItem:
+    """A single item from a DiffDelta feed.
+
+    Attributes:
+        source: Source identifier (e.g. "cisa_kev", "nist_nvd").
+        id: Unique item ID within the source.
+        headline: Human/agent-readable headline.
+        url: Link to the original source.
+        excerpt: Summary text extracted from the source.
+        published_at: When the item was originally published.
+        updated_at: When the item was last updated.
+        bucket: Which change bucket: "new", "updated", or "removed".
+        provenance: Raw provenance data (fetched_at, evidence_urls, content_hash).
+        raw: The full raw item dict from the feed.
+    """
+
+    source: str
+    id: str
+    headline: str
+    url: str = ""
+    excerpt: str = ""
+    published_at: Optional[str] = None
+    updated_at: Optional[str] = None
+    bucket: str = "new"  # "new" | "updated" | "removed"
+    provenance: Dict[str, Any] = field(default_factory=dict)
+    raw: Dict[str, Any] = field(default_factory=dict)
+
+    @classmethod
+    def from_raw(cls, data: Dict[str, Any], bucket: str = "new") -> "FeedItem":
+        """Create a FeedItem from a raw feed item dict."""
+        content = data.get("content", {})
+        excerpt = ""
+        if isinstance(content, dict):
+            excerpt = content.get("excerpt_text", "") or content.get("summary", "")
+        elif isinstance(content, str):
+            excerpt = content
+
+        return cls(
+            source=data.get("source", ""),
+            id=data.get("id", ""),
+            headline=data.get("headline", ""),
+            url=data.get("url", ""),
+            excerpt=excerpt,
+            published_at=data.get("published_at"),
+            updated_at=data.get("updated_at"),
+            bucket=bucket,
+            provenance=data.get("provenance", {}),
+            raw=data,
+        )
+
+    def __repr__(self) -> str:
+        return f"FeedItem(source={self.source!r}, id={self.id!r}, headline={self.headline!r}, bucket={self.bucket!r})"
+
+
+@dataclass
+class Head:
+    """The lightweight head pointer for change detection.
+
+    Attributes:
+        cursor: Opaque cursor string for change detection.
+        hash: Content hash of the latest feed.
+        changed: Whether content has changed since last generation.
+        generated_at: When this head was generated.
+        ttl_sec: Recommended polling interval in seconds.
+    """
+
+    cursor: str
+    hash: str = ""
+    changed: bool = False
+    generated_at: str = ""
+    ttl_sec: int = 900
+
+    @classmethod
+    def from_raw(cls, data: Dict[str, Any]) -> "Head":
+        return cls(
+            cursor=data.get("cursor", ""),
+            hash=data.get("hash", ""),
+            changed=data.get("changed", False),
+            generated_at=data.get("generated_at", ""),
+            ttl_sec=data.get("ttl_sec", 900),
+        )
+
+
+@dataclass
+class Feed:
+    """A full DiffDelta feed response.
+
+    Attributes:
+        cursor: The new cursor (save this for next poll).
+        prev_cursor: The previous cursor.
+        source_id: Source ID (if per-source feed) or "global".
+        generated_at: When this feed was generated.
+        items: All items across all buckets.
+        new: Items in the "new" bucket.
+        updated: Items in the "updated" bucket.
+        removed: Items in the "removed" bucket.
+        narrative: Human-readable summary of what changed.
+        raw: The full raw feed dict.
+    """
+
+    cursor: str
+    prev_cursor: str = ""
+    source_id: str = ""
+    generated_at: str = ""
+    items: List[FeedItem] = field(default_factory=list)
+    new: List[FeedItem] = field(default_factory=list)
+    updated: List[FeedItem] = field(default_factory=list)
+    removed: List[FeedItem] = field(default_factory=list)
+    narrative: str = ""
+    raw: Dict[str, Any] = field(default_factory=dict)
+
+    @classmethod
+    def from_raw(cls, data: Dict[str, Any]) -> "Feed":
+        buckets = data.get("buckets", {})
+
+        new_items = [FeedItem.from_raw(i, "new") for i in buckets.get("new", [])]
+        updated_items = [FeedItem.from_raw(i, "updated") for i in buckets.get("updated", [])]
+        removed_items = [FeedItem.from_raw(i, "removed") for i in buckets.get("removed", [])]
+        all_items = new_items + updated_items + removed_items
+
+        return cls(
+            cursor=data.get("cursor", ""),
+            prev_cursor=data.get("prev_cursor", ""),
+            source_id=data.get("source_id", ""),
+            generated_at=data.get("generated_at", ""),
+            items=all_items,
+            new=new_items,
+            updated=updated_items,
+            removed=removed_items,
+            narrative=data.get("batch_narrative", ""),
+            raw=data,
+        )
+
+
+@dataclass
+class SourceInfo:
+    """Metadata about an available DiffDelta source.
+
+    Attributes:
+        source_id: Unique source identifier (e.g. "cisa_kev").
+        name: Human-readable display name.
+        tags: List of tags (e.g. ["security"]).
+        description: Brief description of the source.
+        homepage: URL of the source's homepage.
+        enabled: Whether the source is currently active.
+        status: Health status ("ok", "degraded", "error").
+        head_url: Path to the source's head.json.
+        latest_url: Path to the source's latest.json.
+    """
+
+    source_id: str
+    name: str
+    tags: List[str] = field(default_factory=list)
+    description: str = ""
+    homepage: str = ""
+    enabled: bool = True
+    status: str = "ok"
+    head_url: str = ""
+    latest_url: str = ""
+
+    @classmethod
+    def from_raw(cls, data: Dict[str, Any]) -> "SourceInfo":
+        return cls(
+            source_id=data.get("source_id", ""),
+            name=data.get("name", ""),
+            tags=data.get("tags", []),
+            description=data.get("description", ""),
+            homepage=data.get("homepage", ""),
+            enabled=data.get("enabled", True),
+            status=data.get("status", "ok"),
+            head_url=data.get("head_url", ""),
+            latest_url=data.get("latest_url", ""),
+        )
+
+    def __repr__(self) -> str:
+        return f"SourceInfo(source_id={self.source_id!r}, name={self.name!r}, status={self.status!r})"

diffdelta-0.1.0/diffdelta.egg-info/PKG-INFO

@@ -0,0 +1,25 @@
+Metadata-Version: 2.4
+Name: diffdelta
+Version: 0.1.0
+Summary: Python client for DiffDelta — agent-ready intelligence feeds
+Author-email: DiffDelta <human@diffdelta.io>
+License: MIT
+Project-URL: Homepage, https://diffdelta.io
+Project-URL: Documentation, https://diffdelta.io/#quickstart
+Project-URL: Repository, https://github.com/diffdelta/diffdelta-python
+Project-URL: Issues, https://github.com/diffdelta/diffdelta-python/issues
+Keywords: diffdelta,ai-agents,security,changefeed,intelligence
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Security
+Classifier: Topic :: Software Development :: Libraries
+Requires-Python: >=3.8
+Requires-Dist: requests>=2.25.0

diffdelta-0.1.0/diffdelta.egg-info/SOURCES.txt

@@ -0,0 +1,10 @@
+pyproject.toml
+diffdelta/__init__.py
+diffdelta/client.py
+diffdelta/cursor.py
+diffdelta/models.py
+diffdelta.egg-info/PKG-INFO
+diffdelta.egg-info/SOURCES.txt
+diffdelta.egg-info/dependency_links.txt
+diffdelta.egg-info/requires.txt
+diffdelta.egg-info/top_level.txt

diffdelta-0.1.0/diffdelta.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

diffdelta-0.1.0/diffdelta.egg-info/requires.txt

@@ -0,0 +1 @@
+requests>=2.25.0

diffdelta-0.1.0/diffdelta.egg-info/top_level.txt

@@ -0,0 +1 @@
+diffdelta

diffdelta-0.1.0/pyproject.toml

@@ -0,0 +1,38 @@
+[build-system]
+requires = ["setuptools>=68.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "diffdelta"
+version = "0.1.0"
+description = "Python client for DiffDelta — agent-ready intelligence feeds"
+requires-python = ">=3.8"
+license = {text = "MIT"}
+authors = [{name = "DiffDelta", email = "human@diffdelta.io"}]
+keywords = ["diffdelta", "ai-agents", "security", "changefeed", "intelligence"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Security",
+    "Topic :: Software Development :: Libraries",
+]
+dependencies = [
+    "requests>=2.25.0",
+]
+
+[project.urls]
+Homepage = "https://diffdelta.io"
+Documentation = "https://diffdelta.io/#quickstart"
+Repository = "https://github.com/diffdelta/diffdelta-python"
+Issues = "https://github.com/diffdelta/diffdelta-python/issues"
+
+[tool.setuptools.packages.find]
+include = ["diffdelta*"]

diffdelta-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+