vastdb 0.1.10__tar.gz → 1.0.0__tar.gz

{vastdb-0.1.10 → vastdb-1.0.0}/CHANGELOG.md

@@ -4,6 +4,25 @@ All notable changes to this project will be documented in this file.
 
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
 
+## [1.0.0] (2024-07-21)
+[1.0.0]: https://github.com/vast-data/vastdb_sdk/compare/v0.1.11...v1.0.0
+
+## Added
+ - Add CLA (`CONTRIBUTING.md`)
+ - Support setting HTTP timeouts
+
+## [0.1.11] (2024-07-17)
+[0.1.11]: https://github.com/vast-data/vastdb_sdk/compare/v0.1.10...v0.1.11
+
+## Fixed
+ - Revert timezone check to keep previous SDK behaviour
+
+## Added
+ - Use Sphinx for building documentation
+
+## Changed
+ - Defer imports to optimize initial import latency
+
 ## [0.1.10] (2024-07-09)
 [0.1.10]: https://github.com/vast-data/vastdb_sdk/compare/v0.1.9...v0.1.10
 

vastdb-1.0.0/CONTRIBUTING.md

@@ -0,0 +1,33 @@
+# VAST DB SDK Contribution License Agreement
+
+Thank you for your interest in VAST DB SDK project (“Project”). You hereby accept and agree to the following terms and conditions (“Agreement”) for Your present and future Contributions (as defined below) submitted to the Project or as part of. Except for the license granted herein to the Project originator – Vast Data Ltd. together with any of its affiliates, assignee, or successor (“Vast Data” or “us” or “we”), You reserve all right, title, and interest in and to Your Contributions.
+
+## Definitions.
+
+"You" (or "Your") shall mean the copyright owner or legal entity authorized by the copyright owner that is making this Agreement with Vast Data. For legal entities, the entity making a Contribution and all other entities that control, are controlled by, or are under common control with that entity are considered to be a single contributor. For the purposes of this definition, "control" means (i) the power, directly or indirectly, to cause the direction or management of such entity, whether by contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the outstanding shares, or (iii) beneficial ownership of such entity.
+
+"Contribution" shall mean the code, documentation, or any original work of authorship, including any modifications or additions to an existing work, that is intentionally submitted by You to the Project (or to Vast Data), inclusion in, or documentation of, the Project (the "Work"). For the purposes of this definition, "submitted" means any form of electronic, verbal, or written communication sent to the Project or its representatives, including but not limited to communication on electronic mailing lists, source code control systems, and issue tracking systems that are managed by, or on behalf of, the Project for the purpose of discussing and improving the Work, but excluding communication that is conspicuously marked or otherwise designated in writing by You as "Not a Contribution."
+
+## Licenses
+
+Grant of Copyright License. Subject to the terms and conditions of this Agreement, You hereby grant to Vast Data and at Vast Data’ discretion, its affiliates, a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable copyright license to reproduce, prepare derivative works of, publicly display, publicly perform, sublicense, sell, and distribute Your Contributions and such derivative works.
+
+Grant of Patent License. Subject to the terms and conditions of this Agreement, You hereby grant to Vast Data and, at Vast Data’ discretion, its affiliates a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable (except as stated in this section) patent license to make, have made, use, offer to sell, sell, import, and otherwise transfer the Work, where such license applies only to those patent claims licensable by You that are necessarily infringed by Your Contribution(s) alone or by the combination of Your Contribution(s) with the Work to which such Contribution(s) was submitted. If any entity institutes patent litigation against You or any other entity (including a cross-claim or counterclaim in a lawsuit) alleging that your Contribution, or the Work to which you have contributed, constitutes a direct or contributory patent infringement, then any patent licenses granted to that entity under this Agreement for that Contribution or Work shall terminate as of the date such litigation is filed.
+
+## Representations
+
+You represent that You are legally entitled to grant the above license. If your employer(s) has rights to intellectual property that you create that includes Your Contributions, You represent that you have received permission to make Contributions on behalf of that employer, that your employer has waived such rights for your Contributions to Vast Data, or that your employer has executed a separate written agreement with Vast Data.
+
+You represent that each of Your Contributions is Your original creation (see below for submissions on behalf of others). You represent that Your Contribution submissions include complete details of any third-party license or other restriction (including, but not limited to, related patents and trademarks) of which you are personally aware, and which are associated with any part of Your Contributions.
+
+You are not expected to provide support for Your Contributions, except to the extent You desire to provide support. You may provide support for free, for a fee, or not at all. 
+
+UNLESS REQUIRED BY APPLICABLE LAW, AGREED TO IN WRITING, OR AS STATED IN THIS CLA, YOU PROVIDE YOUR CONTRIBUTION ON AN "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
+
+Should You wish to submit work that is not Your original creation, You may submit it to Vast Data separately from any Contribution, identifying the complete details of its source and of any license or other restriction (including, but not limited to, related patents, trademarks, and license agreements) of which you are personally aware, and conspicuously marking the work as "Submitted on behalf of a third-party: [named here]". Vast Data shall have the right to determine at its discretion whether or not to use such Contribution.
+
+Code of Conduct
+
+In Your Contribution and/or Work or otherwise in your participation in the Project, you agree to: (i) not use or include any defamatory, illegal, derogatory, abusive, harassing, destructive, malicious, or otherwise, illegitimate content, code or language; or (ii) publish others’ private or personal information without their explicit permission (“Code of Conduct”) Vast Data’ will be entitled but not obligated to enforce the Code of Conduct and may take appropriate and fair action in response to any behaviour that is reasonably deemed by us to be inappropriate, threatening, offensive, or harmful. Further Vast Data will have the right but not the obligation to remove, edit, or reject any comments, code, issues, and other Contributions or Works submitted hereunder including without limitation by reason of nonalignment with the Code of Conduct. 
+
+You agree to notify Vast Data of any facts or circumstances of which you become aware that would make these representations inaccurate in any respect.

{vastdb-0.1.10/vastdb.egg-info → vastdb-1.0.0}/PKG-INFO

@@ -1,12 +1,12 @@
 Metadata-Version: 2.1
 Name: vastdb
-Version: 0.1.10
+Version: 1.0.0
 Summary: VAST Data SDK
 Home-page: https://github.com/vast-data/vastdb_sdk
 Author: VAST DATA
 Author-email: hello@vastdata.com
 License: Copyright (C) VAST Data Ltd.
-Classifier: Development Status :: 4 - Beta
+Classifier: Development Status :: 5 - Production/Stable
 Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.9

{vastdb-0.1.10 → vastdb-1.0.0}/README.md

@@ -2,8 +2,6 @@
 
 # VAST DB Python SDK
 
-🚧 Please note that this package in a pre-release stage. Until version 1.x is officially released, the API should be considered unstable.
-
 ## Introduction
 
 `vastdb` is a Python-based SDK designed for interacting with [VAST Database](https://vastdata.com/database) & [VAST Catalog](https://vastdata.com/blog/vast-catalog-treat-your-file-system-like-a-database), enabling schema and table management, efficient ingest, query and modification of columnar data. For more details, see [our whitepaper](https://vastdata.com/whitepaper/#TheVASTDataBase).

{vastdb-0.1.10 → vastdb-1.0.0}/setup.py

@@ -29,7 +29,7 @@ setup(
     name='vastdb',
     python_requires='>=3.9.0',
     description='VAST Data SDK',
-    version='0.1.10' + suffix,
+    version='1.0.0' + suffix,
     url='https://github.com/vast-data/vastdb_sdk',
     author='VAST DATA',
     author_email='hello@vastdata.com',
@@ -39,7 +39,7 @@ setup(
     long_description=long_description,
     long_description_content_type='text/markdown',
     classifiers=[
-        'Development Status :: 4 - Beta',
+        'Development Status :: 5 - Production/Stable',
         'License :: OSI Approved :: Apache Software License',
         'Programming Language :: Python :: 3',
         'Programming Language :: Python :: 3.9',

{vastdb-0.1.10 → vastdb-1.0.0}/vastdb/__init__.py

@@ -1,9 +1,6 @@
 """VAST Database Python SDK."""
 
 import functools
-import importlib.metadata
-
-__version__ = importlib.metadata.distribution(__package__).version
 
 from . import session
 
@@ -12,3 +9,9 @@ from . import session
 @functools.wraps(session.Session)
 def connect(*args, **kwargs):  # noqa: D103
     return session.Session(*args, **kwargs)
+
+
+def version():
+    """Return VAST DB SDK version."""
+    import importlib
+    return importlib.metadata.distribution(__package__).version

{vastdb-0.1.10 → vastdb-1.0.0}/vastdb/_internal.py

@@ -5,9 +5,8 @@ import re
 import struct
 import urllib.parse
 from collections import defaultdict, namedtuple
-from dataclasses import dataclass, field
 from enum import Enum
-from typing import Any, Callable, Dict, Iterator, List, Optional, Tuple, Union
+from typing import Any, Dict, Iterator, List, Optional, Tuple, Union
 
 import backoff
 import flatbuffers
@@ -104,6 +103,7 @@ from vast_flatbuf.tabular.ListSchemasResponse import ListSchemasResponse as list
 from vast_flatbuf.tabular.ListTablesResponse import ListTablesResponse as list_tables
 
 from . import errors
+from .config import BackoffConfig
 
 UINT64_MAX = 18446744073709551615
 
@@ -742,46 +742,38 @@ def _backoff_giveup(exc: Exception) -> bool:
     return True  # give up in case of other exceptions
 
 
-@dataclass
-class BackoffConfig:
-    wait_gen: Callable = field(default=backoff.expo)
-    max_value: Optional[float] = None  # max duration for a single wait period
-    max_tries: int = 10
-    max_time: float = 60.0  # in seconds
-    backoff_log_level: int = logging.DEBUG
-
-
 class VastdbApi:
     # we expect the vast version to be <major>.<minor>.<patch>.<protocol>
     VAST_VERSION_REGEX = re.compile(r'^vast (\d+\.\d+\.\d+\.\d+)$')
 
     def __init__(self, endpoint, access_key, secret_key,
             *,
-            auth_type=AuthType.SIGV4,
             ssl_verify=True,
+            timeout=None,
             backoff_config: Optional[BackoffConfig] = None):
 
-        from . import __version__  # import lazily here (to avoid circular dependencies)
-        self.client_sdk_version = f"VAST Database Python SDK {__version__} - 2024 (c)"
+        from . import version  # import lazily here (to avoid circular dependencies)
+        self.client_sdk_version = f"VAST Database Python SDK {version()} - 2024 (c)"
 
         url = urllib3.util.parse_url(endpoint)
         self.access_key = access_key
         self.secret_key = secret_key
 
+        self.timeout = timeout
         self.default_max_list_columns_page_size = 1000
         self._session = requests.Session()
         self._session.verify = ssl_verify
         self._session.headers['user-agent'] = self.client_sdk_version
 
-        backoff_config = backoff_config or BackoffConfig()
+        self.backoff_config = backoff_config or BackoffConfig()
         self._backoff_decorator = backoff.on_exception(
-            wait_gen=backoff_config.wait_gen,
+            wait_gen=self.backoff_config.wait_gen,
             exception=_RETRIABLE_EXCEPTIONS,
             giveup=_backoff_giveup,
-            max_tries=backoff_config.max_tries,
-            max_time=backoff_config.max_time,
-            max_value=backoff_config.max_value,  # passed to `backoff_config.wait_gen`
-            backoff_log_level=backoff_config.backoff_log_level)
+            max_tries=self.backoff_config.max_tries,
+            max_time=self.backoff_config.max_time,
+            max_value=self.backoff_config.max_value,  # passed to `self.backoff_config.wait_gen`
+            backoff_log_level=self.backoff_config.backoff_log_level)
         self._request = self._backoff_decorator(self._single_request)
 
         if url.port in {80, 443, None}:
@@ -819,10 +811,18 @@ class VastdbApi:
         _logger.critical(msg)
         raise NotImplementedError(msg)
 
+    def with_endpoint(self, endpoint):
+        return VastdbApi(endpoint=endpoint,
+            access_key=self.access_key,
+            secret_key=self.secret_key,
+            ssl_verify=self._session.verify,
+            timeout=self.timeout,
+            backoff_config=self.backoff_config)
+
     def _single_request(self, *, method, url, skip_status_check=False, **kwargs):
-        _logger.debug("Sending request: %s %s %s", method, url, kwargs)
+        _logger.debug("Sending request: %s %s %s timeout=%s", method, url, kwargs, self.timeout)
         try:
-            res = self._session.request(method=method, url=url, **kwargs)
+            res = self._session.request(method=method, url=url, timeout=self.timeout, **kwargs)
         except requests.exceptions.ConnectionError as err:
             # low-level connection issue, it is safe to retry only read-only requests
             may_retry = (method == "GET")

{vastdb-0.1.10 → vastdb-1.0.0}/vastdb/bench/test_perf.py

@@ -10,11 +10,11 @@ log = logging.getLogger(__name__)
 
 
 @pytest.mark.benchmark
-def test_bench(session, clean_bucket_name, parquets_path, crater_path):
+def test_bench(session, bucket_name, parquets_path, crater_path):
     files = [str(parquets_path / f) for f in (parquets_path.glob('**/*.pq'))]
 
     with session.transaction() as tx:
-        b = tx.bucket(clean_bucket_name)
+        b = tx.bucket(bucket_name)
         s = b.create_schema('s1')
         t = util.create_table_from_files(s, 't1', files, config=ImportConfig(import_concurrency=8))
         config = QueryConfig(num_splits=8, num_sub_splits=4)

{vastdb-0.1.10 → vastdb-1.0.0}/vastdb/bench/test_sample.py

@@ -22,7 +22,8 @@ logging.basicConfig(
 
 log = logging.getLogger()
 
-log.info("Python SDK version: %s", vastdb.util.version())
+sdk_version = vastdb.version()
+log.info("Python SDK version: %s", sdk_version)
 
 NUM_COLUMNS = 10_000
 COLUMNS_BATCH = 10
@@ -63,6 +64,8 @@ def load_batch(bucket, session_kwargs, offset, limit):
             # skip already loaded rows
             log.info('skipping [%d..%d)', offset, limit)
 
+        pid = os.getpid()
+        tid = threading.get_native_id()
         total_nbytes = 0
         calls = 0
         t0 = time.time()
@@ -89,7 +92,7 @@ def load_batch(bucket, session_kwargs, offset, limit):
             metrics_rows.append(metrics.Row(
                 start=start, finish=finish, table_path=table.path, op=op,
                 nbytes=nbytes, rows=len(chunk), cols=len(cols_batch),
-                pid=os.getpid(), tid=threading.get_native_id()))
+                pid=pid, tid=tid, sdk_version=sdk_version))
 
             total_nbytes += nbytes
             calls += 1
@@ -104,12 +107,12 @@ def load_batch(bucket, session_kwargs, offset, limit):
     return metrics_rows
 
 
-def test_ingest(clean_bucket_name, session_kwargs, tabular_endpoint_urls, num_workers, perf_metrics_db):
+def test_ingest(test_bucket_name, session_kwargs, tabular_endpoint_urls, num_workers, perf_metrics_db):
     session = vastdb.connect(**session_kwargs)
     metrics_table = metrics.Table(perf_metrics_db, "ingest")
 
     with session.transaction() as tx:
-        b = tx.bucket(clean_bucket_name)
+        b = tx.bucket(test_bucket_name)
         try:
             s = b.schema(SCHEMA)
         except vastdb.errors.MissingSchema:
@@ -127,7 +130,7 @@ def test_ingest(clean_bucket_name, session_kwargs, tabular_endpoint_urls, num_wo
 
     with ProcessPoolExecutor(max_workers=num_workers) as executor:
         futures = [
-            executor.submit(load_batch, clean_bucket_name, session_kwargs | {'endpoint': url}, offset, limit)
+            executor.submit(load_batch, test_bucket_name, session_kwargs | {'endpoint': url}, offset, limit)
             for (offset, limit), url in zip(ranges, itertools.cycle(tabular_endpoint_urls))
         ]
         log.info("spawned %d futures", len(futures))
@@ -135,7 +138,7 @@ def test_ingest(clean_bucket_name, session_kwargs, tabular_endpoint_urls, num_wo
             metrics_table.insert(future.result())
 
     with session.transaction() as tx:
-        t = tx.bucket(clean_bucket_name).schema(SCHEMA).table(TABLE)
+        t = tx.bucket(test_bucket_name).schema(SCHEMA).table(TABLE)
         count = sum(len(rb) for rb in t.select([]))
         log.info("%s has %d rows: %s", t, count, t.stats)
 
@@ -154,6 +157,10 @@ def run_query(session_kwargs, i, bucket_name, endpoint_url):
     r = random.Random(i)
     r.shuffle(row_group_indices)
 
+    pid = os.getpid()
+    tid = threading.get_native_id()
+    metrics_rows = []
+
     session = vastdb.connect(**(session_kwargs | {"endpoint": endpoint_url}))
     with session.transaction() as tx:
         t = tx.bucket(bucket_name).schema(SCHEMA).table(TABLE)
@@ -174,23 +181,37 @@ def run_query(session_kwargs, i, bucket_name, endpoint_url):
 
         for j, pred in enumerate(preds):
             log.info("%d) starting query #%d on %s", i, j, endpoint_url)
-            t0 = time.time()
+
+            start = time.perf_counter()
             res = t.select(columns=cols, predicate=pred, config=config)
             rows = 0
             data = 0
             for rb in res:
                 rows += len(rb)
                 data += rb.nbytes
-                dt = time.time() - t0
+                dt = time.perf_counter() - start
                 log.info("%d) got query #%d batch %.3f[s], %.3f[GB] %.3f[MB/s], %.3f[Mrows]", i, j, dt, data / 1e9, data / 1e6 / dt, rows / 1e6)
 
-            dt = time.time() - t0
+            finish = time.perf_counter()
+            dt = finish - start
             log.info("%d) finished query #%d %.3f[s], %.3f[GB], %.3f[MB/s], %.3f[Mrows]", i, j, dt, data / 1e9, data / 1e6 / dt, rows / 1e6)
 
+            metrics_rows.append(metrics.Row(
+                start=start, finish=finish, table_path=t.path, op="select",
+                nbytes=data, rows=rows, cols=len(cols),
+                pid=pid, tid=tid, sdk_version=sdk_version))
+
+
+def test_scan(test_bucket_name, session, num_workers, session_kwargs, tabular_endpoint_urls, perf_metrics_db):
+    metrics_table = metrics.Table(perf_metrics_db, "query")
 
-def test_scan(test_bucket_name, session, num_workers, session_kwargs, tabular_endpoint_urls):
     log.info("starting %d workers, endpoints=%s", num_workers, tabular_endpoint_urls)
     with ProcessPoolExecutor(max_workers=num_workers) as executor:
-        for i, url in zip(range(num_workers), itertools.cycle(tabular_endpoint_urls)):
+        futures = [
             executor.submit(run_query, session_kwargs, i, test_bucket_name, url)
+            for i, url in zip(range(num_workers), itertools.cycle(tabular_endpoint_urls))
+        ]
+        for future in as_completed(futures):
+            metrics_table.insert(future.result())
+
     log.info("finished %d workers", num_workers)

vastdb-1.0.0/vastdb/config.py

@@ -0,0 +1,65 @@
+"""Configuration-related dataclasses."""
+
+import logging
+from dataclasses import dataclass, field
+from typing import Callable, List, Optional
+
+import backoff
+
+
+@dataclass
+class BackoffConfig:
+    """Retry configuration."""
+
+    wait_gen: Callable = field(default=backoff.expo)
+    max_value: Optional[float] = None  # max duration for a single wait period
+    max_tries: int = 10
+    max_time: float = 60.0  # in seconds
+    backoff_log_level: int = logging.DEBUG
+
+
+@dataclass
+class QueryConfig:
+    """Query execution configiration."""
+
+    # allows server-side parallel processing by issuing multiple reads concurrently for a single RPC
+    num_sub_splits: int = 4
+
+    # used to split the table into disjoint subsets of rows, to be processed concurrently using multiple RPCs
+    # will be estimated from the table's row count, if not explicitly set
+    num_splits: Optional[int] = None
+
+    # each endpoint will be handled by a separate worker thread
+    # a single endpoint can be specified more than once to benefit from multithreaded execution
+    data_endpoints: Optional[List[str]] = None
+
+    # a subsplit fiber will finish after sending this number of rows back to the client
+    limit_rows_per_sub_split: int = 128 * 1024
+
+    # each fiber will read the following number of rowgroups coninuously before skipping
+    # in order to use semi-sorted projections this value must be 8 (this is the hard coded size of a row groups per row block).
+    num_row_groups_per_sub_split: int = 8
+
+    # can be disabled for benchmarking purposes
+    use_semi_sorted_projections: bool = True
+
+    # enforce using a specific semi-sorted projection (if enabled above)
+    semi_sorted_projection_name: Optional[str] = None
+
+    # used to estimate the number of splits, given the table rows' count
+    rows_per_split: int = 4000000
+
+    # used for worker threads' naming
+    query_id: str = ""
+
+    # non-negative integer, used for server-side prioritization of queued requests:
+    # - requests with lower values will be served before requests with higher values.
+    # - if unset, the request will be added to the queue's end.
+    queue_priority: Optional[int] = None
+
+
+@dataclass
+class ImportConfig:
+    """Import execution configiration."""
+
+    import_concurrency: int = 2

{vastdb-0.1.10 → vastdb-1.0.0}/vastdb/errors.py

@@ -3,7 +3,6 @@ import xml.etree.ElementTree
 from dataclasses import dataclass
 from enum import Enum
 
-import pyarrow as pa
 import requests
 
 
@@ -170,11 +169,6 @@ class NotSupportedCommand(NotSupported):
     table: str
 
 
-@dataclass
-class NotSupportedType(NotSupported):
-    field: pa.Field
-
-
 @dataclass
 class NotSupportedVersion(NotSupported):
     err_msg: str

vastdb-1.0.0/vastdb/features.py

@@ -0,0 +1,42 @@
+"""Version-dependent features."""
+
+import logging
+
+from .errors import NotSupportedVersion
+
+log = logging.getLogger()
+
+
+class Features:
+    """VAST database features - check if server is already support a feature."""
+
+    def __init__(self, vast_version):
+        """Save the server version."""
+        self.vast_version = vast_version
+
+        self.check_imports_table = self._check(
+            "Imported objects' table feature requires 5.2+ VAST release",
+            vast_version >= (5, 2))
+
+        self.check_return_row_ids = self._check(
+            "Returning row IDs requires 5.1+ VAST release",
+            vast_version >= (5, 1))
+
+        self.check_enforce_semisorted_projection = self._check(
+            "Semi-sorted projection enforcement requires 5.1+ VAST release",
+            vast_version >= (5, 1))
+
+        self.check_external_row_ids_allocation = self._check(
+            "External row IDs allocation requires 5.1+ VAST release",
+            vast_version >= (5, 1))
+
+    def _check(self, msg, supported):
+        log.debug("%s (current version is %s): supported=%s", msg, self.vast_version, supported)
+        if not supported:
+            def fail():
+                raise NotSupportedVersion(msg, self.vast_version)
+            return fail
+
+        def noop():
+            pass
+        return noop

{vastdb-0.1.10 → vastdb-1.0.0}/vastdb/schema.py

@@ -10,7 +10,7 @@ from typing import TYPE_CHECKING, Iterable, List, Optional
 
 import pyarrow as pa
 
-from . import bucket, errors, schema, table, util
+from . import bucket, errors, schema, table
 
 if TYPE_CHECKING:
     from .table import Table
@@ -86,7 +86,6 @@ class Schema:
         if use_external_row_ids_allocation:
             self.tx._rpc.features.check_external_row_ids_allocation()
 
-        util.check_supported_types(columns)
         self.tx._rpc.api.create_table(self.bucket.name, self.name, table_name, columns, txid=self.tx.txid,
                                       use_external_row_ids_allocation=use_external_row_ids_allocation)
         log.info("Created table: %s", table_name)

{vastdb-0.1.10 → vastdb-1.0.0}/vastdb/session.py

@@ -7,51 +7,11 @@ For more details see:
 - [Tabular identity policy with the proper permissions](https://support.vastdata.com/s/article/UUID-14322b60-d6a2-89ac-3df0-3dfbb6974182)
 """
 
-import logging
 import os
-from typing import Optional
+from typing import TYPE_CHECKING, Optional
 
-import boto3
-
-from . import _internal, errors, transaction
-from ._internal import BackoffConfig
-
-log = logging.getLogger()
-
-
-class Features:
-    """VAST database features - check if server is already support a feature."""
-
-    def __init__(self, vast_version):
-        """Save the server version."""
-        self.vast_version = vast_version
-
-        self.check_imports_table = self._check(
-            "Imported objects' table feature requires 5.2+ VAST release",
-            vast_version >= (5, 2))
-
-        self.check_return_row_ids = self._check(
-            "Returning row IDs requires 5.1+ VAST release",
-            vast_version >= (5, 1))
-
-        self.check_enforce_semisorted_projection = self._check(
-            "Semi-sorted projection enforcement requires 5.1+ VAST release",
-            vast_version >= (5, 1))
-
-        self.check_external_row_ids_allocation = self._check(
-            "External row IDs allocation requires 5.1+ VAST release",
-            vast_version >= (5, 1))
-
-    def _check(self, msg, supported):
-        log.debug("%s (current version is %s): supported=%s", msg, self.vast_version, supported)
-        if not supported:
-            def fail():
-                raise errors.NotSupportedVersion(msg, self.vast_version)
-            return fail
-
-        def noop():
-            pass
-        return noop
+if TYPE_CHECKING:
+    from .config import BackoffConfig
 
 
 class Session:
@@ -60,8 +20,13 @@ class Session:
     def __init__(self, access=None, secret=None, endpoint=None,
                  *,
                  ssl_verify=True,
-                 backoff_config: Optional[BackoffConfig] = None):
+                 timeout=None,
+                 backoff_config: Optional["BackoffConfig"] = None):
         """Connect to a VAST Database endpoint, using specified credentials."""
+        import boto3
+
+        from . import _internal, features
+
         if access is None:
             access = os.environ['AWS_ACCESS_KEY_ID']
         if secret is None:
@@ -74,8 +39,9 @@ class Session:
             access_key=access,
             secret_key=secret,
             ssl_verify=ssl_verify,
+            timeout=timeout,
             backoff_config=backoff_config)
-        self.features = Features(self.api.vast_version)
+        self.features = features.Features(self.api.vast_version)
         self.s3 = boto3.client('s3',
             aws_access_key_id=access,
             aws_secret_access_key=secret,
@@ -93,4 +59,5 @@ class Session:
             with session.transaction() as tx:
                 tx.bucket("bucket").create_schema("schema")
         """
+        from . import transaction
         return transaction.Transaction(self)