wandb 0.19.1__py3-none-musllinux_1_2_aarch64.whl

wandb/apis/public/sweeps.py

@@ -0,0 +1,240 @@
+"""Public API: sweeps."""
+
+import urllib
+from typing import Optional
+
+from wandb_gql import gql
+
+import wandb
+from wandb import util
+from wandb.apis import public
+from wandb.apis.attrs import Attrs
+from wandb.sdk.lib import ipython
+
+SWEEP_FRAGMENT = """fragment SweepFragment on Sweep {
+    id
+    name
+    method
+    state
+    description
+    displayName
+    bestLoss
+    config
+    createdAt
+    updatedAt
+    runCount
+}
+"""
+
+
+class Sweep(Attrs):
+    """A set of runs associated with a sweep.
+
+    Examples:
+        Instantiate with:
+        ```
+        api = wandb.Api()
+        sweep = api.sweep(path / to / sweep)
+        ```
+
+    Attributes:
+        runs: (`Runs`) list of runs
+        id: (str) sweep id
+        project: (str) name of project
+        config: (str) dictionary of sweep configuration
+        state: (str) the state of the sweep
+        expected_run_count: (int) number of expected runs for the sweep
+    """
+
+    QUERY = gql(
+        """
+    query Sweep($project: String, $entity: String, $name: String!) {
+        project(name: $project, entityName: $entity) {
+            sweep(sweepName: $name) {
+                id
+                name
+                state
+                runCountExpected
+                bestLoss
+                config
+            }
+        }
+    }
+    """
+    )
+
+    LEGACY_QUERY = gql(
+        """
+    query Sweep($project: String, $entity: String, $name: String!) {
+        project(name: $project, entityName: $entity) {
+            sweep(sweepName: $name) {
+                id
+                name
+                state
+                bestLoss
+                config
+            }
+        }
+    }
+    """
+    )
+
+    def __init__(self, client, entity, project, sweep_id, attrs=None):
+        # TODO: Add agents / flesh this out.
+        super().__init__(dict(attrs or {}))
+        self.client = client
+        self._entity = entity
+        self.project = project
+        self.id = sweep_id
+        self.runs = []
+
+        self.load(force=not attrs)
+
+    @property
+    def entity(self):
+        return self._entity
+
+    @property
+    def username(self):
+        wandb.termwarn("Sweep.username is deprecated. please use Sweep.entity instead.")
+        return self._entity
+
+    @property
+    def config(self):
+        return util.load_yaml(self._attrs["config"])
+
+    def load(self, force: bool = False):
+        if force or not self._attrs:
+            sweep = self.get(self.client, self.entity, self.project, self.id)
+            if sweep is None:
+                raise ValueError("Could not find sweep {}".format(self))
+            self._attrs = sweep._attrs
+            self.runs = sweep.runs
+
+        return self._attrs
+
+    @property
+    def order(self):
+        if self._attrs.get("config") and self.config.get("metric"):
+            sort_order = self.config["metric"].get("goal", "minimize")
+            prefix = "+" if sort_order == "minimize" else "-"
+            return public.QueryGenerator.format_order_key(
+                prefix + self.config["metric"]["name"]
+            )
+
+    def best_run(self, order=None):
+        """Return the best run sorted by the metric defined in config or the order passed in."""
+        if order is None:
+            order = self.order
+        else:
+            order = public.QueryGenerator.format_order_key(order)
+        if order is None:
+            wandb.termwarn(
+                "No order specified and couldn't find metric in sweep config, returning most recent run"
+            )
+        else:
+            wandb.termlog("Sorting runs by {}".format(order))
+        filters = {"$and": [{"sweep": self.id}]}
+        try:
+            return public.Runs(
+                self.client,
+                self.entity,
+                self.project,
+                order=order,
+                filters=filters,
+                per_page=1,
+            )[0]
+        except IndexError:
+            return None
+
+    @property
+    def expected_run_count(self) -> Optional[int]:
+        """Return the number of expected runs in the sweep or None for infinite runs."""
+        return self._attrs.get("runCountExpected")
+
+    @property
+    def path(self):
+        return [
+            urllib.parse.quote_plus(str(self.entity)),
+            urllib.parse.quote_plus(str(self.project)),
+            urllib.parse.quote_plus(str(self.id)),
+        ]
+
+    @property
+    def url(self):
+        path = self.path
+        path.insert(2, "sweeps")
+        return self.client.app_url + "/".join(path)
+
+    @property
+    def name(self):
+        return self.config.get("name") or self.id
+
+    @classmethod
+    def get(
+        cls,
+        client,
+        entity=None,
+        project=None,
+        sid=None,
+        order=None,
+        query=None,
+        **kwargs,
+    ):
+        """Execute a query against the cloud backend."""
+        if query is None:
+            query = cls.QUERY
+
+        variables = {
+            "entity": entity,
+            "project": project,
+            "name": sid,
+        }
+        variables.update(kwargs)
+
+        response = None
+        try:
+            response = client.execute(query, variable_values=variables)
+        except Exception:
+            # Don't handle exception, rely on legacy query
+            # TODO(gst): Implement updated introspection workaround
+            query = cls.LEGACY_QUERY
+            response = client.execute(query, variable_values=variables)
+
+        if (
+            not response
+            or not response.get("project")
+            or not response["project"].get("sweep")
+        ):
+            return None
+
+        sweep_response = response["project"]["sweep"]
+        sweep = cls(client, entity, project, sid, attrs=sweep_response)
+        sweep.runs = public.Runs(
+            client,
+            entity,
+            project,
+            order=order,
+            per_page=10,
+            filters={"$and": [{"sweep": sweep.id}]},
+        )
+
+        return sweep
+
+    def to_html(self, height=420, hidden=False):
+        """Generate HTML containing an iframe displaying this sweep."""
+        url = self.url + "?jupyter=true"
+        style = f"border:none;width:100%;height:{height}px;"
+        prefix = ""
+        if hidden:
+            style += "display:none;"
+            prefix = ipython.toggle_button("sweep")
+        return prefix + f"<iframe src={url!r} style={style!r}></iframe>"
+
+    def _repr_html_(self) -> str:
+        return self.to_html()
+
+    def __repr__(self):
+        return "<Sweep {} ({})>".format(
+            "/".join(self.path), self._attrs.get("state", "Unknown State")
+        )

wandb/apis/public/teams.py

@@ -0,0 +1,198 @@
+"""Public API: teams."""
+
+import requests
+from wandb_gql import gql
+
+from wandb.apis.attrs import Attrs
+
+
+class Member(Attrs):
+    DELETE_MEMBER_MUTATION = gql(
+        """
+    mutation DeleteInvite($id: String, $entityName: String) {
+        deleteInvite(input: {id: $id, entityName: $entityName}) {
+            success
+        }
+    }
+  """
+    )
+
+    def __init__(self, client, team, attrs):
+        super().__init__(attrs)
+        self._client = client
+        self.team = team
+
+    def delete(self):
+        """Remove a member from a team.
+
+        Returns:
+            Boolean indicating success
+        """
+        try:
+            return self._client.execute(
+                self.DELETE_MEMBER_MUTATION, {"id": self.id, "entityName": self.team}
+            )["deleteInvite"]["success"]
+        except requests.exceptions.HTTPError:
+            return False
+
+    def __repr__(self):
+        return f"<Member {self.name} ({self.account_type})>"
+
+
+class Team(Attrs):
+    CREATE_TEAM_MUTATION = gql(
+        """
+    mutation CreateTeam($teamName: String!, $teamAdminUserName: String) {
+        createTeam(input: {teamName: $teamName, teamAdminUserName: $teamAdminUserName}) {
+            entity {
+                id
+                name
+                available
+                photoUrl
+                limits
+            }
+        }
+    }
+    """
+    )
+    CREATE_INVITE_MUTATION = gql(
+        """
+    mutation CreateInvite($entityName: String!, $email: String, $username: String, $admin: Boolean) {
+        createInvite(input: {entityName: $entityName, email: $email, username: $username, admin: $admin}) {
+            invite {
+                id
+                name
+                email
+                createdAt
+                toUser {
+                    name
+                }
+            }
+        }
+    }
+    """
+    )
+    TEAM_QUERY = gql(
+        """
+    query Entity($name: String!) {
+        entity(name: $name) {
+            id
+            name
+            available
+            photoUrl
+            readOnly
+            readOnlyAdmin
+            isTeam
+            privateOnly
+            storageBytes
+            codeSavingEnabled
+            defaultAccess
+            isPaid
+            members {
+                id
+                admin
+                pending
+                email
+                username
+                name
+                photoUrl
+                accountType
+                apiKey
+            }
+        }
+    }
+    """
+    )
+    CREATE_SERVICE_ACCOUNT_MUTATION = gql(
+        """
+    mutation CreateServiceAccount($entityName: String!, $description: String!) {
+        createServiceAccount(
+            input: {description: $description, entityName: $entityName}
+        ) {
+            user {
+                id
+            }
+        }
+    }
+    """
+    )
+
+    def __init__(self, client, name, attrs=None):
+        super().__init__(attrs or {})
+        self._client = client
+        self.name = name
+        self.load()
+
+    @classmethod
+    def create(cls, api, team, admin_username=None):
+        """Create a new team.
+
+        Args:
+            api: (`Api`) The api instance to use
+            team: (str) The name of the team
+            admin_username: (str) optional username of the admin user of the team, defaults to the current user.
+
+        Returns:
+            A `Team` object
+        """
+        try:
+            api.client.execute(
+                cls.CREATE_TEAM_MUTATION,
+                {"teamName": team, "teamAdminUserName": admin_username},
+            )
+        except requests.exceptions.HTTPError:
+            pass
+        return Team(api.client, team)
+
+    def invite(self, username_or_email, admin=False):
+        """Invite a user to a team.
+
+        Args:
+            username_or_email: (str) The username or email address of the user you want to invite
+            admin: (bool) Whether to make this user a team admin, defaults to False
+
+        Returns:
+            True on success, False if user was already invited or didn't exist
+        """
+        variables = {"entityName": self.name, "admin": admin}
+        if "@" in username_or_email:
+            variables["email"] = username_or_email
+        else:
+            variables["username"] = username_or_email
+        try:
+            self._client.execute(self.CREATE_INVITE_MUTATION, variables)
+        except requests.exceptions.HTTPError:
+            return False
+        return True
+
+    def create_service_account(self, description):
+        """Create a service account for the team.
+
+        Args:
+            description: (str) A description for this service account
+
+        Returns:
+            The service account `Member` object, or None on failure
+        """
+        try:
+            self._client.execute(
+                self.CREATE_SERVICE_ACCOUNT_MUTATION,
+                {"description": description, "entityName": self.name},
+            )
+            self.load(True)
+            return self.members[-1]
+        except requests.exceptions.HTTPError:
+            return None
+
+    def load(self, force=False):
+        if force or not self._attrs:
+            response = self._client.execute(self.TEAM_QUERY, {"name": self.name})
+            self._attrs = response["entity"]
+            self._attrs["members"] = [
+                Member(self._client, self.name, member)
+                for member in self._attrs["members"]
+            ]
+        return self._attrs
+
+    def __repr__(self):
+        return f"<Team {self.name}>"

wandb/apis/public/users.py

@@ -0,0 +1,136 @@
+"""Public API: users."""
+
+import requests
+from wandb_gql import gql
+
+import wandb
+from wandb.apis.attrs import Attrs
+
+
+class User(Attrs):
+    CREATE_USER_MUTATION = gql(
+        """
+    mutation CreateUserFromAdmin($email: String!, $admin: Boolean) {
+        createUser(input: {email: $email, admin: $admin}) {
+            user {
+                id
+                name
+                username
+                email
+                admin
+            }
+        }
+    }
+        """
+    )
+
+    DELETE_API_KEY_MUTATION = gql(
+        """
+    mutation DeleteApiKey($id: String!) {
+        deleteApiKey(input: {id: $id}) {
+            success
+        }
+    }
+        """
+    )
+    GENERATE_API_KEY_MUTATION = gql(
+        """
+    mutation GenerateApiKey($description: String) {
+        generateApiKey(input: {description: $description}) {
+            apiKey {
+                id
+                name
+            }
+        }
+    }
+        """
+    )
+
+    def __init__(self, client, attrs):
+        super().__init__(attrs)
+        self._client = client
+        self._user_api = None
+
+    @property
+    def user_api(self):
+        """An instance of the api using credentials from the user."""
+        if self._user_api is None and len(self.api_keys) > 0:
+            self._user_api = wandb.Api(api_key=self.api_keys[0])
+        return self._user_api
+
+    @classmethod
+    def create(cls, api, email, admin=False):
+        """Create a new user.
+
+        Args:
+            api: (`Api`) The api instance to use
+            email: (str) The name of the team
+            admin: (bool) Whether this user should be a global instance admin
+
+        Returns:
+            A `User` object
+        """
+        res = api.client.execute(
+            cls.CREATE_USER_MUTATION,
+            {"email": email, "admin": admin},
+        )
+        return User(api.client, res["createUser"]["user"])
+
+    @property
+    def api_keys(self):
+        if self._attrs.get("apiKeys") is None:
+            return []
+        return [k["node"]["name"] for k in self._attrs["apiKeys"]["edges"]]
+
+    @property
+    def teams(self):
+        if self._attrs.get("teams") is None:
+            return []
+        return [k["node"]["name"] for k in self._attrs["teams"]["edges"]]
+
+    def delete_api_key(self, api_key):
+        """Delete a user's api key.
+
+        Returns:
+            Boolean indicating success
+
+        Raises:
+            ValueError if the api_key couldn't be found
+        """
+        idx = self.api_keys.index(api_key)
+        try:
+            self._client.execute(
+                self.DELETE_API_KEY_MUTATION,
+                {"id": self._attrs["apiKeys"]["edges"][idx]["node"]["id"]},
+            )
+        except requests.exceptions.HTTPError:
+            return False
+        return True
+
+    def generate_api_key(self, description=None):
+        """Generate a new api key.
+
+        Returns:
+            The new api key, or None on failure
+        """
+        try:
+            # We must make this call using credentials from the original user
+            key = self.user_api.client.execute(
+                self.GENERATE_API_KEY_MUTATION, {"description": description}
+            )["generateApiKey"]["apiKey"]
+            self._attrs["apiKeys"]["edges"].append({"node": key})
+            return key["name"]
+        except (requests.exceptions.HTTPError, AttributeError):
+            return None
+
+    def __repr__(self):
+        if "email" in self._attrs:
+            return f"<User {self._attrs['email']}>"
+        elif "username" in self._attrs:
+            return f"<User {self._attrs['username']}>"
+        elif "id" in self._attrs:
+            return f"<User {self._attrs['id']}>"
+        elif "name" in self._attrs:
+            return f"<User {self._attrs['name']!r}>"
+        else:
+            return "<User ???>"

wandb/apis/public/utils.py

@@ -0,0 +1,68 @@
+import re
+from enum import Enum
+from urllib.parse import urlparse
+
+from wandb.sdk.artifacts._validators import is_artifact_registry_project
+
+
+def parse_s3_url_to_s3_uri(url) -> str:
+    """Convert an S3 HTTP(S) URL to an S3 URI.
+
+    Arguments:
+        url (str): The S3 URL to convert, in the format
+                   'http(s)://<bucket>.s3.<region>.amazonaws.com/<key>'.
+                   or 'http(s)://<bucket>.s3.amazonaws.com/<key>'
+
+    Returns:
+        str: The corresponding S3 URI in the format 's3://<bucket>/<key>'.
+
+    Raises:
+        ValueError: If the provided URL is not a valid S3 URL.
+    """
+    # Regular expression to match S3 URL pattern
+    s3_pattern = r"^https?://.*s3.*amazonaws\.com.*"
+    parsed_url = urlparse(url)
+
+    # Check if it's an S3 URL
+    match = re.match(s3_pattern, parsed_url.geturl())
+    if not match:
+        raise ValueError("Invalid S3 URL")
+
+    # Extract bucket name and key
+    bucket_name, *_ = parsed_url.netloc.split(".")
+    key = parsed_url.path.lstrip("/")
+
+    # Construct the S3 URI
+    s3_uri = f"s3://{bucket_name}/{key}"
+
+    return s3_uri
+
+
+class PathType(Enum):
+    """We have lots of different paths users pass in to fetch artifacts, projects, etc.
+
+    This enum is used for specifying what format the path is in given a string path.
+    """
+
+    PROJECT = "PROJECT"
+    ARTIFACT = "ARTIFACT"
+
+
+def parse_org_from_registry_path(path: str, path_type: PathType) -> str:
+    """Parse the org from a registry path.
+
+    Essentially fetching the "entity" from the path but for Registries the entity is actually the org.
+
+    Args:
+        path (str): The path to parse. Can be a project path <entity>/<project> or <project> or an
+        artifact path like <entity>/<project>/<artifact> or <project>/<artifact> or <artifact>
+        path_type (PathType): The type of path to parse.
+    """
+    parts = path.split("/")
+    expected_parts = 3 if path_type == PathType.ARTIFACT else 2
+
+    if len(parts) >= expected_parts:
+        org, project = parts[:2]
+        if is_artifact_registry_project(project):
+            return org
+    return ""

wandb/apis/reports/__init__.py

@@ -0,0 +1 @@
+from .v2 import *  # noqa: F403

wandb/apis/reports/v1/__init__.py

@@ -0,0 +1,8 @@
+import wandb
+
+try:
+    from wandb_workspaces.reports.v1 import *  # noqa: F403
+except ImportError:
+    wandb.termerror(
+        "Failed to import wandb_workspaces.  To edit reports programatically, please install it using `pip install wandb[workspaces]`."
+    )

wandb/apis/reports/v2/__init__.py

@@ -0,0 +1,8 @@
+import wandb
+
+try:
+    from wandb_workspaces.reports.v2 import *  # noqa: F403
+except ImportError:
+    wandb.termerror(
+        "Failed to import wandb_workspaces.  To edit reports programatically, please install it using `pip install wandb[workspaces]`."
+    )

wandb/apis/workspaces/__init__.py

@@ -0,0 +1,8 @@
+import wandb
+
+try:
+    from wandb_workspaces.workspaces import *  # noqa: F403
+except ImportError:
+    wandb.termerror(
+        "Failed to import wandb_workspaces. To edit workspaces programatically, please install it using `pip install wandb[workspaces]`."
+    )