pygpt-net 2.4.41__py3-none-any.whl → 2.4.43__py3-none-any.whl

pygpt_net/plugin/cmd_web/worker.py

@@ -6,7 +6,7 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2024.12.13 08:00:00                  #
+# Updated Date: 2024.12.15 01:00:00                  #
 # ================================================== #
 
 import json
@@ -64,6 +64,9 @@ class Worker(BaseWorker):
                 elif item["cmd"] == "web_extract_images":
                     response = self.cmd_web_extract_images(item)
 
+                elif item["cmd"] == "web_request":
+                    response = self.cmd_web_request(item)
+
                 if response:
                     responses.append(response)
 
@@ -363,7 +366,7 @@ class Worker(BaseWorker):
             url = self.get_param(item, "url")
         if not url:
             return self.make_response(item, "No URL provided")
-        links = self.plugin.window.core.web.get_links(url)
+        links = self.plugin.window.core.web.helpers.get_links(url)
         result = {
             'links': links,
         }
@@ -385,17 +388,77 @@ class Worker(BaseWorker):
             download = bool(self.get_param(item, "download"))
         if not url:
             return self.make_response(item, "No URL provided")
-        images = self.plugin.window.core.web.get_images(url)
+        images = self.plugin.window.core.web.helpers.get_images(url)
         result = {
             'images': images,
         }
         if images and download:
             for img in images:
                 try:
-                    path = self.plugin.window.core.web.download_image(img)
+                    path = self.plugin.window.core.web.helpers.download_image(img)
                     if path:
                         self.ctx.images_before.append(path)
                 except Exception as e:
                     print(e)
         self.ctx.urls_before.append(url)
         return self.make_response(item, result)
+
+    def cmd_web_request(self, item: dict) -> dict:
+        """
+        Web request command
+
+        :param item: command item
+        :return: response item
+        """
+        url = ""
+        method = "GET"
+        data = None
+        raw = None
+        json = None
+        headers = None
+        params = None
+        cookies = None
+        files = None
+
+        if self.has_param(item, "url"):
+            url = self.get_param(item, "url")
+        if not url:
+            return self.make_response(item, "No URL provided")
+        if self.has_param(item, "method"):
+            method = self.get_param(item, "method")
+        if self.has_param(item, "data_form"):
+            data = self.get_param(item, "data_form")
+        if self.has_param(item, "data"):
+            raw = self.get_param(item, "data")
+        if self.has_param(item, "data_json"):
+            json = self.get_param(item, "data_json")
+        if self.has_param(item, "headers"):
+            headers = self.get_param(item, "headers")
+        if self.has_param(item, "params"):
+            params = self.get_param(item, "params")
+        if self.has_param(item, "cookies"):
+            cookies = self.get_param(item, "cookies")
+        if self.has_param(item, "files"):
+            files = self.get_param(item, "files")
+
+        code, response = self.window.core.web.helpers.request(
+            url=url,
+            method=method,
+            headers=headers,
+            params=params,
+            data=data if data else raw,
+            json=json,
+            cookies=cookies,
+            files=files,
+            timeout=self.plugin.get_option_value("timeout"),
+            disable_ssl_verify=self.plugin.get_option_value("disable_ssl"),
+            allow_redirects=True,
+            stream=False,
+            user_agent=self.plugin.get_option_value("user_agent"))
+        result = {
+            'url': url,
+            'code': code,
+            'response': response,
+        }
+        self.ctx.urls_before.append(url)
+        return self.make_response(item, result)

pygpt_net/plugin/idx_llama_index/config.py

@@ -6,7 +6,7 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2024.11.18 19:00:00                  #
+# Updated Date: 2024.12.14 19:00:00                  #
 # ================================================== #
 
 from pygpt_net.plugin.base.config import BaseConfig, BasePlugin
@@ -71,7 +71,7 @@ class Config(BaseConfig):
             "model_prepare_question",
             type="combo",
             use="models",
-            value="gpt-3.5-turbo",
+            value="gpt-4o-mini",
             label="Model for question preparation",
             description="Model used to prepare question before asking Llama-index, default: gpt-3.5-turbo",
             tooltip="Model",
@@ -88,7 +88,7 @@ class Config(BaseConfig):
         plugin.add_option(
             "model_query",
             type="combo",
-            value="gpt-3.5-turbo",
+            value="gpt-4o-mini",
             label="Model",
             description="Model used for querying Llama-index, default: gpt-3.5-turbo",
             tooltip="Query model",

pygpt_net/plugin/mailer/__init__.py

@@ -0,0 +1,123 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# ================================================== #
+# This file is a part of PYGPT package               #
+# Website: https://pygpt.net                         #
+# GitHub:  https://github.com/szczyglis-dev/py-gpt   #
+# MIT License                                        #
+# Created By  : Marcin Szczygliński                  #
+# Updated Date: 2024.12.15 04:00:00                  #
+# ================================================== #
+
+from pygpt_net.plugin.base.plugin import BasePlugin
+from pygpt_net.core.events import Event
+from pygpt_net.item.ctx import CtxItem
+
+from .config import Config
+from .runner import Runner
+from .worker import Worker
+
+from pygpt_net.utils import trans
+
+
+class Plugin(BasePlugin):
+    def __init__(self, *args, **kwargs):
+        super(Plugin, self).__init__(*args, **kwargs)
+        self.id = "mailer"
+        self.name = "Mailer"
+        self.description = "Provides email sending"
+        self.prefix = "Email"
+        self.type = [
+            'email',
+        ]
+        self.order = 100
+        self.allowed_cmds = [
+            "send_mail",
+            "get_emails",
+            "get_email_body",
+        ]
+        self.use_locale = True
+        self.runner = Runner(self)
+        self.worker = None
+        self.config = Config(self)
+        self.init_options()
+
+    def init_options(self):
+        """Initialize options"""
+        self.config.from_defaults(self)
+
+    def handle(self, event: Event, *args, **kwargs):
+        """
+        Handle dispatched event
+
+        :param event: event object
+        :param args: args
+        :param kwargs: kwargs
+        """
+        name = event.name
+        data = event.data
+        ctx = event.ctx
+        silent = data.get("silent", False)
+
+        if name == Event.CMD_SYNTAX:
+            self.cmd_syntax(data)
+
+        elif name == Event.CMD_EXECUTE:
+            self.cmd(
+                ctx,
+                data['commands'],
+                silent,
+            )
+
+    def cmd_syntax(self, data: dict):
+        """
+        Event: CMD_SYNTAX
+
+        :param data: event data dict
+        """
+        for item in self.allowed_cmds:
+            if self.has_cmd(item):
+                cmd = self.get_cmd(item)
+                data['cmd'].append(cmd)  # append command
+
+    def cmd(self, ctx: CtxItem, cmds: list, silent: bool = False):
+        """
+        Event: CMD_EXECUTE
+
+        :param ctx: CtxItem
+        :param cmds: commands dict
+        :param silent: silent mode
+        """
+        is_cmd = False
+        force = False
+        my_commands = []
+        for item in cmds:
+            if item["cmd"] in self.allowed_cmds:
+                my_commands.append(item)
+                is_cmd = True
+                if "force" in item and item["force"]:
+                    force = True  # call from tool
+
+        if not is_cmd:
+            return
+
+        # set state: busy
+        if not silent:
+            self.cmd_prepare(ctx, my_commands)
+
+        try:
+            worker = Worker()
+            worker.from_defaults(self)
+            worker.cmds = my_commands
+            worker.ctx = ctx
+
+            # connect signals
+            self.runner.attach_signals(worker.signals)
+
+            if not self.is_async(ctx) and not force:
+                worker.run()
+                return
+            worker.run_async()
+
+        except Exception as e:
+            self.error(e)

pygpt_net/plugin/mailer/config.py

@@ -0,0 +1,149 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# ================================================== #
+# This file is a part of PYGPT package               #
+# Website: https://pygpt.net                         #
+# GitHub:  https://github.com/szczyglis-dev/py-gpt   #
+# MIT License                                        #
+# Created By  : Marcin Szczygliński                  #
+# Updated Date: 2024.12.15 04:00:00                  #
+# ================================================== #
+
+from pygpt_net.plugin.base.config import BaseConfig, BasePlugin
+
+
+class Config(BaseConfig):
+    def __init__(self, plugin: BasePlugin = None, *args, **kwargs):
+        super(Config, self).__init__(plugin)
+        self.plugin = plugin
+
+    def from_defaults(self, plugin: BasePlugin = None):
+        """
+        Set default options for plugin
+
+        :param plugin: plugin instance
+        """
+        plugin.add_option(
+            "smtp_host",
+            type="text",
+            value="",
+            label="SMTP Host",
+            persist=True,
+            tab="smtp",
+        )
+        plugin.add_option(
+            "smtp_port_inbox",
+            type="int",
+            value=995,
+            label="SMTP Port (Inbox)",
+            persist=True,
+            tab="smtp",
+        )
+        plugin.add_option(
+            "smtp_port_outbox",
+            type="int",
+            value=465,
+            label="SMTP Port (Outbox)",
+            persist=True,
+            tab="smtp",
+        )
+        plugin.add_option(
+            "smtp_user",
+            type="text",
+            value="",
+            label="SMTP User",
+            persist=True,
+            tab="smtp",
+        )
+        plugin.add_option(
+            "smtp_password",
+            type="text",
+            value="",
+            label="SMTP Password",
+            secret=True,
+            persist=True,
+            tab="smtp",
+        )
+        plugin.add_option(
+            "from_email",
+            type="text",
+            value="",
+            label="From (email)",
+        )
+        plugin.add_cmd(
+            "send_email",
+            instruction="Send email to specified address",
+            params=[
+                {
+                    "name": "recipient",
+                    "type": "str",
+                    "description": "Recipient email address",
+                    "required": True,
+                },
+                {
+                    "name": "subject",
+                    "type": "str",
+                    "description": "Email subject",
+                    "required": True,
+                },
+                {
+                    "name": "message",
+                    "type": "str",
+                    "description": "Email message",
+                    "required": True,
+                },
+            ],
+            enabled=True,
+            description="Allows sending emails",
+            tab="general",
+        )
+        plugin.add_cmd(
+            "get_emails",
+            instruction="Retrieve emails from the inbox. Use this to access emails from the inbox when the user "
+                        "requests fetching emails from their server.",
+            params=[
+                {
+                    "name": "limit",
+                    "type": "int",
+                    "description": "Limit of emails to receive, default: 10",
+                    "required": True,
+                },
+                {
+                    "name": "offset",
+                    "type": "int",
+                    "description": "Offset of emails to receive, default: 0",
+                    "required": False,
+                },
+                {
+                    "name": "order",
+                    "type": "text",
+                    "description": "Sort order, default: desc, options: asc, desc",
+                    "required": False,
+                },
+            ],
+            enabled=True,
+            description="Allows receiving emails",
+            tab="general",
+        )
+        plugin.add_cmd(
+            "get_email_body",
+            instruction="Retrieve the complete email content from the inbox. Use this to access the message body. "
+                        "To obtain email IDs, use the 'get_emails' function first.",
+            params=[
+                {
+                    "name": "id",
+                    "type": "int",
+                    "description": "Email ID (index)",
+                    "required": True,
+                },
+                {
+                    "name": "format",
+                    "type": "text",
+                    "description": "Display format, default: text, options: text, html",
+                    "required": False,
+                },
+            ],
+            enabled=True,
+            description="Allows receiving email body",
+            tab="general",
+        )

pygpt_net/plugin/mailer/runner.py

@@ -0,0 +1,285 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# ================================================== #
+# This file is a part of PYGPT package               #
+# Website: https://pygpt.net                         #
+# GitHub:  https://github.com/szczyglis-dev/py-gpt   #
+# MIT License                                        #
+# Created By  : Marcin Szczygliński                  #
+# Updated Date: 2024.12.15 04:00:00                  #
+# ================================================== #
+
+import datetime
+import smtplib
+import poplib
+
+from email.parser import BytesParser
+from typing import Any
+from bs4 import BeautifulSoup
+
+from pygpt_net.item.ctx import CtxItem
+
+
+class Runner:
+    def __init__(self, plugin=None):
+        """
+        Cmd Runner
+
+        :param plugin: plugin
+        """
+        self.plugin = plugin
+        self.signals = None
+
+    def attach_signals(self, signals):
+        """
+        Attach signals
+
+        :param signals: signals
+        """
+        self.signals = signals
+
+    def parse_email(self, msg, as_text: bool = True) -> str:
+        """
+        Parse email message
+
+        :param msg: email message
+        :param as_text: return as text
+        :return: parsed email
+        """
+        body = ""
+        is_html = False
+        if msg.is_multipart():
+            for part in msg.walk():
+                content_type = part.get_content_type()
+                content_disposition = str(part.get('Content-Disposition'))
+                if content_type == 'text/plain' and 'attachment' not in content_disposition:
+                    body = part.get_payload(decode=True).decode(part.get_content_charset('utf-8'))
+                elif content_type == 'text/html' and 'attachment' not in content_disposition:
+                    body = part.get_payload(decode=True).decode(part.get_content_charset('utf-8'))
+                    is_html = True
+        else:
+            body = msg.get_payload(decode=True).decode(msg.get_content_charset('utf-8'))
+        if is_html and as_text:
+            body = BeautifulSoup(body, 'html.parser').get_text()
+        return body
+
+    def smtp_get_email_body(self, ctx: CtxItem, item: dict, request: dict) -> dict:
+        """
+        Receive emails from mailbox
+
+        :param ctx: CtxItem
+        :param item: command item
+        :param request: request item
+        :return: response dict
+        """
+        server = self.plugin.get_option_value("smtp_host")
+        port = self.plugin.get_option_value("smtp_port_inbox")
+        id = item["params"].get("id", "")
+        username = self.plugin.get_option_value("smtp_user")
+        password = self.plugin.get_option_value("smtp_password")
+        msg = "Receiving email from: {}".format(server)
+        format = "text"
+        as_text = True
+        if "format" in item["params"]:
+            format = item["params"]["format"].lower()
+        if format == "html":
+            as_text = False
+        self.log(msg)
+        try:
+            if port in [995]:
+                pop3 = poplib.POP3_SSL(server, port)
+            else:
+                pop3 = poplib.POP3(server, port)
+
+            msg = pop3.getwelcome().decode('utf-8')
+            self.log(msg)
+            pop3.user(username)
+            pop3.pass_(password)
+            response, lines, octets = pop3.retr(id)
+            msg_content = b'\r\n'.join(lines)
+            msg = BytesParser().parsebytes(msg_content)
+            result = {
+                "ID": id,
+                "From": msg["From"],
+                "Subject": msg["Subject"],
+                "Date": msg["Date"],
+                "Message": self.parse_email(msg, as_text)
+            }
+            pop3.quit()
+        except Exception as e:
+            self.error(e)
+            result = "Error: {}".format(str(e))
+        return {
+            "request": request,
+            "result": str(result)
+        }
+
+    def smtp_receive_emails(self, ctx: CtxItem, item: dict, request: dict) -> dict:
+        """
+        Receive emails from mailbox
+
+        :param ctx: CtxItem
+        :param item: command item
+        :param request: request item
+        :return: response dict
+        """
+        server = self.plugin.get_option_value("smtp_host")
+        port = self.plugin.get_option_value("smtp_port_inbox")
+        limit = item["params"].get("limit", 10)
+        offset = item["params"].get("offset", 0)
+        username = self.plugin.get_option_value("smtp_user")
+        password = self.plugin.get_option_value("smtp_password")
+        msg = "Receiving emails from: {}".format(server)
+        order = "desc"
+        if "order" in item["params"]:
+            tmp_order = item["params"]["order"].lower()
+            if tmp_order in ["asc", "desc"]:
+                order = tmp_order
+        self.log(msg)
+
+        messages = []
+        try:
+            if port in [995]:
+                pop3 = poplib.POP3_SSL(server, port)
+            else:
+                pop3 = poplib.POP3(server, port)
+
+            msg = pop3.getwelcome().decode('utf-8')
+            self.log(msg)
+            pop3.user(username)
+            pop3.pass_(password)
+
+            message_count, mailbox_size = pop3.stat()
+            total = message_count
+            print(f'Num of messages: {message_count}, Inbox size: {mailbox_size} bytes')
+
+            if order == "desc":
+                if offset > 0:
+                    message_count -= offset
+                if message_count < limit:
+                    limit = message_count
+                range_max = message_count - limit
+                if limit == 0:
+                    range_max = 0
+                for i in range(message_count, range_max, -1):
+                    response, lines, octets = pop3.top(i, 0)
+                    msg_content = b'\r\n'.join(lines)
+                    msg = BytesParser().parsebytes(msg_content)
+                    msg_body = {
+                        "ID": i,
+                        "From": msg["From"],
+                        "Subject": msg["Subject"],
+                        "Date": msg["Date"],
+                    }
+                    messages.append(msg_body)
+            else:
+                if limit == 0:
+                    limit = message_count
+                else:
+                    limit += offset
+                if limit > message_count:
+                    limit = message_count
+                for i in range(offset + 1, limit + 1):
+                    response, lines, octets = pop3.top(i, 0)
+                    msg_content = b'\r\n'.join(lines)
+                    msg = BytesParser().parsebytes(msg_content)
+                    msg_body = {
+                        "ID": i,
+                        "From": msg["From"],
+                        "Subject": msg["Subject"],
+                        "Date": msg["Date"],
+                    }
+                    messages.append(msg_body)
+
+            pop3.quit()
+            result = {
+                "total": total,
+                "messages": messages,
+            }
+        except Exception as e:
+            self.error(e)
+            result = "Error: {}".format(str(e))
+        return {
+            "request": request,
+            "result": str(result)
+        }
+
+    def smtp_send_email(self, ctx: CtxItem, item: dict, request: dict) -> dict:
+        """
+        Execute system command on host
+
+        :param ctx: CtxItem
+        :param item: command item
+        :param request: request item
+        :return: response dict
+        """
+        msg = "Sending email to: {}".format(item["params"]['recipient'])
+        self.log(msg)
+        try:
+            email_to = item["params"]['recipient']
+            message = item["params"]['message']
+            subject = item["params"]['subject']
+            from_addr = self.plugin.get_option_value("from_email")
+            host = self.plugin.get_option_value("smtp_host")
+            port = self.plugin.get_option_value("smtp_port_outbox")
+            user = self.plugin.get_option_value("smtp_user")
+            password = self.plugin.get_option_value("smtp_password")
+            date = datetime.datetime.now().strftime("%d/%m/%Y %H:%M")
+            body = """From: {sender}\nTo: {to}\nDate: {date}\nSubject: {subject}\n\n{msg}
+                    """.format(sender=from_addr, to=email_to, date=date, subject=subject, msg=message)
+            if port in [465]:
+                server = smtplib.SMTP_SSL(host, port)
+            else:
+                server = smtplib.SMTP(host, port)
+            server.ehlo()
+            if port in [587]:
+                server.starttls()
+            server.login(user, password)
+            server.sendmail(from_addr, email_to, body)
+            server.close()
+            result = "OK"
+        except Exception as e:
+            self.error(e)
+            result = "Error: {}".format(str(e))
+        return {
+            "request": request,
+            "result": str(result)
+        }
+
+    def error(self, err: Any):
+        """
+        Log error message
+
+        :param err: exception or error message
+        """
+        if self.signals is not None:
+            self.signals.error.emit(err)
+
+    def status(self, msg: str):
+        """
+        Send status message
+
+        :param msg: status message
+        """
+        if self.signals is not None:
+            self.signals.status.emit(msg)
+
+    def debug(self, msg: Any):
+        """
+        Log debug message
+
+        :param msg: message to log
+        """
+        if self.signals is not None:
+            self.signals.debug.emit(msg)
+
+    def log(self, msg, sandbox: bool = False):
+        """
+        Log message to console
+
+        :param msg: message to log
+        :param sandbox: is sandbox mode
+        """
+        full_msg = '[SMTP]' + ' ' + str(msg)
+        if self.signals is not None:
+            self.signals.log.emit(full_msg)