Metadata-Version: 2.1
Name: mgtdisklib
Version: 0.5.2
Summary: Disk manipulation for SAM Coupé and MGT +D disks images
Home-page: https://github.com/simonowen/mgtdisklib
Author: Simon Owen
Author-email: simon@simonowen.com
License: MIT
Description: # mgtdisklib
        
        A Python library to give file-level access to the contents of SAM Coupé and MGT +D disk images.
        
        NOTE: the library is currently a work in progress and the API is still subject to change.
        
        Homepage: https://github.com/simonowen/mgtdisklib  
        Module: https://pypi.org/project/mgtdisklib/
        
        [![CI](https://github.com/simonowen/mgtdisklib/actions/workflows/main.yml/badge.svg)](https://github.com/simonowen/mgtdisklib/actions/workflows/main.yml)
        
        ----
        
        ## Using the library
        
        ### Installing the module
        
        ```
        pip -m install mgtdisklib
        ```
        
        ### Importing the module
        
        ```python
        from mgtdisklib import Disk, Image, File
        ```
        
        ### Opening a disk image:
        
        ```python
        disk = Disk.open('image.mgt')
        ```
        
        MGT/SAD/EDSK container files are supported, but only those containing a regular 80/2/10/512 or 80/2/9/512 format. The image file may be optionally compressed with gzip.
        
        ### Saving the Disk contents to a new MGT image file
        
        ```python
        disk.save('image2.mgt')
        ```
        
        ----
        
        ## Disk
        
        Represents a logical SAM disk plus all its contents.
        
        ### Class Functions
        
        ```python
            def open(path: str) -> Disk:
                """Load disk from disk image file"""
            def from_image(image: Image) -> Disk:
                """Construct a Disk object from a disk image"""
        ```
        
        ### Instance Functions
        
        ```python
            def save(self, path: str, *, compressed: bool = False, spt: int = 10) -> None:
                """Save disk content to disk image"""
            def to_image(self, *, spt: int = 10) -> Image:
                """Generate MGT disk image from current contents"""
            def add_code_file(self, path: str, *, filename: str = None, at_index: int = None) -> None:
                """Add CODE file from path"""
            def delete(self, pattern: str) -> int:
                """Delete files matching filename pattern"""
            def bam(self) -> bitarray:
                """Combined Bitmap Address Map for all files"""
            def dir(self, *, spt: int = 10) -> None:
                """Display directory listing"""
        ```
        
        ### Instance Variables
        
         - `type` - detected type: `DiskType.SAMDOS` (default), `DiskType.MASTERDOS` or `DiskType.BDOS`.
         - `files` - list of `File` objects in directory order.
         - `dir_tracks` - number of directory tracks (usually 4).
         - `label` - disk volume label string, or None.
         - `serial` - MasterDOS unique disk number, or None.
         - `compressed` - _True_ if the source disk was gzipped.
        
        ----
        
        ## File
        
        ### Types
        
        `FileType` is one of the following values:
        
        ```python
        FileType.NONE           # unused or deleted entry
        FileType.ZX_BASIC       # ZX Spectrum BASIC
        FileType.ZX_DATA        # ZX Spectrum numeric array
        FileType.ZX_DATA_STR    # ZX Spectum string array
        FileType.ZX_CODE        # ZX Spectrum code
        FileType.ZX_SNP_48K     # ZX Spectrum 48K snapshot
        FileType.ZX_MDRV        # ZX Spectrum microdrive file
        FileType.ZX_SCREEN      # ZX Spectrum SCREEN$
        FileType.SPECIAL        # Custom file entry
        FileType.ZX_SNP_128K    # ZX Spectrum 128K snapshot
        FileType.OPENTYPE       # ZX/SAM file stream
        FileType.ZX_EXECUTE     # ZX interface executable
        FileType.UNIDOS_DIR
        FileType.UNIDOS_CREATE  
        FileType.BASIC          # SAM Coupé BASIC
        FileType.DATA           # SAM Coupé numeric array
        FileType.DATA_STR       # SAM Coupé string array
        FileType.CODE           # SAM Coupé code
        FileType.SCREEN         # SAM Coupé SCREEN (mode 1-4)
        FileType.DIR            # SAM Coupé MasterDOS directory
        FileType.DRIVER_APP     # Driver application
        FileType.DRIVER_BOOT    # Driver boot file
        FileType.EDOS_NOMEN     # Entropy IDE DOS (abandoned)
        FileType.EDOS_SYSTEM
        FileType.EDOS_OVERLAY
        FileType.HDOS_DOS       # SD IDE DOS
        FileType.HDOS_DIR
        FileType.HDOS_DISK
        FileType.HDOS_TEMP
        ```
        
        ### Class Functions
        ```python
            def from_code_path(path: str, *, filename: str = None, start: int = 0x8000, execute: int = None) -> File:
                """Create CODE file from path"""
            def from_code_bytes(data: bytes, filename: str, *, start: int = 0x8000, execute: int = None) -> File:
                """Create CODE file from bytes"""
            def from_dir(data: bytes) -> File:
                """Create from 256-byte directory entry data"""
            def from_path(path: str) -> File:
                """Import file entry exported using save()"""
        ```
        
        ### Instance Functions
        ```python
            def save(self, path: str) -> None:
                """Export directory entry and file content for later"""
            def to_dir(self, start_track: int = 4, start_sector: int = 1, *, spt: int = 10) -> bytes:
                """Create directory entry from current file data"""
            def is_bootable(self) -> bool:
                """Check whether the file would be bootable in the first directory slot"""
        ```
        ### Instance Variables
        
        - `type` - FileType (see above) [read-only]
        - `hidden` - True if file is hidden from SAM directory listing
        - `protected` - True is file is protected from deletion
        - `name` - file name in ASCII without trailing spaces
        - `name_raw` - original 10-byte name, which could contain special characters
        - `sectors` - count of data sectors used (from sector bitmap) [read-only]
        - `start_track` - first track of file data [read-only]
        - `start_sector` - first sector of file data [read-only]
        - `sector_map` - bitarray of sectors used by this file (starting track 4 sector 1) [read-only]
        - `start` - file start address
        - `length` - file length
        - `execute` - auto-execute line/address, or None
        - `time` - file time or None
        - `data_var` - variable name for numeric/string DATA types [read-only]
        - `entry` - original 256-byte directory entry
        - `data` - raw file data, including 9-byte header and final sector padding
        
        Some properties are read-only, reflecting the state as read from disk. Some of
        them (including `start_track`, `start_sector` and `sector_map`) will be updated
        as needed when a disk image is created containing them.
        
        ----
        
        ## Image
        
        Represents a disk image container in MGT/SAD/EDSK format.
        
        ### Class Functions
        
        ```python
            def open(path):
                """Create Image object from disk image file"""
        ```
        
        Creating an `Image()` object will give a standard 80/2/10/512 MGT disk image.
        
        ### Instance Functions
        
        ```python
            def save(self, path: str, *, compressed: bool = False) -> None:
                """Save disk data to image file"""
            def read_sector(self, track: int, sector: int) -> bytes:
                """Read sector data for given sector location"""
            def write_sector(self, track: int, sector: int, data: bytes) -> None:
                """Write sector data to given sector location"""
            def sector_offset(self, track: int, sector: int) -> int:
                """Calculate sector data offset in image data"""
        ```
        
        MGT tracks are numbered are 0-79 for the first side and 128-207 for the second.
        Sectors are numbered 1-10 for normal format disks, each being 512 bytes.
        
        The first 4 tracks of the first side contain the disk directory, and the
        remainder of the disk holds data. The second side of the disk is only used once
        the first side is full. Track 4 sector 1 holds the boot sector.
        
        ### Instance Variables
        
        - `path` - full path of the disk image.
        - `spt` - sectors per track, usually 10.
        - `compressed` - _True_ if the source image was gzipped.
        - `data` - raw disk data from image file.
        
        ----
        
Keywords: mgt disk sam coupe
Platform: UNKNOWN
Classifier: Development Status :: 3 - Alpha
Classifier: Intended Audience :: Developers
Classifier: Topic :: System :: Emulators
Classifier: Programming Language :: Python :: 3.6
Classifier: License :: OSI Approved :: MIT License
Description-Content-Type: text/markdown
