pydelfini 1.10.0__tar.gz

pydelfini-1.10.0/.openapi-python-client/config.yaml

@@ -0,0 +1,5 @@
+package_name_override: delfini_core
+post_hooks:
+  - 'find . -name "*.py" -exec reorder-python-imports --py39-plus "{}" \;'
+  - "ruff check --fix ."
+  - "black ."

pydelfini-1.10.0/.openapi-python-client/templates/endpoint_init.py.jinja

@@ -0,0 +1 @@
+"""{{ endpoint_collection.tag | capitalize }} operations"""

pydelfini-1.10.0/.openapi-python-client/templates/endpoint_macros.py.jinja

@@ -0,0 +1,190 @@
+{% from "property_templates/helpers.jinja" import guarded_statement %}
+{% from "helpers.jinja" import safe_docstring %}
+
+{% macro header_params(endpoint) %}
+{% if endpoint.header_parameters or endpoint.bodies | length > 0 %}
+headers: Dict[str, Any] = {}
+{% if endpoint.header_parameters %}
+    {% for parameter in endpoint.header_parameters.values() %}
+        {% import "property_templates/" + parameter.template as param_template %}
+        {% if param_template.transform_header %}
+            {% set expression = param_template.transform_header(parameter.python_name) %}
+        {% else %}
+            {% set expression = parameter.python_name %}
+        {% endif %}
+        {% set statement = 'headers["' +  parameter.name + '"]' + " = " + expression %}
+{{ guarded_statement(parameter, parameter.python_name, statement) }}
+    {% endfor %}
+{% endif %}
+{% endif %}
+{% endmacro %}
+
+{% macro cookie_params(endpoint) %}
+{% if endpoint.cookie_parameters %}
+cookies = {}
+    {% for parameter in endpoint.cookie_parameters.values() %}
+        {% if parameter.required %}
+cookies["{{ parameter.name}}"] = {{ parameter.python_name }}
+        {% else %}
+if {{ parameter.python_name }} is not UNSET:
+    cookies["{{ parameter.name}}"] = {{ parameter.python_name }}
+        {% endif %}
+
+    {% endfor %}
+{% endif %}
+{% endmacro %}
+
+
+{% macro query_params(endpoint) %}
+{% if endpoint.query_parameters %}
+params: Dict[str, Any] = {}
+
+{% for property in endpoint.query_parameters.values() %}
+    {% set destination = property.python_name %}
+    {% import "property_templates/" + property.template as prop_template %}
+    {% if prop_template.transform %}
+        {% set destination = "json_" + property.python_name %}
+{{ prop_template.transform(property, property.python_name, destination) }}
+    {% endif %}
+    {%- if not property.json_is_dict %}
+params["{{ property.name }}"] = {{ destination }}
+    {% else %}
+{{ guarded_statement(property, destination, "params.update(" + destination + ")") }}
+    {% endif %}
+
+{% endfor %}
+
+params = {k: v for k, v in params.items() if v is not UNSET and v is not None}
+{% endif %}
+{% endmacro %}
+
+{% macro body_to_kwarg(body, destination) %}
+{% if body.body_type == "data" %}
+{{ destination }} = body.to_dict()
+{% elif body.body_type == "files"%}
+{{ multipart_body(body, destination) }}
+{% elif body.body_type == "json" %}
+{{ json_body(body, destination) }}
+{% elif body.body_type == "content" %}
+{{ destination }} = body.payload
+{% endif %}
+{% endmacro %}
+
+{% macro json_body(body, destination) %}
+{% set property = body.prop %}
+{% import "property_templates/" + property.template as prop_template %}
+{% if prop_template.transform %}
+{{ prop_template.transform(property, property.python_name, destination) }}
+{% else %}
+{{ destination }} = {{ property.python_name }}
+{% endif %}
+{% endmacro %}
+
+{% macro multipart_body(body, destination) %}
+{% set property = body.prop %}
+{% import "property_templates/" + property.template as prop_template %}
+{% if prop_template.transform_multipart %}
+{{ prop_template.transform_multipart(property, property.python_name, destination) }}
+{% endif %}
+{% endmacro %}
+
+{# The all the kwargs passed into an endpoint (and variants thereof)) #}
+{% macro arguments(endpoint, include_client=True) %}
+{# path parameters #}
+{% for parameter in endpoint.path_parameters.values() %}
+{{ parameter.to_string() }},
+{% endfor %}
+{% if include_client or ((endpoint.list_all_parameters() | length) > (endpoint.path_parameters | length)) %}
+*,
+{% endif %}
+{# Proper client based on whether or not the endpoint requires authentication #}
+{% if include_client %}
+{% if endpoint.requires_security %}
+client: AuthenticatedClient,
+{% else %}
+client: Union[AuthenticatedClient, Client],
+{% endif %}
+{% endif %}
+{# Any allowed bodies #}
+{% if endpoint.bodies | length == 1 %}
+body: {{ endpoint.bodies[0].prop.get_type_string() }},
+{% elif endpoint.bodies | length > 1 %}
+body: Union[
+    {% for body in endpoint.bodies %}
+    {{ body.prop.get_type_string() }},
+    {% endfor %}
+],
+{% endif %}
+{# query parameters #}
+{% for parameter in endpoint.query_parameters.values() %}
+{{ parameter.to_string() }},
+{% endfor %}
+{% for parameter in endpoint.header_parameters.values() %}
+{{ parameter.to_string() }},
+{% endfor %}
+{# cookie parameters #}
+{% for parameter in endpoint.cookie_parameters.values() %}
+{{ parameter.to_string() }},
+{% endfor %}
+{% endmacro %}
+
+{# Just lists all kwargs to endpoints as name=name for passing to other functions #}
+{% macro kwargs(endpoint, include_client=True) %}
+{% for parameter in endpoint.path_parameters.values() %}
+{{ parameter.python_name }}={{ parameter.python_name }},
+{% endfor %}
+{% if include_client %}
+client=client,
+{% endif %}
+{% if endpoint.bodies | length > 0 %}
+body=body,
+{% endif %}
+{% for parameter in endpoint.query_parameters.values() %}
+{{ parameter.python_name }}={{ parameter.python_name }},
+{% endfor %}
+{% for parameter in endpoint.header_parameters.values() %}
+{{ parameter.python_name }}={{ parameter.python_name }},
+{% endfor %}
+{% for parameter in endpoint.cookie_parameters.values() %}
+{{ parameter.python_name }}={{ parameter.python_name }},
+{% endfor %}
+{% endmacro %}
+
+{% macro docstring_content(endpoint, return_string, is_detailed) %}
+{% if endpoint.summary %}{{ endpoint.summary | wordwrap(100)}}
+
+{% endif -%}
+{%- if endpoint.description %}{{ endpoint.description | wordwrap(100) }}
+
+{% endif %}
+{% if not endpoint.summary and not endpoint.description %}
+{# Leave extra space so that Args or Returns isn't at the top #}
+
+{% endif %}
+{% set all_parameters = endpoint.list_all_parameters() %}
+{% if all_parameters %}
+Args:
+    {% for parameter in all_parameters %}
+    {{ parameter.to_docstring() | wordwrap(90) | indent(8) }}
+    {% endfor %}
+
+{% endif %}
+Raises:
+{% if is_detailed %}
+    errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+{% else %}
+    errors.UnexpectedStatus: If the server returns a status code greater than or equal to 300.
+{% endif %}
+    httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+Returns:
+{% if is_detailed %}
+    Response[{{ return_string }}]
+{% else %}
+    {{ return_string }}
+{% endif %}
+{% endmacro %}
+
+{% macro docstring(endpoint, return_string, is_detailed) %}
+{{ safe_docstring(docstring_content(endpoint, return_string, is_detailed)) }}
+{% endmacro %}

pydelfini-1.10.0/.openapi-python-client/templates/endpoint_module.py.jinja

@@ -0,0 +1,163 @@
+"""{{ endpoint.summary }}"""
+from http import HTTPStatus
+from typing import Any, Dict, List, Optional, Union, cast
+
+import httpx
+
+from ...client import AuthenticatedClient, Client
+from ...types import Response, UNSET
+from ... import errors
+
+{% for relative in endpoint.relative_imports %}
+{{ relative }}
+{% endfor %}
+
+{% from "endpoint_macros.py.jinja" import header_params, cookie_params, query_params,
+    arguments, client, kwargs, parse_response, docstring, body_to_kwarg %}
+
+{% set return_string = endpoint.response_type() %}
+{% set parsed_responses = (endpoint.responses | length > 0) and return_string != "Any" %}
+
+def _get_kwargs(
+    {{ arguments(endpoint, include_client=False) | indent(4) }}
+) -> Dict[str, Any]:
+    {{ header_params(endpoint) | indent(4) }}
+
+    {{ cookie_params(endpoint) | indent(4) }}
+
+    {{ query_params(endpoint) | indent(4) }}
+
+    _kwargs: Dict[str, Any] = {
+        "method": "{{ endpoint.method }}",
+        {% if endpoint.path_parameters %}
+        "url": "{{ endpoint.path }}".format(
+        {%- for parameter in endpoint.path_parameters.values() -%}
+        {{parameter.name}}={{parameter.python_name}},
+        {%- endfor -%}
+        ),
+        {% else %}
+        "url": "{{ endpoint.path }}",
+        {% endif %}
+        {% if endpoint.query_parameters %}
+        "params": params,
+        {% endif %}
+        {% if endpoint.cookie_parameters %}
+        "cookies": cookies,
+        {% endif %}
+    }
+
+{% if endpoint.bodies | length > 1 %}
+{% for body in endpoint.bodies %}
+    if isinstance(body, {{body.prop.get_type_string() }}):
+        {% set destination = "_" + body.body_type + "_body" %}
+        {{ body_to_kwarg(body, destination) | indent(8) }}
+        _kwargs["{{ body.body_type.value }}"] = {{ destination }}
+        {% if body.content_type != "multipart/form-data" %}
+        headers["Content-Type"] = "{{ body.content_type }}"
+        {% endif %}
+{% endfor %}
+{% elif endpoint.bodies | length == 1 %}
+{% set body = endpoint.bodies[0] %}
+    {{ body_to_kwarg(body, "_body") | indent(4) }}
+    _kwargs["{{ body.body_type.value }}"] = _body
+    {% if body.content_type != "multipart/form-data" %}{# Need httpx to set the boundary automatically #}
+    headers["Content-Type"] = "{{ body.content_type }}"
+    {% endif %}
+{% endif %}
+
+{% if endpoint.header_parameters or endpoint.bodies | length > 0 %}
+    _kwargs["headers"] = headers
+{% endif %}
+    return _kwargs
+
+def _parse_response(*, client: Union[AuthenticatedClient, Client], response: httpx.Response) -> {{ return_string }}:
+    {% for response in endpoint.responses %}
+    if response.status_code == HTTPStatus.{{ response.status_code.name }}:
+        {% if parsed_responses %}{% import "property_templates/" + response.prop.template as prop_template %}
+        {% if prop_template.construct %}
+        {{ prop_template.construct(response.prop, response.source.attribute) | indent(8) }}
+        {% elif response.source.return_type == response.prop.get_type_string() %}
+        {{ response.prop.python_name }} = {{ response.source.attribute }}
+        {% else %}
+        {{ response.prop.python_name }} = cast({{ response.prop.get_type_string() }}, {{ response.source }})
+        {% endif %}
+        return {{ response.prop.python_name }}
+        {% else %}
+        return None
+        {% endif %}
+    {% endfor %}
+
+    raise errors.UnexpectedStatus(response.status_code, response.content)
+
+
+def _build_response(*, client: Union[AuthenticatedClient, Client], response: httpx.Response) -> Response[{{ return_string }}]:
+    return Response(
+        status_code=HTTPStatus(response.status_code),
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(client=client, response=response),
+    )
+
+
+def sync_detailed(
+    {{ arguments(endpoint) | indent(4) }}
+) -> Response[{{ return_string }}]:
+    {{ docstring(endpoint, return_string, is_detailed=true) | indent(4) }}
+
+    kwargs = _get_kwargs(
+        {{ kwargs(endpoint, include_client=False) }}
+    )
+
+    response = client.get_httpx_client().request(
+        **kwargs,
+    )
+
+    return _build_response(client=client, response=response)
+
+{% if parsed_responses %}
+{% set return_without_error = return_string | replace(', ServerError', '') | replace('ServerError, ', '') %}
+def sync(
+    {{ arguments(endpoint) | indent(4) }}
+) -> {{ return_without_error }}:
+    {{ docstring(endpoint, return_without_error, is_detailed=false) | indent(4) }}
+
+    response = sync_detailed(
+        {{ kwargs(endpoint) }}
+    )
+    if isinstance(response.parsed, ServerError):
+        raise errors.UnexpectedStatus(response.status_code, response.content)
+
+    return response.parsed
+
+{% endif %}
+
+async def asyncio_detailed(
+    {{ arguments(endpoint) | indent(4) }}
+) -> Response[{{ return_string }}]:
+    {{ docstring(endpoint, return_string, is_detailed=true) | indent(4) }}
+
+    kwargs = _get_kwargs(
+        {{ kwargs(endpoint, include_client=False) }}
+    )
+
+    response = await client.get_async_httpx_client().request(
+        **kwargs
+    )
+
+    return _build_response(client=client, response=response)
+
+{% if parsed_responses %}
+{% set return_without_error = return_string | replace(', ServerError', '') | replace('ServerError, ', '') %}
+async def asyncio(
+    {{ arguments(endpoint) | indent(4) }}
+) -> {{ return_without_error }}:
+    {{ docstring(endpoint, return_without_error, is_detailed=false) | indent(4) }}
+
+    response = await asyncio_detailed(
+        {{ kwargs(endpoint) }}
+    )
+    if isinstance(response.parsed, ServerError):
+        raise errors.UnexpectedStatus(response.status_code, response.content)
+
+    return response.parsed
+{% endif %}

pydelfini-1.10.0/.openapi-python-client/templates/model.py.jinja

@@ -0,0 +1,200 @@
+from typing import Any, Dict, Type, TypeVar, Tuple, Optional, BinaryIO, TextIO, TYPE_CHECKING
+
+{% if model.additional_properties %}
+from typing import List
+
+{% endif %}
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+{% if model.is_multipart_body %}
+import json
+{% endif %}
+
+from ..types import UNSET, Unset
+
+{% for relative in model.relative_imports %}
+{{ relative }}
+{% endfor %}
+
+{% for lazy_import in model.lazy_imports | sort %}
+{{ lazy_import }}
+{% endfor %}
+
+
+{% if model.additional_properties %}
+{% set additional_property_type = 'Any' if model.additional_properties == True else model.additional_properties.get_type_string(quoted=not model.additional_properties.is_base_type) %}
+{% endif %}
+
+{% set class_name = model.class_info.name %}
+{% set module_name = model.class_info.module_name %}
+
+{% from "helpers.jinja" import safe_docstring %}
+
+T = TypeVar("T", bound="{{ class_name }}")
+
+{% macro class_docstring_content(model) %}
+    {% if model.title %}{{ model.title | wordwrap(116) }}
+
+    {% endif -%}
+    {%- if model.description %}{{ model.description | wordwrap(116) }}
+
+    {% endif %}
+    {% if not model.title and not model.description %}
+    {{ class_name }} model
+
+    {% endif %}
+    {% if model.example %}
+    Example:
+
+    >>> model = {{ class_name }}.from_dict({{ model.example | pprint | indent('    ...    ') }})
+
+    {% endif %}
+    {% if model.required_properties or model.optional_properties %}
+    Attributes:
+    {% for property in model.required_properties + model.optional_properties %}
+        {{ property.to_docstring() | wordwrap(112) | indent(12) }}
+    {% endfor %}{% endif %}
+{% endmacro %}
+
+@_attrs_define
+class {{ class_name }}:
+    {{ safe_docstring(class_docstring_content(model)) | indent(4) }}
+
+    {% for property in model.required_properties + model.optional_properties %}
+    {% if property.default is none and property.required %}
+    {{ property.to_string() }}
+    {% endif %}
+    {% endfor %}
+    {% for property in model.required_properties + model.optional_properties %}
+    {% if property.default is not none or not property.required %}
+    {{ property.to_string() }}
+    {% endif %}
+    {% endfor %}
+    {% if model.additional_properties %}
+    additional_properties: Dict[str, {{ additional_property_type }}] = _attrs_field(init=False, factory=dict)
+    {% endif %}
+
+{% macro _to_dict(multipart=False) %}
+{% for property in model.required_properties + model.optional_properties %}
+{% import "property_templates/" + property.template as prop_template %}
+{% if prop_template.transform %}
+{{ prop_template.transform(property, "self." + property.python_name, property.python_name, multipart=multipart) }}
+{% elif multipart %}
+{{ property.python_name }} = self.{{ property.python_name }} if isinstance(self.{{ property.python_name }}, Unset) else (None, str(self.{{ property.python_name }}).encode(), "text/plain")
+{% else %}
+{{ property.python_name }} = self.{{ property.python_name }}
+{% endif %}
+{% endfor %}
+
+field_dict: Dict[str, Any] = {}
+{% if model.additional_properties %}
+{% if model.additional_properties.template %}{# Can be a bool instead of an object #}
+    {% import "property_templates/" + model.additional_properties.template as prop_template %}
+{% else %}
+    {% set prop_template = None %}
+{% endif %}
+{% if prop_template and prop_template.transform %}
+for prop_name, prop in self.additional_properties.items():
+    {{ prop_template.transform(model.additional_properties, "prop", "field_dict[prop_name]", multipart=multipart, declare_type=false) | indent(4) }}
+{% elif multipart %}
+field_dict.update({
+    key: (None, str(value).encode(), "text/plain")
+    for key, value in self.additional_properties.items()
+})
+{% else %}
+field_dict.update(self.additional_properties)
+{% endif %}
+{% endif %}
+field_dict.update({
+    {% for property in model.required_properties + model.optional_properties %}
+    {% if property.required %}
+    "{{ property.name }}": {{ property.python_name }},
+    {% endif %}
+    {% endfor %}
+})
+{% for property in model.optional_properties %}
+{% if not property.required %}
+if {{ property.python_name }} is not UNSET:
+    field_dict["{{ property.name }}"] = {{ property.python_name }}
+{% endif %}
+{% endfor %}
+
+return field_dict
+{% endmacro %}
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert to a dict"""
+        {{ _to_dict() | indent(8) }}
+
+{% if model.is_multipart_body %}
+    def to_multipart(self) -> Dict[str, Any]:
+        {{ _to_dict(multipart=True) | indent(8) }}
+{% endif %}
+
+    @classmethod
+    def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T:
+        """Create an instance of :py:class:`{{ class_name }}` from a dict"""
+        d = src_dict.copy()
+{% for property in model.required_properties + model.optional_properties %}
+    {% if property.required %}
+        {% set property_source = 'd.pop("' + property.name + '")' %}
+    {% else %}
+        {% set property_source = 'd.pop("' + property.name + '", UNSET)' %}
+    {% endif %}
+    {% import "property_templates/" + property.template as prop_template %}
+    {% if prop_template.construct %}
+        {{ prop_template.construct(property, property_source) | indent(8) }}
+    {% else %}
+        {{ property.python_name }} = {{ property_source }}
+    {% endif %}
+
+{% endfor %}
+        {{ module_name }} = cls(
+{% for property in model.required_properties + model.optional_properties %}
+            {{ property.python_name }}={{ property.python_name }},
+{% endfor %}
+        )
+
+{% if model.additional_properties %}
+    {% if model.additional_properties.template %}{# Can be a bool instead of an object #}
+        {% import "property_templates/" + model.additional_properties.template as prop_template %}
+
+{% if model.additional_properties.lazy_imports %}
+    {% for lazy_import in model.additional_properties.lazy_imports | sort %}
+        {{ lazy_import }}
+    {% endfor %}
+{% endif %}
+    {% else %}
+        {% set prop_template = None %}
+    {% endif %}
+    {% if prop_template and prop_template.construct %}
+        additional_properties = {}
+        for prop_name, prop_dict in d.items():
+            {{ prop_template.construct(model.additional_properties, "prop_dict") | indent(12) }}
+            additional_properties[prop_name] = {{ model.additional_properties.python_name }}
+
+        {{ module_name }}.additional_properties = additional_properties
+    {% else %}
+        {{ module_name }}.additional_properties = d
+    {% endif %}
+{% endif %}
+        return {{ module_name }}
+
+    {% if model.additional_properties %}
+    @property
+    def additional_keys(self) -> List[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> {{ additional_property_type }}:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: {{ additional_property_type }}) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties
+    {% endif %}

pydelfini-1.10.0/.openapi-python-client/templates/types.py.jinja

@@ -0,0 +1,48 @@
+""" Contains some shared types for properties """
+from http import HTTPStatus
+from typing import Any, BinaryIO, Generic, MutableMapping, Optional, Tuple, TypeVar, Literal
+
+from attrs import define
+
+
+class Unset:
+    def __bool__(self) -> Literal[False]:
+        return False
+
+    def __repr__(self) -> str:
+        return "Unset"
+
+
+UNSET: Unset = Unset()
+
+{# Used as `FileProperty._json_type_string` #}
+FileJsonType = Tuple[Optional[str], BinaryIO, Optional[str]]
+
+
+@define
+class File:
+    """ Contains information for file uploads """
+
+    payload: BinaryIO
+    file_name: Optional[str] = None
+    mime_type: Optional[str] = None
+
+    def to_tuple(self) -> FileJsonType:
+        """ Return a tuple representation that httpx will accept for multipart/form-data """
+        return self.file_name, self.payload, self.mime_type
+
+
+T = TypeVar("T")
+
+
+@define
+class Response(Generic[T]):
+    """ A response from an endpoint """
+
+    status_code: HTTPStatus
+    content: bytes
+    headers: MutableMapping[str, str]
+    parsed: T
+
+
+__all__ = ["File", "Response", "FileJsonType"]

pydelfini-1.10.0/PKG-INFO

@@ -0,0 +1,73 @@
+Metadata-Version: 2.4
+Name: pydelfini
+Version: 1.10.0
+Summary: an easy-to-use Python client for Delfini
+Author-email: BioTeam <contact@bioteam.net>
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: pyyaml>=6.0
+Requires-Dist: httpx<=0.27.2,>=0.20.0
+Requires-Dist: attrs>=21.3.0
+Requires-Dist: python-dateutil
+Requires-Dist: pyarrow>=20.0.0
+Requires-Dist: pandas
+Requires-Dist: tqdm
+Requires-Dist: tabulate
+Provides-Extra: dev
+Requires-Dist: sphinx; extra == "dev"
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: pytest-httpx<=0.27.2,>=0.20.0; extra == "dev"
+Requires-Dist: syrupy>=4; extra == "dev"
+Requires-Dist: pydantic==2.8.2; extra == "dev"
+Requires-Dist: pydantic_core==2.20.1; extra == "dev"
+Requires-Dist: openapi-python-client==0.17.2; extra == "dev"
+Requires-Dist: reorder-python-imports; extra == "dev"
+Requires-Dist: ruff>=0.5.0; extra == "dev"
+Requires-Dist: black==23.12.1; extra == "dev"
+Requires-Dist: mypy; extra == "dev"
+Requires-Dist: types-python-dateutil; extra == "dev"
+Requires-Dist: pandas-stubs; extra == "dev"
+Requires-Dist: types-tqdm; extra == "dev"
+Requires-Dist: types-PyYAML; extra == "dev"
+Requires-Dist: types-tabulate; extra == "dev"
+Requires-Dist: build; extra == "dev"
+Requires-Dist: twine; extra == "dev"
+Provides-Extra: doc
+Requires-Dist: sphinx; extra == "doc"
+
+# PyDelfini
+
+PyDelfini is an easy-to-use Python client for the Delfini data commons
+platform. It's great for scripts, notebooks, or as a foundation for
+other clients to interact with Delfini's public API.
+
+# Quickstart
+
+```
+$ pip install pydelfini
+$ python
+>>> from pydelfini import login
+>>> client = login('delfini.bioteam.net')
+To activate your session, visit the URL below:
+   https://delfini.bioteam.net/login/activate/........
+
+Waiting for session activation...
+>>> collection = client.get_collection_by_name('MHSVI')
+>>> collection
+<DelfiniCollection: name=MHSVI version=LIVE id=...>
+```
+
+# Features
+
+* Interact with collections, folders, and items
+* Read and write data streams (raw files)
+* Read and write data tables via Pandas DataFrames
+
+Coming soon:
+
+* Work with data elements
+    * Persist data elements through DataFrames
+* Work with dataviews (create, edit using simple construction tools)