teams-phone-cli 0.1.2__py3-none-any.whl

teams_phone/services/user_service.py

@@ -0,0 +1,435 @@
+"""User service for Teams Phone user configuration operations.
+
+This module provides the UserService class for listing, searching, and
+retrieving Teams user voice configurations from Microsoft Graph API.
+"""
+
+from __future__ import annotations
+
+import re
+from typing import TYPE_CHECKING, Any
+
+from teams_phone.constants import GRAPH_API_V1_BASE
+from teams_phone.exceptions import NotFoundError, ValidationError
+from teams_phone.models import AccountType, UserConfiguration
+
+
+if TYPE_CHECKING:
+    from teams_phone.infrastructure.graph_client import GraphClient
+
+
+def _strip_odata_metadata(data: dict[str, Any]) -> dict[str, Any]:
+    """Strip OData metadata fields from a response dict.
+
+    Graph API responses include @odata.context and other @ prefixed fields
+    that are not part of the actual data contract. This helper removes them
+    before Pydantic validation with extra="forbid".
+    """
+    return {k: v for k, v in data.items() if not k.startswith("@")}
+
+
+class UserService:
+    """Service for user voice configuration operations.
+
+    Provides methods for listing, searching, and retrieving Teams user
+    configurations from the Microsoft Graph API.
+
+    Attributes:
+        graph_client: GraphClient instance for API communication.
+    """
+
+    # Maximum IDs per filter query (URL length limit)
+    _MAX_IDS_PER_BATCH = 15
+
+    def __init__(self, graph_client: GraphClient) -> None:
+        """Initialize the UserService.
+
+        Args:
+            graph_client: GraphClient instance for API communication.
+        """
+        self.graph_client = graph_client
+
+    async def _fetch_display_names(
+        self,
+        user_ids: list[str],
+    ) -> dict[str, str]:
+        """Fetch display names for a list of user IDs from the directory.
+
+        The /admin/teams/userConfigurations endpoint doesn't return displayName,
+        so we fetch it separately from the v1.0 /users endpoint.
+
+        Args:
+            user_ids: List of Entra object IDs to fetch display names for.
+
+        Returns:
+            Dict mapping user ID to display name. Users not found are omitted.
+        """
+        if not user_ids:
+            return {}
+
+        display_names: dict[str, str] = {}
+
+        # Batch IDs to avoid URL length limits
+        for i in range(0, len(user_ids), self._MAX_IDS_PER_BATCH):
+            batch_ids = user_ids[i : i + self._MAX_IDS_PER_BATCH]
+
+            # Build filter: id in ('id1', 'id2', ...)
+            id_list = ", ".join(f"'{uid}'" for uid in batch_ids)
+            url = f"{GRAPH_API_V1_BASE}/users"
+            params: dict[str, Any] = {
+                "$filter": f"id in ({id_list})",
+                "$select": "id,displayName",
+            }
+
+            async for item in self.graph_client.get_paginated_url(
+                url,
+                params=params,
+            ):
+                user_id = item.get("id")
+                display_name = item.get("displayName")
+                if user_id and display_name:
+                    display_names[user_id] = display_name
+
+        return display_names
+
+    async def _enrich_display_names(
+        self,
+        users: list[UserConfiguration],
+    ) -> list[UserConfiguration]:
+        """Enrich a list of users with display names from the directory.
+
+        Args:
+            users: List of UserConfiguration objects to enrich.
+
+        Returns:
+            New list with display names populated where available.
+        """
+        user_ids = [u.id for u in users if u.display_name is None]
+        if not user_ids:
+            return users
+
+        display_names = await self._fetch_display_names(user_ids)
+        return [
+            u.model_copy(update={"display_name": display_names.get(u.id)})
+            if u.display_name is None and u.id in display_names
+            else u
+            for u in users
+        ]
+
+    async def list_users(
+        self,
+        *,
+        licensed: bool | None = None,
+        assigned: bool | None = None,
+        account_type: AccountType | None = None,
+        page_size: int = 100,
+        max_items: int | None = None,
+    ) -> list[UserConfiguration]:
+        """List users with optional filtering and pagination.
+
+        Retrieves user voice configurations from Microsoft Graph API
+        with support for filtering by licensing, phone number assignment,
+        and account type.
+
+        Args:
+            licensed: If True, only return users with enterprise voice enabled.
+                If False, only return users without enterprise voice.
+                If None, return all users regardless of voice license.
+            assigned: If True, only return users with phone numbers assigned.
+                If False, only return users without phone numbers.
+                If None, return all users regardless of assignment status.
+            account_type: Filter by account type (user, resourceAccount, etc.).
+                If None, return all account types.
+            page_size: Number of items per page (default 100, max 999).
+            max_items: Maximum total items to return. If None, return all items.
+
+        Returns:
+            List of UserConfiguration objects matching the filter criteria.
+
+        Raises:
+            ContractError: If API response is missing expected fields.
+            AuthenticationError: If authentication fails.
+            RateLimitError: If rate limit exceeded after retries.
+        """
+        users: list[UserConfiguration] = []
+        params: dict[str, Any] = {"$top": str(min(page_size, 999))}
+
+        # Build OData $filter string based on parameters
+        # Note: assigned filter is done client-side (Graph API doesn't support $count on telephoneNumbers)
+        filters: list[str] = []
+        if licensed is not None:
+            filters.append(f"isEnterpriseVoiceEnabled eq {str(licensed).lower()}")
+        if account_type is not None:
+            filters.append(f"accountType eq '{account_type.value}'")
+
+        if filters:
+            params["$filter"] = " and ".join(filters)
+
+        async for item in self.graph_client.get_paginated(
+            "/admin/teams/userConfigurations",
+            params=params,
+            max_items=max_items
+            if assigned is None
+            else None,  # Fetch all if filtering client-side
+        ):
+            user = UserConfiguration.model_validate(item)
+            # Client-side filter for assigned status
+            if assigned is not None:
+                has_numbers = len(user.telephone_numbers) > 0
+                if assigned and not has_numbers:
+                    continue
+                if not assigned and has_numbers:
+                    continue
+            users.append(user)
+            # Check max_items after client-side filtering
+            if max_items is not None and len(users) >= max_items:
+                break
+
+        # Enrich with display names from directory
+        # The Teams admin API doesn't return displayName
+        return await self._enrich_display_names(users)
+
+    async def get_user(self, user_id: str) -> UserConfiguration:
+        """Get a single user's voice configuration by ID.
+
+        Retrieves detailed voice configuration for a specific user
+        identified by their Entra object ID.
+
+        Args:
+            user_id: The user's Entra object ID (GUID).
+
+        Returns:
+            UserConfiguration for the specified user.
+
+        Raises:
+            NotFoundError: If the user is not found.
+            ContractError: If API response doesn't match expected schema.
+            AuthenticationError: If authentication fails.
+        """
+        response = await self.graph_client.get(
+            f"/admin/teams/userConfigurations/{user_id}"
+        )
+        user = UserConfiguration.model_validate(_strip_odata_metadata(response))
+
+        # Enrich with display name from directory if not present
+        enriched = await self._enrich_display_names([user])
+        return enriched[0]
+
+    async def _search_directory_users(
+        self,
+        query: str,
+        *,
+        max_results: int = 25,
+    ) -> list[dict[str, str | None]]:
+        """Search users by display name via v1.0 /users endpoint.
+
+        The /admin/teams/userConfigurations endpoint doesn't support
+        displayName filtering, so we search the directory first.
+        We also return displayName since the Teams admin API doesn't
+        populate it in the userConfigurations response.
+
+        Args:
+            query: Display name search query.
+            max_results: Maximum number of results to return.
+
+        Returns:
+            List of dicts with 'id' and 'displayName' for matching users.
+        """
+        # Use v1.0 /users endpoint which supports displayName filtering
+        # Build full URL since GraphClient defaults to beta
+        url = f"{GRAPH_API_V1_BASE}/users"
+        params: dict[str, Any] = {
+            "$filter": f"startsWith(displayName, '{query}')",
+            "$select": "id,displayName",
+            "$top": str(min(max_results, 999)),
+        }
+
+        users: list[dict[str, str | None]] = []
+        async for item in self.graph_client.get_paginated_url(
+            url,
+            params=params,
+            max_items=max_results,
+        ):
+            if "id" in item:
+                users.append(
+                    {
+                        "id": str(item["id"]),
+                        "displayName": item.get("displayName"),
+                    }
+                )
+
+        return users
+
+    async def search_users(
+        self,
+        query: str,
+        *,
+        max_results: int = 25,
+    ) -> list[UserConfiguration]:
+        """Search users by display name, UPN, or phone number.
+
+        Searches user configurations using OData filters. Automatically
+        detects the query type and applies appropriate filtering:
+        - Phone numbers (starting with +): Searches telephoneNumbers collection
+        - Email addresses (containing @): Searches by UPN
+        - Other queries: Searches by display name using v1.0 /users endpoint
+
+        Args:
+            query: Search query - phone number, UPN, or display name.
+            max_results: Maximum number of results to return (default 25).
+
+        Returns:
+            List of UserConfiguration objects matching the search query.
+
+        Raises:
+            ContractError: If API response doesn't match expected schema.
+            AuthenticationError: If authentication fails.
+            RateLimitError: If rate limit exceeded after retries.
+        """
+        # Detect query type and route to appropriate search method
+        if query.startswith("+") or re.match(r"^\d+$", query):
+            # Phone number search - normalize and search in telephoneNumbers
+            # Handle both E.164 format and raw digits
+            normalized = query if query.startswith("+") else f"+{query}"
+            params: dict[str, Any] = {
+                "$top": str(min(max_results, 999)),
+                "$filter": (
+                    f"telephoneNumbers/any(t: t/telephoneNumber eq '{normalized}')"
+                ),
+            }
+            users: list[UserConfiguration] = []
+            async for item in self.graph_client.get_paginated(
+                "/admin/teams/userConfigurations",
+                params=params,
+                max_items=max_results,
+            ):
+                users.append(UserConfiguration.model_validate(item))
+            # Enrich with display names
+            return await self._enrich_display_names(users)
+
+        elif "@" in query:
+            # UPN search - exact match on userConfigurations
+            params = {
+                "$top": str(min(max_results, 999)),
+                "$filter": f"userPrincipalName eq '{query}'",
+            }
+            users = []
+            async for item in self.graph_client.get_paginated(
+                "/admin/teams/userConfigurations",
+                params=params,
+                max_items=max_results,
+            ):
+                users.append(UserConfiguration.model_validate(item))
+            # Enrich with display names
+            return await self._enrich_display_names(users)
+
+        else:
+            # Display name search - use v1.0 /users endpoint first,
+            # then fetch Teams configurations for matched users
+            directory_users = await self._search_directory_users(
+                query, max_results=max_results
+            )
+
+            if not directory_users:
+                return []
+
+            # Fetch Teams configurations for each matched user
+            # Note: The Teams admin API doesn't return displayName, so we
+            # inject it from the directory search result
+            users = []
+            for dir_user in directory_users:
+                user_id = dir_user["id"]
+                if user_id is None:
+                    continue  # Skip if somehow id is None (shouldn't happen)
+                try:
+                    user_config = await self.get_user(user_id)
+                    # Inject displayName from directory if Teams API didn't provide it
+                    if user_config.display_name is None and dir_user.get("displayName"):
+                        # Create a new instance with the displayName set
+                        # Using model_copy to avoid mutating the original
+                        user_config = user_config.model_copy(
+                            update={"display_name": dir_user["displayName"]}
+                        )
+                    users.append(user_config)
+                except NotFoundError:
+                    # User exists in directory but has no Teams configuration
+                    # (e.g., unlicensed user) - skip them
+                    continue
+
+            return users
+
+    async def resolve_user(self, identifier: str) -> UserConfiguration:
+        """Resolve a user by UPN, display name, or object ID.
+
+        Attempts to find a single user matching the identifier. Uses
+        intelligent detection to determine the identifier type:
+        - GUID format: Direct lookup by object ID
+        - Email format (contains @): Lookup by UPN
+        - Other: Search by display name
+
+        Args:
+            identifier: User identifier - UPN, display name, or object ID.
+
+        Returns:
+            UserConfiguration for the resolved user.
+
+        Raises:
+            NotFoundError: If no user matches the identifier.
+            ValidationError: If multiple users match (ambiguous identifier).
+            AuthenticationError: If authentication fails.
+        """
+        # Check if identifier is a GUID (object ID)
+        guid_pattern = re.compile(
+            r"^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-"
+            r"[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$"
+        )
+
+        if guid_pattern.match(identifier):
+            # Direct lookup by ID
+            return await self.get_user(identifier)
+
+        if "@" in identifier:
+            # UPN lookup - search for exact match
+            users = await self.search_users(identifier, max_results=1)
+            if not users:
+                raise NotFoundError(
+                    f"User '{identifier}' not found",
+                    remediation=(
+                        "Verify the user principal name (email) is correct.\n"
+                        "Use 'teams-phone users search' to find available users."
+                    ),
+                )
+            return users[0]
+
+        # Display name search - requires disambiguation
+        users = await self.search_users(identifier, max_results=10)
+
+        if not users:
+            raise NotFoundError(
+                f"No user found matching '{identifier}'",
+                remediation=(
+                    "No user found with a display name starting with "
+                    f"'{identifier}'.\n"
+                    "Use 'teams-phone users list' to see available users, or\n"
+                    "try searching by UPN (email address) for exact matching."
+                ),
+            )
+
+        if len(users) == 1:
+            return users[0]
+
+        # Multiple matches - require disambiguation
+        user_list = "\n".join(
+            f"  - {u.display_name or u.user_principal_name} ({u.user_principal_name})"
+            for u in users[:5]
+        )
+        additional = f"\n  ... and {len(users) - 5} more" if len(users) > 5 else ""
+
+        raise ValidationError(
+            f"Multiple users match '{identifier}'",
+            remediation=(
+                f"The following users match your query:\n{user_list}{additional}\n\n"
+                "Please specify the user by their full UPN (email address) "
+                "or object ID\nto avoid ambiguity."
+            ),
+        )

teams_phone/utils.py

@@ -0,0 +1,172 @@
+"""Phone number normalization and helper utilities."""
+
+import re
+
+from teams_phone.exceptions import ValidationError
+
+
+def normalize_phone_number(number: str) -> str:
+    """Normalize a phone number by stripping non-digit characters.
+
+    Accepts various formats and converts to digits-only format.
+    Validates that the result has at least 10 digits.
+
+    Args:
+        number: Phone number in any format (e.g., "+1 (206) 555-1234",
+            "1-206-555-1234", "+12065551234").
+
+    Returns:
+        Digits-only string (e.g., "12065551234").
+
+    Raises:
+        ValidationError: If the number has fewer than 10 digits after
+            stripping non-digit characters.
+
+    Examples:
+        >>> normalize_phone_number("+1 (206) 555-1234")
+        '12065551234'
+        >>> normalize_phone_number("1-206-555-1234")
+        '12065551234'
+        >>> normalize_phone_number("+12065551234")
+        '12065551234'
+    """
+    digits = re.sub(r"\D", "", number)
+
+    if len(digits) < 10:
+        raise ValidationError(
+            f"Invalid phone number: '{number}' has fewer than 10 digits",
+            remediation="Provide a valid phone number with at least 10 digits.",
+        )
+
+    return digits
+
+
+def format_for_assign(number: str) -> str:
+    """Format a phone number for the assignNumber/unassignNumber API endpoints.
+
+    These endpoints require digits only (no + prefix).
+
+    Args:
+        number: Phone number in any format.
+
+    Returns:
+        Digits-only string suitable for Graph API assign/unassign operations.
+
+    Raises:
+        ValidationError: If the number is invalid.
+
+    Examples:
+        >>> format_for_assign("+1 (206) 555-1234")
+        '12065551234'
+        >>> format_for_assign("12065551234")
+        '12065551234'
+    """
+    return normalize_phone_number(number)
+
+
+def format_for_update(number: str) -> str:
+    """Format a phone number for the updateNumber API endpoint.
+
+    This endpoint requires E.164 format with + prefix.
+
+    Args:
+        number: Phone number in any format.
+
+    Returns:
+        E.164 formatted string with + prefix (e.g., "+12065551234").
+
+    Raises:
+        ValidationError: If the number is invalid.
+
+    Examples:
+        >>> format_for_update("1 (206) 555-1234")
+        '+12065551234'
+        >>> format_for_update("+12065551234")
+        '+12065551234'
+    """
+    digits = normalize_phone_number(number)
+    return f"+{digits}"
+
+
+def format_for_display(number: str) -> str:
+    """Format a phone number for user-friendly display.
+
+    Formats US/Canada NANP numbers as: +1 (NPA) NXX-XXXX
+    For international numbers, returns E.164 format.
+
+    Args:
+        number: Phone number in any format.
+
+    Returns:
+        Formatted string for display (e.g., "+1 (206) 555-1234").
+
+    Raises:
+        ValidationError: If the number is invalid.
+
+    Examples:
+        >>> format_for_display("12065551234")
+        '+1 (206) 555-1234'
+        >>> format_for_display("+442071234567")
+        '+442071234567'
+    """
+    digits = normalize_phone_number(number)
+
+    # US/Canada NANP: 11 digits starting with 1
+    if len(digits) == 11 and digits.startswith("1"):
+        return f"+1 ({digits[1:4]}) {digits[4:7]}-{digits[7:11]}"
+
+    # US/Canada NANP without country code: 10 digits
+    if len(digits) == 10:
+        return f"+1 ({digits[0:3]}) {digits[3:6]}-{digits[6:10]}"
+
+    # International numbers: return E.164 format
+    return f"+{digits}"
+
+
+def match_pattern(number: str, pattern: str) -> bool:
+    """Check if a phone number matches a search pattern.
+
+    Supports wildcards for flexible searching:
+    - `*` matches any sequence of characters
+    - Exact digit sequences match those digits anywhere in the number
+    - Patterns are matched against the normalized (digits-only) number
+
+    Args:
+        number: Phone number to check (any format accepted).
+        pattern: Search pattern, optionally with wildcards.
+
+    Returns:
+        True if the number matches the pattern, False otherwise.
+
+    Raises:
+        ValidationError: If the number is invalid.
+
+    Examples:
+        >>> match_pattern("+12065551234", "206*")
+        True
+        >>> match_pattern("+12065551234", "*555*")
+        True
+        >>> match_pattern("+12065551234", "1234")
+        True
+        >>> match_pattern("+12065551234", "999")
+        False
+    """
+    digits = normalize_phone_number(number)
+
+    # Normalize pattern: strip non-digit except *
+    normalized_pattern = re.sub(r"[^\d*]", "", pattern)
+
+    if not normalized_pattern:
+        return False
+
+    # If pattern has no wildcards, treat as substring search
+    if "*" not in normalized_pattern:
+        return normalized_pattern in digits
+
+    # Convert wildcards to regex pattern
+    # Escape any regex special chars first, then replace \* with .*
+    regex_pattern = re.escape(normalized_pattern).replace(r"\*", ".*")
+
+    # Use search to find pattern anywhere in the number
+    # This allows "206*" to match area codes even with country code prefix
+    return bool(re.search(regex_pattern, digits))

teams_phone_cli-0.1.2.dist-info/METADATA

@@ -0,0 +1,15 @@
+Metadata-Version: 2.4
+Name: teams-phone-cli
+Version: 0.1.2
+Summary: CLI tool for managing Microsoft Teams Phone configurations
+License-File: LICENSE
+Requires-Python: >=3.10
+Requires-Dist: cryptography>=41.0.0
+Requires-Dist: httpx>=0.25.0
+Requires-Dist: msal>=1.24.0
+Requires-Dist: pydantic>=2.0.0
+Requires-Dist: rich>=13.0.0
+Requires-Dist: tenacity>=8.0.0
+Requires-Dist: tomli>=2.0.0; python_version < '3.11'
+Requires-Dist: tomlkit>=0.12.0
+Requires-Dist: typer>=0.9.0

teams_phone_cli-0.1.2.dist-info/RECORD

@@ -0,0 +1,45 @@
+teams_phone/__init__.py,sha256=HDpi3pFZt7yIDIXwT7evnoqE_AIThaf33CAcIIesj2I,92
+teams_phone/__main__.py,sha256=OlqRTyKnFobyvqc0RQ1pcG-SQWUoIku27Mt4yge3tKc,133
+teams_phone/constants.py,sha256=_Kly2IalHvmRRdNyTMfl8STdu1MGhD3cr66_hvzidB4,3249
+teams_phone/exceptions.py,sha256=1KRvVmy2shBrFKvaQ1eOhYZLtgisTrnpO25gBxR-Jko,3883
+teams_phone/utils.py,sha256=nZdxHHQYUYtPAgj_GaoUtfnddyQLqrK6fTSk5j1fHSY,5022
+teams_phone/cli/__init__.py,sha256=KKYQG1nFJB7lwVqb4xu0_jN7O_PyCmbJow_TYErlfo8,281
+teams_phone/cli/api_check.py,sha256=U6oMSJgT618aRisypSdwXFm-O1pKKOVrimXL-nj-QWU,8679
+teams_phone/cli/auth.py,sha256=iBJBCJ3ycsnFoAom5VQACANWZroV5fBHDJBmwYPjFo0,6695
+teams_phone/cli/context.py,sha256=1Jn8mcZ4HJhMtuqWE1zM6kNeefgjCzKr3rqlESwBPeA,3478
+teams_phone/cli/helpers.py,sha256=VkhzUrZaleI32NX8uZYeAneOmMumz5jCurLO_OR2jng,2107
+teams_phone/cli/locations.py,sha256=gk8iZLaGhMvIRlxEnG0Fe9lLisOJ2xF__h1De_RPwes,9843
+teams_phone/cli/main.py,sha256=mHtwei2jI6ESsL49IO2d_I9iiMqhjcfpzJ94Z5IMUqU,3218
+teams_phone/cli/numbers.py,sha256=PX2OfKwaB8dSpbPtvnVZXxvvZIWwHZFL2b97MrqX0sM,62894
+teams_phone/cli/policies.py,sha256=dJ61-hYC3AxafD_AtCzAU_IIxGf1CN0H7vI6vUuxRgA,32973
+teams_phone/cli/tenants.py,sha256=Ivtyr0gZarkHsZ2JbZ2Kuck-yu0DvLtoEF2d2qaUe8I,12495
+teams_phone/cli/users.py,sha256=Ch2K-L84aqx0PS_myM1OJLIyXvLq3N2kiG8L6gFC5hI,13572
+teams_phone/infrastructure/__init__.py,sha256=GzlfRBqyswREd1W13FudNUpl1OzJiXNnM3su3F90fMQ,629
+teams_phone/infrastructure/cache_manager.py,sha256=4LuGV_Tfagh48it69yjgZaFrysi0_a_VHgT2j7UnEh0,9286
+teams_phone/infrastructure/config_manager.py,sha256=qAxM0dhcGGz3tWs2qDSfaJgOH_8R3LnmmrTjspgtcIs,7342
+teams_phone/infrastructure/debug_logger.py,sha256=fDEspLv0SooXh8CR5S1I1aisxYsIOiaU1511pQoJuKs,9379
+teams_phone/infrastructure/graph_client.py,sha256=k8-MiFqYCcfr529DoAYh4rdhiWV-t4xrsez-IE1Ztyw,23620
+teams_phone/infrastructure/output_formatter.py,sha256=WTOfPq7jK_HnfNV7hYhvs9gZl8XdxDsa8l1AF723BCM,7188
+teams_phone/models/__init__.py,sha256=CxtDTZ5A8Xh0s4FpD0WIxydISZ38e7-JzrEj-nLniKM,1793
+teams_phone/models/api_responses.py,sha256=qA4m6X6AHZpt8_C-njQZfaIsv7lSwP8yHZ1mi7K_wiU,2362
+teams_phone/models/auth.py,sha256=YohV8uKHycBo0rUHLyXw2PrpR20YrRZuD7Esyzn6A9w,3119
+teams_phone/models/cache.py,sha256=faTOhi_-0hu-Q5YdS7oK6tE9mxKIgstZ6zCJrvdCO-4,756
+teams_phone/models/config.py,sha256=ujJ5thvg6vVcwVF9poFMfP81EW1aKN1UaLMP9i_b0Hc,1956
+teams_phone/models/location.py,sha256=NSWrXIvp9HnaXAMasE_cAWbgSdn_eBPl3xUEvEF59nA,1565
+teams_phone/models/number.py,sha256=GroicsBpHaCMSYPuPlPPFM0iEFHqDPHyCZSD6VZrQ-o,6822
+teams_phone/models/policy.py,sha256=FmN7ZrTz2BfFOqmorfvHVBIoxnCwo6f7rpKjCY22UAU,962
+teams_phone/models/tenant.py,sha256=FEQZjT7udIocddaqvFFGLdY_-4DF5oPOt7k4UJQyU1w,1473
+teams_phone/models/user.py,sha256=1hPbk7P9X8WxyzawGMQZrpPNPN8s7hxUx_ZHQfgTKko,4411
+teams_phone/services/__init__.py,sha256=RvY68ZVDFFxLwu1iNbGXaIB85JwvJOQPdXDGFkYnjfM,722
+teams_phone/services/auth_service.py,sha256=v5TQQzdDXlu1pWaPeITwHEOYS878B67At3FyIUoePus,20658
+teams_phone/services/bulk_operations.py,sha256=oz7gpOc-SCOaK1EoS6W7QUbGlNR6V6nEH0SKAjlhDrE,19850
+teams_phone/services/location_service.py,sha256=j_IqSHZjSOx-SeQGzfRYAQwpjtdkyTJjMABXoMpWUjA,6185
+teams_phone/services/number_service.py,sha256=xBar84f-sy6CXOaRzJ9jXQzNP4MRgVWF52AGlaTTbEg,18837
+teams_phone/services/policy_service.py,sha256=lKI9XvKePrEFG8GWwmaFt4HuXfzVS1hf7ltq4o77bJY,12358
+teams_phone/services/tenant_service.py,sha256=wfzYnyOfZb_1yuzQ3vy_tX-z2OYIjpa6zqPFhsv5miI,7447
+teams_phone/services/user_service.py,sha256=-FtJTfbz3oE-nD4o0kJv8jBQqIAADQWft_nn2dDiNnE,16645
+teams_phone_cli-0.1.2.dist-info/METADATA,sha256=kRUfVltMAtAqT-ioI4OldD-dJZS-g5EC8Et8DNBy0Ys,468
+teams_phone_cli-0.1.2.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+teams_phone_cli-0.1.2.dist-info/entry_points.txt,sha256=53waHsIjr6V14VxvxuC05zJJnIniudNOuneWGSPVDqs,57
+teams_phone_cli-0.1.2.dist-info/licenses/LICENSE,sha256=FnxAMYZhIzUrihYFEuAr3nGudfb13-HT-3PUmwCrLi0,1069
+teams_phone_cli-0.1.2.dist-info/RECORD,,

teams_phone_cli-0.1.2.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.28.0
+Root-Is-Purelib: true
+Tag: py3-none-any

teams_phone_cli-0.1.2.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+teams-phone = teams_phone.cli.main:app