slack-objects 0.0.2.dev0__tar.gz → 0.0.4__tar.gz

slack_objects-0.0.4/.github/copilot-instructions.md

@@ -0,0 +1,4 @@
+# Copilot Instructions
+
+## Project Guidelines
+- SCIM users live test file naming convention: test files use prefix `test_scim_users_*_live.py`, runner uses `run_all_scim_users_live_tests.py`. The plural "users" is used consistently across all files.

{slack_objects-0.0.2.dev0 → slack_objects-0.0.4}/.gitignore

@@ -1,5 +1,5 @@
 ################################################################################
-# This .gitignore file was automatically created by Microsoft(R) Visual Studio.
+# This .gitignore file was automatically created by Microsoft(R) Visual Studio. Modified by user.
 ################################################################################
 
 /.vs/slack-objects.slnx
@@ -16,4 +16,9 @@
 # Python packaging artifacts
 dist/
 build/
-*.egg-info/
+*.egg-info/
+src/slack_objects/_version.py
+
+# Live-test config (contains real Slack user IDs)
+/tests/SCIM/live_test_config.json
+/tests/SCIM/__pycache__

{slack_objects-0.0.2.dev0 → slack_objects-0.0.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: slack-objects
-Version: 0.0.2.dev0
+Version: 0.0.4
 Summary: Opinionated, testable Python wrappers for Slack’s Web, Admin, and SCIM APIs, organized by object domain (users, conversations, messages, files, workspaces, and IdP groups). Designed for automation and administration workflows.
 Author-email: "Marcos E. Mercado" <marcos_elias@hotmail.com>
 Keywords: slack,objects,classes,slack objects,utilities,slack utilities,slack object types,slack types,types
@@ -10,9 +10,9 @@ Classifier: Operating System :: OS Independent
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: slack-sdk
-Requires-Dist: PC_Utils
-Requires-Dist: requests
+Requires-Dist: slack-sdk<4,>=3.27
+Requires-Dist: PC_Utils>=0.1
+Requires-Dist: requests<3,>=2.31
 Provides-Extra: dev
 Requires-Dist: pytest; extra == "dev"
 Requires-Dist: build; extra == "dev"
@@ -67,15 +67,30 @@ Instead, it focuses on higher-level object operations that typically require:
 All object helpers are created from a single entry point:
 
 ```python
-from slack_objects.client import SlackObjectsClient
+from slack_objects import SlackObjectsClient, SlackObjectsConfig
+
+cfg = SlackObjectsConfig(
+    bot_token="xoxb-...",
+    user_token="xoxp-...",
+    scim_token="xoxp-...",
+    # see SlackObjectsConfig for additional options (scim_base_url, http_timeout_seconds, etc.)
+)
 
 slack = SlackObjectsClient(cfg)
 
-users = slack.users()
-alice = slack.users("U123")
+users = slack.users()       # unbound
+alice = slack.users("U123") # bound to user_id
 
 conversations = slack.conversations()
-general = slack.conversations("C123")
+conversations = slack.conversations("C123") # bound to channel_id
+
+files = slack.files("F123") # bound to file_id
+
+msgs = slack.messages(channel_id="C123", ts="...")  # bound to message
+
+ws = slack.workspaces("T123")   # bound to workspace_id
+
+idp = slack.idp_groups("S123")  # bound to group_id
 ```
 
 This avoids global state while keeping usage concise and consistent.
@@ -133,13 +148,13 @@ pip install slack-objects
 ## Configuration
 
 ```python
-from slack_objects.config import SlackObjectsConfig, RateTier
+from slack_objects import SlackObjectsClient, SlackObjectsConfig, RateTier
 
 cfg = SlackObjectsConfig(
     bot_token="xoxb-...",
     user_token="xoxp-...",
     scim_token="xoxp-...",
-    default_rate_tier=RateTier.TIER_3,
+    default_rate_tier=RateTier.TIER_3,  # fallback sleep between API calls when no specific tier matches
 )
 ```
 
@@ -157,6 +172,6 @@ python -m tests.run_all_smoke
 
 ## Notes
 
-- SCIM v1 is the default; v2 is supported where applicable
-- Guest expiration dates use `PC_Utils.Datetime` if installed
+- SCIM v2 is the default; v1 is supported where applicable
+- `PC_Utils` is an optional dependency (used for datetime handling in `set_guest_expiration_date`)
 - This package is intended for automation and administration workflows

{slack_objects-0.0.2.dev0 → slack_objects-0.0.4}/README.md

@@ -46,15 +46,30 @@ Instead, it focuses on higher-level object operations that typically require:
 All object helpers are created from a single entry point:
 
 ```python
-from slack_objects.client import SlackObjectsClient
+from slack_objects import SlackObjectsClient, SlackObjectsConfig
+
+cfg = SlackObjectsConfig(
+    bot_token="xoxb-...",
+    user_token="xoxp-...",
+    scim_token="xoxp-...",
+    # see SlackObjectsConfig for additional options (scim_base_url, http_timeout_seconds, etc.)
+)
 
 slack = SlackObjectsClient(cfg)
 
-users = slack.users()
-alice = slack.users("U123")
+users = slack.users()       # unbound
+alice = slack.users("U123") # bound to user_id
 
 conversations = slack.conversations()
-general = slack.conversations("C123")
+conversations = slack.conversations("C123") # bound to channel_id
+
+files = slack.files("F123") # bound to file_id
+
+msgs = slack.messages(channel_id="C123", ts="...")  # bound to message
+
+ws = slack.workspaces("T123")   # bound to workspace_id
+
+idp = slack.idp_groups("S123")  # bound to group_id
 ```
 
 This avoids global state while keeping usage concise and consistent.
@@ -112,13 +127,13 @@ pip install slack-objects
 ## Configuration
 
 ```python
-from slack_objects.config import SlackObjectsConfig, RateTier
+from slack_objects import SlackObjectsClient, SlackObjectsConfig, RateTier
 
 cfg = SlackObjectsConfig(
     bot_token="xoxb-...",
     user_token="xoxp-...",
     scim_token="xoxp-...",
-    default_rate_tier=RateTier.TIER_3,
+    default_rate_tier=RateTier.TIER_3,  # fallback sleep between API calls when no specific tier matches
 )
 ```
 
@@ -136,6 +151,6 @@ python -m tests.run_all_smoke
 
 ## Notes
 
-- SCIM v1 is the default; v2 is supported where applicable
-- Guest expiration dates use `PC_Utils.Datetime` if installed
+- SCIM v2 is the default; v1 is supported where applicable
+- `PC_Utils` is an optional dependency (used for datetime handling in `set_guest_expiration_date`)
 - This package is intended for automation and administration workflows

{slack_objects-0.0.2.dev0 → slack_objects-0.0.4}/pyproject.toml

@@ -24,9 +24,9 @@ classifiers=[
 keywords = ["slack", "objects", "classes", "slack objects", "utilities", "slack utilities", "slack object types", "slack types", "types"]
 
 dependencies = [
-"slack-sdk",
-"PC_Utils",
-"requests",
+    "slack-sdk>=3.27,<4",
+    "PC_Utils>=0.1",
+    "requests>=2.31,<3",
 ]
 
 [project.optional-dependencies]

{slack_objects-0.0.2.dev0 → slack_objects-0.0.4}/src/slack_objects/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '0.0.2.dev0'
-__version_tuple__ = version_tuple = (0, 0, 2, 'dev0')
+__version__ = version = '0.0.4'
+__version_tuple__ = version_tuple = (0, 0, 4)
 
-__commit_id__ = commit_id = 'ga1f28b971'
+__commit_id__ = commit_id = 'gdc15695f3'

{slack_objects-0.0.2.dev0 → slack_objects-0.0.4}/src/slack_objects/api_caller.py

@@ -1,5 +1,5 @@
 import time
-from typing import Any, Optional
+from typing import Optional
 
 from slack_sdk.errors import SlackApiError
 
@@ -15,10 +15,12 @@ class SlackApiCaller:
     """
     def __init__(self, cfg: SlackObjectsConfig, policy: RateLimitPolicy = DEFAULT_RATE_POLICY):
         self.cfg = cfg
-        self.policy = policy
+        # Respect cfg.default_rate_tier as the policy's fallback tier
+        self.policy = policy.with_default(cfg.default_rate_tier)
 
-    def call(self, client, method: str, *, rate_tier: Optional[RateTier] = None, use_json: bool = False, **kwargs) -> dict:
-        tier = rate_tier or self.policy.tier_for(method) or self.cfg.default_rate_tier
+    def call(self, client, method: str, *, rate_tier: Optional[RateTier] = None, use_json: bool = False, _retry_count: int = 0, **kwargs) -> dict:
+        MAX_RETRIES = 5
+        tier = rate_tier or self.policy.tier_for(method)
 
         try:
             if use_json:
@@ -27,16 +29,17 @@ class SlackApiCaller:
                 resp = client.api_call(method, params=kwargs)
 
             data = resp.data if hasattr(resp, "data") else resp
-
-            # Space out subsequent calls
             time.sleep(float(tier))
             return data
 
         except SlackApiError as e:
-            # Handle rate limiting properly
             if e.response is not None and e.response.status_code == 429:
-                retry_after = int(e.response.headers.get("Retry-After", tier))
+                if _retry_count >= MAX_RETRIES:
+                    raise RuntimeError(f"Rate-limited {MAX_RETRIES} times on {method}; giving up.") from e
+                try:
+                    retry_after = int(e.response.headers.get("Retry-After", tier))
+                except (ValueError, TypeError):
+                    retry_after = int(float(tier))
                 time.sleep(retry_after)
-                return self.call(client, method, rate_tier=tier, **kwargs)
-
+                return self.call(client, method, rate_tier=tier, use_json=use_json, _retry_count=_retry_count + 1, **kwargs)
             raise

slack_objects-0.0.4/src/slack_objects/base.py

@@ -0,0 +1,54 @@
+import logging
+from dataclasses import dataclass, field
+from typing import Any
+from slack_sdk import WebClient
+
+from .api_caller import SlackApiCaller
+from .config import SlackObjectsConfig
+from .rate_limits import DEFAULT_RATE_POLICY, RateLimitPolicy
+
+
+# Keys that are safe to include in error messages (never contain tokens)
+_SAFE_ERROR_KEYS = frozenset({"ok", "error", "needed", "provided", "response_metadata"})
+
+
+def safe_error_context(resp: Any, *, max_len: int = 300) -> str:
+    """
+    Return a truncated, token-free summary of an API response for use in exception messages.
+
+    Only well-known diagnostic keys are kept. The result is capped at *max_len* characters
+    to prevent massive payloads from flooding logs or error-tracking systems.
+    """
+    if isinstance(resp, dict):
+        summary = {k: v for k, v in resp.items() if k in _SAFE_ERROR_KEYS}
+    else:
+        summary = repr(resp)
+    text = str(summary)
+    return text[:max_len] + ("..." if len(text) > max_len else "")
+
+
+@dataclass
+class SlackObjectBase:
+    """
+    Base class that all object helpers inherit from.
+
+    Holds shared context so every object doesn't need to reinvent plumbing (i.e., don't need to pass cfg, client, logger, and the apicaller).
+    Logging is optional; a default package logger will be used if none is provided.
+    """
+    cfg: SlackObjectsConfig
+    client: WebClient
+    api: SlackApiCaller
+    logger: logging.Logger = field(default_factory=lambda: logging.getLogger("slack-objects"))  # logger is guaranteed to exist via default_factory
+    rate_policy: RateLimitPolicy = field(default=None)
+
+    def __post_init__(self) -> None:
+        # Required dependencies check
+        if self.cfg is None:
+            raise ValueError("cfg is required")
+        if self.client is None:
+            raise ValueError("client is required")
+        if self.api is None:
+            raise ValueError("api is required")
+        # Default rate_policy respects cfg.default_rate_tier as the fallback
+        if self.rate_policy is None:
+            self.rate_policy = DEFAULT_RATE_POLICY.with_default(self.cfg.default_rate_tier)

{slack_objects-0.0.2.dev0 → slack_objects-0.0.4}/src/slack_objects/client.py

@@ -31,20 +31,19 @@ class SlackObjectsClient:
         self.api = SlackApiCaller(cfg)
 
     def users(self, user_id: Optional[str] = None) -> Users:
-        base = Users(cfg=self.cfg, client=self.web_client, api=self.api, logger=self.logger)
-        return base if user_id is None else base.with_user(user_id)
+        return Users(cfg=self.cfg, client=self.web_client, api=self.api, logger=self.logger, user_id=user_id)
 
-    def conversations(self) -> Conversations:
-        return Conversations(cfg=self.cfg, client=self.web_client, api=self.api, logger=self.logger)
+    def conversations(self, channel_id: Optional[str] = None) -> Conversations:
+        return Conversations(cfg=self.cfg, client=self.web_client, api=self.api, logger=self.logger, channel_id=channel_id)
 
-    def files(self) -> Files:
-        return Files(cfg=self.cfg, client=self.web_client, api=self.api, logger=self.logger)
+    def files(self, file_id: Optional[str] = None) -> Files:
+        return Files(cfg=self.cfg, client=self.web_client, api=self.api, logger=self.logger, file_id=file_id)
 
-    def messages(self) -> Messages:
-        return Messages(cfg=self.cfg, client=self.web_client, api=self.api, logger=self.logger)
+    def messages(self, channel_id: Optional[str] = None, ts: Optional[str] = None) -> Messages:
+        return Messages(cfg=self.cfg, client=self.web_client, api=self.api, logger=self.logger, channel_id=channel_id, ts=ts)
 
-    def workspaces(self) -> Workspaces:
-        return Workspaces(cfg=self.cfg, client=self.web_client, api=self.api, logger=self.logger)
+    def workspaces(self, workspace_id: Optional[str] = None) -> Workspaces:
+        return Workspaces(cfg=self.cfg, client=self.web_client, api=self.api, logger=self.logger, workspace_id=workspace_id)
 
-    def idp_groups(self) -> IDP_groups:
-        return IDP_groups(cfg=self.cfg, client=self.web_client, api=self.api, logger=self.logger)
+    def idp_groups(self, group_id: Optional[str] = None) -> IDP_groups:
+        return IDP_groups(cfg=self.cfg, client=self.web_client, api=self.api, logger=self.logger, group_id=group_id)

slack_objects-0.0.4/src/slack_objects/config.py

@@ -0,0 +1,58 @@
+from enum import Enum
+from dataclasses import dataclass, field
+from typing import Optional
+
+
+class RateTier(float, Enum):
+	"""
+	Slack API rate-tier backoff defaults (seconds). These are defined to conform to Slack Web API rate limits.
+	https://docs.slack.dev/apis/web-api/rate-limits/
+	"""
+
+	TIER_1 = 60.0	# 1+ per minute
+	TIER_2 = 3.0	# 20+ per minute
+	TIER_3 = 1.2	# 50+ per minute
+	TIER_4 = 0.6	# 100+ per minute
+	TIER_D = 0.05	# 1200+ per minute
+
+
+@dataclass(frozen=True)
+class SlackObjectsConfig:
+	"""
+	Configuration settings for slack-objects.
+
+	Tokens are optional at construction time.
+	Individual methods will raise clear errors if a required token is missing.
+	"""
+	bot_token: Optional[str] = field(default=None, repr=False)
+	user_token: Optional[str] = field(default=None, repr=False)
+	scim_token: Optional[str] = field(default=None, repr=False)
+
+	default_rate_tier: RateTier = RateTier.TIER_2
+
+	auth_idp_groups_read_access: dict[str, list[str]] = field(default_factory=dict)
+	auth_idp_groups_write_access: dict[str, list[str]] = field(default_factory=dict)
+
+	# SCIM settings
+	scim_base_url: str = "https://api.slack.com/scim"
+	scim_version: str = "v2"
+
+	# HTTP timeout for SCIM and file-download requests (seconds)
+	http_timeout_seconds: int = 30
+
+	def __repr__(self) -> str:
+		""" Modifying the default dataclass __repr__ to mask token values for security. """
+		def _mask(val: Optional[str]) -> str:
+			return "***" if val else "None"
+		return (
+			f"SlackObjectsConfig("
+			f"bot_token={_mask(self.bot_token)}, "
+			f"user_token={_mask(self.user_token)}, "
+			f"scim_token={_mask(self.scim_token)}, "
+			f"default_rate_tier={self.default_rate_tier}, "
+			f"auth_idp_groups_read_access={self.auth_idp_groups_read_access}, "
+			f"auth_idp_groups_write_access={self.auth_idp_groups_write_access}, "
+			f"scim_base_url={self.scim_base_url}, "
+			f"scim_version={self.scim_version}, "
+			f"http_timeout_seconds={self.http_timeout_seconds})"
+		)

{slack_objects-0.0.2.dev0 → slack_objects-0.0.4}/src/slack_objects/conversations.py

@@ -30,10 +30,9 @@ Design goals:
 """
 
 from dataclasses import dataclass, field
-from typing import Any, Dict, List, Optional, Sequence, Union
+from typing import Any, Dict, List, Optional
 
-
-from .base import SlackObjectBase
+from .base import SlackObjectBase, safe_error_context
 from .config import RateTier
 from .messages import Messages
 
@@ -75,7 +74,7 @@ class Conversations(SlackObjectBase):
 
         resp = self.get_conversation_info(self.channel_id)
         if not resp.get("ok"):
-            raise RuntimeError(f"Conversations.get_conversation_info() failed: {resp}")
+            raise RuntimeError(f"Conversations.get_conversation_info() failed: {safe_error_context(resp)}")
 
         self.attributes = resp.get("channel") or {}
         return self.attributes

{slack_objects-0.0.2.dev0 → slack_objects-0.0.4}/src/slack_objects/files.py

@@ -1,4 +1,3 @@
-# src/slack_objects/files.py
 from __future__ import annotations
 
 """
@@ -25,7 +24,7 @@ This module provides file-centric behaviors:
 """
 
 from dataclasses import dataclass, field
-from typing import Any, Dict, Optional, Sequence, Union, List
+from typing import Any, Dict, Optional, Union
 
 import requests
 

{slack_objects-0.0.2.dev0 → slack_objects-0.0.4}/src/slack_objects/idp_groups.py

@@ -17,7 +17,7 @@ This module implements the following functionality:
 
 Design decisions
 ----------------
-- SCIM REST calls are centralized in `_scim_request()`; all public methods call those wrappers (keeps code modular and testable).
+- SCIM REST calls are centralized in ScimMixin._scim_request(); all public methods call endpoint wrappers.
 - Uses an injectable `requests.Session` (`scim_session`) so tests can pass a fake session.
 - Keeps legacy output shapes: lists of dicts for groups and members.
 """
@@ -25,16 +25,14 @@ Design decisions
 from dataclasses import dataclass, field
 from typing import Any, Dict, List, Optional
 
-import json
-import time
 import requests
 
 from .base import SlackObjectBase
-from .config import RateTier
+from .scim_base import ScimMixin, ScimResponse, validate_scim_id
 
 
 @dataclass
-class IDP_groups(SlackObjectBase):
+class IDP_groups(ScimMixin, SlackObjectBase):
     """
     IdP (SCIM) groups helper.
 
@@ -60,78 +58,26 @@ class IDP_groups(SlackObjectBase):
             scim_session=self.scim_session,
         )
 
-    # ---------- SCIM request wrapper ----------
-    def _scim_base_url(self, scim_version: str) -> str:
-        """Return configurable SCIM base URL; default to Slack SCIM endpoints when not overridden."""
-        if scim_version == "v2" and getattr(self.cfg, "scim_base_url_v2", None):
-            return self.cfg.scim_base_url_v2.rstrip("/") + "/"
-        if scim_version == "v1" and getattr(self.cfg, "scim_base_url_v1", None):
-            return self.cfg.scim_base_url_v1.rstrip("/") + "/"
-        return f"https://api.slack.com/scim/{scim_version}/"
-
-    def _scim_request(
-        self,
-        *,
-        path: str,
-        method: str = "GET",
-        payload: Optional[Dict[str, Any]] = None,
-        scim_version: str = "v1",
-        token: Optional[str] = None,
-        params: Optional[Dict[str, Any]] = None,
-    ) -> Dict[str, Any]:
-        """
-        Low-level SCIM request. Returns parsed JSON dict.
-
-        It raises ValueError when token is missing. Network/HTTP errors will raise requests exceptions.
-        We add a small sleep based on RateTier to reduce burstiness (keeps legacy cautious behavior).
-        """
-        tok = token or getattr(self.cfg, "scim_token", None)
-        if not tok:
-            raise ValueError("SCIM request requires cfg.scim_token (or token override)")
-
-        # conservative sleep to avoid bursts (can be tuned)
-        time.sleep(float(RateTier.TIER_2))
-
-        url = self._scim_base_url(scim_version) + path.lstrip("/")
-        headers = {
-            "Authorization": f"Bearer {tok}",
-            "Content-Type": "application/json; charset=utf-8",
-        }
-
-        resp = self.scim_session.request(
-            method=method.upper(),
-            url=url,
-            headers=headers,
-            params=params,
-            json=payload,
-            timeout=getattr(self.cfg, "http_timeout_seconds", 30),
-        )
-        resp.raise_for_status()
-        # best-effort JSON parse; return empty dict if no body
-        try:
-            return resp.json() if resp.text else {}
-        except Exception:
-            return {"_raw_text": resp.text or ""}
-
     # ---------- endpoint wrappers (only these call _scim_request) ----------
 
-    def _scim_groups_list(self, *, count: int = 1000, start_index: Optional[int] = None, scim_version: str = "v1") -> Dict[str, Any]:
+    def _scim_groups_list(self, *, count: int = 1000, start_index: Optional[int] = None) -> ScimResponse:
         """
         Wrapper for GET Groups (paginated).
         Accepts pagination params as query parameters according to Slack SCIM docs.
         """
-        params = {"count": count}
-        if start_index:
+        params: Dict[str, Any] = {"count": count}   # Number or records to return at a time. Maximum is 1000 https://api.slack.com/changelog/2019-06-have-scim-will-paginate#what
+        if start_index is not None:
             params["startIndex"] = start_index
-        return self._scim_request(path="Groups", method="GET", params=params, scim_version=scim_version)
+        return self._scim_request(path="Groups", method="GET", params=params)   # https://docs.slack.dev/reference/scim-api/#get-groups
 
-    def _scim_group_get(self, group_id: str, scim_version: str = "v1") -> Dict[str, Any]:
+    def _scim_group_get(self, group_id: str) -> ScimResponse:
         """Wrapper for GET Groups/{id}"""
-        return self._scim_request(path=f"Groups/{group_id}", method="GET", scim_version=scim_version)
+        validate_scim_id(group_id, "group_id")
+        return self._scim_request(path=f"Groups/{group_id}", method="GET")      # https://docs.slack.dev/reference/scim-api/#get-groups-id
 
     # ---------- public helpers ----------
 
-    def get_groups(self, scim_version: str = "v1", fetch_count: int = 1000) -> List[Dict[str, str]]:
+    def get_groups(self, fetch_count: int = 1000) -> List[Dict[str, str]]:
         """
         Return a list of IdP groups visible to the SCIM token.
 
@@ -147,7 +93,8 @@ class IDP_groups(SlackObjectBase):
         retrieved = 0
 
         while True:
-            resp = self._scim_groups_list(count=fetch_count, start_index=start_index, scim_version=scim_version)
+            scim_resp = self._scim_groups_list(count=fetch_count, start_index=start_index)
+            resp = scim_resp.data
 
             # Slack SCIM returns 'Resources' (list) and 'totalResults' and 'startIndex' values.
             resources = resp.get("Resources", []) or []
@@ -173,7 +120,7 @@ class IDP_groups(SlackObjectBase):
 
         return groups_out
 
-    def get_members(self, group_id: Optional[str] = None, scim_version: str = "v1") -> List[Dict[str, str]]:
+    def get_members(self, group_id: Optional[str] = None) -> List[Dict[str, str]]:
         """
         Return the members of a group as a list of dicts `{'value': <user_id>, 'display': <name>}`.
 
@@ -183,16 +130,16 @@ class IDP_groups(SlackObjectBase):
         if not gid:
             raise ValueError("get_members requires group_id (passed or bound)")
 
-        resp = self._scim_group_get(gid, scim_version=scim_version)
+        scim_resp = self._scim_group_get(gid)
         # In the legacy scripts, group members are at `members` in the response body
-        return resp.get("members", [])
+        return scim_resp.data.get("members", [])
 
-    def is_member(self, user_id: str, group_id: Optional[str] = None, scim_version: str = "v1") -> bool:
+    def is_member(self, user_id: str, group_id: Optional[str] = None) -> bool:
         """
         Return True if `user_id` is a member of `group_id`.
         Preserves legacy semantics (scans the members list).
         """
-        members = self.get_members(group_id=group_id, scim_version=scim_version)
+        members = self.get_members(group_id=group_id)
         for member in members:
             # member dicts historically had 'value' for id
             if member.get("value") == user_id:

{slack_objects-0.0.2.dev0 → slack_objects-0.0.4}/src/slack_objects/messages.py

@@ -16,15 +16,15 @@ Design goals:
     slack = SlackObjectsClient(cfg)
     msgs = slack.messages()                      # unbound
     msgs_c = slack.messages(channel_id="C123")   # bound to channel
-    msg = slack.messages("C123", "1700.12")      # bound to message
+    msg = slack.messages(channel_id="C123", ts="1700.12")   # bound to message
 - Modular:
     Only endpoint wrapper methods call self.api.call(...)
 - Practical:
     Provide common message operations: update/delete, thread replies, and block replacement.
 """
 
-from dataclasses import dataclass, field
-from typing import Any, Dict, List, Optional, Sequence
+from dataclasses import dataclass
+from typing import Any, Dict, List, Optional
 
 from .base import SlackObjectBase
 from .config import RateTier

{slack_objects-0.0.2.dev0 → slack_objects-0.0.4}/src/slack_objects/rate_limits.py

@@ -1,5 +1,5 @@
-from dataclasses import dataclass
-from typing import Optional, Mapping
+from dataclasses import dataclass, replace
+from typing import Mapping
 
 from .config import RateTier
 
@@ -15,6 +15,10 @@ class RateLimitPolicy:
     # fallback
     default: RateTier = RateTier.TIER_3
 
+    def with_default(self, tier: RateTier) -> "RateLimitPolicy":
+        """Return a copy of this policy with a different fallback tier."""
+        return replace(self, default=tier)
+
     def tier_for(self, method: str) -> RateTier:
         # 1) exact match wins
         if method in self.method_overrides: