PyRAMObjects 0.1.0__py3-none-any.whl

PyRAM.py

@@ -0,0 +1,623 @@
+from PyRAMErrors import (
+    PyRAMError, ComponentNotInstalledError,
+    DiskAlreadyExistsError, DiskNotFoundError,
+    DiskCreationError, IncorrectSymbolInPath,
+    NoDiskInPath, FolderNotFile, FileNotFound,
+    PathNotFound, NotEnoughRAMError,
+    DiskNotAlreadyExistsError, FolderAlreadyExistsError,
+    FolderNotAlreadyExistsError, ProcessAlreadyExistsError,
+    ProcessNotAlreadyExistsError, WindowsDiskDeleteError,
+    ZeroOrNegativeRAMError, FailedToFormatDisk,
+    WindowsDiskFormatError, ForeignDiskError, InputError,
+    IncorrectDiskName
+)
+from typing import Any
+from pathlib import Path
+import subprocess
+import sys
+import os
+import platform
+from warnings import deprecated
+import warnings
+from dataclasses import dataclass
+import ctypes
+import shutil
+import re
+
+MARKER = ".pyram_owned"
+FILE_READ_ONLY_VOLUME = 0x00080000
+IMDISK_UNIT_MIN, IMDISK_UNIT_MAX = 100, 199
+
+if platform.system() != "Windows":
+    raise RuntimeError("Library only for Windows")
+
+try:
+    import psutil
+    psutil_instaled = True
+except(ImportError, ImportWarning):
+    psutil_instaled = False
+
+try:
+    import winfspy
+    winfspy_installed = True
+except(ImportError, ImportWarning):
+    warnings.warn("Warning: winfspy not installed!\nPls download winfspy on site https://winfsp.dev/ and download library winfspy.", RuntimeWarning)
+    winfspy_installed = False
+
+def _find_imdisk() -> str:
+    exe = shutil.which("imdisk")
+    if exe:
+        return exe
+    for base in (os.environ.get("SystemRoot", r"C:\Windows"),):
+        for sub in ("System32", "Sysnative"):
+            p = os.path.join(base, sub, "imdisk.exe")
+            if os.path.isfile(p):
+                return p
+    raise ComponentNotInstalledError("ImDisk not found. Install ImDisk Toolkit: https://sourceforge.net/projects/imdisk-toolkit/")
+
+class MemoryObject:
+    def __init__(self):
+        self.objects = {}
+
+    def write(self, path, value) -> None:
+        self.objects[path] = value
+
+    def read(self, path) -> Any:
+        try:
+            return self.objects[path]
+        except(KeyError):
+            raise KeyError(f"Object '{path}', not found!")
+
+    def delete(self, path) -> None:
+        del self.objects[path]
+
+    def object_sum(self, path1, path2) -> Any:
+        object1 = self.read(path=path1)
+        object2 = self.read(path=path2)
+
+        try:
+            return object1 + object2
+        except(TypeError):
+            raise TypeError(f"Can not concatenate '{object1}:{type(object1)}' and '{object2}:{type(object2)}'")
+
+    def object_sub(self, path1, path2) -> Any:
+        object1 = self.read(path=path1)
+        object2 = self.read(path=path2)
+
+        try:
+            return object1 - object2
+        except(TypeError):
+            raise TypeError(f"Can not subtract '{object1}:{type(object1)}' and '{object2}:{type(object2)}'")
+
+    def object_div(self, path1, path2) -> int | float | bool | complex:
+        object1 = self.read(path=path1)
+        object2 = self.read(path=path2)
+
+        try:
+            return object1 / object2
+        except(TypeError):
+            raise TypeError(f"Can not divide '{object1}:{type(object1)}' and '{object2}:{type(object2)}'")
+
+    def object_mul(self, path1, path2) -> Any:
+        object1 = self.read(path=path1)
+        object2 = self.read(path=path2)
+
+        try:
+            return object1 * object2
+        except(TypeError):
+            raise TypeError(f"Can not multiply '{object1}:{type(object1)}' and '{object2}:{type(object2)}'")
+
+    def object_equal(self, path1, path2) -> bool:
+        object1 = self.read(path=path1)
+        object2 = self.read(path=path2)
+
+        if object1 == object2:
+            return True
+        elif object1 != object2:
+            return False
+        else:
+            raise RuntimeError(f"Objects cannot be compared, {object1}:{type(object1)} and {object2}:{type(object2)}")
+
+class MemoryPythonFolder:
+    def __init__(self):
+        self.filesystem = {}
+        self.default_disk = "C"
+
+    def write(self, path: str, value=None) -> None:
+        disk = path.split(":")[0]
+
+        if len(disk) > 1:
+            raise NoDiskInPath("Pls enter disk, for example 'C:/example/popato.txt'")
+        
+        path_without_disk = path.split(":")[1]
+        blocked_symbol = {":", ";", ","}
+        clean_path = Path(path)
+        list_of_parts = clean_path.parts
+        # file_name = clean_path.name
+
+        if any(symbol in path_without_disk for symbol in blocked_symbol):
+            raise IncorrectSymbolInPath("Pls do not use ':', ';', ',' in path, for example 'C:/example/popato.txt'")
+
+        current = self.filesystem
+
+        for part in list_of_parts[:-1]:
+            if current == part:
+                current = current[part]
+                continue
+            current = current.setdefault(part, {})
+
+        if list_of_parts[-1] is not None and value is not None:
+            current[list_of_parts[-1]] = value
+        elif list_of_parts[-1] is not None and value is None:
+            current[list_of_parts[-1]] = {}
+
+        return self.filesystem
+
+    def read(self, path: str) -> Any:
+        disk = path.split(":")[0]
+
+        if len(disk) > 1:
+            raise NoDiskInPath("Pls enter disk, for example 'C:/example/popato.txt'")
+        
+        path_without_disk = path.split(":")[1]
+        blocked_symbol = {":", ";", ","}
+        clean_path = Path(path)
+        list_of_parts = clean_path.parts
+
+        if any(symbol in path_without_disk for symbol in blocked_symbol):
+            raise IncorrectSymbolInPath("Pls do not use ':', ';', ',' in path, for example 'C:/example/popato.txt'")
+
+        current = self.filesystem
+
+        for part in list_of_parts:
+            try:
+                current = current[part]
+            except(KeyError):
+                raise FileNotFound(f"File {path} not found")
+
+        return current
+
+    def listdir(self, path: str) -> Any:
+        disk = path.split(":")[0]
+
+        if len(disk) > 1:
+            raise NoDiskInPath("Pls enter disk, for example 'C:/example/popato.txt'")
+        
+        path_without_disk = path.split(":")[1]
+        blocked_symbol = {":", ";", ","}
+        clean_path = Path(path)
+        list_of_parts = clean_path.parts
+
+        if any(symbol in path_without_disk for symbol in blocked_symbol):
+            raise IncorrectSymbolInPath("Pls do not use ':', ';', ',' in path, for example 'C:/example/popato.txt'")
+
+        current = self.filesystem
+
+        for part in list_of_parts:
+            try:
+                current = current[part]
+            except(KeyError):
+                raise FileNotFound(f"File {path} not found")
+
+        if isinstance(current, str):
+            raise FolderNotFile("Path must end by folder, not file!")
+
+        return list(current.keys())
+
+    def delete(self, path: str) -> None:
+        disk = path.split(":")[0]
+
+        if len(disk) > 1:
+            raise NoDiskInPath("Pls enter disk, for example 'C:/example/popato.txt'")
+        
+        path_without_disk = path.split(":")[1]
+        blocked_symbol = {":", ";", ","}
+        clean_path = Path(path)
+        list_of_parts = clean_path.parts
+
+        if any(symbol in path_without_disk for symbol in blocked_symbol):
+            raise IncorrectSymbolInPath("Pls do not use ':', ';', ',' in path, for example 'C:/example/popato.txt'")
+
+        current = self.filesystem
+
+        for part in list_of_parts[:-1]:
+            try:
+                current = current[part]
+            except KeyError:
+                raise PathNotFound(f"Path '{path}' not found")
+
+        try:
+            del current[list_of_parts[-1]]
+        except KeyError:
+            raise FileNotFound(f"File '{path}' not found")
+
+class MemoryStorage:
+    def __init__(self, cleanup_on_exit: bool = False):
+        self.ImDiskPath = _find_imdisk()
+        self._cleanup_on_exit = cleanup_on_exit
+        self.disks = {}
+        self.folders = {}
+        self.process = {}
+
+        for d in self.get_all_drives():
+            drive = d.rstrip("\\")
+            self.disks[drive] = self._unit_by_letter(disk_name=drive)
+
+    def _is_owned(self, drive: str) -> bool:
+        unit = self._unit_by_letter(drive)
+        if unit is None:
+            return False
+        if not (IMDISK_UNIT_MIN <= unit <= IMDISK_UNIT_MAX):
+            return False
+
+        return True
+
+    def _is_admin(self) -> bool:
+        try:
+            return bool(ctypes.windll.shell32.IsUserAnAdmin())
+        except Exception:
+            return False
+
+    def check_disk_formatted(self, disk_name: str) -> bool:
+        if psutil_instaled == False:
+            raise ComponentNotInstalledError("Psutil not installed, please do it")
+
+        disk_name = self._normalizate_disk_name(disk_name)
+
+        partitions = psutil.disk_partitions(all=True)
+        
+        for p in partitions:
+            if p.device.startswith(disk_name) or p.mountpoint.startswith(disk_name):
+                if p.fstype and p.fstype.upper() != 'RAW':
+                    return True
+                else:
+                    return False
+                    
+        return False
+
+    def _normalizate_disk_name(self, name: str) -> str:
+        if not isinstance(name, str):
+            raise InputError("Disk name must be string!")
+
+        name = name.upper()
+
+        if not name.endswith(":"):
+            name += ":"
+
+        return name
+
+    def _formatdr(self, disk_name: str) -> bool:
+        success = re.fullmatch(r"[A-Z]:?", disk_name) and len(disk_name) == 2
+        return bool(success)
+
+    def _imdisk(self, *args, timeout=60) -> subprocess.CompletedProcess[str]:
+        exe = self.ImDiskPath
+        r = subprocess.run([exe, *args], capture_output=True, text=True, timeout=timeout)
+        return r
+
+    def get_all_drives(self) -> list:
+        drives = os.listdrives()
+        return drives
+
+    def get_windows_disk(self) -> str:
+        return os.environ.get('SystemDrive')
+
+    def get_disk_info(self, disk_name: str) -> dict:
+        disk_name = self._normalizate_disk_name(name=disk_name)
+
+        owner = None
+        is_formatted = None
+        total_bytes = None
+        used_bytes = None
+        free_bytes = None
+        used_perstange = None
+        partitions = None
+        fs_type = None
+        mountpoint = None
+        opts = None
+
+        try:
+            disk_value = self.disks[disk_name]
+        except(KeyError):
+            raise DiskNotAlreadyExistsError(f"Disk: '{disk_name.rstrip(":")}' not already exists")
+
+        if self.get_windows_disk() == disk_name:
+            owner = "System"
+        elif isinstance(disk_value, subprocess.Popen) or self._is_owned(drive=disk_name):
+            owner = "PyRAM"
+        else:
+            owner = "Unknown"
+
+        is_formatted = self.check_disk_formatted(disk_name=disk_name)
+        
+        if is_formatted and psutil_instaled:
+            try:
+                usage = psutil.disk_usage(disk_name)
+
+                total_bytes = usage.total
+                used_bytes = usage.used
+                free_bytes = usage.free
+                used_perstange = usage.percent
+            except:
+                pass
+
+        elif not psutil_instaled:
+            warnings.warn("Psutil not installed, some data may be unavailable")
+
+        if psutil_instaled:
+            partitions = psutil.disk_partitions(all=True)
+
+            for p in partitions:
+                if p.device.upper().rstrip(r"\\") == disk_name:
+                    try:
+                        fs_type = p.fstype
+                        mountpoint = p.mountpoint
+                        opts = p.opts
+                    except:
+                        pass
+
+        return DiskInfo(drive=disk_name, owner=owner,is_formatted=is_formatted, drive_opts=opts, fs=fs_type, label=self.get_drive_label(drive_letter=disk_name), 
+                        total_bytes=total_bytes, used_bytes=used_bytes, free_bytes=free_bytes, used_percent=used_perstange,
+                        readonly=self.is_drive_readonly(drive_letter=disk_name), mountpoint=mountpoint)
+
+    def get_drive_label(self, drive_letter: str) -> str:
+        path = f"{drive_letter.rstrip('\\').rstrip(':')}:\\"
+        
+        volume_name_buffer = ctypes.create_unicode_buffer(260)
+        
+        success = ctypes.windll.kernel32.GetVolumeInformationW(
+            path,
+            volume_name_buffer,
+            len(volume_name_buffer),
+            None, None, None, None, 0
+        )
+        
+        if success:
+            return volume_name_buffer.value or "Local disk"
+        else:
+            return "Unknown disk"
+
+    def is_drive_readonly(self, drive_letter: str) -> bool:
+        path = f"{drive_letter.rstrip('\\').rstrip(':')}:\\"
+        
+        flags = ctypes.c_ulong(0)
+        
+        success = ctypes.windll.kernel32.GetVolumeInformationW(
+            path, None, 0, None, None, ctypes.byref(flags), None, 0
+        )
+        
+        if success:
+            return bool(flags.value & FILE_READ_ONLY_VOLUME)
+        else:
+            return None
+
+    def _imdisk_units(self) -> list[int]:
+        r = self._imdisk("-l")
+        return [int(n) for n in re.findall(r"ImDisk(\d+)", r.stdout)]
+
+    def _free_unit(self) -> int:
+        used = set(self._imdisk_units())
+        for u in range(IMDISK_UNIT_MIN, IMDISK_UNIT_MAX + 1):
+            if u not in used:
+                return u
+        raise PyRAMError("No free ImDisk units in PyRAM range")
+
+    def _unit_by_letter(self, disk_name: str) -> int | None:
+        target = self._normalizate_disk_name(disk_name)
+        for u in self._imdisk_units():
+            if self._letter_by_unit(u) == target:
+                return u
+        return None
+
+    def _letter_by_unit(self, unit: int) -> str | None:
+        r = self._imdisk("-l", "-u", str(unit))
+        m = re.search(r"^Drive letter:\s*([A-Za-z])\s*$", r.stdout, re.MULTILINE)
+        return m.group(1).upper() + ":" if m else None
+
+    def create_disk_imdisk(self, disk_name: str = "Z:", memory_mb_size: int = 2048, file_system: str = "ntfs") -> bool:
+        disk_name = self._normalizate_disk_name(disk_name)
+
+        if self._formatdr(disk_name=disk_name) == False:
+            raise IncorrectDiskName(f"Disk name not correct: '{disk_name}'")
+
+        if disk_name in self.disks:
+            raise DiskAlreadyExistsError(f"Disk: '{disk_name.rstrip(":")}' already exists")
+
+        if psutil_instaled == True:
+            bytes_val = psutil.virtual_memory().total
+            mb_val = bytes_val / (1024 ** 2)
+
+            if memory_mb_size > mb_val:
+                raise NotEnoughRAMError("You cannot specify more RAM than you actually have!")
+
+        elif psutil_instaled == False:
+            warnings.warn("Psutil not installed, can not check RAM restrictions", RuntimeWarning)
+
+        if memory_mb_size <= 0:
+            raise ZeroOrNegativeRAMError(f"RAM is zero or negative: '{memory_mb_size}'")
+
+        unit = self._free_unit()
+        r = self._imdisk(
+            "-a",
+            "-u", str(unit),
+            "-s", f"{memory_mb_size}M",
+            "-m", disk_name,
+            "-p", f"/fs:{file_system} /q /y /v:PyRAM",
+        )
+
+        if r.returncode != 0:
+            raise PyRAMError(f"imdisk failed ({r.returncode}): {r.stderr or r.stdout}")
+
+        self.disks[disk_name] = unit 
+
+        if not self.format_imdisk(disk_name, file_system):
+            warnings.warn(f"Failed to format RAM disk '{disk_name.rstrip(":")}'\nYou need to run the process as an administrator.", RuntimeWarning)
+
+        return True
+
+    def remove_disk_imdisk(self, disk_name: str, force: bool = True) -> bool:
+        disk_name = self._normalizate_disk_name(disk_name)
+
+        if self._formatdr(disk_name=disk_name) == False:
+            raise IncorrectDiskName(f"Disk name not correct: '{disk_name}'")
+
+        sys_drive = self.get_windows_disk()
+
+        if sys_drive == disk_name:
+            raise WindowsDiskDeleteError("You can not delete main Windows disk")
+
+        unit = self._unit_by_letter(disk_name)
+        if unit is None:
+            raise DiskNotAlreadyExistsError(f"Disk '{disk_name.rstrip(":")}' not found in ImDisk")
+        if not (IMDISK_UNIT_MIN <= unit <= IMDISK_UNIT_MAX):
+            raise ForeignDiskError(f"Disk '{disk_name.rstrip(":")}' was not created by PyRAM")
+
+        r = self._imdisk("-D" if force else "-d", "-u", str(unit))
+        if r.returncode != 0:
+            raise PyRAMError(f"imdisk failed ({r.returncode}): {r.stderr or r.stdout}")
+
+        self.disks.pop(disk_name, None)
+
+        return True
+
+    def format_imdisk(self, disk_name: str, file_system: str = "NTFS") -> bool:
+        disk_name = self._normalizate_disk_name(disk_name)
+
+        if self._formatdr(disk_name=disk_name) == False:
+            raise IncorrectDiskName(f"Disk name not correct: '{disk_name}'")
+
+        if disk_name == self.get_windows_disk():
+            raise WindowsDiskFormatError("You can not format main Windows disk")
+
+        fs = file_system.upper()
+        if fs not in {"NTFS", "FAT32", "EXFAT"}:
+            raise ValueError("Unsupported file system")
+
+        unit = self._unit_by_letter(disk_name)
+        if unit is None:
+            raise DiskNotAlreadyExistsError(f"Disk {disk_name.rstrip(':')} not found in ImDisk")
+        if not (IMDISK_UNIT_MIN <= unit <= IMDISK_UNIT_MAX):
+            raise ForeignDiskError(f"Disk {disk_name.rstrip(':')} was not created by PyRAM")
+
+        r = subprocess.run(
+            ["format.com", disk_name, f"/FS:{fs}", "/Q", "/Y", "/V:PyRAM"],
+            capture_output=True, text=True, timeout=60,
+        )
+        if r.returncode != 0:
+            self._imdisk("-D", "-u", str(unit))
+            raise PyRAMError(f"format failed ({r.returncode}): {r.stdout or r.stderr}")
+
+        return True
+
+    def get_all_disks(self) -> dict:
+        return self.disks
+
+    def get_all_folders(self) -> dict:
+        return self.folders
+
+    def get_all_processes(self) -> dict:
+        return self.process
+
+    @deprecated("Experimental method, not stable. Please use ramdisk methods")
+    def create_disk_winfspy(self, disk_name: str = "Z:") -> subprocess.Popen:
+        if winfspy_installed == False:
+            raise ComponentNotInstalledError("winfspy not installed!")
+
+        if disk_name in self.disks:
+            raise DiskAlreadyExistsError(f"Disk: '{disk_name.rstrip(":")}' already exists")
+
+        process = subprocess.Popen([
+            sys.executable,
+            "-m", "winfspy.memfs",
+            disk_name,
+        ])
+
+        self.process[disk_name] = process
+
+        return process
+
+    @deprecated("Experimental method, not stable. Please use ramdisk methods")
+    def create_folder_winfspy(self, path: str) -> subprocess.Popen:
+        if winfspy_installed == False:
+            raise ComponentNotInstalledError("winfspy not installed!")
+
+        clead_path = Path(path)
+
+        if clead_path in self.folders:
+            raise FolderAlreadyExistsError(f"Folder: {path} already exists")
+
+        process = subprocess.Popen([
+            sys.executable,
+            "-m", "winfspy.memfs",
+            clead_path,
+        ])
+
+        self.process[clead_path] = process
+
+        return process
+
+    @deprecated("Experimental method, not stable. Please use ramdisk methods")
+    def remove_storage_winfspy(self, pointer: str) -> bool:
+        if len(pointer) <= 2:
+            pointer = self._normalizate_disk_name(pointer)
+
+        if winfspy_installed == False:
+            raise ComponentNotInstalledError("winfspy not installed!")
+
+        if pointer not in self.disks and pointer not in self.folders:
+            raise ProcessNotAlreadyExistsError(f"Process: {pointer.rstrip(":")} not already exists")
+
+        process: subprocess.Popen = self.process.get(pointer)
+
+        if process is None:
+            return False
+
+        process.terminate()
+        try:
+            process.wait(timeout=5)
+        except subprocess.TimeoutExpired:
+            process.kill()
+
+        if len(pointer) >= 2:
+            del self.folders[pointer]
+        else:
+            del self.disks[pointer]
+
+    def _owned_disks(self) -> list[str]:
+        result = []
+        for u in self._imdisk_units():
+            if IMDISK_UNIT_MIN <= u <= IMDISK_UNIT_MAX:
+                letter = self._letter_by_unit(u)
+                if letter:
+                    result.append(letter)
+        return result
+
+    def close(self, force: bool = False) -> None:
+        for drive in self._owned_disks():
+            try:
+                self.remove_disk_imdisk(drive, force=force)
+            except PyRAMError as e:
+                warnings.warn(f"Could not remove {drive}: {e}", RuntimeWarning)
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc, tb):
+        if self._cleanup_on_exit:
+            self.close(force=True)
+        return False
+
+@dataclass(frozen=True)
+class DiskInfo:
+    drive: str
+    owner: str
+    is_formatted: bool
+    drive_opts: str | None
+    fs: str | None
+    label: str | None
+    total_bytes: int | None
+    used_bytes: int | None
+    free_bytes: int | None
+    used_percent: float | None
+    readonly: bool | None
+    mountpoint: str | None

PyRAMErrors.py

@@ -0,0 +1,68 @@
+class PyRAMError(Exception):
+    """A fundamental error in the PyRAM library."""
+
+class ComponentNotInstalledError(PyRAMError):
+    """A required component is not installed."""
+
+class DiskAlreadyExistsError(PyRAMError):
+    """Disk already exists."""
+
+class DiskNotFoundError(PyRAMError):
+    """Disk not found."""
+
+class DiskCreationError(PyRAMError):
+    """Failed to create disk."""
+
+class IncorrectSymbolInPath(PyRAMError):
+    """Character error in the path."""
+
+class NoDiskInPath(PyRAMError):
+    """No disk in the path."""
+
+class FileNotFound(PyRAMError):
+    """File not found."""
+
+class FolderNotFile(PyRAMError):
+    """A folder, not a file."""
+
+class PathNotFound(PyRAMError):
+    """Path not found."""
+
+class NotEnoughRAMError(PyRAMError):
+    """Not enough RAM."""
+
+class DiskNotAlreadyExistsError(PyRAMError):
+    """Disk does not exist."""
+
+class FolderAlreadyExistsError(PyRAMError):
+    """Folder already exists."""
+
+class FolderNotAlreadyExistsError(PyRAMError):
+    """Folder does not exist."""
+
+class ProcessAlreadyExistsError(PyRAMError):
+    """Process already exists."""
+
+class ProcessNotAlreadyExistsError(PyRAMError):
+    """Process does not exist."""
+
+class WindowsDiskDeleteError(PyRAMError):
+    """Windows disk deletion error"""
+
+class WindowsDiskFormatError(PyRAMError):
+    """Windows disk formattion error"""
+
+class ZeroOrNegativeRAMError(PyRAMError):
+    """Zero or negative RAM."""
+
+class FailedToFormatDisk(PyRAMError):
+    """Disk formatting error"""
+
+class ForeignDiskError(PyRAMError):
+    """Not PyRAM created"""
+
+class InputError(PyRAMError):
+    """incorrect answer"""
+
+class IncorrectDiskName(PyRAMError):
+    """Incorrect disk name"""

pyramobjects-0.1.0.dist-info/METADATA

@@ -0,0 +1,133 @@
+Metadata-Version: 2.4
+Name: PyRAMObjects
+Version: 0.1.0
+Summary: Safe Python API for ImDisk RAM disks on Windows plus in-memory objects
+Author: lolololox
+License: MIT
+Keywords: ramdisk,imdisk,windows,in-memory
+Classifier: Development Status :: 3 - Alpha
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Programming Language :: Python :: 3.13
+Requires-Python: >=3.13
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: psutil>=5.9
+Dynamic: license-file
+
+# PyRAM
+
+A Python library for managing RAM disks on Windows. Based on ImDisk with RamDisk and WinFs with WinFsPy.
+Project target it is:
+
+1. Create more simple API than original library
+2. Do more stable than original library
+3. Give additional functional than original library
+
+> [!CAUTION]
+> **IMPORTANT:**
+>
+> 1. Early version of the library, bugs are possible
+> 2. Disks may be removed with a delay
+> 3. API can changes every update, please check actual documentation
+> 4. Administrator privileges are required for the library to function properly
+> 5. ONLY Windows
+> 6. PyRAM only manages disks it created (ImDisk units 100-199) and refuses to touch others.
+
+## Features
+
+- Create RAM disks.
+- Remove RAM disks.
+- Track disks managed by a `MemoryStorage` instance.
+- Simple API with minimal setup.
+- Format RAM disks
+- Virtual in-memory file system
+
+## Requirements
+
+- Windows
+- Python
+- ImDisk
+- WinFs(Not strictly required, but necessary for the library to additional function)
+- WinFsPy(Not strictly required, but necessary for the library to additional features)
+- Python 3.12 and higer
+
+RAM disk operations may require administrator privileges.
+
+## Installation
+
+Install ImDisk and the required Python dependencies before using PyRAM.
+In short time meybe you can install PyRAM from PaPi(Pip install PyRAMObjects)
+
+## Quick Start
+
+```python
+from PyRAM import MemoryStorage
+
+storage = MemoryStorage()
+
+# Create disk without parameters
+storage.create_disk_ramdisk() # uses default parameters disk_name = "Z:", memory_mb_size = 2048, file_system = "ntfs"
+
+# Create a 512 MB RAM disk
+storage.create_disk_ramdisk(
+    disk_name="X:",
+    memory_mb_size=512,
+    file_system = "ntfs"
+)
+
+# Remove the RAM disk
+storage.remove_disk_ramdisk(disk_name="X:")
+
+with MemoryStorage(cleanup_on_exit=True) as storage1: # cleaning all PyRAM disks when app closing, becouse cleanup_on_exit=True
+    storage1.create_disk_imdisk(disk_name="K:", memory_mb_size=512)
+```
+
+## Usage Notes
+
+- RAM disks use volatile memory. Data stored on them should be considered temporary.
+- A drive letter must be available when creating a RAM disk.
+- Creating, formatting, or removing a RAM disk may require elevated permissions.
+- The library's disk registry tracks disks managed by the current `MemoryStorage` instance.
+
+## License
+
+MIT
+
+## Documentation
+
+- classes
+
+1. MemoryObject. Just dict with dicts
+2. MemoryPythonFolder. Virtual file system, where you can save only string data types
+3. MemoryStorage. Class where access create folders(experimental only WinFsPy) and disks in ram and see it in explorer
+4. DiskInfo. Just dataclass, has no methods
+
+### MemoryObject methods
+
+1. write. Save value
+2. read. Get value
+3. delete. delete value
+4. object_sum/object_sub/object_div/object_mul/object_equal. Operations with objects
+
+### MemoryPythonFolder methods
+
+1. write. Save value
+2. read. Get value
+3. listdir. Get list of folders
+4. delete. Delete value
+
+### MemoryStorage methods
+
+1. get_all_drives. Get all drives
+2. remove_disk_imdisk. Create disk in RAM using ImDisk
+3. remove_disk_imdisk. Delete disk, that created using ImDisk
+4. format_ramdisk. Format disk
+5. get_all_disks/get_all_folders/get_all_processes. Get all disks/folders/processes
+6. create_disk_winfspy. Create disk in RAM using WinFsPy
+7. create_folder_winfspy. Create folder in RAM using WinFsPy
+8. remove_storage_winfspy. Remove storage, that created using WinFsPy
+9. get_windows_disk. Get Windows disk
+10. check_disk_formatted. Check disk formatted or not
+11. get_drive_label. Get disk label
+12. is_drive_readonly. Check disk read-only or not
+13. get_disk_info. Get info about disk

pyramobjects-0.1.0.dist-info/RECORD

@@ -0,0 +1,7 @@
+PyRAM.py,sha256=QffA21icHcDKqLhqNCPHbgI9H_pC5MRiusVvJbqUtvE,21720
+PyRAMErrors.py,sha256=1mm3sr5El-pnpRJEelaqqDWeuLJAD8kVw_Hei6C6JMs,1745
+pyramobjects-0.1.0.dist-info/licenses/LICENSE,sha256=NGSda9nG6kWtoYMffS-hwJx92ADfBIm2-__O30Vw3aw,1109
+pyramobjects-0.1.0.dist-info/METADATA,sha256=ga2y4HJbIEkjDhuzUuFulLSuSkvFeOVR2Vh93Ux29XQ,4258
+pyramobjects-0.1.0.dist-info/WHEEL,sha256=mOdXR9C3wMVov7cSY8PY-XCzo3SmmWCHvGQr5csJoao,91
+pyramobjects-0.1.0.dist-info/top_level.txt,sha256=4MvBKbML7j0d0jNmPgd8tqR17pUbaHeVSXyitjyvzjY,18
+pyramobjects-0.1.0.dist-info/RECORD,,

pyramobjects-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.2.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

pyramobjects-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,20 @@
+<!-- markdownlint-disable MD041 -->
+Copyright (c) 2026 lolololox
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

pyramobjects-0.1.0.dist-info/top_level.txt

@@ -0,0 +1,2 @@
+PyRAM
+PyRAMErrors