dominodatalab-data 5.11.0.dev1__tar.gz → 5.11.0.dev3__tar.gz

{dominodatalab_data-5.11.0.dev1 → dominodatalab_data-5.11.0.dev3}/PKG-INFO

@@ -1,31 +1,30 @@
 Metadata-Version: 2.1
 Name: dominodatalab-data
-Version: 5.11.0.dev1
+Version: 5.11.0.dev3
 Summary: Domino Data API for interacting with Domino Data features
 Home-page: https://github.com/dominodatalab/domino-data
 License: Apache Software License 2.0
 Author: Gabriel Haim
 Author-email: gabriel.haim@dominodatalab.com
-Requires-Python: >=3.8,<4.0
+Requires-Python: >=3.9,<4.0
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: Apache Software License
 Classifier: License :: Other/Proprietary License
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Requires-Dist: attrs (>=20.1.0)
-Requires-Dist: backoff (>=1.11.1,<2.0.0)
+Requires-Dist: backoff (>=1.11.1)
 Requires-Dist: bson (>=0.5.10,<0.6.0)
-Requires-Dist: httpx (>=0.23.0,<0.24.0)
+Requires-Dist: httpx (>=0.23.0)
 Requires-Dist: loguru (>=0.5.3,<0.6.0)
-Requires-Dist: pandas (>=1.3.0,<2.0.0)
-Requires-Dist: pyarrow (>=14.0.2,<15.0.0)
+Requires-Dist: pandas (>=1.3.0)
+Requires-Dist: pyarrow (>=15.0.2)
 Requires-Dist: python-dateutil (>=2.8.0,<3.0.0)
 Requires-Dist: urllib3 (>=1.26.16,<2.0.0)
 Project-URL: Repository, https://github.com/dominodatalab/domino-data

dominodatalab_data-5.11.0.dev3/datasource_api_client/__init__.py

@@ -0,0 +1,8 @@
+"""A client library for accessing Datasource API"""
+
+from .client import AuthenticatedClient, Client
+
+__all__ = (
+    "AuthenticatedClient",
+    "Client",
+)

dominodatalab_data-5.11.0.dev3/datasource_api_client/api/__init__.py

@@ -0,0 +1 @@
+"""Contains methods for accessing the API"""

dominodatalab_data-5.11.0.dev3/datasource_api_client/api/datasource/get_datasource_by_name.py

@@ -0,0 +1,195 @@
+from typing import Any, Dict, Optional, Union
+
+from http import HTTPStatus
+
+import httpx
+
+from ... import errors
+from ...client import AuthenticatedClient, Client
+from ...models.datasource_dto import DatasourceDto
+from ...models.error_response import ErrorResponse
+from ...types import UNSET, Response, Unset
+
+
+def _get_kwargs(
+    name: str,
+    *,
+    run_id: Union[Unset, str] = UNSET,
+) -> Dict[str, Any]:
+    params: Dict[str, Any] = {}
+
+    params["runId"] = run_id
+
+    params = {k: v for k, v in params.items() if v is not UNSET and v is not None}
+
+    _kwargs: Dict[str, Any] = {
+        "method": "get",
+        "url": "/datasource/name/{name}".format(
+            name=name,
+        ),
+        "params": params,
+    }
+
+    return _kwargs
+
+
+def _parse_response(
+    *, client: Union[AuthenticatedClient, Client], response: httpx.Response
+) -> Optional[Union[DatasourceDto, ErrorResponse]]:
+    if response.status_code == HTTPStatus.OK:
+        response_200 = DatasourceDto.from_dict(response.json())
+
+        return response_200
+    if response.status_code == HTTPStatus.BAD_REQUEST:
+        response_400 = ErrorResponse.from_dict(response.json())
+
+        return response_400
+    if response.status_code == HTTPStatus.UNAUTHORIZED:
+        response_401 = ErrorResponse.from_dict(response.json())
+
+        return response_401
+    if response.status_code == HTTPStatus.FORBIDDEN:
+        response_403 = ErrorResponse.from_dict(response.json())
+
+        return response_403
+    if response.status_code == HTTPStatus.NOT_FOUND:
+        response_404 = ErrorResponse.from_dict(response.json())
+
+        return response_404
+    if response.status_code == HTTPStatus.INTERNAL_SERVER_ERROR:
+        response_500 = ErrorResponse.from_dict(response.json())
+
+        return response_500
+    if client.raise_on_unexpected_status:
+        raise errors.UnexpectedStatus(response.status_code, response.content)
+    else:
+        return None
+
+
+def _build_response(
+    *, client: Union[AuthenticatedClient, Client], response: httpx.Response
+) -> Response[Union[DatasourceDto, ErrorResponse]]:
+    return Response(
+        status_code=HTTPStatus(response.status_code),
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(client=client, response=response),
+    )
+
+
+def sync_detailed(
+    name: str,
+    *,
+    client: Union[AuthenticatedClient, Client],
+    run_id: Union[Unset, str] = UNSET,
+) -> Response[Union[DatasourceDto, ErrorResponse]]:
+    """Get datasource by name
+
+    Args:
+        name (str):
+        run_id (Union[Unset, str]):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Union[DatasourceDto, ErrorResponse]]
+    """
+
+    kwargs = _get_kwargs(
+        name=name,
+        run_id=run_id,
+    )
+
+    response = client.get_httpx_client().request(
+        **kwargs,
+    )
+
+    return _build_response(client=client, response=response)
+
+
+def sync(
+    name: str,
+    *,
+    client: Union[AuthenticatedClient, Client],
+    run_id: Union[Unset, str] = UNSET,
+) -> Optional[Union[DatasourceDto, ErrorResponse]]:
+    """Get datasource by name
+
+    Args:
+        name (str):
+        run_id (Union[Unset, str]):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Union[DatasourceDto, ErrorResponse]
+    """
+
+    return sync_detailed(
+        name=name,
+        client=client,
+        run_id=run_id,
+    ).parsed
+
+
+async def asyncio_detailed(
+    name: str,
+    *,
+    client: Union[AuthenticatedClient, Client],
+    run_id: Union[Unset, str] = UNSET,
+) -> Response[Union[DatasourceDto, ErrorResponse]]:
+    """Get datasource by name
+
+    Args:
+        name (str):
+        run_id (Union[Unset, str]):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Union[DatasourceDto, ErrorResponse]]
+    """
+
+    kwargs = _get_kwargs(
+        name=name,
+        run_id=run_id,
+    )
+
+    response = await client.get_async_httpx_client().request(**kwargs)
+
+    return _build_response(client=client, response=response)
+
+
+async def asyncio(
+    name: str,
+    *,
+    client: Union[AuthenticatedClient, Client],
+    run_id: Union[Unset, str] = UNSET,
+) -> Optional[Union[DatasourceDto, ErrorResponse]]:
+    """Get datasource by name
+
+    Args:
+        name (str):
+        run_id (Union[Unset, str]):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Union[DatasourceDto, ErrorResponse]
+    """
+
+    return (
+        await asyncio_detailed(
+            name=name,
+            client=client,
+            run_id=run_id,
+        )
+    ).parsed

dominodatalab_data-5.11.0.dev3/datasource_api_client/api/proxy/get_key_url.py

@@ -0,0 +1,168 @@
+from typing import Any, Dict, Optional, Union, cast
+
+from http import HTTPStatus
+
+import httpx
+
+from ... import errors
+from ...client import AuthenticatedClient, Client
+from ...models.key_request import KeyRequest
+from ...models.proxy_error_response import ProxyErrorResponse
+from ...types import Response
+
+
+def _get_kwargs(
+    *,
+    body: KeyRequest,
+) -> Dict[str, Any]:
+    headers: Dict[str, Any] = {}
+
+    _kwargs: Dict[str, Any] = {
+        "method": "post",
+        "url": "/objectstore/key",
+    }
+
+    _body = body.to_dict()
+
+    _kwargs["json"] = _body
+    headers["Content-Type"] = "application/json"
+
+    _kwargs["headers"] = headers
+    return _kwargs
+
+
+def _parse_response(
+    *, client: Union[AuthenticatedClient, Client], response: httpx.Response
+) -> Optional[Union[ProxyErrorResponse, str]]:
+    if response.status_code == HTTPStatus.OK:
+        response_200 = cast(str, response.json())
+        return response_200
+    if response.status_code == HTTPStatus.BAD_REQUEST:
+        response_400 = ProxyErrorResponse.from_dict(response.json())
+
+        return response_400
+    if response.status_code == HTTPStatus.INTERNAL_SERVER_ERROR:
+        response_500 = ProxyErrorResponse.from_dict(response.json())
+
+        return response_500
+    if client.raise_on_unexpected_status:
+        raise errors.UnexpectedStatus(response.status_code, response.content)
+    else:
+        return None
+
+
+def _build_response(
+    *, client: Union[AuthenticatedClient, Client], response: httpx.Response
+) -> Response[Union[ProxyErrorResponse, str]]:
+    return Response(
+        status_code=HTTPStatus(response.status_code),
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(client=client, response=response),
+    )
+
+
+def sync_detailed(
+    *,
+    client: Union[AuthenticatedClient, Client],
+    body: KeyRequest,
+) -> Response[Union[ProxyErrorResponse, str]]:
+    """Request a new signed URL for the key of a object store
+
+    Args:
+        body (KeyRequest):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Union[ProxyErrorResponse, str]]
+    """
+
+    kwargs = _get_kwargs(
+        body=body,
+    )
+
+    response = client.get_httpx_client().request(
+        **kwargs,
+    )
+
+    return _build_response(client=client, response=response)
+
+
+def sync(
+    *,
+    client: Union[AuthenticatedClient, Client],
+    body: KeyRequest,
+) -> Optional[Union[ProxyErrorResponse, str]]:
+    """Request a new signed URL for the key of a object store
+
+    Args:
+        body (KeyRequest):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Union[ProxyErrorResponse, str]
+    """
+
+    return sync_detailed(
+        client=client,
+        body=body,
+    ).parsed
+
+
+async def asyncio_detailed(
+    *,
+    client: Union[AuthenticatedClient, Client],
+    body: KeyRequest,
+) -> Response[Union[ProxyErrorResponse, str]]:
+    """Request a new signed URL for the key of a object store
+
+    Args:
+        body (KeyRequest):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Union[ProxyErrorResponse, str]]
+    """
+
+    kwargs = _get_kwargs(
+        body=body,
+    )
+
+    response = await client.get_async_httpx_client().request(**kwargs)
+
+    return _build_response(client=client, response=response)
+
+
+async def asyncio(
+    *,
+    client: Union[AuthenticatedClient, Client],
+    body: KeyRequest,
+) -> Optional[Union[ProxyErrorResponse, str]]:
+    """Request a new signed URL for the key of a object store
+
+    Args:
+        body (KeyRequest):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Union[ProxyErrorResponse, str]
+    """
+
+    return (
+        await asyncio_detailed(
+            client=client,
+            body=body,
+        )
+    ).parsed

dominodatalab_data-5.11.0.dev3/datasource_api_client/api/proxy/list_keys.py

@@ -0,0 +1,169 @@
+from typing import Any, Dict, List, Optional, Union, cast
+
+from http import HTTPStatus
+
+import httpx
+
+from ... import errors
+from ...client import AuthenticatedClient, Client
+from ...models.list_request import ListRequest
+from ...models.proxy_error_response import ProxyErrorResponse
+from ...types import Response
+
+
+def _get_kwargs(
+    *,
+    body: ListRequest,
+) -> Dict[str, Any]:
+    headers: Dict[str, Any] = {}
+
+    _kwargs: Dict[str, Any] = {
+        "method": "post",
+        "url": "/objectstore/list",
+    }
+
+    _body = body.to_dict()
+
+    _kwargs["json"] = _body
+    headers["Content-Type"] = "application/json"
+
+    _kwargs["headers"] = headers
+    return _kwargs
+
+
+def _parse_response(
+    *, client: Union[AuthenticatedClient, Client], response: httpx.Response
+) -> Optional[Union[List[str], ProxyErrorResponse]]:
+    if response.status_code == HTTPStatus.OK:
+        response_200 = cast(List[str], response.json())
+
+        return response_200
+    if response.status_code == HTTPStatus.BAD_REQUEST:
+        response_400 = ProxyErrorResponse.from_dict(response.json())
+
+        return response_400
+    if response.status_code == HTTPStatus.INTERNAL_SERVER_ERROR:
+        response_500 = ProxyErrorResponse.from_dict(response.json())
+
+        return response_500
+    if client.raise_on_unexpected_status:
+        raise errors.UnexpectedStatus(response.status_code, response.content)
+    else:
+        return None
+
+
+def _build_response(
+    *, client: Union[AuthenticatedClient, Client], response: httpx.Response
+) -> Response[Union[List[str], ProxyErrorResponse]]:
+    return Response(
+        status_code=HTTPStatus(response.status_code),
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(client=client, response=response),
+    )
+
+
+def sync_detailed(
+    *,
+    client: Union[AuthenticatedClient, Client],
+    body: ListRequest,
+) -> Response[Union[List[str], ProxyErrorResponse]]:
+    """Request a new signed URL for a blob datasource
+
+    Args:
+        body (ListRequest):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Union[List[str], ProxyErrorResponse]]
+    """
+
+    kwargs = _get_kwargs(
+        body=body,
+    )
+
+    response = client.get_httpx_client().request(
+        **kwargs,
+    )
+
+    return _build_response(client=client, response=response)
+
+
+def sync(
+    *,
+    client: Union[AuthenticatedClient, Client],
+    body: ListRequest,
+) -> Optional[Union[List[str], ProxyErrorResponse]]:
+    """Request a new signed URL for a blob datasource
+
+    Args:
+        body (ListRequest):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Union[List[str], ProxyErrorResponse]
+    """
+
+    return sync_detailed(
+        client=client,
+        body=body,
+    ).parsed
+
+
+async def asyncio_detailed(
+    *,
+    client: Union[AuthenticatedClient, Client],
+    body: ListRequest,
+) -> Response[Union[List[str], ProxyErrorResponse]]:
+    """Request a new signed URL for a blob datasource
+
+    Args:
+        body (ListRequest):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Union[List[str], ProxyErrorResponse]]
+    """
+
+    kwargs = _get_kwargs(
+        body=body,
+    )
+
+    response = await client.get_async_httpx_client().request(**kwargs)
+
+    return _build_response(client=client, response=response)
+
+
+async def asyncio(
+    *,
+    client: Union[AuthenticatedClient, Client],
+    body: ListRequest,
+) -> Optional[Union[List[str], ProxyErrorResponse]]:
+    """Request a new signed URL for a blob datasource
+
+    Args:
+        body (ListRequest):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Union[List[str], ProxyErrorResponse]
+    """
+
+    return (
+        await asyncio_detailed(
+            client=client,
+            body=body,
+        )
+    ).parsed

dominodatalab_data-5.11.0.dev3/datasource_api_client/api/proxy/log_metric.py

@@ -0,0 +1,128 @@
+from typing import Any, Dict, Optional, Union
+
+from http import HTTPStatus
+
+import httpx
+
+from ... import errors
+from ...client import AuthenticatedClient, Client
+from ...models.log_metric_m import LogMetricM
+from ...models.log_metric_t import LogMetricT
+from ...types import UNSET, Response
+
+
+def _get_kwargs(
+    *,
+    t: LogMetricT,
+    b: int,
+    m: LogMetricM,
+) -> Dict[str, Any]:
+    params: Dict[str, Any] = {}
+
+    json_t = t.value
+    params["t"] = json_t
+
+    params["b"] = b
+
+    json_m = m.value
+    params["m"] = json_m
+
+    params = {k: v for k, v in params.items() if v is not UNSET and v is not None}
+
+    _kwargs: Dict[str, Any] = {
+        "method": "head",
+        "url": "/objectstore/metric",
+        "params": params,
+    }
+
+    return _kwargs
+
+
+def _parse_response(
+    *, client: Union[AuthenticatedClient, Client], response: httpx.Response
+) -> Optional[Any]:
+    if response.status_code == HTTPStatus.OK:
+        return None
+    if client.raise_on_unexpected_status:
+        raise errors.UnexpectedStatus(response.status_code, response.content)
+    else:
+        return None
+
+
+def _build_response(
+    *, client: Union[AuthenticatedClient, Client], response: httpx.Response
+) -> Response[Any]:
+    return Response(
+        status_code=HTTPStatus(response.status_code),
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(client=client, response=response),
+    )
+
+
+def sync_detailed(
+    *,
+    client: Union[AuthenticatedClient, Client],
+    t: LogMetricT,
+    b: int,
+    m: LogMetricM,
+) -> Response[Any]:
+    """Log metrics about file size read or written
+
+    Args:
+        t (LogMetricT):
+        b (int):
+        m (LogMetricM):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Any]
+    """
+
+    kwargs = _get_kwargs(
+        t=t,
+        b=b,
+        m=m,
+    )
+
+    response = client.get_httpx_client().request(
+        **kwargs,
+    )
+
+    return _build_response(client=client, response=response)
+
+
+async def asyncio_detailed(
+    *,
+    client: Union[AuthenticatedClient, Client],
+    t: LogMetricT,
+    b: int,
+    m: LogMetricM,
+) -> Response[Any]:
+    """Log metrics about file size read or written
+
+    Args:
+        t (LogMetricT):
+        b (int):
+        m (LogMetricM):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Any]
+    """
+
+    kwargs = _get_kwargs(
+        t=t,
+        b=b,
+        m=m,
+    )
+
+    response = await client.get_async_httpx_client().request(**kwargs)
+
+    return _build_response(client=client, response=response)