briefcase-python 2.4.1

Python bindings for Briefcase AI
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141

"""
Context manager for lakeFS versioned operations.
"""

from typing import Optional
from contextlib import contextmanager
import logging

try:
    from opentelemetry import trace
    HAS_OTEL = True
except ImportError:
    HAS_OTEL = False

from briefcase.integrations.lakefs.client import VersionedClient

logger = logging.getLogger(__name__)


class VersionedContextManager:
    """
    Context manager for versioned knowledge base access.

    Configuration priority (highest to lowest):
        1. Explicit parameters
        2. briefcase_client.config dict
        3. Environment variables (LAKEFS_ENDPOINT, LAKEFS_ACCESS_KEY, LAKEFS_SECRET_KEY)
        4. Default endpoint

    Usage:
        with versioned_context(client, "acme", "main") as versioned:
            policy = versioned.read_object("policies/policy.pdf")
    """

    def __init__(
        self,
        briefcase_client,
        repository: str,
        branch: str = "main",
        commit: str = "latest",
        lakefs_endpoint: Optional[str] = None,
        lakefs_access_key: Optional[str] = None,
        lakefs_secret_key: Optional[str] = None,
        require_live: bool = False,
    ):
        self.briefcase_client = briefcase_client
        self.repository = repository
        self.branch = branch
        self.commit = commit

        # Get lakeFS credentials from config if not provided
        if hasattr(briefcase_client, 'config'):
            if lakefs_endpoint is None:
                lakefs_endpoint = briefcase_client.config.get("lakefs_endpoint")
            if lakefs_access_key is None:
                lakefs_access_key = briefcase_client.config.get("lakefs_access_key")
            if lakefs_secret_key is None:
                lakefs_secret_key = briefcase_client.config.get("lakefs_secret_key")

        self.lakefs_endpoint = lakefs_endpoint
        self.lakefs_access_key = lakefs_access_key
        self.lakefs_secret_key = lakefs_secret_key
        self.require_live = require_live

        self._lakefs_client = None
        self._span = None
        self._span_token = None

    def __enter__(self):
        """Enter context - create span and lakeFS client."""
        if HAS_OTEL:
            try:
                # Start a span for this versioned context
                tracer = trace.get_tracer(__name__)
                self._span = tracer.start_as_current_span(
                    "lakefs.versioned_context",
                    attributes={
                        "lakefs.repository": self.repository,
                        "lakefs.branch": self.branch,
                        "lakefs.commit.requested": self.commit
                    }
                )
                # Enter the span context
                self._span_token = self._span.__enter__()
            except Exception as e:
                logger.warning(f"Failed to create OTel span: {e}")

        # Create instrumented lakeFS client
        self._lakefs_client = VersionedClient(
            repository=self.repository,
            branch=self.branch,
            commit=self.commit,
            briefcase_client=self.briefcase_client,
            lakefs_endpoint=self.lakefs_endpoint,
            lakefs_access_key=self.lakefs_access_key,
            lakefs_secret_key=self.lakefs_secret_key,
            require_live=self.require_live,
        )

        return self._lakefs_client

    def __exit__(self, exc_type, exc_val, exc_tb):
        """Exit context - end span."""
        if self._span:
            try:
                self._span.__exit__(exc_type, exc_val, exc_tb)
            except Exception as e:
                logger.warning(f"Failed to exit OTel span: {e}")
        return False


@contextmanager
def versioned_context(
    briefcase_client,
    repository: str,
    branch: str = "main",
    commit: str = "latest",
    **kwargs
):
    """
    Convenience function for versioned_context as a context manager.

    Usage:
        with versioned_context(client, "acme", "main") as versioned:
            data = versioned.read_object("file.pdf")
    """
    ctx = VersionedContextManager(
        briefcase_client,
        repository,
        branch,
        commit,
        **kwargs
    )

    with ctx as versioned_client:
        yield versioned_client


# Backwards compatibility aliases
LakeFSContextManager = VersionedContextManager
lakefs_context = versioned_context