slack-objects 0.1.2__tar.gz → 0.2.0__tar.gz

{slack_objects-0.1.2 → slack_objects-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: slack-objects
-Version: 0.1.2
+Version: 0.2.0
 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
@@ -198,3 +198,4 @@ explicit per-call tier → method-specific override → prefix rule → `default
 - `is_user_authorized` supports IdP-group-based authorization checks with configurable read/write access levels
 - SCIM user operations are available on `Users`: create, deactivate, reactivate, update attributes, update email, and convert to multi-channel guest
 - Discovery API is used for `Users.get_channels` and `Conversations.get_members` (requires appropriate token scopes)
+- `Users.get_channels(include_channels_user_left=True)` and `Conversations.get_members(include_members_who_left=True)` opt into historical data; both default to `False` so the common case makes fewer paginated calls

{slack_objects-0.1.2 → slack_objects-0.2.0}/README.md

@@ -176,4 +176,5 @@ explicit per-call tier → method-specific override → prefix rule → `default
 - `resolve_user_id` accepts flexible identifiers (user ID, email, or @username) and verifies existence via Web API + SCIM fallback
 - `is_user_authorized` supports IdP-group-based authorization checks with configurable read/write access levels
 - SCIM user operations are available on `Users`: create, deactivate, reactivate, update attributes, update email, and convert to multi-channel guest
-- Discovery API is used for `Users.get_channels` and `Conversations.get_members` (requires appropriate token scopes)
+- Discovery API is used for `Users.get_channels` and `Conversations.get_members` (requires appropriate token scopes)
+- `Users.get_channels(include_channels_user_left=True)` and `Conversations.get_members(include_members_who_left=True)` opt into historical data; both default to `False` so the common case makes fewer paginated calls

slack_objects-0.2.0/pytest.ini

@@ -0,0 +1,15 @@
+[pytest]
+pythonpath =
+    src
+
+# Test tiers
+# ----------
+# live: hits real Azure Key Vault + real Slack APIs. Applied automatically to
+#       every '*_live.py' file by tests/conftest.py. Some live tests (tests/SCIM)
+#       mutate real users, so they are NOT run by default.
+markers =
+    live: requires real credentials and makes live Slack API calls (deselected by default)
+
+# Deselect the live tier by default so a bare 'pytest' is safe to run.
+# Override with '-m live' (only live tests) or '-m "live or not live"' (everything).
+addopts = -m "not live"

{slack_objects-0.1.2 → slack_objects-0.2.0}/src/slack_objects/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '0.1.2'
-__version_tuple__ = version_tuple = (0, 1, 2)
+__version__ = version = '0.2.0'
+__version_tuple__ = version_tuple = (0, 2, 0)
 
-__commit_id__ = commit_id = 'ge0d1b7810'
+__commit_id__ = commit_id = 'g7fa644b5a'

{slack_objects-0.1.2 → slack_objects-0.2.0}/src/slack_objects/client.py

@@ -18,7 +18,7 @@ class SlackObjectsClient:
     Owns config, Slack client, and rate-limited API caller.
     """
 
-    def __init__(self, cfg: SlackObjectsConfig, logger: logging.Logger | None = None):
+    def __init__(self, cfg: SlackObjectsConfig, logger: Optional[logging.Logger] = None):
         self.cfg = cfg
         self.logger = logger or logging.getLogger("slack-objects")
 

{slack_objects-0.1.2 → slack_objects-0.2.0}/src/slack_objects/users.py

@@ -404,19 +404,39 @@ class Users(ScimMixin, SlackObjectBase):
 
     # ---------- discovery helper ----------
 
-    def get_channels(self, user_id: str, active_only: bool = True) -> List[Dict[str, Any]]:
+    def get_channels(self, user_id: str, include_channels_user_left: bool = False) -> List[Dict[str, Any]]:
         """
         discovery.user.conversations, paginated by offset.
 
+        Args:
+            user_id: The Slack user whose conversations should be listed.
+            include_channels_user_left: When True, also return channels the user
+                has left (those with a non-zero ``date_left``). Mirrors
+                ``Conversations.get_members(include_members_who_left=...)``.
+
+        Note:
+            Slack only returns channels the user has left when ``include_historical``
+            is sent, so this flag controls the *request* and not just local filtering.
+            Leaving it False keeps the common case cheaper: Slack returns fewer
+            channels, which also means fewer paginated calls.
+
         Returns:
             - If errors occur: a list of error dicts (legacy behavior preserved)
-            - Else: list of channels (active_only controls whether it filters to channels with date_left == 0)
+            - Else: the user's channels, including left channels only when
+              ``include_channels_user_left`` is True
         """
         current_channels: List[Dict[str, Any]] = []
         all_channels: List[Dict[str, Any]] = []
         errors: List[Dict[str, Any]] = []
 
-        payload: Dict[str, Any] = {"user": user_id, "limit": 1000}
+        payload: Dict[str, Any] = {
+            "user": user_id,
+            "limit": 1000,
+            # Sent explicitly in both states so the behavior does not depend on
+            # Slack's server-side default. The Slack SDK serializes booleans to
+            # "0"/"1", so False is transmitted correctly.
+            "include_historical": include_channels_user_left,
+        }
 
         while True:
             resp = self._discovery_user_conversations(payload)
@@ -428,6 +448,7 @@ class Users(ScimMixin, SlackObjectBase):
             channels = resp.get("channels") or []
             for ch in channels:
                 all_channels.append(ch)
+                # date_left is 0 for channels the user is still a member of.
                 if ch.get("date_left", 0) == 0:
                     current_channels.append(ch)
 
@@ -440,7 +461,9 @@ class Users(ScimMixin, SlackObjectBase):
         if errors:
             return errors  # preserve legacy behavior
 
-        return current_channels if active_only else all_channels
+        # The filter is a safety net: when include_historical is False Slack
+        # should not return left channels in the first place.
+        return all_channels if include_channels_user_left else current_channels
 
     # ============================================================
     # SCIM public methods (use inherited ScimMixin._scim_request)

{slack_objects-0.1.2 → slack_objects-0.2.0}/src/slack_objects.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: slack-objects
-Version: 0.1.2
+Version: 0.2.0
 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
@@ -198,3 +198,4 @@ explicit per-call tier → method-specific override → prefix rule → `default
 - `is_user_authorized` supports IdP-group-based authorization checks with configurable read/write access levels
 - SCIM user operations are available on `Users`: create, deactivate, reactivate, update attributes, update email, and convert to multi-channel guest
 - Discovery API is used for `Users.get_channels` and `Conversations.get_members` (requires appropriate token scopes)
+- `Users.get_channels(include_channels_user_left=True)` and `Conversations.get_members(include_members_who_left=True)` opt into historical data; both default to `False` so the common case makes fewer paginated calls

{slack_objects-0.1.2 → slack_objects-0.2.0}/src/slack_objects.egg-info/SOURCES.txt

@@ -26,7 +26,10 @@ src/slack_objects.egg-info/PKG-INFO
 src/slack_objects.egg-info/SOURCES.txt
 src/slack_objects.egg-info/dependency_links.txt
 src/slack_objects.egg-info/requires.txt
+src/slack_objects.egg-info/scm_file_list.json
+src/slack_objects.egg-info/scm_version.json
 src/slack_objects.egg-info/top_level.txt
+tests/conftest.py
 tests/live_test_config.example.json
 tests/Examples/examples_config.example.json
 tests/Examples/users_search_by_email_example.py

slack_objects-0.2.0/src/slack_objects.egg-info/scm_file_list.json

@@ -0,0 +1,68 @@
+{
+  "files": [
+    "pyproject.toml",
+    "LICENSE",
+    "README.md",
+    "pytest.ini",
+    ".gitignore",
+    ".github/copilot-instructions.md",
+    ".github/workflows/publish-testpypi.yml",
+    ".github/workflows/publish-pypi.yml",
+    ".github/workflows/ci.yml",
+    "tests/live_test_config.example.json",
+    "tests/conftest.py",
+    "tests/UnitTests/usergroups_test.py",
+    "tests/UnitTests/rate_limits_unit_test.py",
+    "tests/UnitTests/files_unit_test.py",
+    "tests/UnitTests/idp_groups_unit_test.py",
+    "tests/UnitTests/messages_unit_test.py",
+    "tests/UnitTests/workspaces_unit_test.py",
+    "tests/UnitTests/users_unit_test.py",
+    "tests/UnitTests/conversations_unit_test.py",
+    "tests/UnitTests/config_unit_test.py",
+    "tests/SCIM/test_scim_users_make_guest_live.py",
+    "tests/SCIM/test_scim_users_update_email_live.py",
+    "tests/SCIM/test_scim_users_reactivate_live.py",
+    "tests/SCIM/conftest_live.py",
+    "tests/SCIM/test_scim_users_update_attribute_live.py",
+    "tests/SCIM/test_scim_users_input_validation_live.py",
+    "tests/SCIM/run_all_scim_users_live_tests.py",
+    "tests/SCIM/test_scim_users_create_live.py",
+    "tests/SCIM/test_scim_users_deactivate_live.py",
+    "tests/SCIM/test_scim_idp_groups_live.py",
+    "tests/Smoke/idp_groups_smoke_test.py",
+    "tests/Smoke/security_smoke_test.py",
+    "tests/Smoke/api_caller_smoke_test.py",
+    "tests/Smoke/run_all_smoke.py",
+    "tests/Smoke/_smoke_harness.py",
+    "tests/Smoke/users_smoke_test.py",
+    "tests/Smoke/files_smoke_test.py",
+    "tests/Smoke/workspaces_smoke_test.py",
+    "tests/Smoke/conversations_smoke_test.py",
+    "tests/Smoke/messages_smoke_test.py",
+    "tests/Smoke/usergroups_smoke_test.py",
+    "tests/Users/test_users_read_live.py",
+    "tests/Users/conftest_live.py",
+    "tests/Users/test_users_input_validation_live.py",
+    "tests/Users/run_all_users_live_tests.py",
+    "tests/Users/test_users_classification_live.py",
+    "tests/Users/test_users_admin_live.py",
+    "tests/Examples/users_search_by_email_example.py",
+    "tests/Examples/users_test_AzureKeyVault.py",
+    "tests/Examples/examples_config.example.json",
+    "src/slack_objects/workspaces.py",
+    "src/slack_objects/usergroups.py",
+    "src/slack_objects/conversations.py",
+    "src/slack_objects/messages.py",
+    "src/slack_objects/users.py",
+    "src/slack_objects/config.py",
+    "src/slack_objects/__init__.py",
+    "src/slack_objects/client.py",
+    "src/slack_objects/files.py",
+    "src/slack_objects/api_caller.py",
+    "src/slack_objects/scim_base.py",
+    "src/slack_objects/rate_limits.py",
+    "src/slack_objects/base.py",
+    "src/slack_objects/idp_groups.py"
+  ]
+}

slack_objects-0.2.0/src/slack_objects.egg-info/scm_version.json

@@ -0,0 +1,8 @@
+{
+  "tag": "0.2.0",
+  "distance": 0,
+  "node": "g7fa644b5a865631efd38f980ea488ba704bda19a",
+  "dirty": false,
+  "branch": "HEAD",
+  "node_date": "2026-07-31"
+}

{slack_objects-0.1.2 → slack_objects-0.2.0}/tests/SCIM/run_all_scim_users_live_tests.py

@@ -49,7 +49,8 @@ def main() -> int:
         print(f"{'═' * 70}\n")
 
         rc = subprocess.call(
-            [sys.executable, "-m", "pytest", str(filepath), *extra_args],
+            # '-m live' re-enables the live tier, which pytest.ini deselects by default.
+            [sys.executable, "-m", "pytest", "-m", "live", str(filepath), *extra_args],
             cwd=str(_HERE.parent.parent),  # workspace root
         )
         results[filename] = rc

{slack_objects-0.1.2 → slack_objects-0.2.0}/tests/Smoke/users_smoke_test.py

@@ -136,8 +136,8 @@ def main() -> None:
         CallSpec("remove_from_conversation()", lambda: bound.remove_from_conversation("U1", "C1")),
 
         # Discovery helper
-        CallSpec("get_channels(active_only)", lambda: bound.get_channels("U1", active_only=True)),
-        CallSpec("get_channels(all)", lambda: bound.get_channels("U1", active_only=False)),
+        CallSpec("get_channels(current only)", lambda: bound.get_channels("U1")),
+        CallSpec("get_channels(including left)", lambda: bound.get_channels("U1", include_channels_user_left=True)),
 
         # Authorization helper
         CallSpec(

{slack_objects-0.1.2 → slack_objects-0.2.0}/tests/UnitTests/users_unit_test.py

@@ -663,3 +663,175 @@ class TestScimUpdateUserAttribute:
         users = _make_users()
         with pytest.raises(ValueError):
             users.scim_update_user_attribute(user_id="", attribute="active", new_value=False)
+
+
+# ═══════════════════════════════════════════════════════════════════════════
+# get_channels (discovery.user.conversations)
+# ═══════════════════════════════════════════════════════════════════════════
+
+class FakeDiscoveryWebClient:
+    """Fake discovery.user.conversations that honors include_historical.
+
+    Mirrors real Slack behavior confirmed against the Discovery API: channels the
+    user has left are returned ONLY when include_historical is truthy. The Slack
+    SDK serializes booleans to "0"/"1", so this accepts both forms.
+
+    Also records every payload it receives so tests can assert on the request.
+    """
+
+    CURRENT = [
+        {"id": "C001", "date_joined": 1665776256, "date_left": 0},
+        {"id": "C002", "date_joined": 1665776257, "date_left": 0},
+    ]
+    LEFT = [
+        {"id": "C900", "date_joined": 1665776258, "date_left": 1700000000},
+    ]
+
+    def __init__(self, paginate: bool = False):
+        self.payloads: list = []
+        self.paginate = paginate
+
+    @staticmethod
+    def _is_truthy(value) -> bool:
+        # Accept True, "1", and 1; the SDK converts booleans to "0"/"1".
+        return value in (True, 1, "1")
+
+    def api_call(self, method: str, json=None, params=None):
+        payload = json if json is not None else (params or {})
+
+        if method != "discovery.user.conversations":
+            return {"ok": True}
+
+        self.payloads.append(dict(payload))
+
+        include_historical = self._is_truthy(payload.get("include_historical"))
+        channels = list(self.CURRENT)
+        if include_historical:
+            channels += self.LEFT
+
+        # Emit two pages on the first call when pagination is being exercised.
+        if self.paginate and "offset" not in payload:
+            return {"ok": True, "channels": channels, "offset": "page2"}
+
+        return {"ok": True, "channels": channels}
+
+
+class FakeDiscoveryErrorWebClient:
+    """Fake that always fails, to exercise the legacy error-list behavior."""
+
+    def api_call(self, method: str, json=None, params=None):
+        if method == "discovery.user.conversations":
+            return {"ok": False, "error": "user_not_found"}
+        return {"ok": True}
+
+
+def _make_users_with_client(web_client):
+    """Helper: build a Users instance wired to a specific fake web client."""
+    cfg = SlackObjectsConfig(
+        bot_token="xoxb-fake",
+        user_token="xoxp-fake",
+        scim_token="xoxp-fake",
+        default_rate_tier=RateTier.TIER_3,
+    )
+    slack = SlackObjectsClient(cfg, logger=logging.getLogger("test"))
+    slack.web_client = web_client
+    slack.api = FakeApiCaller(cfg)
+    slack._users = None
+    return slack.users()
+
+
+class TestGetChannels:
+    """get_channels — include_channels_user_left controls the request, not just filtering."""
+
+    def test_default_does_not_request_historical(self):
+        """Default call must send include_historical=False.
+
+        This is the efficiency guarantee: the common case should not make Slack
+        return channels the user left only for them to be filtered out locally.
+        """
+        fake = FakeDiscoveryWebClient()
+        users = _make_users_with_client(fake)
+
+        users.get_channels("U1")
+
+        assert fake.payloads[0]["include_historical"] is False
+
+    def test_include_left_requests_historical(self):
+        """include_channels_user_left=True must send include_historical=True."""
+        fake = FakeDiscoveryWebClient()
+        users = _make_users_with_client(fake)
+
+        users.get_channels("U1", include_channels_user_left=True)
+
+        assert fake.payloads[0]["include_historical"] is True
+
+    def test_default_returns_only_current_channels(self):
+        """Default call returns just the channels the user is still in."""
+        users = _make_users_with_client(FakeDiscoveryWebClient())
+
+        result = users.get_channels("U1")
+
+        assert [c["id"] for c in result] == ["C001", "C002"]
+
+    def test_include_left_returns_current_and_left(self):
+        """include_channels_user_left=True returns left channels too."""
+        users = _make_users_with_client(FakeDiscoveryWebClient())
+
+        result = users.get_channels("U1", include_channels_user_left=True)
+
+        assert [c["id"] for c in result] == ["C001", "C002", "C900"]
+
+    def test_include_left_returns_more_than_default(self):
+        """The two modes must not return identical data (the original bug)."""
+        users = _make_users_with_client(FakeDiscoveryWebClient())
+
+        current = users.get_channels("U1")
+        including_left = users.get_channels("U1", include_channels_user_left=True)
+
+        assert len(including_left) > len(current)
+
+    def test_request_includes_user_and_limit(self):
+        """Payload keeps the documented user/limit parameters."""
+        fake = FakeDiscoveryWebClient()
+        users = _make_users_with_client(fake)
+
+        users.get_channels("U1")
+
+        assert fake.payloads[0]["user"] == "U1"
+        assert fake.payloads[0]["limit"] == 1000
+
+    def test_pagination_follows_offset(self):
+        """An offset in the response triggers another call and results accumulate."""
+        fake = FakeDiscoveryWebClient(paginate=True)
+        users = _make_users_with_client(fake)
+
+        result = users.get_channels("U1")
+
+        assert len(fake.payloads) == 2
+        assert fake.payloads[1]["offset"] == "page2"
+        assert len(result) == 4  # two current channels per page
+
+    def test_pagination_preserves_historical_flag(self):
+        """include_historical must persist across paginated requests."""
+        fake = FakeDiscoveryWebClient(paginate=True)
+        users = _make_users_with_client(fake)
+
+        users.get_channels("U1", include_channels_user_left=True)
+
+        assert all(p["include_historical"] is True for p in fake.payloads)
+
+    def test_api_error_returns_error_list(self):
+        """Legacy behavior: API failures come back as a list of error dicts."""
+        users = _make_users_with_client(FakeDiscoveryErrorWebClient())
+
+        result = users.get_channels("U1")
+
+        assert isinstance(result, list)
+        assert result[0]["message"] == "user_not_found"
+
+    def test_active_only_no_longer_accepted(self):
+        """The old active_only parameter was replaced and must not silently work."""
+        users = _make_users_with_client(FakeDiscoveryWebClient())
+
+        with pytest.raises(TypeError):
+            users.get_channels("U1", active_only=False)

{slack_objects-0.1.2 → slack_objects-0.2.0}/tests/Users/run_all_users_live_tests.py

@@ -45,7 +45,8 @@ def main() -> int:
         print(f"{'═' * 70}\n")
 
         rc = subprocess.call(
-            [sys.executable, "-m", "pytest", str(filepath)] + extra_args
+            # '-m live' re-enables the live tier, which pytest.ini deselects by default.
+            [sys.executable, "-m", "pytest", "-m", "live", str(filepath)] + extra_args
         )
         results[filename] = rc
 

{slack_objects-0.1.2 → slack_objects-0.2.0}/tests/Users/test_users_read_live.py

@@ -311,22 +311,33 @@ class TestGetChannels:
         assert isinstance(result, list)
         _pause()
 
-    def test_active_only_true_subset_of_all(self, ctx, users):
-        """active_only=True should return ≤ active_only=False."""
-        active = users.get_channels(ctx.active_member_id, active_only=True)
+    def test_current_only_subset_of_including_left(self, ctx, users):
+        """Default (current only) should return ≤ include_channels_user_left=True."""
+        current = users.get_channels(ctx.active_member_id)
         _pause()
-        all_ch = users.get_channels(ctx.active_member_id, active_only=False)
+        including_left = users.get_channels(ctx.active_member_id, include_channels_user_left=True)
         _pause()
-        assert len(active) <= len(all_ch), (
-            f"active_only ({len(active)}) should be ≤ all ({len(all_ch)})"
+        assert len(current) <= len(including_left), (
+            f"current only ({len(current)}) should be ≤ including left ({len(including_left)})"
         )
 
-    def test_active_only_false_returns_list(self, ctx, users):
-        """active_only=False should still return a list."""
-        result = users.get_channels(ctx.active_member_id, active_only=False)
+    def test_including_left_returns_list(self, ctx, users):
+        """include_channels_user_left=True should still return a list."""
+        result = users.get_channels(ctx.active_member_id, include_channels_user_left=True)
         assert isinstance(result, list)
         _pause()
 
+    def test_default_excludes_left_channels(self, ctx, users):
+        """Default call must not return channels the user has left.
+
+        Guards the regression where include_historical was never sent: the flag
+        controls the request, so a default call should contain no date_left != 0.
+        """
+        result = users.get_channels(ctx.active_member_id)
+        left = [c for c in result if c.get("date_left", 0) != 0]
+        assert not left, f"Default call returned {len(left)} channel(s) the user left"
+        _pause()
+
 
 # ═══════════════════════════════════════════════════════════════════════════
 # 6.  refresh

slack_objects-0.2.0/tests/conftest.py

@@ -0,0 +1,31 @@
+"""
+Shared pytest configuration for the whole test suite.
+
+The suite has two tiers:
+
+	Offline tier  - tests/UnitTests/*  (fakes only, no network, no credentials)
+	Live tier     - tests/**/*_live.py (real Azure Key Vault tokens + real Slack API calls)
+
+Every live test file follows the '*_live.py' naming convention, so instead of
+decorating hundreds of tests by hand, this hook marks them automatically at
+collection time.
+
+pytest.ini deselects the 'live' marker by default, which makes a bare 'pytest'
+run safe: it collects only the offline tier. The live tier is opt-in, since some
+of it (notably tests/SCIM) performs mutating operations against real users.
+
+To run the live tier explicitly:
+
+	pytest -m live tests/Users/test_users_read_live.py
+	python tests/Users/run_all_users_live_tests.py
+"""
+
+import pytest
+
+
+def pytest_collection_modifyitems(config, items):
+	"""Automatically apply the 'live' marker to tests in *_live.py files."""
+	for item in items:
+		# item.path is the file the test was collected from.
+		if item.path is not None and item.path.name.endswith("_live.py"):
+			item.add_marker(pytest.mark.live)

slack_objects-0.1.2/pytest.ini

@@ -1,3 +0,0 @@
-[pytest]
-pythonpath =
-    src