orionapi 2.29.0__tar.gz → 2.30.2__tar.gz

{orionapi-2.29.0 → orionapi-2.30.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: orionapi
-Version: 2.29.0
+Version: 2.30.2
 Summary: A python interface for the Orion Advisors platform web API
 Author: spencerogden-dsam
 Author-email: 67068943+spencerogden-dsam@users.noreply.github.com

{orionapi-2.29.0 → orionapi-2.30.2}/orionapi/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "2.29.0"
+__version__ = "2.30.2"
 
 import logging
 import re
@@ -2810,6 +2810,11 @@ class EclipseV1(EclipseBase):
         """Get portfolio details by ID.
 
         Returns dict with 'general', 'teams', 'issues', 'summary' sections.
+        The 'general' section carries ``teamIds`` / ``primaryTeamId``. The
+        'teams' section's per-record field spelling is unspecified upstream
+        (``id`` vs ``teamId``, ``name`` vs ``teamName``) — accept both, or use
+        :meth:`get_portfolio_teams` for a normalized ``{id, name, is_primary}``
+        view.
         """
         res = self.api_request(f"{self.base_url}/portfolio/portfolios/{portfolio_id}")
         return res.json()
@@ -4838,46 +4843,46 @@ class EclipseV1(EclipseBase):
     def set_portfolio_tradeable(self, portfolio_id, tradeable=True, sync=True):
         """Set whether trading is allowed for a portfolio.
 
+        Uses the v2 ``setPortfolioTradeBlock`` action, which accepts only
+        ``{"id", "doNotTrade"}`` and therefore cannot touch any other portfolio
+        field. The older approach (GET the portfolio, rebuild the v1 PUT payload
+        by hand) rejected portfolios with no primary team and risked stripping
+        teams, trading instructions and auto-rebalance settings that the
+        rebuilt payload did not carry. Verified live 2026-09-10 on portfolio
+        209: the flag flips and every ``general``/``teams`` field is unchanged.
+
         Args:
             portfolio_id: Portfolio ID
             tradeable: True to allow trading, False to block (default True)
             sync: Wait for analytics to complete (default True)
 
         Returns:
-            dict: Updated portfolio details
+            dict: Updated portfolio details (same shape as :meth:`get_portfolio`)
         """
         if not isinstance(portfolio_id, int) or portfolio_id < 1:
             raise ValueError("portfolio_id must be a positive integer")
         if not isinstance(tradeable, bool):
             raise ValueError("tradeable must be a boolean")
 
-        # Get current portfolio to preserve other fields
-        portfolio = self.get_portfolio(portfolio_id)
-        general = portfolio.get("general", {})
-
-        # Build payload preserving existing fields
-        payload = {
-            "name": general.get("portfolioName"),
-            "modelId": general.get("modelId"),
-            "isSleevePortfolio": general.get("sleevePortfolio", False),
-            "doNotTrade": 0 if tradeable else 1,
-            "tags": general.get("tags", ""),
-            "teamIds": general.get("teamIds", []),
-            "primaryTeamId": general.get("primaryTeamId"),
-        }
-
-        res = self.api_request(
-            f"{self.base_url}/portfolio/portfolios/{portfolio_id}",
+        self.api_request(
+            f"{self.base_url_v2}/Portfolio/Portfolios/action/setPortfolioTradeBlock",
             requests.put,
-            json=payload,
+            json=[{"id": portfolio_id, "doNotTrade": not tradeable}],
         )
-        result = res.json()
+        result = self.get_portfolio(portfolio_id)
         self._maybe_wait_for_analytics(sync)
         return result
 
     def set_account_tradeable(self, account_id, trade_restriction="tradeable", sync=True):
         """Set trading restrictions for an account.
 
+        Uses the v2 ``setAccountTradeBlock`` action, which accepts only
+        ``{"id", "isDoNotBuySell", "isCustodialRestriction"}`` and therefore
+        cannot touch any other account field. The older approach rebuilt the
+        v1 ``PUT /account/accounts/{id}`` payload from ``generalSection`` of the
+        GET DTO, but the account DTO is flat (no ``generalSection``), so it was
+        sending ``accountName: null`` / ``portfolioId: null`` alongside the flags.
+
         Args:
             account_id: Internal Eclipse account ID
             trade_restriction: One of:
@@ -4887,7 +4892,8 @@ class EclipseV1(EclipseBase):
             sync: Wait for analytics to complete (default True)
 
         Returns:
-            dict: Updated account details
+            dict: Updated account details (same shape as :meth:`get_account_details`;
+            the flags are ``isDoNotBuySell`` and ``isCustodialRestriction``)
 
         Note:
             These are mutually exclusive options - only one can be active at a time.
@@ -4895,35 +4901,27 @@ class EclipseV1(EclipseBase):
         if not isinstance(account_id, int) or account_id < 1:
             raise ValueError("account_id must be a positive integer")
 
-        valid_restrictions = ["tradeable", "block_advisor", "block_custodian"]
-        if trade_restriction not in valid_restrictions:
-            raise ValueError(f"trade_restriction must be one of {valid_restrictions}")
-
-        # Get current account details
-        account = self.get_account_details(account_id)
-        general = account.get("generalSection", {})
-
-        # Build payload
-        payload = {
-            "accountName": general.get("accountName"),
-            "portfolioId": general.get("portfolioId"),
+        flags = {
+            "tradeable": (False, False),
+            "block_advisor": (True, False),
+            "block_custodian": (False, True),
         }
+        if trade_restriction not in flags:
+            raise ValueError(f"trade_restriction must be one of {list(flags)}")
+        do_not_buy_sell, custodial_restriction = flags[trade_restriction]
 
-        # Set flags based on restriction type
-        if trade_restriction == "tradeable":
-            payload["doNotTrade"] = 0
-            payload["doNotTradeCustodian"] = 0
-        elif trade_restriction == "block_advisor":
-            payload["doNotTrade"] = 1
-            payload["doNotTradeCustodian"] = 0
-        elif trade_restriction == "block_custodian":
-            payload["doNotTrade"] = 0
-            payload["doNotTradeCustodian"] = 1
-
-        res = self.api_request(
-            f"{self.base_url}/account/accounts/{account_id}", requests.put, json=payload
+        self.api_request(
+            f"{self.base_url_v2}/Account/Accounts/action/setAccountTradeBlock",
+            requests.put,
+            json=[
+                {
+                    "id": account_id,
+                    "isDoNotBuySell": do_not_buy_sell,
+                    "isCustodialRestriction": custodial_restriction,
+                }
+            ],
         )
-        result = res.json()
+        result = self.get_account_details(account_id)
         self._maybe_wait_for_analytics(sync)
         return result
 
@@ -6663,6 +6661,108 @@ class EclipseV1(EclipseBase):
             json=payload,
         ).json()
 
+    # --- Admin: Teams (v1 reads) ---
+    # The v1 team routes are the reliable team read on tenants where teams were
+    # not created with an externalId — EclipseV2.get_teams returns [] there
+    # (see its docstring). teamIds/primaryTeamId are required on the portfolio
+    # record, so these are the reads that unblock create_portfolio.
+
+    def get_teams(self, is_active=None):
+        """Get all teams (``GET /admin/teams``).
+
+        Args:
+            is_active: When set, passed as ``isActive`` (e.g. ``True`` returns
+                active teams only). When None (default), the parameter is
+                omitted and all teams are returned.
+
+        Returns:
+            list: Team dicts. At minimum ``{id, name}``; the full record also
+            carries ``portfolioAccess``, ``modelAccess``, ``status``,
+            ``numberOfUsers``, ``numberOfModels``, ``numberOfPortfolios``,
+            ``numberOfAdvisors``, ``isDeleted``, ``createdOn/By``,
+            ``editedOn/By``.
+        """
+        params = {}
+        if is_active is not None:
+            params["isActive"] = str(bool(is_active)).lower()
+        res = self.api_request(f"{self.base_url}/admin/teams", params=params)
+        return res.json()
+
+    def get_team(self, team_id):
+        """Get details for a single team (``GET /admin/teams/{id}``).
+
+        Args:
+            team_id: Eclipse team ID
+
+        Returns:
+            dict: Team detail record
+        """
+        res = self.api_request(f"{self.base_url}/admin/teams/{team_id}")
+        return res.json()
+
+    def get_team_portfolios(self, team_id):
+        """Get portfolios associated with a team (``GET /admin/teams/{id}/portfolios``).
+
+        Args:
+            team_id: Eclipse team ID
+
+        Returns:
+            list: Portfolio dicts (``{id, name, isDeleted, createdOn/By, editedOn/By}``)
+        """
+        res = self.api_request(f"{self.base_url}/admin/teams/{team_id}/portfolios")
+        return res.json()
+
+    def get_team_primary_portfolios(self, team_id):
+        """Get portfolios where the team is set as primary
+        (``GET /admin/teams/{id}/primaryPortfolios``).
+
+        Args:
+            team_id: Eclipse team ID
+
+        Returns:
+            list: Portfolio dicts (``{id, name, createdOn/By, editedOn/By}``)
+        """
+        res = self.api_request(f"{self.base_url}/admin/teams/{team_id}/primaryPortfolios")
+        return res.json()
+
+    def get_portfolio_teams(self, portfolio_id):
+        """Get the teams stamped on a portfolio, normalized.
+
+        Reads the ``teams`` section of ``GET /portfolio/portfolios/{id}``
+        (see :meth:`get_portfolio`) and normalizes each record to
+        ``{id, name, is_primary}``. Unlike the ``/admin/teams`` routes, this
+        works for a credential that is on no team at all, so it is the team
+        read of last resort for service accounts.
+
+        The upstream field spelling is unspecified (``id`` vs ``teamId``,
+        ``name`` vs ``teamName``), so both are accepted. ``is_primary`` is
+        derived from ``general.primaryTeamId`` when present, falling back to
+        the record's own ``isPrimaryTeam`` flag.
+
+        Args:
+            portfolio_id: Portfolio ID
+
+        Returns:
+            list: ``{id, name, is_primary}`` dicts, one per team on the portfolio
+        """
+        portfolio = self.get_portfolio(portfolio_id)
+        primary_team_id = portfolio.get("general", {}).get("primaryTeamId")
+        normalized = []
+        for team in portfolio.get("teams") or []:
+            team_id = team.get("id", team.get("teamId"))
+            if primary_team_id is not None:
+                is_primary = team_id == primary_team_id
+            else:
+                is_primary = bool(team.get("isPrimaryTeam"))
+            normalized.append(
+                {
+                    "id": team_id,
+                    "name": team.get("name", team.get("teamName")),
+                    "is_primary": is_primary,
+                }
+            )
+        return normalized
+
     # --- Admin token (v1) ---
 
     def get_firm_token(self, payload):
@@ -10107,13 +10207,19 @@ class EclipseV2(EclipseBase):
     # --- Team / ServiceTeams / User ---
 
     def get_teams(self, external_id=None):
-        """Get teams.
+        """Get teams (v2 ``Team/Team/GetTeams``).
+
+        Warning:
+            Returns ``[]`` (HTTP 200) on tenants where teams were not created
+            with an ``externalId`` — live-verified 2026-08-17. Prefer the v1
+            route (:meth:`EclipseV1.get_teams`, ``GET /admin/teams``), which
+            the :class:`Eclipse` unifier resolves to.
 
         Args:
             external_id: Optional external ID filter (maps to ``externalId``)
 
         Returns:
-            list: Team dicts
+            list: Team dicts (``{teamId, teamName, isPrimaryTeam, ...}``)
         """
         params = {}
         if external_id is not None:
@@ -11713,6 +11819,21 @@ class Eclipse(EclipseBase):
             internal_account_id=internal_account_id,
         )
 
+    # --- v1-preferred overrides (documented best-of-both choices) ----------------
+
+    def get_teams(self, is_active=None):
+        """Teams via the v1 route (best: v2 ``GetTeams`` is empty on some tenants).
+
+        Delegates to :meth:`EclipseV1.get_teams` (``GET /admin/teams``),
+        returning ``{id, name, ...}`` records. **Behavior change in 2.30.0:**
+        this name previously resolved to :meth:`EclipseV2.get_teams`, which
+        returns ``[]`` (with differently spelled ``{teamId, teamName,
+        isPrimaryTeam}`` records) on tenants where teams were not created with
+        an ``externalId``. Use ``self.v2.get_teams(external_id=...)`` for the
+        v2 surface explicitly.
+        """
+        return self.v1.get_teams(is_active=is_active)
+
 
 class EclipseAPI(Eclipse):
     """Deprecated alias of :class:`Eclipse` (best-of-both client).

{orionapi-2.29.0 → orionapi-2.30.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "orionapi"
-version = "2.29.0"
+version = "2.30.2"
 description = "A python interface for the Orion Advisors platform web API"
 authors = ["spencerogden-dsam <67068943+spencerogden-dsam@users.noreply.github.com>"]