Added json file system

Author: CodingSamrat

filexdb/collection.py

@@ -14,12 +14,12 @@
 
 
 class Collection:
-    def __init__(self, col_name: str, binary_file: FileIO) -> None:
+    def __init__(self, col_name: str, file_handler: FileIO) -> None:
         self._col_name = col_name
-        self._binary_file = binary_file
+        self._file_handler = file_handler
 
         # Get the data of existing Database or empty database.
-        self._database = self._binary_file.read()
+        self._database = self._file_handler.read()
 
         self._cursor: int = 0
 
@@ -69,7 +69,7 @@ def insert(self, document: Mapping) -> str:
 
             # print(self._database)
             # Write current state of Database into the Database-file
-            self._binary_file.write(self._database)
+            self._file_handler.write(self._database)
 
             return _doc_id
         else:
@@ -99,9 +99,8 @@ def insert_all(self, document_list: List[Mapping]) -> List[str]:
 
         return _doc_id
 
-    """ FIND_ONE 
-    def __find_one(self, query: Mapping = None) -> Document | None:
-        "
+    def __find_one(self, query: Mapping = None) -> Document | None:         # Not works, right nom
+        """
         Finds a single ``Document`` of ``Collection``.
 
         If ``query`` is None then returns all the ``Documents`` of ``Collection``.
@@ -110,7 +109,8 @@ def __find_one(self, query: Mapping = None) -> Document | None:
 
         :param query: Condition to search Document
         :return: Document
-        "
+        """
+
         # Default result
         _result = {}
 
@@ -131,7 +131,6 @@ def __find_one(self, query: Mapping = None) -> Document | None:
             _result = _result[self._cursor]
 
         return _result
-    """
 
     def find(self, query=None, limit=None) -> List[Document]:
         """
@@ -208,7 +207,7 @@ def find(self, query=None, limit=None) -> List[Document]:
                 self._reset_cursor()
 
                 # check if lower limit is valid or not
-                if _limit_start >= len(_result):
+                if _limit_start >= len(_result) and _limit_start != 0:
                     raise ValueError(f"lower limit should be smaller than length of result")
                 else:
                     # Travers limited result
@@ -248,7 +247,7 @@ def delete(self, query=None) -> List[str]:
             self._collection.remove(_doc)
             _doc_id.append(_doc["_id_"])
 
-        self._binary_file.write(self._database)
+        self._file_handler.write(self._database)
 
         return _doc_id
 
@@ -284,7 +283,7 @@ def update(self, document: Mapping, query=None) -> List[str]:
             _doc_id.append(_doc["_id_"])
 
             # Write current state of Database
-            self._binary_file.write(self._database)
+            self._file_handler.write(self._database)
 
         return _doc_id
 
@@ -300,6 +299,15 @@ def count(self, query=None, limit: tuple = None) -> int:
 
         return count
 
+    def rename(self, new_name: str) -> str:
+        pass
+
+    def drop(self) -> str:
+        pass
+
+
+
+    # ----------------------------------------------------------------#
     def _reset_cursor(self) -> None:
         """
         Reset Cursor Pointer to 0th index

filexdb/database.py

@@ -1,12 +1,12 @@
 from typing import Dict, Type, List
 
 from .collection import Collection
-from .fileio import BinaryFileIO
+from .fileio import BinaryFileIO, JsonFileIO
 
 
 class FileXdb:
 
-    def __init__(self, db_name: str, data_dir: str = None):
+    def __init__(self, db_name: str, data_dir=None, mode="binary"):
         """
         Creates a Databased in ``data_dir`` Directory named ``db_name``.
 
@@ -23,7 +23,10 @@ def __init__(self, db_name: str, data_dir: str = None):
         self._data_dir = data_dir
 
         # Creating an instance of FileIO to Read Write Database-File.
-        self._binary_file = BinaryFileIO(self._db_name, self._data_dir)
+        if mode == "binary":
+            self._file_handler = BinaryFileIO(self._db_name, self._data_dir)
+        elif mode == "json":
+            self._file_handler = JsonFileIO(self._db_name, self._data_dir)
 
     def collection(self, col_name: str) -> Collection:
         """
@@ -35,9 +38,13 @@ def collection(self, col_name: str) -> Collection:
         :return: An instance of Collection Baseclass.
         """
         # Initiating collection
-        collection = Collection(col_name, self._binary_file)
+        collection = Collection(col_name, self._file_handler)
 
         return collection
 
     def show_collections(self):
         pass
+
+
+
+

filexdb/fileio.py

@@ -71,7 +71,7 @@ def write(self, data: dict):
 
 
 class BinaryFileIO(FileIO):
-    def __init__(self, db_name: str, data_dir: str = None):
+    def __init__(self, db_name: str, data_dir=None):
         """
         Create a new instance.
 
@@ -87,7 +87,7 @@ def __init__(self, db_name: str, data_dir: str = None):
 
         self._data_dir = data_dir
 
-        # Adding ``FileXdb`` specific file extention to the Database-file.
+        # Adding ``FileXdb`` specific file extension to the Database-file.
         self._db_name = f"{db_name}.fxdb"
 
         # Setting default Database-file path.
@@ -132,7 +132,7 @@ def read(self) -> dict:
                     raise IOError(f"Cannot read file.\n\t`{self._db_name}` is not a database")
 
             else:
-                # Returns an empty dict as
+                # Initiate an empty dict as
                 database = {}
 
         return database
@@ -167,12 +167,85 @@ def write(self, data: dict) -> None:
 
 
 class JsonFileIO(FileIO):
-    def __init__(self, db_name):
+    def __init__(self, db_name:str, data_dir=None):
+
         super().__init__()
-        self.db_name = db_name
+
+        self._data_dir = data_dir
+
+        # Adding ``JSON`` file extension to the Database-file.
+        self._db_name = f"{db_name}.json"
+
+        # Setting default Database-file path.
+        self._db_file_path = self._db_name
+
+        # Checking if Data Directory is on root or not.
+        if self._data_dir is not None:
+            # Creating Database-file full path by joining data_dir & db_name.
+            self._db_file_path = os.path.join(self._data_dir, self._db_name)
+
+        # Create the Database/File if it doesn't exist
+        create_db(self._db_name, self._data_dir)
 
     def read(self) -> dict:
-        pass
+        """
+        Reads existing Database-file, either it is empty or non-empty.
+
+        If empty returns an empty dict, else returns saved Data.
+
+        :return: Database as a python Dictionary.
+        """
+        database = None
+
+        with open(self._db_file_path, "r") as file:
+
+            # Get the file size by moving the cursor to the file end and reading its location.
+            file.seek(0, os.SEEK_END)
+            size = file.tell()
+
+            # check if size of file is 0
+            if size:
+                # Bring the cursor to the beginning of Database-file
+                file.seek(0)
+
+                try:
+                    # Load whole Database form Database-file
+                    database = json.load(file)
+
+                except io.UnsupportedOperation:
+                    # Through an Unsupported Operation Error.
+                    raise IOError(f"Cannot read file.\n\t`{self._db_name}` is not a database")
+
+            else:
+                # Initiate an empty dict as
+                database = {}
+
+        return database
 
     def write(self, data: dict):
-        pass
+        """
+        Write the current state of entire Database to the Database-file.
+
+        :param data: Dictionary object to write on Database.
+        :return: None.
+        """
+        with open(self._db_file_path, "w") as file:
+
+            # Move the cursor to the beginning of the file just in case.
+            file.seek(0)
+
+            # Serialize the database state using the user-provided arguments
+            serialized = json.dumps(data, indent=4)
+
+            # Write the serialized data to the file
+            try:
+                file.write(serialized)
+            except io.UnsupportedOperation:
+                raise IOError(f"Cannot write to the file.\n\t`{self._db_name}` is not a database")
+
+            # Ensure the file has been written
+            file.flush()
+            os.fsync(file.fileno())
+
+            # Remove data that is behind the new cursor if the file has gotten shorter.
+            file.truncate()