fmtr.tools 1.1.1__py3-none-any.whl → 1.3.81__py3-none-any.whl

fmtr/tools/__init__.py

@@ -1,8 +1,5 @@
-from fmtr.tools import version_tools as version
-
-__version__ = version.read()
-
-
+import fmtr.tools.async_tools as asyncio
+import fmtr.tools.database_tools as db
 import fmtr.tools.dataclass_tools as dataclass
 import fmtr.tools.datatype_tools as datatype
 import fmtr.tools.environment_tools as env
@@ -10,156 +7,175 @@ import fmtr.tools.environment_tools as environment
 import fmtr.tools.function_tools as function
 import fmtr.tools.hash_tools as hash
 import fmtr.tools.import_tools as import_
+import fmtr.tools.inherit_tools as inherit
 import fmtr.tools.iterator_tools as iterator
 import fmtr.tools.json_tools as json
+import fmtr.tools.logging_tools as logging
+import fmtr.tools.name_tools as name
+import fmtr.tools.packaging_tools as packaging
 import fmtr.tools.path_tools as path
 import fmtr.tools.platform_tools as platform
 import fmtr.tools.random_tools as random
+import fmtr.tools.setup_tools as setup
 import fmtr.tools.string_tools as string
-import fmtr.tools.name_tools as name
-import fmtr.tools.logging_tools as logging
-import fmtr.tools.async_tools as asyncio
-from fmtr.tools.logging_tools import logger
-
-from fmtr.tools.import_tools import MissingExtraMockModule
-from fmtr.tools.path_tools import Path, PackagePaths
+from fmtr.tools import ai_tools as ai
+from fmtr.tools import datetime_tools as dt
+from fmtr.tools import dns_tools as dns
+from fmtr.tools import docker_tools as docker
+from fmtr.tools import interface_tools as interface
+from fmtr.tools import version_tools as version
 from fmtr.tools.constants import Constants
+from fmtr.tools.import_tools import MissingExtraMockModule
+from fmtr.tools.logging_tools import logger
+# Submodules
+from fmtr.tools.path_tools import Path, PackagePaths, AppPaths
+from fmtr.tools.setup_tools import Setup, SetupPaths, Dependencies, Tools
 
 try:
     from fmtr.tools import augmentation_tools as augmentation
-except ImportError as exception:
+except ModuleNotFoundError as exception:
     augmentation = MissingExtraMockModule('augmentation', exception)
 
 try:
     from fmtr.tools import yaml_tools as yaml
-except ImportError as exception:
+except ModuleNotFoundError as exception:
     yaml = MissingExtraMockModule('yaml', exception)
 
-try:
-    from fmtr.tools import docker_tools as docker
-    from fmtr.tools.docker_tools import Container
-except ImportError as exception:
-    docker = Container = MissingExtraMockModule('docker.api', exception)
 
 try:
     from fmtr.tools import parallel_tools as parallel
-except ImportError as exception:
+except ModuleNotFoundError as exception:
     parallel = MissingExtraMockModule('parallel', exception)
 
 try:
     from fmtr.tools import profiling_tools as profiling
     from fmtr.tools.profiling_tools import Timer
-except ImportError as exception:
+except ModuleNotFoundError as exception:
     profiling = Timer = MissingExtraMockModule('profiling', exception)
 
 try:
     import fmtr.tools.process_tools as process
     from fmtr.tools.process_tools import ContextProcess
-except ImportError as exception:
+except ModuleNotFoundError as exception:
     process = ContextProcess = MissingExtraMockModule('process', exception)
 
 try:
     from fmtr.tools import tokenization_tools as tokenization
-except ImportError as exception:
+except ModuleNotFoundError as exception:
     tokenization = MissingExtraMockModule('tokenization', exception)
 
 try:
     from fmtr.tools import unicode_tools as unicode
-except ImportError as exception:
+except ModuleNotFoundError as exception:
     unicode = MissingExtraMockModule('unicode', exception)
 
 try:
     from fmtr.tools import netrc_tools as netrc
-except ImportError as exception:
+except ModuleNotFoundError as exception:
     netrc = MissingExtraMockModule('netrc', exception)
 
 try:
     from fmtr.tools import spaces_tools as spaces
-except ImportError as exception:
+except ModuleNotFoundError as exception:
     spaces = MissingExtraMockModule('spaces', exception)
 
 try:
     from fmtr.tools import hfh_tools as hfh
-except ImportError as exception:
+except ModuleNotFoundError as exception:
     hfh = MissingExtraMockModule('hfh', exception)
 
 try:
     from fmtr.tools import merging_tools as merging
     from fmtr.tools.merging_tools import merge
-except ImportError as exception:
+except ModuleNotFoundError as exception:
     merging = merge = MissingExtraMockModule('merging', exception)
 
 try:
     from fmtr.tools import api_tools as api
-except ImportError as exception:
+except ModuleNotFoundError as exception:
     api = MissingExtraMockModule('api', exception)
 
-try:
-    from fmtr.tools import ai_tools as ai
-except ImportError as exception:
-    ai = MissingExtraMockModule('ai', exception)
-
 try:
     from fmtr.tools import data_modelling_tools as dm
-except ImportError as exception:
+except ModuleNotFoundError as exception:
     dm = MissingExtraMockModule('dm', exception)
 
 try:
     from fmtr.tools import json_fix_tools as json_fix
-except ImportError as exception:
+except ModuleNotFoundError as exception:
     json_fix = MissingExtraMockModule('json_fix', exception)
 
 try:
     from fmtr.tools import semantic_tools as semantic
-except ImportError as exception:
+except ModuleNotFoundError as exception:
     semantic = MissingExtraMockModule('semantic', exception)
 
 try:
     from fmtr.tools import metric_tools as metric
-except ImportError as exception:
+except ModuleNotFoundError as exception:
     metric = MissingExtraMockModule('metric', exception)
 
 try:
     from fmtr.tools import html_tools as html
-except ImportError as exception:
+except ModuleNotFoundError as exception:
     html = MissingExtraMockModule('html', exception)
 
-try:
-    from fmtr.tools import interface_tools as interface
-except ImportError as exception:
-    interface = MissingExtraMockModule('interface', exception)
-
 try:
     from fmtr.tools import openai_tools as openai
-except ImportError as exception:
+except ModuleNotFoundError as exception:
     openai = MissingExtraMockModule('openai', exception)
 
 try:
     from fmtr.tools import google_api_tools as google_api
-except ImportError as exception:
+except ModuleNotFoundError as exception:
     google_api = MissingExtraMockModule('google.api', exception)
 
 try:
     from fmtr.tools import caching_tools as caching
-except ImportError as exception:
+except ModuleNotFoundError as exception:
     caching = MissingExtraMockModule('caching', exception)
 
 try:
     from fmtr.tools import pdf_tools as pdf
-except ImportError as exception:
+except ModuleNotFoundError as exception:
     pdf = MissingExtraMockModule('pdf', exception)
 
 try:
     from fmtr.tools import tabular_tools as tabular
-except ImportError as exception:
+except ModuleNotFoundError as exception:
     tabular = MissingExtraMockModule('tabular', exception)
 
 try:
     from fmtr.tools import debugging_tools as debug
-except ImportError as exception:
+except ModuleNotFoundError as exception:
     debug = MissingExtraMockModule('debug', exception)
 
 try:
     from fmtr.tools import settings_tools as sets
-except ImportError as exception:
-    sets = MissingExtraMockModule('sets', exception)
+except ModuleNotFoundError as exception:
+    sets = MissingExtraMockModule('sets', exception)
+
+try:
+    from fmtr.tools import pattern_tools as patterns
+except ModuleNotFoundError as exception:
+    patterns = MissingExtraMockModule('patterns', exception)
+
+try:
+    from fmtr.tools import http_tools as http
+    from fmtr.tools.http_tools import Client
+except ModuleNotFoundError as exception:
+    http = Client = MissingExtraMockModule('http', exception)
+
+try:
+    from fmtr.tools import webhook_tools as webhook
+except ModuleNotFoundError as exception:
+    webhook = MissingExtraMockModule('webhook', exception)
+
+
+def get_version():
+    """
+
+    Defer reading version
+
+    """
+    return version.read()

fmtr/tools/ai_tools/__init__.py

@@ -2,10 +2,10 @@ from fmtr.tools.import_tools import MissingExtraMockModule
 
 try:
     from fmtr.tools.ai_tools import inference_tools as infer
-except ImportError as exception:
+except ModuleNotFoundError as exception:
     infer = MissingExtraMockModule('ai', exception)
 
 try:
     from fmtr.tools.ai_tools import agentic_tools as agentic
-except ImportError as exception:
+except ModuleNotFoundError as exception:
     agentic = MissingExtraMockModule('ai.client', exception)

fmtr/tools/ai_tools/agentic_tools.py

@@ -1,33 +1,57 @@
+from typing import List, Optional, Any, Annotated, Generic
+
 import pydantic_ai
-from pydantic_ai import RunContext
+from pydantic import PlainValidator
+from pydantic_ai import RunContext, ModelRetry
+from pydantic_ai._output import OutputDataT
 from pydantic_ai.agent import AgentRunResult, Agent
-from pydantic_ai.messages import ModelRequest, RetryPromptPart
 from pydantic_ai.models.openai import OpenAIModel
+from pydantic_ai.output import OutputSpec, NativeOutput, ToolOutput
 from pydantic_ai.providers.openai import OpenAIProvider
+from pydantic_ai.tools import AgentDepsT
 
 from fmtr.tools import environment_tools as env
 from fmtr.tools.constants import Constants
+from fmtr.tools.logging_tools import logger
+from fmtr.tools.string_tools import truncate_mid
 
 pydantic_ai.Agent.instrument_all()
 
-class Task:
+
+class Validator:
+    """
+
+    Subclassable validator
+
+    """
+
+    async def validate(self, ctx: RunContext[Any], output: Any) -> List[str]:
+        raise NotImplementedError()
+
+
+api_key = env.get(Constants.FMTR_OPENAI_API_KEY_KEY, None)
+
+class Task(Generic[AgentDepsT, OutputDataT]):
     """
 
     Linear task definition, as Agent configuration and typing, plus state history.
 
     """
 
-    PROVIDER = OpenAIProvider(api_key=env.get(Constants.FMTR_OPENAI_API_KEY_KEY))
+    TypeDeps = str
+    TypeOutput = str
+
+    PROVIDER = OpenAIProvider(api_key=api_key) if api_key else None
 
     API_HOST_FMTR = env.get(Constants.FMTR_AI_HOST_KEY, Constants.FMTR_AI_HOST_DEFAULT)
     API_URL_FMTR = f'https://{API_HOST_FMTR}/v1'
     PROVIDER_FMTR = OpenAIProvider(base_url=API_URL_FMTR)
 
     MODEL_ID = 'gpt-4o'
-    SYSTEM_PROMPT = None
-    DEPS_TYPE = str
-    RESULT_TYPE = str
+    MODEL_ID_FMTR = 'qwen2.5-coder:32b'
+    SYSTEM_PROMPT_STATIC = None
     RESULT_RETRIES = 5
+    VALIDATORS: List[Validator] = []
 
     def __init__(self, *args, **kwargs):
         """
@@ -37,64 +61,159 @@ class Task:
         """
 
         self.model = OpenAIModel(self.MODEL_ID, provider=self.PROVIDER)
-        self.agent = Agent(
+        self.agent = Agent[AgentDepsT, OutputDataT](
             *args,
             model=self.model,
-            system_prompt=self.SYSTEM_PROMPT or [],
-            deps_type=self.DEPS_TYPE,
-            result_type=self.RESULT_TYPE,
-            result_retries=self.RESULT_RETRIES,
+            system_prompt=self.SYSTEM_PROMPT_STATIC or [],
+            deps_type=self.TypeDeps,
+            output_type=self.tool_output,
+            output_retries=self.RESULT_RETRIES,
             **kwargs
         )
 
         self.agent.output_validator(self.validate)
+        self.agent.system_prompt(self.add_system_prompt)
         self.history = []
 
-    async def run(self, *args, **kwargs) -> AgentRunResult[RESULT_TYPE]:
+    @property
+    def tool_output(self) -> OutputSpec[OutputDataT]:
         """
 
-        Run Agent storing history
+        Tool output specification (e.g. ToolOutput/NativeOutput etc.)
 
         """
+        return ToolOutput(self.TypeOutput)
 
-        result = await self.agent.run(*args, message_history=self.history, **kwargs)
-        self.history = result.all_messages()
-        return result
 
-    async def revert(self, msg, deps):
+    @property
+    def sync_runner(self):
         """
 
-        Post-hoc, user-initiated tool retry.
+        Convenience/debug function to run without async.
 
         """
-        msg_final = self.history.pop(-1)
-        tool_return_part = msg_final.parts[0]
+        import asyncio
+        return asyncio.run
 
-        retry_prompt = RetryPromptPart(content=msg, tool_name=tool_return_part.tool_name, tool_call_id=tool_return_part.tool_call_id, timestamp=tool_return_part.timestamp, part_kind='retry-prompt')
-        retry_request = ModelRequest(parts=[retry_prompt], instructions=msg_final.instructions, kind='request')
+    async def run(self, *args, deps=None, **kwargs) -> AgentRunResult[OutputDataT]:
+        """
 
-        self.history.append(retry_request)
+        Run Agent with deps-relative user prompt and while storing history
 
-        result = await Task.run(self, deps=deps)
+        """
+        result = await self.agent.run(*args, user_prompt=self.get_prompt(deps), deps=deps, message_history=self.history, **kwargs)
+        self.history = result.all_messages()
         return result
 
-    async def validate(self, ctx: RunContext[DEPS_TYPE], output: RESULT_TYPE) -> RESULT_TYPE:
+    async def validate(self, ctx: RunContext[AgentDepsT], output: OutputDataT) -> OutputDataT:
         """
 
-        Dummy validator
+        Aggregate any validation failures and combine them into a single ModelRetry exception
 
         """
+        msgs = []
+        for validator in self.VALIDATORS:
+            msgs += validator.validate(ctx, output)
+
+        if msgs:
+            msg = '. '.join(msgs)
+            logger.warning(msg)
+            raise ModelRetry(msg)
+
         return output
 
+    def get_prompt(self, deps: Optional[AgentDepsT]) -> Optional[str]:
+        """
+
+        Dummy prompt generator
 
-class TaskTest(Task):
-    PROVIDER = Task.PROVIDER_FMTR
-    MODEL_ID = 'mixtral:8x7b'
+        """
+        return None
+
+    def add_system_prompt(self, ctx: RunContext[AgentDepsT]) -> str | List[str]:
+        """
+
+        Dummy system prompt append
+
+        """
+
+        return []
+
+    def reset(self):
+        """
+
+        Reset the task by deleting its history.
+
+        """
+        self.history = []
+
+    @property
+    def tool_schema(self):
+        """
+
+        Impossible to find otherwise.
+
+        """
+        return self.agent._output_toolset
+
+    def __repr__(self):
+        """
+
+        String representation of the object
+
+        """
+        return f'{self.__class__.__name__}({repr(truncate_mid(self.SYSTEM_PROMPT_STATIC, 100))})'
+
+
+def default_prompt_none_specified(text):
+    """
+
+    If the prompt is falsey, explicitly state None Specified
+
+    """
+    if not (text or '').strip():
+        return Constants.PROMPT_NONE_SPECIFIED
+    return text
+
+
+StringDefaultNoneSpecified = Annotated[Optional[str], PlainValidator(default_prompt_none_specified)]
 
 
 if __name__ == '__main__':
     import asyncio
+    from fmtr.tools import dm
+
+
+    class TestOutput(dm.Base):
+        text: str
+
+
+    class TestDeps(dm.Base):
+        lang: str
+        subject: str
+
+
+    class TaskTest(Task):
+        PROVIDER = Task.PROVIDER_FMTR
+        MODEL_ID = Task.MODEL_ID_FMTR
+        TypeOutput = TestOutput
+        SYSTEM_PROMPT_STATIC = 'Tell the user jokes.'
+
+        @property
+        def tool_output(self) -> OutputSpec[TestOutput]:
+            return NativeOutput(self.TypeOutput)
+
+        def add_system_prompt(self, ctx: RunContext[TestDeps]) -> str:
+            return f'The jokes must be in the {ctx.deps.lang} language.'
+
+        def get_prompt(self, deps: Optional[TestDeps]) -> str:
+            return f'Tell me one about {deps.subject}.'
 
     task = TaskTest()
-    result = asyncio.run(task.run('Hello! What is your name?'))
-    result
+    deps = TestDeps(lang='English', subject='eggs')
+    result1 = task.sync_runner(task.run(deps=deps))
+    result1
+
+    deps = TestDeps(lang='German', subject='sausages')
+    result2 = task.sync_runner(task.run(deps=deps))
+    result2

fmtr/tools/ai_tools/inference_tools.py

@@ -266,6 +266,7 @@ class BulkInferenceManager:
                 yield ids_output
 
             except RuntimeError as exception:
+                # Instability causes CUBLAS_STATUS in str(exception) too
                 if "CUDA out of memory" in str(exception):
                     logger.warning(f"Ran out of memory. Reducing batch size: {repr(exception)}")
                     batcher.reduce()
@@ -412,5 +413,5 @@ def tst_tool():
 
 
 if __name__ == '__main__':
-    texts = tst_tool()
+    texts = tst()
     texts

fmtr/tools/api_tools.py

@@ -3,7 +3,7 @@ from dataclasses import dataclass
 from fastapi import FastAPI, Request
 from typing import Callable, List, Optional, Union
 
-from fmtr.tools.environment_tools import IS_DEBUG
+from fmtr.tools import environment_tools
 from fmtr.tools.iterator_tools import enlist
 from fmtr.tools.logging_tools import logger
 
@@ -24,7 +24,7 @@ class Endpoint:
         self.tags = enlist(self.tags)
 
 
-class ApiBase:
+class Base:
     """
 
     Simple API base class, generalising endpoint-as-method config.
@@ -33,6 +33,8 @@ class ApiBase:
     TITLE = 'Base API'
     HOST = '0.0.0.0'
     PORT = 8080
+    SWAGGER_PARAMS = dict(tryItOutEnabled=True)
+    URL_DOCS = '/docs'
 
     def add_endpoint(self, endpoint: Endpoint):
         """
@@ -51,12 +53,13 @@ class ApiBase:
         )(endpoint.method)
 
     def __init__(self):
-        self.app = FastAPI(title=self.TITLE)
+        self.app = FastAPI(title=self.TITLE, swagger_ui_parameters=self.SWAGGER_PARAMS, docs_url=self.URL_DOCS)
+        logger.instrument_fastapi(self.app)
 
         for endpoint in self.get_endpoints():
             self.add_endpoint(endpoint)
 
-        if IS_DEBUG:
+        if environment_tools.IS_DEV:
             self.app.exception_handler(Exception)(self.handle_exception)
 
     def get_endpoints(self) -> List[Endpoint]:
@@ -94,4 +97,4 @@ class ApiBase:
 
 
 if __name__ == '__main__':
-    ApiBase.launch()
+    Base.launch()

fmtr/tools/caching_tools.py

@@ -1,6 +1,10 @@
+import cachetools
+from datetime import timedelta, datetime
 from diskcache import Cache
 
-from fmtr.tools import logger, Path
+from fmtr.tools.constants import Constants
+from fmtr.tools.logging_tools import logger
+from fmtr.tools.path_tools.path_tools import Path
 
 
 class Dump(dict):
@@ -31,9 +35,9 @@ class Disk(Cache):
             if not path.parent.exists():
                 raise FileNotFoundError(f"Directory {path.parent=} does not exist")
             if path and not path.exists():
-                logger.warning(f'Cache does not exist. Will be created. "{path=}"...')
+                logger.warning(f'Cache does not exist. Will be created. {str(path)=}...')
 
-            logger.info(f'Initializing Disk Cache at path "{path=}"...')
+            logger.info(f'Initializing Disk Cache {str(path)=}...')
 
         super().__init__(directory=str(path / self.ROOT_KEY), **settings)
 
@@ -95,7 +99,101 @@ class Disk(Cache):
         return self.dump()
 
 
+class TLRU(cachetools.TLRUCache):
+    """
+
+    Subclass to include logging and simplify global TTU
+
+    """
+    MASK_MAPPING = '{key} ' + Constants.ARROW + ' {value}'
+
+    def __init__(self, maxsize=1_024, timer=datetime.now, getsizeof=None, ttu_static=None, desc=None):
+        """
+
+        Add overridable TTU method
+
+        """
+        super().__init__(maxsize=maxsize, ttu=self.get_ttu, timer=timer, getsizeof=getsizeof)
+        self.ttu_static = ttu_static
+        self.desc = desc
+
+    @property
+    def cache_desc(self):
+        """
+
+        Friendly description of cache
+
+        """
+        desc = self.desc or self.__class__.__name__
+        return desc
+
+    def get_ttu(self, _key, value, now) -> float | timedelta:
+        """
+
+        Default implementation just adds on the static TTU
+
+        """
+        return now + self.ttu_static
+
+    def expire(self, time=None):
+        """
+
+        Log expiry
+
+        """
+        items = super().expire(time)
+        if not items:
+            return items
+
+        with logger.span(f'{self.desc} cache expiry {len(items)=}...'):
+            for key, value in items:
+                logger.debug(self.MASK_MAPPING.format(key=key, value=value))
+
+        return items
+
+    def popitem(self):
+        """
+
+        Log eviction
+
+        """
+        key, value = super().popitem()
+        logger.debug(f'{self.desc} cache eviction: {self.MASK_MAPPING.format(key=key, value=value)}')
+        return key, value
+
+    def dump(self):
+        """
+
+        Dump contents
+
+        """
+        data = Dump(self.items())
+        return data
+
+    @property
+    def data(self):
+        """
+
+        Dump as property
+
+        """
+        return self.dump()
+
+
+
 if __name__ == '__main__':
+    sec10 = timedelta(seconds=10)
+    c = TLRU(ttu_static=sec10, maxsize=2, desc='Test Data')
+    c['test'] = 'val'
+    c['test2'] = 'val2'
+    c['test3'] = 'val3'
+    c
+
+
+
+
+
+
     path_tmp_cache = Path.cwd().parent.parent / 'data' / 'cache'
     tc = Disk(path_tmp_cache)