flock-core 0.2.2__tar.gz → 0.2.3__tar.gz

{flock_core-0.2.2 → flock_core-0.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: flock-core
-Version: 0.2.2
+Version: 0.2.3
 Summary: Declarative LLM Orchestration at Scale
 Author-email: Andre Ratzenberger <andre.ratzenberger@whiteduck.de>
 License-File: LICENSE
@@ -15,6 +15,7 @@ Requires-Dist: httpx>=0.28.1
 Requires-Dist: loguru>=0.7.3
 Requires-Dist: msgpack>=1.1.0
 Requires-Dist: opentelemetry-api>=1.30.0
+Requires-Dist: opentelemetry-exporter-jaeger-proto-grpc>=1.21.0
 Requires-Dist: opentelemetry-exporter-jaeger>=1.21.0
 Requires-Dist: opentelemetry-exporter-otlp>=1.30.0
 Requires-Dist: opentelemetry-instrumentation-logging>=0.51b0

{flock_core-0.2.2 → flock_core-0.2.3}/examples/02_cook_book_wip/self_improvement.py

@@ -1,7 +1,11 @@
 """
 Title: Reasoning assistant with self managed memory
 """
+
+from datetime import datetime
 import warnings
+
+from flock.core.tools import basic_tools
 warnings.simplefilter("error", UserWarning)
 import asyncio
 from dataclasses import dataclass, field
@@ -83,12 +87,13 @@ async def main():
 
     chatty = FlockAgent(
         name="chatty", 
-        description="You are Chatty, a friendly assistant that loves to chat.",
+        description=f"You are Chatty, a friendly assistant that loves to chat. Today is {datetime.now().strftime('%A, %B %d, %Y')}",
         input="user_query, memory | Memory of previous interactions, chat_history | the current chat history", 
         output="answer_to_query, important_new_knowledge_to_add_to_memory | Empty string if no knowledge to add",
         initialize_callback=chat_helper.before_response,
         terminate_callback=chat_helper.after_response,
-        config=FlockAgentConfig(disable_output=True,agent_type_override="ChainOfThought")
+        config=FlockAgentConfig(disable_output=True),
+        tools=[basic_tools.web_search_tavily],
     )
     flock.add_agent(chatty)
 

{flock_core-0.2.2 → flock_core-0.2.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "flock-core"
-version = "0.2.2"
+version = "0.2.3"
 description = "Declarative LLM Orchestration at Scale"
 readme = "README.md"
 authors = [
@@ -21,6 +21,7 @@ dependencies = [
     "msgpack>=1.1.0",
     "opentelemetry-api>=1.30.0",
     "opentelemetry-exporter-jaeger>=1.21.0",
+    "opentelemetry-exporter-jaeger-proto-grpc>=1.21.0",
     "opentelemetry-exporter-otlp>=1.30.0",
     "opentelemetry-instrumentation-logging>=0.51b0",
     "opentelemetry-sdk>=1.30.0",

flock_core-0.2.3/src/flock/__init__.py

@@ -0,0 +1,5 @@
+"""Flock package initialization."""
+
+from flock.config import TELEMETRY
+
+tracer = TELEMETRY.setup_tracing()

flock_core-0.2.3/src/flock/config.py

@@ -0,0 +1,29 @@
+# flock/config.py
+import os
+
+from flock.core.logging.telemetry import TelemetryConfig
+
+# -- Connection and External Service Configurations --
+TEMPORAL_SERVER_URL = os.getenv("TEMPORAL_SERVER_URL", "localhost:7233")
+DEFAULT_MODEL = os.getenv("DEFAULT_MODEL", "openai/gpt-4o")
+
+# API Keys and related settings
+TAVILY_API_KEY = os.getenv("TAVILY_API_KEY", "")
+GITHUB_PAT = os.getenv("GITHUB_PAT", "")
+GITHUB_REPO = os.getenv("GITHUB_REPO", "")
+GITHUB_USERNAME = os.getenv("GITHUB_USERNAME", "")
+
+# -- Debugging and Logging Configurations --
+LOCAL_DEBUG = os.getenv("LOCAL_DEBUG", "0") == "1"
+LOG_LEVEL = os.getenv("LOG_LEVEL", "DEBUG")
+
+OTL_SERVICE_NAME = os.getenv("OTL_SERVICE_NAME", "otel-flock")
+JAEGER_ENDPOINT = os.getenv(
+    "JAEGER_ENDPOINT", "http://localhost:14268/api/traces"
+)  # Default gRPC endpoint for Jaeger
+JAEGER_TRANSPORT = os.getenv(
+    "JAEGER_TRANSPORT", "http"
+).lower()  # Options: "grpc" or "http"
+
+
+TELEMETRY = TelemetryConfig(OTL_SERVICE_NAME, JAEGER_ENDPOINT, JAEGER_TRANSPORT)

flock_core-0.2.3/src/flock/core/__init__.py

@@ -0,0 +1,6 @@
+"""This module contains the core classes of the flock package."""
+
+from flock.core.flock import Flock
+from flock.core.flock_agent import FlockAgent
+
+__all__ = ["Flock", "FlockAgent"]

{flock_core-0.2.2 → flock_core-0.2.3}/src/flock/core/flock.py

@@ -15,14 +15,13 @@ from flock.core.flock_agent import FlockAgent
 from flock.core.logging.formatters.base_formatter import FormatterOptions
 from flock.core.logging.formatters.pprint_formatter import PrettyPrintFormatter
 from flock.core.logging.logging import get_logger
-from flock.core.logging.telemetry import setup_tracing
 from flock.core.registry.agent_registry import Registry
 from flock.core.util.cli_helper import display_banner
 from flock.core.util.input_resolver import top_level_to_keys
 
 T = TypeVar("T", bound=FlockAgent)
 logger = get_logger("flock")
-tracer = setup_tracing()
+
 tracer = trace.get_tracer(__name__)
 
 

flock_core-0.2.3/src/flock/core/logging/telemetry.py

@@ -0,0 +1,109 @@
+"""This module sets up OpenTelemetry tracing for a service."""
+
+from opentelemetry import trace
+from opentelemetry.sdk.resources import Resource
+from opentelemetry.sdk.trace import TracerProvider
+from opentelemetry.sdk.trace.export import (
+    BatchSpanProcessor,
+)
+
+from flock.core.logging.telemetry_exporter.file_span import FileSpanExporter
+from flock.core.logging.telemetry_exporter.sqllite_span import (
+    SQLiteSpanExporter,
+)
+
+
+class TelemetryConfig:
+    """This configuration class sets up OpenTelemetry tracing.
+
+      - Export spans to a Jaeger collector using gRPC.
+      - Write spans to a file.
+      - Save spans in a SQLite database.
+
+    Only exporters with a non-None configuration will be activated.
+    """
+
+    def __init__(
+        self,
+        service_name: str,
+        jaeger_endpoint: str = None,
+        jaeger_transport: str = "grpc",
+        file_export_path: str = None,
+        sqlite_db_path: str = None,
+        batch_processor_options: dict = None,
+    ):
+        """:param service_name: Name of your service.
+
+        :param jaeger_endpoint: The Jaeger collector gRPC endpoint (e.g., "localhost:14250").
+        :param file_export_path: If provided, spans will be written to this file.
+        :param sqlite_db_path: If provided, spans will be stored in this SQLite DB.
+        :param batch_processor_options: Dict of options for BatchSpanProcessor (e.g., {"max_export_batch_size": 10}).
+        """
+        self.service_name = service_name
+        self.jaeger_endpoint = jaeger_endpoint
+        self.jaeger_transport = jaeger_transport
+        self.file_export_path = file_export_path
+        self.sqlite_db_path = sqlite_db_path
+        self.batch_processor_options = batch_processor_options or {}
+
+    def setup_tracing(self):
+        # Create a Resource with the service name.
+        resource = Resource(attributes={"service.name": self.service_name})
+        provider = TracerProvider(resource=resource)
+        trace.set_tracer_provider(provider)
+
+        # List to collect our span processors.
+        span_processors = []
+
+        # If a Jaeger endpoint is specified, add the Jaeger gRPC exporter.
+        if self.jaeger_endpoint:
+            if self.jaeger_transport == "grpc":
+                from opentelemetry.exporter.jaeger.proto.grpc import (
+                    JaegerExporter,
+                )
+
+                jaeger_exporter = JaegerExporter(
+                    endpoint=self.jaeger_endpoint,
+                    insecure=True,
+                )
+            elif self.jaeger_transport == "http":
+                from opentelemetry.exporter.jaeger.thrift import JaegerExporter
+
+                jaeger_exporter = JaegerExporter(
+                    collector_endpoint=self.jaeger_endpoint,
+                )
+            else:
+                raise ValueError(
+                    "Invalid JAEGER_TRANSPORT specified. Use 'grpc' or 'http'."
+                )
+
+            span_processors.append(
+                BatchSpanProcessor(
+                    jaeger_exporter, **self.batch_processor_options
+                )
+            )
+
+        # If a file path is provided, add the custom file exporter.
+        if self.file_export_path:
+            file_exporter = FileSpanExporter(self.file_export_path)
+            span_processors.append(
+                BatchSpanProcessor(
+                    file_exporter, **self.batch_processor_options
+                )
+            )
+
+        # If a SQLite database path is provided, add the custom SQLite exporter.
+        if self.sqlite_db_path:
+            sqlite_exporter = SQLiteSpanExporter(self.sqlite_db_path)
+            span_processors.append(
+                BatchSpanProcessor(
+                    sqlite_exporter, **self.batch_processor_options
+                )
+            )
+
+        # Register all span processors with the provider.
+        for processor in span_processors:
+            provider.add_span_processor(processor)
+
+        # Return a tracer instance.
+        return trace.get_tracer(__name__)

flock_core-0.2.3/src/flock/core/logging/telemetry_exporter/file_span.py

@@ -0,0 +1,37 @@
+import json
+
+from opentelemetry.sdk.trace.export import (
+    SpanExporter,
+    SpanExportResult,
+)
+
+
+class FileSpanExporter(SpanExporter):
+    """A simple exporter that writes span data as JSON lines into a file."""
+
+    def __init__(self, file_path: str):
+        self.file_path = file_path
+
+    def export(self, spans) -> SpanExportResult:
+        try:
+            with open(self.file_path, "a") as f:
+                for span in spans:
+                    # Create a dictionary representation of the span.
+                    span_dict = {
+                        "name": span.name,
+                        "trace_id": format(span.context.trace_id, "032x"),
+                        "span_id": format(span.context.span_id, "016x"),
+                        "start_time": span.start_time,
+                        "end_time": span.end_time,
+                        "attributes": span.attributes,
+                        "status": str(span.status),
+                    }
+                    f.write(json.dumps(span_dict) + "\n")
+            return SpanExportResult.SUCCESS
+        except Exception as e:
+            print("Error exporting spans to file:", e)
+            return SpanExportResult.FAILURE
+
+    def shutdown(self) -> None:
+        # Nothing special needed on shutdown.
+        pass

flock_core-0.2.3/src/flock/core/logging/telemetry_exporter/sqllite_span.py

@@ -0,0 +1,68 @@
+import json
+import sqlite3
+
+from opentelemetry.sdk.trace.export import (
+    SpanExporter,
+    SpanExportResult,
+)
+
+
+class SQLiteSpanExporter(SpanExporter):
+    """A custom exporter that writes span data into a SQLite database."""
+
+    def __init__(self, sqlite_db_path: str):
+        self.sqlite_db_path = sqlite_db_path
+        self.conn = sqlite3.connect(
+            self.sqlite_db_path, check_same_thread=False
+        )
+        self._create_table()
+
+    def _create_table(self):
+        cursor = self.conn.cursor()
+        cursor.execute(
+            """
+            CREATE TABLE IF NOT EXISTS spans (
+                id TEXT PRIMARY KEY,
+                name TEXT,
+                trace_id TEXT,
+                span_id TEXT,
+                start_time INTEGER,
+                end_time INTEGER,
+                attributes TEXT,
+                status TEXT
+            )
+            """
+        )
+        self.conn.commit()
+
+    def export(self, spans) -> SpanExportResult:
+        try:
+            cursor = self.conn.cursor()
+            for span in spans:
+                span_id = format(span.context.span_id, "016x")
+                trace_id = format(span.context.trace_id, "032x")
+                cursor.execute(
+                    """
+                    INSERT OR REPLACE INTO spans 
+                    (id, name, trace_id, span_id, start_time, end_time, attributes, status)
+                    VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+                    """,
+                    (
+                        span_id,
+                        span.name,
+                        trace_id,
+                        span_id,
+                        span.start_time,
+                        span.end_time,
+                        json.dumps(span.attributes),
+                        str(span.status),
+                    ),
+                )
+            self.conn.commit()
+            return SpanExportResult.SUCCESS
+        except Exception as e:
+            print("Error exporting spans to SQLite:", e)
+            return SpanExportResult.FAILURE
+
+    def shutdown(self) -> None:
+        self.conn.close()

{flock_core-0.2.2 → flock_core-0.2.3}/src/flock/workflow/activities.py

@@ -96,7 +96,7 @@ async def run_agent(
                     context.record(
                         agent.name,
                         result,
-                        timestamp=datetime.now(),
+                        timestamp=datetime.now().isoformat(),
                         hand_off=None,
                         called_from=previous_agent_name,
                     )

{flock_core-0.2.2 → flock_core-0.2.3}/uv.lock

@@ -940,7 +940,7 @@ wheels = [
 
 [[package]]
 name = "flock-core"
-version = "0.2.2"
+version = "0.2.3"
 source = { editable = "." }
 dependencies = [
     { name = "cloudpickle" },
@@ -951,6 +951,7 @@ dependencies = [
     { name = "msgpack" },
     { name = "opentelemetry-api" },
     { name = "opentelemetry-exporter-jaeger" },
+    { name = "opentelemetry-exporter-jaeger-proto-grpc" },
     { name = "opentelemetry-exporter-otlp" },
     { name = "opentelemetry-instrumentation-logging" },
     { name = "opentelemetry-sdk" },
@@ -1012,6 +1013,7 @@ requires-dist = [
     { name = "msgpack", specifier = ">=1.1.0" },
     { name = "opentelemetry-api", specifier = ">=1.30.0" },
     { name = "opentelemetry-exporter-jaeger", specifier = ">=1.21.0" },
+    { name = "opentelemetry-exporter-jaeger-proto-grpc", specifier = ">=1.21.0" },
     { name = "opentelemetry-exporter-otlp", specifier = ">=1.30.0" },
     { name = "opentelemetry-instrumentation-logging", specifier = ">=0.51b0" },
     { name = "opentelemetry-sdk", specifier = ">=1.30.0" },

flock_core-0.2.2/src/flock/__init__.py

@@ -1 +0,0 @@
-"""Flock package initialization."""

flock_core-0.2.2/src/flock/core/__init__.py

@@ -1 +0,0 @@
-

flock_core-0.2.2/src/flock/core/logging/telemetry.py

@@ -1,21 +0,0 @@
-from opentelemetry import trace
-from opentelemetry.exporter.jaeger.thrift import JaegerExporter
-from opentelemetry.sdk.resources import Resource
-from opentelemetry.sdk.trace import TracerProvider
-from opentelemetry.sdk.trace.export import BatchSpanProcessor
-
-
-def setup_tracing():
-    resource = Resource(attributes={"service.name": "flock-agent-framework"})
-    provider = TracerProvider(resource=resource)
-    trace.set_tracer_provider(provider)
-
-    # Create a Jaeger exporter
-    jaeger_exporter = JaegerExporter(
-        agent_host_name="localhost",  # or the hostname where Jaeger is running
-        agent_port=6831,  # default Jaeger agent port
-    )
-
-    provider.add_span_processor(BatchSpanProcessor(jaeger_exporter))
-    tracer = trace.get_tracer(__name__)
-    return tracer