code-analysis-client 1.6.65__tar.gz → 1.6.67__tar.gz

{code_analysis_client-1.6.65 → code_analysis_client-1.6.67}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-analysis-client
-Version: 1.6.65
+Version: 1.6.67
 Summary: Async JSON-RPC client for the code-analysis MCP server (mcp-proxy-adapter JsonRpcClient)
 Author-email: Vasiliy Zdanovskiy <vasilyvz@gmail.com>
 Requires-Python: >=3.10
@@ -85,9 +85,34 @@ counterparts): `timeout` (seconds, default `None` = wait until terminal),
 `poll_interval` (seconds between polls, default `1.0`), `status_hook` (sync or
 async callable invoked with each poll's status dict).
 
+`call` / `call_validated` also take `auto_poll` (default `True`, matching the
+behavior above exactly). Pass `auto_poll=False` to opt out of automatic
+polling: a non-queued response still comes back as the plain domain result,
+but a queued-job response comes back immediately as a `QueuedJob` handle
+instead of blocking until the job finishes.
+
+```python
+from code_analysis_client import QueuedJob
+
+result = await client.call("some_long_running_command", {...}, auto_poll=False)
+if isinstance(result, QueuedJob):
+    # do other work here, then block on it whenever you're ready
+    result = await result.wait()
+# `result` is now the same dict shape a default (auto_poll=True) call returns
+```
+
+`QueuedJob` exposes `.job_id`, `.envelope` (the raw queue-service response),
+and two async methods: `.wait(timeout=None, poll_interval=1.0, status_hook=None)`
+— polls to completion and returns/raises exactly like the default path — and
+`.status()` — a single `queue_get_job_status` fetch without polling to
+completion.
+
 `call_unified` / `call_unified_validated` are kept as **deprecated aliases** of
-`call` / `call_validated` for backward compatibility — `expect_queue` and
-`auto_poll` are accepted but ignored, since queue handling is now always on.
+`call` / `call_validated` for backward compatibility and emit
+`DeprecationWarning` on every call. `expect_queue` remains accepted-and-ignored
+(documented no-op). `auto_poll` is the one canonical switch and is forwarded
+straight through to `call` / `call_validated` — `auto_poll=False` on an alias
+returns a `QueuedJob` the same way it does on the non-deprecated method.
 Prefer `call` / `call_validated` directly.
 
 ## Validation using the server schema

{code_analysis_client-1.6.65 → code_analysis_client-1.6.67}/README.md

@@ -73,9 +73,34 @@ counterparts): `timeout` (seconds, default `None` = wait until terminal),
 `poll_interval` (seconds between polls, default `1.0`), `status_hook` (sync or
 async callable invoked with each poll's status dict).
 
+`call` / `call_validated` also take `auto_poll` (default `True`, matching the
+behavior above exactly). Pass `auto_poll=False` to opt out of automatic
+polling: a non-queued response still comes back as the plain domain result,
+but a queued-job response comes back immediately as a `QueuedJob` handle
+instead of blocking until the job finishes.
+
+```python
+from code_analysis_client import QueuedJob
+
+result = await client.call("some_long_running_command", {...}, auto_poll=False)
+if isinstance(result, QueuedJob):
+    # do other work here, then block on it whenever you're ready
+    result = await result.wait()
+# `result` is now the same dict shape a default (auto_poll=True) call returns
+```
+
+`QueuedJob` exposes `.job_id`, `.envelope` (the raw queue-service response),
+and two async methods: `.wait(timeout=None, poll_interval=1.0, status_hook=None)`
+— polls to completion and returns/raises exactly like the default path — and
+`.status()` — a single `queue_get_job_status` fetch without polling to
+completion.
+
 `call_unified` / `call_unified_validated` are kept as **deprecated aliases** of
-`call` / `call_validated` for backward compatibility — `expect_queue` and
-`auto_poll` are accepted but ignored, since queue handling is now always on.
+`call` / `call_validated` for backward compatibility and emit
+`DeprecationWarning` on every call. `expect_queue` remains accepted-and-ignored
+(documented no-op). `auto_poll` is the one canonical switch and is forwarded
+straight through to `call` / `call_validated` — `auto_poll=False` on an alias
+returns a `QueuedJob` the same way it does on the non-deprecated method.
 Prefer `call` / `call_validated` directly.
 
 ## Validation using the server schema

{code_analysis_client-1.6.65 → code_analysis_client-1.6.67}/code_analysis_client/__init__.py

@@ -24,6 +24,13 @@ from code_analysis_client.exceptions import (
     QueueJobError,
 )
 from code_analysis_client.file_session import FileSessionClient, SessionNotFoundError
+from code_analysis_client.queue_wait import (
+    QueuedJob,
+    extract_job_id,
+    is_queued_envelope,
+    unwrap_job_result,
+    wait_for_job,
+)
 from code_analysis_client.server_api import (
     CLIENT_FACADE_COMMANDS,
     CST_REMOVED_COMMANDS,
@@ -57,6 +64,7 @@ __all__ = [
     "JobTimeoutError",
     "LEGACY_REMOVED_COMMANDS",
     "QueueJobError",
+    "QueuedJob",
     "REMOVED_COMMANDS",
     "SessionNotFoundError",
     "TRANSFER_FACADE_METHODS",
@@ -65,11 +73,15 @@ __all__ = [
     "ValidatedCommandsProxy",
     "adapter_settings_from_server_config",
     "adapter_settings_to_jsonrpc_kwargs",
+    "extract_job_id",
     "fetch_command_schema_from_server",
+    "is_queued_envelope",
     "load_server_config",
     "parse_schema_from_help_payload",
     "prepare_params_for_schema",
+    "unwrap_job_result",
     "validate_params_against_schema",
+    "wait_for_job",
 ]
 
 

{code_analysis_client-1.6.65 → code_analysis_client-1.6.67}/code_analysis_client/client.py

@@ -7,8 +7,9 @@ email: vasilyvz@gmail.com
 
 from __future__ import annotations
 
+import warnings
 from pathlib import Path
-from typing import Any, Dict, Mapping, Optional
+from typing import Any, Dict, Literal, Mapping, Optional, Union, overload
 
 try:
     from mcp_proxy_adapter.client.jsonrpc_client.client import JsonRpcClient
@@ -23,6 +24,7 @@ from code_analysis_client.config import (
 )
 from code_analysis_client.file_session import FileSessionClient
 from code_analysis_client.queue_wait import (
+    QueuedJob,
     StatusHook,
     extract_job_id,
     is_queued_envelope,
@@ -154,19 +156,28 @@ class CodeAnalysisAsyncClient:
         params: Optional[Dict[str, Any]] = None,
         *,
         use_cmd_endpoint: bool = False,
+        auto_poll: bool = True,
         timeout: Optional[float] = None,
         poll_interval: float = 1.0,
         status_hook: Optional[StatusHook] = None,
-    ) -> Dict[str, Any]:
+    ) -> Union[Dict[str, Any], QueuedJob]:
         """Single queue-aware core every public entry point routes through.
 
         Runs ``command`` via the raw adapter ``execute_command``. If the
         immediate response is a queue-service envelope
-        (:func:`code_analysis_client.queue_wait.is_queued_envelope`), polls the
-        job to completion (:func:`~code_analysis_client.queue_wait.wait_for_job`)
-        and returns the unwrapped inner result
-        (:func:`~code_analysis_client.queue_wait.unwrap_job_result`), raising on
-        failure. A non-queued response is returned unchanged.
+        (:func:`code_analysis_client.queue_wait.is_queued_envelope`):
+
+        * ``auto_poll=True`` (default, unchanged behavior) — polls the job to
+          completion (:func:`~code_analysis_client.queue_wait.wait_for_job`)
+          and returns the unwrapped inner result
+          (:func:`~code_analysis_client.queue_wait.unwrap_job_result`), raising
+          on failure.
+        * ``auto_poll=False`` — returns a
+          :class:`~code_analysis_client.queue_wait.QueuedJob` handle
+          immediately instead of polling; call ``await handle.wait(...)`` to
+          get the same result the default path would have returned.
+
+        A non-queued response is returned unchanged regardless of ``auto_poll``.
         """
         resp = await self._rpc.execute_command(
             command,
@@ -177,6 +188,9 @@ class CodeAnalysisAsyncClient:
             return resp
 
         job_id = extract_job_id(resp)
+        if not auto_poll:
+            return QueuedJob(job_id=job_id, envelope=resp, rpc=self._rpc)
+
         status = await wait_for_job(
             self._rpc,
             job_id,
@@ -186,6 +200,7 @@ class CodeAnalysisAsyncClient:
         )
         return await unwrap_job_result(status, rpc=self._rpc)
 
+    @overload
     async def call_validated(
         self,
         command: str,
@@ -193,11 +208,58 @@ class CodeAnalysisAsyncClient:
         *,
         use_cmd_endpoint: bool = False,
         refresh_schema: bool = False,
+        auto_poll: Literal[True] = True,
         timeout: Optional[float] = None,
         poll_interval: float = 1.0,
         status_hook: Optional[StatusHook] = None,
-    ) -> Dict[str, Any]:
-        """``help`` → schema on server, shallow local validation, then the queue-aware core."""
+    ) -> Dict[str, Any]: ...
+
+    @overload
+    async def call_validated(
+        self,
+        command: str,
+        params: Optional[Dict[str, Any]] = None,
+        *,
+        use_cmd_endpoint: bool = False,
+        refresh_schema: bool = False,
+        auto_poll: Literal[False],
+        timeout: Optional[float] = None,
+        poll_interval: float = 1.0,
+        status_hook: Optional[StatusHook] = None,
+    ) -> QueuedJob: ...
+
+    @overload
+    async def call_validated(
+        self,
+        command: str,
+        params: Optional[Dict[str, Any]] = None,
+        *,
+        use_cmd_endpoint: bool = False,
+        refresh_schema: bool = False,
+        auto_poll: bool,
+        timeout: Optional[float] = None,
+        poll_interval: float = 1.0,
+        status_hook: Optional[StatusHook] = None,
+    ) -> Union[Dict[str, Any], QueuedJob]: ...
+
+    async def call_validated(
+        self,
+        command: str,
+        params: Optional[Dict[str, Any]] = None,
+        *,
+        use_cmd_endpoint: bool = False,
+        refresh_schema: bool = False,
+        auto_poll: bool = True,
+        timeout: Optional[float] = None,
+        poll_interval: float = 1.0,
+        status_hook: Optional[StatusHook] = None,
+    ) -> Union[Dict[str, Any], QueuedJob]:
+        """``help`` → schema on server, shallow local validation, then the queue-aware core.
+
+        ``auto_poll`` (default ``True``) forwards to :meth:`_execute`: set it
+        to ``False`` to get a :class:`~code_analysis_client.queue_wait.QueuedJob`
+        handle back instead of blocking until a queued job completes.
+        """
         schema = await self.get_command_schema(command, refresh=refresh_schema)
         merged = dict(params or {})
         prepared = prepare_params_for_schema(merged, schema)
@@ -206,11 +268,57 @@ class CodeAnalysisAsyncClient:
             command,
             prepared,
             use_cmd_endpoint=use_cmd_endpoint,
+            auto_poll=auto_poll,
             timeout=timeout,
             poll_interval=poll_interval,
             status_hook=status_hook,
         )
 
+    @overload
+    async def call_unified_validated(
+        self,
+        command: str,
+        params: Optional[Dict[str, Any]] = None,
+        *,
+        refresh_schema: bool = False,
+        use_cmd_endpoint: bool = False,
+        expect_queue: Optional[bool] = None,
+        auto_poll: Literal[True] = True,
+        poll_interval: float = 1.0,
+        timeout: Optional[float] = None,
+        status_hook: Optional[StatusHook] = None,
+    ) -> Dict[str, Any]: ...
+
+    @overload
+    async def call_unified_validated(
+        self,
+        command: str,
+        params: Optional[Dict[str, Any]] = None,
+        *,
+        refresh_schema: bool = False,
+        use_cmd_endpoint: bool = False,
+        expect_queue: Optional[bool] = None,
+        auto_poll: Literal[False],
+        poll_interval: float = 1.0,
+        timeout: Optional[float] = None,
+        status_hook: Optional[StatusHook] = None,
+    ) -> QueuedJob: ...
+
+    @overload
+    async def call_unified_validated(
+        self,
+        command: str,
+        params: Optional[Dict[str, Any]] = None,
+        *,
+        refresh_schema: bool = False,
+        use_cmd_endpoint: bool = False,
+        expect_queue: Optional[bool] = None,
+        auto_poll: bool,
+        poll_interval: float = 1.0,
+        timeout: Optional[float] = None,
+        status_hook: Optional[StatusHook] = None,
+    ) -> Union[Dict[str, Any], QueuedJob]: ...
+
     async def call_unified_validated(
         self,
         command: str,
@@ -223,14 +331,25 @@ class CodeAnalysisAsyncClient:
         poll_interval: float = 1.0,
         timeout: Optional[float] = None,
         status_hook: Optional[StatusHook] = None,
-    ) -> Dict[str, Any]:
+    ) -> Union[Dict[str, Any], QueuedJob]:
         """Deprecated alias for :meth:`call_validated`.
 
-        ``expect_queue`` and ``auto_poll`` are accepted only for backward
-        compatibility and are ignored: every path is now queue-aware
-        unconditionally through the shared :meth:`_execute` core (no more
-        adapter ``execute_command_unified``). Prefer :meth:`call_validated`.
+        ``expect_queue`` remains accepted-and-ignored (documented no-op, kept
+        only for signature compatibility). ``auto_poll`` is now LIVE again and
+        forwards straight to the shared :meth:`_execute` core: ``auto_poll=False``
+        returns a :class:`~code_analysis_client.queue_wait.QueuedJob` handle
+        instead of a plain dict when the response is a queued envelope — a
+        return-type change versus the previous era where this parameter was
+        silently ignored and every path always blocked until completion.
+        Prefer :meth:`call_validated` directly; this alias emits
+        ``DeprecationWarning`` on every call.
         """
+        warnings.warn(
+            "call_unified_validated is deprecated; use call_validated() "
+            "directly (its 'auto_poll' keyword works the same way).",
+            DeprecationWarning,
+            stacklevel=2,
+        )
         schema = await self.get_command_schema(command, refresh=refresh_schema)
         merged = dict(params or {})
         prepared = prepare_params_for_schema(merged, schema)
@@ -239,31 +358,121 @@ class CodeAnalysisAsyncClient:
             command,
             prepared,
             use_cmd_endpoint=use_cmd_endpoint,
+            auto_poll=auto_poll,
             timeout=timeout,
             poll_interval=poll_interval,
             status_hook=status_hook,
         )
 
+    @overload
     async def call(
         self,
         command: str,
         params: Optional[Dict[str, Any]] = None,
         *,
         use_cmd_endpoint: bool = False,
+        auto_poll: Literal[True] = True,
         timeout: Optional[float] = None,
         poll_interval: float = 1.0,
         status_hook: Optional[StatusHook] = None,
-    ) -> Dict[str, Any]:
-        """Run any registered server command; queued jobs are polled to completion."""
+    ) -> Dict[str, Any]: ...
+
+    @overload
+    async def call(
+        self,
+        command: str,
+        params: Optional[Dict[str, Any]] = None,
+        *,
+        use_cmd_endpoint: bool = False,
+        auto_poll: Literal[False],
+        timeout: Optional[float] = None,
+        poll_interval: float = 1.0,
+        status_hook: Optional[StatusHook] = None,
+    ) -> QueuedJob: ...
+
+    @overload
+    async def call(
+        self,
+        command: str,
+        params: Optional[Dict[str, Any]] = None,
+        *,
+        use_cmd_endpoint: bool = False,
+        auto_poll: bool,
+        timeout: Optional[float] = None,
+        poll_interval: float = 1.0,
+        status_hook: Optional[StatusHook] = None,
+    ) -> Union[Dict[str, Any], QueuedJob]: ...
+
+    async def call(
+        self,
+        command: str,
+        params: Optional[Dict[str, Any]] = None,
+        *,
+        use_cmd_endpoint: bool = False,
+        auto_poll: bool = True,
+        timeout: Optional[float] = None,
+        poll_interval: float = 1.0,
+        status_hook: Optional[StatusHook] = None,
+    ) -> Union[Dict[str, Any], QueuedJob]:
+        """Run any registered server command; queued jobs are polled to completion by default.
+
+        Pass ``auto_poll=False`` to get a
+        :class:`~code_analysis_client.queue_wait.QueuedJob` handle back
+        immediately instead (call ``await handle.wait(...)`` when you're
+        ready to block on it).
+        """
         return await self._execute(
             command,
             params,
             use_cmd_endpoint=use_cmd_endpoint,
+            auto_poll=auto_poll,
             timeout=timeout,
             poll_interval=poll_interval,
             status_hook=status_hook,
         )
 
+    @overload
+    async def call_unified(
+        self,
+        command: str,
+        params: Optional[Dict[str, Any]] = None,
+        *,
+        use_cmd_endpoint: bool = False,
+        expect_queue: Optional[bool] = None,
+        auto_poll: Literal[True] = True,
+        poll_interval: float = 1.0,
+        timeout: Optional[float] = None,
+        status_hook: Optional[StatusHook] = None,
+    ) -> Dict[str, Any]: ...
+
+    @overload
+    async def call_unified(
+        self,
+        command: str,
+        params: Optional[Dict[str, Any]] = None,
+        *,
+        use_cmd_endpoint: bool = False,
+        expect_queue: Optional[bool] = None,
+        auto_poll: Literal[False],
+        poll_interval: float = 1.0,
+        timeout: Optional[float] = None,
+        status_hook: Optional[StatusHook] = None,
+    ) -> QueuedJob: ...
+
+    @overload
+    async def call_unified(
+        self,
+        command: str,
+        params: Optional[Dict[str, Any]] = None,
+        *,
+        use_cmd_endpoint: bool = False,
+        expect_queue: Optional[bool] = None,
+        auto_poll: bool,
+        poll_interval: float = 1.0,
+        timeout: Optional[float] = None,
+        status_hook: Optional[StatusHook] = None,
+    ) -> Union[Dict[str, Any], QueuedJob]: ...
+
     async def call_unified(
         self,
         command: str,
@@ -275,18 +484,29 @@ class CodeAnalysisAsyncClient:
         poll_interval: float = 1.0,
         timeout: Optional[float] = None,
         status_hook: Optional[StatusHook] = None,
-    ) -> Dict[str, Any]:
+    ) -> Union[Dict[str, Any], QueuedJob]:
         """Deprecated alias for :meth:`call`.
 
-        ``expect_queue`` and ``auto_poll`` are accepted only for backward
-        compatibility and are ignored: every path is now queue-aware
-        unconditionally through the shared :meth:`_execute` core (no more
-        adapter ``execute_command_unified``). Prefer :meth:`call`.
+        ``expect_queue`` remains accepted-and-ignored (documented no-op).
+        ``auto_poll`` is now LIVE again and forwards straight to the shared
+        :meth:`_execute` core: ``auto_poll=False`` returns a
+        :class:`~code_analysis_client.queue_wait.QueuedJob` handle instead of
+        a plain dict when the response is a queued envelope — a return-type
+        change versus the previous era where this parameter was silently
+        ignored. Prefer :meth:`call` directly; this alias emits
+        ``DeprecationWarning`` on every call.
         """
+        warnings.warn(
+            "call_unified is deprecated; use call() directly (its "
+            "'auto_poll' keyword works the same way).",
+            DeprecationWarning,
+            stacklevel=2,
+        )
         return await self._execute(
             command,
             params,
             use_cmd_endpoint=use_cmd_endpoint,
+            auto_poll=auto_poll,
             timeout=timeout,
             poll_interval=poll_interval,
             status_hook=status_hook,

{code_analysis_client-1.6.65 → code_analysis_client-1.6.67}/code_analysis_client/queue_wait.py

@@ -11,6 +11,7 @@ from __future__ import annotations
 import asyncio
 import inspect
 import time
+from dataclasses import dataclass, field
 from typing import Any, Awaitable, Callable, Dict, Optional, Union
 
 from code_analysis_client.exceptions import (
@@ -254,3 +255,54 @@ async def unwrap_job_result(
         raise CommandFailedError(command, job_id, inner)
 
     return inner if isinstance(inner, dict) else {"result": inner}
+
+
+@dataclass
+class QueuedJob:
+    """Handle for a queued job returned when ``auto_poll=False`` opts out of automatic polling.
+
+    Returned by the client's queue-aware core (``CodeAnalysisAsyncClient._execute``)
+    in place of polling to completion when the immediate server response is a
+    queued-job envelope (:func:`is_queued_envelope`) and the caller passed
+    ``auto_poll=False``. Encapsulates all envelope-shape quirks (the job id may
+    live top-level or nested under ``data``, see :func:`extract_job_id`) behind
+    :meth:`wait` / :meth:`status` so callers never need to touch the raw envelope.
+    """
+
+    job_id: str
+    envelope: Dict[str, Any]
+    rpc: Any = field(repr=False)
+
+    async def wait(
+        self,
+        *,
+        timeout: Optional[float] = None,
+        poll_interval: float = 1.0,
+        status_hook: Optional[StatusHook] = None,
+    ) -> Dict[str, Any]:
+        """Poll the job to completion and return what ``_execute`` would have returned.
+
+        Delegates to the same :func:`wait_for_job` + :func:`unwrap_job_result`
+        pair the auto-polling path uses, so failures raise the identical
+        :class:`~code_analysis_client.exceptions.JobFailedError` /
+        :class:`~code_analysis_client.exceptions.CommandFailedError` /
+        :class:`~code_analysis_client.exceptions.JobTimeoutError`.
+        """
+        status = await wait_for_job(
+            self.rpc,
+            self.job_id,
+            timeout=timeout,
+            poll_interval=poll_interval,
+            status_hook=status_hook,
+        )
+        return await unwrap_job_result(status, rpc=self.rpc)
+
+    async def status(self) -> Dict[str, Any]:
+        """One-shot ``queue_get_job_status`` fetch (no polling to completion)."""
+        resp = await self.rpc.execute_command(
+            "queue_get_job_status", {"job_id": self.job_id}
+        )
+        data = resp.get("data") if isinstance(resp, dict) else None
+        if not isinstance(data, dict):
+            data = resp if isinstance(resp, dict) else {}
+        return data

code_analysis_client-1.6.67/code_analysis_client/version.txt

@@ -0,0 +1 @@
+1.6.67

{code_analysis_client-1.6.65 → code_analysis_client-1.6.67}/code_analysis_client.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-analysis-client
-Version: 1.6.65
+Version: 1.6.67
 Summary: Async JSON-RPC client for the code-analysis MCP server (mcp-proxy-adapter JsonRpcClient)
 Author-email: Vasiliy Zdanovskiy <vasilyvz@gmail.com>
 Requires-Python: >=3.10
@@ -85,9 +85,34 @@ counterparts): `timeout` (seconds, default `None` = wait until terminal),
 `poll_interval` (seconds between polls, default `1.0`), `status_hook` (sync or
 async callable invoked with each poll's status dict).
 
+`call` / `call_validated` also take `auto_poll` (default `True`, matching the
+behavior above exactly). Pass `auto_poll=False` to opt out of automatic
+polling: a non-queued response still comes back as the plain domain result,
+but a queued-job response comes back immediately as a `QueuedJob` handle
+instead of blocking until the job finishes.
+
+```python
+from code_analysis_client import QueuedJob
+
+result = await client.call("some_long_running_command", {...}, auto_poll=False)
+if isinstance(result, QueuedJob):
+    # do other work here, then block on it whenever you're ready
+    result = await result.wait()
+# `result` is now the same dict shape a default (auto_poll=True) call returns
+```
+
+`QueuedJob` exposes `.job_id`, `.envelope` (the raw queue-service response),
+and two async methods: `.wait(timeout=None, poll_interval=1.0, status_hook=None)`
+— polls to completion and returns/raises exactly like the default path — and
+`.status()` — a single `queue_get_job_status` fetch without polling to
+completion.
+
 `call_unified` / `call_unified_validated` are kept as **deprecated aliases** of
-`call` / `call_validated` for backward compatibility — `expect_queue` and
-`auto_poll` are accepted but ignored, since queue handling is now always on.
+`call` / `call_validated` for backward compatibility and emit
+`DeprecationWarning` on every call. `expect_queue` remains accepted-and-ignored
+(documented no-op). `auto_poll` is the one canonical switch and is forwarded
+straight through to `call` / `call_validated` — `auto_poll=False` on an alias
+returns a `QueuedJob` the same way it does on the non-deprecated method.
 Prefer `call` / `call_validated` directly.
 
 ## Validation using the server schema

code_analysis_client-1.6.65/code_analysis_client/version.txt

@@ -1 +0,0 @@
-1.6.65