arize-phoenix 4.14.1__py3-none-any.whl → 4.16.0__py3-none-any.whl

phoenix/server/api/routers/v1/dataset_examples.py

@@ -1,178 +0,0 @@
-from sqlalchemy import and_, func, select
-from starlette.requests import Request
-from starlette.responses import JSONResponse, Response
-from starlette.status import HTTP_404_NOT_FOUND
-from strawberry.relay import GlobalID
-
-from phoenix.db.models import Dataset, DatasetExample, DatasetExampleRevision, DatasetVersion
-
-
-async def list_dataset_examples(request: Request) -> Response:
-    """
-    summary: Get dataset examples by dataset ID
-    operationId: getDatasetExamples
-    tags:
-      - datasets
-    parameters:
-      - in: path
-        name: id
-        required: true
-        schema:
-          type: string
-        description: Dataset ID
-      - in: query
-        name: version_id
-        schema:
-          type: string
-        description: Dataset version ID. If omitted, returns the latest version.
-    responses:
-      200:
-        description: Success
-        content:
-          application/json:
-            schema:
-              type: object
-              properties:
-                data:
-                  type: object
-                  properties:
-                    dataset_id:
-                      type: string
-                      description: ID of the dataset
-                    version_id:
-                      type: string
-                      description: ID of the version
-                    examples:
-                      type: array
-                      items:
-                        type: object
-                        properties:
-                          id:
-                            type: string
-                            description: ID of the dataset example
-                          input:
-                            type: object
-                            description: Input data of the example
-                          output:
-                            type: object
-                            description: Output data of the example
-                          metadata:
-                            type: object
-                            description: Metadata of the example
-                          updated_at:
-                            type: string
-                            format: date-time
-                            description: ISO formatted timestamp of when the example was updated
-                        required:
-                          - id
-                          - input
-                          - output
-                          - metadata
-                          - updated_at
-                  required:
-                    - dataset_id
-                    - version_id
-                    - examples
-      403:
-        description: Forbidden
-      404:
-        description: Dataset does not exist.
-    """
-    dataset_id = GlobalID.from_id(request.path_params["id"])
-    raw_version_id = request.query_params.get("version_id")
-    version_id = GlobalID.from_id(raw_version_id) if raw_version_id else None
-
-    if (dataset_type := dataset_id.type_name) != "Dataset":
-        return Response(
-            content=f"ID {dataset_id} refers to a {dataset_type}", status_code=HTTP_404_NOT_FOUND
-        )
-
-    if version_id and (version_type := version_id.type_name) != "DatasetVersion":
-        return Response(
-            content=f"ID {version_id} refers to a {version_type}", status_code=HTTP_404_NOT_FOUND
-        )
-
-    async with request.app.state.db() as session:
-        if (
-            resolved_dataset_id := await session.scalar(
-                select(Dataset.id).where(Dataset.id == int(dataset_id.node_id))
-            )
-        ) is None:
-            return Response(
-                content=f"No dataset with id {dataset_id} can be found.",
-                status_code=HTTP_404_NOT_FOUND,
-            )
-
-        # Subquery to find the maximum created_at for each dataset_example_id
-        # timestamp tiebreaks are resolved by the largest id
-        partial_subquery = select(
-            func.max(DatasetExampleRevision.id).label("max_id"),
-        ).group_by(DatasetExampleRevision.dataset_example_id)
-
-        if version_id:
-            if (
-                resolved_version_id := await session.scalar(
-                    select(DatasetVersion.id).where(
-                        and_(
-                            DatasetVersion.dataset_id == resolved_dataset_id,
-                            DatasetVersion.id == int(version_id.node_id),
-                        )
-                    )
-                )
-            ) is None:
-                return Response(
-                    content=f"No dataset version with id {version_id} can be found.",
-                    status_code=HTTP_404_NOT_FOUND,
-                )
-            # if a version_id is provided, filter the subquery to only include revisions from that
-            partial_subquery = partial_subquery.filter(
-                DatasetExampleRevision.dataset_version_id <= resolved_version_id
-            )
-        else:
-            if (
-                resolved_version_id := await session.scalar(
-                    select(func.max(DatasetVersion.id)).where(
-                        DatasetVersion.dataset_id == resolved_dataset_id
-                    )
-                )
-            ) is None:
-                return Response(
-                    content="Dataset has no versions.",
-                    status_code=HTTP_404_NOT_FOUND,
-                )
-
-        subquery = partial_subquery.subquery()
-        # Query for the most recent example revisions that are not deleted
-        query = (
-            select(DatasetExample, DatasetExampleRevision)
-            .join(
-                DatasetExampleRevision,
-                DatasetExample.id == DatasetExampleRevision.dataset_example_id,
-            )
-            .join(
-                subquery,
-                (subquery.c.max_id == DatasetExampleRevision.id),
-            )
-            .filter(DatasetExample.dataset_id == resolved_dataset_id)
-            .filter(DatasetExampleRevision.revision_kind != "DELETE")
-            .order_by(DatasetExample.id.asc())
-        )
-        examples = [
-            {
-                "id": str(GlobalID("DatasetExample", str(example.id))),
-                "input": revision.input,
-                "output": revision.output,
-                "metadata": revision.metadata_,
-                "updated_at": revision.created_at.isoformat(),
-            }
-            async for example, revision in await session.stream(query)
-        ]
-    return JSONResponse(
-        {
-            "data": {
-                "dataset_id": str(GlobalID("Dataset", str(resolved_dataset_id))),
-                "version_id": str(GlobalID("DatasetVersion", str(resolved_version_id))),
-                "examples": examples,
-            }
-        }
-    )

phoenix/server/openapi/docs.py

@@ -1,221 +0,0 @@
-import json
-from typing import Any, Dict, Optional
-
-from starlette.responses import HTMLResponse
-
-swagger_ui_default_parameters: Dict[str, Any] = {
-    "dom_id": "#swagger-ui",
-    "layout": "BaseLayout",
-    "deepLinking": True,
-    "showExtensions": True,
-    "showCommonExtensions": True,
-}
-
-
-def get_swagger_ui_html(
-    *,
-    openapi_url: str = "/schema",
-    title: str,
-    swagger_js_url: str = "https://cdn.jsdelivr.net/npm/swagger-ui-dist@5.9.0/swagger-ui-bundle.js",
-    swagger_css_url: str = "https://cdn.jsdelivr.net/npm/swagger-ui-dist@5.9.0/swagger-ui.css",
-    swagger_favicon_url: str = "/favicon.ico",
-    oauth2_redirect_url: Optional[str] = None,
-    init_oauth: Optional[str] = None,
-    swagger_ui_parameters: Optional[Dict[str, Any]] = None,
-) -> HTMLResponse:
-    """
-    Generate and return the HTML  that loads Swagger UI for the interactive API
-    docs (normally served at `/docs`).
-    """
-    current_swagger_ui_parameters = swagger_ui_default_parameters.copy()
-    if swagger_ui_parameters:
-        current_swagger_ui_parameters.update(swagger_ui_parameters)
-
-    html = f"""
-    <!DOCTYPE html>
-    <html>
-    <head>
-    <link type="text/css" rel="stylesheet" href="{swagger_css_url}">
-    <link rel="shortcut icon" href="{swagger_favicon_url}">
-    <title>{title}</title>
-    </head>
-    <body>
-    <div id="swagger-ui">
-    </div>
-    <script src="{swagger_js_url}"></script>
-    <style type="text/css">
-    div[id^="operations-private"]{{display:none}} #operations-tag-private{{display:none}}
-    </style>
-    <!-- `SwaggerUIBundle` is now available on the page -->
-    <script>
-    const ui = SwaggerUIBundle({{
-        url: '{openapi_url}',
-    """
-
-    for key, value in current_swagger_ui_parameters.items():
-        html += f"{json.dumps(key)}: {json.dumps(value)},\n"
-
-    if oauth2_redirect_url:
-        html += f"oauth2RedirectUrl: window.location.origin + '{oauth2_redirect_url}',"
-
-    html += """
-    presets: [
-        SwaggerUIBundle.presets.apis,
-        SwaggerUIBundle.SwaggerUIStandalonePreset
-        ],
-    })"""
-
-    if init_oauth:
-        html += f"""
-        ui.initOAuth({json.dumps(init_oauth)})
-        """
-
-    html += """
-    </script>
-    </body>
-    </html>
-    """
-    return HTMLResponse(html)
-
-
-def get_redoc_html(
-    *,
-    openapi_url: str,
-    title: str,
-    redoc_js_url: str = "https://cdn.jsdelivr.net/npm/redoc@next/bundles/redoc.standalone.js",
-    redoc_favicon_url: str = "/favicon.ico",
-    with_google_fonts: bool = True,
-) -> HTMLResponse:
-    """
-    Generate and return the HTML response that loads ReDoc for the alternative
-    API docs (normally served at `/redoc`).
-
-
-    """
-    html = f"""
-    <!DOCTYPE html>
-    <html>
-    <head>
-    <title>{title}</title>
-    <!-- needed for adaptive design -->
-    <meta charset="utf-8"/>
-    <meta name="viewport" content="width=device-width, initial-scale=1">
-    """
-    if with_google_fonts:
-        html += """
-    <link href="https://fonts.googleapis.com/css?family=Montserrat:300,400,700|Roboto:300,400,700" rel="stylesheet">
-    """  # noqa: E501
-    html += f"""
-    <link rel="shortcut icon" href="{redoc_favicon_url}">
-    <!--
-    ReDoc doesn't change outer page styles
-    -->
-    <style>
-      body {{
-        margin: 0;
-        padding: 0;
-      }}
-    </style>
-    </head>
-    <body>
-    <noscript>
-        ReDoc requires Javascript to function. Please enable it to browse the documentation.
-    </noscript>
-    <redoc spec-url="{openapi_url}"></redoc>
-    <script src="{redoc_js_url}"> </script>
-    </body>
-    </html>
-    """
-    return HTMLResponse(html)
-
-
-# Not needed now but copy-pasting for future reference
-def get_swagger_ui_oauth2_redirect_html() -> HTMLResponse:
-    """
-    Generate the HTML response with the OAuth2 redirection for Swagger UI.
-
-    You normally don't need to use or change this.
-    """
-    # copied from https://github.com/swagger-api/swagger-ui/blob/v4.14.0/dist/oauth2-redirect.html
-    html = """
-    <!doctype html>
-    <html lang="en-US">
-    <head>
-        <title>Swagger UI: OAuth2 Redirect</title>
-    </head>
-    <body>
-    <script>
-        'use strict';
-        function run () {
-            var oauth2 = window.opener.swaggerUIRedirectOauth2;
-            var sentState = oauth2.state;
-            var redirectUrl = oauth2.redirectUrl;
-            var isValid, qp, arr;
-
-            if (/code|token|error/.test(window.location.hash)) {
-                qp = window.location.hash.substring(1).replace('?', '&');
-            } else {
-                qp = location.search.substring(1);
-            }
-
-            arr = qp.split("&");
-            arr.forEach(function (v,i,_arr) { _arr[i] = '"' + v.replace('=', '":"') + '"';});
-            qp = qp ? JSON.parse('{' + arr.join() + '}',
-                    function (key, value) {
-                        return key === "" ? value : decodeURIComponent(value);
-                    }
-            ) : {};
-
-            isValid = qp.state === sentState;
-
-            if ((
-              oauth2.auth.schema.get("flow") === "accessCode" ||
-              oauth2.auth.schema.get("flow") === "authorizationCode" ||
-              oauth2.auth.schema.get("flow") === "authorization_code"
-            ) && !oauth2.auth.code) {
-                if (!isValid) {
-                    oauth2.errCb({
-                        authId: oauth2.auth.name,
-                        source: "auth",
-                        level: "warning",
-                        message: "Authorization may be unsafe, passed state was changed in server. The passed state wasn't returned from auth server."
-                    });
-                }
-
-                if (qp.code) {
-                    delete oauth2.state;
-                    oauth2.auth.code = qp.code;
-                    oauth2.callback({auth: oauth2.auth, redirectUrl: redirectUrl});
-                } else {
-                    let oauthErrorMsg;
-                    if (qp.error) {
-                        oauthErrorMsg = "["+qp.error+"]: " +
-                            (qp.error_description ? qp.error_description+ ". " : "no accessCode received from the server. ") +
-                            (qp.error_uri ? "More info: "+qp.error_uri : "");
-                    }
-
-                    oauth2.errCb({
-                        authId: oauth2.auth.name,
-                        source: "auth",
-                        level: "error",
-                        message: oauthErrorMsg || "[Authorization failed]: no accessCode received from the server."
-                    });
-                }
-            } else {
-                oauth2.callback({auth: oauth2.auth, token: qp, isValid: isValid, redirectUrl: redirectUrl});
-            }
-            window.close();
-        }
-
-        if (document.readyState !== 'loading') {
-            run();
-        } else {
-            document.addEventListener('DOMContentLoaded', function () {
-                run();
-            });
-        }
-    </script>
-    </body>
-    </html>
-        """  # noqa: E501
-    return HTMLResponse(content=html)