diskstack 1.0.0__py3-none-any.whl

diskstack/_vendor/greaseweazle/image/image.py

@@ -0,0 +1,130 @@
+# greaseweazle/image/image.py
+#
+# Written & released by Keir Fraser <keir.xen@gmail.com>
+#
+# This is free and unencumbered software released into the public domain.
+# See the file COPYING for more details, or visit <http://unlicense.org>.
+
+from __future__ import annotations
+from typing import Optional, List, Dict
+
+import os
+
+from diskstack._vendor.greaseweazle import error
+from diskstack._vendor.greaseweazle.codec import codec
+from diskstack._vendor.greaseweazle.flux import HasFlux
+
+OptDict = Dict[str,str]
+
+class ImageOpts:
+    r_settings: List[str] = [] # r_set()
+    w_settings: List[str] = [] # w_set()
+    a_settings: List[str] = [] # r_set(), w_set()
+
+    def _set(self, filename: str, opt: str, val: str,
+             settings: List[str]) -> None:
+        error.check(opt in settings,
+                    "%s: Invalid file option: %s\n" % (filename, opt)
+                    + 'Valid options: '
+                    + (', '.join(settings) if settings else '<none>'))
+        setattr(self, opt, val)
+
+    def r_set(self, filename: str, opt: str, val: str) -> None:
+        self._set(filename, opt, val, self.a_settings + self.r_settings)
+
+    def w_set(self, filename: str, opt: str, val: str) -> None:
+        self._set(filename, opt, val, self.a_settings + self.w_settings)
+
+class Image:
+
+    filename: str
+    noclobber = False
+    default_format: Optional[str] = None
+    read_only = False
+    write_on_ctrl_c = False
+    opts = ImageOpts() # empty
+
+    def __init__(self, name: str, fmt) -> None:
+        raise NotImplementedError
+
+    def apply_r_opts(self, opts: OptDict) -> None:
+        for opt, val in opts.items():
+            self.opts.r_set(self.filename, opt, val)
+    
+    def apply_w_opts(self, opts: OptDict) -> None:
+        for opt, val in opts.items():
+            self.opts.w_set(self.filename, opt, val)
+    
+    ## Context manager for image objects created using .to_file()
+
+    def __enter__(self) -> Image:
+        self.file = open(self.filename, ('wb','xb')[self.noclobber])
+        return self
+
+    def __exit__(self, type, value, tb):
+        save = (type is None or
+                (type is KeyboardInterrupt and self.write_on_ctrl_c))
+        try:
+            if save:
+                # No error: Normal writeout.
+                self.file.write(self.get_image())
+        finally:
+            # Always close the file.
+            self.file.close()
+        if not save:
+            # An error occurred: We remove the target file.
+            os.remove(self.filename)
+
+    ## Default .to_file() constructor
+    @classmethod
+    def to_file(cls, name: str, fmt: Optional[codec.DiskDef],
+                noclobber: bool, opts: OptDict) -> Image:
+        error.check(not cls.read_only,
+                    "%s: Cannot create %s image files" % (name, cls.__name__))
+        obj = cls(name, fmt)
+        obj.noclobber = noclobber
+        obj.apply_w_opts(opts)
+        return obj
+
+    ## Default .from_file() constructor
+    @classmethod
+    def from_file(cls, name: str, fmt: Optional[codec.DiskDef],
+                  opts: OptDict) -> Image:
+        obj = cls(name, fmt)
+        obj.apply_r_opts(opts)
+        with open(name, "rb") as f:
+            obj.from_bytes(f.read())
+        return obj
+
+    ## Used by default .from_file constructor
+    def from_bytes(self, dat: bytes) -> None:
+        raise NotImplementedError
+
+    # Maximum non-empty cylinder on each head, or -1 if no cylinders exist.
+    # Returns a list of integers, indexed by head.
+    def max_cylinder(self):
+        r = list()
+        for h in range(2):
+            for c in range(100, -2, -1):
+                if c < 0 or self.get_track(c,h) is not None:
+                    r.append(c)
+                    break
+        return r
+
+    ## Above methods and class variables can be overridden by subclasses.
+    ## Additionally, subclasses must provide following public interfaces:
+
+    def get_track(self, cyl: int, side: int) -> Optional[HasFlux]:
+        raise NotImplementedError
+
+    ## Write support (if not cls.read_only):
+    def emit_track(self, cyl: int, side: int, track: HasFlux):
+        raise NotImplementedError
+    ## Plus get_image, or __enter__ / __exit__
+    def get_image(self) -> bytes:
+        raise NotImplementedError
+
+
+# Local variables:
+# python-indent: 4
+# End:

diskstack/_vendor/greaseweazle/image/imd.py

@@ -0,0 +1,201 @@
+# greaseweazle/image/imd.py
+#
+# Written & released by Keir Fraser <keir.xen@gmail.com>
+# 
+# This is free and unencumbered software released into the public domain.
+# See the file COPYING for more details, or visit <http://unlicense.org>.
+
+from typing import Dict, Tuple, Optional
+
+import datetime, struct
+
+from diskstack._vendor.greaseweazle import __version__
+from diskstack._vendor.greaseweazle import error
+from diskstack._vendor.greaseweazle.codec.ibm import ibm
+from .image import Image
+
+class IMDMode:
+    FM_500kbps = 0
+    FM_300kbps = 1
+    FM_250kbps = 2
+    MFM_500kbps = 3
+    MFM_300kbps = 4
+    MFM_250kbps = 5
+
+class IMD(Image):
+
+    def __init__(self, name: str, _fmt):
+        self.to_track: Dict[Tuple[int,int],ibm.IBMTrack_Fixed] = dict()
+        self.filename = name
+
+
+    def from_bytes(self, dat: bytes) -> None:
+
+        # Check and strip the header
+        sig, = struct.unpack('4s', dat[:4])
+        error.check(sig == b'IMD ', 'Unrecognised IMD file: bad signature')
+        for i,x in enumerate(dat):
+            if x == 0x1a:
+                break
+        error.check(x == 0x1a, 'IMD: No comment terminator found')
+
+        # We will adjust this as we go
+        rpm = 300
+
+        i += 1
+        while i < len(dat)-5:
+            mode, cyl, head, nsec, sec_n = struct.unpack('5B', dat[i:i+5])
+            i += 5
+            error.check(0 <= sec_n <= 6, 'IMD: Bad sector size %x' % sec_n)
+            secsz = 128 << sec_n
+
+            has_cyl_map = (head & 0x80) != 0
+            has_head_map = (head & 0x40) != 0
+            head &= 0x3f
+            error.check(0 <= head <= 1, 'IMD: Bad head value %x' % head)
+
+            if mode == IMDMode.FM_250kbps or mode == IMDMode.FM_300kbps:
+                fmt = ibm.IBMTrack_FixedDef('ibm.fm')
+                fmt.rate = 125
+            elif mode == IMDMode.FM_500kbps:
+                fmt = ibm.IBMTrack_FixedDef('ibm.fm')
+                if nsec == 26: rpm = 360 # 8-inch disk
+                fmt.rate = 250
+            elif mode == IMDMode.MFM_250kbps or mode == IMDMode.MFM_300kbps:
+                fmt = ibm.IBMTrack_FixedDef('ibm.mfm')
+                fmt.rate = 250
+            elif mode == IMDMode.MFM_500kbps:
+                fmt = ibm.IBMTrack_FixedDef('ibm.mfm')
+                if nsec == 26: rpm = 360 # 8-inch disk
+                fmt.rate = 500
+            else:
+                raise error.Fatal('IMD: Unrecognised track mode %x' % mode)
+
+            fmt.rpm = rpm
+            fmt.secs, fmt.sz = nsec, [sec_n]
+            fmt.finalise()
+            t = fmt.mk_track(cyl, head)
+
+            rmap = dat[i:i+nsec]
+            i += nsec
+            if has_cyl_map:
+                cmap = dat[i:i+nsec]
+                i += nsec
+            if has_head_map:
+                hmap = dat[i:i+nsec]
+                i += nsec
+
+            for nr,s in enumerate(t.sectors):
+                s.crc = s.idam.crc = s.dam.crc = 0
+                s.idam.r = rmap[nr]
+                if has_cyl_map:
+                    s.idam.c = cmap[nr]
+                if has_head_map:
+                    s.idam.h = hmap[nr]
+                rec = dat[i]
+                i += 1
+                error.check(0 <= rec <= 8,
+                            'IMD: Unexpected sector code %x' % rec)
+                if rec == 0:
+                    s.crc = s.dam.crc = 0xffff
+                    continue # Data unavailable
+                rec -= 1
+                if rec&1:
+                    s.dam.data = bytes([dat[i]] * secsz)
+                    i += 1
+                else:
+                    s.dam.data = dat[i:i+secsz]
+                    i += secsz
+                if rec&2:
+                    s.dam.mark = ibm.Mark.DDAM
+                if rec&4:
+                    s.crc = s.dam.crc = 0xffff
+
+            self.to_track[cyl,head] = t
+
+
+    def get_track(self, cyl: int, side: int) -> Optional[ibm.IBMTrack_Fixed]:
+        if (cyl,side) not in self.to_track:
+            return None
+        return self.to_track[cyl,side]
+
+
+    def emit_track(self, cyl: int, side: int, track) -> None:
+        if isinstance(track, ibm.IBMTrack_Scan):
+            track = track.track
+        error.check(isinstance(track, ibm.IBMTrack),
+                    'IMD: Cannot create T%d.%d: Not IBM.FM nor IBM.MFM'
+                    % (cyl, side))
+        if not isinstance(track, ibm.IBMTrack_Empty):
+            self.to_track[cyl,side] = track
+
+
+    def get_image(self) -> bytes:
+
+        tdat = bytearray()
+
+        now = datetime.datetime.now()
+        sig = ('IMD 1.17: %s\r\nGreaseweazle %s\r\n\x1a'
+               % (now.strftime('%d/%m/%Y %H:%M:%S'), __version__))
+        tdat += sig.encode()
+
+        for (c,h),t in sorted(self.to_track.items()):
+            if t.mode is ibm.Mode.FM:
+                if t.clock < 3.0e-6:
+                    mode = IMDMode.FM_500kbps # High Rate
+                else:
+                    mode = IMDMode.FM_250kbps # 300 RPM
+            else:
+                assert t.mode is ibm.Mode.MFM
+                if t.clock < 1.5e-6:
+                    mode = IMDMode.MFM_500kbps # High Rate
+                else:
+                    mode = IMDMode.MFM_250kbps # 300 RPM
+            cyl, head, nsec, sec_n = c, h, 0, None
+            rmap, cmap, hmap = [], [], []
+            for s in t.sectors:
+                if not isinstance(s, ibm.Sector):
+                    continue
+                nsec += 1
+                error.check(s.idam.n == sec_n or sec_n is None,
+                            'IMD: Cannot create T%d.%d: Sectors vary in size'
+                            % (c,h))
+                sec_n = s.idam.n
+                rmap.append(s.idam.r)
+                cmap.append(s.idam.c)
+                hmap.append(s.idam.h)
+                if s.idam.c != c:
+                    head |= 0x80
+                if s.idam.h != h:
+                    head |= 0x40
+            if sec_n is None:
+                sec_n = 0
+            secsz = 128 << sec_n
+            tdat += struct.pack('5B', mode, cyl, head, nsec, sec_n)
+            tdat += bytes(rmap)
+            if head & 0x80:
+                tdat += bytes(cmap)
+            if head & 0x40:
+                tdat += bytes(hmap)
+            for s in t.sectors:
+                if not isinstance(s, ibm.Sector):
+                    continue
+                rec = 0
+                if s.dam.data.count(s.dam.data[0]) == secsz:
+                    rec |= 1
+                if s.dam.mark == ibm.Mark.DDAM:
+                    rec |= 2
+                if s.dam.crc != 0:
+                    rec |= 4
+                tdat += bytes([rec+1])
+                if rec & 1:
+                    tdat += s.dam.data[:1]
+                else:
+                    tdat += s.dam.data[:]
+
+        return tdat
+
+
+# Local variables:
+# python-indent: 4
+# End:

diskstack/_vendor/greaseweazle/image/img.py

@@ -0,0 +1,111 @@
+# greaseweazle/image/img.py
+#
+# Written & released by Keir Fraser <keir.xen@gmail.com>
+#
+# This is free and unencumbered software released into the public domain.
+# See the file COPYING for more details, or visit <http://unlicense.org>.
+
+from typing import Dict, Tuple, Optional, Any
+
+from diskstack._vendor.greaseweazle import error
+from diskstack._vendor.greaseweazle.codec import codec
+from diskstack._vendor.greaseweazle.flux import HasFlux
+from .image import Image, OptDict
+
+class IMG(Image):
+
+    sides_swapped = False
+    sequential = False
+    min_cyls: Optional[int] = None
+
+    def __init__(self, name: str, fmt):
+        self.to_track: Dict[Tuple[int,int],codec.Codec] = dict()
+        error.check(fmt is not None, """\
+Sector image requires a disk format to be specified""")
+        self.filename = name
+        self.fmt: codec.DiskDef = fmt
+
+
+    def track_list(self):
+        t, l = self.fmt.tracks, []
+        if self.sequential:
+            for h in t.heads:
+                for c in t.cyls:
+                    l.append((c,h))
+        else:
+            for c in t.cyls:
+                for h in t.heads:
+                    l.append((c,h))
+        return l
+
+
+    def from_bytes(self, dat: bytes) -> None:
+        pos = 0
+        for (cyl, head) in self.track_list():
+            if self.sides_swapped:
+                head ^= 1
+            track = self.fmt.mk_track(cyl, head)
+            if track is not None:
+                pos += track.set_img_track(dat[pos:])
+                self.to_track[cyl,head] = track
+
+
+    def get_track(self, cyl: int, side: int) -> Optional[codec.Codec]:
+        if (cyl,side) not in self.to_track:
+            return None
+        return self.to_track[cyl,side]
+
+
+    def emit_track(self, cyl: int, side: int, track) -> None:
+        self.to_track[cyl,side] = track
+
+
+    def get_image(self) -> bytes:
+
+        tdat = bytearray()
+
+        # If min_cyls is specified, only emit extra cylinders if there is
+        # valid data.
+        max_cyl = None
+        if self.min_cyls is not None:
+            max_cyl = self.min_cyls - 1
+            for (cyl, head) in self.track_list():
+                if cyl > max_cyl and (cyl,head) in self.to_track:
+                    track = self.to_track[cyl,head]
+                    if track.nr_missing() < track.nsec:
+                        max_cyl = cyl
+
+        for (cyl, head) in self.track_list():
+            if max_cyl is not None and cyl > max_cyl:
+                break
+            if self.sides_swapped:
+                head ^= 1
+            if (cyl,head) in self.to_track:
+                t = self.to_track[cyl,head]
+            else:
+                _t = self.fmt.mk_track(cyl, head)
+                assert _t is not None # mypy
+                t = _t
+            tdat += t.get_img_track()
+
+        return tdat
+
+
+class IMG_AutoFormat(IMG):
+
+    @staticmethod
+    def format_from_file(name: str) -> str:
+        raise NotImplementedError
+
+    @classmethod
+    def from_file(cls, name: str, fmt: Optional[codec.DiskDef],
+                  opts: OptDict) -> Image:
+        if fmt is None:
+            format_str = cls.format_from_file(name)
+            fmt = codec.get_diskdef(format_str)
+            print(f'{cls.__name__}: Image format {format_str}')
+        return super().from_file(name, fmt, opts)
+
+# Local variables:
+# python-indent: 4
+# End: