atomicshop 2.16.16__py3-none-any.whl → 2.16.18__py3-none-any.whl

atomicshop/__init__.py

@@ -1,4 +1,4 @@
 """Atomic Basic functions and classes to make developer life easier"""
 
 __author__ = "Den Kras"
-__version__ = '2.16.16'
+__version__ = '2.16.18'

atomicshop/mitm/statistic_analyzer_helper/moving_average_helper.py

@@ -5,7 +5,7 @@ from typing import Literal
 from ...print_api import print_api
 from ...wrappers.loggingw import reading, consts
 from ...file_io import csvs
-from ... import urls
+from ... import urls, filesystem
 
 
 def calculate_moving_average(
@@ -43,7 +43,7 @@ def calculate_moving_average(
     date_format: str = consts.DEFAULT_ROTATING_SUFFIXES_FROM_WHEN['midnight']
 
     # Get all the file paths and their midnight rotations.
-    logs_paths: list = reading.get_logs_paths(
+    logs_paths: list[filesystem.AtomicPath] = reading.get_logs_paths(
         log_file_path=file_path,
         date_format=date_format
     )
@@ -54,14 +54,14 @@ def calculate_moving_average(
 
     statistics_content: dict = {}
     # Read each file to its day.
-    for log_path_dict in logs_paths:
-        date_string = log_path_dict['date_string']
+    for log_atomic_path in logs_paths:
+        date_string = log_atomic_path.datetime_string
         statistics_content[date_string] = {}
 
-        statistics_content[date_string]['file'] = log_path_dict
+        statistics_content[date_string]['file'] = log_atomic_path
 
         log_file_content, log_file_header = (
-            csvs.read_csv_to_list_of_dicts_by_header(log_path_dict['file_path'], **(print_kwargs or {})))
+            csvs.read_csv_to_list_of_dicts_by_header(log_atomic_path.path, **(print_kwargs or {})))
         statistics_content[date_string]['content'] = log_file_content
         statistics_content[date_string]['header'] = log_file_header
 

atomicshop/wrappers/loggingw/loggers.py

@@ -14,6 +14,17 @@ import logging
 """
 
 
+def is_logger_exists(
+        logger_name: str
+) -> bool:
+    """
+    Function to check if the logger exists.
+    :param logger_name: str, Name of the logger.
+    :return: bool, True if the logger exists, False otherwise.
+    """
+    return logger_name in logging.Logger.manager.loggerDict
+
+
 def get_logger(logger_name: str) -> logging.Logger:
     """
     Function to get a logger.

atomicshop/wrappers/loggingw/loggingw.py

@@ -8,6 +8,7 @@ from . import loggers, handlers
 # noinspection PyPep8Naming
 def create_logger(
         logger_name: str,
+        get_existing_if_exists: bool = True,
         file_path: str = None,
         directory_path: str = None,
         add_stream: bool = False,
@@ -42,6 +43,8 @@ def create_logger(
     Function to get a logger and add StreamHandler and TimedRotatingFileHandler to it.
 
     :param logger_name: Name of the logger.
+    :param get_existing_if_exists: bool, If set to True, the logger will be returned if it already exists.
+        If set to False, the new stream/file handler will be added to existing logger again.
     :param file_path: full path to the log file. If you don't want to use the file, set it to None.
         You can set the directory_path only and then the 'logger_name' will be used as the file name with the
         'file_type' as the file extension.
@@ -173,8 +176,15 @@ def create_logger(
 
         file_path = f"{directory_path}{os.sep}{logger_name}.{file_type}"
 
+    # Check if the logger exists before creating it/getting the existing.
+    is_logger_exists = loggers.is_logger_exists(logger_name)
+
     logger = get_logger_with_level(logger_name, logging_level)
 
+    # If the logger already exists, and we don't want to add the handlers again, return the logger.
+    if get_existing_if_exists and is_logger_exists:
+        return logger
+
     if add_stream:
         handlers.add_stream_handler(
             logger=logger, logging_level=logging_level, formatter=formatter_streamhandler,

atomicshop/wrappers/loggingw/reading.py

@@ -14,7 +14,7 @@ def get_logs_paths(
         latest_only: bool = False,
         previous_day_only: bool = False,
         specific_date: str = None
-):
+) -> list[filesystem.AtomicPath]:
     """
     This function gets the logs file paths from the directory. Supports rotating files to get the logs by time.
 
@@ -61,7 +61,7 @@ def get_logs_paths(
     log_files_directory_path: str = str(Path(log_file_path).parent)
 
     # Get all the log file paths by the file_name_pattern and the date_format string.
-    logs_files: list = filesystem.get_paths_from_directory(
+    logs_files: list[filesystem.AtomicPath] = filesystem.get_paths_from_directory(
         log_files_directory_path,
         get_file=True,
         file_name_check_pattern=file_name_pattern,

atomicshop/wrappers/mongodbw/mongo_infra.py

@@ -23,6 +23,14 @@ def test_connection(
         uri: str = MONGODB_DEFAULT_URI,
         raise_exception: bool = False
 ) -> bool:
+    """
+    Test the connection to the MongoDB server.
+
+    :param uri: str, URI to the MongoDB server.
+    :param raise_exception: bool, True to raise an exception if the connection fails, False otherwise (just return
+    False).
+    :return: bool, True if the connection is successful, False otherwise.
+    """
     try:
         client = MongoClient(uri)
         client.admin.command('ping')

atomicshop/wrappers/mongodbw/mongodbw.py

@@ -1,7 +1,11 @@
-from typing import Union
+from typing import Union, Literal
 import datetime
+import json
 
+# noinspection PyPackageRequirements
 import pymongo
+# noinspection PyPackageRequirements
+import pymongo.database
 
 from ...basics import dicts
 
@@ -14,6 +18,253 @@ These are good examples to get you started, but can't really cover all the use c
 """
 
 
+class MongoDBWrapper:
+    def __init__(
+            self,
+            db_name: str,
+            uri: str = mongo_infra.MONGODB_DEFAULT_URI
+    ):
+        self.db_name: str = db_name
+        self.uri: str = uri
+
+        # noinspection PyTypeChecker
+        self.client: pymongo.MongoClient = None
+        # noinspection PyTypeChecker
+        self.db: pymongo.database.Database = None
+
+    def connect(self):
+        """
+        Connect to a MongoDB database.
+        :return: pymongo.MongoClient, the client object.
+        """
+
+        if not self.client:
+            self.client = connect(uri=self.uri)
+            self.db = get_db(database=self.db_name, mongo_client=self.client)
+
+    def disconnect(self):
+        """
+        Disconnect from a MongoDB database.
+        :return: None
+        """
+
+        if self.client:
+            self.client.close()
+            self.client = None
+
+    def index(
+            self,
+            object_instance: Union[list[dict], dict],
+            collection_name: str,
+            add_timestamp: bool = False,
+            convert_mixed_lists_to_strings: bool = False
+    ):
+        """
+        Add a dictionary or list dictionaries to a MongoDB collection.
+        :param object_instance: list of dictionaries or dictionary to add to the collection.
+        :param collection_name: str, the name of the collection.
+        :param add_timestamp: bool, if True, a current time timestamp will be added to the object.
+        :param convert_mixed_lists_to_strings: bool, if True, mixed lists or tuples when entries are
+            strings and integers, the integers will be converted to strings.
+
+        :return: None
+        """
+
+        self.connect()
+
+        index(
+            object_instance=object_instance,
+            database=self.db, collection_name=collection_name,
+            add_timestamp=add_timestamp, convert_mixed_lists_to_strings=convert_mixed_lists_to_strings,
+            mongo_client=self.client, close_client=False)
+
+    def delete(
+            self,
+            object_instance: Union[list[dict], dict],
+            collection_name: str
+    ):
+        """
+        Remove a list of dictionaries or a dictionary from a MongoDB collection.
+
+        :param object_instance: list of dictionaries, the list of dictionaries to remove from the collection.
+        :param collection_name: str, the name of the collection.
+
+        :return: None
+        """
+
+        self.connect()
+
+        delete(
+            object_instance=object_instance,
+            database=self.db, collection_name=collection_name,
+            mongo_client=self.client, close_client=False)
+
+    def find(
+            self,
+            collection_name: str,
+            query: dict = None,
+            page: int = None,
+            items: int = None,
+            sorting: dict[str, Literal[
+                'asc', 'desc',
+                1, -1]] = None,
+            convert_object_id_to_str: bool = False,
+            keys_convert_to_dict: list[str] = None
+    ) -> list[dict]:
+        """
+        Find entries in a MongoDB collection by query.
+        :param collection_name: str, the name of the collection.
+        :param query: dict, the query to search for.
+            Example, search for all entries with column name 'name' equal to 'John':
+                query = {'name': 'John'}
+            Example, return all entries from collection:
+                query = None
+
+            CHECK MORE EXAMPLES IN THE DOCSTRING OF THE FUNCTION 'find' BELOW which is not in this class.
+        :param page: int, the page number (Optional).
+            The results are filtered after results are fetched from db.
+        :param items: int, the number of results per page (Optional).
+            The results are filtered after results are fetched from db.
+        :param sorting: dict, the name of the field and the order to sort the containers by.
+            You can use several fields to sort the containers by several fields.
+            In this case the containers will be sorted by the first field, then by the second field, etc.
+            You can also use only singular field to sort the containers by only one field.
+            Usage:
+                {
+                    field_name: order
+                }
+            Example:
+                {
+                    'vendor': 'asc',
+                    'model': 'desc'
+                }
+
+            Or example using integers:
+                {
+                    'vendor': 1,
+                    'model': -1
+                }
+
+        :param convert_object_id_to_str: bool, if True, the '_id' field will be converted to a string.
+            The '_id' field is an ObjectId type, which is a complex object, it can be converted to a string for simpler
+            processing.
+        :param keys_convert_to_dict: list, the keys of the documents that should be converted from string to dict.
+            Recursively searches for keys in specified list in a nested dictionary in result entries list,
+            and converts their values using 'json.loads' if found.
+        :return: list of dictionaries, the list of entries that match the query.
+        """
+
+        self.connect()
+
+        entries: list[dict] = find(
+            database=self.db, collection_name=collection_name,
+            query=query, page=page, items=items, sorting=sorting,
+            convert_object_id_to_str=convert_object_id_to_str, key_convert_to_dict=keys_convert_to_dict,
+            mongo_client=self.client, close_client=False)
+
+        return entries
+
+    def distinct(
+            self,
+            collection_name: str,
+            field_name: str,
+            query: dict = None
+    ) -> list:
+        """
+        Get distinct values of a field from a MongoDB collection.
+        Example:
+            Example database:
+                {
+                    'users': [
+                        {'name': 'John', 'age': 25},
+                        {'name': 'John', 'age': 30},
+                        {'name': 'Alice', 'age': 25}
+                    ]
+                }
+
+            Get distinct values of the field 'name' from the collection 'users':
+                distinct('users', 'name')
+
+            Output:
+                ['John', 'Alice']
+
+        :param collection_name: str, the name of the collection.
+        :param field_name: str, the name of the field.
+        :param query: dict, the query to search for. If None, the query will not be executed.
+
+        :return: list, the list of distinct values.
+        """
+
+        self.connect()
+
+        distinct_values = distinct(
+            database=self.db, collection_name=collection_name,
+            field_name=field_name, query=query, mongo_client=self.client, close_client=False)
+
+        return distinct_values
+
+    def count_entries_in_collection(
+            self,
+            collection_name: str,
+            query: dict = None
+    ) -> int:
+        """
+        Count entries in a MongoDB collection by query.
+
+        :param collection_name: str, the name of the collection.
+        :param query: dict, the query to search for.
+            Example, search for all entries with column name 'name' equal to 'John':
+                query = {'name': 'John'}
+            Example, return all entries from collection:
+                query = None
+
+        :return: int, the number of entries that match the query.
+        """
+
+        self.connect()
+
+        count = count_entries_in_collection(
+            database=self.db, collection_name=collection_name,
+            query=query, mongo_client=self.client, close_client=False)
+
+        return count
+
+    def get_client(self):
+        return self.client
+
+    def get_stats_db(
+            self
+    ):
+        """
+        Get the stats of a MongoDB database.
+
+        :return: dict, the stats of the collection.
+        """
+
+        self.connect()
+
+        stats = get_stats_db(
+            database=self.db, mongo_client=self.client, close_client=False)
+
+        return stats
+
+    def get_stats_db_size(
+            self
+    ):
+        """
+        Get the size of a MongoDB database in bytes.
+
+        :return: int, the size of the database in bytes.
+        """
+
+        self.connect()
+
+        size = get_stats_db_size(
+            database=self.db, mongo_client=self.client, close_client=False)
+
+        return size
+
+
 def connect(uri: str = mongo_infra.MONGODB_DEFAULT_URI):
     """
     Connect to a MongoDB database.
@@ -23,9 +274,27 @@ def connect(uri: str = mongo_infra.MONGODB_DEFAULT_URI):
     return pymongo.MongoClient(uri)
 
 
+def get_db(
+        database: str,
+        mongo_client: pymongo.MongoClient = None
+) -> pymongo.database.Database:
+    """
+    Get a MongoDB database object.
+    :param database: String, the name of the database.
+    :param mongo_client: pymongo.MongoClient, the connection object.
+        If None, a new connection will be created to default URI.
+    :return: pymongo.database.Database, the database object.
+    """
+
+    if not mongo_client:
+        mongo_client = connect()
+
+    return mongo_client[database]
+
+
 def index(
         object_instance: Union[list[dict], dict],
-        database_name: str,
+        database: Union[str, pymongo.database.Database],
         collection_name: str,
         add_timestamp: bool = False,
         convert_mixed_lists_to_strings: bool = False,
@@ -35,7 +304,9 @@ def index(
     """
     Add a dictionary or list dictionaries to a MongoDB collection.
     :param object_instance: list of dictionaries or dictionary to add to the collection.
-    :param database_name: str, the name of the database.
+    :param database: String or the database object.
+        str - the name of the database. In this case the database object will be created.
+        pymongo.database.Database - the database object that will be used instead of creating a new one.
     :param collection_name: str, the name of the collection.
     :param add_timestamp: bool, if True, a current time timestamp will be added to the object.
     :param convert_mixed_lists_to_strings: bool, if True, mixed lists or tuples when entries are strings and integers,
@@ -53,7 +324,7 @@ def index(
         mongo_client = connect()
         close_client = True
 
-    db = mongo_client[database_name]
+    db = _get_pymongo_db_from_string_or_pymongo_db(database, mongo_client)
     collection = db[collection_name]
 
     if convert_mixed_lists_to_strings:
@@ -78,7 +349,7 @@ def index(
 
 def delete(
         object_instance: Union[list[dict], dict],
-        database_name: str,
+        database: Union[str, pymongo.database.Database],
         collection_name: str,
         mongo_client: pymongo.MongoClient = None,
         close_client: bool = False
@@ -87,7 +358,9 @@ def delete(
     Remove a list of dictionaries or a dictionary from a MongoDB collection.
 
     :param object_instance: list of dictionaries, the list of dictionaries to remove from the collection.
-    :param database_name: str, the name of the database.
+    :param database: String or the database object.
+        str - the name of the database. In this case the database object will be created.
+        pymongo.database.Database - the database object that will be used instead of creating a new one.
     :param collection_name: str, the name of the collection.
     :param mongo_client: pymongo.MongoClient, the connection object.
         If None, a new connection will be created to default URI.
@@ -102,7 +375,7 @@ def delete(
         mongo_client = connect()
         close_client = True
 
-    db = mongo_client[database_name]
+    db = _get_pymongo_db_from_string_or_pymongo_db(database, mongo_client)
     collection = db[collection_name]
 
     if isinstance(object_instance, dict):
@@ -116,21 +389,91 @@ def delete(
 
 
 def find(
-        database_name: str,
+        database: Union[str, pymongo.database.Database],
         collection_name: str,
         query: dict = None,
+        page: int = None,
+        items: int = None,
+        sorting: dict[str, Literal[
+            'asc', 'desc',
+            1, -1]] = None,
+        convert_object_id_to_str: bool = False,
+        key_convert_to_dict: list[str] = None,
         mongo_client: pymongo.MongoClient = None,
         close_client: bool = False
-):
+) -> list[dict]:
     """
     Find entries in a MongoDB collection by query.
-    :param database_name: str, the name of the database.
+    :param database: String or the database object.
+        str - the name of the database. In this case the database object will be created.
+        pymongo.database.Database - the database object that will be used instead of creating a new one.
     :param collection_name: str, the name of the collection.
     :param query: dict, the query to search for.
-        Example, search for all entries with column name 'name' equal to 'John':
-            query = {'name': 'John'}
         Example, return all entries from collection:
             query = None
+        Example, search for all entries with column name 'name' equal to 'John':
+            query = {'name': 'John'}
+
+        Additional parameters to use in the value of the query:
+        $regex: Will search for a regex pattern in the field.
+            Example for searching for a value that contains 'test':
+            query = {'field_name': {'$regex': 'test'}}
+            This will return all entries where the field 'field_name' contains the word 'test':
+            'test', 'test1', '2test', etc.
+
+            Example for searching for a value that starts with 'test':
+            query = {'field_name': {'$regex': '^test'}}
+        $options: The options for the regex search.
+            'i': case-insensitive search.
+                Example for case-insensitive search:
+                query = {'field_name': {'$regex': 'test', '$options': 'i'}}
+        $and: Will search for entries that match all the conditions.
+            Example for searching for entries that match all the conditions:
+            query = {'$and': [
+                {'field_name1': 'value1'},
+                {'field_name2': 'value2'}
+            ]}
+        $or: Will search for entries that match at least one of the conditions.
+            Example for searching for entries that match at least one of the conditions:
+            query = {'$or': [
+                {'field_name1': 'value1'},
+                {'field_name2': 'value2'}
+            ]}
+        $in: Will search for a value in a list of values.
+            Example for searching for a value that is in a list of values:
+            query = {'field_name': {'$in': ['value1', 'value2', 'value3']}}
+        $nin: Will search for a value not in a list of values.
+            Example for searching for a value that is not in a list of values:
+            query = {'field_name': {'$nin': ['value1', 'value2', 'value3']}}
+
+
+    :param page: int, the page number (Optional).
+    :param items: int, the number of results per page (Optional).
+    :param sorting: dict, the name of the field and the order to sort the containers by.
+        You can use several fields to sort the containers by several fields.
+        In this case the containers will be sorted by the first field, then by the second field, etc.
+        You can also use only singular field to sort the containers by only one field.
+        Usage:
+            {
+                field_name: order
+            }
+        Example:
+            {
+                'vendor': 'asc',
+                'model': 'desc'
+            }
+
+        Or example using integers:
+            {
+                'vendor': 1,
+                'model': -1
+            }
+    :param convert_object_id_to_str: bool, if True, the '_id' field will be converted to a string.
+        The '_id' field is an ObjectId type, which is a complex object, it can be converted to a string for simpler
+        processing.
+    :param key_convert_to_dict: list, the keys of the documents that should be converted from string to dict.
+        Recursively searches for keys in specified list in a nested dictionary in result entries list,
+        and converts their values using 'json.loads' if found.
     :param mongo_client: pymongo.MongoClient, the connection object.
         If None, a new connection will be created to default URI.
     :param close_client: bool, if True, the connection will be closed after the operation.
@@ -138,17 +481,58 @@ def find(
     :return: list of dictionaries, the list of entries that match the query.
     """
 
+    if page and not items:
+        raise ValueError("If 'page' is provided, 'items' must be provided as well.")
+    elif items and not page:
+        page = 1
+
+    if sorting:
+        for key_to_sort_by, order in sorting.items():
+            if order not in ['asc', 'desc', 1, -1]:
+                raise ValueError("The order must be 'asc', 'desc', 1 or -1.")
+
     if not mongo_client:
         mongo_client = connect()
         close_client = True
 
-    db = mongo_client[database_name]
+    db = _get_pymongo_db_from_string_or_pymongo_db(database, mongo_client)
     collection = db[collection_name]
 
     if query is None:
-        entries: list = list(collection.find())
-    else:
-        entries: list = list(collection.find(query))
+        query = {}
+
+    # Calculate the number of documents to skip
+    skip_items = 0
+    if page and items:
+        skip_items = (page - 1) * items
+
+    collection_items = collection.find(query)
+
+    if sorting:
+        sorting_list_of_tuples: list[tuple[str, int]] = []
+        for key_to_sort_by, order in sorting.items():
+            if order == 'asc':
+                order = pymongo.ASCENDING
+            elif order == 'desc':
+                order = pymongo.DESCENDING
+
+            sorting_list_of_tuples.append((key_to_sort_by, order))
+
+        collection_items = collection_items.sort(sorting_list_of_tuples)
+
+    # 'skip_items' can be 0, if we ask for the first page, so we still need to cut the number of items.
+    # In this case checking if 'items' is not None is enough.
+    if items:
+        collection_items = collection_items.skip(skip_items).limit(items)
+
+    entries: list[dict] = list(collection_items)
+
+    if convert_object_id_to_str:
+        for entry_index, entry in enumerate(entries):
+            entries[entry_index]['_id'] = str(entry['_id'])
+
+    if key_convert_to_dict and entries:
+        entries = _convert_key_values_to_objects(keys_convert_to_dict=key_convert_to_dict, returned_data=entries)
 
     if close_client:
         mongo_client.close()
@@ -156,15 +540,116 @@ def find(
     return entries
 
 
+def distinct(
+        database: Union[str, pymongo.database.Database],
+        collection_name: str,
+        field_name: str,
+        query: dict = None,
+        mongo_client: pymongo.MongoClient = None,
+        close_client: bool = False
+) -> list:
+    """
+    Get distinct values of a field from a MongoDB collection.
+    Example:
+        Example database:
+            {
+                'users': [
+                    {'name': 'John', 'age': 25},
+                    {'name': 'John', 'age': 30},
+                    {'name': 'Alice', 'age': 25}
+                ]
+            }
+
+        Get distinct values of the field 'name' from the collection 'users':
+            distinct('my_db', 'users', 'name')
+
+        Output:
+            ['John', 'Alice']
+
+    :param database: String or the database object.
+        str - the name of the database. In this case the database object will be created.
+        pymongo.database.Database - the database object that will be used instead of creating a new one.
+    :param collection_name: str, the name of the collection.
+    :param field_name: str, the name of the field.
+    :param query: dict, the query to search for.
+        If None, the query will not be executed.
+    :param mongo_client: pymongo.MongoClient, the connection object.
+        If None, a new connection will be created to default URI.
+    :param close_client: bool, if True, the connection will be closed after the operation.
+
+    :return: list, the list of distinct values.
+    """
+
+    if not mongo_client:
+        mongo_client = connect()
+        close_client = True
+
+    db = _get_pymongo_db_from_string_or_pymongo_db(database, mongo_client)
+    collection = db[collection_name]
+
+    distinct_values = collection.distinct(field_name, query)
+
+    if close_client:
+        mongo_client.close()
+
+    return distinct_values
+
+
+def count_entries_in_collection(
+        database: Union[str, pymongo.database.Database],
+        collection_name: str,
+        query: dict = None,
+        mongo_client: pymongo.MongoClient = None,
+        close_client: bool = False
+) -> int:
+    """
+    Count entries in a MongoDB collection by query.
+
+    :param database: String or the database object.
+        str - the name of the database. In this case the database object will be created.
+        pymongo.database.Database - the database object that will be used instead of creating a new one.
+    :param collection_name: str, the name of the collection.
+    :param query: dict, the query to search for.
+        Example, search for all entries with column name 'name' equal to 'John':
+            query = {'name': 'John'}
+        Example, return all entries from collection:
+            query = None
+    :param mongo_client: pymongo.MongoClient, the connection object.
+        If None, a new connection will be created to default URI.
+    :param close_client: bool, if True, the connection will be closed after the operation.
+
+    :return: int, the number of entries that match the query.
+    """
+
+    if not mongo_client:
+        mongo_client = connect()
+        close_client = True
+
+    db = _get_pymongo_db_from_string_or_pymongo_db(database, mongo_client)
+    collection = db[collection_name]
+
+    if query is None:
+        query = {}
+
+    count = collection.count_documents(query)
+
+    if close_client:
+        mongo_client.close()
+
+    return count
+
+
 def delete_all_entries_from_collection(
-        database_name: str,
+        database: Union[str, pymongo.database.Database],
         collection_name: str,
         mongo_client: pymongo.MongoClient = None,
         close_client: bool = False
 ):
     """
     Remove all entries from a MongoDB collection.
-    :param database_name: str, the name of the database.
+    :param database: String or the database object.
+        str - the name of the database. In this case the database object will be created.
+        pymongo.database.Database - the database object that will be used instead of creating a new one.
     :param collection_name: str, the name of the collection.
     :param mongo_client: pymongo.MongoClient, the connection object.
         If None, a new connection will be created to default URI.
@@ -177,7 +662,7 @@ def delete_all_entries_from_collection(
         mongo_client = connect()
         close_client = True
 
-    db = mongo_client[database_name]
+    db = _get_pymongo_db_from_string_or_pymongo_db(database, mongo_client)
     collection = db[collection_name]
 
     collection.delete_many({})
@@ -188,7 +673,7 @@ def delete_all_entries_from_collection(
 
 def overwrite_collection(
         object_instance: list,
-        database_name: str,
+        database: Union[str, pymongo.database.Database],
         collection_name: str,
         add_timestamp: bool = False,
         convert_mixed_lists_to_strings: bool = False,
@@ -198,7 +683,9 @@ def overwrite_collection(
     """
     Overwrite a MongoDB collection with list of dicts or a dict.
     :param object_instance: list of dictionaries, the list of dictionaries to overwrite in the collection.
-    :param database_name: str, the name of the database.
+    :param database: String or the database object.
+        str - the name of the database. In this case the database object will be created.
+        pymongo.database.Database - the database object that will be used instead of creating a new one.
     :param collection_name: str, the name of the collection.
     :param add_timestamp: bool, if True, a current time timestamp will be added to the object.
     :param convert_mixed_lists_to_strings: bool, if True, mixed lists or tuples when entries are strings and integers,
@@ -217,13 +704,13 @@ def overwrite_collection(
         close_client = True
 
     delete_all_entries_from_collection(
-        database_name=database_name, collection_name=collection_name,
+        database=database, collection_name=collection_name,
         mongo_client=mongo_client
     )
 
     index(
         object_instance=object_instance,
-        database_name=database_name, collection_name=collection_name,
+        database=database, collection_name=collection_name,
         add_timestamp=add_timestamp, convert_mixed_lists_to_strings=convert_mixed_lists_to_strings,
         mongo_client=mongo_client, close_client=close_client)
 
@@ -242,15 +729,39 @@ def _is_object_list_of_dicts_or_dict(
         raise ValueError("Object must be a dictionary or a list of dictionaries.")
 
 
+def _get_pymongo_db_from_string_or_pymongo_db(
+        database: Union[str, pymongo.database.Database],
+        mongo_client: pymongo.MongoClient
+) -> pymongo.database.Database:
+    """
+    Get a pymongo.database.Database object from a string or a pymongo.database.Database object.
+
+    :param database: Union[str, pymongo.database.Database], the database object or the name of the database.
+        If the database is a string, the database object will be created.
+        If the database is a pymongo.database.Database object, it will be returned as is.
+    :param mongo_client: mongodb.MongoClient, the connection object.
+    :return: pymongo.database.Database, the database object.
+    """
+
+    if isinstance(database, str):
+        return mongo_client[database]
+    elif isinstance(database, pymongo.database.Database):
+        return database
+    else:
+        raise ValueError("Database must be a string (database name) or a pymongo.database.Database object.")
+
+
 def get_stats_db(
-        database_name: str,
+        database: Union[str, pymongo.database.Database],
         mongo_client: pymongo.MongoClient = None,
         close_client: bool = False
 ):
     """
     Get the stats of a MongoDB database.
 
-    :param database_name: str, the name of the database.
+    :param database: String or the database object.
+        str - the name of the database. In this case the database object will be created.
+        pymongo.database.Database - the database object that will be used instead of creating a new one.
     :param mongo_client: pymongo.MongoClient, the connection object.
         If None, a new connection will be created to default URI.
     :param close_client: bool, if True, the connection will be closed after the operation.
@@ -262,7 +773,7 @@ def get_stats_db(
         mongo_client = connect()
         close_client = True
 
-    db = mongo_client[database_name]
+    db = _get_pymongo_db_from_string_or_pymongo_db(database, mongo_client)
 
     stats = db.command("dbStats")
 
@@ -273,14 +784,16 @@ def get_stats_db(
 
 
 def get_stats_db_size(
-        database_name: str,
+        database: Union[str, pymongo.database.Database],
         mongo_client: pymongo.MongoClient = None,
         close_client: bool = False
 ):
     """
     Get the size of a MongoDB database in bytes.
 
-    :param database_name: str, the name of the database.
+    :param database: String or the database object.
+        str - the name of the database. In this case the database object will be created.
+        pymongo.database.Database - the database object that will be used instead of creating a new one.
     :param mongo_client: pymongo.MongoClient, the connection object.
         If None, a new connection will be created to default URI.
     :param close_client: bool, if True, the connection will be closed after the operation.
@@ -289,6 +802,40 @@ def get_stats_db_size(
     """
 
     stats = get_stats_db(
-        database_name=database_name, mongo_client=mongo_client, close_client=close_client)
+        database=database, mongo_client=mongo_client, close_client=close_client)
 
     return stats['dataSize']
+
+
+def _convert_key_values_to_objects(
+        keys_convert_to_dict: list[str],
+        returned_data: Union[dict, list]
+) -> Union[dict, list]:
+    """
+    Recursively searches for provided keys from the 'keys_convert_to_dict' list like 'test1' and 'test2'
+    in a nested dictionary 'returned_data' and converts their values using "json.loads" if found.
+
+    :param keys_convert_to_dict: list, the keys of the documents that should be converted from string to dict.
+    :param returned_data: The nested dictionary to search through.
+    :type returned_data: dict
+    """
+
+    if isinstance(returned_data, dict):
+        for key, value in returned_data.items():
+            if key in keys_convert_to_dict:
+                # Can be that the value is None, so we don't need to convert it.
+                if value is None:
+                    continue
+
+                try:
+                    returned_data[key] = json.loads(value)
+                except (ValueError, TypeError):
+                    # This is needed only to know the possible exception types.
+                    raise
+            else:
+                _convert_key_values_to_objects(keys_convert_to_dict, value)
+    elif isinstance(returned_data, list):
+        for i, item in enumerate(returned_data):
+            returned_data[i] = _convert_key_values_to_objects(keys_convert_to_dict, item)
+
+    return returned_data

{atomicshop-2.16.16.dist-info → atomicshop-2.16.18.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: atomicshop
-Version: 2.16.16
+Version: 2.16.18
 Summary: Atomic functions and classes to make developer life easier
 Author: Denis Kras
 License: MIT License

{atomicshop-2.16.16.dist-info → atomicshop-2.16.18.dist-info}/RECORD

@@ -1,4 +1,4 @@
-atomicshop/__init__.py,sha256=43IIwVKubkBxqcW9co_kEzLRQCXqxLEBrGIx94aWzjg,124
+atomicshop/__init__.py,sha256=oNmVsW_-ZdNWYFu1cVLreluzXWdxRiR3VEX5qDGDz5A,124
 atomicshop/_basics_temp.py,sha256=6cu2dd6r2dLrd1BRNcVDKTHlsHs_26Gpw8QS6v32lQ0,3699
 atomicshop/_create_pdf_demo.py,sha256=Yi-PGZuMg0RKvQmLqVeLIZYadqEZwUm-4A9JxBl_vYA,3713
 atomicshop/_patch_import.py,sha256=ENp55sKVJ0e6-4lBvZnpz9PQCt3Otbur7F6aXDlyje4,6334
@@ -145,7 +145,7 @@ atomicshop/mitm/engines/__reference_general/recorder___reference_general.py,sha2
 atomicshop/mitm/engines/__reference_general/responder___reference_general.py,sha256=1AM49UaFTKA0AHw-k3SV3uH3QbG-o6ux0c-GoWkKNU0,6993
 atomicshop/mitm/statistic_analyzer_helper/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 atomicshop/mitm/statistic_analyzer_helper/analyzer_helper.py,sha256=pk6L1t1ea1kvlBoR9QEJptOmaX-mumhwLsP2GCKukbk,5920
-atomicshop/mitm/statistic_analyzer_helper/moving_average_helper.py,sha256=lsG_eSWf6M_3AfWqIYEBNwYAyVHJfBiRVKHhmWIOZ9A,16615
+atomicshop/mitm/statistic_analyzer_helper/moving_average_helper.py,sha256=Wge-OfbbClfjeEWwOyksd-x9C5QZdRD3KRSjtP9VL9Q,16651
 atomicshop/monitor/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 atomicshop/monitor/change_monitor.py,sha256=K5NlVp99XIDDPnQQMdru4BDmua_DtcDIhVAzkTOvD5s,7673
 atomicshop/monitor/checks/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -248,13 +248,13 @@ atomicshop/wrappers/loggingw/consts.py,sha256=JWiUJEydjhwatBxtIJsGTmDUSTLbmIRidt
 atomicshop/wrappers/loggingw/filters.py,sha256=CMs5PAMb68zxJgBcQobaOFDG5kLJBOVYnoBHjDgksO8,2859
 atomicshop/wrappers/loggingw/formatters.py,sha256=7XUJvlB0CK4DCkEp8NTL0S0dkyrZD0UTADgEwkStKOY,5483
 atomicshop/wrappers/loggingw/handlers.py,sha256=hAPFJQ-wFoNO8QzGrJRSvyuP09Q1F0Dl9_w7zzlgcW0,18155
-atomicshop/wrappers/loggingw/loggers.py,sha256=DHOOTAtqkwn1xgvLHSkOiBm6yFGNuQy1kvbhG-TDog8,2374
-atomicshop/wrappers/loggingw/loggingw.py,sha256=_VT5aqYgUVI6uurrnfm0_tAYO41Aavs1SSnlU6gfOiQ,11808
-atomicshop/wrappers/loggingw/reading.py,sha256=tplnJlQ7RMxWv2s782tWGOo1C7WNemk2SRTZCCgD9J0,16474
+atomicshop/wrappers/loggingw/loggers.py,sha256=QH5QainlGLyrDpsDu4T1C8-WQQau3JW2OS5RgC-kXpM,2677
+atomicshop/wrappers/loggingw/loggingw.py,sha256=6HUn2z4ZW8PgakPscosKx23qYwHlBQcLiZGw-VZHi-k,12374
+atomicshop/wrappers/loggingw/reading.py,sha256=SZFE4d6IFoC1GveFf28oAuDQzHG8UnBHx3K3-dE5Mes,16528
 atomicshop/wrappers/mongodbw/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 atomicshop/wrappers/mongodbw/install_mongodb.py,sha256=3ZPqrXxj3lC-PnAKGXclylLuOqsbyXYeUpb5iGjdeUU,6626
-atomicshop/wrappers/mongodbw/mongo_infra.py,sha256=JO63ShbHYRBmUdFv-GeJxkPQdhRhq59ly6bxnn64fUM,1713
-atomicshop/wrappers/mongodbw/mongodbw.py,sha256=_K1alcxAAIiMhwJYNB82OD-FjQVQijxp2UYnq-g1z98,9860
+atomicshop/wrappers/mongodbw/mongo_infra.py,sha256=IjEF0jPzQz866MpTm7rnksnyyWQeUT_B2h2DA9ryAio,2034
+atomicshop/wrappers/mongodbw/mongodbw.py,sha256=v_5YYgbgT0F-k2I-hDHQCMPhpry8OonsPclubJk2NG0,31509
 atomicshop/wrappers/nodejsw/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 atomicshop/wrappers/nodejsw/install_nodejs.py,sha256=QZg-R2iTQt7kFb8wNtnTmwraSGwvUs34JIasdbNa7ZU,5154
 atomicshop/wrappers/playwrightw/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -309,8 +309,8 @@ atomicshop/wrappers/socketw/ssl_base.py,sha256=kmiif84kMhBr5yjQW17p935sfjR5JKG0L
 atomicshop/wrappers/socketw/statistics_csv.py,sha256=V_m1D0KpizQox3IEWp2AUcncwWy5kG25hbFrc-mBSJE,3029
 atomicshop/wrappers/winregw/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 atomicshop/wrappers/winregw/winreg_network.py,sha256=bQ8Jql8bVGBJ0dt3VQ56lga_1LBOMLI3Km_otvvbU6c,7138
-atomicshop-2.16.16.dist-info/LICENSE.txt,sha256=lLU7EYycfYcK2NR_1gfnhnRC8b8ccOTElACYplgZN88,1094
-atomicshop-2.16.16.dist-info/METADATA,sha256=JpxLeyrTWZ_qfqn0SMMQtTi9nPcAOj3YLYkPeh-YAJw,10473
-atomicshop-2.16.16.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
-atomicshop-2.16.16.dist-info/top_level.txt,sha256=EgKJB-7xcrAPeqTRF2laD_Np2gNGYkJkd4OyXqpJphA,11
-atomicshop-2.16.16.dist-info/RECORD,,
+atomicshop-2.16.18.dist-info/LICENSE.txt,sha256=lLU7EYycfYcK2NR_1gfnhnRC8b8ccOTElACYplgZN88,1094
+atomicshop-2.16.18.dist-info/METADATA,sha256=b68lhNlBqxZwdV4zttZaQcCUAF18IPOHwKq4PaFIAkA,10473
+atomicshop-2.16.18.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+atomicshop-2.16.18.dist-info/top_level.txt,sha256=EgKJB-7xcrAPeqTRF2laD_Np2gNGYkJkd4OyXqpJphA,11
+atomicshop-2.16.18.dist-info/RECORD,,