ollama Interface: comparison OllamaInterface/OllamaClient.py

-:ca28466a186d
+:7dd1b9cd3150
 import contextlib
 import datetime
 import enum
 import json
-from PyQt6.QtCore import pyqtSignal, QObject, QUrl
+from PyQt6.QtCore import (
-from PyQt6.QtNetwork import QNetworkAccessManager, QNetworkRequest, QNetworkReply
+QCoreApplication,
+QObject,
+QThread,
+QTimer,
+QUrl,
+pyqtSignal,
+pyqtSlot,
+)
+from PyQt6.QtNetwork import QNetworkAccessManager, QNetworkReply, QNetworkRequest
 from eric7.EricNetwork.EricNetworkProxyFactory import proxyAuthenticationRequired
 class OllamaClientState(enum.Enum):
 """
 Class defining the various client states.
 """
 Waiting = 0
 Requesting = 1
 Receiving = 2
 Finished = 3
 class OllamaClient(QObject):
 """
 Class implementing the 'ollama' client.
 @signal replyReceived(content:str, role:str) emitted after a response from the
 'ollama' server was received
 @signal modelsList(modelNames:list[str]) emitted after the list of model
 names was obtained from the 'ollama' server
 @signal detailedModelsList(models:list[dict]) emitted after the list of
 models was obtained from the 'ollama' server giving some model details
 @signal runningModelsList(models:list[dict]) emitted after the list of
 running models was obtained from the 'ollama' server giving some model
 execution details
 @signal pullStatus(msg:str, id:str, total:int, completed:int) emitted to indicate
 the status of a pull request as reported by the 'ollama' server
+@signal serverVersion(version:str) emitted after the server version was obtained
+from the 'ollama' server
 @signal finished() emitted to indicate the completion of a request
 @signal errorOccurred(error:str) emitted to indicate a network error occurred
 while processing the request
+@signal serverStateChanged(ok:bool) emitted to indicate a change of the server
+responsiveness
 """
 replyReceived = pyqtSignal(str, str)
 modelsList = pyqtSignal(list)
 detailedModelsList = pyqtSignal(list)
 runningModelsList = pyqtSignal(list)
 pullStatus = pyqtSignal(str, str, int, int)
+serverVersion = pyqtSignal(str)
 finished = pyqtSignal()
 errorOccurred = pyqtSignal(str)
+serverStateChanged = pyqtSignal(bool)
 def __init__(self, plugin, parent=None):
 """
 Constructor
 self.__networkManager = QNetworkAccessManager(self)
 self.__networkManager.proxyAuthenticationRequired.connect(
 proxyAuthenticationRequired
 )
+self.__serverResponding = False
+self.__heartbeatTimer = QTimer(self)
+self.__heartbeatTimer.timeout.connect(self.__periodicHeartbeat)
 self.__state = OllamaClientState.Waiting
+self.__serverResponding = False  # start with a faulty state
+self.__plugin.preferencesChanged.connect(self.__setHeartbeatTimer)
+self.__setHeartbeatTimer()
 def chat(self, model, messages):
 """
 Public method to request a chat completion from the 'ollama' server.
 def list(self):
 """
 Public method to request a list of models available locally from the 'ollama'
 server.
 """
-# TODO: not implemented yet
 self.__sendRequest("tags", processResponse=self.__processModelsList)
 def __processModelsList(self, response):
 """
 Private method to process the tags response of the 'ollama' server.
 models = []
 with contextlib.suppress(KeyError):
 for model in response["models"]:
 name = model["name"]
 if name:
-models.append(name)
+models.append(name.replace(":latest", ""))
 self.modelsList.emit(models)
 def listDetails(self):
 """
 Public method to request a list of models available locally from the 'ollama'
 server with some model details.
-@return list of available models
-@rtype list of dict
 """
 # TODO: not implemented yet
 self.__sendRequest("tags", processResponse=self.__processDetailedModelsList)
 def __processDetailedModelsList(self, response):
 )
 self.detailedModelsList.emit(models)
 def listRunning(self):
 """
-Public method to request a list of running models from the 'ollama' server
+Public method to request a list of running models from the 'ollama' server.
 """
 # TODO: not implemented yet
 self.__sendRequest("ps", processResponse=self.__processRunningModelsList)
 def __processRunningModelsList(self, response):
 ),
 }
 )
 self.runningModelsList.emit(models)
+def version(self):
+"""
+Public method to request the version from the 'ollama' server.
+"""
+self.__sendRequest("version", processResponse=self.__processVersion)
+def __processVersion(self, response):
+"""
+Private method to process the version response of the 'ollama' server.
+@param response dictionary containing the version response
+@type dict
+"""
+with contextlib.suppress(KeyError):
+self.serverVersion.emit(response["version"])
 def state(self):
 """
 Public method to get the current client state.
 @return current client state
 @rtype OllamaClientState
 """
 return self.__state
 if data is not None:
 request.setHeader(
 QNetworkRequest.KnownHeaders.ContentTypeHeader, "application/json"
 )
 jsonData = json.dumps(data).encode("utf-8")
-reply = self.__networkManager.post(request=request, data=jsonData)
+reply = self.__networkManager.post(request, jsonData)
 else:
-reply = self.__networkManager.get(request=request)
+reply = self.__networkManager.get(request)
 reply.finished.connect(lambda: self.__replyFinished(reply))
 reply.errorOccurred.connect(lambda error: self.__errorOccurred(error, reply))
 reply.readyRead.connect(lambda: self.__processData(reply, processResponse))
 self.__replies.append(reply)
 if buffer:
 with contextlib.suppress(json.JSONDecodeError):
 data = json.loads(buffer)
 if data and processResponse:
 processResponse(data)
+def heartbeat(self):
+"""
+Public method to check, if the 'ollama' server has started and is responsive.
+@return flag indicating a responsive 'ollama' server
+@rtype bool
+"""
+ollamaUrl = QUrl(
+"{0}://{1}:{2}/".format(
+self.__plugin.getPreferences("OllamaScheme"),
+self.__plugin.getPreferences("OllamaHost"),
+self.__plugin.getPreferences("OllamaPort"),
+)
+)
+request = QNetworkRequest(ollamaUrl)
+reply = self.__networkManager.head(request)
+while not reply.isFinished():
+QCoreApplication.processEvents()
+QThread.msleep(100)
+reply.deleteLater()
+return reply.error() == QNetworkReply.NetworkError.NoError
+@pyqtSlot()
+def __setHeartbeatTimer(self):
+"""
+Private slot to configure the heartbeat timer.
+"""
+interval = self.__plugin.getPreferences("OllamaHeartbeatInterval")
+if interval:
+self.__heartbeatTimer.setInterval(interval * 1000)  # interval in ms
+self.__heartbeatTimer.start()
+else:
+self.__heartbeatTimer.stop()
+@pyqtSlot()
+def __periodicHeartbeat(self):
+"""
+Private slot to do a periodic check of the 'ollama' server responsiveness.
+"""
+responding = self.heartbeat()
+if responding != self.__serverResponding:
+self.serverStateChanged.emit(responding)
+self.__serverResponding = responding

Mercurial Repositories > ollama Interface / file comparison

comparison: OllamaInterface/OllamaClient.py

OllamaInterface/OllamaClient.py