scootcli 0.1.0__py3-none-any.whl

scootcli/providers/openai_chat.py

@@ -0,0 +1,142 @@
+"""OpenAI Chat Completions adapter (``POST {base}/chat/completions``).
+
+Scoot's neutral format *is* this wire format, so translation is a pass-through apart from stripping
+scoot-private keys. Kept for OpenAI-compatible endpoints that do not implement the Responses API
+(``wire="openai_chat"`` on their registry row); nothing in the default set uses it.
+"""
+
+from __future__ import annotations
+
+from typing import Callable, List
+
+from ..errors import ApiError
+from .base import (
+    BaseProvider,
+    ChatRequest,
+    ChatResult,
+    decode_json,
+    finish_stream,
+    iter_sse_json,
+    normalize_usage,
+)
+
+_PRIVATE_KEYS = ("provider_items",)
+
+
+def strip_private(messages: List[dict]) -> List[dict]:
+    """Drop scoot-private keys the API would reject."""
+    out = []
+    for m in messages:
+        if any(k in m for k in _PRIVATE_KEYS):
+            m = {k: v for k, v in m.items() if k not in _PRIVATE_KEYS}
+        out.append(m)
+    return out
+
+
+class StreamAccumulator:
+    """Reassembles a streamed chat completion from SSE ``choices[0].delta`` fragments."""
+
+    def __init__(self) -> None:
+        self._content: List[str] = []
+        self._tool_calls: dict = {}  # index -> {id, type, function:{name, arguments}}
+        self.finish_reason = ""
+        self.model = ""
+        self.usage: dict = {}
+
+    def add(self, obj: dict) -> str:
+        """Fold one SSE chunk in; return any new content text to emit live."""
+        if obj.get("model"):
+            self.model = obj["model"]
+        if obj.get("usage"):
+            self.usage = obj["usage"]
+        choices = obj.get("choices") or []
+        if not choices:
+            return ""
+        choice = choices[0]
+        if choice.get("finish_reason"):
+            self.finish_reason = choice["finish_reason"]
+        delta = choice.get("delta") or {}
+        for tc in delta.get("tool_calls") or []:
+            idx = tc.get("index", 0)
+            slot = self._tool_calls.setdefault(
+                idx, {"id": "", "type": "function", "function": {"name": "", "arguments": ""}}
+            )
+            if tc.get("id"):
+                slot["id"] = tc["id"]
+            if tc.get("type"):
+                slot["type"] = tc["type"]
+            fn = tc.get("function") or {}
+            if fn.get("name"):
+                slot["function"]["name"] = fn["name"]
+            if fn.get("arguments"):
+                slot["function"]["arguments"] += fn["arguments"]
+        text = delta.get("content") or ""
+        if text:
+            self._content.append(text)
+        return text
+
+    def result(self, model_sent: str) -> ChatResult:
+        calls = [self._tool_calls[i] for i in sorted(self._tool_calls)]
+        content = "".join(self._content)
+        message: dict = {"role": "assistant", "content": content}
+        if calls:
+            message["tool_calls"] = calls
+        return ChatResult(content=content, model=self.model or model_sent, tool_calls=calls,
+                          finish_reason=self.finish_reason, usage=normalize_usage(self.usage),
+                          raw_message=message)
+
+
+def parse_chat(data: dict, model_sent: str) -> ChatResult:
+    try:
+        choice = data["choices"][0]
+        message = choice.get("message", {})
+    except (KeyError, IndexError, TypeError) as exc:
+        raise ApiError(f"unexpected chat response shape: {str(data)[:200]}") from exc
+    return ChatResult(
+        content=message.get("content") or "",
+        model=data.get("model", model_sent),
+        tool_calls=message.get("tool_calls") or [],
+        finish_reason=choice.get("finish_reason", ""),
+        usage=normalize_usage(data.get("usage", {})),
+        raw_message=message,
+    )
+
+
+class OpenAIChatProvider(BaseProvider):
+    wire = "openai_chat"
+
+    def _payload(self, req: ChatRequest, stream: bool) -> dict:
+        payload: dict = {"model": req.model, "messages": strip_private(req.messages)}
+        if req.temperature is not None and self.spec.has("temperature"):
+            payload["temperature"] = req.temperature
+        if req.max_tokens is not None:
+            payload["max_tokens"] = req.max_tokens
+        if req.tools:
+            payload["tools"] = req.tools
+            payload["tool_choice"] = req.tool_choice or "auto"
+        if stream:
+            payload["stream"] = True
+            payload["stream_options"] = {"include_usage": True}
+        return payload
+
+    def _complete(self, req: ChatRequest) -> ChatResult:
+        payload = self._payload(req, stream=False)
+        status, body = self._http("POST", "/chat/completions", payload, req.cancel_event)
+        result = parse_chat(decode_json(status, body), req.model)
+        result.model = self.qualified(result.model)
+        return result
+
+    def _stream(self, req: ChatRequest, on_delta: Callable[[str], None]) -> ChatResult:
+        payload = self._payload(req, stream=True)
+        acc = StreamAccumulator()
+        holder: dict = {}
+        leftovers: List[str] = []
+        for obj in iter_sse_json(self._http_stream("/chat/completions", payload, req.cancel_event),
+                                 holder, leftovers):
+            text = acc.add(obj)
+            if text:
+                on_delta(text)
+        finish_stream(holder, leftovers, self.name)
+        result = acc.result(req.model)
+        result.model = self.qualified(result.model)
+        return result

scootcli/providers/openai_responses.py

@@ -0,0 +1,248 @@
+"""OpenAI Responses API adapter (``POST {base}/responses``).
+
+This is the wire OpenAI recommends for new work and the only one that serves its Codex models. Ollama
+(0.32+) implements the same endpoint, so one adapter covers both. Translation from scoot's neutral
+format:
+
+  * ``system`` messages → ``instructions``
+  * ``user`` messages → message items (``input_text`` / ``input_image`` parts)
+  * ``assistant`` messages → an ``output_text`` message item plus one ``function_call`` item per tool
+    call, or, when the message carries ``provider_items`` produced by this very model, those items are
+    replayed verbatim (that is how encrypted ``reasoning`` items travel across tool calls)
+  * ``tool`` messages → ``function_call_output`` items
+  * tool schemas → flat ``{"type": "function", "name", "description", "parameters"}``
+
+Requests are stateless (``store: false``); scoot replays history itself.
+"""
+
+from __future__ import annotations
+
+import json
+from typing import Callable, List, Optional, Tuple
+
+from ..errors import ApiError
+from .base import (
+    BaseProvider,
+    ChatRequest,
+    ChatResult,
+    decode_json,
+    finish_stream,
+    iter_sse_json,
+    normalize_usage,
+    raise_for_status,
+)
+
+# Models that accept the ``reasoning`` parameter (others reject it with a 400).
+_REASONING_PREFIXES = ("gpt-5", "o1", "o3", "o4", "codex")
+
+
+def is_reasoning_model(model: str) -> bool:
+    m = (model or "").lower()
+    return any(m.startswith(p) or p in m for p in _REASONING_PREFIXES)
+
+
+# ── request translation ─────────────────────────────────────────────────────────
+def _content_parts(content, role: str) -> object:
+    """Neutral content (str or OpenAI-chat parts) → Responses content for ``role``."""
+    if isinstance(content, str) or content is None:
+        return content or ""
+    text_type = "output_text" if role == "assistant" else "input_text"
+    parts = []
+    for part in content:
+        if not isinstance(part, dict):
+            continue
+        ptype = part.get("type")
+        if ptype == "text":
+            parts.append({"type": text_type, "text": part.get("text", "")})
+        elif ptype == "image_url":
+            img = part.get("image_url") or {}
+            url = img.get("url") if isinstance(img, dict) else img
+            item = {"type": "input_image", "image_url": url}
+            if isinstance(img, dict) and img.get("detail"):
+                item["detail"] = img["detail"]
+            parts.append(item)
+        elif ptype in ("input_text", "output_text", "input_image"):
+            parts.append(part)
+    return parts
+
+
+def _arguments(raw) -> str:
+    if isinstance(raw, str):
+        return raw
+    return json.dumps(raw or {})
+
+
+def translate_messages(messages: List[dict], qualified_model: str) -> Tuple[str, List[dict]]:
+    """Return ``(instructions, input_items)`` for the Responses request."""
+    instructions: List[str] = []
+    items: List[dict] = []
+    for m in messages:
+        role = m.get("role")
+        if role in ("system", "developer"):
+            text = m.get("content")
+            if isinstance(text, list):
+                text = "\n".join(p.get("text", "") for p in text if isinstance(p, dict))
+            if text:
+                instructions.append(str(text))
+        elif role == "user":
+            items.append({"role": "user", "content": _content_parts(m.get("content"), "user")})
+        elif role == "assistant":
+            replay = m.get("provider_items")
+            if isinstance(replay, dict) and replay.get("model") == qualified_model and replay.get("items"):
+                items.extend(replay["items"])
+                continue
+            text = m.get("content")
+            if isinstance(text, list):
+                items.append({"role": "assistant", "content": _content_parts(text, "assistant")})
+            elif text:
+                items.append({"role": "assistant",
+                              "content": [{"type": "output_text", "text": str(text)}]})
+            for tc in m.get("tool_calls") or []:
+                fn = tc.get("function") or {}
+                items.append({
+                    "type": "function_call",
+                    "call_id": tc.get("id", ""),
+                    "name": fn.get("name", ""),
+                    "arguments": _arguments(fn.get("arguments")),
+                })
+        elif role == "tool":
+            content = m.get("content")
+            if not isinstance(content, str):
+                content = json.dumps(content) if content is not None else ""
+            items.append({"type": "function_call_output", "call_id": m.get("tool_call_id", ""),
+                          "output": content})
+    return "\n\n".join(instructions), items
+
+
+def translate_tool(tool: dict) -> dict:
+    """Neutral ``{"type": "function", "function": {...}}`` → flat Responses tool definition."""
+    fn = tool.get("function") if isinstance(tool, dict) else None
+    if not isinstance(fn, dict):
+        return tool
+    return {
+        "type": "function",
+        "name": fn.get("name", ""),
+        "description": fn.get("description", ""),
+        "parameters": fn.get("parameters") or {"type": "object", "properties": {}},
+    }
+
+
+# ── response parsing ────────────────────────────────────────────────────────────
+def _text_of(item: dict) -> str:
+    parts = item.get("content") or []
+    if isinstance(parts, str):
+        return parts
+    return "".join(p.get("text", "") for p in parts if isinstance(p, dict) and p.get("type") == "output_text")
+
+
+def _tool_call_of(item: dict) -> dict:
+    return {
+        "id": item.get("call_id") or item.get("id") or "",
+        "type": "function",
+        "function": {"name": item.get("name", ""), "arguments": item.get("arguments") or "{}"},
+    }
+
+
+def build_result(items: List[dict], model: str, usage: Optional[dict], status: str,
+                 streamed_text: str = "") -> ChatResult:
+    """Fold output items into a :class:`ChatResult`; ``provider_items`` keeps them for replay."""
+    texts = [_text_of(it) for it in items if it.get("type") == "message"]
+    tool_calls = [_tool_call_of(it) for it in items if it.get("type") == "function_call"]
+    content = streamed_text or "".join(texts)
+    if tool_calls:
+        finish = "tool_calls"
+    elif status == "incomplete":
+        finish = "length"
+    else:
+        finish = "stop"
+    message: dict = {"role": "assistant", "content": content}
+    if tool_calls:
+        message["tool_calls"] = tool_calls
+    if items:
+        message["provider_items"] = {"model": model, "items": items}
+    return ChatResult(content=content, model=model, tool_calls=tool_calls, finish_reason=finish,
+                      usage=normalize_usage(usage), raw_message=message)
+
+
+class _StreamState:
+    """Accumulates Responses SSE events into output items + live text."""
+
+    def __init__(self) -> None:
+        self.items: List[dict] = []
+        self.text: List[str] = []
+        self.usage: dict = {}
+        self.model = ""
+        self.status = ""
+        self.error: Optional[dict] = None
+
+    def add(self, obj: dict) -> str:
+        etype = obj.get("type", "")
+        if etype == "response.output_text.delta":
+            delta = obj.get("delta") or ""
+            if delta:
+                self.text.append(delta)
+            return delta
+        if etype == "response.output_item.done":
+            item = obj.get("item")
+            if isinstance(item, dict):
+                self.items.append(item)
+        elif etype in ("response.completed", "response.incomplete", "response.failed"):
+            resp = obj.get("response") or {}
+            self.usage = resp.get("usage") or self.usage
+            self.model = resp.get("model") or self.model
+            self.status = resp.get("status") or etype.rsplit(".", 1)[-1]
+            if resp.get("error"):
+                self.error = resp["error"]
+            if not self.items and resp.get("output"):
+                self.items = list(resp["output"])
+        elif etype == "error":
+            self.error = {"message": obj.get("message") or obj.get("error") or "stream error",
+                          "code": obj.get("code", "")}
+        return ""
+
+
+class OpenAIResponsesProvider(BaseProvider):
+    wire = "openai_responses"
+
+    def _payload(self, req: ChatRequest, stream: bool) -> dict:
+        instructions, items = translate_messages(req.messages, self.qualified(req.model))
+        payload: dict = {"model": req.model, "input": items, "store": False, "stream": stream}
+        if instructions:
+            payload["instructions"] = instructions
+        if req.tools:
+            payload["tools"] = [translate_tool(t) for t in req.tools]
+            payload["tool_choice"] = req.tool_choice or "auto"
+        if req.max_tokens:
+            payload["max_output_tokens"] = req.max_tokens
+        if req.temperature is not None and self.spec.has("temperature"):
+            payload["temperature"] = req.temperature
+        effort = getattr(self.config, "effort", "") or ""
+        if self.spec.has("reasoning") and is_reasoning_model(req.model) and effort:
+            payload["reasoning"] = {"effort": effort}
+        return payload
+
+    def _complete(self, req: ChatRequest) -> ChatResult:
+        payload = self._payload(req, stream=False)
+        status, body = self._http("POST", "/responses", payload, req.cancel_event)
+        data = decode_json(status, body)
+        if data.get("error"):
+            raise_for_status(400, json.dumps({"error": data["error"]}), self.name)
+        return build_result(data.get("output") or [], self.qualified(data.get("model") or req.model),
+                            data.get("usage"), data.get("status", ""))
+
+    def _stream(self, req: ChatRequest, on_delta: Callable[[str], None]) -> ChatResult:
+        payload = self._payload(req, stream=True)
+        state = _StreamState()
+        holder: dict = {}
+        leftovers: List[str] = []
+        for obj in iter_sse_json(self._http_stream("/responses", payload, req.cancel_event), holder,
+                                 leftovers):
+            text = state.add(obj)
+            if text:
+                on_delta(text)
+        finish_stream(holder, leftovers, self.name)
+        if state.error:
+            raise_for_status(400, json.dumps({"error": state.error}), self.name)
+            raise ApiError(str(state.error))
+        return build_result(state.items, self.qualified(state.model or req.model), state.usage,
+                            state.status, streamed_text="".join(state.text))

scootcli/providers/registry.py

@@ -0,0 +1,173 @@
+"""Provider registry and the pool the application holds.
+
+Adding a provider is one :func:`register` call with a :class:`ProviderSpec`; the wire adapters are
+selected by ``spec.wire``. Base URLs can be overridden per provider with ``SCOOT_<NAME>_BASE_URL``.
+"""
+
+from __future__ import annotations
+
+import os
+from dataclasses import replace
+from typing import Dict, List, Optional
+
+from ..errors import ConfigError, ScootError
+from .base import BaseProvider, ChatResult, ModelInfo, ProviderSpec, qualify, split_model_id
+
+_SPECS: Dict[str, ProviderSpec] = {}
+_WIRES: Dict[str, type] = {}
+
+
+def register(spec: ProviderSpec) -> None:
+    _SPECS[spec.name] = spec
+
+
+def get(name: str) -> Optional[ProviderSpec]:
+    load_builtins()
+    return _SPECS.get(name)
+
+
+def names() -> List[str]:
+    load_builtins()
+    return list(_SPECS)
+
+
+def all_specs() -> List[ProviderSpec]:
+    load_builtins()
+    return list(_SPECS.values())
+
+
+_loaded = False
+
+
+def load_builtins() -> None:
+    """Register the built-in providers and wire adapters (idempotent)."""
+    global _loaded
+    if _loaded:
+        return
+    from .openai_chat import OpenAIChatProvider
+    from .openai_responses import OpenAIResponsesProvider
+
+    _WIRES["openai_responses"] = OpenAIResponsesProvider
+    _WIRES["openai_chat"] = OpenAIChatProvider
+    register(ProviderSpec(
+        name="openai",
+        base_url="https://api.openai.com/v1",
+        wire="openai_responses",
+        key_env=("OPENAI_API_KEY",),
+        key_required=True,
+        preferred_models=("gpt-5.3-codex", "gpt-5.5", "gpt-5.4", "gpt-5", "gpt-4.1"),
+        vision_models=("gpt-5.3-codex", "gpt-5", "gpt-4.1", "gpt-4o"),
+        capabilities=frozenset({"tools", "streaming", "vision", "reasoning"}),
+    ))
+    register(ProviderSpec(
+        name="ollama",
+        base_url="http://localhost:11434/v1",
+        wire="openai_responses",
+        key_env=("OLLAMA_API_KEY",),
+        key_required=False,
+        preferred_models=("llama3.2", "qwen3", "llama3.1", "mistral"),
+        vision_models=("qwen2.5vl", "llama3.2-vision", "llava", "gemma3", "minicpm-v"),
+        capabilities=frozenset({"tools", "streaming", "vision", "temperature"}),
+    ))
+    _loaded = True
+
+
+def base_url_for(spec: ProviderSpec) -> str:
+    override = os.environ.get(f"SCOOT_{spec.name.upper()}_BASE_URL", "").strip()
+    return override or spec.base_url
+
+
+def make_provider(name: str, config, transport=None) -> BaseProvider:
+    """Instantiate the adapter for ``name`` with any base-URL override applied."""
+    spec = get(name)
+    if spec is None:
+        raise ConfigError(f"unknown provider '{name}'", hint=f"known providers: {', '.join(names())}")
+    cls = _WIRES.get(spec.wire)
+    if cls is None:
+        raise ConfigError(f"provider '{name}' uses unknown wire '{spec.wire}'")
+    return cls(replace(spec, base_url=base_url_for(spec)), config, transport=transport)
+
+
+def default_provider_name(config) -> str:
+    """``SCOOT_PROVIDER`` if set, else the first provider with a key configured, else ``ollama``."""
+    from ..auth import is_configured
+
+    wanted = (getattr(config, "provider", "") or "").strip().lower()
+    if wanted:
+        if get(wanted) is None:
+            raise ConfigError(f"unknown provider '{wanted}'", hint=f"known providers: {', '.join(names())}")
+        return wanted
+    for spec in all_specs():
+        if spec.key_required and is_configured(spec):
+            return spec.name
+    return "ollama"
+
+
+def fallback_model(config) -> str:
+    """The qualified model ``auto`` resolves to before any live model list is known."""
+    name = default_provider_name(config)
+    spec = get(name)
+    head = spec.preferred_models[0] if spec and spec.preferred_models else "default"
+    return qualify(name, head)
+
+
+class ProviderPool:
+    """Holds one adapter per provider, built lazily, and dispatches by the ``provider/`` prefix.
+
+    Implements the same ``chat`` / ``chat_stream`` / ``list_models`` surface as a single provider, so
+    consumers never care whether one or many providers are in play. This is also where a routing
+    provider would plug in later: a router is just another entry the pool can dispatch to.
+    """
+
+    def __init__(self, config, transport=None):
+        self.config = config
+        self._transport = transport
+        self._providers: Dict[str, BaseProvider] = {}
+        self.list_errors: Dict[str, str] = {}
+
+    @property
+    def default_name(self) -> str:
+        return default_provider_name(self.config)
+
+    @property
+    def spec(self) -> ProviderSpec:
+        return self.provider(self.default_name).spec
+
+    def provider(self, name: Optional[str] = None) -> BaseProvider:
+        name = name or self.default_name
+        if name not in self._providers:
+            self._providers[name] = make_provider(name, self.config, transport=self._transport)
+        return self._providers[name]
+
+    def for_model(self, model: Optional[str]) -> "tuple[BaseProvider, str]":
+        """Resolve ``provider/model`` (or a bare name) to ``(adapter, bare_model)``."""
+        head, bare = split_model_id(model)
+        if head and get(head) is None:
+            raise ConfigError(f"unknown provider '{head}' in model '{model}'",
+                              hint=f"known providers: {', '.join(names())}")
+        return self.provider(head), bare
+
+    def chat(self, messages, model=None, **kwargs) -> ChatResult:
+        p, bare = self.for_model(model or self.config.resolve_model())
+        return p.chat(messages, model=bare, **kwargs)
+
+    def chat_stream(self, messages, model=None, **kwargs) -> ChatResult:
+        p, bare = self.for_model(model or self.config.resolve_model())
+        return p.chat_stream(messages, model=bare, **kwargs)
+
+    def list_models(self, provider: Optional[str] = None, cancel_event=None) -> List[ModelInfo]:
+        """Models from one provider, or from every configured provider (failures are recorded, not raised)."""
+        from ..auth import is_configured
+
+        if provider:
+            return self.provider(provider).list_models(cancel_event=cancel_event)
+        out: List[ModelInfo] = []
+        self.list_errors = {}
+        for spec in all_specs():
+            if not is_configured(spec):
+                continue
+            try:
+                out.extend(self.provider(spec.name).list_models(cancel_event=cancel_event))
+            except ScootError as exc:
+                self.list_errors[spec.name] = str(exc)
+        return out

scootcli/rendering.py

@@ -0,0 +1,86 @@
+"""Minimal stdlib rendering helpers: ANSI colors + secret redaction. No third-party deps."""
+
+from __future__ import annotations
+
+import difflib
+import os
+import re
+import sys
+
+_COLOR_ENABLED = sys.stdout.isatty() and os.environ.get("NO_COLOR") is None
+
+_CODES = {
+    "reset": "\033[0m",
+    "bold": "\033[1m",
+    "dim": "\033[2m",
+    "red": "\033[31m",
+    "green": "\033[32m",
+    "yellow": "\033[33m",
+    "blue": "\033[34m",
+    "magenta": "\033[35m",
+    "cyan": "\033[36m",
+    "gray": "\033[90m",
+}
+
+
+def color(text: str, *styles: str) -> str:
+    """Wrap ``text`` in the given ANSI styles (no-op when color is disabled)."""
+    if not _COLOR_ENABLED or not styles:
+        return text
+    prefix = "".join(_CODES.get(s, "") for s in styles)
+    return f"{prefix}{text}{_CODES['reset']}"
+
+
+# Redact anything that looks like a token/secret before printing (defense in depth): provider API
+# keys (OpenAI ``sk-…``, Anthropic ``sk-ant-…``), GitHub tokens, Bearer values, and JWTs. Bearer values
+# may contain separators, so the whole non-whitespace run is masked.
+_SECRET_RE = re.compile(
+    r"(sk-[A-Za-z0-9_\-]{12,}|gh[opsu]_[A-Za-z0-9]{8,}|Bearer\s+\S+|tid=\S+|eyJ[A-Za-z0-9._\-]{20,})"
+)
+
+
+def redact(text: str) -> str:
+    """Mask token-like substrings so secrets never reach the terminal/logs."""
+    return _SECRET_RE.sub("<redacted>", text)
+
+
+def eprint(*args, **kwargs) -> None:
+    """Print to stderr."""
+    print(*args, file=sys.stderr, **kwargs)
+
+
+def diff_stats(old: str, new: str) -> "tuple[int, int]":
+    """Return ``(added, removed)`` line counts between two texts."""
+    added = removed = 0
+    for line in difflib.unified_diff(old.splitlines(), new.splitlines(), lineterm=""):
+        if line.startswith("+") and not line.startswith("+++"):
+            added += 1
+        elif line.startswith("-") and not line.startswith("---"):
+            removed += 1
+    return added, removed
+
+
+def unified_diff(old: str, new: str, path: str = "", context: int = 3) -> str:
+    """Return a colorized unified diff between ``old`` and ``new``."""
+    from_name = f"a/{path}" if path else "old"
+    to_name = f"b/{path}" if path else "new"
+    lines = difflib.unified_diff(
+        old.splitlines(), new.splitlines(),
+        fromfile=from_name, tofile=to_name, lineterm="", n=context,
+    )
+    out = []
+    for line in lines:
+        if line.startswith("+++") or line.startswith("---"):
+            out.append(color(line, "bold"))
+        elif line.startswith("@@"):
+            out.append(color(line, "cyan"))
+        elif line.startswith("+"):
+            out.append(color(line, "green"))
+        elif line.startswith("-"):
+            out.append(color(line, "red"))
+        else:
+            out.append(color(line, "gray"))
+    return "\n".join(out)
+
+
+