microsoft-teams-common 0.0.1a1__tar.gz

microsoft_teams_common-0.0.1a1/.gitignore

@@ -0,0 +1,34 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.egg-info/
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+.copilot-instructions.md
+
+# other
+.DS_STORE
+*.bak
+*~
+*.tmp
+
+ref/
+py.typed
+CLAUDE.md
+
+.env.claude/
+.claude/

microsoft_teams_common-0.0.1a1/PKG-INFO

@@ -0,0 +1,22 @@
+Metadata-Version: 2.4
+Name: microsoft-teams-common
+Version: 0.0.1a1
+Summary: Common package for Microsoft Teams
+Project-URL: Homepage, https://github.com/microsoft/teams.py/tree/main/packages/common/src/microsoft/teams/common
+Author-email: Microsoft <TeamsAISDKFeedback@microsoft.com>
+License-Expression: MIT
+Keywords: agents,ai,bot,microsoft,teams
+Requires-Python: >=3.12
+Requires-Dist: coverage>=7.8.0
+Requires-Dist: httpx>=0.28.1
+Requires-Dist: pytest>=8.3.5
+Requires-Dist: ruff>=0.11.5
+Description-Content-Type: text/markdown
+
+> [!CAUTION]
+> This project is in active development and not ready for production use. It has not been publicly announced yet.
+
+# Microsoft Teams Common Utilities
+
+Shared utilities including HTTP client, logging, storage, and event handling.
+Provides common functionality used across other Teams SDK packages.

microsoft_teams_common-0.0.1a1/README.md

@@ -0,0 +1,7 @@
+> [!CAUTION]
+> This project is in active development and not ready for production use. It has not been publicly announced yet.
+
+# Microsoft Teams Common Utilities
+
+Shared utilities including HTTP client, logging, storage, and event handling.
+Provides common functionality used across other Teams SDK packages.

microsoft_teams_common-0.0.1a1/pyproject.toml

@@ -0,0 +1,38 @@
+[project]
+name = "microsoft-teams-common"
+version = "0.0.1-alpha.1"
+description = "Common package for Microsoft Teams"
+readme = "README.md"
+repository = "https://github.com/microsoft/teams.py"
+keywords = ["microsoft", "teams", "ai", "bot", "agents"] 
+license = "MIT"
+authors = [
+    { name = "Microsoft", email = "TeamsAISDKFeedback@microsoft.com" }
+]
+requires-python = ">=3.12"
+dependencies = [
+    "coverage>=7.8.0",
+    "httpx>=0.28.1",
+    "pytest>=8.3.5",
+    "ruff>=0.11.5",
+]
+
+[dependency-groups]
+dev = [
+    "pytest>=8.4.0",
+    "pytest-asyncio>=1.0.0",
+]
+
+[project.urls]
+Homepage = "https://github.com/microsoft/teams.py/tree/main/packages/common/src/microsoft/teams/common"
+
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/microsoft"]
+
+[tool.hatch.build.targets.sdist]
+include = ["src"]

microsoft_teams_common-0.0.1a1/src/microsoft/teams/common/__init__.py

@@ -0,0 +1,17 @@
+"""
+Copyright (c) Microsoft Corporation. All rights reserved.
+Licensed under the MIT License.
+"""
+
+from . import events, http, logging, storage  # noqa: E402
+from .events import *  # noqa: F401, F402, F403
+from .http import *  # noqa: F401, F402, F403
+from .logging import *  # noqa: F401, F402, F403
+from .storage import *  # noqa: F401, F402, F403
+
+# Combine all exports from submodules
+__all__: list[str] = []
+__all__.extend(events.__all__)
+__all__.extend(http.__all__)
+__all__.extend(logging.__all__)
+__all__.extend(storage.__all__)

microsoft_teams_common-0.0.1a1/src/microsoft/teams/common/events/__init__.py

@@ -0,0 +1,8 @@
+"""
+Copyright (c) Microsoft Corporation. All rights reserved.
+Licensed under the MIT License.
+"""
+
+from .event_emitter import EventEmitter, EventEmitterOptions, EventEmitterProtocol, EventHandler
+
+__all__ = ["EventEmitter", "EventEmitterOptions", "EventHandler", "EventEmitterProtocol"]

microsoft_teams_common-0.0.1a1/src/microsoft/teams/common/events/event_emitter.py

@@ -0,0 +1,227 @@
+"""
+Copyright (c) Microsoft Corporation. All rights reserved.
+Licensed under the MIT License.
+"""
+
+import asyncio
+import logging
+from typing import Any, Awaitable, Callable, Dict, Generic, List, Optional, Protocol, TypedDict, TypeVar, Union
+
+from ..logging import ConsoleLogger
+
+EventTypeT = TypeVar("EventTypeT", bound=str, contravariant=True)
+
+EventHandler = Union[
+    Callable[[Any], None],  # Sync handler
+    Callable[[Any], Awaitable[Any]],  # Async handler
+]
+
+
+class Subscription(TypedDict):
+    """A subscription entry for an event handler."""
+
+    id: int
+    handler: EventHandler
+
+
+class EventEmitterProtocol(Protocol, Generic[EventTypeT]):
+    """Interface for event emitter functionality."""
+
+    def on(self, event: EventTypeT, handler: EventHandler) -> int:
+        """Register an event handler. Returns subscription ID."""
+        ...
+
+    def once(self, event: EventTypeT, handler: EventHandler) -> int:
+        """Register a one-time event handler. Returns subscription ID."""
+        ...
+
+    def off(self, subscription_id: int) -> None:
+        """Remove an event handler by subscription ID."""
+
+    def emit(self, event: EventTypeT, value: Any = None) -> None:
+        """Emit an event synchronously."""
+
+
+class EventEmitterOptions(TypedDict, total=False):
+    """
+    Options for EventEmitter configuration.
+
+    :param logger: Custom logger instance to use for logging events
+    """
+
+    logger: logging.Logger
+
+
+class EventEmitter(EventEmitterProtocol[EventTypeT]):
+    """
+    Event emitter implementation inspired by TypeScript/Node.js EventEmitter.
+
+    Provides both synchronous and asynchronous event emission capabilities.
+    Thread-safe for single-threaded use cases.
+    """
+
+    def __init__(self, options: Optional[EventEmitterOptions] = None) -> None:
+        self._index = -1
+        self._subscriptions: Dict[str, List[Subscription]] = {}
+
+        # Use provided logger or create default console logger
+        logger = options.get("logger") if options else None
+        if logger:
+            self._logger = logger.getChild("microsoft.teams.common.events.EventEmitter")
+        else:
+            self._logger = ConsoleLogger().create_logger("microsoft.teams.common.events.EventEmitter")
+
+    def on(self, event: EventTypeT, handler: EventHandler) -> int:
+        """
+        Register an event handler.
+
+        Args:
+            event: Event name to listen for
+            handler: Function to call when event is emitted
+
+        Returns:
+            Subscription ID for removing the handler later
+        """
+        subscription_id = self._get_next_id()
+
+        if event not in self._subscriptions:
+            self._subscriptions[event] = []
+
+        self._subscriptions[event].append({"id": subscription_id, "handler": handler})
+
+        self._logger.debug("Registered handler for event '%s' with id %d", event, subscription_id)
+        return subscription_id
+
+    def once(self, event: EventTypeT, handler: EventHandler) -> int:
+        """
+        Register a one-time event handler that will be removed after first execution.
+
+        Args:
+            event: Event name to listen for
+            handler: Function to call when event is emitted
+
+        Returns:
+            Subscription ID for removing the handler later
+        """
+
+        def once_wrapper(value: Any) -> None:
+            self.off(subscription_id)
+            handler(value)
+
+        subscription_id = self._get_next_id()
+
+        if event not in self._subscriptions:
+            self._subscriptions[event] = []
+
+        self._subscriptions[event].append({"id": subscription_id, "handler": once_wrapper})
+
+        self._logger.debug("Registered one-time handler for event '%s' with id %d", event, subscription_id)
+        return subscription_id
+
+    def off(self, subscription_id: int) -> None:
+        """
+        Remove an event handler by subscription ID.
+
+        Args:
+            subscription_id: ID returned from on() or once()
+        """
+        for event_name, subscriptions in list(self._subscriptions.items()):
+            for i, subscription in enumerate(subscriptions):
+                if subscription["id"] == subscription_id:
+                    subscriptions.pop(i)
+                    self._logger.debug("Removed handler with id %d from event '%s'", subscription_id, event_name)
+                    if not subscriptions:
+                        del self._subscriptions[event_name]
+                    return
+
+    def emit(self, event: EventTypeT, value: Any = None) -> None:
+        """
+        Emit an event synchronously to all registered handlers.
+
+        Async handlers are run using asyncio.run() in a separate event loop.
+
+        Args:
+            event: Event name to emit
+            value: Data to pass to event handlers
+        """
+        if event not in self._subscriptions:
+            return
+
+        handler_count = len(self._subscriptions[event])
+        self._logger.debug("Emitting event '%s' to %d handler(s)", event, handler_count)
+
+        awaitables: list[Awaitable[None]] = []
+
+        for subscription in self._subscriptions[event][:]:  # Copy to avoid modification during iteration
+            try:
+                handler = subscription["handler"]
+
+                if asyncio.iscoroutinefunction(handler):
+                    awaitables.append(handler(value))
+                else:
+                    handler(value)
+            except Exception as e:
+                # Continue executing other handlers even if one fails
+                self._logger.error("Handler failed for event '%s': %s", event, e)
+
+        # Handle awaitables if any exist
+        if awaitables:
+            self._logger.debug("Running %d async handler(s) for event '%s'", len(awaitables), event)
+
+            async def run_async_handlers() -> None:
+                results = await asyncio.gather(*awaitables, return_exceptions=True)
+                for i, result in enumerate(results):
+                    if isinstance(result, Exception):
+                        self._logger.error("Async handler %d failed for event '%s': %s", i, event, result)
+
+            try:
+                # Try to get the current event loop
+                loop = asyncio.get_running_loop()
+                # If loop is running, schedule the async handlers as tasks
+                loop.create_task(run_async_handlers())
+                # Note: tasks run in background, emit() doesn't wait for completion
+            except RuntimeError:
+                # No event loop running, create one
+                asyncio.run(run_async_handlers())
+
+    def listener_count(self, event: str) -> int:
+        """
+        Get the number of listeners for an event.
+
+        Args:
+            event: Event name
+
+        Returns:
+            Number of registered listeners
+        """
+        return len(self._subscriptions.get(event, []))
+
+    def event_names(self) -> List[str]:
+        """
+        Get list of event names that have listeners.
+
+        Returns:
+            List of event names
+        """
+        return list(self._subscriptions.keys())
+
+    def remove_all_listeners(self, event: Optional[str] = None) -> None:
+        """
+        Remove all listeners for a specific event or all events.
+
+        Args:
+            event: Event name to clear. If None, clears all events.
+        """
+        if event is None:
+            total_handlers = sum(len(handlers) for handlers in self._subscriptions.values())
+            self._subscriptions.clear()
+            self._logger.debug("Removed all %d handler(s) from all events", total_handlers)
+        elif event in self._subscriptions:
+            handler_count = len(self._subscriptions[event])
+            del self._subscriptions[event]
+            self._logger.debug("Removed all %d handler(s) from event '%s'", handler_count, event)
+
+    def _get_next_id(self) -> int:
+        """Get next unique subscription ID."""
+        self._index += 1
+        return self._index

microsoft_teams_common-0.0.1a1/src/microsoft/teams/common/http/__init__.py

@@ -0,0 +1,19 @@
+"""
+Copyright (c) Microsoft Corporation. All rights reserved.
+Licensed under the MIT License.
+"""
+
+from .client import Client, ClientOptions
+from .client_token import Token, TokenFactory, resolve_token
+from .interceptor import Interceptor, InterceptorRequestContext, InterceptorResponseContext
+
+__all__ = [
+    "Client",
+    "ClientOptions",
+    "Interceptor",
+    "InterceptorRequestContext",
+    "InterceptorResponseContext",
+    "Token",
+    "TokenFactory",
+    "resolve_token",
+]

microsoft_teams_common-0.0.1a1/src/microsoft/teams/common/http/client.py

@@ -0,0 +1,438 @@
+"""
+Copyright (c) Microsoft Corporation. All rights reserved.
+Licensed under the MIT License.
+"""
+
+import inspect
+import json
+import logging
+from dataclasses import dataclass, field
+from typing import Any, Awaitable, Callable, Dict, List, Optional
+
+import httpx
+from httpx._models import Request, Response
+from httpx._types import QueryParamTypes, RequestContent, RequestData, RequestFiles
+
+from ..logging import ConsoleLogger
+from .client_token import Token, resolve_token
+from .interceptor import Interceptor, InterceptorRequestContext, InterceptorResponseContext
+
+console_logger = ConsoleLogger()
+
+
+def _wrap_response_json(response: httpx.Response, logger: logging.Logger) -> None:
+    """
+    Wrap the response.json method to handle JSONDecodeError gracefully.
+
+    Args:
+        response: The httpx.Response object to wrap.
+        logger: Logger instance for warning messages.
+    """
+    original_json = response.json
+
+    def safe_json(**kwargs: Any) -> Any:
+        try:
+            return original_json(**kwargs)
+        except json.JSONDecodeError as e:
+            if e.pos == 0:
+                logger.warning(f"Failed to decode JSON response from {response.url}. Returning empty dict.")
+                return {}
+            else:
+                raise
+
+    response.json = safe_json
+
+
+@dataclass(frozen=True)
+class ClientOptions:
+    """
+    Configuration options for the HTTP Client.
+
+    Attributes:
+        base_url: The base URL for all requests.
+        headers: Default headers to include with every request.
+        timeout: Default request timeout in seconds.
+        logger: Logger instance for request/response/error logging.
+        token: Default authorization token (string, string-like, or callable).
+        interceptors: List of interceptors for request/response middleware.
+    """
+
+    base_url: Optional[str] = None
+    headers: Dict[str, str] = field(default_factory=dict[str, str])
+    timeout: Optional[float] = None
+    logger: Optional[logging.Logger] = None
+    token: Optional[Token] = None
+    interceptors: Optional[List[Interceptor]] = field(default_factory=list[Interceptor])
+
+
+class Client:
+    """
+    HTTP Client abstraction for making requests with configurable options.
+
+    Args:
+        options: ClientOptions dataclass with configuration for the client.
+    """
+
+    def __init__(self, options: Optional[ClientOptions] = None):
+        """
+        Initialize the HTTP Client.
+
+        Args:
+            options: Optional ClientOptions dataclass with configuration for the client.
+        """
+        if options is None:
+            options = ClientOptions()
+
+        self._options = options
+        self._logger = options.logger or console_logger.create_logger("http-client")
+        self._token = options.token
+
+        # Configure httpx logging to match our logger's level
+        httpx_logger = logging.getLogger("httpx")
+        httpx_logger.setLevel(self._logger.level)
+
+        # Maintain interceptors as a separate instance attribute (do not mutate options)
+        self._interceptors = list(options.interceptors or [])
+
+        self.http = httpx.AsyncClient(
+            base_url=httpx.URL(options.base_url) if options.base_url else "",
+            headers=options.headers,
+            timeout=options.timeout,
+        )
+        self._update_event_hooks()
+
+    async def _prepare_headers(self, headers: Optional[Dict[str, str]], token: Optional[Token]) -> Dict[str, str]:
+        """
+        Merge default and per-request headers, resolve token, and inject Authorization header if needed.
+
+        Args:
+            headers: Optional per-request headers.
+            token: Optional per-request token.
+
+        Returns:
+            Final headers dict for the request.
+        """
+        req_headers = {**self._options.headers, **(headers or {})}
+        resolved_token = await self._resolve_token(token)
+        if resolved_token:
+            req_headers["Authorization"] = f"Bearer {resolved_token}"
+        return req_headers
+
+    async def get(
+        self,
+        url: str,
+        *,
+        headers: Optional[Dict[str, str]] = None,
+        token: Optional[Token] = None,
+        params: Optional[QueryParamTypes] = None,
+        **kwargs: Any,
+    ) -> httpx.Response:
+        """
+        Send a GET request.
+
+        Args:
+            url: The URL path or full URL.
+            headers: Optional per-request headers.
+            params: Optional query parameters.
+            token: Optional per-request token (overrides default).
+            **kwargs: Additional httpx.AsyncClient.get arguments.
+
+        Returns:
+            httpx.Response
+        """
+        req_headers = await self._prepare_headers(headers, token)
+        response = await self.http.get(url, headers=req_headers, params=params, **kwargs)
+        response.raise_for_status()
+        _wrap_response_json(response, self._logger)
+        return response
+
+    async def post(
+        self,
+        url: str,
+        *,
+        content: Optional[RequestContent] = None,
+        data: Optional[RequestData] = None,
+        files: Optional[RequestFiles] = None,
+        json: Optional[Any] = None,
+        params: Optional[QueryParamTypes] = None,
+        headers: Optional[Dict[str, str]] = None,
+        token: Optional[Token] = None,
+        **kwargs: Any,
+    ) -> httpx.Response:
+        """
+        Send a POST request.
+
+        Args:
+            url: The URL path or full URL.
+            data: The request body.
+            headers: Optional per-request headers.
+            params: Optional query parameters.
+            content: The request body.
+            files: The request files.
+            json: The request JSON body.
+            token: Optional per-request token (overrides default).
+            **kwargs: Additional httpx.AsyncClient.post arguments.
+
+        Returns:
+            httpx.Response
+        """
+        req_headers = await self._prepare_headers(headers, token)
+        response = await self.http.post(
+            url,
+            data=data,
+            files=files,
+            json=json,
+            content=content,
+            params=params,
+            headers=req_headers,
+            **kwargs,
+        )
+        response.raise_for_status()
+        _wrap_response_json(response, self._logger)
+        return response
+
+    async def put(
+        self,
+        url: str,
+        *,
+        content: Optional[RequestContent] = None,
+        data: Optional[RequestData] = None,
+        files: Optional[RequestFiles] = None,
+        json: Optional[Any] = None,
+        params: Optional[QueryParamTypes] = None,
+        headers: Optional[Dict[str, str]] = None,
+        token: Optional[Token] = None,
+        **kwargs: Any,
+    ) -> httpx.Response:
+        """
+        Send a PUT request.
+
+        Args:
+            url: The URL path or full URL.
+            data: The request body.
+            headers: Optional per-request headers.
+            params: Optional query parameters.
+            content: The request body.
+            files: The request files.
+            json: The request JSON body.
+            token: Optional per-request token (overrides default).
+            **kwargs: Additional httpx.AsyncClient.put arguments.
+
+        Returns:
+            httpx.Response
+        """
+        req_headers = await self._prepare_headers(headers, token)
+        response = await self.http.put(
+            url,
+            data=data,
+            files=files,
+            json=json,
+            content=content,
+            params=params,
+            headers=req_headers,
+            **kwargs,
+        )
+        response.raise_for_status()
+        _wrap_response_json(response, self._logger)
+        return response
+
+    async def patch(
+        self,
+        url: str,
+        *,
+        content: Optional[RequestContent] = None,
+        data: Optional[RequestData] = None,
+        files: Optional[RequestFiles] = None,
+        json: Optional[Any] = None,
+        params: Optional[QueryParamTypes] = None,
+        headers: Optional[Dict[str, str]] = None,
+        token: Optional[Token] = None,
+        **kwargs: Any,
+    ) -> httpx.Response:
+        """
+        Send a PATCH request.
+
+        Args:
+            url: The URL path or full URL.
+            data: The request body.
+            headers: Optional per-request headers.
+            params: Optional query parameters.
+            content: The request body.
+            files: The request files.
+            json: The request JSON body.
+            token: Optional per-request token (overrides default).
+            **kwargs: Additional httpx.AsyncClient.patch arguments.
+
+        Returns:
+            httpx.Response
+        """
+        req_headers = await self._prepare_headers(headers, token)
+        response = await self.http.patch(
+            url,
+            data=data,
+            files=files,
+            json=json,
+            content=content,
+            params=params,
+            headers=req_headers,
+            **kwargs,
+        )
+        response.raise_for_status()
+        _wrap_response_json(response, self._logger)
+        return response
+
+    async def delete(
+        self,
+        url: str,
+        *,
+        headers: Optional[Dict[str, str]] = None,
+        token: Optional[Token] = None,
+        params: Optional[QueryParamTypes] = None,
+        **kwargs: Any,
+    ) -> httpx.Response:
+        """
+        Send a DELETE request.
+
+        Args:
+            url: The URL path or full URL.
+            headers: Optional per-request headers.
+            params: Optional query parameters.
+            token: Optional per-request token (overrides default).
+            **kwargs: Additional httpx.AsyncClient.delete arguments.
+
+        Returns:
+            httpx.Response
+        """
+        req_headers = await self._prepare_headers(headers, token)
+        response = await self.http.delete(url, headers=req_headers, params=params, **kwargs)
+        response.raise_for_status()
+        _wrap_response_json(response, self._logger)
+        return response
+
+    async def request(
+        self,
+        method: str,
+        url: str,
+        *,
+        params: Optional[QueryParamTypes] = None,
+        headers: Optional[Dict[str, str]] = None,
+        token: Optional[Token] = None,
+        content: Optional[RequestContent] = None,
+        data: Optional[RequestData] = None,
+        files: Optional[RequestFiles] = None,
+        json: Optional[Any] = None,
+        **kwargs: Any,
+    ) -> httpx.Response:
+        """
+        Send a custom HTTP request.
+
+        Args:
+            method: HTTP method (GET, POST, etc).
+            url: The URL path or full URL.
+            headers: Optional per-request headers.
+            params: Optional query parameters.
+            content: The request body.
+            data: The request body.
+            files: The request files.
+            json: The request JSON body.
+            token: Optional per-request token (overrides default).
+            **kwargs: Additional httpx.AsyncClient.request arguments.
+
+        Returns:
+            httpx.Response
+        """
+        req_headers = await self._prepare_headers(headers, token)
+        response = await self.http.request(
+            method,
+            url,
+            headers=req_headers,
+            params=params,
+            content=content,
+            data=data,
+            files=files,
+            json=json,
+            **kwargs,
+        )
+        response.raise_for_status()
+        _wrap_response_json(response, self._logger)
+        return response
+
+    async def _resolve_token(self, token: Optional[Token]) -> Optional[str]:
+        """
+        Resolve the token to a string, using per-request or default token.
+
+        Args:
+            token: Per-request token or None.
+
+        Returns:
+            The resolved token string or None.
+        """
+        use_token = token if token is not None else self._token
+        if use_token is None:
+            return None
+        return await resolve_token(use_token)
+
+    def use_interceptor(self, interceptor: Interceptor) -> None:
+        """
+        Register an interceptor for request/response middleware.
+
+        Args:
+            interceptor: An object with optional request/response methods.
+        """
+        self._interceptors.append(interceptor)
+        self._update_event_hooks()
+
+    def _update_event_hooks(self) -> None:
+        """
+        Internal: Update the httpx.AsyncClient event_hooks to match current interceptors.
+        """
+        event_hooks_dict: Dict[str, List[Callable[[Any], Any]]] = {}
+        for hook in self._interceptors:
+            if hasattr(hook, "request"):
+
+                def _make_request_wrapper(h: Interceptor) -> Callable[[Request], Awaitable[None]]:
+                    async def wrapper(request: Request) -> None:
+                        ctx = InterceptorRequestContext(request, self._logger)
+                        result = h.request(ctx)
+                        if inspect.isawaitable(result):
+                            await result
+
+                    return wrapper
+
+                event_hooks_dict.setdefault("request", []).append(_make_request_wrapper(hook))
+            if hasattr(hook, "response"):
+
+                def _make_response_wrapper(h: Interceptor) -> Callable[[Response], Awaitable[None]]:
+                    async def wrapper(response: Response) -> None:
+                        ctx = InterceptorResponseContext(response, self._logger)
+                        result = h.response(ctx)
+                        if inspect.isawaitable(result):
+                            await result
+
+                    return wrapper
+
+                event_hooks_dict.setdefault("response", []).append(_make_response_wrapper(hook))
+        self.http.event_hooks = event_hooks_dict
+
+    def clone(self, overrides: Optional[ClientOptions] = None) -> "Client":
+        """
+        Create a new Client instance with merged configuration.
+
+        Args:
+            overrides: Optional ClientOptions object to override fields.
+
+        Returns:
+            A new Client instance with merged options and a cloned interceptor list.
+        """
+        overrides = overrides or ClientOptions()
+        merged_options = ClientOptions(
+            base_url=overrides.base_url if overrides.base_url is not None else self._options.base_url,
+            headers={**self._options.headers, **(overrides.headers or {})},
+            timeout=overrides.timeout if overrides.timeout is not None else self._options.timeout,
+            logger=overrides.logger if overrides.logger is not None else self._options.logger,
+            token=overrides.token if overrides.token is not None else self._options.token,
+            interceptors=list(overrides.interceptors)
+            if overrides.interceptors is not None
+            else list(self._interceptors),
+        )
+        return Client(merged_options)

microsoft_teams_common-0.0.1a1/src/microsoft/teams/common/http/client_token.py

@@ -0,0 +1,43 @@
+"""
+Copyright (c) Microsoft Corporation. All rights reserved.
+Licensed under the MIT License.
+"""
+
+import inspect
+from typing import Awaitable, Callable, Optional, Protocol, Union, runtime_checkable
+
+
+# String-like protocol: any object with __str__
+@runtime_checkable
+class StringLike(Protocol):
+    def __str__(self) -> str: ...
+
+
+TokenFactory = Callable[
+    [],
+    Union[
+        str,
+        StringLike,
+        None,
+        Awaitable[Union[str, StringLike, None]],
+    ],
+]
+
+Token = Union[str, StringLike, TokenFactory, None]
+
+
+async def resolve_token(token: Token) -> Optional[str]:
+    """
+    Resolves a token value to a string, handling callables and awaitables.
+    Always used as an async function for uniform async usage.
+    """
+    value = token
+    if callable(value):
+        called_value = value()
+        if inspect.isawaitable(called_value):
+            resolved = await called_value
+            return str(resolved) if resolved is not None else None
+        return str(called_value) if called_value is not None else None
+    if value is None:
+        return None
+    return str(value)

microsoft_teams_common-0.0.1a1/src/microsoft/teams/common/http/interceptor.py

@@ -0,0 +1,42 @@
+"""
+Copyright (c) Microsoft Corporation. All rights reserved.
+Licensed under the MIT License.
+"""
+
+import logging
+from typing import Any, Awaitable, Callable, TypeVar, Union
+
+from httpx import Request, Response
+
+T = TypeVar("T")
+D = TypeVar("D")
+
+
+class InterceptorRequestContext:
+    def __init__(self, request: Request, log: logging.Logger):
+        self.request = request
+        self.log = log
+
+
+class InterceptorResponseContext:
+    def __init__(self, response: Response, log: logging.Logger):
+        self.response = response
+        self.log = log
+
+
+RequestInterceptor = Callable[[InterceptorRequestContext], Union[Any, Awaitable[Any]]]
+ResponseInterceptor = Callable[[InterceptorResponseContext], Union[Any, Awaitable[Any]]]
+
+
+class Interceptor:
+    """
+    Protocol for HTTP interceptors.
+
+    Optionally implement any of:
+    - request(ctx): mutate or observe outgoing request (ctx: InterceptorRequestContext)
+    - response(ctx): mutate or observe incoming response (ctx: InterceptorResponseContext)
+    """
+
+    def request(self, ctx: InterceptorRequestContext) -> Union[None, Awaitable[None]]: ...
+
+    def response(self, ctx: InterceptorResponseContext) -> Union[None, Awaitable[None]]: ...

microsoft_teams_common-0.0.1a1/src/microsoft/teams/common/logging/__init__.py

@@ -0,0 +1,11 @@
+"""
+Copyright (c) Microsoft Corporation. All rights reserved.
+Licensed under the MIT License.
+"""
+
+from .ansi import ANSI
+from .console import ConsoleLogger
+from .filter import ConsoleFilter
+from .formatter import ConsoleFormatter
+
+__all__ = ["ANSI", "ConsoleLogger", "ConsoleFormatter", "ConsoleFilter"]

microsoft_teams_common-0.0.1a1/src/microsoft/teams/common/logging/ansi.py

@@ -0,0 +1,41 @@
+"""
+Copyright (c) Microsoft Corporation. All rights reserved.
+Licensed under the MIT License.
+"""
+
+from enum import Enum
+
+
+class ANSI(str, Enum):
+    RESET = "\033[0m"
+
+    BOLD = "\033[1m"
+    BOLD_RESET = "\033[22m"
+    ITALIC = "\033[3m"
+    ITALIC_RESET = "\033[23m"
+    UNDERLINE = "\033[4m"
+    UNDERLINE_RESET = "\033[24m"
+    STRIKE = "\033[9m"
+    STRIKE_RESET = "\033[29m"
+
+    FOREGROUND_RESET = "\033[0m"
+    BACKGROUND_RESET = "\033[0m"
+    FOREGROUND_BLACK = "\033[30m"
+    BACKGROUND_BLACK = "\033[40m"
+    FOREGROUND_RED = "\033[31m"
+    BACKGROUND_RED = "\033[41m"
+    FOREGROUND_GREEN = "\033[32m"
+    BACKGROUND_GREEN = "\033[42m"
+    FOREGROUND_YELLOW = "\033[33m"
+    BACKGROUND_YELLOW = "\033[43m"
+    FOREGROUND_BLUE = "\033[34m"
+    BACKGROUND_BLUE = "\033[44m"
+    FOREGROUND_MAGENTA = "\033[35m"
+    BACKGROUND_MAGENTA = "\033[45m"
+    FOREGROUND_CYAN = "\033[36m"
+    BACKGROUND_CYAN = "\033[46m"
+    FOREGROUND_WHITE = "\033[37m"
+    BACKGROUND_WHITE = "\033[47m"
+    FOREGROUND_GRAY = "\033[90m"
+    FOREGROUND_DEFAULT = "\033[39m"
+    BACKGROUND_DEFAULT = "\033[49m"

microsoft_teams_common-0.0.1a1/src/microsoft/teams/common/logging/console.py

@@ -0,0 +1,56 @@
+"""
+Copyright (c) Microsoft Corporation. All rights reserved.
+Licensed under the MIT License.
+"""
+
+import logging
+import os
+from typing import Optional, TypedDict
+
+from .filter import ConsoleFilter
+from .formatter import ConsoleFormatter
+
+
+class ConsoleLoggerOptions(TypedDict, total=False):
+    """
+    ConsoleLoggerOptions is a dictionary that contains the options for the ConsoleLogger.
+
+    :param level: The level of the logger (error, warn, info, debug)
+    :param pattern: The pattern of the logger (e.g. "my_module.*")
+    """
+
+    level: str
+    pattern: str
+
+
+class ConsoleLogger:
+    """
+    ConsoleLogger is a class that creates a logger for the console.
+    """
+
+    _levels = {"error": logging.ERROR, "warn": logging.WARNING, "info": logging.INFO, "debug": logging.DEBUG}
+
+    def create_logger(self, name: str, options: Optional[ConsoleLoggerOptions] = None) -> logging.Logger:
+        """
+        Create a logger for the console.
+
+        :param name: The name of the logger
+        :param options: The options for the logger
+        """
+
+        logger = logging.getLogger(name)
+        logger.handlers = []
+
+        handler = logging.StreamHandler()
+        handler.setFormatter(ConsoleFormatter())
+        logger.addHandler(handler)
+
+        options_level = options.get("level", "info") if options else "info"
+        level = (os.environ.get("LOG_LEVEL") or options_level).lower()
+        logger.setLevel(self._levels.get(level, logging.INFO))
+
+        options_pattern = options.get("pattern", "*") if options else "*"
+        pattern = os.environ.get("LOG") or options_pattern
+        logger.addFilter(ConsoleFilter(pattern))
+
+        return logger

microsoft_teams_common-0.0.1a1/src/microsoft/teams/common/logging/filter.py

@@ -0,0 +1,35 @@
+"""
+Copyright (c) Microsoft Corporation. All rights reserved.
+Licensed under the MIT License.
+"""
+
+import logging
+import re
+
+
+class ConsoleFilter(logging.Filter):
+    """
+    A logging filter that matches log records against a pattern.
+
+    Attributes:
+        pattern (str): The pattern to match against log record names.
+    """
+
+    def __init__(self, pattern: str = "*"):
+        super().__init__()
+        self.pattern = self._parse_magic_expr(pattern)
+
+    def filter(self, record: logging.LogRecord) -> bool:
+        """
+        Filter log records based on a pattern.
+        Args:
+            record (logging.LogRecord): The log record to filter.
+        Returns:
+            bool: True if the record matches the pattern, False otherwise.
+        """
+        return bool(self.pattern.match(record.name))
+
+    @staticmethod
+    def _parse_magic_expr(pattern: str) -> re.Pattern[str]:
+        pattern = pattern.replace("*", ".*")
+        return re.compile(f"^{pattern}$")

microsoft_teams_common-0.0.1a1/src/microsoft/teams/common/logging/formatter.py

@@ -0,0 +1,43 @@
+"""
+Copyright (c) Microsoft Corporation. All rights reserved.
+Licensed under the MIT License.
+"""
+
+import json
+import logging
+
+from .ansi import ANSI
+
+
+class ConsoleFormatter(logging.Formatter):
+    """
+    A custom logging formatter that formats log messages with colors and prefixes.
+    """
+
+    _colors = {
+        "ERROR": ANSI.FOREGROUND_RED,
+        "WARNING": ANSI.FOREGROUND_YELLOW,
+        "INFO": ANSI.FOREGROUND_CYAN,
+        "DEBUG": ANSI.FOREGROUND_MAGENTA,
+    }
+
+    def format(self, record: logging.LogRecord) -> str:
+        """
+        Format the log record with colors and prefixes.
+        Args:
+            record (logging.LogRecord): The log record to format.
+        Returns:
+            str: The formatted log message.
+        """
+        if isinstance(record.msg, (dict, list)):
+            record.msg = json.dumps(record.msg, indent=2)  # pyright: ignore[reportUnknownMemberType]
+
+        level_name = record.levelname.upper()
+        color = self._colors.get(level_name, ANSI.FOREGROUND_CYAN)
+        prefix = f"{color.value}{ANSI.BOLD.value}[{level_name}]"
+        name = f"{record.name}{ANSI.FOREGROUND_RESET.value}{ANSI.BOLD_RESET.value}"
+
+        message = record.getMessage()
+        lines = message.split("\n")
+        formatted_lines = [f"{prefix} {name} {line}" for line in lines]
+        return "\n".join(formatted_lines)

microsoft_teams_common-0.0.1a1/src/microsoft/teams/common/storage/__init__.py

@@ -0,0 +1,10 @@
+"""
+Copyright (c) Microsoft Corporation. All rights reserved.
+Licensed under the MIT License.
+"""
+
+from .list_local_storage import ListLocalStorage
+from .local_storage import LocalStorage, LocalStorageOptions
+from .storage import ListStorage, Storage
+
+__all__ = ["Storage", "ListStorage", "LocalStorage", "ListLocalStorage", "LocalStorageOptions"]

microsoft_teams_common-0.0.1a1/src/microsoft/teams/common/storage/list_local_storage.py

@@ -0,0 +1,67 @@
+"""
+Copyright (c) Microsoft Corporation. All rights reserved.
+Licensed under the MIT License.
+"""
+
+from typing import Callable, List, Optional, TypeVar
+
+from .storage import ListStorage
+
+V = TypeVar("V")
+
+
+class ListLocalStorage(ListStorage[V]):
+    """A local storage implementation for a list of items."""
+
+    def __init__(self, items: Optional[List[V]] = None):
+        self._items = items or []
+
+    def get(self, key: int) -> Optional[V]:
+        if key < 0 or key >= len(self._items):
+            return None
+        return self._items[key]
+
+    async def async_get(self, key: int) -> Optional[V]:
+        return self.get(key)
+
+    def set(self, key: int, value: V) -> None:
+        self._items[key] = value
+
+    async def async_set(self, key: int, value: V) -> None:
+        return self.set(key, value)
+
+    def delete(self, key: int) -> None:
+        del self._items[key]
+
+    async def async_delete(self, key: int) -> None:
+        return self.delete(key)
+
+    def append(self, value: V) -> None:
+        return self._items.append(value)
+
+    async def async_append(self, value: V) -> None:
+        return self.append(value)
+
+    def pop(self) -> Optional[V]:
+        return self._items.pop()
+
+    async def async_pop(self) -> Optional[V]:
+        return self.pop()
+
+    def items(self) -> List[V]:
+        return self._items
+
+    async def async_items(self) -> List[V]:
+        return self.items()
+
+    def length(self) -> int:
+        return len(self._items)
+
+    async def async_length(self) -> int:
+        return self.length()
+
+    def filter(self, predicate: Callable[[V, int], bool]) -> List[V]:
+        return [item for i, item in enumerate(self._items) if predicate(item, i)]
+
+    async def async_filter(self, predicate: Callable[[V, int], bool]) -> List[V]:
+        return self.filter(predicate)

microsoft_teams_common-0.0.1a1/src/microsoft/teams/common/storage/local_storage.py

@@ -0,0 +1,77 @@
+"""
+Copyright (c) Microsoft Corporation. All rights reserved.
+Licensed under the MIT License.
+"""
+
+from collections import OrderedDict
+from dataclasses import dataclass
+from typing import Dict, List, Optional, TypeVar
+
+from .storage import Storage
+
+V = TypeVar("V")
+
+
+@dataclass(frozen=True)
+class LocalStorageOptions:
+    max: Optional[int] = None
+    """Maximum number of items in the storage"""
+
+
+class LocalStorage(Storage[str, V]):
+    """
+    A key-value storage with optional size limit and LRU behavior.
+    """
+
+    @property
+    def store(self) -> OrderedDict[str, V]:
+        return self._store
+
+    @property
+    def options(self) -> LocalStorageOptions:
+        return self._options
+
+    @property
+    def keys(self) -> List[str]:
+        return list(self._store.keys())
+
+    @property
+    def size(self) -> int:
+        return len(self._store)
+
+    def __init__(
+        self,
+        data: Optional[Dict[str, V]] = None,
+        options: Optional[LocalStorageOptions] = None,
+    ):
+        self._store = OrderedDict(data or {})
+        self._options = options or LocalStorageOptions()
+
+    def get(self, key: str) -> Optional[V]:
+        if key not in self._store:
+            return None
+
+        value = self._store.pop(key)
+        self._store[key] = value
+        return value
+
+    async def async_get(self, key: str) -> Optional[V]:
+        return self.get(key)
+
+    def set(self, key: str, value: V) -> None:
+        if key in self._store:
+            del self._store[key]
+        elif self._options.max and len(self._store) >= self._options.max:
+            self._store.popitem(last=False)
+
+        self._store[key] = value
+
+    async def async_set(self, key: str, value: V) -> None:
+        return self.set(key, value)
+
+    def delete(self, key: str) -> None:
+        if key in self._store:
+            del self._store[key]
+
+    async def async_delete(self, key: str) -> None:
+        return self.delete(key)

microsoft_teams_common-0.0.1a1/src/microsoft/teams/common/storage/storage.py

@@ -0,0 +1,98 @@
+"""
+Copyright (c) Microsoft Corporation. All rights reserved.
+Licensed under the MIT License.
+"""
+
+from abc import ABC, abstractmethod
+from typing import Callable, Generic, List, Optional, TypeVar
+
+K = TypeVar("K")
+V = TypeVar("V")
+
+
+class Storage(Generic[K, V], ABC):
+    """A storage container that can get/set/delete items by a unique key."""
+
+    @abstractmethod
+    def get(self, key: K) -> Optional[V]:
+        """Synchronously get a value by key."""
+        pass
+
+    @abstractmethod
+    async def async_get(self, key: K) -> Optional[V]:
+        """Asynchronously get a value by key."""
+        pass
+
+    @abstractmethod
+    def set(self, key: K, value: V) -> None:
+        """Synchronously set a value by key."""
+        pass
+
+    @abstractmethod
+    async def async_set(self, key: K, value: V) -> None:
+        """Asynchronously set a value by key."""
+        pass
+
+    @abstractmethod
+    def delete(self, key: K) -> None:
+        """Synchronously delete a value by key."""
+        pass
+
+    @abstractmethod
+    async def async_delete(self, key: K) -> None:
+        """Asynchronously delete a value by key."""
+        pass
+
+
+class ListStorage(Storage[int, V], ABC):
+    """A list storage container that can store/query iterable data."""
+
+    @abstractmethod
+    def append(self, value: V) -> None:
+        """Synchronously append a value to the list."""
+        pass
+
+    @abstractmethod
+    async def async_append(self, value: V) -> None:
+        """Asynchronously append a value to the list."""
+        pass
+
+    @abstractmethod
+    def pop(self) -> Optional[V]:
+        """Synchronously remove and return the last value."""
+        pass
+
+    @abstractmethod
+    async def async_pop(self) -> Optional[V]:
+        """Asynchronously remove and return the last value."""
+        pass
+
+    @abstractmethod
+    def items(self) -> List[V]:
+        """Synchronously return all items as a list."""
+        pass
+
+    @abstractmethod
+    async def async_items(self) -> List[V]:
+        """Asynchronously return all items as a list."""
+        pass
+
+    @abstractmethod
+    def length(self) -> int:
+        """Return the number of items."""
+        pass
+
+    @abstractmethod
+    async def async_length(self) -> int:
+        """Return the number of items."""
+        pass
+
+    @abstractmethod
+    def filter(self, predicate: Callable[[V, int], bool]) -> List[V]:
+        """Synchronously filter items using predicate."""
+        pass
+
+    @abstractmethod
+    async def async_filter(self, predicate: Callable[[V, int], bool]) -> List[V]:
+        """Asynchronously filter items using predicate."""
+        pass