fmtr.tools 1.1.1__py3-none-any.whl → 1.4.37__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 aio
+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,193 @@ 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.networking_tools as net
+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 ha_tools as ha
+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)
+
+try:
+    from fmtr.tools import mqtt_tools as mqtt
+except ModuleNotFoundError as exception:
+    mqtt = MissingExtraMockModule('mqtt', exception)
+
+try:
+    from fmtr.tools import av_tools as av
+except ModuleNotFoundError as exception:
+    av = MissingExtraMockModule('av', exception)
+
+try:
+    from fmtr.tools import youtube_tools as youtube
+except ModuleNotFoundError as exception:
+    youtube = MissingExtraMockModule('youtube', 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

@@ -1,12 +1,18 @@
-import uvicorn
+import logging
 from dataclasses import dataclass
-from fastapi import FastAPI, Request
 from typing import Callable, List, Optional, Union
 
-from fmtr.tools.environment_tools import IS_DEBUG
+import uvicorn
+from fastapi import FastAPI, Request
+
+from fmtr.tools import environment_tools
 from fmtr.tools.iterator_tools import enlist
 from fmtr.tools.logging_tools import logger
 
+for name in ["uvicorn.access", "uvicorn.error", "uvicorn"]:
+    logger_uvicorn = logging.getLogger(name)
+    logger_uvicorn.handlers.clear()
+    logger_uvicorn.propagate = False
 
 @dataclass
 class Endpoint:
@@ -24,7 +30,7 @@ class Endpoint:
         self.tags = enlist(self.tags)
 
 
-class ApiBase:
+class Base:
     """
 
     Simple API base class, generalising endpoint-as-method config.
@@ -33,6 +39,9 @@ class ApiBase:
     TITLE = 'Base API'
     HOST = '0.0.0.0'
     PORT = 8080
+    SWAGGER_PARAMS = dict(tryItOutEnabled=True)
+    URL = None
+    URL_DOCS = '/docs'
 
     def add_endpoint(self, endpoint: Endpoint):
         """
@@ -51,12 +60,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]:
@@ -80,18 +90,69 @@ class ApiBase:
         exception
         raise
 
+    @property
+    def url(self) -> str:
+        """
+
+        Default URL unless overridden.
+
+        """
+        if self.URL:
+            url = self.URL
+        else:
+            url = f'http://{self.HOST}:{self.PORT}'
+        return url
+
+    @property
+    def message(self) -> str:
+        """
+
+        Launch message.
+
+        """
+        return f"Launching {self.TITLE} at {self.url}"
+
+    @property
+    def config(self) -> uvicorn.Config:
+        """
+
+        Uvicorn config.
+
+        """
+        return uvicorn.Config(self.app, host=self.HOST, port=self.PORT, access_log=False)
+
+    @property
+    def server(self) -> uvicorn.Server:
+        """"
+
+        Uvicorn server.
+
+        """
+        return uvicorn.Server(self.config)
 
     @classmethod
-    def launch(cls):
+    async def launch_async(cls, *args, **kwargs):
         """
 
-        Initialise self and launch.
+        Initialise and launch.
 
         """
-        self = cls()
-        logger.info(f'Launching API {cls.TITLE}...')
-        uvicorn.run(self.app, host=self.HOST, port=self.PORT)
+
+        self = cls(*args, **kwargs)
+        logger.info(self.message)
+        await self.server.serve()
+
+    @classmethod
+    def launch(cls, *args, **kwargs):
+        """
+
+        Convenience method to launch async from a regular context.
+
+        """
+        import asyncio
+        return asyncio.run(cls.launch_async(*args, **kwargs))
+
 
 
 if __name__ == '__main__':
-    ApiBase.launch()
+    Base.launch()

fmtr/tools/async_tools.py

@@ -1,4 +1,5 @@
 import asyncio
+import inspect
 
 
 def ensure_loop():
@@ -13,3 +14,6 @@ def ensure_loop():
         loop = asyncio.new_event_loop()
         asyncio.set_event_loop(loop)
         return loop
+
+
+is_async = inspect.iscoroutinefunction

fmtr/tools/av_tools.py

@@ -0,0 +1,7 @@
+import av
+
+av = av
+
+open = av.open
+AudioResampler = av.AudioResampler
+AudioFrame = av.AudioFrame