pygpt-net 2.4.37__py3-none-any.whl → 2.4.42__py3-none-any.whl

pygpt_net/core/ctx/__init__.py

@@ -6,12 +6,13 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2024.11.26 19:00:00                  #
+# Updated Date: 2024.12.14 08:00:00                  #
 # ================================================== #
 
 import copy
 import datetime
 import uuid
+from typing import Optional, Tuple, List, Dict
 
 from packaging.version import Version
 
@@ -97,104 +98,250 @@ class Ctx:
         self.current_sys_prompt = ""
         self.groups_loaded = False
 
-    def get_items(self):
-        # print(self.container.count_items())
+    def get_items(self) -> List[CtxItem]:
+        """
+        Get context items
+
+        :return: context items
+        """
         return self.container.get_items()
 
-    def set_items(self, items):
+    def set_items(self, items: List[CtxItem]):
+        """
+        Set context items
+
+        :param items: context items
+        """
         self.container.set_items(items)
 
     def clear_items(self):
+        """Clear context items"""
         self.container.clear_items()
 
-    def count_items(self):
+    def count_items(self) -> int:
+        """
+        Count context items
+        :return: context items count
+        """
         return self.container.count_items()
 
-    def get_current(self):
+    def get_current(self) -> int:
+        """
+        Get current context ID
+
+        :return: current context ID
+        """
         return self.current
 
-    def set_current(self, current):
+    def set_current(self, current: int):
+        """
+        Set current context ID
+
+        :param current: current context ID
+        """
         self.current = current
 
     def clear_current(self):
+        """Clear current context ID"""
         self.current = None
 
-    def get_last_item(self):
+    def get_last_item(self) -> Optional[CtxItem]:
+        """
+        Get last item
+
+        :return: last item
+        """
         return self.last_item
 
-    def set_last_item(self, last_item):
+    def set_last_item(self, last_item: Optional[CtxItem]):
+        """
+        Set last item
+
+        :param last_item: last item
+        """
         self.last_item = last_item
 
-    def get_assistant(self):
+    def get_assistant(self) -> str:
+        """
+        Get assistant name
+
+        :return: assistant name
+        """
         return self.assistant
 
-    def set_assistant(self, assistant):
+    def set_assistant(self, assistant: str):
+        """
+        Set assistant name
+
+        :param assistant: assistant name
+        :return: assistant name
+        """
         self.assistant = assistant
 
-    def get_mode(self):
+    def get_mode(self) -> str:
+        """
+        Get mode
+
+        :return: mode
+        """
         return self.mode
 
-    def set_mode(self, mode):
+    def set_mode(self, mode: str):
+        """
+        Set mode
+
+        :param mode: mode
+        """
         self.mode = mode
 
-    def get_model(self):
+    def get_model(self) -> str:
+        """
+        Get model name
+        :return: model name
+        """
         return self.model
 
-    def set_model(self, model):
+    def set_model(self, model: str):
+        """
+        Set model name
+
+        :param model: model name
+        """
         self.model = model
 
-    def get_preset(self):
+    def get_preset(self) -> str:
+        """
+        Get preset name
+        :return: preset
+        """
         return self.preset
 
-    def set_preset(self, preset):
+    def set_preset(self, preset: str):
+        """
+        Set preset name
+
+        :param preset: preset name
+        """
         self.preset = preset
 
-    def get_run(self):
+    def get_run(self) -> str:
+        """
+        Get run ID
+
+        :return: run ID
+        """
         return self.run
 
-    def set_status(self, status):
+    def set_status(self, status: int):
+        """
+        Set status (label color)
+
+        :param status: status
+        """
         self.status = status
 
-    def get_status(self):
+    def get_status(self) -> int:
+        """
+        Get status (label color)
+
+        :return: status
+        """
         return self.status
 
-    def set_run(self, run):
+    def set_run(self, run: str):
+        """
+        Set run ID
+
+        :param run: run ID
+        """
         self.preset = run
 
-    def get_thread(self):
+    def get_thread(self) -> str:
+        """
+        Get thread ID
+
+        :return: thread ID
+        """
         return self.thread
 
-    def set_thread(self, thread):
+    def set_thread(self, thread: str):
+        """
+        Set thread ID
+
+        :param thread: thread ID
+        """
         self.thread = thread
 
     def clear_thread(self):
+        """Clear thread ID"""
         self.thread = None
 
-    def get_last_mode(self):
+    def get_last_mode(self) -> str:
+        """
+        Get last mode
+
+        :return: last mode
+        """
         return self.last_mode
 
-    def set_last_mode(self, last_mode):
+    def set_last_mode(self, last_mode: str):
+        """
+        Set last mode
+
+        :param last_mode: last mode
+        """
         self.last_mode = last_mode
 
-    def get_last_model(self):
+    def get_last_model(self) -> str:
+        """
+        Get last model name
+
+        :return: last model
+        """
         return self.last_model
 
-    def set_last_model(self, last_model):
+    def set_last_model(self, last_model: str):
+        """
+        Set last model name
+
+        :param last_model: last model name
+        """
         self.last_model = last_model
 
-    def get_tmp_meta(self):
+    def get_tmp_meta(self) -> Optional[CtxMeta]:
+        """
+        Get temporary meta
+
+        :return: temporary meta
+        """
         return self.tmp_meta
 
-    def set_tmp_meta(self, tmp_meta):
+    def set_tmp_meta(self, tmp_meta: Optional[CtxMeta]):
+        """
+        Set temporary meta
+
+        :param tmp_meta: temporary meta
+        """
         self.tmp_meta = tmp_meta
 
-    def get_search_string(self):
+    def get_search_string(self) -> Optional[str]:
+        """
+        Get search string
+
+        :return: search string
+        """
         return self.search_string
 
-    def set_search_string(self, search_string):
+    def set_search_string(self, search_string: Optional[str]):
+        """
+        Set search string
+
+        :param search_string: search string
+        """
         self.search_string = search_string
 
     def clear_search_string(self):
+        """Clear search string"""
         self.search_string = None
 
     def install(self):
@@ -218,7 +365,11 @@ class Ctx:
         """
         return self.provider
 
-    def select(self, id: int, restore_model: bool = True):
+    def select(
+            self,
+            id: int,
+            restore_model: bool = True
+    ):
         """
         Select ctx meta by ID and load ctx items
 
@@ -254,7 +405,10 @@ class Ctx:
 
             self.set_items(self.load(id))
 
-    def new(self, group_id: int = None) -> CtxMeta or None:
+    def new(
+            self,
+            group_id: Optional[int] = None
+    ) -> Optional[CtxMeta]:
         """
         Create new ctx and set as current
 
@@ -294,7 +448,10 @@ class Ctx:
         meta.initialized = False
         return meta
 
-    def create(self, group_id: int = None) -> CtxMeta:
+    def create(
+            self,
+            group_id: Optional[int] = None
+    ) -> CtxMeta:
         """
         Send created meta to provider and return new ID
 
@@ -308,7 +465,11 @@ class Ctx:
         meta.id = id
         return meta
 
-    def add(self, item: CtxItem, parent_id: int = None):
+    def add(
+            self,
+            item: CtxItem,
+            parent_id: Optional[int] = None
+    ):
         """
         Add CtxItem to contexts and saves context
 
@@ -333,7 +494,11 @@ class Ctx:
                 if not result:
                     self.store()  # if not stored, e.g. in JSON file provider, then store whole ctx (save all)
 
-    def add_to_meta(self, item: CtxItem, meta_id: int = None):
+    def add_to_meta(
+            self,
+            item: CtxItem,
+            meta_id: Optional[int] = None
+    ):
         """
         Add CtxItem to custom meta
 
@@ -490,6 +655,16 @@ class Ctx:
         for item in self.get_items():
             if item.id == id:
                 return item
+        return self.fetch_item_by_id(id)   # if no item found, try to fetch from DB
+
+    def fetch_item_by_id(self, id: int) -> CtxItem:
+        """
+        Fetch ctx item by id
+
+        :param id: item id
+        :return: context item
+        """
+        return self.provider.get_item_by_id(id)
 
     def get_meta(self, reload: bool = False) -> dict:
         """
@@ -502,7 +677,7 @@ class Ctx:
             self.load_meta()
         return self.meta
 
-    def get_current_meta(self) -> CtxMeta or None:
+    def get_current_meta(self) -> Optional[CtxMeta]:
         """
         Get current meta
 
@@ -555,7 +730,7 @@ class Ctx:
         if id in self.meta:
             return self.meta[id]
 
-    def get_last(self) -> CtxItem or None:
+    def get_last(self) -> Optional[CtxItem]:
         """
         Return last item from ctx
 
@@ -587,7 +762,7 @@ class Ctx:
             return self.get_items()[-1].id == item_id
         return False
 
-    def get_previous_item(self, item_id: int) -> CtxItem or None:
+    def get_previous_item(self, item_id: int) -> Optional[CtxItem]:
         """
         Get previous item from ctx
 
@@ -633,7 +808,10 @@ class Ctx:
         """
         return len(self.meta)
 
-    def all(self, meta_id: int = None) -> list:
+    def all(
+            self,
+            meta_id: Optional[int] = None
+    ) -> List[CtxItem]:
         """
         Return ctx items (current or by meta_id if provided)
 
@@ -667,7 +845,11 @@ class Ctx:
                 self.provider.remove_item(id)
                 break
 
-    def remove_items_from(self, meta_id: int, item_id: int):
+    def remove_items_from(
+            self,
+            meta_id: int,
+            item_id: int
+    ):
         """
         Remove ctx items from meta_id
 
@@ -731,7 +913,11 @@ class Ctx:
             self.meta[self.current].status = self.status
             self.save(self.current)
 
-    def get_or_create_slave_meta(self, master_ctx: CtxItem, preset_id: str) -> CtxMeta:
+    def get_or_create_slave_meta(
+            self,
+            master_ctx: CtxItem,
+            preset_id: str
+    ) -> CtxMeta:
         """
         Get or create slave meta
 
@@ -758,7 +944,7 @@ class Ctx:
         slave.id = id
         return slave
 
-    def get_prev(self) -> int or None:
+    def get_prev(self) -> Optional[int]:
         """
         Get previous context
 
@@ -771,7 +957,7 @@ class Ctx:
             if idx > 0:
                 return self.get_id_by_idx(idx - 1)
 
-    def get_next(self) -> int or None:
+    def get_next(self) -> Optional[int]:
         """
         Get next context
 
@@ -784,7 +970,7 @@ class Ctx:
             if idx < self.count_meta() - 1:
                 return self.get_id_by_idx(idx + 1)
 
-    def get_last_meta(self) -> int or None:
+    def get_last_meta(self) -> Optional[int]:
         """
         Get last context
 
@@ -794,12 +980,12 @@ class Ctx:
 
     def count_history(
             self,
-            history_items: list,
+            history_items: List[CtxItem],
             model: str,
             mode: str,
             used_tokens: int = 100,
             max_tokens: int = 1000
-    ) -> (int, int):
+    ) -> Tuple[int, int]:
         """
         Count ctx items to add to prompt
 
@@ -826,7 +1012,7 @@ class Ctx:
 
     def get_history(
             self,
-            history_items: list,
+            history_items: List[CtxItem],
             model: str,
             mode: str = MODE_CHAT,
             used_tokens: int = 100,
@@ -867,7 +1053,7 @@ class Ctx:
             mode: str,
             used_tokens: int = 100,
             max_tokens: int = 1000
-    ) -> (int, int):
+    ) -> Tuple[int, int]:
         """
         Count ctx items to add to prompt
 
@@ -1007,7 +1193,11 @@ class Ctx:
         """
         self.filters = filters
 
-    def is_allowed_for_mode(self, mode: str, check_assistant: bool = True) -> bool:
+    def is_allowed_for_mode(
+            self,
+            mode: str,
+            check_assistant: bool = True
+    ) -> bool:
         """
         Check if ctx is allowed for this mode
 
@@ -1159,7 +1349,7 @@ class Ctx:
             }
         return filters
 
-    def load(self, id: int) -> list:
+    def load(self, id: int) -> List[CtxItem]:
         """
         Load ctx items from provider and append meta to each item
 
@@ -1187,7 +1377,7 @@ class Ctx:
             return True
         return False
 
-    def get_groups(self) -> dict:
+    def get_groups(self) -> Dict[int, CtxGroup]:
         """
         Get groups
 
@@ -1198,7 +1388,7 @@ class Ctx:
             self.groups_loaded = True
         return self.groups
 
-    def get_group_by_id(self, id: int) -> CtxGroup or None:
+    def get_group_by_id(self, id: int) -> Optional[CtxGroup]:
         """
         Get group by ID
 
@@ -1212,7 +1402,11 @@ class Ctx:
             return None
         return self.groups[id]
 
-    def remove_group(self, group: CtxGroup, all: bool = False):
+    def remove_group(
+            self,
+            group: CtxGroup,
+            all: bool = False
+    ):
         """
         Remove group
 
@@ -1273,9 +1467,9 @@ class Ctx:
         self.provider.update_meta_group_id(id, group_id)
         self.load_groups()
 
-    def get_items_by_id(self, id: int) -> list:
+    def get_items_by_id(self, id: int) -> List[str]:
         """
-        Get ctx items by id
+        Get ctx items by id as string list
 
         :param id: ctx id
         :return: ctx items list
@@ -1287,7 +1481,11 @@ class Ctx:
             data.append("Human: " + str(item.input) + "\n" + "Assistant: " + str(item.output) + "\n")
         return data
 
-    def get_list_in_date_range(self, search_string, limit: int = 0) -> list:
+    def get_list_in_date_range(
+            self,
+            search_string: Optional[str] = None,
+            limit: int = 0
+    ) -> List[Dict[str, Dict]]:
         """
         Get ctx list in date range
 
@@ -1361,10 +1559,13 @@ class Ctx:
         """
         prev_ctx = CtxItem()
         prev_ctx.urls = copy.deepcopy(ctx.urls)
+        prev_ctx.urls_before = copy.deepcopy(ctx.urls_before)
         prev_ctx.images = copy.deepcopy(ctx.images)
         prev_ctx.images_before = copy.deepcopy(ctx.images_before)
         prev_ctx.files = copy.deepcopy(ctx.files)
+        prev_ctx.files_before = copy.deepcopy(ctx.files_before)
         prev_ctx.attachments = copy.deepcopy(ctx.attachments)
+        prev_ctx.attachments_before = copy.deepcopy(ctx.attachments_before)
         prev_ctx.results = copy.deepcopy(ctx.results)
         prev_ctx.index_meta = copy.deepcopy(ctx.index_meta)
         prev_ctx.doc_ids = copy.deepcopy(ctx.doc_ids)
@@ -1372,7 +1573,8 @@ class Ctx:
         prev_ctx.output_name = copy.deepcopy(ctx.output_name)
 
         ctx.clear_reply()  # clear current reply result
-        ctx.from_previous()  # get result from previous if exists
+        if len(ctx.cmds) == 0:
+            ctx.from_previous()  # get result from previous if exists
         return prev_ctx
 
     def dump(self, ctx: CtxItem) -> str:

pygpt_net/core/ctx/bag.py

@@ -6,9 +6,14 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2024.11.05 23:00:00                  #
+# Updated Date: 2024.12.14 08:00:00                  #
 # ================================================== #
 
+from typing import List
+
+from pygpt_net.item.ctx import CtxItem
+
+
 class Bag:
     def __init__(self, window=None):
         """
@@ -19,14 +24,30 @@ class Bag:
         self.tab_id = 0
         self.items = []
 
-    def get_items(self):
+    def get_items(self) -> List[CtxItem]:
+        """
+        Return ctx items
+
+        :return: ctx items
+        """
         return self.items
 
-    def set_items(self, items):
+    def set_items(self, items: List[CtxItem]):
+        """
+        Set ctx items
+
+        :param items: ctx items
+        """
         self.items = items
 
     def clear_items(self):
+        """Clear items"""
         self.items = []
 
-    def count_items(self):
+    def count_items(self) -> int:
+        """
+        Count ctx items
+
+        :return: items count
+        """
         return len(self.items)