============================= test session starts ==============================
platform linux -- Python 3.10.12, pytest-9.0.2, pluggy-1.6.0 -- /usr/bin/python
cachedir: .pytest_cache
metadata: {'Python': '3.10.12', 'Platform': 'Linux-6.8.0-1025-gke-x86_64-with-glibc2.35', 'Packages': {'pytest': '9.0.2', 'pluggy': '1.6.0'}, 'Plugins': {'anyio': '4.12.1', 'metadata': '3.1.1', 'json-report': '1.5.0', 'cov': '7.0.0'}}
rootdir: /workspace/tinydb
configfile: pytest.ini
plugins: anyio-4.12.1, metadata-3.1.1, json-report-1.5.0, cov-7.0.0
collecting ... collected 201 items

tests/test_middlewares.py::test_caching ERROR                            [  0%]
tests/test_middlewares.py::test_caching_read FAILED                      [  0%]
tests/test_middlewares.py::test_caching_write_many ERROR                 [  1%]
tests/test_middlewares.py::test_caching_flush ERROR                      [  1%]
tests/test_middlewares.py::test_caching_flush_manually ERROR             [  2%]
tests/test_middlewares.py::test_caching_write ERROR                      [  2%]
tests/test_middlewares.py::test_nested FAILED                            [  3%]
tests/test_middlewares.py::test_caching_json_write FAILED                [  3%]
tests/test_operations.py::test_delete[memory] ERROR                      [  4%]
tests/test_operations.py::test_delete[json] ERROR                        [  4%]
tests/test_operations.py::test_add_int[memory] ERROR                     [  5%]
tests/test_operations.py::test_add_int[json] ERROR                       [  5%]
tests/test_operations.py::test_add_str[memory] ERROR                     [  6%]
tests/test_operations.py::test_add_str[json] ERROR                       [  6%]
tests/test_operations.py::test_subtract[memory] ERROR                    [  7%]
tests/test_operations.py::test_subtract[json] ERROR                      [  7%]
tests/test_operations.py::test_set[memory] ERROR                         [  8%]
tests/test_operations.py::test_set[json] ERROR                           [  8%]
tests/test_operations.py::test_increment[memory] ERROR                   [  9%]
tests/test_operations.py::test_increment[json] ERROR                     [  9%]
tests/test_operations.py::test_decrement[memory] ERROR                   [ 10%]
tests/test_operations.py::test_decrement[json] ERROR                     [ 10%]
tests/test_queries.py::test_no_path PASSED                               [ 11%]
tests/test_queries.py::test_path_exists PASSED                           [ 11%]
tests/test_queries.py::test_path_and PASSED                              [ 12%]
tests/test_queries.py::test_callable_in_path_with_map PASSED             [ 12%]
tests/test_queries.py::test_callable_in_path_with_chain PASSED           [ 13%]
tests/test_queries.py::test_eq PASSED                                    [ 13%]
tests/test_queries.py::test_ne PASSED                                    [ 14%]
tests/test_queries.py::test_lt PASSED                                    [ 14%]
tests/test_queries.py::test_le PASSED                                    [ 15%]
tests/test_queries.py::test_gt PASSED                                    [ 15%]
tests/test_queries.py::test_ge PASSED                                    [ 16%]
tests/test_queries.py::test_or PASSED                                    [ 16%]
tests/test_queries.py::test_and PASSED                                   [ 17%]
tests/test_queries.py::test_not PASSED                                   [ 17%]
tests/test_queries.py::test_has_key PASSED                               [ 18%]
tests/test_queries.py::test_regex PASSED                                 [ 18%]
tests/test_queries.py::test_custom PASSED                                [ 19%]
tests/test_queries.py::test_custom_with_params PASSED                    [ 19%]
tests/test_queries.py::test_any FAILED                                   [ 20%]
tests/test_queries.py::test_all FAILED                                   [ 20%]
tests/test_queries.py::test_has PASSED                                   [ 21%]
tests/test_queries.py::test_one_of PASSED                                [ 21%]
tests/test_queries.py::test_hash PASSED                                  [ 22%]
tests/test_queries.py::test_orm_usage PASSED                             [ 22%]
tests/test_queries.py::test_repr PASSED                                  [ 23%]
tests/test_queries.py::test_subclass PASSED                              [ 23%]
tests/test_queries.py::test_noop PASSED                                  [ 24%]
tests/test_queries.py::test_equality PASSED                              [ 24%]
tests/test_queries.py::test_empty_query_error PASSED                     [ 25%]
tests/test_queries.py::test_fragment FAILED                              [ 25%]
tests/test_queries.py::test_fragment_with_path FAILED                    [ 26%]
tests/test_queries.py::test_get_item PASSED                              [ 26%]
tests/test_storages.py::test_json FAILED                                 [ 27%]
tests/test_storages.py::test_json_kwargs FAILED                          [ 27%]
tests/test_storages.py::test_json_readwrite FAILED                       [ 28%]
tests/test_storages.py::test_json_read FAILED                            [ 28%]
tests/test_storages.py::test_create_dirs FAILED                          [ 29%]
tests/test_storages.py::test_json_invalid_directory FAILED               [ 29%]
tests/test_storages.py::test_in_memory FAILED                            [ 30%]
tests/test_storages.py::test_in_memory_close FAILED                      [ 30%]
tests/test_storages.py::test_custom PASSED                               [ 31%]
tests/test_storages.py::test_read_once FAILED                            [ 31%]
tests/test_storages.py::test_custom_with_exception PASSED                [ 32%]
tests/test_storages.py::test_yaml FAILED                                 [ 32%]
tests/test_storages.py::test_encoding FAILED                             [ 33%]
tests/test_tables.py::test_next_id[memory] ERROR                         [ 33%]
tests/test_tables.py::test_next_id[json] ERROR                           [ 34%]
tests/test_tables.py::test_tables_list[memory] ERROR                     [ 34%]
tests/test_tables.py::test_tables_list[json] ERROR                       [ 35%]
tests/test_tables.py::test_one_table[memory] ERROR                       [ 35%]
tests/test_tables.py::test_one_table[json] ERROR                         [ 36%]
tests/test_tables.py::test_multiple_tables[memory] ERROR                 [ 36%]
tests/test_tables.py::test_multiple_tables[json] ERROR                   [ 37%]
tests/test_tables.py::test_caching[memory] ERROR                         [ 37%]
tests/test_tables.py::test_caching[json] ERROR                           [ 38%]
tests/test_tables.py::test_query_cache[memory] ERROR                     [ 38%]
tests/test_tables.py::test_query_cache[json] ERROR                       [ 39%]
tests/test_tables.py::test_query_cache_with_mutable_callable[memory] ERROR [ 39%]
tests/test_tables.py::test_query_cache_with_mutable_callable[json] ERROR [ 40%]
tests/test_tables.py::test_zero_cache_size[memory] ERROR                 [ 40%]
tests/test_tables.py::test_zero_cache_size[json] ERROR                   [ 41%]
tests/test_tables.py::test_query_cache_size[memory] ERROR                [ 41%]
tests/test_tables.py::test_query_cache_size[json] ERROR                  [ 42%]
tests/test_tables.py::test_lru_cache[memory] ERROR                       [ 42%]
tests/test_tables.py::test_lru_cache[json] ERROR                         [ 43%]
tests/test_tables.py::test_table_is_iterable[memory] ERROR               [ 43%]
tests/test_tables.py::test_table_is_iterable[json] ERROR                 [ 44%]
tests/test_tables.py::test_table_name[memory] ERROR                      [ 44%]
tests/test_tables.py::test_table_name[json] ERROR                        [ 45%]
tests/test_tables.py::test_table_repr[memory] ERROR                      [ 45%]
tests/test_tables.py::test_table_repr[json] ERROR                        [ 46%]
tests/test_tables.py::test_truncate_table[memory] ERROR                  [ 46%]
tests/test_tables.py::test_truncate_table[json] ERROR                    [ 47%]
tests/test_tinydb.py::test_drop_tables[memory] ERROR                     [ 47%]
tests/test_tinydb.py::test_drop_tables[json] ERROR                       [ 48%]
tests/test_tinydb.py::test_all[memory] ERROR                             [ 48%]
tests/test_tinydb.py::test_all[json] ERROR                               [ 49%]
tests/test_tinydb.py::test_insert[memory] ERROR                          [ 49%]
tests/test_tinydb.py::test_insert[json] ERROR                            [ 50%]
tests/test_tinydb.py::test_insert_ids[memory] ERROR                      [ 50%]
tests/test_tinydb.py::test_insert_ids[json] ERROR                        [ 51%]
tests/test_tinydb.py::test_insert_with_doc_id[memory] ERROR              [ 51%]
tests/test_tinydb.py::test_insert_with_doc_id[json] ERROR                [ 52%]
tests/test_tinydb.py::test_insert_with_duplicate_doc_id[memory] ERROR    [ 52%]
tests/test_tinydb.py::test_insert_with_duplicate_doc_id[json] ERROR      [ 53%]
tests/test_tinydb.py::test_insert_multiple[memory] ERROR                 [ 53%]
tests/test_tinydb.py::test_insert_multiple[json] ERROR                   [ 54%]
tests/test_tinydb.py::test_insert_multiple_with_ids[memory] ERROR        [ 54%]
tests/test_tinydb.py::test_insert_multiple_with_ids[json] ERROR          [ 55%]
tests/test_tinydb.py::test_insert_multiple_with_doc_ids[memory] ERROR    [ 55%]
tests/test_tinydb.py::test_insert_multiple_with_doc_ids[json] ERROR      [ 56%]
tests/test_tinydb.py::test_insert_invalid_type_raises_error[memory] ERROR [ 56%]
tests/test_tinydb.py::test_insert_invalid_type_raises_error[json] ERROR  [ 57%]
tests/test_tinydb.py::test_insert_valid_mapping_type[memory] ERROR       [ 57%]
tests/test_tinydb.py::test_insert_valid_mapping_type[json] ERROR         [ 58%]
tests/test_tinydb.py::test_custom_mapping_type_with_json FAILED          [ 58%]
tests/test_tinydb.py::test_remove[memory] ERROR                          [ 59%]
tests/test_tinydb.py::test_remove[json] ERROR                            [ 59%]
tests/test_tinydb.py::test_remove_all_fails[memory] ERROR                [ 60%]
tests/test_tinydb.py::test_remove_all_fails[json] ERROR                  [ 60%]
tests/test_tinydb.py::test_remove_multiple[memory] ERROR                 [ 61%]
tests/test_tinydb.py::test_remove_multiple[json] ERROR                   [ 61%]
tests/test_tinydb.py::test_remove_ids[memory] ERROR                      [ 62%]
tests/test_tinydb.py::test_remove_ids[json] ERROR                        [ 62%]
tests/test_tinydb.py::test_remove_returns_ids[memory] ERROR              [ 63%]
tests/test_tinydb.py::test_remove_returns_ids[json] ERROR                [ 63%]
tests/test_tinydb.py::test_update[memory] ERROR                          [ 64%]
tests/test_tinydb.py::test_update[json] ERROR                            [ 64%]
tests/test_tinydb.py::test_update_all[memory] ERROR                      [ 65%]
tests/test_tinydb.py::test_update_all[json] ERROR                        [ 65%]
tests/test_tinydb.py::test_update_returns_ids[memory] ERROR              [ 66%]
tests/test_tinydb.py::test_update_returns_ids[json] ERROR                [ 66%]
tests/test_tinydb.py::test_update_transform[memory] ERROR                [ 67%]
tests/test_tinydb.py::test_update_transform[json] ERROR                  [ 67%]
tests/test_tinydb.py::test_update_ids[memory] ERROR                      [ 68%]
tests/test_tinydb.py::test_update_ids[json] ERROR                        [ 68%]
tests/test_tinydb.py::test_update_multiple[memory] ERROR                 [ 69%]
tests/test_tinydb.py::test_update_multiple[json] ERROR                   [ 69%]
tests/test_tinydb.py::test_update_multiple_operation[memory] ERROR       [ 70%]
tests/test_tinydb.py::test_update_multiple_operation[json] ERROR         [ 70%]
tests/test_tinydb.py::test_upsert[memory] ERROR                          [ 71%]
tests/test_tinydb.py::test_upsert[json] ERROR                            [ 71%]
tests/test_tinydb.py::test_upsert_by_id[memory] ERROR                    [ 72%]
tests/test_tinydb.py::test_upsert_by_id[json] ERROR                      [ 72%]
tests/test_tinydb.py::test_search[memory] ERROR                          [ 73%]
tests/test_tinydb.py::test_search[json] ERROR                            [ 73%]
tests/test_tinydb.py::test_search_path[memory] ERROR                     [ 74%]
tests/test_tinydb.py::test_search_path[json] ERROR                       [ 74%]
tests/test_tinydb.py::test_search_no_results_cache[memory] ERROR         [ 75%]
tests/test_tinydb.py::test_search_no_results_cache[json] ERROR           [ 75%]
tests/test_tinydb.py::test_get[memory] ERROR                             [ 76%]
tests/test_tinydb.py::test_get[json] ERROR                               [ 76%]
tests/test_tinydb.py::test_get_ids[memory] ERROR                         [ 77%]
tests/test_tinydb.py::test_get_ids[json] ERROR                           [ 77%]
tests/test_tinydb.py::test_get_multiple_ids[memory] ERROR                [ 78%]
tests/test_tinydb.py::test_get_multiple_ids[json] ERROR                  [ 78%]
tests/test_tinydb.py::test_get_invalid[memory] ERROR                     [ 79%]
tests/test_tinydb.py::test_get_invalid[json] ERROR                       [ 79%]
tests/test_tinydb.py::test_count[memory] ERROR                           [ 80%]
tests/test_tinydb.py::test_count[json] ERROR                             [ 80%]
tests/test_tinydb.py::test_contains[memory] ERROR                        [ 81%]
tests/test_tinydb.py::test_contains[json] ERROR                          [ 81%]
tests/test_tinydb.py::test_contains_ids[memory] ERROR                    [ 82%]
tests/test_tinydb.py::test_contains_ids[json] ERROR                      [ 82%]
tests/test_tinydb.py::test_contains_invalid[memory] ERROR                [ 83%]
tests/test_tinydb.py::test_contains_invalid[json] ERROR                  [ 83%]
tests/test_tinydb.py::test_get_idempotent[memory] ERROR                  [ 84%]
tests/test_tinydb.py::test_get_idempotent[json] ERROR                    [ 84%]
tests/test_tinydb.py::test_multiple_dbs FAILED                           [ 85%]
tests/test_tinydb.py::test_storage_closed_once PASSED                    [ 85%]
tests/test_tinydb.py::test_unique_ids FAILED                             [ 86%]
tests/test_tinydb.py::test_lastid_after_open FAILED                      [ 86%]
tests/test_tinydb.py::test_doc_ids_json FAILED                           [ 87%]
tests/test_tinydb.py::test_insert_string FAILED                          [ 87%]
tests/test_tinydb.py::test_insert_invalid_dict FAILED                    [ 88%]
tests/test_tinydb.py::test_gc FAILED                                     [ 88%]
tests/test_tinydb.py::test_drop_table FAILED                             [ 89%]
tests/test_tinydb.py::test_empty_write FAILED                            [ 89%]
tests/test_tinydb.py::test_query_cache FAILED                            [ 90%]
tests/test_tinydb.py::test_tinydb_is_iterable[memory] ERROR              [ 90%]
tests/test_tinydb.py::test_tinydb_is_iterable[json] ERROR                [ 91%]
tests/test_tinydb.py::test_repr FAILED                                   [ 91%]
tests/test_tinydb.py::test_delete FAILED                                 [ 92%]
tests/test_tinydb.py::test_insert_multiple_with_single_dict[memory] ERROR [ 92%]
tests/test_tinydb.py::test_insert_multiple_with_single_dict[json] ERROR  [ 93%]
tests/test_tinydb.py::test_access_storage FAILED                         [ 93%]
tests/test_tinydb.py::test_empty_db_len FAILED                           [ 94%]
tests/test_tinydb.py::test_insert_on_existing_db FAILED                  [ 94%]
tests/test_tinydb.py::test_storage_access FAILED                         [ 95%]
tests/test_tinydb.py::test_lambda_query FAILED                           [ 95%]
tests/test_utils.py::test_lru_cache PASSED                               [ 96%]
tests/test_utils.py::test_lru_cache_set_multiple PASSED                  [ 96%]
tests/test_utils.py::test_lru_cache_get PASSED                           [ 97%]
tests/test_utils.py::test_lru_cache_delete PASSED                        [ 97%]
tests/test_utils.py::test_lru_cache_clear PASSED                         [ 98%]
tests/test_utils.py::test_lru_cache_unlimited PASSED                     [ 98%]
tests/test_utils.py::test_lru_cache_unlimited_explicit PASSED            [ 99%]
tests/test_utils.py::test_lru_cache_iteration_works PASSED               [ 99%]
tests/test_utils.py::test_freeze FAILED                                  [100%]

==================================== ERRORS ====================================
________________________ ERROR at setup of test_caching ________________________

    @pytest.fixture
    def storage():
>       return CachingMiddleware(MemoryStorage)()

tests/conftest.py:27: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <tinydb.middlewares.CachingMiddleware object at 0x7f06a92e80a0>
args = (), kwargs = {}

    def __call__(self, *args, **kwargs):
        """
        Create the storage instance and store it as self.storage.
    
        Usually a user creates a new TinyDB instance like this::
    
            TinyDB(storage=StorageClass)
    
        The storage keyword argument is used by TinyDB this way::
    
            self.storage = storage(*args, **kwargs)
    
        As we can see, ``storage(...)`` runs the constructor and returns the
        new storage instance.
    
    
        Using Middlewares, the user will call::
    
                                       The 'real' storage class
                                       v
            TinyDB(storage=Middleware(StorageClass))
                       ^
                       Already an instance!
    
        So, when running ``self.storage = storage(*args, **kwargs)`` Python
        now will call ``__call__`` and TinyDB will expect the return value to
        be the storage (or Middleware) instance. Returning the instance is
        simple, but we also got the underlying (*real*) StorageClass as an
        __init__ argument that still is not an instance.
        So, we initialize it in __call__ forwarding any arguments we receive
        from TinyDB (``TinyDB(arg1, kwarg1=value, storage=...)``).
    
        In case of nested Middlewares, calling the instance as if it was a
        class results in calling ``__call__`` what initializes the next
        nested Middleware that itself will initialize the next Middleware and
        so on.
        """
>       self.storage = self._storage_cls(*args, **kwargs)
E       TypeError: Can't instantiate abstract class MemoryStorage with abstract methods read, write

tinydb/middlewares.py:60: TypeError
__________________ ERROR at setup of test_caching_write_many ___________________

    @pytest.fixture
    def storage():
>       return CachingMiddleware(MemoryStorage)()

tests/conftest.py:27: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <tinydb.middlewares.CachingMiddleware object at 0x7f06a920d960>
args = (), kwargs = {}

    def __call__(self, *args, **kwargs):
        """
        Create the storage instance and store it as self.storage.
    
        Usually a user creates a new TinyDB instance like this::
    
            TinyDB(storage=StorageClass)
    
        The storage keyword argument is used by TinyDB this way::
    
            self.storage = storage(*args, **kwargs)
    
        As we can see, ``storage(...)`` runs the constructor and returns the
        new storage instance.
    
    
        Using Middlewares, the user will call::
    
                                       The 'real' storage class
                                       v
            TinyDB(storage=Middleware(StorageClass))
                       ^
                       Already an instance!
    
        So, when running ``self.storage = storage(*args, **kwargs)`` Python
        now will call ``__call__`` and TinyDB will expect the return value to
        be the storage (or Middleware) instance. Returning the instance is
        simple, but we also got the underlying (*real*) StorageClass as an
        __init__ argument that still is not an instance.
        So, we initialize it in __call__ forwarding any arguments we receive
        from TinyDB (``TinyDB(arg1, kwarg1=value, storage=...)``).
    
        In case of nested Middlewares, calling the instance as if it was a
        class results in calling ``__call__`` what initializes the next
        nested Middleware that itself will initialize the next Middleware and
        so on.
        """
>       self.storage = self._storage_cls(*args, **kwargs)
E       TypeError: Can't instantiate abstract class MemoryStorage with abstract methods read, write

tinydb/middlewares.py:60: TypeError
_____________________ ERROR at setup of test_caching_flush _____________________

    @pytest.fixture
    def storage():
>       return CachingMiddleware(MemoryStorage)()

tests/conftest.py:27: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <tinydb.middlewares.CachingMiddleware object at 0x7f06a92e83a0>
args = (), kwargs = {}

    def __call__(self, *args, **kwargs):
        """
        Create the storage instance and store it as self.storage.
    
        Usually a user creates a new TinyDB instance like this::
    
            TinyDB(storage=StorageClass)
    
        The storage keyword argument is used by TinyDB this way::
    
            self.storage = storage(*args, **kwargs)
    
        As we can see, ``storage(...)`` runs the constructor and returns the
        new storage instance.
    
    
        Using Middlewares, the user will call::
    
                                       The 'real' storage class
                                       v
            TinyDB(storage=Middleware(StorageClass))
                       ^
                       Already an instance!
    
        So, when running ``self.storage = storage(*args, **kwargs)`` Python
        now will call ``__call__`` and TinyDB will expect the return value to
        be the storage (or Middleware) instance. Returning the instance is
        simple, but we also got the underlying (*real*) StorageClass as an
        __init__ argument that still is not an instance.
        So, we initialize it in __call__ forwarding any arguments we receive
        from TinyDB (``TinyDB(arg1, kwarg1=value, storage=...)``).
    
        In case of nested Middlewares, calling the instance as if it was a
        class results in calling ``__call__`` what initializes the next
        nested Middleware that itself will initialize the next Middleware and
        so on.
        """
>       self.storage = self._storage_cls(*args, **kwargs)
E       TypeError: Can't instantiate abstract class MemoryStorage with abstract methods read, write

tinydb/middlewares.py:60: TypeError
________________ ERROR at setup of test_caching_flush_manually _________________

    @pytest.fixture
    def storage():
>       return CachingMiddleware(MemoryStorage)()

tests/conftest.py:27: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <tinydb.middlewares.CachingMiddleware object at 0x7f06a920ded0>
args = (), kwargs = {}

    def __call__(self, *args, **kwargs):
        """
        Create the storage instance and store it as self.storage.
    
        Usually a user creates a new TinyDB instance like this::
    
            TinyDB(storage=StorageClass)
    
        The storage keyword argument is used by TinyDB this way::
    
            self.storage = storage(*args, **kwargs)
    
        As we can see, ``storage(...)`` runs the constructor and returns the
        new storage instance.
    
    
        Using Middlewares, the user will call::
    
                                       The 'real' storage class
                                       v
            TinyDB(storage=Middleware(StorageClass))
                       ^
                       Already an instance!
    
        So, when running ``self.storage = storage(*args, **kwargs)`` Python
        now will call ``__call__`` and TinyDB will expect the return value to
        be the storage (or Middleware) instance. Returning the instance is
        simple, but we also got the underlying (*real*) StorageClass as an
        __init__ argument that still is not an instance.
        So, we initialize it in __call__ forwarding any arguments we receive
        from TinyDB (``TinyDB(arg1, kwarg1=value, storage=...)``).
    
        In case of nested Middlewares, calling the instance as if it was a
        class results in calling ``__call__`` what initializes the next
        nested Middleware that itself will initialize the next Middleware and
        so on.
        """
>       self.storage = self._storage_cls(*args, **kwargs)
E       TypeError: Can't instantiate abstract class MemoryStorage with abstract methods read, write

tinydb/middlewares.py:60: TypeError
_____________________ ERROR at setup of test_caching_write _____________________

    @pytest.fixture
    def storage():
>       return CachingMiddleware(MemoryStorage)()

tests/conftest.py:27: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <tinydb.middlewares.CachingMiddleware object at 0x7f06a92eb550>
args = (), kwargs = {}

    def __call__(self, *args, **kwargs):
        """
        Create the storage instance and store it as self.storage.
    
        Usually a user creates a new TinyDB instance like this::
    
            TinyDB(storage=StorageClass)
    
        The storage keyword argument is used by TinyDB this way::
    
            self.storage = storage(*args, **kwargs)
    
        As we can see, ``storage(...)`` runs the constructor and returns the
        new storage instance.
    
    
        Using Middlewares, the user will call::
    
                                       The 'real' storage class
                                       v
            TinyDB(storage=Middleware(StorageClass))
                       ^
                       Already an instance!
    
        So, when running ``self.storage = storage(*args, **kwargs)`` Python
        now will call ``__call__`` and TinyDB will expect the return value to
        be the storage (or Middleware) instance. Returning the instance is
        simple, but we also got the underlying (*real*) StorageClass as an
        __init__ argument that still is not an instance.
        So, we initialize it in __call__ forwarding any arguments we receive
        from TinyDB (``TinyDB(arg1, kwarg1=value, storage=...)``).
    
        In case of nested Middlewares, calling the instance as if it was a
        class results in calling ``__call__`` what initializes the next
        nested Middleware that itself will initialize the next Middleware and
        so on.
        """
>       self.storage = self._storage_cls(*args, **kwargs)
E       TypeError: Can't instantiate abstract class MemoryStorage with abstract methods read, write

tinydb/middlewares.py:60: TypeError
____________________ ERROR at setup of test_delete[memory] _____________________

request = <SubRequest 'db' for <Function test_delete[memory]>>
tmp_path = PosixPath('/tmp/pytest-of-openhands/pytest-0/test_delete_memory_0')

    @pytest.fixture(params=['memory', 'json'])
    def db(request, tmp_path: Path):
        if request.param == 'json':
            db_ = TinyDB(tmp_path / 'test.db', storage=JSONStorage)
        else:
>           db_ = TinyDB(storage=MemoryStorage)

tests/conftest.py:17: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <[TypeError("'NoneType' object is not iterable") raised in repr()] TinyDB object at 0x7f06a920c310>
args = (), kwargs = {}, storage = <class 'tinydb.storages.MemoryStorage'>

    def __init__(self, *args, **kwargs) -> None:
        """
        Create a new instance of TinyDB.
        """
        storage = kwargs.pop('storage', self.default_storage_class)
>       self._storage: Storage = storage(*args, **kwargs)
E       TypeError: Can't instantiate abstract class MemoryStorage with abstract methods read, write

tinydb/database.py:74: TypeError
_____________________ ERROR at setup of test_delete[json] ______________________

request = <SubRequest 'db' for <Function test_delete[json]>>
tmp_path = PosixPath('/tmp/pytest-of-openhands/pytest-0/test_delete_json_0')

    @pytest.fixture(params=['memory', 'json'])
    def db(request, tmp_path: Path):
        if request.param == 'json':
>           db_ = TinyDB(tmp_path / 'test.db', storage=JSONStorage)

tests/conftest.py:15: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <[TypeError("'NoneType' object is not iterable") raised in repr()] TinyDB object at 0x7f06a92154e0>
args = (PosixPath('/tmp/pytest-of-openhands/pytest-0/test_delete_json_0/test.db'),)
kwargs = {}, storage = <class 'tinydb.storages.JSONStorage'>

    def __init__(self, *args, **kwargs) -> None:
        """
        Create a new instance of TinyDB.
        """
        storage = kwargs.pop('storage', self.default_storage_class)
>       self._storage: Storage = storage(*args, **kwargs)
E       TypeError: Can't instantiate abstract class JSONStorage with abstract methods read, write

tinydb/database.py:74: TypeError
____________________ ERROR at setup of test_add_int[memory] ____________________

request = <SubRequest 'db' for <Function test_add_int[memory]>>
tmp_path = PosixPath('/tmp/pytest-of-openhands/pytest-0/test_add_int_memory_0')

    @pytest.fixture(params=['memory', 'json'])
    def db(request, tmp_path: Path):
        if request.param == 'json':
            db_ = TinyDB(tmp_path / 'test.db', storage=JSONStorage)
        else:
>           db_ = TinyDB(storage=MemoryStorage)

tests/conftest.py:17: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <[TypeError("'NoneType' object is not iterable") raised in repr()] TinyDB object at 0x7f06a920c040>
args = (), kwargs = {}, storage = <class 'tinydb.storages.MemoryStorage'>

    def __init__(self, *args, **kwargs) -> None:
        """
        Create a new instance of TinyDB.
        """
        storage = kwargs.pop('storage', self.default_storage_class)
>       self._storage: Storage = storage(*args, **kwargs)
E       TypeError: Can't instantiate abstract class MemoryStorage with abstract methods read, write

tinydb/database.py:74: TypeError
_____________________ ERROR at setup of test_add_int[json] _____________________

request = <SubRequest 'db' for <Function test_add_int[json]>>
tmp_path = PosixPath('/tmp/pytest-of-openhands/pytest-0/test_add_int_json_0')

    @pytest.fixture(params=['memory', 'json'])
    def db(request, tmp_path: Path):
        if request.param == 'json':
>           db_ = TinyDB(tmp_path / 'test.db', storage=JSONStorage)

tests/conftest.py:15: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <[TypeError("'NoneType' object is not iterable") raised in repr()] TinyDB object at 0x7f06a9453730>
args = (PosixPath('/tmp/pytest-of-openhands/pytest-0/test_add_int_json_0/test.db'),)
kwargs = {}, storage = <class 'tinydb.storages.JSONStorage'>

    def __init__(self, *args, **kwargs) -> None:
        """
        Create a new instance of TinyDB.
        """
        storage = kwargs.pop('storage', self.default_storage_class)
>       self._storage: Storage = storage(*args, **kwargs)
E       TypeError: Can't instantiate abstract class JSONStorage with abstract methods read, write

tinydb/database.py:74: TypeError
____________________ ERROR at setup of test_add_str[memory] ____________________

request = <SubRequest 'db' for <Function test_add_str[memory]>>
tmp_path = PosixPath('/tmp/pytest-of-openhands/pytest-0/test_add_str_memory_0')

    @pytest.fixture(params=['memory', 'json'])
    def db(request, tmp_path: Path):
        if request.param == 'json':
            db_ = TinyDB(tmp_path / 'test.db', storage=JSONStorage)
        else:
>           db_ = TinyDB(storage=MemoryStorage)

tests/conftest.py:17: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <[TypeError("'NoneType' object is not iterable") raised in repr()] TinyDB object at 0x7f06a92d8790>
args = (), kwargs = {}, storage = <class 'tinydb.storages.MemoryStorage'>

    def __init__(self, *args, **kwargs) -> None:
        """
        Create a new instance of TinyDB.
        """
        storage = kwargs.pop('storage', self.default_storage_class)
>       self._storage: Storage = storage(*args, **kwargs)
E       TypeError: Can't instantiate abstract class MemoryStorage with abstract methods read, write

tinydb/database.py:74: TypeError
_____________________ ERROR at setup of test_add_str[json] _____________________

request = <SubRequest 'db' for <Function test_add_str[json]>>
tmp_path = PosixPath('/tmp/pytest-of-openhands/pytest-0/test_add_str_json_0')

    @pytest.fixture(params=['memory', 'json'])
    def db(request, tmp_path: Path):
        if request.param == 'json':
>           db_ = TinyDB(tmp_path / 'test.db', storage=JSONStorage)

tests/conftest.py:15: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <[TypeError("'NoneType' object is not iterable") raised in repr()] TinyDB object at 0x7f06a92141f0>
args = (PosixPath('/tmp/pytest-of-openhands/pytest-0/test_add_str_json_0/test.db'),)
kwargs = {}, storage = <class 'tinydb.storages.JSONStorage'>

    def __init__(self, *args, **kwargs) -> None:
        """
        Create a new instance of TinyDB.
        """
        storage = kwargs.pop('storage', self.default_storage_class)
>       self._storage: Storage = storage(*args, **kwargs)
E       TypeError: Can't instantiate abstract class JSONStorage with abstract methods read, write

tinydb/database.py:74: TypeError
___________________ ERROR at setup of test_subtract[memory] ____________________

request = <SubRequest 'db' for <Function test_subtract[memory]>>
tmp_path = PosixPath('/tmp/pytest-of-openhands/pytest-0/test_subtract_memory_0')

    @pytest.fixture(params=['memory', 'json'])
    def db(request, tmp_path: Path):
        if request.param == 'json':
            db_ = TinyDB(tmp_path / 'test.db', storage=JSONStorage)
        else:
>           db_ = TinyDB(storage=MemoryStorage)

tests/conftest.py:17: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <[TypeError("'NoneType' object is not iterable") raised in repr()] TinyDB object at 0x7f06a92e8d60>
args = (), kwargs = {}, storage = <class 'tinydb.storages.MemoryStorage'>

    def __init__(self, *args, **kwargs) -> None:
        """
        Create a new instance of TinyDB.
        """
        storage = kwargs.pop('storage', self.default_storage_class)
>       self._storage: Storage = storage(*args, **kwargs)
E       TypeError: Can't instantiate abstract class MemoryStorage with abstract methods read, write

tinydb/database.py:74: TypeError
____________________ ERROR at setup of test_subtract[json] _____________________

request = <SubRequest 'db' for <Function test_subtract[json]>>
tmp_path = PosixPath('/tmp/pytest-of-openhands/pytest-0/test_subtract_json_0')

    @pytest.fixture(params=['memory', 'json'])
    def db(request, tmp_path: Path):
        if request.param == 'json':
>           db_ = TinyDB(tmp_path / 'test.db', storage=JSONStorage)

tests/conftest.py:15: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <[TypeError("'NoneType' object is not iterable") raised in repr()] TinyDB object at 0x7f06a9214e80>
args = (PosixPath('/tmp/pytest-of-openhands/pytest-0/test_subtract_json_0/test.db'),)
kwargs = {}, storage = <class 'tinydb.storages.JSONStorage'>

    def __init__(self, *args, **kwargs) -> None:
        """
        Create a new instance of TinyDB.
        """
        storage = kwargs.pop('storage', self.default_storage_class)
>       self._storage: Storage = storage(*args, **kwargs)
E       TypeError: Can't instantiate abstract class JSONStorage with abstract methods read, write

tinydb/database.py:74: TypeError
______________________ ERROR at setup of test_set[memory] ______________________

request = <SubRequest 'db' for <Function test_set[memory]>>
tmp_path = PosixPath('/tmp/pytest-of-openhands/pytest-0/test_set_memory_0')

    @pytest.fixture(params=['memory', 'json'])
    def db(request, tmp_path: Path):
        if request.param == 'json':
            db_ = TinyDB(tmp_path / 'test.db', storage=JSONStorage)
        else:
>           db_ = TinyDB(storage=MemoryStorage)

tests/conftest.py:17: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <[TypeError("'NoneType' object is not iterable") raised in repr()] TinyDB object at 0x7f06a92e9ae0>
args = (), kwargs = {}, storage = <class 'tinydb.storages.MemoryStorage'>

    def __init__(self, *args, **kwargs) -> None:
        """
        Create a new instance of TinyDB.
        """
        storage = kwargs.pop('storage', self.default_storage_class)
>       self._storage: Storage = storage(*args, **kwargs)
E       TypeError: Can't instantiate abstract class MemoryStorage with abstract methods read, write

tinydb/database.py:74: TypeError
_______________________ ERROR at setup of test_set[json] _______________________

request = <SubRequest 'db' for <Function test_set[json]>>
tmp_path = PosixPath('/tmp/pytest-of-openhands/pytest-0/test_set_json_0')

    @pytest.fixture(params=['memory', 'json'])
    def db(request, tmp_path: Path):
        if request.param == 'json':
>           db_ = TinyDB(tmp_path / 'test.db', storage=JSONStorage)

tests/conftest.py:15: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <[TypeError("'NoneType' object is not iterable") raised in repr()] TinyDB object at 0x7f06a934b730>
args = (PosixPath('/tmp/pytest-of-openhands/pytest-0/test_set_json_0/test.db'),)
kwargs = {}, storage = <class 'tinydb.storages.JSONStorage'>

    def __init__(self, *args, **kwargs) -> None:
        """
        Create a new instance of TinyDB.
        """
        storage = kwargs.pop('storage', self.default_storage_class)
>       self._storage: Storage = storage(*args, **kwargs)
E       TypeError: Can't instantiate abstract class JSONStorage with abstract methods read, write

tinydb/database.py:74: TypeError
___________________ ERROR at setup of test_increment[memory] ___________________

request = <SubRequest 'db' for <Function test_increment[memory]>>
tmp_path = PosixPath('/tmp/pytest-of-openhands/pytest-0/test_increment_memory_0')

    @pytest.fixture(params=['memory', 'json'])
    def db(request, tmp_path: Path):
        if request.param == 'json':
            db_ = TinyDB(tmp_path / 'test.db', storage=JSONStorage)
        else:
>           db_ = TinyDB(storage=MemoryStorage)

tests/conftest.py:17: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <[TypeError("'NoneType' object is not iterable") raised in repr()] TinyDB object at 0x7f06a920f700>
args = (), kwargs = {}, storage = <class 'tinydb.storages.MemoryStorage'>

    def __init__(self, *args, **kwargs) -> None:
        """
        Create a new instance of TinyDB.
        """
        storage = kwargs.pop('storage', self.default_storage_class)
>       self._storage: Storage = storage(*args, **kwargs)
E       TypeError: Can't instantiate abstract class MemoryStorage with abstract methods read, write

tinydb/database.py:74: TypeError
____________________ ERROR at setup of test_increment[json] ____________________

request = <SubRequest 'db' for <Function test_increment[json]>>
tmp_path = PosixPath('/tmp/pytest-of-openhands/pytest-0/test_increment_json_0')

    @pytest.fixture(params=['memory', 'json'])
    def db(request, tmp_path: Path):
        if request.param == 'json':
>           db_ = TinyDB(tmp_path / 'test.db', storage=JSONStorage)

tests/conftest.py:15: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <[TypeError("'NoneType' object is not iterable") raised in repr()] TinyDB object at 0x7f06a920fbe0>
args = (PosixPath('/tmp/pytest-of-openhands/pytest-0/test_increment_json_0/test.db'),)
kwargs = {}, storage = <class 'tinydb.storages.JSONStorage'>

    def __init__(self, *args, **kwargs) -> None:
        """
        Create a new instance of TinyDB.
        """
        storage = kwargs.pop('storage', self.default_storage_class)
>       self._storage: Storage = storage(*args, **kwargs)
E       TypeError: Can't instantiate abstract class JSONStorage with abstract methods read, write

tinydb/database.py:74: TypeError
___________________ ERROR at setup of test_decrement[memory] ___________________

request = <SubRequest 'db' for <Function test_decrement[memory]>>
tmp_path = PosixPath('/tmp/pytest-of-openhands/pytest-0/test_decrement_memory_0')

    @pytest.fixture(params=['memory', 'json'])
    def db(request, tmp_path: Path):
        if request.param == 'json':
            db_ = TinyDB(tmp_path / 'test.db', storage=JSONStorage)
        else:
>           db_ = TinyDB(storage=MemoryStorage)

tests/conftest.py:17: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <[TypeError("'NoneType' object is not iterable") raised in repr()] TinyDB object at 0x7f06a931a650>
args = (), kwargs = {}, storage = <class 'tinydb.storages.MemoryStorage'>

    def __init__(self, *args, **kwargs) -> None:
        """
        Create a new instance of TinyDB.
        """
        storage = kwargs.pop('storage', self.default_storage_class)
>       self._storage: Storage = storage(*args, **kwargs)
E       TypeError: Can't instantiate abstract class MemoryStorage with abstract methods read, write

tinydb/database.py:74: TypeError
____________________ ERROR at setup of test_decrement[json] ____________________

request = <SubRequest 'db' for <Function test_decrement[json]>>
tmp_path = PosixPath('/tmp/pytest-of-openhands/pytest-0/test_decrement_json_0')

    @pytest.fixture(params=['memory', 'json'])
    def db(request, tmp_path: Path):
        if request.param == 'json':
>           db_ = TinyDB(tmp_path / 'test.db', storage=JSONStorage)

tests/conftest.py:15: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <[TypeError("'NoneType' object is not iterable") raised in repr()] TinyDB object at 0x7f06a9316830>
args = (PosixPath('/tmp/pytest-of-openhands/pytest-0/test_decrement_json_0/test.db'),)
kwargs = {}, storage = <class 'tinydb.storages.JSONStorage'>

    def __init__(self, *args, **kwargs) -> None:
        """
        Create a new instance of TinyDB.
        """
        storage = kwargs.pop('storage', self.default_storage_class)
>       self._storage: Storage = storage(*args, **kwargs)
E       TypeError: Can't instantiate abstract class JSONStorage with abstract methods read, write

tinydb/database.py:74: TypeError
____________________ ERROR at setup of test_next_id[memory] ____________________

request = <SubRequest 'db' for <Function test_next_id[memory]>>
tmp_path = PosixPath('/tmp/pytest-of-openhands/pytest-0/test_next_id_memory_0')

    @pytest.fixture(params=['memory', 'json'])
    def db(request, tmp_path: Path):
        if request.param == 'json':
            db_ = TinyDB(tmp_path / 'test.db', storage=JSONStorage)
        else:
>           db_ = TinyDB(storage=MemoryStorage)

tests/conftest.py:17: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <[TypeError("'NoneType' object is not iterable") raised in repr()] TinyDB object at 0x7f06a924ad70>
args = (), kwargs = {}, storage = <class 'tinydb.storages.MemoryStorage'>

    def __init__(self, *args, **kwargs) -> None:
        """
        Create a new instance of TinyDB.
        """
        storage = kwargs.pop('storage', self.default_storage_class)
>       self._storage: Storage = storage(*args, **kwargs)
E       TypeError: Can't instantiate abstract class MemoryStorage with abstract methods read, write

tinydb/database.py:74: TypeError
_____________________ ERROR at setup of test_next_id[json] _____________________

request = <SubRequest 'db' for <Function test_next_id[json]>>
tmp_path = PosixPath('/tmp/pytest-of-openhands/pytest-0/test_next_id_json_0')

    @pytest.fixture(params=['memory', 'json'])
    def db(request, tmp_path: Path):
        if request.param == 'json':
>           db_ = TinyDB(tmp_path / 'test.db', storage=JSONStorage)

tests/conftest.py:15: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <[TypeError("'NoneType' object is not iterable") raised in repr()] TinyDB object at 0x7f06a920f100>
args = (PosixPath('/tmp/pytest-of-openhands/pytest-0/test_next_id_json_0/test.db'),)
kwargs = {}, storage = <class 'tinydb.storages.JSONStorage'>

    def __init__(self, *args, **kwargs) -> None:
        """
        Create a new instance of TinyDB.
        """
        storage = kwargs.pop('storage', self.default_storage_class)
>       self._storage: Storage = storage(*args, **kwargs)
E       TypeError: Can't instantiate abstract class JSONStorage with abstract methods read, write

tinydb/database.py:74: TypeError
__________________ ERROR at setup of test_tables_list[memory] __________________

request = <SubRequest 'db' for <Function test_tables_list[memory]>>
tmp_path = PosixPath('/tmp/pytest-of-openhands/pytest-0/test_tables_list_memory_0')

    @pytest.fixture(params=['memory', 'json'])
    def db(request, tmp_path: Path):
        if request.param == 'json':
            db_ = TinyDB(tmp_path / 'test.db', storage=JSONStorage)
        else:
>           db_ = TinyDB(storage=MemoryStorage)

tests/conftest.py:17: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <[TypeError("'NoneType' object is not iterable") raised in repr()] TinyDB object at 0x7f06a929e200>
args = (), kwargs = {}, storage = <class 'tinydb.storages.MemoryStorage'>

    def __init__(self, *args, **kwargs) -> None:
        """
        Create a new instance of TinyDB.
        """
        storage = kwargs.pop('storage', self.default_storage_class)
>       self._storage: Storage = storage(*args, **kwargs)
E       TypeError: Can't instantiate abstract class MemoryStorage with abstract methods read, write

tinydb/database.py:74: TypeError
___________________ ERROR at setup of test_tables_list[json] ___________________

request = <SubRequest 'db' for <Function test_tables_list[json]>>
tmp_path = PosixPath('/tmp/pytest-of-openhands/pytest-0/test_tables_list_json_0')

    @pytest.fixture(params=['memory', 'json'])
    def db(request, tmp_path: Path):
        if request.param == 'json':
>           db_ = TinyDB(tmp_path / 'test.db', storage=JSONStorage)

tests/conftest.py:15: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <[TypeError("'NoneType' object is not iterable") raised in repr()] TinyDB object at 0x7f06a920c970>
args = (PosixPath('/tmp/pytest-of-openhands/pytest-0/test_tables_list_json_0/test.db'),)
kwargs = {}, storage = <class 'tinydb.storages.JSONStorage'>

    def __init__(self, *args, **kwargs) -> None:
        """
        Create a new instance of TinyDB.
        """
        storage = kwargs.pop('storage', self.default_storage_class)
>       self._storage: Storage = storage(*args, **kwargs)
E       TypeError: Can't instantiate abstract class JSONStorage with abstract methods read, write

tinydb/database.py:74: TypeError
___________________ ERROR at setup of test_one_table[memory] ___________________

request = <SubRequest 'db' for <Function test_one_table[memory]>>
tmp_path = PosixPath('/tmp/pytest-of-openhands/pytest-0/test_one_table_memory_0')

    @pytest.fixture(params=['memory', 'json'])
    def db(request, tmp_path: Path):
        if request.param == 'json':
            db_ = TinyDB(tmp_path / 'test.db', storage=JSONStorage)
        else:
>           db_ = TinyDB(storage=MemoryStorage)

tests/conftest.py:17: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <[TypeError("'NoneType' object is not iterable") raised in repr()] TinyDB object at 0x7f06a929d810>
args = (), kwargs = {}, storage = <class 'tinydb.storages.MemoryStorage'>

    def __init__(self, *args, **kwargs) -> None:
        """
        Create a new instance of TinyDB.
        """
        storage = kwargs.pop('storage', self.default_storage_class)
>       self._storage: Storage = storage(*args, **kwargs)
E       TypeError: Can't instantiate abstract class MemoryStorage with abstract methods read, write

tinydb/database.py:74: TypeError
____________________ ERROR at setup of test_one_table[json] ____________________

request = <SubRequest 'db' for <Function test_one_table[json]>>
tmp_path = PosixPath('/tmp/pytest-of-openhands/pytest-0/test_one_table_json_0')

    @pytest.fixture(params=['memory', 'json'])
    def db(request, tmp_path: Path):
        if request.param == 'json':
>           db_ = TinyDB(tmp_path / 'test.db', storage=JSONStorage)

tests/conftest.py:15: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <[TypeError("'NoneType' object is not iterable") raised in repr()] TinyDB object at 0x7f06a931b340>
args = (PosixPath('/tmp/pytest-of-openhands/pytest-0/test_one_table_json_0/test.db'),)
kwargs = {}, storage = <class 'tinydb.storages.JSONStorage'>

    def __init__(self, *args, **kwargs) -> None:
        """
        Create a new instance of TinyDB.
        """
        storage = kwargs.pop('storage', self.default_storage_class)
>       self._storage: Storage = storage(*args, **kwargs)
E       TypeError: Can't instantiate abstract class JSONStorage with abstract methods read, write

tinydb/database.py:74: TypeError
________________ ERROR at setup of test_multiple_tables[memory] ________________

request = <SubRequest 'db' for <Function test_multiple_tables[memory]>>
tmp_path = PosixPath('/tmp/pytest-of-openhands/pytest-0/test_multiple_tables_memory_0')

    @pytest.fixture(params=['memory', 'json'])
    def db(request, tmp_path: Path):
        if request.param == 'json':
            db_ = TinyDB(tmp_path / 'test.db', storage=JSONStorage)
        else:
>           db_ = TinyDB(storage=MemoryStorage)

tests/conftest.py:17: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <[TypeError("'NoneType' object is not iterable") raised in repr()] TinyDB object at 0x7f06a929c070>
args = (), kwargs = {}, storage = <class 'tinydb.storages.MemoryStorage'>

    def __init__(self, *args, **kwargs) -> None:
        """
        Create a new instance of TinyDB.
        """
        storage = kwargs.pop('storage', self.default_storage_class)
>       self._storage: Storage = storage(*args, **kwargs)
E       TypeError: Can't instantiate abstract class MemoryStorage with abstract methods read, write

tinydb/database.py:74: TypeError
_________________ ERROR at setup of test_multiple_tables[json] _________________

request = <SubRequest 'db' for <Function test_multiple_tables[json]>>
tmp_path = PosixPath('/tmp/pytest-of-openhands/pytest-0/test_multiple_tables_json_0')

    @pytest.fixture(params=['memory', 'json'])
    def db(request, tmp_path: Path):
        if request.param == 'json':
>           db_ = TinyDB(tmp_path / 'test.db', storage=JSONStorage)

tests/conftest.py:15: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <[TypeError("'NoneType' object is not iterable") raised in repr()] TinyDB object at 0x7f06a92c9930>
args = (PosixPath('/tmp/pytest-of-openhands/pytest-0/test_multiple_tables_json_0/test.db'),)
kwargs = {}, storage = <class 'tinydb.storages.JSONStorage'>

    def __init__(self, *args, **kwargs) -> None:
        """
        Create a new instance of TinyDB.
        """
        storage = kwargs.pop('storage', self.default_storage_class)
>       self._storage: Storage = storage(*args, **kwargs)
E       TypeError: Can't instantiate abstract class JSONStorage with abstract methods read, write

tinydb/database.py:74: TypeError
____________________ ERROR at setup of test_caching[memory] ____________________

request = <SubRequest 'db' for <Function test_caching[memory]>>
tmp_path = PosixPath('/tmp/pytest-of-openhands/pytest-0/test_caching_memory_0')

    @pytest.fixture(params=['memory', 'json'])
    def db(request, tmp_path: Path):
        if request.param == 'json':
            db_ = TinyDB(tmp_path / 'test.db', storage=JSONStorage)
        else:
>           db_ = TinyDB(storage=MemoryStorage)

tests/conftest.py:17: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <[TypeError("'NoneType' object is not iterable") raised in repr()] TinyDB object at 0x7f06a929e350>
args = (), kwargs = {}, storage = <class 'tinydb.storages.MemoryStorage'>

    def __init__(self, *args, **kwargs) -> None:
        """
        Create a new instance of TinyDB.
        """
        storage = kwargs.pop('storage', self.default_storage_class)
>       self._storage: Storage = storage(*args, **kwargs)
E       TypeError: Can't instantiate abstract class MemoryStorage with abstract methods read, write

tinydb/database.py:74: TypeError
_____________________ ERROR at setup of test_caching[json] _____________________

request = <SubRequest 'db' for <Function test_caching[json]>>
tmp_path = PosixPath('/tmp/pytest-of-openhands/pytest-0/test_caching_json_0')

    @pytest.fixture(params=['memory', 'json'])
    def db(request, tmp_path: Path):
        if request.param == 'json':
>           db_ = TinyDB(tmp_path / 'test.db', storage=JSONStorage)

tests/conftest.py:15: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <[TypeError("'NoneType' object is not iterable") raised in repr()] TinyDB object at 0x7f06a92c8d90>
args = (PosixPath('/tmp/pytest-of-openhands/pytest-0/test_caching_json_0/test.db'),)
kwargs = {}, storage = <class 'tinydb.storages.JSONStorage'>

    def __init__(self, *args, **kwargs) -> None:
        """
        Create a new instance of TinyDB.
        """
        storage = kwargs.pop('storage', self.default_storage_class)
>       self._storage: Storage = storage(*args, **kwargs)
E       TypeError: Can't instantiate abstract class JSONStorage with abstract methods read, write

tinydb/database.py:74: TypeError
__________________ ERROR at setup of test_query_cache[memory] __________________

request = <SubRequest 'db' for <Function test_query_cache[memory]>>
tmp_path = PosixPath('/tmp/pytest-of-openhands/pytest-0/test_query_cache_memory_0')

    @pytest.fixture(params=['memory', 'json'])
    def db(request, tmp_path: Path):
        if request.param == 'json':
            db_ = TinyDB(tmp_path / 'test.db', storage=JSONStorage)
        else:
>           db_ = TinyDB(storage=MemoryStorage)

tests/conftest.py:17: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <[TypeError("'NoneType' object is not iterable") raised in repr()] TinyDB object at 0x7f06a92c8550>
args = (), kwargs = {}, storage = <class 'tinydb.storages.MemoryStorage'>

    def __init__(self, *args, **kwargs) -> None:
        """
        Create a new instance of TinyDB.
        """
        storage = kwargs.pop('storage', self.default_storage_class)
>       self._storage: Storage = storage(*args, **kwargs)
E       TypeError: Can't instantiate abstract class MemoryStorage with abstract methods read, write

tinydb/database.py:74: TypeError
___________________ ERROR at setup of test_query_cache[json] ___________________

request = <SubRequest 'db' for <Function test_query_cache[json]>>
tmp_path = PosixPath('/tmp/pytest-of-openhands/pytest-0/test_query_cache_json_0')

    @pytest.fixture(params=['memory', 'json'])
    def db(request, tmp_path: Path):
        if request.param == 'json':
>           db_ = TinyDB(tmp_path / 'test.db', storage=JSONStorage)

tests/conftest.py:15: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <[TypeError("'NoneType' object is not iterable") raised in repr()] TinyDB object at 0x7f06a9452c50>
args = (PosixPath('/tmp/pytest-of-openhands/pytest-0/test_query_cache_json_0/test.db'),)
kwargs = {}, storage = <class 'tinydb.storages.JSONStorage'>

    def __init__(self, *args, **kwargs) -> None:
        """
        Create a new instance of TinyDB.
        """
        storage = kwargs.pop('storage', self.default_storage_class)
>       self._storage: Storage = storage(*args, **kwargs)
E       TypeError: Can't instantiate abstract class JSONStorage with abstract methods read, write

tinydb/database.py:74: TypeError
_______ ERROR at setup of test_query_cache_with_mutable_callable[memory] _______

request = <SubRequest 'db' for <Function test_query_cache_with_mutable_callable[memory]>>
tmp_path = PosixPath('/tmp/pytest-of-openhands/pytest-0/test_query_cache_with_mutable_0')

    @pytest.fixture(params=['memory', 'json'])
    def db(request, tmp_path: Path):
        if request.param == 'json':
            db_ = TinyDB(tmp_path / 'test.db', storage=JSONStorage)
        else:
>           db_ = TinyDB(storage=MemoryStorage)

tests/conftest.py:17: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <[TypeError("'NoneType' object is not iterable") raised in repr()] TinyDB object at 0x7f06a931bb20>
args = (), kwargs = {}, storage = <class 'tinydb.storages.MemoryStorage'>

    def __init__(self, *args, **kwargs) -> None:
        """
        Create a new instance of TinyDB.
        """
        storage = kwargs.pop('storage', self.default_storage_class)
>       self._storage: Storage = storage(*args, **kwargs)
E       TypeError: Can't instantiate abstract class MemoryStorage with abstract methods read, write

tinydb/database.py:74: TypeError
________ ERROR at setup of test_query_cache_with_mutable_callable[json] ________

request = <SubRequest 'db' for <Function test_query_cache_with_mutable_callable[json]>>
tmp_path = PosixPath('/tmp/pytest-of-openhands/pytest-0/test_query_cache_with_mutable_1')

    @pytest.fixture(params=['memory', 'json'])
    def db(request, tmp_path: Path):
        if request.param == 'json':
>           db_ = TinyDB(tmp_path / 'test.db', storage=JSONStorage)

tests/conftest.py:15: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <[TypeError("'NoneType' object is not iterable") raised in repr()] TinyDB object at 0x7f06a929b5b0>
args = (PosixPath('/tmp/pytest-of-openhands/pytest-0/test_query_cache_with_mutable_1/test.db'),)
kwargs = {}, storage = <class 'tinydb.storages.JSONStorage'>

    def __init__(self, *args, **kwargs) -> None:
        """
        Create a new instance of TinyDB.
        """
        storage = kwargs.pop('storage', self.default_storage_class)
>       self._storage: Storage = storage(*args, **kwargs)
E       TypeError: Can't instantiate abstract class JSONStorage with abstract methods read, write

tinydb/database.py:74: TypeError
________________ ERROR at setup of test_zero_cache_size[memory] ________________

request = <SubRequest 'db' for <Function test_zero_cache_size[memory]>>
tmp_path = PosixPath('/tmp/pytest-of-openhands/pytest-0/test_zero_cache_size_memory_0')

    @pytest.fixture(params=['memory', 'json'])
    def db(request, tmp_path: Path):
        if request.param == 'json':
            db_ = TinyDB(tmp_path / 'test.db', storage=JSONStorage)
        else:
>           db_ = TinyDB(storage=MemoryStorage)

tests/conftest.py:17: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <[TypeError("'NoneType' object is not iterable") raised in repr()] TinyDB object at 0x7f06a929e2c0>
args = (), kwargs = {}, storage = <class 'tinydb.storages.MemoryStorage'>

    def __init__(self, *args, **kwargs) -> None:
        """
        Create a new instance of TinyDB.
        """
        storage = kwargs.pop('storage', self.default_storage_class)
>       self._storage: Storage = storage(*args, **kwargs)
E       TypeError: Can't instantiate abstract class MemoryStorage with abstract methods read, write

tinydb/database.py:74: TypeError
_________________ ERROR at setup of test_zero_cache_size[json] _________________

request = <SubRequest 'db' for <Function test_zero_cache_size[json]>>
tmp_path = PosixPath('/tmp/pytest-of-openhands/pytest-0/test_zero_cache_size_json_0')

    @pytest.fixture(params=['memory', 'json'])
    def db(request, tmp_path: Path):
        if request.param == 'json':
>           db_ = TinyDB(tmp_path / 'test.db', storage=JSONStorage)

tests/conftest.py:15: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <[TypeError("'NoneType' object is not iterable") raised in repr()] TinyDB object at 0x7f06a9298a00>
args = (PosixPath('/tmp/pytest-of-openhands/pytest-0/test_zero_cache_size_json_0/test.db'),)
kwargs = {}, storage = <class 'tinydb.storages.JSONStorage'>

    def __init__(self, *args, **kwargs) -> None:
        """
        Create a new instance of TinyDB.
        """
        storage = kwargs.pop('storage', self.default_storage_class)
>       self._storage: Storage = storage(*args, **kwargs)
E       TypeError: Can't instantiate abstract class JSONStorage with abstract methods read, write

tinydb/database.py:74: TypeError
_______________ ERROR at setup of test_query_cache_size[memory] ________________

request = <SubRequest 'db' for <Function test_query_cache_size[memory]>>
tmp_path = PosixPath('/tmp/pytest-of-openhands/pytest-0/test_query_cache_size_memory_0')

    @pytest.fixture(params=['memory', 'json'])
    def db(request, tmp_path: Path):
        if request.param == 'json':
            db_ = TinyDB(tmp_path / 'test.db', storage=JSONStorage)
        else:
>           db_ = TinyDB(storage=MemoryStorage)

tests/conftest.py:17: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <[TypeError("'NoneType' object is not iterable") raised in repr()] TinyDB object at 0x7f06a920e1d0>
args = (), kwargs = {}, storage = <class 'tinydb.storages.MemoryStorage'>

    def __init__(self, *args, **kwargs) -> None:
        """
        Create a new instance of TinyDB.
        """
        storage = kwargs.pop('storage', self.default_storage_class)
>       self._storage: Storage = storage(*args, **kwargs)
E       TypeError: Can't instantiate abstract class MemoryStorage with abstract methods read, write

tinydb/database.py:74: TypeError
________________ ERROR at setup of test_query_cache_size[json] _________________

request = <SubRequest 'db' for <Function test_query_cache_size[json]>>
tmp_path = PosixPath('/tmp/pytest-of-openhands/pytest-0/test_query_cache_size_json_0')

    @pytest.fixture(params=['memory', 'json'])
    def db(request, tmp_path: Path):
        if request.param == 'json':
>           db_ = TinyDB(tmp_path / 'test.db', storage=JSONStorage)

tests/conftest.py:15: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <[TypeError("'NoneType' object is not iterable") raised in repr()] TinyDB object at 0x7f06a9317cd0>
args = (PosixPath('/tmp/pytest-of-openhands/pytest-0/test_query_cache_size_json_0/test.db'),)
kwargs = {}, storage = <class 'tinydb.storages.JSONStorage'>

    def __init__(self, *args, **kwargs) -> None:
        """
        Create a new instance of TinyDB.
        """
        storage = kwargs.pop('storage', self.default_storage_class)
>       self._storage: Storage = storage(*args, **kwargs)
E       TypeError: Can't instantiate abstract class JSONStorage with abstract methods read, write

tinydb/database.py:74: TypeError
___________________ ERROR at setup of test_lru_cache[memory] ___________________

request = <SubRequest 'db' for <Function test_lru_cache[memory]>>
tmp_path = PosixPath('/tmp/pytest-of-openhands/pytest-0/test_lru_cache_memory_0')

    @pytest.fixture(params=['memory', 'json'])
    def db(request, tmp_path: Path):
        if request.param == 'json':
            db_ = TinyDB(tmp_path / 'test.db', storage=JSONStorage)
        else:
>           db_ = TinyDB(storage=MemoryStorage)

tests/conftest.py:17: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <[TypeError("'NoneType' object is not iterable") raised in repr()] TinyDB object at 0x7f06a929dc90>
args = (), kwargs = {}, storage = <class 'tinydb.storages.MemoryStorage'>

    def __init__(self, *args, **kwargs) -> None:
        """
        Create a new instance of TinyDB.
        """
        storage = kwargs.pop('storage', self.default_storage_class)
>       self._storage: Storage = storage(*args, **kwargs)
E       TypeError: Can't instantiate abstract class MemoryStorage with abstract methods read, write

tinydb/database.py:74: TypeError
____________________ ERROR at setup of test_lru_cache[json] ____________________

request = <SubRequest 'db' for <Function test_lru_cache[json]>>
tmp_path = PosixPath('/tmp/pytest-of-openhands/pytest-0/test_lru_cache_json_0')

    @pytest.fixture(params=['memory', 'json'])
    def db(request, tmp_path: Path):
        if request.param == 'json':
>           db_ = TinyDB(tmp_path / 'test.db', storage=JSONStorage)

tests/conftest.py:15: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <[TypeError("'NoneType' object is not iterable") raised in repr()] TinyDB object at 0x7f06a9315f90>
args = (PosixPath('/tmp/pytest-of-openhands/pytest-0/test_lru_cache_json_0/test.db'),)
kwargs = {}, storage = <class 'tinydb.storages.JSONStorage'>

    def __init__(self, *args, **kwargs) -> None:
        """
        Create a new instance of TinyDB.
        """
        storage = kwargs.pop('storage', self.default_storage_class)
>       self._storage: Storage = storage(*args, **kwargs)
E       TypeError: Can't instantiate abstract class JSONStorage with abstract methods read, write

tinydb/database.py:74: TypeError
_______________ ERROR at setup of test_table_is_iterable[memory] _______________

request = <SubRequest 'db' for <Function test_table_is_iterable[memory]>>
tmp_path = PosixPath('/tmp/pytest-of-openhands/pytest-0/test_table_is_iterable_memory_0')

    @pytest.fixture(params=['memory', 'json'])
    def db(request, tmp_path: Path):
        if request.param == 'json':
            db_ = TinyDB(tmp_path / 'test.db', storage=JSONStorage)
        else:
>           db_ = TinyDB(storage=MemoryStorage)

tests/conftest.py:17: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <[TypeError("'NoneType' object is not iterable") raised in repr()] TinyDB object at 0x7f06a929fb80>
args = (), kwargs = {}, storage = <class 'tinydb.storages.MemoryStorage'>

    def __init__(self, *args, **kwargs) -> None:
        """
        Create a new instance of TinyDB.
        """
        storage = kwargs.pop('storage', self.default_storage_class)
>       self._storage: Storage = storage(*args, **kwargs)
E       TypeError: Can't instantiate abstract class MemoryStorage with abstract methods read, write

tinydb/database.py:74: TypeError
________________ ERROR at setup of test_table_is_iterable[json] ________________

request = <SubRequest 'db' for <Function test_table_is_iterable[json]>>
tmp_path = PosixPath('/tmp/pytest-of-openhands/pytest-0/test_table_is_iterable_json_0')

    @pytest.fixture(params=['memory', 'json'])
    def db(request, tmp_path: Path):
        if request.param == 'json':
>           db_ = TinyDB(tmp_path / 'test.db', storage=JSONStorage)

tests/conftest.py:15: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <[TypeError("'NoneType' object is not iterable") raised in repr()] TinyDB object at 0x7f06a929b130>
args = (PosixPath('/tmp/pytest-of-openhands/pytest-0/test_table_is_iterable_json_0/test.db'),)
kwargs = {}, storage = <class 'tinydb.storages.JSONStorage'>

    def __init__(self, *args, **kwargs) -> None:
        """
        Create a new instance of TinyDB.
        """
        storage = kwargs.pop('storage', self.default_storage_class)
>       self._storage: Storage = storage(*args, **kwargs)
E       TypeError: Can't instantiate abstract class JSONStorage with abstract methods read, write

tinydb/database.py:74: TypeError
__________________ ERROR at setup of test_table_name[memory] ___________________

request = <SubRequest 'db' for <Function test_table_name[memory]>>
tmp_path = PosixPath('/tmp/pytest-of-openhands/pytest-0/test_table_name_memory_0')

    @pytest.fixture(params=['memory', 'json'])
    def db(request, tmp_path: Path):
        if request.param == 'json':
            db_ = TinyDB(tmp_path / 'test.db', storage=JSONStorage)
        else:
>           db_ = TinyDB(storage=MemoryStorage)

tests/conftest.py:17: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <[TypeError("'NoneType' object is not iterable") raised in repr()] TinyDB object at 0x7f06a92151e0>
args = (), kwargs = {}, storage = <class 'tinydb.storages.MemoryStorage'>

    def __init__(self, *args, **kwargs) -> None:
        """
        Create a new instance of TinyDB.
        """
        storage = kwargs.pop('storage', self.default_storage_class)
>       self._storage: Storage = storage(*args, **kwargs)
E       TypeError: Can't instantiate abstract class MemoryStorage with abstract methods read, write

tinydb/database.py:74: TypeError
___________________ ERROR at setup of test_table_name[json] ____________________

request = <SubRequest 'db' for <Function test_table_name[json]>>
tmp_path = PosixPath('/tmp/pytest-of-openhands/pytest-0/test_table_name_json_0')

    @pytest.fixture(params=['memory', 'json'])
    def db(request, tmp_path: Path):
        if request.param == 'json':
>           db_ = TinyDB(tmp_path / 'test.db', storage=JSONStorage)

tests/conftest.py:15: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <[TypeError("'NoneType' object is not iterable") raised in repr()] TinyDB object at 0x7f06a931b580>
args = (PosixPath('/tmp/pytest-of-openhands/pytest-0/test_table_name_json_0/test.db'),)
kwargs = {}, storage = <class 'tinydb.storages.JSONStorage'>

    def __init__(self, *args, **kwargs) -> None:
        """
        Create a new instance of TinyDB.
        """
        storage = kwargs.pop('storage', self.default_storage_class)
>       self._storage: Storage = storage(*args, **kwargs)
E       TypeError: Can't instantiate abstract class JSONStorage with abstract methods read, write

tinydb/database.py:74: TypeError
__________________ ERROR at setup of test_table_repr[memory] ___________________

request = <SubRequest 'db' for <Function test_table_repr[memory]>>
tmp_path = PosixPath('/tmp/pytest-of-openhands/pytest-0/test_table_repr_memory_0')

    @pytest.fixture(params=['memory', 'json'])
    def db(request, tmp_path: Path):
        if request.param == 'json':
            db_ = TinyDB(tmp_path / 'test.db', storage=JSONStorage)
        else:
>           db_ = TinyDB(storage=MemoryStorage)

tests/conftest.py:17: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <[TypeError("'NoneType' object is not iterable") raised in repr()] TinyDB object at 0x7f06a929d480>
args = (), kwargs = {}, storage = <class 'tinydb.storages.MemoryStorage'>

    def __init__(self, *args, **kwargs) -> None:
        """
        Create a new instance of TinyDB.
        """
        storage = kwargs.pop('storage', self.default_storage_class)
>       self._storage: Storage = storage(*args, **kwargs)
E       TypeError: Can't instantiate abstract class MemoryStorage with abstract methods read, write

tinydb/database.py:74: TypeError
___________________ ERROR at setup of test_table_repr[json] ____________________

request = <SubRequest 'db' for <Function test_table_repr[json]>>
tmp_path = PosixPath('/tmp/pytest-of-openhands/pytest-0/test_table_repr_json_0')

    @pytest.fixture(params=['memory', 'json'])
    def db(request, tmp_path: Path):
        if request.param == 'json':
>           db_ = TinyDB(tmp_path / 'test.db', storage=JSONStorage)

tests/conftest.py:15: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <[TypeError("'NoneType' object is not iterable") raised in repr()] TinyDB object at 0x7f06a92ca0b0>
args = (PosixPath('/tmp/pytest-of-openhands/pytest-0/test_table_repr_json_0/test.db'),)
kwargs = {}, storage = <class 'tinydb.storages.JSONStorage'>

    def __init__(self, *args, **kwargs) -> None:
        """
        Create a new instance of TinyDB.
        """
        storage = kwargs.pop('storage', self.default_storage_class)
>       self._storage: Storage = storage(*args, **kwargs)
E       TypeError: Can't instantiate abstract class JSONStorage with abstract methods read, write

tinydb/database.py:74: TypeError
________________ ERROR at setup of test_truncate_table[memory] _________________

request = <SubRequest 'db' for <Function test_truncate_table[memory]>>
tmp_path = PosixPath('/tmp/pytest-of-openhands/pytest-0/test_truncate_table_memory_0')

    @pytest.fixture(params=['memory', 'json'])
    def db(request, tmp_path: Path):
        if request.param == 'json':
            db_ = TinyDB(tmp_path / 'test.db', storage=JSONStorage)
        else:
>           db_ = TinyDB(storage=MemoryStorage)

tests/conftest.py:17: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <[TypeError("'NoneType' object is not iterable") raised in repr()] TinyDB object at 0x7f06a929dab0>
args = (), kwargs = {}, storage = <class 'tinydb.storages.MemoryStorage'>

    def __init__(self, *args, **kwargs) -> None:
        """
        Create a new instance of TinyDB.
        """
        storage = kwargs.pop('storage', self.default_storage_class)
>       self._storage: Storage = storage(*args, **kwargs)
E       TypeError: Can't instantiate abstract class MemoryStorage with abstract methods read, write

tinydb/database.py:74: TypeError
_________________ ERROR at setup of test_truncate_table[json] __________________

request = <SubRequest 'db' for <Function test_truncate_table[json]>>
tmp_path = PosixPath('/tmp/pytest-of-openhands/pytest-0/test_truncate_table_json_0')

    @pytest.fixture(params=['memory', 'json'])
    def db(request, tmp_path: Path):
        if request.param == 'json':
>           db_ = TinyDB(tmp_path / 'test.db', storage=JSONStorage)

tests/conftest.py:15: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <[TypeError("'NoneType' object is not iterable") raised in repr()] TinyDB object at 0x7f06a8c84790>
args = (PosixPath('/tmp/pytest-of-openhands/pytest-0/test_truncate_table_json_0/test.db'),)
kwargs = {}, storage = <class 'tinydb.storages.JSONStorage'>

    def __init__(self, *args, **kwargs) -> None:
        """
        Create a new instance of TinyDB.
        """
        storage = kwargs.pop('storage', self.default_storage_class)
>       self._storage: Storage = storage(*args, **kwargs)
E       TypeError: Can't instantiate abstract class JSONStorage with abstract methods read, write

tinydb/database.py:74: TypeError
__________________ ERROR at setup of test_drop_tables[memory] __________________

request = <SubRequest 'db' for <Function test_drop_tables[memory]>>
tmp_path = PosixPath('/tmp/pytest-of-openhands/pytest-0/test_drop_tables_memory_0')

    @pytest.fixture(params=['memory', 'json'])
    def db(request, tmp_path: Path):
        if request.param == 'json':
            db_ = TinyDB(tmp_path / 'test.db', storage=JSONStorage)
        else:
>           db_ = TinyDB(storage=MemoryStorage)

tests/conftest.py:17: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <[TypeError("'NoneType' object is not iterable") raised in repr()] TinyDB object at 0x7f06a929c970>
args = (), kwargs = {}, storage = <class 'tinydb.storages.MemoryStorage'>

    def __init__(self, *args, **kwargs) -> None:
        """
        Create a new instance of TinyDB.
        """
        storage = kwargs.pop('storage', self.default_storage_class)
>       self._storage: Storage = storage(*args, **kwargs)
E       TypeError: Can't instantiate abstract class MemoryStorage with abstract methods read, write

tinydb/database.py:74: TypeError
___________________ ERROR at setup of test_drop_tables[json] ___________________

request = <SubRequest 'db' for <Function test_drop_tables[json]>>
tmp_path = PosixPath('/tmp/pytest-of-openhands/pytest-0/test_drop_tables_json_0')

    @pytest.fixture(params=['memory', 'json'])
    def db(request, tmp_path: Path):
        if request.param == 'json':
>           db_ = TinyDB(tmp_path / 'test.db', storage=JSONStorage)

tests/conftest.py:15: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <[TypeError("'NoneType' object is not iterable") raised in repr()] TinyDB object at 0x7f06a920e4a0>
args = (PosixPath('/tmp/pytest-of-openhands/pytest-0/test_drop_tables_json_0/test.db'),)
kwargs = {}, storage = <class 'tinydb.storages.JSONStorage'>

    def __init__(self, *args, **kwargs) -> None:
        """
        Create a new instance of TinyDB.
        """
        storage = kwargs.pop('storage', self.default_storage_class)
>       self._storage: Storage = storage(*args, **kwargs)
E       TypeError: Can't instantiate abstract class JSONStorage with abstract methods read, write

tinydb/database.py:74: TypeError
______________________ ERROR at setup of test_all[memory] ______________________

request = <SubRequest 'db' for <Function test_all[memory]>>
tmp_path = PosixPath('/tmp/pytest-of-openhands/pytest-0/test_all_memory_0')

    @pytest.fixture(params=['memory', 'json'])
    def db(request, tmp_path: Path):
        if request.param == 'json':
            db_ = TinyDB(tmp_path / 'test.db', storage=JSONStorage)
        else:
>           db_ = TinyDB(storage=MemoryStorage)

tests/conftest.py:17: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <[TypeError("'NoneType' object is not iterable") raised in repr()] TinyDB object at 0x7f06a9315450>
args = (), kwargs = {}, storage = <class 'tinydb.storages.MemoryStorage'>

    def __init__(self, *args, **kwargs) -> None:
        """
        Create a new instance of TinyDB.
        """
        storage = kwargs.pop('storage', self.default_storage_class)
>       self._storage: Storage = storage(*args, **kwargs)
E       TypeError: Can't instantiate abstract class MemoryStorage with abstract methods read, write

tinydb/database.py:74: TypeError
_______________________ ERROR at setup of test_all[json] _______________________

request = <SubRequest 'db' for <Function test_all[json]>>
tmp_path = PosixPath('/tmp/pytest-of-openhands/pytest-0/test_all_json_0')

    @pytest.fixture(params=['memory', 'json'])
    def db(request, tmp_path: Path):
        if request.param == 'json':
>           db_ = TinyDB(tmp_path / 'test.db', storage=JSONStorage)

tests/conftest.py:15: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <[TypeError("'NoneType' object is not iterable") raised in repr()] TinyDB object at 0x7f06a8c86830>
args = (PosixPath('/tmp/pytest-of-openhands/pytest-0/test_all_json_0/test.db'),)
kwargs = {}, storage = <class 'tinydb.storages.JSONStorage'>

    def __init__(self, *args, **kwargs) -> None:
        """
        Create a new instance of TinyDB.
        """
        storage = kwargs.pop('storage', self.default_storage_class)
>       self._storage: Storage = storage(*args, **kwargs)
E       TypeError: Can't instantiate abstract class JSONStorage with abstract methods read, write

tinydb/database.py:74: TypeError
____________________ ERROR at setup of test_insert[memory] _____________________

request = <SubRequest 'db' for <Function test_insert[memory]>>
tmp_path = PosixPath('/tmp/pytest-of-openhands/pytest-0/test_insert_memory_0')

    @pytest.fixture(params=['memory', 'json'])
    def db(request, tmp_path: Path):
        if request.param == 'json':
            db_ = TinyDB(tmp_path / 'test.db', storage=JSONStorage)
        else:
>           db_ = TinyDB(storage=MemoryStorage)

tests/conftest.py:17: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <[TypeError("'NoneType' object is not iterable") raised in repr()] TinyDB object at 0x7f06a8e39ae0>
args = (), kwargs = {}, storage = <class 'tinydb.storages.MemoryStorage'>

    def __init__(self, *args, **kwargs) -> None:
        """
        Create a new instance of TinyDB.
        """
        storage = kwargs.pop('storage', self.default_storage_class)
>       self._storage: Storage = storage(*args, **kwargs)
E       TypeError: Can't instantiate abstract class MemoryStorage with abstract methods read, write

tinydb/database.py:74: TypeError
_____________________ ERROR at setup of test_insert[json] ______________________

request = <SubRequest 'db' for <Function test_insert[json]>>
tmp_path = PosixPath('/tmp/pytest-of-openhands/pytest-0/test_insert_json_0')

    @pytest.fixture(params=['memory', 'json'])
    def db(request, tmp_path: Path):
        if request.param == 'json':
>           db_ = TinyDB(tmp_path / 'test.db', storage=JSONStorage)

tests/conftest.py:15: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <[TypeError("'NoneType' object is not iterable") raised in repr()] TinyDB object at 0x7f06a8c843d0>
args = (PosixPath('/tmp/pytest-of-openhands/pytest-0/test_insert_json_0/test.db'),)
kwargs = {}, storage = <class 'tinydb.storages.JSONStorage'>

    def __init__(self, *args, **kwargs) -> None:
        """
        Create a new instance of TinyDB.
        """
        storage = kwargs.pop('storage', self.default_storage_class)
>       self._storage: Storage = storage(*args, **kwargs)
E       TypeError: Can't instantiate abstract class JSONStorage with abstract methods read, write

tinydb/database.py:74: TypeError
__________________ ERROR at setup of test_insert_ids[memory] ___________________

request = <SubRequest 'db' for <Function test_insert_ids[memory]>>
tmp_path = PosixPath('/tmp/pytest-of-openhands/pytest-0/test_insert_ids_memory_0')

    @pytest.fixture(params=['memory', 'json'])
    def db(request, tmp_path: Path):
        if request.param == 'json':
            db_ = TinyDB(tmp_path / 'test.db', storage=JSONStorage)
        else:
>           db_ = TinyDB(storage=MemoryStorage)

tests/conftest.py:17: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <[TypeError("'NoneType' object is not iterable") raised in repr()] TinyDB object at 0x7f06a9453c40>
args = (), kwargs = {}, storage = <class 'tinydb.storages.MemoryStorage'>

    def __init__(self, *args, **kwargs) -> None:
        """
        Create a new instance of TinyDB.
        """
        storage = kwargs.pop('storage', self.default_storage_class)
>       self._storage: Storage = storage(*args, **kwargs)
E       TypeError: Can't instantiate abstract class MemoryStorage with abstract methods read, write

tinydb/database.py:74: TypeError
___________________ ERROR at setup of test_insert_ids[json] ____________________

request = <SubRequest 'db' for <Function test_insert_ids[json]>>
tmp_path = PosixPath('/tmp/pytest-of-openhands/pytest-0/test_insert_ids_json_0')

    @pytest.fixture(params=['memory', 'json'])
    def db(request, tmp_path: Path):
        if request.param == 'json':
>           db_ = TinyDB(tmp_path / 'test.db', storage=JSONStorage)

tests/conftest.py:15: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <[TypeError("'NoneType' object is not iterable") raised in repr()] TinyDB object at 0x7f06a8e3ae00>
args = (PosixPath('/tmp/pytest-of-openhands/pytest-0/test_insert_ids_json_0/test.db'),)
kwargs = {}, storage = <class 'tinydb.storages.JSONStorage'>

    def __init__(self, *args, **kwargs) -> None:
        """
        Create a new instance of TinyDB.
        """
        storage = kwargs.pop('storage', self.default_storage_class)
>       self._storage: Storage = storage(*args, **kwargs)
E       TypeError: Can't instantiate abstract class JSONStorage with abstract methods read, write

tinydb/database.py:74: TypeError
______________ ERROR at setup of test_insert_with_doc_id[memory] _______________

request = <SubRequest 'db' for <Function test_insert_with_doc_id[memory]>>
tmp_path = PosixPath('/tmp/pytest-of-openhands/pytest-0/test_insert_with_doc_id_memory0')

    @pytest.fixture(params=['memory', 'json'])
    def db(request, tmp_path: Path):
        if request.param == 'json':
            db_ = TinyDB(tmp_path / 'test.db', storage=JSONStorage)
        else:
>           db_ = TinyDB(storage=MemoryStorage)

tests/conftest.py:17: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <[TypeError("'NoneType' object is not iterable") raised in repr()] TinyDB object at 0x7f06a93176a0>
args = (), kwargs = {}, storage = <class 'tinydb.storages.MemoryStorage'>

    def __init__(self, *args, **kwargs) -> None:
        """
        Create a new instance of TinyDB.
        """
        storage = kwargs.pop('storage', self.default_storage_class)
>       self._storage: Storage = storage(*args, **kwargs)
E       TypeError: Can't instantiate abstract class MemoryStorage with abstract methods read, write

tinydb/database.py:74: TypeError
_______________ ERROR at setup of test_insert_with_doc_id[json] ________________

request = <SubRequest 'db' for <Function test_insert_with_doc_id[json]>>
tmp_path = PosixPath('/tmp/pytest-of-openhands/pytest-0/test_insert_with_doc_id_json_0')

    @pytest.fixture(params=['memory', 'json'])
    def db(request, tmp_path: Path):
        if request.param == 'json':
>           db_ = TinyDB(tmp_path / 'test.db', storage=JSONStorage)

tests/conftest.py:15: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <[TypeError("'NoneType' object is not iterable") raised in repr()] TinyDB object at 0x7f06a931a530>
args = (PosixPath('/tmp/pytest-of-openhands/pytest-0/test_insert_with_doc_id_json_0/test.db'),)
kwargs = {}, storage = <class 'tinydb.storages.JSONStorage'>

    def __init__(self, *args, **kwargs) -> None:
        """
        Create a new instance of TinyDB.
        """
        storage = kwargs.pop('storage', self.default_storage_class)
>       self._storage: Storage = storage(*args, **kwargs)
E       TypeError: Can't instantiate abstract class JSONStorage with abstract methods read, write

tinydb/database.py:74: TypeError
_________ ERROR at setup of test_insert_with_duplicate_doc_id[memory] __________

request = <SubRequest 'db' for <Function test_insert_with_duplicate_doc_id[memory]>>
tmp_path = PosixPath('/tmp/pytest-of-openhands/pytest-0/test_insert_with_duplicate_doc0')

    @pytest.fixture(params=['memory', 'json'])
    def db(request, tmp_path: Path):
        if request.param == 'json':
            db_ = TinyDB(tmp_path / 'test.db', storage=JSONStorage)
        else:
>           db_ = TinyDB(storage=MemoryStorage)

tests/conftest.py:17: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <[TypeError("'NoneType' object is not iterable") raised in repr()] TinyDB object at 0x7f06a92161a0>
args = (), kwargs = {}, storage = <class 'tinydb.storages.MemoryStorage'>

    def __init__(self, *args, **kwargs) -> None:
        """
        Create a new instance of TinyDB.
        """
        storage = kwargs.pop('storage', self.default_storage_class)
>       self._storage: Storage = storage(*args, **kwargs)
E       TypeError: Can't instantiate abstract class MemoryStorage with abstract methods read, write

tinydb/database.py:74: TypeError
__________ ERROR at setup of test_insert_with_duplicate_doc_id[json] ___________

request = <SubRequest 'db' for <Function test_insert_with_duplicate_doc_id[json]>>
tmp_path = PosixPath('/tmp/pytest-of-openhands/pytest-0/test_insert_with_duplicate_doc1')

    @pytest.fixture(params=['memory', 'json'])
    def db(request, tmp_path: Path):
        if request.param == 'json':
>           db_ = TinyDB(tmp_path / 'test.db', storage=JSONStorage)

tests/conftest.py:15: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <[TypeError("'NoneType' object is not iterable") raised in repr()] TinyDB object at 0x7f06a8e3bdc0>
args = (PosixPath('/tmp/pytest-of-openhands/pytest-0/test_insert_with_duplicate_doc1/test.db'),)
kwargs = {}, storage = <class 'tinydb.storages.JSONStorage'>

    def __init__(self, *args, **kwargs) -> None:
        """
        Create a new instance of TinyDB.
        """
        storage = kwargs.pop('storage', self.default_storage_class)
>       self._storage: Storage = storage(*args, **kwargs)
E       TypeError: Can't instantiate abstract class JSONStorage with abstract methods read, write

tinydb/database.py:74: TypeError
________________ ERROR at setup of test_insert_multiple[memory] ________________

request = <SubRequest 'db' for <Function test_insert_multiple[memory]>>
tmp_path = PosixPath('/tmp/pytest-of-openhands/pytest-0/test_insert_multiple_memory_0')

    @pytest.fixture(params=['memory', 'json'])
    def db(request, tmp_path: Path):
        if request.param == 'json':
            db_ = TinyDB(tmp_path / 'test.db', storage=JSONStorage)
        else:
>           db_ = TinyDB(storage=MemoryStorage)

tests/conftest.py:17: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <[TypeError("'NoneType' object is not iterable") raised in repr()] TinyDB object at 0x7f06a8c84df0>
args = (), kwargs = {}, storage = <class 'tinydb.storages.MemoryStorage'>

    def __init__(self, *args, **kwargs) -> None:
        """
        Create a new instance of TinyDB.
        """
        storage = kwargs.pop('storage', self.default_storage_class)
>       self._storage: Storage = storage(*args, **kwargs)
E       TypeError: Can't instantiate abstract class MemoryStorage with abstract methods read, write

tinydb/database.py:74: TypeError
_________________ ERROR at setup of test_insert_multiple[json] _________________

request = <SubRequest 'db' for <Function test_insert_multiple[json]>>
tmp_path = PosixPath('/tmp/pytest-of-openhands/pytest-0/test_insert_multiple_json_0')

    @pytest.fixture(params=['memory', 'json'])
    def db(request, tmp_path: Path):
        if request.param == 'json':
>           db_ = TinyDB(tmp_path / 'test.db', storage=JSONStorage)

tests/conftest.py:15: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <[TypeError("'NoneType' object is not iterable") raised in repr()] TinyDB object at 0x7f06a929f160>
args = (PosixPath('/tmp/pytest-of-openhands/pytest-0/test_insert_multiple_json_0/test.db'),)
kwargs = {}, storage = <class 'tinydb.storages.JSONStorage'>

    def __init__(self, *args, **kwargs) -> None:
        """
        Create a new instance of TinyDB.
        """
        storage = kwargs.pop('storage', self.default_storage_class)
>       self._storage: Storage = storage(*args, **kwargs)
E       TypeError: Can't instantiate abstract class JSONStorage with abstract methods read, write

tinydb/database.py:74: TypeError
___________ ERROR at setup of test_insert_multiple_with_ids[memory] ____________

request = <SubRequest 'db' for <Function test_insert_multiple_with_ids[memory]>>
tmp_path = PosixPath('/tmp/pytest-of-openhands/pytest-0/test_insert_multiple_with_ids_0')

    @pytest.fixture(params=['memory', 'json'])
    def db(request, tmp_path: Path):
        if request.param == 'json':
            db_ = TinyDB(tmp_path / 'test.db', storage=JSONStorage)
        else:
>           db_ = TinyDB(storage=MemoryStorage)

tests/conftest.py:17: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <[TypeError("'NoneType' object is not iterable") raised in repr()] TinyDB object at 0x7f06a929a770>
args = (), kwargs = {}, storage = <class 'tinydb.storages.MemoryStorage'>

    def __init__(self, *args, **kwargs) -> None:
        """
        Create a new instance of TinyDB.
        """
        storage = kwargs.pop('storage', self.default_storage_class)
>       self._storage: Storage = storage(*args, **kwargs)
E       TypeError: Can't instantiate abstract class MemoryStorage with abstract methods read, write

tinydb/database.py:74: TypeError
____________ ERROR at setup of test_insert_multiple_with_ids[json] _____________

request = <SubRequest 'db' for <Function test_insert_multiple_with_ids[json]>>
tmp_path = PosixPath('/tmp/pytest-of-openhands/pytest-0/test_insert_multiple_with_ids_1')

    @pytest.fixture(params=['memory', 'json'])
    def db(request, tmp_path: Path):
        if request.param == 'json':
>           db_ = TinyDB(tmp_path / 'test.db', storage=JSONStorage)

tests/conftest.py:15: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <[TypeError("'NoneType' object is not iterable") raised in repr()] TinyDB object at 0x7f06a9316170>
args = (PosixPath('/tmp/pytest-of-openhands/pytest-0/test_insert_multiple_with_ids_1/test.db'),)
kwargs = {}, storage = <class 'tinydb.storages.JSONStorage'>

    def __init__(self, *args, **kwargs) -> None:
        """
        Create a new instance of TinyDB.
        """
        storage = kwargs.pop('storage', self.default_storage_class)
>       self._storage: Storage = storage(*args, **kwargs)
E       TypeError: Can't instantiate abstract class JSONStorage with abstract methods read, write

tinydb/database.py:74: TypeError
_________ ERROR at setup of test_insert_multiple_with_doc_ids[memory] __________

request = <SubRequest 'db' for <Function test_insert_multiple_with_doc_ids[memory]>>
tmp_path = PosixPath('/tmp/pytest-of-openhands/pytest-0/test_insert_multiple_with_doc_0')

    @pytest.fixture(params=['memory', 'json'])
    def db(request, tmp_path: Path):
        if request.param == 'json':
            db_ = TinyDB(tmp_path / 'test.db', storage=JSONStorage)
        else:
>           db_ = TinyDB(storage=MemoryStorage)

tests/conftest.py:17: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <[TypeError("'NoneType' object is not iterable") raised in repr()] TinyDB object at 0x7f06a929ace0>
args = (), kwargs = {}, storage = <class 'tinydb.storages.MemoryStorage'>

    def __init__(self, *args, **kwargs) -> None:
        """
        Create a new instance of TinyDB.
        """
        storage = kwargs.pop('storage', self.default_storage_class)
>       self._storage: Storage = storage(*args, **kwargs)
E       TypeError: Can't instantiate abstract class MemoryStorage with abstract methods read, write

tinydb/database.py:74: TypeError
__________ ERROR at setup of test_insert_multiple_with_doc_ids[json] ___________

request = <SubRequest 'db' for <Function test_insert_multiple_with_doc_ids[json]>>
tmp_path = PosixPath('/tmp/pytest-of-openhands/pytest-0/test_insert_multiple_with_doc_1')

    @pytest.fixture(params=['memory', 'json'])
    def db(request, tmp_path: Path):
        if request.param == 'json':
>           db_ = TinyDB(tmp_path / 'test.db', storage=JSONStorage)

tests/conftest.py:15: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <[TypeError("'NoneType' object is not iterable") raised in repr()] TinyDB object at 0x7f06a93161d0>
args = (PosixPath('/tmp/pytest-of-openhands/pytest-0/test_insert_multiple_with_doc_1/test.db'),)
kwargs = {}, storage = <class 'tinydb.storages.JSONStorage'>

    def __init__(self, *args, **kwargs) -> None:
        """
        Create a new instance of TinyDB.
        """
        storage = kwargs.pop('storage', self.default_storage_class)
>       self._storage: Storage = storage(*args, **kwargs)
E       TypeError: Can't instantiate abstract class JSONStorage with abstract methods read, write

tinydb/database.py:74: TypeError
_______ ERROR at setup of test_insert_invalid_type_raises_error[memory] ________

request = <SubRequest 'db' for <Function test_insert_invalid_type_raises_error[memory]>>
tmp_path = PosixPath('/tmp/pytest-of-openhands/pytest-0/test_insert_invalid_type_raise0')

    @pytest.fixture(params=['memory', 'json'])
    def db(request, tmp_path: Path):
        if request.param == 'json':
            db_ = TinyDB(tmp_path / 'test.db', storage=JSONStorage)
        else:
>           db_ = TinyDB(storage=MemoryStorage)

tests/conftest.py:17: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <[TypeError("'NoneType' object is not iterable") raised in repr()] TinyDB object at 0x7f06a9298df0>
args = (), kwargs = {}, storage = <class 'tinydb.storages.MemoryStorage'>

    def __init__(self, *args, **kwargs) -> None:
        """
        Create a new instance of TinyDB.
        """
        storage = kwargs.pop('storage', self.default_storage_class)
>       self._storage: Storage = storage(*args, **kwargs)
E       TypeError: Can't instantiate abstract class MemoryStorage with abstract methods read, write

tinydb/database.py:74: TypeError
________ ERROR at setup of test_insert_invalid_type_raises_error[json] _________

request = <SubRequest 'db' for <Function test_insert_invalid_type_raises_error[json]>>
tmp_path = PosixPath('/tmp/pytest-of-openhands/pytest-0/test_insert_invalid_type_raise1')

    @pytest.fixture(params=['memory', 'json'])
    def db(request, tmp_path: Path):
        if request.param == 'json':
>           db_ = TinyDB(tmp_path / 'test.db', storage=JSONStorage)

tests/conftest.py:15: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <[TypeError("'NoneType' object is not iterable") raised in repr()] TinyDB object at 0x7f06a8e6a350>
args = (PosixPath('/tmp/pytest-of-openhands/pytest-0/test_insert_invalid_type_raise1/test.db'),)
kwargs = {}, storage = <class 'tinydb.storages.JSONStorage'>

    def __init__(self, *args, **kwargs) -> None:
        """
        Create a new instance of TinyDB.
        """
        storage = kwargs.pop('storage', self.default_storage_class)
>       self._storage: Storage = storage(*args, **kwargs)
E       TypeError: Can't instantiate abstract class JSONStorage with abstract methods read, write

tinydb/database.py:74: TypeError
___________ ERROR at setup of test_insert_valid_mapping_type[memory] ___________

request = <SubRequest 'db' for <Function test_insert_valid_mapping_type[memory]>>
tmp_path = PosixPath('/tmp/pytest-of-openhands/pytest-0/test_insert_valid_mapping_type0')

    @pytest.fixture(params=['memory', 'json'])
    def db(request, tmp_path: Path):
        if request.param == 'json':
            db_ = TinyDB(tmp_path / 'test.db', storage=JSONStorage)
        else:
>           db_ = TinyDB(storage=MemoryStorage)

tests/conftest.py:17: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <[TypeError("'NoneType' object is not iterable") raised in repr()] TinyDB object at 0x7f06a92e8370>
args = (), kwargs = {}, storage = <class 'tinydb.storages.MemoryStorage'>

    def __init__(self, *args, **kwargs) -> None:
        """
        Create a new instance of TinyDB.
        """
        storage = kwargs.pop('storage', self.default_storage_class)
>       self._storage: Storage = storage(*args, **kwargs)
E       TypeError: Can't instantiate abstract class MemoryStorage with abstract methods read, write

tinydb/database.py:74: TypeError
____________ ERROR at setup of test_insert_valid_mapping_type[json] ____________

request = <SubRequest 'db' for <Function test_insert_valid_mapping_type[json]>>
tmp_path = PosixPath('/tmp/pytest-of-openhands/pytest-0/test_insert_valid_mapping_type1')

    @pytest.fixture(params=['memory', 'json'])
    def db(request, tmp_path: Path):
        if request.param == 'json':
>           db_ = TinyDB(tmp_path / 'test.db', storage=JSONStorage)

tests/conftest.py:15: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <[TypeError("'NoneType' object is not iterable") raised in repr()] TinyDB object at 0x7f06a931b730>
args = (PosixPath('/tmp/pytest-of-openhands/pytest-0/test_insert_valid_mapping_type1/test.db'),)
kwargs = {}, storage = <class 'tinydb.storages.JSONStorage'>

    def __init__(self, *args, **kwargs) -> None:
        """
        Create a new instance of TinyDB.
        """
        storage = kwargs.pop('storage', self.default_storage_class)
>       self._storage: Storage = storage(*args, **kwargs)
E       TypeError: Can't instantiate abstract class JSONStorage with abstract methods read, write

tinydb/database.py:74: TypeError
____________________ ERROR at setup of test_remove[memory] _____________________

request = <SubRequest 'db' for <Function test_remove[memory]>>
tmp_path = PosixPath('/tmp/pytest-of-openhands/pytest-0/test_remove_memory_0')

    @pytest.fixture(params=['memory', 'json'])
    def db(request, tmp_path: Path):
        if request.param == 'json':
            db_ = TinyDB(tmp_path / 'test.db', storage=JSONStorage)
        else:
>           db_ = TinyDB(storage=MemoryStorage)

tests/conftest.py:17: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <[TypeError("'NoneType' object is not iterable") raised in repr()] TinyDB object at 0x7f06a901fe50>
args = (), kwargs = {}, storage = <class 'tinydb.storages.MemoryStorage'>

    def __init__(self, *args, **kwargs) -> None:
        """
        Create a new instance of TinyDB.
        """
        storage = kwargs.pop('storage', self.default_storage_class)
>       self._storage: Storage = storage(*args, **kwargs)
E       TypeError: Can't instantiate abstract class MemoryStorage with abstract methods read, write

tinydb/database.py:74: TypeError
_____________________ ERROR at setup of test_remove[json] ______________________

request = <SubRequest 'db' for <Function test_remove[json]>>
tmp_path = PosixPath('/tmp/pytest-of-openhands/pytest-0/test_remove_json_0')

    @pytest.fixture(params=['memory', 'json'])
    def db(request, tmp_path: Path):
        if request.param == 'json':
>           db_ = TinyDB(tmp_path / 'test.db', storage=JSONStorage)

tests/conftest.py:15: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <[TypeError("'NoneType' object is not iterable") raised in repr()] TinyDB object at 0x7f06a924a4a0>
args = (PosixPath('/tmp/pytest-of-openhands/pytest-0/test_remove_json_0/test.db'),)
kwargs = {}, storage = <class 'tinydb.storages.JSONStorage'>

    def __init__(self, *args, **kwargs) -> None:
        """
        Create a new instance of TinyDB.
        """
        storage = kwargs.pop('storage', self.default_storage_class)
>       self._storage: Storage = storage(*args, **kwargs)
E       TypeError: Can't instantiate abstract class JSONStorage with abstract methods read, write

tinydb/database.py:74: TypeError
_______________ ERROR at setup of test_remove_all_fails[memory] ________________

request = <SubRequest 'db' for <Function test_remove_all_fails[memory]>>
tmp_path = PosixPath('/tmp/pytest-of-openhands/pytest-0/test_remove_all_fails_memory_0')

    @pytest.fixture(params=['memory', 'json'])
    def db(request, tmp_path: Path):
        if request.param == 'json':
            db_ = TinyDB(tmp_path / 'test.db', storage=JSONStorage)
        else:
>           db_ = TinyDB(storage=MemoryStorage)

tests/conftest.py:17: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <[TypeError("'NoneType' object is not iterable") raised in repr()] TinyDB object at 0x7f06a9317880>
args = (), kwargs = {}, storage = <class 'tinydb.storages.MemoryStorage'>

    def __init__(self, *args, **kwargs) -> None:
        """
        Create a new instance of TinyDB.
        """
        storage = kwargs.pop('storage', self.default_storage_class)
>       self._storage: Storage = storage(*args, **kwargs)
E       TypeError: Can't instantiate abstract class MemoryStorage with abstract methods read, write

tinydb/database.py:74: TypeError
________________ ERROR at setup of test_remove_all_fails[json] _________________

request = <SubRequest 'db' for <Function test_remove_all_fails[json]>>
tmp_path = PosixPath('/tmp/pytest-of-openhands/pytest-0/test_remove_all_fails_json_0')

    @pytest.fixture(params=['memory', 'json'])
    def db(request, tmp_path: Path):
        if request.param == 'json':
>           db_ = TinyDB(tmp_path / 'test.db', storage=JSONStorage)

tests/conftest.py:15: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <[TypeError("'NoneType' object is not iterable") raised in repr()] TinyDB object at 0x7f06a931b610>
args = (PosixPath('/tmp/pytest-of-openhands/pytest-0/test_remove_all_fails_json_0/test.db'),)
kwargs = {}, storage = <class 'tinydb.storages.JSONStorage'>

    def __init__(self, *args, **kwargs) -> None:
        """
        Create a new instance of TinyDB.
        """
        storage = kwargs.pop('storage', self.default_storage_class)
>       self._storage: Storage = storage(*args, **kwargs)
E       TypeError: Can't instantiate abstract class JSONStorage with abstract methods read, write

tinydb/database.py:74: TypeError
________________ ERROR at setup of test_remove_multiple[memory] ________________

request = <SubRequest 'db' for <Function test_remove_multiple[memory]>>
tmp_path = PosixPath('/tmp/pytest-of-openhands/pytest-0/test_remove_multiple_memory_0')

    @pytest.fixture(params=['memory', 'json'])
    def db(request, tmp_path: Path):
        if request.param == 'json':
            db_ = TinyDB(tmp_path / 'test.db', storage=JSONStorage)
        else:
>           db_ = TinyDB(storage=MemoryStorage)

tests/conftest.py:17: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <[TypeError("'NoneType' object is not iterable") raised in repr()] TinyDB object at 0x7f06a9315cc0>
args = (), kwargs = {}, storage = <class 'tinydb.storages.MemoryStorage'>

    def __init__(self, *args, **kwargs) -> None:
        """
        Create a new instance of TinyDB.
        """
        storage = kwargs.pop('storage', self.default_storage_class)
>       self._storage: Storage = storage(*args, **kwargs)
E       TypeError: Can't instantiate abstract class MemoryStorage with abstract methods read, write

tinydb/database.py:74: TypeError
_________________ ERROR at setup of test_remove_multiple[json] _________________

request = <SubRequest 'db' for <Function test_remove_multiple[json]>>
tmp_path = PosixPath('/tmp/pytest-of-openhands/pytest-0/test_remove_multiple_json_0')

    @pytest.fixture(params=['memory', 'json'])
    def db(request, tmp_path: Path):
        if request.param == 'json':
>           db_ = TinyDB(tmp_path / 'test.db', storage=JSONStorage)

tests/conftest.py:15: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <[TypeError("'NoneType' object is not iterable") raised in repr()] TinyDB object at 0x7f06a8e6b8b0>
args = (PosixPath('/tmp/pytest-of-openhands/pytest-0/test_remove_multiple_json_0/test.db'),)
kwargs = {}, storage = <class 'tinydb.storages.JSONStorage'>

    def __init__(self, *args, **kwargs) -> None:
        """
        Create a new instance of TinyDB.
        """
        storage = kwargs.pop('storage', self.default_storage_class)
>       self._storage: Storage = storage(*args, **kwargs)
E       TypeError: Can't instantiate abstract class JSONStorage with abstract methods read, write

tinydb/database.py:74: TypeError
__________________ ERROR at setup of test_remove_ids[memory] ___________________

request = <SubRequest 'db' for <Function test_remove_ids[memory]>>
tmp_path = PosixPath('/tmp/pytest-of-openhands/pytest-0/test_remove_ids_memory_0')

    @pytest.fixture(params=['memory', 'json'])
    def db(request, tmp_path: Path):
        if request.param == 'json':
            db_ = TinyDB(tmp_path / 'test.db', storage=JSONStorage)
        else:
>           db_ = TinyDB(storage=MemoryStorage)

tests/conftest.py:17: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <[TypeError("'NoneType' object is not iterable") raised in repr()] TinyDB object at 0x7f06a901c7f0>
args = (), kwargs = {}, storage = <class 'tinydb.storages.MemoryStorage'>

    def __init__(self, *args, **kwargs) -> None:
        """
        Create a new instance of TinyDB.
        """
        storage = kwargs.pop('storage', self.default_storage_class)
>       self._storage: Storage = storage(*args, **kwargs)
E       TypeError: Can't instantiate abstract class MemoryStorage with abstract methods read, write

tinydb/database.py:74: TypeError
___________________ ERROR at setup of test_remove_ids[json] ____________________

request = <SubRequest 'db' for <Function test_remove_ids[json]>>
tmp_path = PosixPath('/tmp/pytest-of-openhands/pytest-0/test_remove_ids_json_0')

    @pytest.fixture(params=['memory', 'json'])
    def db(request, tmp_path: Path):
        if request.param == 'json':
>           db_ = TinyDB(tmp_path / 'test.db', storage=JSONStorage)

tests/conftest.py:15: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <[TypeError("'NoneType' object is not iterable") raised in repr()] TinyDB object at 0x7f06a9256a10>
args = (PosixPath('/tmp/pytest-of-openhands/pytest-0/test_remove_ids_json_0/test.db'),)
kwargs = {}, storage = <class 'tinydb.storages.JSONStorage'>

    def __init__(self, *args, **kwargs) -> None:
        """
        Create a new instance of TinyDB.
        """
        storage = kwargs.pop('storage', self.default_storage_class)
>       self._storage: Storage = storage(*args, **kwargs)
E       TypeError: Can't instantiate abstract class JSONStorage with abstract methods read, write

tinydb/database.py:74: TypeError
______________ ERROR at setup of test_remove_returns_ids[memory] _______________

request = <SubRequest 'db' for <Function test_remove_returns_ids[memory]>>
tmp_path = PosixPath('/tmp/pytest-of-openhands/pytest-0/test_remove_returns_ids_memory0')

    @pytest.fixture(params=['memory', 'json'])
    def db(request, tmp_path: Path):
        if request.param == 'json':
            db_ = TinyDB(tmp_path / 'test.db', storage=JSONStorage)
        else:
>           db_ = TinyDB(storage=MemoryStorage)

tests/conftest.py:17: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <[TypeError("'NoneType' object is not iterable") raised in repr()] TinyDB object at 0x7f06a901d600>
args = (), kwargs = {}, storage = <class 'tinydb.storages.MemoryStorage'>

    def __init__(self, *args, **kwargs) -> None:
        """
        Create a new instance of TinyDB.
        """
        storage = kwargs.pop('storage', self.default_storage_class)
>       self._storage: Storage = storage(*args, **kwargs)
E       TypeError: Can't instantiate abstract class MemoryStorage with abstract methods read, write

tinydb/database.py:74: TypeError
_______________ ERROR at setup of test_remove_returns_ids[json] ________________

request = <SubRequest 'db' for <Function test_remove_returns_ids[json]>>
tmp_path = PosixPath('/tmp/pytest-of-openhands/pytest-0/test_remove_returns_ids_json_0')

    @pytest.fixture(params=['memory', 'json'])
    def db(request, tmp_path: Path):
        if request.param == 'json':
>           db_ = TinyDB(tmp_path / 'test.db', storage=JSONStorage)

tests/conftest.py:15: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <[TypeError("'NoneType' object is not iterable") raised in repr()] TinyDB object at 0x7f06a924bbe0>
args = (PosixPath('/tmp/pytest-of-openhands/pytest-0/test_remove_returns_ids_json_0/test.db'),)
kwargs = {}, storage = <class 'tinydb.storages.JSONStorage'>

    def __init__(self, *args, **kwargs) -> None:
        """
        Create a new instance of TinyDB.
        """
        storage = kwargs.pop('storage', self.default_storage_class)
>       self._storage: Storage = storage(*args, **kwargs)
E       TypeError: Can't instantiate abstract class JSONStorage with abstract methods read, write

tinydb/database.py:74: TypeError
____________________ ERROR at setup of test_update[memory] _____________________

request = <SubRequest 'db' for <Function test_update[memory]>>
tmp_path = PosixPath('/tmp/pytest-of-openhands/pytest-0/test_update_memory_0')

    @pytest.fixture(params=['memory', 'json'])
    def db(request, tmp_path: Path):
        if request.param == 'json':
            db_ = TinyDB(tmp_path / 'test.db', storage=JSONStorage)
        else:
>           db_ = TinyDB(storage=MemoryStorage)

tests/conftest.py:17: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <[TypeError("'NoneType' object is not iterable") raised in repr()] TinyDB object at 0x7f06a8e39cc0>
args = (), kwargs = {}, storage = <class 'tinydb.storages.MemoryStorage'>

    def __init__(self, *args, **kwargs) -> None:
        """
        Create a new instance of TinyDB.
        """
        storage = kwargs.pop('storage', self.default_storage_class)
>       self._storage: Storage = storage(*args, **kwargs)
E       TypeError: Can't instantiate abstract class MemoryStorage with abstract methods read, write

tinydb/database.py:74: TypeError
_____________________ ERROR at setup of test_update[json] ______________________

request = <SubRequest 'db' for <Function test_update[json]>>
tmp_path = PosixPath('/tmp/pytest-of-openhands/pytest-0/test_update_json_0')

    @pytest.fixture(params=['memory', 'json'])
    def db(request, tmp_path: Path):
        if request.param == 'json':
>           db_ = TinyDB(tmp_path / 'test.db', storage=JSONStorage)

tests/conftest.py:15: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <[TypeError("'NoneType' object is not iterable") raised in repr()] TinyDB object at 0x7f06a9316cb0>
args = (PosixPath('/tmp/pytest-of-openhands/pytest-0/test_update_json_0/test.db'),)
kwargs = {}, storage = <class 'tinydb.storages.JSONStorage'>

    def __init__(self, *args, **kwargs) -> None:
        """
        Create a new instance of TinyDB.
        """
        storage = kwargs.pop('storage', self.default_storage_class)
>       self._storage: Storage = storage(*args, **kwargs)
E       TypeError: Can't instantiate abstract class JSONStorage with abstract methods read, write

tinydb/database.py:74: TypeError
__________________ ERROR at setup of test_update_all[memory] ___________________

request = <SubRequest 'db' for <Function test_update_all[memory]>>
tmp_path = PosixPath('/tmp/pytest-of-openhands/pytest-0/test_update_all_memory_0')

    @pytest.fixture(params=['memory', 'json'])
    def db(request, tmp_path: Path):
        if request.param == 'json':
            db_ = TinyDB(tmp_path / 'test.db', storage=JSONStorage)
        else:
>           db_ = TinyDB(storage=MemoryStorage)

tests/conftest.py:17: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <[TypeError("'NoneType' object is not iterable") raised in repr()] TinyDB object at 0x7f06a8e384c0>
args = (), kwargs = {}, storage = <class 'tinydb.storages.MemoryStorage'>

    def __init__(self, *args, **kwargs) -> None:
        """
        Create a new instance of TinyDB.
        """
        storage = kwargs.pop('storage', self.default_storage_class)
>       self._storage: Storage = storage(*args, **kwargs)
E       TypeError: Can't instantiate abstract class MemoryStorage with abstract methods read, write

tinydb/database.py:74: TypeError
___________________ ERROR at setup of test_update_all[json] ____________________

request = <SubRequest 'db' for <Function test_update_all[json]>>
tmp_path = PosixPath('/tmp/pytest-of-openhands/pytest-0/test_update_all_json_0')

    @pytest.fixture(params=['memory', 'json'])
    def db(request, tmp_path: Path):
        if request.param == 'json':
>           db_ = TinyDB(tmp_path / 'test.db', storage=JSONStorage)

tests/conftest.py:15: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <[TypeError("'NoneType' object is not iterable") raised in repr()] TinyDB object at 0x7f06a901d660>
args = (PosixPath('/tmp/pytest-of-openhands/pytest-0/test_update_all_json_0/test.db'),)
kwargs = {}, storage = <class 'tinydb.storages.JSONStorage'>

    def __init__(self, *args, **kwargs) -> None:
        """
        Create a new instance of TinyDB.
        """
        storage = kwargs.pop('storage', self.default_storage_class)
>       self._storage: Storage = storage(*args, **kwargs)
E       TypeError: Can't instantiate abstract class JSONStorage with abstract methods read, write

tinydb/database.py:74: TypeError
______________ ERROR at setup of test_update_returns_ids[memory] _______________

request = <SubRequest 'db' for <Function test_update_returns_ids[memory]>>
tmp_path = PosixPath('/tmp/pytest-of-openhands/pytest-0/test_update_returns_ids_memory0')

    @pytest.fixture(params=['memory', 'json'])
    def db(request, tmp_path: Path):
        if request.param == 'json':
            db_ = TinyDB(tmp_path / 'test.db', storage=JSONStorage)
        else:
>           db_ = TinyDB(storage=MemoryStorage)

tests/conftest.py:17: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <[TypeError("'NoneType' object is not iterable") raised in repr()] TinyDB object at 0x7f06a8e3ae60>
args = (), kwargs = {}, storage = <class 'tinydb.storages.MemoryStorage'>

    def __init__(self, *args, **kwargs) -> None:
        """
        Create a new instance of TinyDB.
        """
        storage = kwargs.pop('storage', self.default_storage_class)
>       self._storage: Storage = storage(*args, **kwargs)
E       TypeError: Can't instantiate abstract class MemoryStorage with abstract methods read, write

tinydb/database.py:74: TypeError
_______________ ERROR at setup of test_update_returns_ids[json] ________________

request = <SubRequest 'db' for <Function test_update_returns_ids[json]>>
tmp_path = PosixPath('/tmp/pytest-of-openhands/pytest-0/test_update_returns_ids_json_0')

    @pytest.fixture(params=['memory', 'json'])
    def db(request, tmp_path: Path):
        if request.param == 'json':
>           db_ = TinyDB(tmp_path / 'test.db', storage=JSONStorage)

tests/conftest.py:15: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <[TypeError("'NoneType' object is not iterable") raised in repr()] TinyDB object at 0x7f06a931b610>
args = (PosixPath('/tmp/pytest-of-openhands/pytest-0/test_update_returns_ids_json_0/test.db'),)
kwargs = {}, storage = <class 'tinydb.storages.JSONStorage'>

    def __init__(self, *args, **kwargs) -> None:
        """
        Create a new instance of TinyDB.
        """
        storage = kwargs.pop('storage', self.default_storage_class)
>       self._storage: Storage = storage(*args, **kwargs)
E       TypeError: Can't instantiate abstract class JSONStorage with abstract methods read, write

tinydb/database.py:74: TypeError
_______________ ERROR at setup of test_update_transform[memory] ________________

request = <SubRequest 'db' for <Function test_update_transform[memory]>>
tmp_path = PosixPath('/tmp/pytest-of-openhands/pytest-0/test_update_transform_memory_0')

    @pytest.fixture(params=['memory', 'json'])
    def db(request, tmp_path: Path):
        if request.param == 'json':
            db_ = TinyDB(tmp_path / 'test.db', storage=JSONStorage)
        else:
>           db_ = TinyDB(storage=MemoryStorage)

tests/conftest.py:17: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <[TypeError("'NoneType' object is not iterable") raised in repr()] TinyDB object at 0x7f06a9256800>
args = (), kwargs = {}, storage = <class 'tinydb.storages.MemoryStorage'>

    def __init__(self, *args, **kwargs) -> None:
        """
        Create a new instance of TinyDB.
        """
        storage = kwargs.pop('storage', self.default_storage_class)
>       self._storage: Storage = storage(*args, **kwargs)
E       TypeError: Can't instantiate abstract class MemoryStorage with abstract methods read, write

tinydb/database.py:74: TypeError
________________ ERROR at setup of test_update_transform[json] _________________

request = <SubRequest 'db' for <Function test_update_transform[json]>>
tmp_path = PosixPath('/tmp/pytest-of-openhands/pytest-0/test_update_transform_json_0')

    @pytest.fixture(params=['memory', 'json'])
    def db(request, tmp_path: Path):
        if request.param == 'json':
>           db_ = TinyDB(tmp_path / 'test.db', storage=JSONStorage)

tests/conftest.py:15: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <[TypeError("'NoneType' object is not iterable") raised in repr()] TinyDB object at 0x7f06a8e396c0>
args = (PosixPath('/tmp/pytest-of-openhands/pytest-0/test_update_transform_json_0/test.db'),)
kwargs = {}, storage = <class 'tinydb.storages.JSONStorage'>

    def __init__(self, *args, **kwargs) -> None:
        """
        Create a new instance of TinyDB.
        """
        storage = kwargs.pop('storage', self.default_storage_class)
>       self._storage: Storage = storage(*args, **kwargs)
E       TypeError: Can't instantiate abstract class JSONStorage with abstract methods read, write

tinydb/database.py:74: TypeError
__________________ ERROR at setup of test_update_ids[memory] ___________________

request = <SubRequest 'db' for <Function test_update_ids[memory]>>
tmp_path = PosixPath('/tmp/pytest-of-openhands/pytest-0/test_update_ids_memory_0')

    @pytest.fixture(params=['memory', 'json'])
    def db(request, tmp_path: Path):
        if request.param == 'json':
            db_ = TinyDB(tmp_path / 'test.db', storage=JSONStorage)
        else:
>           db_ = TinyDB(storage=MemoryStorage)

tests/conftest.py:17: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <[TypeError("'NoneType' object is not iterable") raised in repr()] TinyDB object at 0x7f06a9254130>
args = (), kwargs = {}, storage = <class 'tinydb.storages.MemoryStorage'>

    def __init__(self, *args, **kwargs) -> None:
        """
        Create a new instance of TinyDB.
        """
        storage = kwargs.pop('storage', self.default_storage_class)
>       self._storage: Storage = storage(*args, **kwargs)
E       TypeError: Can't instantiate abstract class MemoryStorage with abstract methods read, write

tinydb/database.py:74: TypeError
___________________ ERROR at setup of test_update_ids[json] ____________________

request = <SubRequest 'db' for <Function test_update_ids[json]>>
tmp_path = PosixPath('/tmp/pytest-of-openhands/pytest-0/test_update_ids_json_0')

    @pytest.fixture(params=['memory', 'json'])
    def db(request, tmp_path: Path):
        if request.param == 'json':
>           db_ = TinyDB(tmp_path / 'test.db', storage=JSONStorage)

tests/conftest.py:15: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <[TypeError("'NoneType' object is not iterable") raised in repr()] TinyDB object at 0x7f06a9215b40>
args = (PosixPath('/tmp/pytest-of-openhands/pytest-0/test_update_ids_json_0/test.db'),)
kwargs = {}, storage = <class 'tinydb.storages.JSONStorage'>

    def __init__(self, *args, **kwargs) -> None:
        """
        Create a new instance of TinyDB.
        """
        storage = kwargs.pop('storage', self.default_storage_class)
>       self._storage: Storage = storage(*args, **kwargs)
E       TypeError: Can't instantiate abstract class JSONStorage with abstract methods read, write

tinydb/database.py:74: TypeError
________________ ERROR at setup of test_update_multiple[memory] ________________

request = <SubRequest 'db' for <Function test_update_multiple[memory]>>
tmp_path = PosixPath('/tmp/pytest-of-openhands/pytest-0/test_update_multiple_memory_0')

    @pytest.fixture(params=['memory', 'json'])
    def db(request, tmp_path: Path):
        if request.param == 'json':
            db_ = TinyDB(tmp_path / 'test.db', storage=JSONStorage)
        else:
>           db_ = TinyDB(storage=MemoryStorage)

tests/conftest.py:17: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <[TypeError("'NoneType' object is not iterable") raised in repr()] TinyDB object at 0x7f06a9298a00>
args = (), kwargs = {}, storage = <class 'tinydb.storages.MemoryStorage'>

    def __init__(self, *args, **kwargs) -> None:
        """
        Create a new instance of TinyDB.
        """
        storage = kwargs.pop('storage', self.default_storage_class)
>       self._storage: Storage = storage(*args, **kwargs)
E       TypeError: Can't instantiate abstract class MemoryStorage with abstract methods read, write

tinydb/database.py:74: TypeError
_________________ ERROR at setup of test_update_multiple[json] _________________

request = <SubRequest 'db' for <Function test_update_multiple[json]>>
tmp_path = PosixPath('/tmp/pytest-of-openhands/pytest-0/test_update_multiple_json_0')

    @pytest.fixture(params=['memory', 'json'])
    def db(request, tmp_path: Path):
        if request.param == 'json':
>           db_ = TinyDB(tmp_path / 'test.db', storage=JSONStorage)

tests/conftest.py:15: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <[TypeError("'NoneType' object is not iterable") raised in repr()] TinyDB object at 0x7f06a9319210>
args = (PosixPath('/tmp/pytest-of-openhands/pytest-0/test_update_multiple_json_0/test.db'),)
kwargs = {}, storage = <class 'tinydb.storages.JSONStorage'>

    def __init__(self, *args, **kwargs) -> None:
        """
        Create a new instance of TinyDB.
        """
        storage = kwargs.pop('storage', self.default_storage_class)
>       self._storage: Storage = storage(*args, **kwargs)
E       TypeError: Can't instantiate abstract class JSONStorage with abstract methods read, write

tinydb/database.py:74: TypeError
___________ ERROR at setup of test_update_multiple_operation[memory] ___________

request = <SubRequest 'db' for <Function test_update_multiple_operation[memory]>>
tmp_path = PosixPath('/tmp/pytest-of-openhands/pytest-0/test_update_multiple_operation0')

    @pytest.fixture(params=['memory', 'json'])
    def db(request, tmp_path: Path):
        if request.param == 'json':
            db_ = TinyDB(tmp_path / 'test.db', storage=JSONStorage)
        else:
>           db_ = TinyDB(storage=MemoryStorage)

tests/conftest.py:17: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <[TypeError("'NoneType' object is not iterable") raised in repr()] TinyDB object at 0x7f06a93196c0>
args = (), kwargs = {}, storage = <class 'tinydb.storages.MemoryStorage'>

    def __init__(self, *args, **kwargs) -> None:
        """
        Create a new instance of TinyDB.
        """
        storage = kwargs.pop('storage', self.default_storage_class)
>       self._storage: Storage = storage(*args, **kwargs)
E       TypeError: Can't instantiate abstract class MemoryStorage with abstract methods read, write

tinydb/database.py:74: TypeError
____________ ERROR at setup of test_update_multiple_operation[json] ____________

request = <SubRequest 'db' for <Function test_update_multiple_operation[json]>>
tmp_path = PosixPath('/tmp/pytest-of-openhands/pytest-0/test_update_multiple_operation1')

    @pytest.fixture(params=['memory', 'json'])
    def db(request, tmp_path: Path):
        if request.param == 'json':
>           db_ = TinyDB(tmp_path / 'test.db', storage=JSONStorage)

tests/conftest.py:15: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <[TypeError("'NoneType' object is not iterable") raised in repr()] TinyDB object at 0x7f06a8e38790>
args = (PosixPath('/tmp/pytest-of-openhands/pytest-0/test_update_multiple_operation1/test.db'),)
kwargs = {}, storage = <class 'tinydb.storages.JSONStorage'>

    def __init__(self, *args, **kwargs) -> None:
        """
        Create a new instance of TinyDB.
        """
        storage = kwargs.pop('storage', self.default_storage_class)
>       self._storage: Storage = storage(*args, **kwargs)
E       TypeError: Can't instantiate abstract class JSONStorage with abstract methods read, write

tinydb/database.py:74: TypeError
____________________ ERROR at setup of test_upsert[memory] _____________________

request = <SubRequest 'db' for <Function test_upsert[memory]>>
tmp_path = PosixPath('/tmp/pytest-of-openhands/pytest-0/test_upsert_memory_0')

    @pytest.fixture(params=['memory', 'json'])
    def db(request, tmp_path: Path):
        if request.param == 'json':
            db_ = TinyDB(tmp_path / 'test.db', storage=JSONStorage)
        else:
>           db_ = TinyDB(storage=MemoryStorage)

tests/conftest.py:17: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <[TypeError("'NoneType' object is not iterable") raised in repr()] TinyDB object at 0x7f06a9315de0>
args = (), kwargs = {}, storage = <class 'tinydb.storages.MemoryStorage'>

    def __init__(self, *args, **kwargs) -> None:
        """
        Create a new instance of TinyDB.
        """
        storage = kwargs.pop('storage', self.default_storage_class)
>       self._storage: Storage = storage(*args, **kwargs)
E       TypeError: Can't instantiate abstract class MemoryStorage with abstract methods read, write

tinydb/database.py:74: TypeError
_____________________ ERROR at setup of test_upsert[json] ______________________

request = <SubRequest 'db' for <Function test_upsert[json]>>
tmp_path = PosixPath('/tmp/pytest-of-openhands/pytest-0/test_upsert_json_0')

    @pytest.fixture(params=['memory', 'json'])
    def db(request, tmp_path: Path):
        if request.param == 'json':
>           db_ = TinyDB(tmp_path / 'test.db', storage=JSONStorage)

tests/conftest.py:15: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <[TypeError("'NoneType' object is not iterable") raised in repr()] TinyDB object at 0x7f06a8e38610>
args = (PosixPath('/tmp/pytest-of-openhands/pytest-0/test_upsert_json_0/test.db'),)
kwargs = {}, storage = <class 'tinydb.storages.JSONStorage'>

    def __init__(self, *args, **kwargs) -> None:
        """
        Create a new instance of TinyDB.
        """
        storage = kwargs.pop('storage', self.default_storage_class)
>       self._storage: Storage = storage(*args, **kwargs)
E       TypeError: Can't instantiate abstract class JSONStorage with abstract methods read, write

tinydb/database.py:74: TypeError
_________________ ERROR at setup of test_upsert_by_id[memory] __________________

request = <SubRequest 'db' for <Function test_upsert_by_id[memory]>>
tmp_path = PosixPath('/tmp/pytest-of-openhands/pytest-0/test_upsert_by_id_memory_0')

    @pytest.fixture(params=['memory', 'json'])
    def db(request, tmp_path: Path):
        if request.param == 'json':
            db_ = TinyDB(tmp_path / 'test.db', storage=JSONStorage)
        else:
>           db_ = TinyDB(storage=MemoryStorage)

tests/conftest.py:17: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <[TypeError("'NoneType' object is not iterable") raised in repr()] TinyDB object at 0x7f06a934bfa0>
args = (), kwargs = {}, storage = <class 'tinydb.storages.MemoryStorage'>

    def __init__(self, *args, **kwargs) -> None:
        """
        Create a new instance of TinyDB.
        """
        storage = kwargs.pop('storage', self.default_storage_class)
>       self._storage: Storage = storage(*args, **kwargs)
E       TypeError: Can't instantiate abstract class MemoryStorage with abstract methods read, write

tinydb/database.py:74: TypeError
__________________ ERROR at setup of test_upsert_by_id[json] ___________________

request = <SubRequest 'db' for <Function test_upsert_by_id[json]>>
tmp_path = PosixPath('/tmp/pytest-of-openhands/pytest-0/test_upsert_by_id_json_0')

    @pytest.fixture(params=['memory', 'json'])
    def db(request, tmp_path: Path):
        if request.param == 'json':
>           db_ = TinyDB(tmp_path / 'test.db', storage=JSONStorage)

tests/conftest.py:15: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <[TypeError("'NoneType' object is not iterable") raised in repr()] TinyDB object at 0x7f06a8c845e0>
args = (PosixPath('/tmp/pytest-of-openhands/pytest-0/test_upsert_by_id_json_0/test.db'),)
kwargs = {}, storage = <class 'tinydb.storages.JSONStorage'>

    def __init__(self, *args, **kwargs) -> None:
        """
        Create a new instance of TinyDB.
        """
        storage = kwargs.pop('storage', self.default_storage_class)
>       self._storage: Storage = storage(*args, **kwargs)
E       TypeError: Can't instantiate abstract class JSONStorage with abstract methods read, write

tinydb/database.py:74: TypeError
____________________ ERROR at setup of test_search[memory] _____________________

request = <SubRequest 'db' for <Function test_search[memory]>>
tmp_path = PosixPath('/tmp/pytest-of-openhands/pytest-0/test_search_memory_0')

    @pytest.fixture(params=['memory', 'json'])
    def db(request, tmp_path: Path):
        if request.param == 'json':
            db_ = TinyDB(tmp_path / 'test.db', storage=JSONStorage)
        else:
>           db_ = TinyDB(storage=MemoryStorage)

tests/conftest.py:17: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <[TypeError("'NoneType' object is not iterable") raised in repr()] TinyDB object at 0x7f06a92c8d90>
args = (), kwargs = {}, storage = <class 'tinydb.storages.MemoryStorage'>

    def __init__(self, *args, **kwargs) -> None:
        """
        Create a new instance of TinyDB.
        """
        storage = kwargs.pop('storage', self.default_storage_class)
>       self._storage: Storage = storage(*args, **kwargs)
E       TypeError: Can't instantiate abstract class MemoryStorage with abstract methods read, write

tinydb/database.py:74: TypeError
_____________________ ERROR at setup of test_search[json] ______________________

request = <SubRequest 'db' for <Function test_search[json]>>
tmp_path = PosixPath('/tmp/pytest-of-openhands/pytest-0/test_search_json_0')

    @pytest.fixture(params=['memory', 'json'])
    def db(request, tmp_path: Path):
        if request.param == 'json':
>           db_ = TinyDB(tmp_path / 'test.db', storage=JSONStorage)

tests/conftest.py:15: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <[TypeError("'NoneType' object is not iterable") raised in repr()] TinyDB object at 0x7f06a9256290>
args = (PosixPath('/tmp/pytest-of-openhands/pytest-0/test_search_json_0/test.db'),)
kwargs = {}, storage = <class 'tinydb.storages.JSONStorage'>

    def __init__(self, *args, **kwargs) -> None:
        """
        Create a new instance of TinyDB.
        """
        storage = kwargs.pop('storage', self.default_storage_class)
>       self._storage: Storage = storage(*args, **kwargs)
E       TypeError: Can't instantiate abstract class JSONStorage with abstract methods read, write

tinydb/database.py:74: TypeError
__________________ ERROR at setup of test_search_path[memory] __________________

request = <SubRequest 'db' for <Function test_search_path[memory]>>
tmp_path = PosixPath('/tmp/pytest-of-openhands/pytest-0/test_search_path_memory_0')

    @pytest.fixture(params=['memory', 'json'])
    def db(request, tmp_path: Path):
        if request.param == 'json':
            db_ = TinyDB(tmp_path / 'test.db', storage=JSONStorage)
        else:
>           db_ = TinyDB(storage=MemoryStorage)

tests/conftest.py:17: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <[TypeError("'NoneType' object is not iterable") raised in repr()] TinyDB object at 0x7f06a93494e0>
args = (), kwargs = {}, storage = <class 'tinydb.storages.MemoryStorage'>

    def __init__(self, *args, **kwargs) -> None:
        """
        Create a new instance of TinyDB.
        """
        storage = kwargs.pop('storage', self.default_storage_class)
>       self._storage: Storage = storage(*args, **kwargs)
E       TypeError: Can't instantiate abstract class MemoryStorage with abstract methods read, write

tinydb/database.py:74: TypeError
___________________ ERROR at setup of test_search_path[json] ___________________

request = <SubRequest 'db' for <Function test_search_path[json]>>
tmp_path = PosixPath('/tmp/pytest-of-openhands/pytest-0/test_search_path_json_0')

    @pytest.fixture(params=['memory', 'json'])
    def db(request, tmp_path: Path):
        if request.param == 'json':
>           db_ = TinyDB(tmp_path / 'test.db', storage=JSONStorage)

tests/conftest.py:15: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <[TypeError("'NoneType' object is not iterable") raised in repr()] TinyDB object at 0x7f06a9256fe0>
args = (PosixPath('/tmp/pytest-of-openhands/pytest-0/test_search_path_json_0/test.db'),)
kwargs = {}, storage = <class 'tinydb.storages.JSONStorage'>

    def __init__(self, *args, **kwargs) -> None:
        """
        Create a new instance of TinyDB.
        """
        storage = kwargs.pop('storage', self.default_storage_class)
>       self._storage: Storage = storage(*args, **kwargs)
E       TypeError: Can't instantiate abstract class JSONStorage with abstract methods read, write

tinydb/database.py:74: TypeError
____________ ERROR at setup of test_search_no_results_cache[memory] ____________

request = <SubRequest 'db' for <Function test_search_no_results_cache[memory]>>
tmp_path = PosixPath('/tmp/pytest-of-openhands/pytest-0/test_search_no_results_cache_m0')

    @pytest.fixture(params=['memory', 'json'])
    def db(request, tmp_path: Path):
        if request.param == 'json':
            db_ = TinyDB(tmp_path / 'test.db', storage=JSONStorage)
        else:
>           db_ = TinyDB(storage=MemoryStorage)

tests/conftest.py:17: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <[TypeError("'NoneType' object is not iterable") raised in repr()] TinyDB object at 0x7f06a8c870a0>
args = (), kwargs = {}, storage = <class 'tinydb.storages.MemoryStorage'>

    def __init__(self, *args, **kwargs) -> None:
        """
        Create a new instance of TinyDB.
        """
        storage = kwargs.pop('storage', self.default_storage_class)
>       self._storage: Storage = storage(*args, **kwargs)
E       TypeError: Can't instantiate abstract class MemoryStorage with abstract methods read, write

tinydb/database.py:74: TypeError
_____________ ERROR at setup of test_search_no_results_cache[json] _____________

request = <SubRequest 'db' for <Function test_search_no_results_cache[json]>>
tmp_path = PosixPath('/tmp/pytest-of-openhands/pytest-0/test_search_no_results_cache_j0')

    @pytest.fixture(params=['memory', 'json'])
    def db(request, tmp_path: Path):
        if request.param == 'json':
>           db_ = TinyDB(tmp_path / 'test.db', storage=JSONStorage)

tests/conftest.py:15: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <[TypeError("'NoneType' object is not iterable") raised in repr()] TinyDB object at 0x7f06a92d9e70>
args = (PosixPath('/tmp/pytest-of-openhands/pytest-0/test_search_no_results_cache_j0/test.db'),)
kwargs = {}, storage = <class 'tinydb.storages.JSONStorage'>

    def __init__(self, *args, **kwargs) -> None:
        """
        Create a new instance of TinyDB.
        """
        storage = kwargs.pop('storage', self.default_storage_class)
>       self._storage: Storage = storage(*args, **kwargs)
E       TypeError: Can't instantiate abstract class JSONStorage with abstract methods read, write

tinydb/database.py:74: TypeError
______________________ ERROR at setup of test_get[memory] ______________________

request = <SubRequest 'db' for <Function test_get[memory]>>
tmp_path = PosixPath('/tmp/pytest-of-openhands/pytest-0/test_get_memory_0')

    @pytest.fixture(params=['memory', 'json'])
    def db(request, tmp_path: Path):
        if request.param == 'json':
            db_ = TinyDB(tmp_path / 'test.db', storage=JSONStorage)
        else:
>           db_ = TinyDB(storage=MemoryStorage)

tests/conftest.py:17: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <[TypeError("'NoneType' object is not iterable") raised in repr()] TinyDB object at 0x7f06a9217490>
args = (), kwargs = {}, storage = <class 'tinydb.storages.MemoryStorage'>

    def __init__(self, *args, **kwargs) -> None:
        """
        Create a new instance of TinyDB.
        """
        storage = kwargs.pop('storage', self.default_storage_class)
>       self._storage: Storage = storage(*args, **kwargs)
E       TypeError: Can't instantiate abstract class MemoryStorage with abstract methods read, write

tinydb/database.py:74: TypeError
_______________________ ERROR at setup of test_get[json] _______________________

request = <SubRequest 'db' for <Function test_get[json]>>
tmp_path = PosixPath('/tmp/pytest-of-openhands/pytest-0/test_get_json_0')

    @pytest.fixture(params=['memory', 'json'])
    def db(request, tmp_path: Path):
        if request.param == 'json':
>           db_ = TinyDB(tmp_path / 'test.db', storage=JSONStorage)

tests/conftest.py:15: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <[TypeError("'NoneType' object is not iterable") raised in repr()] TinyDB object at 0x7f06a8c86170>
args = (PosixPath('/tmp/pytest-of-openhands/pytest-0/test_get_json_0/test.db'),)
kwargs = {}, storage = <class 'tinydb.storages.JSONStorage'>

    def __init__(self, *args, **kwargs) -> None:
        """
        Create a new instance of TinyDB.
        """
        storage = kwargs.pop('storage', self.default_storage_class)
>       self._storage: Storage = storage(*args, **kwargs)
E       TypeError: Can't instantiate abstract class JSONStorage with abstract methods read, write

tinydb/database.py:74: TypeError
____________________ ERROR at setup of test_get_ids[memory] ____________________

request = <SubRequest 'db' for <Function test_get_ids[memory]>>
tmp_path = PosixPath('/tmp/pytest-of-openhands/pytest-0/test_get_ids_memory_0')

    @pytest.fixture(params=['memory', 'json'])
    def db(request, tmp_path: Path):
        if request.param == 'json':
            db_ = TinyDB(tmp_path / 'test.db', storage=JSONStorage)
        else:
>           db_ = TinyDB(storage=MemoryStorage)

tests/conftest.py:17: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <[TypeError("'NoneType' object is not iterable") raised in repr()] TinyDB object at 0x7f06a8e3ba00>
args = (), kwargs = {}, storage = <class 'tinydb.storages.MemoryStorage'>

    def __init__(self, *args, **kwargs) -> None:
        """
        Create a new instance of TinyDB.
        """
        storage = kwargs.pop('storage', self.default_storage_class)
>       self._storage: Storage = storage(*args, **kwargs)
E       TypeError: Can't instantiate abstract class MemoryStorage with abstract methods read, write

tinydb/database.py:74: TypeError
_____________________ ERROR at setup of test_get_ids[json] _____________________

request = <SubRequest 'db' for <Function test_get_ids[json]>>
tmp_path = PosixPath('/tmp/pytest-of-openhands/pytest-0/test_get_ids_json_0')

    @pytest.fixture(params=['memory', 'json'])
    def db(request, tmp_path: Path):
        if request.param == 'json':
>           db_ = TinyDB(tmp_path / 'test.db', storage=JSONStorage)

tests/conftest.py:15: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <[TypeError("'NoneType' object is not iterable") raised in repr()] TinyDB object at 0x7f06a9217e20>
args = (PosixPath('/tmp/pytest-of-openhands/pytest-0/test_get_ids_json_0/test.db'),)
kwargs = {}, storage = <class 'tinydb.storages.JSONStorage'>

    def __init__(self, *args, **kwargs) -> None:
        """
        Create a new instance of TinyDB.
        """
        storage = kwargs.pop('storage', self.default_storage_class)
>       self._storage: Storage = storage(*args, **kwargs)
E       TypeError: Can't instantiate abstract class JSONStorage with abstract methods read, write

tinydb/database.py:74: TypeError
_______________ ERROR at setup of test_get_multiple_ids[memory] ________________

request = <SubRequest 'db' for <Function test_get_multiple_ids[memory]>>
tmp_path = PosixPath('/tmp/pytest-of-openhands/pytest-0/test_get_multiple_ids_memory_0')

    @pytest.fixture(params=['memory', 'json'])
    def db(request, tmp_path: Path):
        if request.param == 'json':
            db_ = TinyDB(tmp_path / 'test.db', storage=JSONStorage)
        else:
>           db_ = TinyDB(storage=MemoryStorage)

tests/conftest.py:17: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <[TypeError("'NoneType' object is not iterable") raised in repr()] TinyDB object at 0x7f06a9318d30>
args = (), kwargs = {}, storage = <class 'tinydb.storages.MemoryStorage'>

    def __init__(self, *args, **kwargs) -> None:
        """
        Create a new instance of TinyDB.
        """
        storage = kwargs.pop('storage', self.default_storage_class)
>       self._storage: Storage = storage(*args, **kwargs)
E       TypeError: Can't instantiate abstract class MemoryStorage with abstract methods read, write

tinydb/database.py:74: TypeError
________________ ERROR at setup of test_get_multiple_ids[json] _________________

request = <SubRequest 'db' for <Function test_get_multiple_ids[json]>>
tmp_path = PosixPath('/tmp/pytest-of-openhands/pytest-0/test_get_multiple_ids_json_0')

    @pytest.fixture(params=['memory', 'json'])
    def db(request, tmp_path: Path):
        if request.param == 'json':
>           db_ = TinyDB(tmp_path / 'test.db', storage=JSONStorage)

tests/conftest.py:15: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <[TypeError("'NoneType' object is not iterable") raised in repr()] TinyDB object at 0x7f06a934b1c0>
args = (PosixPath('/tmp/pytest-of-openhands/pytest-0/test_get_multiple_ids_json_0/test.db'),)
kwargs = {}, storage = <class 'tinydb.storages.JSONStorage'>

    def __init__(self, *args, **kwargs) -> None:
        """
        Create a new instance of TinyDB.
        """
        storage = kwargs.pop('storage', self.default_storage_class)
>       self._storage: Storage = storage(*args, **kwargs)
E       TypeError: Can't instantiate abstract class JSONStorage with abstract methods read, write

tinydb/database.py:74: TypeError
__________________ ERROR at setup of test_get_invalid[memory] __________________

request = <SubRequest 'db' for <Function test_get_invalid[memory]>>
tmp_path = PosixPath('/tmp/pytest-of-openhands/pytest-0/test_get_invalid_memory_0')

    @pytest.fixture(params=['memory', 'json'])
    def db(request, tmp_path: Path):
        if request.param == 'json':
            db_ = TinyDB(tmp_path / 'test.db', storage=JSONStorage)
        else:
>           db_ = TinyDB(storage=MemoryStorage)

tests/conftest.py:17: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <[TypeError("'NoneType' object is not iterable") raised in repr()] TinyDB object at 0x7f06a9256740>
args = (), kwargs = {}, storage = <class 'tinydb.storages.MemoryStorage'>

    def __init__(self, *args, **kwargs) -> None:
        """
        Create a new instance of TinyDB.
        """
        storage = kwargs.pop('storage', self.default_storage_class)
>       self._storage: Storage = storage(*args, **kwargs)
E       TypeError: Can't instantiate abstract class MemoryStorage with abstract methods read, write

tinydb/database.py:74: TypeError
___________________ ERROR at setup of test_get_invalid[json] ___________________

request = <SubRequest 'db' for <Function test_get_invalid[json]>>
tmp_path = PosixPath('/tmp/pytest-of-openhands/pytest-0/test_get_invalid_json_0')

    @pytest.fixture(params=['memory', 'json'])
    def db(request, tmp_path: Path):
        if request.param == 'json':
>           db_ = TinyDB(tmp_path / 'test.db', storage=JSONStorage)

tests/conftest.py:15: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <[TypeError("'NoneType' object is not iterable") raised in repr()] TinyDB object at 0x7f06a929dde0>
args = (PosixPath('/tmp/pytest-of-openhands/pytest-0/test_get_invalid_json_0/test.db'),)
kwargs = {}, storage = <class 'tinydb.storages.JSONStorage'>

    def __init__(self, *args, **kwargs) -> None:
        """
        Create a new instance of TinyDB.
        """
        storage = kwargs.pop('storage', self.default_storage_class)
>       self._storage: Storage = storage(*args, **kwargs)
E       TypeError: Can't instantiate abstract class JSONStorage with abstract methods read, write

tinydb/database.py:74: TypeError
_____________________ ERROR at setup of test_count[memory] _____________________

request = <SubRequest 'db' for <Function test_count[memory]>>
tmp_path = PosixPath('/tmp/pytest-of-openhands/pytest-0/test_count_memory_0')

    @pytest.fixture(params=['memory', 'json'])
    def db(request, tmp_path: Path):
        if request.param == 'json':
            db_ = TinyDB(tmp_path / 'test.db', storage=JSONStorage)
        else:
>           db_ = TinyDB(storage=MemoryStorage)

tests/conftest.py:17: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <[TypeError("'NoneType' object is not iterable") raised in repr()] TinyDB object at 0x7f06a93499f0>
args = (), kwargs = {}, storage = <class 'tinydb.storages.MemoryStorage'>

    def __init__(self, *args, **kwargs) -> None:
        """
        Create a new instance of TinyDB.
        """
        storage = kwargs.pop('storage', self.default_storage_class)
>       self._storage: Storage = storage(*args, **kwargs)
E       TypeError: Can't instantiate abstract class MemoryStorage with abstract methods read, write

tinydb/database.py:74: TypeError
______________________ ERROR at setup of test_count[json] ______________________

request = <SubRequest 'db' for <Function test_count[json]>>
tmp_path = PosixPath('/tmp/pytest-of-openhands/pytest-0/test_count_json_0')

    @pytest.fixture(params=['memory', 'json'])
    def db(request, tmp_path: Path):
        if request.param == 'json':
>           db_ = TinyDB(tmp_path / 'test.db', storage=JSONStorage)

tests/conftest.py:15: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <[TypeError("'NoneType' object is not iterable") raised in repr()] TinyDB object at 0x7f06a8fbf7f0>
args = (PosixPath('/tmp/pytest-of-openhands/pytest-0/test_count_json_0/test.db'),)
kwargs = {}, storage = <class 'tinydb.storages.JSONStorage'>

    def __init__(self, *args, **kwargs) -> None:
        """
        Create a new instance of TinyDB.
        """
        storage = kwargs.pop('storage', self.default_storage_class)
>       self._storage: Storage = storage(*args, **kwargs)
E       TypeError: Can't instantiate abstract class JSONStorage with abstract methods read, write

tinydb/database.py:74: TypeError
___________________ ERROR at setup of test_contains[memory] ____________________

request = <SubRequest 'db' for <Function test_contains[memory]>>
tmp_path = PosixPath('/tmp/pytest-of-openhands/pytest-0/test_contains_memory_0')

    @pytest.fixture(params=['memory', 'json'])
    def db(request, tmp_path: Path):
        if request.param == 'json':
            db_ = TinyDB(tmp_path / 'test.db', storage=JSONStorage)
        else:
>           db_ = TinyDB(storage=MemoryStorage)

tests/conftest.py:17: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <[TypeError("'NoneType' object is not iterable") raised in repr()] TinyDB object at 0x7f06a92ca5f0>
args = (), kwargs = {}, storage = <class 'tinydb.storages.MemoryStorage'>

    def __init__(self, *args, **kwargs) -> None:
        """
        Create a new instance of TinyDB.
        """
        storage = kwargs.pop('storage', self.default_storage_class)
>       self._storage: Storage = storage(*args, **kwargs)
E       TypeError: Can't instantiate abstract class MemoryStorage with abstract methods read, write

tinydb/database.py:74: TypeError
____________________ ERROR at setup of test_contains[json] _____________________

request = <SubRequest 'db' for <Function test_contains[json]>>
tmp_path = PosixPath('/tmp/pytest-of-openhands/pytest-0/test_contains_json_0')

    @pytest.fixture(params=['memory', 'json'])
    def db(request, tmp_path: Path):
        if request.param == 'json':
>           db_ = TinyDB(tmp_path / 'test.db', storage=JSONStorage)

tests/conftest.py:15: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <[TypeError("'NoneType' object is not iterable") raised in repr()] TinyDB object at 0x7f06a929fac0>
args = (PosixPath('/tmp/pytest-of-openhands/pytest-0/test_contains_json_0/test.db'),)
kwargs = {}, storage = <class 'tinydb.storages.JSONStorage'>

    def __init__(self, *args, **kwargs) -> None:
        """
        Create a new instance of TinyDB.
        """
        storage = kwargs.pop('storage', self.default_storage_class)
>       self._storage: Storage = storage(*args, **kwargs)
E       TypeError: Can't instantiate abstract class JSONStorage with abstract methods read, write

tinydb/database.py:74: TypeError
_________________ ERROR at setup of test_contains_ids[memory] __________________

request = <SubRequest 'db' for <Function test_contains_ids[memory]>>
tmp_path = PosixPath('/tmp/pytest-of-openhands/pytest-0/test_contains_ids_memory_0')

    @pytest.fixture(params=['memory', 'json'])
    def db(request, tmp_path: Path):
        if request.param == 'json':
            db_ = TinyDB(tmp_path / 'test.db', storage=JSONStorage)
        else:
>           db_ = TinyDB(storage=MemoryStorage)

tests/conftest.py:17: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <[TypeError("'NoneType' object is not iterable") raised in repr()] TinyDB object at 0x7f06a8c878b0>
args = (), kwargs = {}, storage = <class 'tinydb.storages.MemoryStorage'>

    def __init__(self, *args, **kwargs) -> None:
        """
        Create a new instance of TinyDB.
        """
        storage = kwargs.pop('storage', self.default_storage_class)
>       self._storage: Storage = storage(*args, **kwargs)
E       TypeError: Can't instantiate abstract class MemoryStorage with abstract methods read, write

tinydb/database.py:74: TypeError
__________________ ERROR at setup of test_contains_ids[json] ___________________

request = <SubRequest 'db' for <Function test_contains_ids[json]>>
tmp_path = PosixPath('/tmp/pytest-of-openhands/pytest-0/test_contains_ids_json_0')

    @pytest.fixture(params=['memory', 'json'])
    def db(request, tmp_path: Path):
        if request.param == 'json':
>           db_ = TinyDB(tmp_path / 'test.db', storage=JSONStorage)

tests/conftest.py:15: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <[TypeError("'NoneType' object is not iterable") raised in repr()] TinyDB object at 0x7f06a9348220>
args = (PosixPath('/tmp/pytest-of-openhands/pytest-0/test_contains_ids_json_0/test.db'),)
kwargs = {}, storage = <class 'tinydb.storages.JSONStorage'>

    def __init__(self, *args, **kwargs) -> None:
        """
        Create a new instance of TinyDB.
        """
        storage = kwargs.pop('storage', self.default_storage_class)
>       self._storage: Storage = storage(*args, **kwargs)
E       TypeError: Can't instantiate abstract class JSONStorage with abstract methods read, write

tinydb/database.py:74: TypeError
_______________ ERROR at setup of test_contains_invalid[memory] ________________

request = <SubRequest 'db' for <Function test_contains_invalid[memory]>>
tmp_path = PosixPath('/tmp/pytest-of-openhands/pytest-0/test_contains_invalid_memory_0')

    @pytest.fixture(params=['memory', 'json'])
    def db(request, tmp_path: Path):
        if request.param == 'json':
            db_ = TinyDB(tmp_path / 'test.db', storage=JSONStorage)
        else:
>           db_ = TinyDB(storage=MemoryStorage)

tests/conftest.py:17: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <[TypeError("'NoneType' object is not iterable") raised in repr()] TinyDB object at 0x7f06a9216fb0>
args = (), kwargs = {}, storage = <class 'tinydb.storages.MemoryStorage'>

    def __init__(self, *args, **kwargs) -> None:
        """
        Create a new instance of TinyDB.
        """
        storage = kwargs.pop('storage', self.default_storage_class)
>       self._storage: Storage = storage(*args, **kwargs)
E       TypeError: Can't instantiate abstract class MemoryStorage with abstract methods read, write

tinydb/database.py:74: TypeError
________________ ERROR at setup of test_contains_invalid[json] _________________

request = <SubRequest 'db' for <Function test_contains_invalid[json]>>
tmp_path = PosixPath('/tmp/pytest-of-openhands/pytest-0/test_contains_invalid_json_0')

    @pytest.fixture(params=['memory', 'json'])
    def db(request, tmp_path: Path):
        if request.param == 'json':
>           db_ = TinyDB(tmp_path / 'test.db', storage=JSONStorage)

tests/conftest.py:15: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <[TypeError("'NoneType' object is not iterable") raised in repr()] TinyDB object at 0x7f06a8e3a9b0>
args = (PosixPath('/tmp/pytest-of-openhands/pytest-0/test_contains_invalid_json_0/test.db'),)
kwargs = {}, storage = <class 'tinydb.storages.JSONStorage'>

    def __init__(self, *args, **kwargs) -> None:
        """
        Create a new instance of TinyDB.
        """
        storage = kwargs.pop('storage', self.default_storage_class)
>       self._storage: Storage = storage(*args, **kwargs)
E       TypeError: Can't instantiate abstract class JSONStorage with abstract methods read, write

tinydb/database.py:74: TypeError
________________ ERROR at setup of test_get_idempotent[memory] _________________

request = <SubRequest 'db' for <Function test_get_idempotent[memory]>>
tmp_path = PosixPath('/tmp/pytest-of-openhands/pytest-0/test_get_idempotent_memory_0')

    @pytest.fixture(params=['memory', 'json'])
    def db(request, tmp_path: Path):
        if request.param == 'json':
            db_ = TinyDB(tmp_path / 'test.db', storage=JSONStorage)
        else:
>           db_ = TinyDB(storage=MemoryStorage)

tests/conftest.py:17: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <[TypeError("'NoneType' object is not iterable") raised in repr()] TinyDB object at 0x7f06a9255990>
args = (), kwargs = {}, storage = <class 'tinydb.storages.MemoryStorage'>

    def __init__(self, *args, **kwargs) -> None:
        """
        Create a new instance of TinyDB.
        """
        storage = kwargs.pop('storage', self.default_storage_class)
>       self._storage: Storage = storage(*args, **kwargs)
E       TypeError: Can't instantiate abstract class MemoryStorage with abstract methods read, write

tinydb/database.py:74: TypeError
_________________ ERROR at setup of test_get_idempotent[json] __________________

request = <SubRequest 'db' for <Function test_get_idempotent[json]>>
tmp_path = PosixPath('/tmp/pytest-of-openhands/pytest-0/test_get_idempotent_json_0')

    @pytest.fixture(params=['memory', 'json'])
    def db(request, tmp_path: Path):
        if request.param == 'json':
>           db_ = TinyDB(tmp_path / 'test.db', storage=JSONStorage)

tests/conftest.py:15: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <[TypeError("'NoneType' object is not iterable") raised in repr()] TinyDB object at 0x7f06a9314b80>
args = (PosixPath('/tmp/pytest-of-openhands/pytest-0/test_get_idempotent_json_0/test.db'),)
kwargs = {}, storage = <class 'tinydb.storages.JSONStorage'>

    def __init__(self, *args, **kwargs) -> None:
        """
        Create a new instance of TinyDB.
        """
        storage = kwargs.pop('storage', self.default_storage_class)
>       self._storage: Storage = storage(*args, **kwargs)
E       TypeError: Can't instantiate abstract class JSONStorage with abstract methods read, write

tinydb/database.py:74: TypeError
______________ ERROR at setup of test_tinydb_is_iterable[memory] _______________

request = <SubRequest 'db' for <Function test_tinydb_is_iterable[memory]>>
tmp_path = PosixPath('/tmp/pytest-of-openhands/pytest-0/test_tinydb_is_iterable_memory0')

    @pytest.fixture(params=['memory', 'json'])
    def db(request, tmp_path: Path):
        if request.param == 'json':
            db_ = TinyDB(tmp_path / 'test.db', storage=JSONStorage)
        else:
>           db_ = TinyDB(storage=MemoryStorage)

tests/conftest.py:17: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <[TypeError("'NoneType' object is not iterable") raised in repr()] TinyDB object at 0x7f06a8f24520>
args = (), kwargs = {}, storage = <class 'tinydb.storages.MemoryStorage'>

    def __init__(self, *args, **kwargs) -> None:
        """
        Create a new instance of TinyDB.
        """
        storage = kwargs.pop('storage', self.default_storage_class)
>       self._storage: Storage = storage(*args, **kwargs)
E       TypeError: Can't instantiate abstract class MemoryStorage with abstract methods read, write

tinydb/database.py:74: TypeError
_______________ ERROR at setup of test_tinydb_is_iterable[json] ________________

request = <SubRequest 'db' for <Function test_tinydb_is_iterable[json]>>
tmp_path = PosixPath('/tmp/pytest-of-openhands/pytest-0/test_tinydb_is_iterable_json_0')

    @pytest.fixture(params=['memory', 'json'])
    def db(request, tmp_path: Path):
        if request.param == 'json':
>           db_ = TinyDB(tmp_path / 'test.db', storage=JSONStorage)

tests/conftest.py:15: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <[TypeError("'NoneType' object is not iterable") raised in repr()] TinyDB object at 0x7f06a8ec6c50>
args = (PosixPath('/tmp/pytest-of-openhands/pytest-0/test_tinydb_is_iterable_json_0/test.db'),)
kwargs = {}, storage = <class 'tinydb.storages.JSONStorage'>

    def __init__(self, *args, **kwargs) -> None:
        """
        Create a new instance of TinyDB.
        """
        storage = kwargs.pop('storage', self.default_storage_class)
>       self._storage: Storage = storage(*args, **kwargs)
E       TypeError: Can't instantiate abstract class JSONStorage with abstract methods read, write

tinydb/database.py:74: TypeError
_______ ERROR at setup of test_insert_multiple_with_single_dict[memory] ________

request = <SubRequest 'db' for <Function test_insert_multiple_with_single_dict[memory]>>
tmp_path = PosixPath('/tmp/pytest-of-openhands/pytest-0/test_insert_multiple_with_sing0')

    @pytest.fixture(params=['memory', 'json'])
    def db(request, tmp_path: Path):
        if request.param == 'json':
            db_ = TinyDB(tmp_path / 'test.db', storage=JSONStorage)
        else:
>           db_ = TinyDB(storage=MemoryStorage)

tests/conftest.py:17: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <[TypeError("'NoneType' object is not iterable") raised in repr()] TinyDB object at 0x7f06a9349ab0>
args = (), kwargs = {}, storage = <class 'tinydb.storages.MemoryStorage'>

    def __init__(self, *args, **kwargs) -> None:
        """
        Create a new instance of TinyDB.
        """
        storage = kwargs.pop('storage', self.default_storage_class)
>       self._storage: Storage = storage(*args, **kwargs)
E       TypeError: Can't instantiate abstract class MemoryStorage with abstract methods read, write

tinydb/database.py:74: TypeError
________ ERROR at setup of test_insert_multiple_with_single_dict[json] _________

request = <SubRequest 'db' for <Function test_insert_multiple_with_single_dict[json]>>
tmp_path = PosixPath('/tmp/pytest-of-openhands/pytest-0/test_insert_multiple_with_sing1')

    @pytest.fixture(params=['memory', 'json'])
    def db(request, tmp_path: Path):
        if request.param == 'json':
>           db_ = TinyDB(tmp_path / 'test.db', storage=JSONStorage)

tests/conftest.py:15: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <[TypeError("'NoneType' object is not iterable") raised in repr()] TinyDB object at 0x7f06a9256cb0>
args = (PosixPath('/tmp/pytest-of-openhands/pytest-0/test_insert_multiple_with_sing1/test.db'),)
kwargs = {}, storage = <class 'tinydb.storages.JSONStorage'>

    def __init__(self, *args, **kwargs) -> None:
        """
        Create a new instance of TinyDB.
        """
        storage = kwargs.pop('storage', self.default_storage_class)
>       self._storage: Storage = storage(*args, **kwargs)
E       TypeError: Can't instantiate abstract class JSONStorage with abstract methods read, write

tinydb/database.py:74: TypeError
=================================== FAILURES ===================================
______________________________ test_caching_read _______________________________

    def test_caching_read():
>       db = TinyDB(storage=CachingMiddleware(MemoryStorage))

tests/test_middlewares.py:22: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
tinydb/database.py:74: in __init__
    self._storage: Storage = storage(*args, **kwargs)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <tinydb.middlewares.CachingMiddleware object at 0x7f06a92da2f0>
args = (), kwargs = {}

    def __call__(self, *args, **kwargs):
        """
        Create the storage instance and store it as self.storage.
    
        Usually a user creates a new TinyDB instance like this::
    
            TinyDB(storage=StorageClass)
    
        The storage keyword argument is used by TinyDB this way::
    
            self.storage = storage(*args, **kwargs)
    
        As we can see, ``storage(...)`` runs the constructor and returns the
        new storage instance.
    
    
        Using Middlewares, the user will call::
    
                                       The 'real' storage class
                                       v
            TinyDB(storage=Middleware(StorageClass))
                       ^
                       Already an instance!
    
        So, when running ``self.storage = storage(*args, **kwargs)`` Python
        now will call ``__call__`` and TinyDB will expect the return value to
        be the storage (or Middleware) instance. Returning the instance is
        simple, but we also got the underlying (*real*) StorageClass as an
        __init__ argument that still is not an instance.
        So, we initialize it in __call__ forwarding any arguments we receive
        from TinyDB (``TinyDB(arg1, kwarg1=value, storage=...)``).
    
        In case of nested Middlewares, calling the instance as if it was a
        class results in calling ``__call__`` what initializes the next
        nested Middleware that itself will initialize the next Middleware and
        so on.
        """
>       self.storage = self._storage_cls(*args, **kwargs)
E       TypeError: Can't instantiate abstract class MemoryStorage with abstract methods read, write

tinydb/middlewares.py:60: TypeError
_________________________________ test_nested __________________________________

    def test_nested():
        storage = CachingMiddleware(MemoryStorage)
>       storage()  # Initialization

tests/test_middlewares.py:79: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <tinydb.middlewares.CachingMiddleware object at 0x7f06a920c760>
args = (), kwargs = {}

    def __call__(self, *args, **kwargs):
        """
        Create the storage instance and store it as self.storage.
    
        Usually a user creates a new TinyDB instance like this::
    
            TinyDB(storage=StorageClass)
    
        The storage keyword argument is used by TinyDB this way::
    
            self.storage = storage(*args, **kwargs)
    
        As we can see, ``storage(...)`` runs the constructor and returns the
        new storage instance.
    
    
        Using Middlewares, the user will call::
    
                                       The 'real' storage class
                                       v
            TinyDB(storage=Middleware(StorageClass))
                       ^
                       Already an instance!
    
        So, when running ``self.storage = storage(*args, **kwargs)`` Python
        now will call ``__call__`` and TinyDB will expect the return value to
        be the storage (or Middleware) instance. Returning the instance is
        simple, but we also got the underlying (*real*) StorageClass as an
        __init__ argument that still is not an instance.
        So, we initialize it in __call__ forwarding any arguments we receive
        from TinyDB (``TinyDB(arg1, kwarg1=value, storage=...)``).
    
        In case of nested Middlewares, calling the instance as if it was a
        class results in calling ``__call__`` what initializes the next
        nested Middleware that itself will initialize the next Middleware and
        so on.
        """
>       self.storage = self._storage_cls(*args, **kwargs)
E       TypeError: Can't instantiate abstract class MemoryStorage with abstract methods read, write

tinydb/middlewares.py:60: TypeError
___________________________ test_caching_json_write ____________________________

tmpdir = local('/tmp/pytest-of-openhands/pytest-0/test_caching_json_write0')

    def test_caching_json_write(tmpdir):
        path = str(tmpdir.join('test.db'))
    
>       with TinyDB(path, storage=CachingMiddleware(JSONStorage)) as db:

tests/test_middlewares.py:91: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
tinydb/database.py:74: in __init__
    self._storage: Storage = storage(*args, **kwargs)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <tinydb.middlewares.CachingMiddleware object at 0x7f06a931aa10>
args = ('/tmp/pytest-of-openhands/pytest-0/test_caching_json_write0/test.db',)
kwargs = {}

    def __call__(self, *args, **kwargs):
        """
        Create the storage instance and store it as self.storage.
    
        Usually a user creates a new TinyDB instance like this::
    
            TinyDB(storage=StorageClass)
    
        The storage keyword argument is used by TinyDB this way::
    
            self.storage = storage(*args, **kwargs)
    
        As we can see, ``storage(...)`` runs the constructor and returns the
        new storage instance.
    
    
        Using Middlewares, the user will call::
    
                                       The 'real' storage class
                                       v
            TinyDB(storage=Middleware(StorageClass))
                       ^
                       Already an instance!
    
        So, when running ``self.storage = storage(*args, **kwargs)`` Python
        now will call ``__call__`` and TinyDB will expect the return value to
        be the storage (or Middleware) instance. Returning the instance is
        simple, but we also got the underlying (*real*) StorageClass as an
        __init__ argument that still is not an instance.
        So, we initialize it in __call__ forwarding any arguments we receive
        from TinyDB (``TinyDB(arg1, kwarg1=value, storage=...)``).
    
        In case of nested Middlewares, calling the instance as if it was a
        class results in calling ``__call__`` what initializes the next
        nested Middleware that itself will initialize the next Middleware and
        so on.
        """
>       self.storage = self._storage_cls(*args, **kwargs)
E       TypeError: Can't instantiate abstract class JSONStorage with abstract methods read, write

tinydb/middlewares.py:60: TypeError
___________________________________ test_any ___________________________________

    def test_any():
        query = Query().followers.any(Query().name == 'don')
    
        assert query({'followers': [{'name': 'don'}, {'name': 'john'}]})
        assert not query({'followers': 1})
        assert not query({})
        assert hash(query)
    
        query = Query().followers.any(Query().num.matches('\\d+'))
        assert query({'followers': [{'num': '12'}, {'num': 'abc'}]})
        assert not query({'followers': [{'num': 'abc'}]})
        assert hash(query)
    
        query = Query().followers.any(['don', 'jon'])
        assert query({'followers': ['don', 'greg', 'bill']})
        assert not query({'followers': ['greg', 'bill']})
        assert not query({})
>       assert hash(query)

tests/test_queries.py:242: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = QueryImpl('any', ('followers',), ['don', 'jon'])

    def __hash__(self) -> int:
>       return hash(self._hash)
E       TypeError: unhashable type: 'list'

tinydb/queries.py:85: TypeError
___________________________________ test_all ___________________________________

    def test_all():
        query = Query().followers.all(Query().name == 'don')
        assert query({'followers': [{'name': 'don'}]})
        assert not query({'followers': [{'name': 'don'}, {'name': 'john'}]})
        assert hash(query)
    
        query = Query().followers.all(Query().num.matches('\\d+'))
        assert query({'followers': [{'num': '123'}, {'num': '456'}]})
        assert not query({'followers': [{'num': '123'}, {'num': 'abc'}]})
        assert hash(query)
    
        query = Query().followers.all(['don', 'john'])
>       assert query({'followers': ['don', 'john', 'greg']})
E       AssertionError: assert False
E        +  where False = QueryImpl('all', ('followers',), ['don', 'john'])({'followers': ['don', 'john', 'greg']})

tests/test_queries.py:262: AssertionError
________________________________ test_fragment _________________________________

    def test_fragment():
>       query = Query().fragment({'a': 4, 'b': True})

tests/test_queries.py:424: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
tinydb/queries.py:82: in __call__
    return self._test(value)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

_ = {'a': 4, 'b': True}

    def notest(_):
>       raise RuntimeError('Empty query was evaluated')
E       RuntimeError: Empty query was evaluated

tinydb/queries.py:158: RuntimeError
___________________________ test_fragment_with_path ____________________________

    def test_fragment_with_path():
>       query = Query().doc.fragment({'a': 4, 'b': True})

tests/test_queries.py:434: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
tinydb/queries.py:82: in __call__
    return self._test(value)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

_ = {'a': 4, 'b': True}

    def notest(_):
>       raise RuntimeError('Empty query was evaluated')
E       RuntimeError: Empty query was evaluated

tinydb/queries.py:158: RuntimeError
__________________________________ test_json ___________________________________

tmpdir = local('/tmp/pytest-of-openhands/pytest-0/test_json0')

    def test_json(tmpdir):
        # Write contents
        path = str(tmpdir.join('test.db'))
>       storage = JSONStorage(path)
E       TypeError: Can't instantiate abstract class JSONStorage with abstract methods read, write

tests/test_storages.py:23: TypeError
_______________________________ test_json_kwargs _______________________________

tmpdir = local('/tmp/pytest-of-openhands/pytest-0/test_json_kwargs0')

    def test_json_kwargs(tmpdir):
        db_file = tmpdir.join('test.db')
>       db = TinyDB(str(db_file), sort_keys=True, indent=4, separators=(',', ': '))

tests/test_storages.py:33: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <[TypeError("'NoneType' object is not iterable") raised in repr()] TinyDB object at 0x7f06a9319930>
args = ('/tmp/pytest-of-openhands/pytest-0/test_json_kwargs0/test.db',)
kwargs = {'indent': 4, 'separators': (',', ': '), 'sort_keys': True}
storage = <class 'tinydb.storages.JSONStorage'>

    def __init__(self, *args, **kwargs) -> None:
        """
        Create a new instance of TinyDB.
        """
        storage = kwargs.pop('storage', self.default_storage_class)
>       self._storage: Storage = storage(*args, **kwargs)
E       TypeError: Can't instantiate abstract class JSONStorage with abstract methods read, write

tinydb/database.py:74: TypeError
_____________________________ test_json_readwrite ______________________________

tmpdir = local('/tmp/pytest-of-openhands/pytest-0/test_json_readwrite0')

    def test_json_readwrite(tmpdir):
        """
        Regression test for issue #1
        """
        path = str(tmpdir.join('test.db'))
    
        # Create TinyDB instance
>       db = TinyDB(path, storage=JSONStorage)

tests/test_storages.py:59: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <[TypeError("'NoneType' object is not iterable") raised in repr()] TinyDB object at 0x7f06a8e68040>
args = ('/tmp/pytest-of-openhands/pytest-0/test_json_readwrite0/test.db',)
kwargs = {}, storage = <class 'tinydb.storages.JSONStorage'>

    def __init__(self, *args, **kwargs) -> None:
        """
        Create a new instance of TinyDB.
        """
        storage = kwargs.pop('storage', self.default_storage_class)
>       self._storage: Storage = storage(*args, **kwargs)
E       TypeError: Can't instantiate abstract class JSONStorage with abstract methods read, write

tinydb/database.py:74: TypeError
________________________________ test_json_read ________________________________

tmpdir = local('/tmp/pytest-of-openhands/pytest-0/test_json_read0')

    def test_json_read(tmpdir):
        r"""Open a database only for reading"""
        path = str(tmpdir.join('test.db'))
        with pytest.raises(FileNotFoundError):
>           db = TinyDB(path, storage=JSONStorage, access_mode='r')

tests/test_storages.py:86: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <[TypeError("'NoneType' object is not iterable") raised in repr()] TinyDB object at 0x7f06a9319480>
args = ('/tmp/pytest-of-openhands/pytest-0/test_json_read0/test.db',)
kwargs = {'access_mode': 'r'}, storage = <class 'tinydb.storages.JSONStorage'>

    def __init__(self, *args, **kwargs) -> None:
        """
        Create a new instance of TinyDB.
        """
        storage = kwargs.pop('storage', self.default_storage_class)
>       self._storage: Storage = storage(*args, **kwargs)
E       TypeError: Can't instantiate abstract class JSONStorage with abstract methods read, write

tinydb/database.py:74: TypeError
_______________________________ test_create_dirs _______________________________

    def test_create_dirs():
        temp_dir = tempfile.gettempdir()
    
        while True:
            dname = os.path.join(temp_dir, str(random.getrandbits(20)))
            if not os.path.exists(dname):
                db_dir = dname
                db_file = os.path.join(db_dir, 'db.json')
                break
    
        with pytest.raises(IOError):
>           JSONStorage(db_file)
E           TypeError: Can't instantiate abstract class JSONStorage with abstract methods read, write

tests/test_storages.py:111: TypeError
_________________________ test_json_invalid_directory __________________________

    def test_json_invalid_directory():
        with pytest.raises(IOError):
>           with TinyDB('/this/is/an/invalid/path/db.json', storage=JSONStorage):

tests/test_storages.py:126: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <[TypeError("'NoneType' object is not iterable") raised in repr()] TinyDB object at 0x7f06a931a650>
args = ('/this/is/an/invalid/path/db.json',), kwargs = {}
storage = <class 'tinydb.storages.JSONStorage'>

    def __init__(self, *args, **kwargs) -> None:
        """
        Create a new instance of TinyDB.
        """
        storage = kwargs.pop('storage', self.default_storage_class)
>       self._storage: Storage = storage(*args, **kwargs)
E       TypeError: Can't instantiate abstract class JSONStorage with abstract methods read, write

tinydb/database.py:74: TypeError
________________________________ test_in_memory ________________________________

    def test_in_memory():
        # Write contents
>       storage = MemoryStorage()
E       TypeError: Can't instantiate abstract class MemoryStorage with abstract methods read, write

tests/test_storages.py:132: TypeError
_____________________________ test_in_memory_close _____________________________

    def test_in_memory_close():
>       with TinyDB(storage=MemoryStorage) as db:

tests/test_storages.py:145: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <[TypeError("'NoneType' object is not iterable") raised in repr()] TinyDB object at 0x7f06a931b850>
args = (), kwargs = {}, storage = <class 'tinydb.storages.MemoryStorage'>

    def __init__(self, *args, **kwargs) -> None:
        """
        Create a new instance of TinyDB.
        """
        storage = kwargs.pop('storage', self.default_storage_class)
>       self._storage: Storage = storage(*args, **kwargs)
E       TypeError: Can't instantiate abstract class MemoryStorage with abstract methods read, write

tinydb/database.py:74: TypeError
________________________________ test_read_once ________________________________

    def test_read_once():
        count = 0
    
        # noinspection PyAbstractClass
        class MyStorage(Storage):
            def __init__(self):
                self.memory = None
    
            def read(self):
                nonlocal count
                count += 1
    
                return self.memory
    
            def write(self, data):
                self.memory = data
    
        with TinyDB(storage=MyStorage) as db:
            assert count == 0
    
            db.table(db.default_table_name)
    
            assert count == 0
    
            db.all()
    
>           assert count == 1
E           assert 0 == 1

tests/test_storages.py:184: AssertionError
__________________________________ test_yaml ___________________________________

tmpdir = local('/tmp/pytest-of-openhands/pytest-0/test_yaml0')

    def test_yaml(tmpdir):
        """
        :type tmpdir: py._path.local.LocalPath
        """
    
        try:
            import yaml
        except ImportError:
            return pytest.skip('PyYAML not installed')
    
        def represent_doc(dumper, data):
            # Represent `Document` objects as their dict's string representation
            # which PyYAML understands
            return dumper.represent_data(dict(data))
    
        yaml.add_representer(Document, represent_doc)
    
        class YAMLStorage(Storage):
            def __init__(self, filename):
                self.filename = filename
                touch(filename, False)
    
            def read(self):
                with open(self.filename) as handle:
                    data = yaml.safe_load(handle.read())
                    return data
    
            def write(self, data):
                with open(self.filename, 'w') as handle:
                    yaml.dump(data, handle)
    
            def close(self):
                pass
    
        # Write contents
        path = str(tmpdir.join('test.db'))
        db = TinyDB(path, storage=YAMLStorage)
        db.insert(doc)
>       assert db.all() == [doc]
E       assert None == [{'bool': [True, False, True, False], 'dict': {'hp': 13, 'sp': 5}, 'float': 3.14159, 'int': 42, ...}]
E        +  where None = all()
E        +    where all = <[TypeError("'NoneType' object is not iterable") raised in repr()] TinyDB object at 0x7f06a93081f0>.all

tests/test_storages.py:252: AssertionError
________________________________ test_encoding _________________________________

tmpdir = local('/tmp/pytest-of-openhands/pytest-0/test_encoding0')

    def test_encoding(tmpdir):
        japanese_doc = {"Test": u"こんにちは世界"}
    
        path = str(tmpdir.join('test.db'))
        # cp936 is used for japanese encodings
>       jap_storage = JSONStorage(path, encoding="cp936")
E       TypeError: Can't instantiate abstract class JSONStorage with abstract methods read, write

tests/test_storages.py:267: TypeError
______________________ test_custom_mapping_type_with_json ______________________

tmpdir = local('/tmp/pytest-of-openhands/pytest-0/test_custom_mapping_type_with_0')

    def test_custom_mapping_type_with_json(tmpdir):
        class CustomDocument(Mapping):
            def __init__(self, data):
                self.data = data
    
            def __getitem__(self, key):
                return self.data[key]
    
            def __iter__(self):
                return iter(self.data)
    
            def __len__(self):
                return len(self.data)
    
        # Insert
>       db = TinyDB(str(tmpdir.join('test.db')))

tests/test_tinydb.py:165: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <[TypeError("'NoneType' object is not iterable") raised in repr()] TinyDB object at 0x7f06a920d240>
args = ('/tmp/pytest-of-openhands/pytest-0/test_custom_mapping_type_with_0/test.db',)
kwargs = {}, storage = <class 'tinydb.storages.JSONStorage'>

    def __init__(self, *args, **kwargs) -> None:
        """
        Create a new instance of TinyDB.
        """
        storage = kwargs.pop('storage', self.default_storage_class)
>       self._storage: Storage = storage(*args, **kwargs)
E       TypeError: Can't instantiate abstract class JSONStorage with abstract methods read, write

tinydb/database.py:74: TypeError
______________________________ test_multiple_dbs _______________________________

    def test_multiple_dbs():
        """
        Regression test for issue #3
        """
>       db1 = TinyDB(storage=MemoryStorage)

tests/test_tinydb.py:415: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <[TypeError("'NoneType' object is not iterable") raised in repr()] TinyDB object at 0x7f06a934ab60>
args = (), kwargs = {}, storage = <class 'tinydb.storages.MemoryStorage'>

    def __init__(self, *args, **kwargs) -> None:
        """
        Create a new instance of TinyDB.
        """
        storage = kwargs.pop('storage', self.default_storage_class)
>       self._storage: Storage = storage(*args, **kwargs)
E       TypeError: Can't instantiate abstract class MemoryStorage with abstract methods read, write

tinydb/database.py:74: TypeError
_______________________________ test_unique_ids ________________________________

tmpdir = local('/tmp/pytest-of-openhands/pytest-0/test_unique_ids0')

    def test_unique_ids(tmpdir):
        """
        :type tmpdir: py._path.local.LocalPath
        """
        path = str(tmpdir.join('db.json'))
    
        # Verify ids are unique when reopening the DB and inserting
>       with TinyDB(path) as _db:

tests/test_tinydb.py:458: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <[TypeError("'NoneType' object is not iterable") raised in repr()] TinyDB object at 0x7f06a9315630>
args = ('/tmp/pytest-of-openhands/pytest-0/test_unique_ids0/db.json',)
kwargs = {}, storage = <class 'tinydb.storages.JSONStorage'>

    def __init__(self, *args, **kwargs) -> None:
        """
        Create a new instance of TinyDB.
        """
        storage = kwargs.pop('storage', self.default_storage_class)
>       self._storage: Storage = storage(*args, **kwargs)
E       TypeError: Can't instantiate abstract class JSONStorage with abstract methods read, write

tinydb/database.py:74: TypeError
____________________________ test_lastid_after_open ____________________________

tmpdir = local('/tmp/pytest-of-openhands/pytest-0/test_lastid_after_open0')

    def test_lastid_after_open(tmpdir):
        """
        Regression test for issue #34
    
        :type tmpdir: py._path.local.LocalPath
        """
    
        NUM = 100
        path = str(tmpdir.join('db.json'))
    
>       with TinyDB(path) as _db:

tests/test_tinydb.py:491: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <[TypeError("'NoneType' object is not iterable") raised in repr()] TinyDB object at 0x7f06a9254850>
args = ('/tmp/pytest-of-openhands/pytest-0/test_lastid_after_open0/db.json',)
kwargs = {}, storage = <class 'tinydb.storages.JSONStorage'>

    def __init__(self, *args, **kwargs) -> None:
        """
        Create a new instance of TinyDB.
        """
        storage = kwargs.pop('storage', self.default_storage_class)
>       self._storage: Storage = storage(*args, **kwargs)
E       TypeError: Can't instantiate abstract class JSONStorage with abstract methods read, write

tinydb/database.py:74: TypeError
______________________________ test_doc_ids_json _______________________________

tmpdir = local('/tmp/pytest-of-openhands/pytest-0/test_doc_ids_json0')

    def test_doc_ids_json(tmpdir):
        """
        Regression test for issue #45
        """
    
        path = str(tmpdir.join('db.json'))
    
>       with TinyDB(path) as _db:

tests/test_tinydb.py:505: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <[TypeError("'NoneType' object is not iterable") raised in repr()] TinyDB object at 0x7f06a92178e0>
args = ('/tmp/pytest-of-openhands/pytest-0/test_doc_ids_json0/db.json',)
kwargs = {}, storage = <class 'tinydb.storages.JSONStorage'>

    def __init__(self, *args, **kwargs) -> None:
        """
        Create a new instance of TinyDB.
        """
        storage = kwargs.pop('storage', self.default_storage_class)
>       self._storage: Storage = storage(*args, **kwargs)
E       TypeError: Can't instantiate abstract class JSONStorage with abstract methods read, write

tinydb/database.py:74: TypeError
______________________________ test_insert_string ______________________________

tmpdir = local('/tmp/pytest-of-openhands/pytest-0/test_insert_string0')

    def test_insert_string(tmpdir):
        path = str(tmpdir.join('db.json'))
    
>       with TinyDB(path) as _db:

tests/test_tinydb.py:533: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <[TypeError("'NoneType' object is not iterable") raised in repr()] TinyDB object at 0x7f06a8f24af0>
args = ('/tmp/pytest-of-openhands/pytest-0/test_insert_string0/db.json',)
kwargs = {}, storage = <class 'tinydb.storages.JSONStorage'>

    def __init__(self, *args, **kwargs) -> None:
        """
        Create a new instance of TinyDB.
        """
        storage = kwargs.pop('storage', self.default_storage_class)
>       self._storage: Storage = storage(*args, **kwargs)
E       TypeError: Can't instantiate abstract class JSONStorage with abstract methods read, write

tinydb/database.py:74: TypeError
___________________________ test_insert_invalid_dict ___________________________

tmpdir = local('/tmp/pytest-of-openhands/pytest-0/test_insert_invalid_dict0')

    def test_insert_invalid_dict(tmpdir):
        path = str(tmpdir.join('db.json'))
    
>       with TinyDB(path) as _db:

tests/test_tinydb.py:551: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <[TypeError("'NoneType' object is not iterable") raised in repr()] TinyDB object at 0x7f06a901cb50>
args = ('/tmp/pytest-of-openhands/pytest-0/test_insert_invalid_dict0/db.json',)
kwargs = {}, storage = <class 'tinydb.storages.JSONStorage'>

    def __init__(self, *args, **kwargs) -> None:
        """
        Create a new instance of TinyDB.
        """
        storage = kwargs.pop('storage', self.default_storage_class)
>       self._storage: Storage = storage(*args, **kwargs)
E       TypeError: Can't instantiate abstract class JSONStorage with abstract methods read, write

tinydb/database.py:74: TypeError
___________________________________ test_gc ____________________________________

tmpdir = local('/tmp/pytest-of-openhands/pytest-0/test_gc0')

    def test_gc(tmpdir):
        # See https://github.com/msiemens/tinydb/issues/92
        path = str(tmpdir.join('db.json'))
>       db = TinyDB(path)

tests/test_tinydb.py:566: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <[TypeError("'NoneType' object is not iterable") raised in repr()] TinyDB object at 0x7f06a8f27b80>
args = ('/tmp/pytest-of-openhands/pytest-0/test_gc0/db.json',), kwargs = {}
storage = <class 'tinydb.storages.JSONStorage'>

    def __init__(self, *args, **kwargs) -> None:
        """
        Create a new instance of TinyDB.
        """
        storage = kwargs.pop('storage', self.default_storage_class)
>       self._storage: Storage = storage(*args, **kwargs)
E       TypeError: Can't instantiate abstract class JSONStorage with abstract methods read, write

tinydb/database.py:74: TypeError
_______________________________ test_drop_table ________________________________

    def test_drop_table():
>       db = TinyDB(storage=MemoryStorage)

tests/test_tinydb.py:576: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <[TypeError("'NoneType' object is not iterable") raised in repr()] TinyDB object at 0x7f06a8ed63e0>
args = (), kwargs = {}, storage = <class 'tinydb.storages.MemoryStorage'>

    def __init__(self, *args, **kwargs) -> None:
        """
        Create a new instance of TinyDB.
        """
        storage = kwargs.pop('storage', self.default_storage_class)
>       self._storage: Storage = storage(*args, **kwargs)
E       TypeError: Can't instantiate abstract class MemoryStorage with abstract methods read, write

tinydb/database.py:74: TypeError
_______________________________ test_empty_write _______________________________

tmpdir = local('/tmp/pytest-of-openhands/pytest-0/test_empty_write0')

    def test_empty_write(tmpdir):
        path = str(tmpdir.join('db.json'))
    
        class ReadOnlyMiddleware(Middleware):
            def write(self, data):
                raise AssertionError('No write for unchanged db')
    
>       TinyDB(path).close()

tests/test_tinydb.py:608: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <[TypeError("'NoneType' object is not iterable") raised in repr()] TinyDB object at 0x7f06a8f25fc0>
args = ('/tmp/pytest-of-openhands/pytest-0/test_empty_write0/db.json',)
kwargs = {}, storage = <class 'tinydb.storages.JSONStorage'>

    def __init__(self, *args, **kwargs) -> None:
        """
        Create a new instance of TinyDB.
        """
        storage = kwargs.pop('storage', self.default_storage_class)
>       self._storage: Storage = storage(*args, **kwargs)
E       TypeError: Can't instantiate abstract class JSONStorage with abstract methods read, write

tinydb/database.py:74: TypeError
_______________________________ test_query_cache _______________________________

    def test_query_cache():
>       db = TinyDB(storage=MemoryStorage)

tests/test_tinydb.py:613: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <[TypeError("'NoneType' object is not iterable") raised in repr()] TinyDB object at 0x7f06a8ed57e0>
args = (), kwargs = {}, storage = <class 'tinydb.storages.MemoryStorage'>

    def __init__(self, *args, **kwargs) -> None:
        """
        Create a new instance of TinyDB.
        """
        storage = kwargs.pop('storage', self.default_storage_class)
>       self._storage: Storage = storage(*args, **kwargs)
E       TypeError: Can't instantiate abstract class MemoryStorage with abstract methods read, write

tinydb/database.py:74: TypeError
__________________________________ test_repr ___________________________________

tmpdir = local('/tmp/pytest-of-openhands/pytest-0/test_repr0')

    def test_repr(tmpdir):
        path = str(tmpdir.join('db.json'))
    
>       db = TinyDB(path)

tests/test_tinydb.py:640: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <[TypeError("'NoneType' object is not iterable") raised in repr()] TinyDB object at 0x7f06a8e39c00>
args = ('/tmp/pytest-of-openhands/pytest-0/test_repr0/db.json',), kwargs = {}
storage = <class 'tinydb.storages.JSONStorage'>

    def __init__(self, *args, **kwargs) -> None:
        """
        Create a new instance of TinyDB.
        """
        storage = kwargs.pop('storage', self.default_storage_class)
>       self._storage: Storage = storage(*args, **kwargs)
E       TypeError: Can't instantiate abstract class JSONStorage with abstract methods read, write

tinydb/database.py:74: TypeError
_________________________________ test_delete __________________________________

tmpdir = local('/tmp/pytest-of-openhands/pytest-0/test_delete0')

    def test_delete(tmpdir):
        path = str(tmpdir.join('db.json'))
    
>       db = TinyDB(path, ensure_ascii=False)

tests/test_tinydb.py:655: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <[TypeError("'NoneType' object is not iterable") raised in repr()] TinyDB object at 0x7f06a8ed47c0>
args = ('/tmp/pytest-of-openhands/pytest-0/test_delete0/db.json',)
kwargs = {'ensure_ascii': False}
storage = <class 'tinydb.storages.JSONStorage'>

    def __init__(self, *args, **kwargs) -> None:
        """
        Create a new instance of TinyDB.
        """
        storage = kwargs.pop('storage', self.default_storage_class)
>       self._storage: Storage = storage(*args, **kwargs)
E       TypeError: Can't instantiate abstract class JSONStorage with abstract methods read, write

tinydb/database.py:74: TypeError
_____________________________ test_access_storage ______________________________

    def test_access_storage():
>       assert isinstance(TinyDB(storage=MemoryStorage).storage,
                          MemoryStorage)

tests/test_tinydb.py:675: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <[TypeError("'NoneType' object is not iterable") raised in repr()] TinyDB object at 0x7f06a8ec7580>
args = (), kwargs = {}, storage = <class 'tinydb.storages.MemoryStorage'>

    def __init__(self, *args, **kwargs) -> None:
        """
        Create a new instance of TinyDB.
        """
        storage = kwargs.pop('storage', self.default_storage_class)
>       self._storage: Storage = storage(*args, **kwargs)
E       TypeError: Can't instantiate abstract class MemoryStorage with abstract methods read, write

tinydb/database.py:74: TypeError
______________________________ test_empty_db_len _______________________________

    def test_empty_db_len():
>       db = TinyDB(storage=MemoryStorage)

tests/test_tinydb.py:682: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <[TypeError("'NoneType' object is not iterable") raised in repr()] TinyDB object at 0x7f06a8ed7ac0>
args = (), kwargs = {}, storage = <class 'tinydb.storages.MemoryStorage'>

    def __init__(self, *args, **kwargs) -> None:
        """
        Create a new instance of TinyDB.
        """
        storage = kwargs.pop('storage', self.default_storage_class)
>       self._storage: Storage = storage(*args, **kwargs)
E       TypeError: Can't instantiate abstract class MemoryStorage with abstract methods read, write

tinydb/database.py:74: TypeError
__________________________ test_insert_on_existing_db __________________________

tmpdir = local('/tmp/pytest-of-openhands/pytest-0/test_insert_on_existing_db0')

    def test_insert_on_existing_db(tmpdir):
        path = str(tmpdir.join('db.json'))
    
>       db = TinyDB(path, ensure_ascii=False)

tests/test_tinydb.py:689: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <[TypeError("'NoneType' object is not iterable") raised in repr()] TinyDB object at 0x7f06a8ec7f70>
args = ('/tmp/pytest-of-openhands/pytest-0/test_insert_on_existing_db0/db.json',)
kwargs = {'ensure_ascii': False}
storage = <class 'tinydb.storages.JSONStorage'>

    def __init__(self, *args, **kwargs) -> None:
        """
        Create a new instance of TinyDB.
        """
        storage = kwargs.pop('storage', self.default_storage_class)
>       self._storage: Storage = storage(*args, **kwargs)
E       TypeError: Can't instantiate abstract class JSONStorage with abstract methods read, write

tinydb/database.py:74: TypeError
_____________________________ test_storage_access ______________________________

    def test_storage_access():
>       db = TinyDB(storage=MemoryStorage)

tests/test_tinydb.py:704: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <[TypeError("'NoneType' object is not iterable") raised in repr()] TinyDB object at 0x7f06a8ed5bd0>
args = (), kwargs = {}, storage = <class 'tinydb.storages.MemoryStorage'>

    def __init__(self, *args, **kwargs) -> None:
        """
        Create a new instance of TinyDB.
        """
        storage = kwargs.pop('storage', self.default_storage_class)
>       self._storage: Storage = storage(*args, **kwargs)
E       TypeError: Can't instantiate abstract class MemoryStorage with abstract methods read, write

tinydb/database.py:74: TypeError
______________________________ test_lambda_query _______________________________

    def test_lambda_query():
>       db = TinyDB(storage=MemoryStorage)

tests/test_tinydb.py:710: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <[TypeError("'NoneType' object is not iterable") raised in repr()] TinyDB object at 0x7f06a8ec6380>
args = (), kwargs = {}, storage = <class 'tinydb.storages.MemoryStorage'>

    def __init__(self, *args, **kwargs) -> None:
        """
        Create a new instance of TinyDB.
        """
        storage = kwargs.pop('storage', self.default_storage_class)
>       self._storage: Storage = storage(*args, **kwargs)
E       TypeError: Can't instantiate abstract class MemoryStorage with abstract methods read, write

tinydb/database.py:74: TypeError
_________________________________ test_freeze __________________________________

    def test_freeze():
        frozen = freeze([0, 1, 2, {'a': [1, 2, 3]}, {1, 2}])
        assert isinstance(frozen, tuple)
        assert isinstance(frozen[3], FrozenDict)
        assert isinstance(frozen[3]['a'], tuple)
        assert isinstance(frozen[4], frozenset)
    
        with pytest.raises(TypeError):
            frozen[0] = 10
    
        with pytest.raises(TypeError):
            frozen[3]['a'] = 10
    
>       with pytest.raises(TypeError):
E       Failed: DID NOT RAISE <class 'TypeError'>

tests/test_utils.py:104: Failed
--------------------------------- JSON report ----------------------------------
report saved to: report.json
================================ tests coverage ================================
_______________ coverage: platform linux, python 3.10.12-final-0 _______________

Name                    Stmts   Miss Branch BrPart  Cover
---------------------------------------------------------
tinydb/__init__.py          5      0      0      0   100%
tinydb/database.py         39      6      2      1    83%
tinydb/middlewares.py      19      3      0      0    84%
tinydb/mypy_plugin.py      11     11      0      0     0%
tinydb/operations.py       12      6      0      0    50%
tinydb/queries.py         138      6     36      4    94%
tinydb/storages.py         31     12      2      0    58%
tinydb/table.py            62     25      2      0    58%
tinydb/utils.py            65      5     16      0    91%
tinydb/version.py           1      0      0      0   100%
---------------------------------------------------------
TOTAL                     383     74     58      5    81%
=========================== short test summary info ============================
FAILED tests/test_middlewares.py::test_caching_read - TypeError: Can't instan...
FAILED tests/test_middlewares.py::test_nested - TypeError: Can't instantiate ...
FAILED tests/test_middlewares.py::test_caching_json_write - TypeError: Can't ...
FAILED tests/test_queries.py::test_any - TypeError: unhashable type: 'list'
FAILED tests/test_queries.py::test_all - AssertionError: assert False
FAILED tests/test_queries.py::test_fragment - RuntimeError: Empty query was e...
FAILED tests/test_queries.py::test_fragment_with_path - RuntimeError: Empty q...
FAILED tests/test_storages.py::test_json - TypeError: Can't instantiate abstr...
FAILED tests/test_storages.py::test_json_kwargs - TypeError: Can't instantiat...
FAILED tests/test_storages.py::test_json_readwrite - TypeError: Can't instant...
FAILED tests/test_storages.py::test_json_read - TypeError: Can't instantiate ...
FAILED tests/test_storages.py::test_create_dirs - TypeError: Can't instantiat...
FAILED tests/test_storages.py::test_json_invalid_directory - TypeError: Can't...
FAILED tests/test_storages.py::test_in_memory - TypeError: Can't instantiate ...
FAILED tests/test_storages.py::test_in_memory_close - TypeError: Can't instan...
FAILED tests/test_storages.py::test_read_once - assert 0 == 1
FAILED tests/test_storages.py::test_yaml - assert None == [{'bool': [True, Fa...
FAILED tests/test_storages.py::test_encoding - TypeError: Can't instantiate a...
FAILED tests/test_tinydb.py::test_custom_mapping_type_with_json - TypeError: ...
FAILED tests/test_tinydb.py::test_multiple_dbs - TypeError: Can't instantiate...
FAILED tests/test_tinydb.py::test_unique_ids - TypeError: Can't instantiate a...
FAILED tests/test_tinydb.py::test_lastid_after_open - TypeError: Can't instan...
FAILED tests/test_tinydb.py::test_doc_ids_json - TypeError: Can't instantiate...
FAILED tests/test_tinydb.py::test_insert_string - TypeError: Can't instantiat...
FAILED tests/test_tinydb.py::test_insert_invalid_dict - TypeError: Can't inst...
FAILED tests/test_tinydb.py::test_gc - TypeError: Can't instantiate abstract ...
FAILED tests/test_tinydb.py::test_drop_table - TypeError: Can't instantiate a...
FAILED tests/test_tinydb.py::test_empty_write - TypeError: Can't instantiate ...
FAILED tests/test_tinydb.py::test_query_cache - TypeError: Can't instantiate ...
FAILED tests/test_tinydb.py::test_repr - TypeError: Can't instantiate abstrac...
FAILED tests/test_tinydb.py::test_delete - TypeError: Can't instantiate abstr...
FAILED tests/test_tinydb.py::test_access_storage - TypeError: Can't instantia...
FAILED tests/test_tinydb.py::test_empty_db_len - TypeError: Can't instantiate...
FAILED tests/test_tinydb.py::test_insert_on_existing_db - TypeError: Can't in...
FAILED tests/test_tinydb.py::test_storage_access - TypeError: Can't instantia...
FAILED tests/test_tinydb.py::test_lambda_query - TypeError: Can't instantiate...
FAILED tests/test_utils.py::test_freeze - Failed: DID NOT RAISE <class 'TypeE...
ERROR tests/test_middlewares.py::test_caching - TypeError: Can't instantiate ...
ERROR tests/test_middlewares.py::test_caching_write_many - TypeError: Can't i...
ERROR tests/test_middlewares.py::test_caching_flush - TypeError: Can't instan...
ERROR tests/test_middlewares.py::test_caching_flush_manually - TypeError: Can...
ERROR tests/test_middlewares.py::test_caching_write - TypeError: Can't instan...
ERROR tests/test_operations.py::test_delete[memory] - TypeError: Can't instan...
ERROR tests/test_operations.py::test_delete[json] - TypeError: Can't instanti...
ERROR tests/test_operations.py::test_add_int[memory] - TypeError: Can't insta...
ERROR tests/test_operations.py::test_add_int[json] - TypeError: Can't instant...
ERROR tests/test_operations.py::test_add_str[memory] - TypeError: Can't insta...
ERROR tests/test_operations.py::test_add_str[json] - TypeError: Can't instant...
ERROR tests/test_operations.py::test_subtract[memory] - TypeError: Can't inst...
ERROR tests/test_operations.py::test_subtract[json] - TypeError: Can't instan...
ERROR tests/test_operations.py::test_set[memory] - TypeError: Can't instantia...
ERROR tests/test_operations.py::test_set[json] - TypeError: Can't instantiate...
ERROR tests/test_operations.py::test_increment[memory] - TypeError: Can't ins...
ERROR tests/test_operations.py::test_increment[json] - TypeError: Can't insta...
ERROR tests/test_operations.py::test_decrement[memory] - TypeError: Can't ins...
ERROR tests/test_operations.py::test_decrement[json] - TypeError: Can't insta...
ERROR tests/test_tables.py::test_next_id[memory] - TypeError: Can't instantia...
ERROR tests/test_tables.py::test_next_id[json] - TypeError: Can't instantiate...
ERROR tests/test_tables.py::test_tables_list[memory] - TypeError: Can't insta...
ERROR tests/test_tables.py::test_tables_list[json] - TypeError: Can't instant...
ERROR tests/test_tables.py::test_one_table[memory] - TypeError: Can't instant...
ERROR tests/test_tables.py::test_one_table[json] - TypeError: Can't instantia...
ERROR tests/test_tables.py::test_multiple_tables[memory] - TypeError: Can't i...
ERROR tests/test_tables.py::test_multiple_tables[json] - TypeError: Can't ins...
ERROR tests/test_tables.py::test_caching[memory] - TypeError: Can't instantia...
ERROR tests/test_tables.py::test_caching[json] - TypeError: Can't instantiate...
ERROR tests/test_tables.py::test_query_cache[memory] - TypeError: Can't insta...
ERROR tests/test_tables.py::test_query_cache[json] - TypeError: Can't instant...
ERROR tests/test_tables.py::test_query_cache_with_mutable_callable[memory] - ...
ERROR tests/test_tables.py::test_query_cache_with_mutable_callable[json] - Ty...
ERROR tests/test_tables.py::test_zero_cache_size[memory] - TypeError: Can't i...
ERROR tests/test_tables.py::test_zero_cache_size[json] - TypeError: Can't ins...
ERROR tests/test_tables.py::test_query_cache_size[memory] - TypeError: Can't ...
ERROR tests/test_tables.py::test_query_cache_size[json] - TypeError: Can't in...
ERROR tests/test_tables.py::test_lru_cache[memory] - TypeError: Can't instant...
ERROR tests/test_tables.py::test_lru_cache[json] - TypeError: Can't instantia...
ERROR tests/test_tables.py::test_table_is_iterable[memory] - TypeError: Can't...
ERROR tests/test_tables.py::test_table_is_iterable[json] - TypeError: Can't i...
ERROR tests/test_tables.py::test_table_name[memory] - TypeError: Can't instan...
ERROR tests/test_tables.py::test_table_name[json] - TypeError: Can't instanti...
ERROR tests/test_tables.py::test_table_repr[memory] - TypeError: Can't instan...
ERROR tests/test_tables.py::test_table_repr[json] - TypeError: Can't instanti...
ERROR tests/test_tables.py::test_truncate_table[memory] - TypeError: Can't in...
ERROR tests/test_tables.py::test_truncate_table[json] - TypeError: Can't inst...
ERROR tests/test_tinydb.py::test_drop_tables[memory] - TypeError: Can't insta...
ERROR tests/test_tinydb.py::test_drop_tables[json] - TypeError: Can't instant...
ERROR tests/test_tinydb.py::test_all[memory] - TypeError: Can't instantiate a...
ERROR tests/test_tinydb.py::test_all[json] - TypeError: Can't instantiate abs...
ERROR tests/test_tinydb.py::test_insert[memory] - TypeError: Can't instantiat...
ERROR tests/test_tinydb.py::test_insert[json] - TypeError: Can't instantiate ...
ERROR tests/test_tinydb.py::test_insert_ids[memory] - TypeError: Can't instan...
ERROR tests/test_tinydb.py::test_insert_ids[json] - TypeError: Can't instanti...
ERROR tests/test_tinydb.py::test_insert_with_doc_id[memory] - TypeError: Can'...
ERROR tests/test_tinydb.py::test_insert_with_doc_id[json] - TypeError: Can't ...
ERROR tests/test_tinydb.py::test_insert_with_duplicate_doc_id[memory] - TypeE...
ERROR tests/test_tinydb.py::test_insert_with_duplicate_doc_id[json] - TypeErr...
ERROR tests/test_tinydb.py::test_insert_multiple[memory] - TypeError: Can't i...
ERROR tests/test_tinydb.py::test_insert_multiple[json] - TypeError: Can't ins...
ERROR tests/test_tinydb.py::test_insert_multiple_with_ids[memory] - TypeError...
ERROR tests/test_tinydb.py::test_insert_multiple_with_ids[json] - TypeError: ...
ERROR tests/test_tinydb.py::test_insert_multiple_with_doc_ids[memory] - TypeE...
ERROR tests/test_tinydb.py::test_insert_multiple_with_doc_ids[json] - TypeErr...
ERROR tests/test_tinydb.py::test_insert_invalid_type_raises_error[memory] - T...
ERROR tests/test_tinydb.py::test_insert_invalid_type_raises_error[json] - Typ...
ERROR tests/test_tinydb.py::test_insert_valid_mapping_type[memory] - TypeErro...
ERROR tests/test_tinydb.py::test_insert_valid_mapping_type[json] - TypeError:...
ERROR tests/test_tinydb.py::test_remove[memory] - TypeError: Can't instantiat...
ERROR tests/test_tinydb.py::test_remove[json] - TypeError: Can't instantiate ...
ERROR tests/test_tinydb.py::test_remove_all_fails[memory] - TypeError: Can't ...
ERROR tests/test_tinydb.py::test_remove_all_fails[json] - TypeError: Can't in...
ERROR tests/test_tinydb.py::test_remove_multiple[memory] - TypeError: Can't i...
ERROR tests/test_tinydb.py::test_remove_multiple[json] - TypeError: Can't ins...
ERROR tests/test_tinydb.py::test_remove_ids[memory] - TypeError: Can't instan...
ERROR tests/test_tinydb.py::test_remove_ids[json] - TypeError: Can't instanti...
ERROR tests/test_tinydb.py::test_remove_returns_ids[memory] - TypeError: Can'...
ERROR tests/test_tinydb.py::test_remove_returns_ids[json] - TypeError: Can't ...
ERROR tests/test_tinydb.py::test_update[memory] - TypeError: Can't instantiat...
ERROR tests/test_tinydb.py::test_update[json] - TypeError: Can't instantiate ...
ERROR tests/test_tinydb.py::test_update_all[memory] - TypeError: Can't instan...
ERROR tests/test_tinydb.py::test_update_all[json] - TypeError: Can't instanti...
ERROR tests/test_tinydb.py::test_update_returns_ids[memory] - TypeError: Can'...
ERROR tests/test_tinydb.py::test_update_returns_ids[json] - TypeError: Can't ...
ERROR tests/test_tinydb.py::test_update_transform[memory] - TypeError: Can't ...
ERROR tests/test_tinydb.py::test_update_transform[json] - TypeError: Can't in...
ERROR tests/test_tinydb.py::test_update_ids[memory] - TypeError: Can't instan...
ERROR tests/test_tinydb.py::test_update_ids[json] - TypeError: Can't instanti...
ERROR tests/test_tinydb.py::test_update_multiple[memory] - TypeError: Can't i...
ERROR tests/test_tinydb.py::test_update_multiple[json] - TypeError: Can't ins...
ERROR tests/test_tinydb.py::test_update_multiple_operation[memory] - TypeErro...
ERROR tests/test_tinydb.py::test_update_multiple_operation[json] - TypeError:...
ERROR tests/test_tinydb.py::test_upsert[memory] - TypeError: Can't instantiat...
ERROR tests/test_tinydb.py::test_upsert[json] - TypeError: Can't instantiate ...
ERROR tests/test_tinydb.py::test_upsert_by_id[memory] - TypeError: Can't inst...
ERROR tests/test_tinydb.py::test_upsert_by_id[json] - TypeError: Can't instan...
ERROR tests/test_tinydb.py::test_search[memory] - TypeError: Can't instantiat...
ERROR tests/test_tinydb.py::test_search[json] - TypeError: Can't instantiate ...
ERROR tests/test_tinydb.py::test_search_path[memory] - TypeError: Can't insta...
ERROR tests/test_tinydb.py::test_search_path[json] - TypeError: Can't instant...
ERROR tests/test_tinydb.py::test_search_no_results_cache[memory] - TypeError:...
ERROR tests/test_tinydb.py::test_search_no_results_cache[json] - TypeError: C...
ERROR tests/test_tinydb.py::test_get[memory] - TypeError: Can't instantiate a...
ERROR tests/test_tinydb.py::test_get[json] - TypeError: Can't instantiate abs...
ERROR tests/test_tinydb.py::test_get_ids[memory] - TypeError: Can't instantia...
ERROR tests/test_tinydb.py::test_get_ids[json] - TypeError: Can't instantiate...
ERROR tests/test_tinydb.py::test_get_multiple_ids[memory] - TypeError: Can't ...
ERROR tests/test_tinydb.py::test_get_multiple_ids[json] - TypeError: Can't in...
ERROR tests/test_tinydb.py::test_get_invalid[memory] - TypeError: Can't insta...
ERROR tests/test_tinydb.py::test_get_invalid[json] - TypeError: Can't instant...
ERROR tests/test_tinydb.py::test_count[memory] - TypeError: Can't instantiate...
ERROR tests/test_tinydb.py::test_count[json] - TypeError: Can't instantiate a...
ERROR tests/test_tinydb.py::test_contains[memory] - TypeError: Can't instanti...
ERROR tests/test_tinydb.py::test_contains[json] - TypeError: Can't instantiat...
ERROR tests/test_tinydb.py::test_contains_ids[memory] - TypeError: Can't inst...
ERROR tests/test_tinydb.py::test_contains_ids[json] - TypeError: Can't instan...
ERROR tests/test_tinydb.py::test_contains_invalid[memory] - TypeError: Can't ...
ERROR tests/test_tinydb.py::test_contains_invalid[json] - TypeError: Can't in...
ERROR tests/test_tinydb.py::test_get_idempotent[memory] - TypeError: Can't in...
ERROR tests/test_tinydb.py::test_get_idempotent[json] - TypeError: Can't inst...
ERROR tests/test_tinydb.py::test_tinydb_is_iterable[memory] - TypeError: Can'...
ERROR tests/test_tinydb.py::test_tinydb_is_iterable[json] - TypeError: Can't ...
ERROR tests/test_tinydb.py::test_insert_multiple_with_single_dict[memory] - T...
ERROR tests/test_tinydb.py::test_insert_multiple_with_single_dict[json] - Typ...
================== 37 failed, 39 passed, 125 errors in 1.87s ===================