===== tinydb/database.py =====
"""
This module contains the main component of TinyDB: the database.
"""
from typing import Dict, Iterator, Set, Type
from . import JSONStorage
from .storages import Storage
from .table import Table, Document
from .utils import with_typehint
TableBase: Type[Table] = with_typehint(Table)

class TinyDB(TableBase):
    """
    The main class of TinyDB.

    The ``TinyDB`` class is responsible for creating the storage class instance
    that will store this database's documents, managing the database
    tables as well as providing access to the default table.

    For table management, a simple ``dict`` is used that stores the table class
    instances accessible using their table name.

    Default table access is provided by forwarding all unknown method calls
    and property access operations to the default table by implementing
    ``__getattr__``.

    When creating a new instance, all arguments and keyword arguments (except
    for ``storage``) will be passed to the storage class that is provided. If
    no storage class is specified, :class:`~tinydb.storages.JSONStorage` will be
    used.

    .. admonition:: Customization

        For customization, the following class variables can be set:

        - ``table_class`` defines the class that is used to create tables,
        - ``default_table_name`` defines the name of the default table, and
        - ``default_storage_class`` will define the class that will be used to
          create storage instances if no other storage is passed.

        .. versionadded:: 4.0

    .. admonition:: Data Storage Model

        Data is stored using a storage class that provides persistence for a
        ``dict`` instance. This ``dict`` contains all tables and their data.
        The data is modelled like this::

            {
                'table1': {
                    0: {document...},
                    1: {document...},
                },
                'table2': {
                    ...
                }
            }

        Each entry in this ``dict`` uses the table name as its key and a
        ``dict`` of documents as its value. The document ``dict`` contains
        document IDs as keys and the documents themselves as values.

    :param storage: The class of the storage to use. Will be initialized
                    with ``args`` and ``kwargs``.
    """
    table_class = Table
    default_table_name = '_default'
    default_storage_class = 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)
        self._opened = True
        self._tables: Dict[str, Table] = {}

    def __repr__(self):
        args = ['tables={}'.format(list(self.tables())), 'tables_count={}'.format(len(self.tables())), 'default_table_documents_count={}'.format(self.__len__()), 'all_tables_documents_count={}'.format(['{}={}'.format(table, len(self.table(table))) for table in self.tables()])]
        return '<{} {}>'.format(type(self).__name__, ', '.join(args))

    def table(self, name: str, **kwargs) -> Table:
        """
        Get access to a specific table.

        If the table hasn't been accessed yet, a new table instance will be
        created using the :attr:`~tinydb.database.TinyDB.table_class` class.
        Otherwise, the previously created table instance will be returned.

        All further options besides the name are passed to the table class which
        by default is :class:`~tinydb.table.Table`. Check its documentation
        for further parameters you can pass.

        :param name: The name of the table.
        :param kwargs: Keyword arguments to pass to the table class constructor
        """
        pass

    def tables(self) -> Set[str]:
        """
        Get the names of all tables in the database.

        :returns: a set of table names
        """
        pass

    def drop_tables(self) -> None:
        """
        Drop all tables from the database. **CANNOT BE REVERSED!**
        """
        pass

    def drop_table(self, name: str) -> None:
        """
        Drop a specific table from the database. **CANNOT BE REVERSED!**

        :param name: The name of the table to drop.
        """
        pass

    @property
    def storage(self) -> Storage:
        """
        Get the storage instance used for this TinyDB instance.

        :return: This instance's storage
        :rtype: Storage
        """
        pass

    def close(self) -> None:
        """
        Close the database.

        This may be needed if the storage instance used for this database
        needs to perform cleanup operations like closing file handles.

        To ensure this method is called, the TinyDB instance can be used as a
        context manager::

            with TinyDB('data.json') as db:
                db.insert({'foo': 'bar'})

        Upon leaving this context, the ``close`` method will be called.
        """
        pass

    def __enter__(self):
        """
        Use the database as a context manager.

        Using the database as a context manager ensures that the
        :meth:`~tinydb.database.TinyDB.close` method is called upon leaving
        the context.

        :return: The current instance
        """
        return self

    def __exit__(self, *args):
        """
        Close the storage instance when leaving a context.
        """
        if self._opened:
            self.close()

    def __getattr__(self, name):
        """
        Forward all unknown attribute calls to the default table instance.
        """
        return getattr(self.table(self.default_table_name), name)

    def __len__(self):
        """
        Get the total number of documents in the default table.

        >>> db = TinyDB('db.json')
        >>> len(db)
        0
        """
        return len(self.table(self.default_table_name))

    def __iter__(self) -> Iterator[Document]:
        """
        Return an iterator for the default table's documents.
        """
        return iter(self.table(self.default_table_name))===== tinydb/table.py =====
"""
This module implements tables, the central place for accessing and manipulating
data in TinyDB.
"""
from typing import Callable, Dict, Iterable, Iterator, List, Mapping, Optional, Union, cast, Tuple
from .queries import QueryLike
from .storages import Storage
from .utils import LRUCache
__all__ = ('Document', 'Table')

class Document(dict):
    """
    A document stored in the database.

    This class provides a way to access both a document's content and
    its ID using ``doc.doc_id``.
    """

    def __init__(self, value: Mapping, doc_id: int):
        super().__init__(value)
        self.doc_id = doc_id

class Table:
    """
    Represents a single TinyDB table.

    It provides methods for accessing and manipulating documents.

    .. admonition:: Query Cache

        As an optimization, a query cache is implemented using a
        :class:`~tinydb.utils.LRUCache`. This class mimics the interface of
        a normal ``dict``, but starts to remove the least-recently used entries
        once a threshold is reached.

        The query cache is updated on every search operation. When writing
        data, the whole cache is discarded as the query results may have
        changed.

    .. admonition:: Customization

        For customization, the following class variables can be set:

        - ``document_class`` defines the class that is used to represent
          documents,
        - ``document_id_class`` defines the class that is used to represent
          document IDs,
        - ``query_cache_class`` defines the class that is used for the query
          cache
        - ``default_query_cache_capacity`` defines the default capacity of
          the query cache

        .. versionadded:: 4.0


    :param storage: The storage instance to use for this table
    :param name: The table name
    :param cache_size: Maximum capacity of query cache
    """
    document_class = Document
    document_id_class = int
    query_cache_class = LRUCache
    default_query_cache_capacity = 10

    def __init__(self, storage: Storage, name: str, cache_size: int=default_query_cache_capacity):
        """
        Create a table instance.
        """
        self._storage = storage
        self._name = name
        self._query_cache: LRUCache[QueryLike, List[Document]] = self.query_cache_class(capacity=cache_size)
        self._next_id = None

    def __repr__(self):
        args = ['name={!r}'.format(self.name), 'total={}'.format(len(self)), 'storage={}'.format(self._storage)]
        return '<{} {}>'.format(type(self).__name__, ', '.join(args))

    @property
    def name(self) -> str:
        """
        Get the table name.
        """
        pass

    @property
    def storage(self) -> Storage:
        """
        Get the table storage instance.
        """
        pass

    def insert(self, document: Mapping) -> int:
        """
        Insert a new document into the table.

        :param document: the document to insert
        :returns: the inserted document's ID
        """
        pass

    def insert_multiple(self, documents: Iterable[Mapping]) -> List[int]:
        """
        Insert multiple documents into the table.

        :param documents: an Iterable of documents to insert
        :returns: a list containing the inserted documents' IDs
        """
        pass

    def all(self) -> List[Document]:
        """
        Get all documents stored in the table.

        :returns: a list with all documents.
        """
        pass

    def search(self, cond: QueryLike) -> List[Document]:
        """
        Search for all documents matching a 'where' cond.

        :param cond: the condition to check against
        :returns: list of matching documents
        """
        pass

    def get(self, cond: Optional[QueryLike]=None, doc_id: Optional[int]=None, doc_ids: Optional[List]=None) -> Optional[Union[Document, List[Document]]]:
        """
        Get exactly one document specified by a query or a document ID.
        However, if multiple document IDs are given then returns all
        documents in a list.

        Returns ``None`` if the document doesn't exist.

        :param cond: the condition to check against
        :param doc_id: the document's ID
        :param doc_ids: the document's IDs(multiple)

        :returns: the document(s) or ``None``
        """
        pass

    def contains(self, cond: Optional[QueryLike]=None, doc_id: Optional[int]=None) -> bool:
        """
        Check whether the database contains a document matching a query or
        an ID.

        If ``doc_id`` is set, it checks if the db contains the specified ID.

        :param cond: the condition use
        :param doc_id: the document ID to look for
        """
        pass

    def update(self, fields: Union[Mapping, Callable[[Mapping], None]], cond: Optional[QueryLike]=None, doc_ids: Optional[Iterable[int]]=None) -> List[int]:
        """
        Update all matching documents to have a given set of fields.

        :param fields: the fields that the matching documents will have
                       or a method that will update the documents
        :param cond: which documents to update
        :param doc_ids: a list of document IDs
        :returns: a list containing the updated document's ID
        """
        pass

    def update_multiple(self, updates: Iterable[Tuple[Union[Mapping, Callable[[Mapping], None]], QueryLike]]) -> List[int]:
        """
        Update all matching documents to have a given set of fields.

        :returns: a list containing the updated document's ID
        """
        pass

    def upsert(self, document: Mapping, cond: Optional[QueryLike]=None) -> List[int]:
        """
        Update documents, if they exist, insert them otherwise.

        Note: This will update *all* documents matching the query. Document
        argument can be a tinydb.table.Document object if you want to specify a
        doc_id.

        :param document: the document to insert or the fields to update
        :param cond: which document to look for, optional if you've passed a
        Document with a doc_id
        :returns: a list containing the updated documents' IDs
        """
        pass

    def remove(self, cond: Optional[QueryLike]=None, doc_ids: Optional[Iterable[int]]=None) -> List[int]:
        """
        Remove all matching documents.

        :param cond: the condition to check against
        :param doc_ids: a list of document IDs
        :returns: a list containing the removed documents' ID
        """
        pass

    def truncate(self) -> None:
        """
        Truncate the table by removing all documents.
        """
        pass

    def count(self, cond: QueryLike) -> int:
        """
        Count the documents matching a query.

        :param cond: the condition use
        """
        pass

    def clear_cache(self) -> None:
        """
        Clear the query cache.
        """
        pass

    def __len__(self):
        """
        Count the total number of documents in this table.
        """
        return len(self._read_table())

    def __iter__(self) -> Iterator[Document]:
        """
        Iterate over all documents stored in the table.

        :returns: an iterator over all documents.
        """
        for doc_id, doc in self._read_table().items():
            yield self.document_class(doc, self.document_id_class(doc_id))

    def _get_next_id(self):
        """
        Return the ID for a newly inserted document.
        """
        pass

    def _read_table(self) -> Dict[str, Mapping]:
        """
        Read the table data from the underlying storage.

        Documents and doc_ids are NOT yet transformed, as
        we may not want to convert *all* documents when returning
        only one document for example.
        """
        pass

    def _update_table(self, updater: Callable[[Dict[int, Mapping]], None]):
        """
        Perform a table update operation.

        The storage interface used by TinyDB only allows to read/write the
        complete database data, but not modifying only portions of it. Thus,
        to only update portions of the table data, we first perform a read
        operation, perform the update on the table data and then write
        the updated data back to the storage.

===== tinydb/queries.py =====
"""
Contains the querying interface.

Starting with :class:`~tinydb.queries.Query` you can construct complex
queries:

>>> ((where('f1') == 5) & (where('f2') != 2)) | where('s').matches(r'^\\w+$')
(('f1' == 5) and ('f2' != 2)) or ('s' ~= ^\\w+$ )

Queries are executed by using the ``__call__``:

>>> q = where('val') == 5
>>> q({'val': 5})
True
>>> q({'val': 1})
False
"""
import r<response clipped><NOTE>Due to the max output limit, only part of the full response has been shown to you.</NOTE>plementations.
"""
from typing import Optional
from tinydb import Storage

class Middleware:
    """
    The base class for all Middlewares.

    Middlewares hook into the read/write process of TinyDB allowing you to
    extend the behaviour by adding caching, logging, ...

    Your middleware's ``__init__`` method has to call the parent class
    constructor so the middleware chain can be configured properly.
    """

    def __init__(self, storage_cls) -> None:
        self._storage_cls = storage_cls
        self.storage: Storage = None

    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)
        return self

    def __getattr__(self, name):
        """
        Forward all unknown attribute calls to the underlying storage, so we
        remain as transparent as possible.
        """
        return getattr(self.__dict__['storage'], name)

class CachingMiddleware(Middleware):
    """
    Add some caching to TinyDB.

    This Middleware aims to improve the performance of TinyDB by writing only
    the last DB state every :attr:`WRITE_CACHE_SIZE` time and reading always
    from cache.
    """
    WRITE_CACHE_SIZE = 1000

    def __init__(self, storage_cls):
        super().__init__(storage_cls)
        self.cache = None
        self._cache_modified_count = 0

    def flush(self):
        """
        Flush all unwritten data to disk.
        """
        pass===== tinydb/operations.py =====
"""
A collection of update operations for TinyDB.

They are used for updates like this:

>>> db.update(delete('foo'), where('foo') == 2)

This would delete the ``foo`` field from all documents where ``foo`` equals 2.
"""

def delete(field):
    """
    Delete a given field from the document.
    """
    pass

def add(field, n):
    """
    Add ``n`` to a given field in the document.
    """
    pass

def subtract(field, n):
    """
    Subtract ``n`` to a given field in the document.
    """
    pass

def set(field, val):
    """
    Set a given field to ``val``.
    """
    pass

def increment(field):
    """
    Increment a given field in the document by 1.
    """
    pass

def decrement(field):
    """
    Decrement a given field in the document by 1.
    """
    pass===== tinydb/utils.py =====
"""
Utility functions.
"""
from collections import OrderedDict, abc
from typing import List, Iterator, TypeVar, Generic, Union, Optional, Type, TYPE_CHECKING
K = TypeVar('K')
V = TypeVar('V')
D = TypeVar('D')
T = TypeVar('T')
__all__ = ('LRUCache', 'freeze', 'with_typehint')

def with_typehint(baseclass: Type[T]):
    """
    Add type hints from a specified class to a base class:

    >>> class Foo(with_typehint(Bar)):
    ...     pass

    This would add type hints from class ``Bar`` to class ``Foo``.

    Note that while PyCharm and Pyright (for VS Code) understand this pattern,
    MyPy does not. For that reason TinyDB has a MyPy plugin in
    ``mypy_plugin.py`` that adds support for this pattern.
    """
    pass

class LRUCache(abc.MutableMapping, Generic[K, V]):
    """
    A least-recently used (LRU) cache with a fixed cache size.

    This class acts as a dictionary but has a limited size. If the number of
    entries in the cache exceeds the cache size, the least-recently accessed
    entry will be discarded.

    This is implemented using an ``OrderedDict``. On every access the accessed
    entry is moved to the front by re-inserting it into the ``OrderedDict``.
    When adding an entry and the cache size is exceeded, the last entry will
    be discarded.
    """

    def __init__(self, capacity=None) -> None:
        self.capacity = capacity
        self.cache: OrderedDict[K, V] = OrderedDict()

    def __len__(self) -> int:
        return self.length

    def __contains__(self, key: object) -> bool:
        return key in self.cache

    def __setitem__(self, key: K, value: V) -> None:
        self.set(key, value)

    def __delitem__(self, key: K) -> None:
        del self.cache[key]

    def __getitem__(self, key) -> V:
        value = self.get(key)
        if value is None:
            raise KeyError(key)
        return value

    def __iter__(self) -> Iterator[K]:
        return iter(self.cache)

class FrozenDict(dict):
    """
    An immutable dictionary.

    This is used to generate stable hashes for queries that contain dicts.
    Usually, Python dicts are not hashable because they are mutable. This
    class removes the mutability and implements the ``__hash__`` method.
    """

    def __hash__(self):
        return hash(tuple(sorted(self.items())))
    __setitem__ = _immutable
    __delitem__ = _immutable
    clear = _immutable
    setdefault = _immutable
    popitem = _immutable

def freeze(obj):
    """
    Freeze an object by making it immutable and thus hashable.
    """
    pass===== tinydb/__init__.py =====
"""
TinyDB is a tiny, document oriented database optimized for your happiness :)

TinyDB stores different types of Python data types using a configurable
storage mechanism. It comes with a syntax for querying data and storing
data in multiple tables.

.. codeauthor:: Markus Siemens <markus@m-siemens.de>

Usage example:

>>> from tinydb import TinyDB, where
>>> from tinydb.storages import MemoryStorage
>>> db = TinyDB(storage=MemoryStorage)
>>> db.insert({'data': 5})  # Insert into '_default' table
>>> db.search(where('data') == 5)
[{'data': 5, '_id': 1}]
>>> # Now let's create a new table
>>> tbl = db.table('our_table')
>>> for i in range(10):
...     tbl.insert({'data': i})
...
>>> len(tbl.search(where('data') < 5))
5
"""

from .queries import Query, where
from .storages import Storage, JSONStorage
from .database import TinyDB
from .version import __version__

__all__ = ('TinyDB', 'Storage', 'JSONStorage', 'Query', 'where')
===== tests names =====
tests/test_tinydb.py:12:def test_drop_tables(db: TinyDB):
tests/test_tinydb.py:21:def test_all(db: TinyDB):
tests/test_tinydb.py:30:def test_insert(db: TinyDB):
tests/test_tinydb.py:46:def test_insert_ids(db: TinyDB):
tests/test_tinydb.py:52:def test_insert_with_doc_id(db: TinyDB):
tests/test_tinydb.py:60:def test_insert_with_duplicate_doc_id(db: TinyDB):
tests/test_tinydb.py:68:def test_insert_multiple(db: TinyDB):
tests/test_tinydb.py:102:def test_insert_multiple_with_ids(db: TinyDB):
tests/test_tinydb.py:111:def test_insert_multiple_with_doc_ids(db: TinyDB):
tests/test_tinydb.py:125:def test_insert_invalid_type_raises_error(db: TinyDB):
tests/test_tinydb.py:131:def test_insert_valid_mapping_type(db: TinyDB):
tests/test_tinydb.py:150:def test_custom_mapping_type_with_json(tmpdir):
tests/test_tinydb.py:186:def test_remove(db: TinyDB):
tests/test_tinydb.py:193:def test_remove_all_fails(db: TinyDB):
tests/test_tinydb.py:198:def test_remove_multiple(db: TinyDB):
tests/test_tinydb.py:204:def test_remove_ids(db: TinyDB):
tests/test_tinydb.py:210:def test_remove_returns_ids(db: TinyDB):
tests/test_tinydb.py:214:def test_update(db: TinyDB):
tests/test_tinydb.py:223:def test_update_all(db: TinyDB):
tests/test_tinydb.py:231:def test_update_returns_ids(db: TinyDB):
tests/test_tinydb.py:239:def test_update_transform(db: TinyDB):
tests/test_tinydb.py:262:def test_update_ids(db: TinyDB):
tests/test_tinydb.py:268:def test_update_multiple(db: TinyDB):
tests/test_tinydb.py:281:def test_update_multiple_operation(db: TinyDB):
tests/test_tinydb.py:298:def test_upsert(db: TinyDB):
tests/test_tinydb.py:310:def test_upsert_by_id(db: TinyDB):
tests/test_tinydb.py:339:def test_search(db: TinyDB):
tests/test_tinydb.py:347:def test_search_path(db: TinyDB):
tests/test_tinydb.py:356:def test_search_no_results_cache(db: TinyDB):
tests/test_tinydb.py:361:def test_get(db: TinyDB):
tests/test_tinydb.py:368:def test_get_ids(db: TinyDB):
tests/test_tinydb.py:374:def test_get_multiple_ids(db: TinyDB):
tests/test_tinydb.py:379:def test_get_invalid(db: TinyDB):
tests/test_tinydb.py:384:def test_count(db: TinyDB):
tests/test_tinydb.py:389:def test_contains(db: TinyDB):
tests/test_tinydb.py:394:def test_contains_ids(db: TinyDB):
tests/test_tinydb.py:400:def test_contains_invalid(db: TinyDB):
tests/test_tinydb.py:405:def test_get_idempotent(db: TinyDB):
tests/test_tinydb.py:411:def test_multiple_dbs():
tests/test_tinydb.py:428:def test_storage_closed_once():
tests/test_tinydb.py:451:def test_unique_ids(tmpdir):
tests/test_tinydb.py:481:def test_lastid_after_open(tmpdir):
tests/test_tinydb.py:498:def test_doc_ids_json(tmpdir):
tests/test_tinydb.py:530:def test_insert_string(tmpdir):
tests/test_tinydb.py:548:def test_insert_invalid_dict(tmpdir):
tests/test_tinydb.py:563:def test_gc(tmpdir):
tests/test_tinydb.py:575:def test_drop_table():
tests/test_tinydb.py:601:def test_empty_write(tmpdir):
tests/test_tinydb.py:612:def test_query_cache():
tests/test_tinydb.py:633:def test_tinydb_is_iterable(db: TinyDB):
tests/test_tinydb.py:637:def test_repr(tmpdir):
tests/test_tinydb.py:652:def test_delete(tmpdir):
tests/test_tinydb.py:667:def test_insert_multiple_with_single_dict(db: TinyDB):
tests/test_tinydb.py:674:def test_access_storage():
tests/test_tinydb.py:681:def test_empty_db_len():
tests/test_tinydb.py:686:def test_insert_on_existing_db(tmpdir):
tests/test_tinydb.py:703:def test_storage_access():
tests/test_tinydb.py:709:def test_lambda_query():
tests/test_storages.py:20:def test_json(tmpdir):
tests/test_storages.py:31:def test_json_kwargs(tmpdir):
tests/test_storages.py:52:def test_json_readwrite(tmpdir):
tests/test_storages.py:82:def test_json_read(tmpdir):
tests/test_storages.py:100:def test_create_dirs():
tests/test_storages.py:124:def test_json_invalid_directory():
tests/test_storages.py:130:def test_in_memory():
tests/test_storages.py:144:def test_in_memory_close():
tests/test_storages.py:149:def test_custom():
tests/test_storages.py:158:def test_read_once():
tests/test_storages.py:195:def test_custom_with_exception():
tests/test_storages.py:214:def test_yaml(tmpdir):
tests/test_storages.py:262:def test_encoding(tmpdir):
tests/test_tables.py:8:def test_next_id(db):
tests/test_tables.py:16:def test_tables_list(db):
tests/test_tables.py:23:def test_one_table(db):
tests/test_tables.py:32:def test_multiple_tables(db):
tests/test_tables.py:52:def test_caching(db):
tests/test_tables.py:59:def test_query_cache(db):
tests/test_tables.py:77:def test_query_cache_with_mutable_callable(db):
tests/test_tables.py:98:def test_zero_cache_size(db):
tests/test_tables.py:110:def test_query_cache_size(db):
tests/test_tables.py:122:def test_lru_cache(db):
tests/test_tables.py:142:def test_table_is_iterable(db):
tests/test_tables.py:150:def test_table_name(db):
tests/test_tables.py:159:def test_table_repr(db):
tests/test_tables.py:169:def test_truncate_table(db):
tests/test_utils.py:6:def test_lru_cache():
tests/test_utils.py:22:def test_lru_cache_set_multiple():
tests/test_utils.py:32:def test_lru_cache_get():
tests/test_utils.py:43:def test_lru_cache_delete():
tests/test_utils.py:57:def test_lru_cache_clear():
tests/test_utils.py:66:def test_lru_cache_unlimited():
tests/test_utils.py:74:def test_lru_cache_unlimited_explicit():
tests/test_utils.py:82:def test_lru_cache_iteration_works():
tests/test_utils.py:91:def test_freeze():
tests/test_queries.py:8:def test_no_path():
tests/test_queries.py:13:def test_path_exists():
tests/test_queries.py:31:def test_path_and():
tests/test_queries.py:40:def test_callable_in_path_with_map():
tests/test_queries.py:47:def test_callable_in_path_with_chain():
tests/test_queries.py:53:def test_eq():
tests/test_queries.py:65:def test_ne():
tests/test_queries.py:78:def test_lt():
tests/test_queries.py:86:def test_le():
tests/test_queries.py:94:def test_gt():
tests/test_queries.py:101:def test_ge():
tests/test_queries.py:109:def test_or():
tests/test_queries.py:121:def test_and():
tests/test_queries.py:133:def test_not():
tests/test_queries.py:151:def test_has_key():
tests/test_queries.py:159:def test_regex():
tests/test_queries.py:188:def test_custom():
tests/test_queries.py:212:def test_custom_with_params():
tests/test_queries.py:225:def test_any():
tests/test_queries.py:250:def test_all():
tests/test_queries.py:276:def test_has():
tests/test_queries.py:344:def test_one_of():
tests/test_queries.py:351:def test_hash():
tests/test_queries.py:370:def test_orm_usage():
tests/test_queries.py:380:def test_repr():
tests/test_queries.py:387:def test_subclass():
tests/test_queries.py:404:def test_noop():
tests/test_queries.py:412:def test_equality():
tests/test_queries.py:418:def test_empty_query_error():
tests/test_queries.py:423:def test_fragment():
tests/test_queries.py:433:def test_fragment_with_path():
tests/test_queries.py:441:def test_get_item():
tests/test_operations.py:5:def test_delete(db):
tests/test_operations.py:10:def test_add_int(db):
tests/test_operations.py:15:def test_add_str(db):
tests/test_operations.py:20:def test_subtract(db):
tests/test_operations.py:25:def test_set(db):
tests/test_operations.py:30:def test_increment(db):
tests/test_operations.py:35:def test_decrement(db):
tests/test_middlewares.py:13:def test_caching(storage):
tests/test_middlewares.py:21:def test_caching_read():
tests/test_middlewares.py:26:def test_caching_write_many(storage):
tests/test_middlewares.py:43:def test_caching_flush(storage):
tests/test_middlewares.py:57:def test_caching_flush_manually(storage):
tests/test_middlewares.py:67:def test_caching_write(storage):
tests/test_middlewares.py:77:def test_nested():
tests/test_middlewares.py:88:def test_caching_json_write(tmpdir):
[The command completed with exit code 0.]
[Current working directory: /workspace/tinydb]
[Python interpreter: /usr/bin/python]
[Command finished with exit code 0]