atomicshop 2.16.17__py3-none-any.whl → 2.16.19__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.17'
+__version__ = '2.16.19'

atomicshop/filesystem.py

@@ -422,17 +422,33 @@ def temporary_change_working_directory(new_working_directory: str) -> None:
         os.chdir(original_working_directory)
 
 
-def move_file(source_file_path: str, target_file_path: str, overwrite: bool = True) -> None:
+def move_file(source_file_path: str, target_directory: str, overwrite: bool = True) -> None:
     """
     The function moves file from source to target.
 
     :param source_file_path: string, full path to source file.
-    :param target_file_path: string, full path to target file.
+    :param target_directory: string, full path to target directory.
     :param overwrite: boolean, if 'False', then the function will not overwrite the file if it exists.
 
+    Example:
+        Before move:
+        Source file = 'C:/Users/user1/Downloads/file-to-move.txt'
+        Move to directory = 'C:/Users/user1/Documents'
+
+        Move:
+        source_file_path = 'C:/Users/user1/Downloads/file-to-move.txt'
+        target_directory = 'C:/Users/user1/Documents'
+        move_file(source_file_path, target_file_path)
+
+        After move:
+        'C:/Users/user1/Downloads'
+        'C:/Users/user1/Documents/file-to-move.txt'
+
     :return: None
     """
 
+    target_file_path = target_directory + os.sep + Path(source_file_path).name
+
     # Check if 'no_overwrite' is set to 'True' and if the file exists.
     if not overwrite:
         if is_file_exists(target_file_path):
@@ -455,12 +471,17 @@ def move_folder(source_directory: str, target_directory: str, overwrite: bool =
     ------------------------------
 
     Example:
-    source_directory = 'C:/Users/user1/Downloads/folder-to-move'
-    target_directory = 'C:/Users/user1/Documents'
-    move_folder(source_directory, target_directory)
+        Before move:
+        Source folder = 'C:/Users/user1/Downloads/folder-to-move'
+        Move to directory = 'C:/Users/user1/Documents'
+
+        Move:
+        source_directory = 'C:/Users/user1/Downloads/folder-to-move'
+        target_directory = 'C:/Users/user1/Documents'
+        move_folder(source_directory, target_directory)
 
-    Result path of the 'folder-to-move' will be:
-    'C:/Users/user1/Documents/folder-to-move'
+        Result path of the 'folder-to-move' will be:
+        'C:/Users/user1/Documents/folder-to-move'
 
     """
 
@@ -473,14 +494,14 @@ def move_folder(source_directory: str, target_directory: str, overwrite: bool =
     shutil.move(source_directory, target_directory)
 
 
-def move_files_from_folder_to_folder(
+def move_top_level_files_from_folder_to_folder(
         source_directory: str,
         target_directory: str,
         overwrite: bool = True
 ):
     """
-    The function is currently non-recursive and not tested with directories inside the source directories.
-    The function will move all the files from source directory to target directory overwriting existing files.
+    The function is non-recursive to move only top level files from source directory to target directory
+    overwriting existing files.
 
     :param source_directory: string, full path to source directory.
     :param target_directory: string, full path to target directory.
@@ -488,26 +509,50 @@ def move_files_from_folder_to_folder(
     """
 
     # Iterate over each item in the source directory
-    for item in os.listdir(source_directory):
-        # Construct full file path
-        source_item = os.path.join(source_directory, item)
-        destination_item = os.path.join(target_directory, item)
+    top_level_files: list[str] = get_paths_from_directory(
+        directory_path=source_directory, get_file=True, recursive=False, simple_list=True)
 
+    for source_item in top_level_files:
         # Move each item to the destination directory
-        move_file(source_file_path=source_item, target_file_path=destination_item, overwrite=overwrite)
+        move_file(source_file_path=source_item, target_directory=target_directory, overwrite=overwrite)
 
-    # # Get all file names without full paths in source folder.
-    # file_list_in_source: list = get_paths_from_directory(source_directory, get_file=True)
-    #
-    # # Iterate through all the files.
-    # for file_path in file_list_in_source:
-    #     # Move the file from source to target.
-    #     if file_path.relative_dir:
-    #         create_directory(target_directory + os.sep + file_path.relative_dir)
-    #         relative_file_path: str = file_path.relative_dir + os.sep + Path(file_path.path).name
-    #     else:
-    #         relative_file_path: str = Path(file_path.path).name
-    #     move_file(file_path.path, target_directory + os.sep + relative_file_path)
+
+def move_folder_contents_to_folder(
+        source_directory: str,
+        target_directory: str,
+        overwrite: bool = True
+):
+    """
+    The function moves all the contents of the source directory to the target directory.
+    If target directory is inside the source directory, this folder will be skipped.
+
+    :param source_directory: string, full path to source directory.
+    :param target_directory: string, full path to target directory.
+    :param overwrite: boolean, if 'True', then the function will overwrite the files if they exist.
+    """
+
+    # Make sure the destination directory exists, if not create it
+    os.makedirs(target_directory, exist_ok=True)
+
+    # Move contents of the source directory to the destination directory
+    for item in os.listdir(source_directory):
+        s = os.path.join(source_directory, item)
+        d = os.path.join(target_directory, item)
+
+        # if the target directory is inside the source directory, skip it
+        if os.path.abspath(target_directory).startswith(os.path.abspath(s)):
+            continue
+
+        if os.path.isdir(s):
+            if os.path.exists(d) and not overwrite:
+                print(f"Directory {d} already exists. Skipping due to overwrite=False.")
+            else:
+                shutil.move(s, d)
+        else:
+            if os.path.exists(d) and not overwrite:
+                print(f"File {d} already exists. Skipping due to overwrite=False.")
+            else:
+                shutil.move(s, d)
 
 
 def copy_file(
@@ -681,7 +726,7 @@ def get_paths_from_directory(
         sort_by_last_modified_time: bool = False,
         add_file_binary: bool = False,
         add_file_hash: bool = False,
-) -> list[AtomicPath]:
+) -> Union[list[AtomicPath], list[str]]:
     """
     Recursive, by option.
     The function receives a filesystem directory as string, scans it recursively for files and returns list of
@@ -1524,7 +1569,7 @@ def backup_file(
         else:
             file_name: str = f"{file_name_no_extension}_{timestamp}{file_extension}"
         backup_file_path: str = str(Path(backup_directory) / file_name)
-        move_file(file_path, backup_file_path)
+        move_file(file_path, backup_directory)
 
         return backup_file_path
     else:

atomicshop/mitm/recs_files.py

@@ -51,7 +51,7 @@ def recs_archiver(recs_directory: str) -> list:
             target_directory_path: str = f"{directory_path.path}{os.sep}{recs_atomic_path.datetime_string}"
             filesystem.create_directory(target_directory_path)
             filesystem.move_file(
-                recs_atomic_path.path, f'{target_directory_path}{os.sep}{recs_atomic_path.name}')
+                recs_atomic_path.path, target_directory_path)
 
         # Archive directories.
         archive_directories: list = filesystem.get_paths_from_directory(

atomicshop/wrappers/loggingw/reading.py

@@ -207,8 +207,7 @@ def get_all_log_files_into_list(
         filesystem.create_directory(move_to_path_with_timestamp)
         # Move the statistics files.
         for single_file in logs_files:
-            move_to_path_with_file = f'{move_to_path_with_timestamp}{os.sep}{single_file.name}'
-            filesystem.move_file(single_file.path, move_to_path_with_file)
+            filesystem.move_file(single_file.path, move_to_path_with_timestamp)
 
     return logs_content
 

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.17.dist-info → atomicshop-2.16.19.dist-info}/METADATA

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

{atomicshop-2.16.17.dist-info → atomicshop-2.16.19.dist-info}/RECORD

@@ -1,4 +1,4 @@
-atomicshop/__init__.py,sha256=8j7ZCpRQjA2znKZa29KoZQlCV-GjDBzWXCHWB8Kft3c,124
+atomicshop/__init__.py,sha256=ZX5xejuYVvRch1tJs02jeNOwNajL4QyvDzPyQpk4C7s,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
@@ -14,7 +14,7 @@ atomicshop/dns.py,sha256=J4yX6vCaRdL0McYWnlJ9arCDKW-yRui7Y5WyL5BoD6M,6391
 atomicshop/domains.py,sha256=Rxu6JhhMqFZRcoFs69IoEd1PtYca0lMCG6F1AomP7z4,3197
 atomicshop/emails.py,sha256=I0KyODQpIMEsNRi9YWSOL8EUPBiWyon3HRdIuSj3AEU,1410
 atomicshop/file_types.py,sha256=-0jzQMRlmU1AP9DARjk-HJm1tVE22E6ngP2mRblyEjY,763
-atomicshop/filesystem.py,sha256=5xkZFIKYoTTmRBkJo5p4R1G48Xbdjlyc7R514QqNXQs,58711
+atomicshop/filesystem.py,sha256=XPrOjqxQRP3fa01QztDvuDUpiFjCYtpPUC0KhaGHxqs,60222
 atomicshop/functions.py,sha256=pK8hoCE9z61PtWCxQJsda7YAphrLH1wxU5x-1QJP-sY,499
 atomicshop/get_process_list.py,sha256=8cxb7gKe9sl4R6H2yMi8J6oe-RkonTvCdKjRFqi-Fs4,6075
 atomicshop/get_process_name_cmd_dll.py,sha256=CtaSp3mgxxJKCCVW8BLx6BJNx4giCklU_T7USiCEwfc,5162
@@ -129,7 +129,7 @@ atomicshop/mitm/import_config.py,sha256=_nu8mgA-M4s6dZ8_QWx3x0aVb75upvsCuX_PIUg4
 atomicshop/mitm/initialize_engines.py,sha256=kBG8TBnyFuwlJ1uKaWDzc5AiZNpwdvouq2pr-PYrdEA,8349
 atomicshop/mitm/message.py,sha256=d_sm3O_aoZf87dDQP44xOMNEG-uZBN1ZecQgMCacbZs,1814
 atomicshop/mitm/mitm_main.py,sha256=CdCv4nYt_jwd23AI14v6lC2H8SZeIZqsXjFhwq61UtM,21285
-atomicshop/mitm/recs_files.py,sha256=4k6vCemGRmZ605yZ0-yRpF1ny3eAns7f3j61UXTJ99M,2966
+atomicshop/mitm/recs_files.py,sha256=B8fSuvYXlh50LWfwLRw_bYswreTjmdZLuHJzbDC5Gss,2930
 atomicshop/mitm/shared_functions.py,sha256=hplm98tz8pgJ4WHUVI9sf_oVqUM2KJ1Y2pD6EFSb8P0,1879
 atomicshop/mitm/statistic_analyzer.py,sha256=AzL9rQhg0tLJj33gZfxdwWghmbXGLh_HyMBDpzuBmsQ,24709
 atomicshop/mitm/engines/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -250,11 +250,11 @@ atomicshop/wrappers/loggingw/formatters.py,sha256=7XUJvlB0CK4DCkEp8NTL0S0dkyrZD0
 atomicshop/wrappers/loggingw/handlers.py,sha256=hAPFJQ-wFoNO8QzGrJRSvyuP09Q1F0Dl9_w7zzlgcW0,18155
 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/loggingw/reading.py,sha256=ERBSiQbEksySKpXpu2E_6k9dZ6MPH95ZIsmdjWW9MUE,16436
 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.17.dist-info/LICENSE.txt,sha256=lLU7EYycfYcK2NR_1gfnhnRC8b8ccOTElACYplgZN88,1094
-atomicshop-2.16.17.dist-info/METADATA,sha256=hh2ElTNYbFQfLq_0PnD9wptNCmnlx06CLdEMgs-DWDo,10473
-atomicshop-2.16.17.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
-atomicshop-2.16.17.dist-info/top_level.txt,sha256=EgKJB-7xcrAPeqTRF2laD_Np2gNGYkJkd4OyXqpJphA,11
-atomicshop-2.16.17.dist-info/RECORD,,
+atomicshop-2.16.19.dist-info/LICENSE.txt,sha256=lLU7EYycfYcK2NR_1gfnhnRC8b8ccOTElACYplgZN88,1094
+atomicshop-2.16.19.dist-info/METADATA,sha256=rjqYESm2qP69gn_SoSyX0Ki4mxg4z4cvCJfuxC2xEcY,10473
+atomicshop-2.16.19.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+atomicshop-2.16.19.dist-info/top_level.txt,sha256=EgKJB-7xcrAPeqTRF2laD_Np2gNGYkJkd4OyXqpJphA,11
+atomicshop-2.16.19.dist-info/RECORD,,