polyfile-weave 0.5.5__py3-none-any.whl

polyfile/structs.py

@@ -0,0 +1,281 @@
+import sys
+from abc import ABCMeta, abstractmethod
+from collections import OrderedDict
+from enum import Enum
+import struct as python_struct
+from typing import BinaryIO, Optional, Tuple, Type, TypeVar, Union
+
+if sys.version_info < (3, 7):
+    from typing import Dict as OrderedDictType
+elif sys.version_info < (3, 9):
+    # typing.OrderedDict was added in Python 3.7
+    from typing import OrderedDict as OrderedDictType
+else:
+    # In Python 3.9 and newer, collections.OrderedDict is subscriptable
+    OrderedDictType = OrderedDict
+
+
+class Endianness(Enum):
+    NATIVE = "="
+    LITTLE = "<"
+    BIG = ">"
+    NETWORK = "!"
+
+
+class SizeReference:
+    def __init__(self, size_member_name: str):
+        self.size_member_name: str = size_member_name
+
+    def __str__(self):
+        return self.size_member_name
+
+
+T = TypeVar("T")
+
+
+class AnnotatedType(ABCMeta):
+    endianness: Optional[Endianness] = None
+
+    def __class_getitem__(mcs, endianness: Optional[Endianness]) -> "AnnotatedType":
+        name = mcs.__name__
+        if endianness is not None:
+            name = f"{name}{endianness.name}"
+        else:
+            name = f"{name}DefaultEndianness"
+        ret = type(name, (AnnotatedType,), {
+            "endianness": endianness
+        })
+        return ret
+
+
+def struct_fmt_int(size: int, signed: bool) -> str:
+    if size == 1:
+        fmt = "b"
+    elif size == 2:
+        fmt = "h"
+    elif size == 4:
+        fmt = "i"
+    elif size == 8:
+        fmt = "q"
+    else:
+        raise TypeError(f"Unsupported struct integer size: {size}")
+    if not signed:
+        fmt = fmt.upper()
+    return fmt
+
+
+class AnnotatedSizeType(AnnotatedType):
+    size: Union[int, SizeReference]
+
+    def __class_getitem__(mcs: T, size: Union[int, str, SizeReference]) -> T:
+        if isinstance(size, str):
+            size = SizeReference(size)
+        name = f"{mcs.__name__}{size!s}"
+        return type(name, (mcs,), {
+            "endianness": None,
+            "size": size
+        })
+
+
+IntTypeArgs = Union[
+    Tuple[Union[int, str, SizeReference], bool],
+    Tuple[Union[int, str, SizeReference], bool, Optional[Endianness]]
+]
+
+
+class AnnotatedIntType(AnnotatedType):
+    size: Union[int, SizeReference]
+    signed: bool
+
+    def __class_getitem__(mcs: T, args: IntTypeArgs) -> T:
+        if len(args) == 3:
+            size, signed, endianness = args
+        elif len(args) == 2:
+            size, signed = args
+            endianness = None
+        else:
+            raise TypeError(f"{mcs.__name__}[{','.join(map(repr, args))}] must have either two or three arguments")
+        if isinstance(size, str):
+            size = SizeReference(size)
+        if endianness is None:
+            endianness_name = "DefaultEndianness"
+        else:
+            endianness_name = endianness.name
+        if signed:
+            signed_name = "Signed"
+        else:
+            signed_name = "Unsigned"
+        name = f"{signed_name}{mcs.__name__}{endianness_name}{size!s}"
+        endianness_type = super().__class_getitem__(endianness)
+        return type(name, (mcs, endianness_type), {
+            "size": size,
+            "signed": signed
+        })
+
+    def __str__(self):
+        if self.endianness is not None:
+            s = f"{self.endianness.name.lower()} endian "
+        else:
+            s = ""
+        s = f"{s}{self.size}-byte "
+        if not self.signed:
+            s = f"{s}un"
+        s = f"{s}signed integer"
+        return s
+
+
+class Field(metaclass=AnnotatedType):
+    start_offset: int
+    num_bytes: int
+
+    @classmethod
+    @abstractmethod
+    def read(cls: Type[T], struct: "Struct", field_name: str, stream: BinaryIO, endianness: Endianness) -> T:
+        raise NotImplementedError()
+
+
+class IntField(int, Field, metaclass=AnnotatedIntType):
+    def __class_getitem__(cls: T, args: IntTypeArgs) -> T:
+        if not isinstance(args[0], int):
+            raise TypeError("An int field must have a constant integer size")
+
+        class BoundIntField(cls, metaclass=AnnotatedIntType[args]):
+            pass
+
+        return BoundIntField
+
+    @classmethod
+    def read(cls: Type[T], struct: "Struct", field_name: str, stream: BinaryIO, endianness: Endianness) -> T:
+        data = stream.read(cls.size)
+        if len(data) != cls.size:
+            raise StructReadError(f"Reached the end of stream while expecting {cls!s} for "
+                                  f"{struct.__class__.__name__}.{field_name}")
+        try:
+            return cls(python_struct.unpack(f"{endianness.value}{struct_fmt_int(cls.size, cls.signed)}", data)[0])
+        except python_struct.error:
+            raise StructReadError(f"Error unpacking {cls!s} from {data!r} for {struct.__class__.__name__}.{field_name}")
+
+
+class ByteField(bytes, Field, metaclass=AnnotatedSizeType):
+    def __class_getitem__(cls: T, size: Union[str, int, SizeReference]) -> T:
+        class BoundByteField(cls, metaclass=AnnotatedSizeType[size]):
+            pass
+        return BoundByteField
+
+    @classmethod
+    def read(cls: Type[T], struct: "Struct", field_name: str, stream: BinaryIO, endianness: Endianness) -> T:
+        if isinstance(cls.size, SizeReference):
+            if not hasattr(struct, cls.size.size_member_name):
+                raise StructReadError(f"{struct.__class__.__name__}.{field_name} has a size bound to field "
+                                      f"{cls.size.size_member_name!r}, which does not exist")
+            size: int = getattr(struct, cls.size.size_member_name)
+            if size is None or not isinstance(size, int):
+                raise StructReadError(f"{struct.__class__.__name__}.{field_name} has a size bound to "
+                                      f"{struct.__class__.__name__}.{field_name}={size}, which is not an int")
+        else:
+            size = cls.size
+        data = stream.read(size)
+        if len(data) != size:
+            raise StructReadError(f"Reached the end of stream while expecting {size} bytes for "
+                                  f"{struct.__class__.__name__}.{field_name}")
+        return cls(data)
+
+
+Int8 = IntField[1, True]
+Int16 = IntField[2, True]
+Int32 = IntField[4, True]
+Int64 = IntField[8, True]
+UInt8 = IntField[1, False]
+UInt16 = IntField[2, False]
+UInt32 = IntField[4, False]
+UInt64 = IntField[8, False]
+Int8BE = IntField[1, True, Endianness.BIG]
+Int16BE = IntField[2, True, Endianness.BIG]
+Int32BE = IntField[4, True, Endianness.BIG]
+Int64BE = IntField[8, True, Endianness.BIG]
+UInt8BE = IntField[1, False, Endianness.BIG]
+UInt16BE = IntField[2, False, Endianness.BIG]
+UInt32BE = IntField[4, False, Endianness.BIG]
+UInt64BE = IntField[8, False, Endianness.BIG]
+Int8LE = IntField[1, True, Endianness.LITTLE]
+Int16LE = IntField[2, True, Endianness.LITTLE]
+Int32LE = IntField[4, True, Endianness.LITTLE]
+Int64LE = IntField[8, True, Endianness.LITTLE]
+UInt8LE = IntField[1, False, Endianness.LITTLE]
+UInt16LE = IntField[2, False, Endianness.LITTLE]
+UInt32LE = IntField[4, False, Endianness.LITTLE]
+UInt64LE = IntField[8, False, Endianness.LITTLE]
+
+
+class Constant(ByteField):
+    constant: bytes
+
+    def __class_getitem__(cls: T, to_match: bytes) -> T:
+        c = super().__class_getitem__(len(to_match))
+        setattr(c, "constant", to_match)
+        return c
+
+    @classmethod
+    def read(cls: Type[T], struct: "Struct", field_name: str, stream: BinaryIO, endianness: Endianness) -> T:
+        ret = super().read(struct, field_name, stream, endianness)
+        if ret != cls.constant:
+            raise StructReadError(f"Expected {cls.constant!r} but instead found {ret!r} while parsing "
+                                  f"{struct.__class__.__name__}.{field_name}")
+        return ret
+
+
+class StructMeta(ABCMeta):
+    fields: OrderedDictType[str, Type[Field]]
+
+    def __init__(cls, name, bases, clsdict):
+        cls.fields = OrderedDict()
+        if "__annotations__" in clsdict:
+            for field_name, field_type in clsdict["__annotations__"].items():
+                if isinstance(field_type, type) and issubclass(field_type, Field):
+                    if field_name in cls.fields:
+                        raise TypeError(f"Invalid redeclaration of struct field {field_name} in {cls.__name__}")
+                    cls.fields[field_name] = field_type
+        super().__init__(name, bases, clsdict)
+
+
+class StructError(RuntimeError):
+    pass
+
+
+class StructReadError(StructError):
+    pass
+
+
+class Struct(metaclass=StructMeta):
+    endianness: Endianness = Endianness.NATIVE
+    start_offset: int
+    num_bytes: int
+
+    @classmethod
+    def read(cls: Type[T], stream: BinaryIO) -> T:
+        ret = cls()
+        setattr(ret, "start_offset", stream.tell())
+        for field_name, field in cls.fields.items():
+            if field.__class__.endianness is not None:
+                endianness = field.__class__.endianness
+            else:
+                endianness = cls.endianness
+            offset_before = stream.tell()
+            value = field.read(ret, field_name, stream, endianness)
+            setattr(ret, field_name, value)
+            setattr(value, "start_offset", offset_before)
+            setattr(value, "num_bytes", stream.tell() - offset_before)
+        setattr(ret, "num_bytes", stream.tell() - ret.start_offset)
+        return ret
+
+
+if __name__ == "__main__":
+    from io import BytesIO
+
+    class Test(Struct):
+        foo: UInt8LE
+        bar: Int32LE
+        data: ByteField["foo"]
+
+    test = Test.read(BytesIO(b"\x03234567890"))
+    print(test.foo, test.bar, test.data)

polyfile/templates/download.js

@@ -0,0 +1,162 @@
+//download.js v4.2, by dandavis; 2008-2016. [CCBY2] see http://danml.com/download.html for tests/usage
+// v1 landed a FF+Chrome compat way of downloading strings to local un-named files, upgraded to use a hidden frame and optional mime
+// v2 added named files via a[download], msSaveBlob, IE (10+) support, and window.URL support for larger+faster saves than dataURLs
+// v3 added dataURL and Blob Input, bind-toggle arity, and legacy dataURL fallback was improved with force-download mime and base64 support. 3.1 improved safari handling.
+// v4 adds AMD/UMD, commonJS, and plain browser support
+// v4.1 adds url download capability via solo URL argument (same domain/CORS only)
+// v4.2 adds semantic variable names, long (over 2MB) dataURL support, and hidden by default temp anchors
+// https://github.com/rndme/download
+
+(function (root, factory) {
+	if (typeof define === 'function' && define.amd) {
+		// AMD. Register as an anonymous module.
+		define([], factory);
+	} else if (typeof exports === 'object') {
+		// Node. Does not work with strict CommonJS, but
+		// only CommonJS-like environments that support module.exports,
+		// like Node.
+		module.exports = factory();
+	} else {
+		// Browser globals (root is window)
+		root.download = factory();
+  }
+}(this, function () {
+
+	return function download(data, strFileName, strMimeType) {
+
+		var self = window, // this script is only for browsers anyway...
+			defaultMime = "application/octet-stream", // this default mime also triggers iframe downloads
+			mimeType = strMimeType || defaultMime,
+			payload = data,
+			url = !strFileName && !strMimeType && payload,
+			anchor = document.createElement("a"),
+			toString = function(a){return String(a);},
+			myBlob = (self.Blob || self.MozBlob || self.WebKitBlob || toString),
+			fileName = strFileName || "download",
+			blob,
+			reader;
+			myBlob= myBlob.call ? myBlob.bind(self) : Blob ;
+	  
+		if(String(this)==="true"){ //reverse arguments, allowing download.bind(true, "text/xml", "export.xml") to act as a callback
+			payload=[payload, mimeType];
+			mimeType=payload[0];
+			payload=payload[1];
+		}
+
+
+		if(url && url.length< 2048){ // if no filename and no mime, assume a url was passed as the only argument
+			fileName = url.split("/").pop().split("?")[0];
+			anchor.href = url; // assign href prop to temp anchor
+		  	if(anchor.href.indexOf(url) !== -1){ // if the browser determines that it's a potentially valid url path:
+        		var ajax=new XMLHttpRequest();
+        		ajax.open( "GET", url, true);
+        		ajax.responseType = 'blob';
+        		ajax.onload= function(e){ 
+				  download(e.target.response, fileName, defaultMime);
+				};
+        		setTimeout(function(){ ajax.send();}, 0); // allows setting custom ajax headers using the return:
+			    return ajax;
+			} // end if valid url?
+		} // end if url?
+
+
+		//go ahead and download dataURLs right away
+		if(/^data\:[\w+\-]+\/[\w+\-]+[,;]/.test(payload)){
+		
+			if(payload.length > (1024*1024*1.999) && myBlob !== toString ){
+				payload=dataUrlToBlob(payload);
+				mimeType=payload.type || defaultMime;
+			}else{			
+				return navigator.msSaveBlob ?  // IE10 can't do a[download], only Blobs:
+					navigator.msSaveBlob(dataUrlToBlob(payload), fileName) :
+					saver(payload) ; // everyone else can save dataURLs un-processed
+			}
+			
+		}//end if dataURL passed?
+
+		blob = payload instanceof myBlob ?
+			payload :
+			new myBlob([payload], {type: mimeType}) ;
+
+
+		function dataUrlToBlob(strUrl) {
+			var parts= strUrl.split(/[:;,]/),
+			type= parts[1],
+			decoder= parts[2] == "base64" ? atob : decodeURIComponent,
+			binData= decoder( parts.pop() ),
+			mx= binData.length,
+			i= 0,
+			uiArr= new Uint8Array(mx);
+
+			for(i;i<mx;++i) uiArr[i]= binData.charCodeAt(i);
+
+			return new myBlob([uiArr], {type: type});
+		 }
+
+		function saver(url, winMode){
+
+			if ('download' in anchor) { //html5 A[download]
+				anchor.href = url;
+				anchor.setAttribute("download", fileName);
+				anchor.className = "download-js-link";
+				anchor.innerHTML = "downloading...";
+				anchor.style.display = "none";
+				document.body.appendChild(anchor);
+				setTimeout(function() {
+					anchor.click();
+					document.body.removeChild(anchor);
+					if(winMode===true){setTimeout(function(){ self.URL.revokeObjectURL(anchor.href);}, 250 );}
+				}, 66);
+				return true;
+			}
+
+			// handle non-a[download] safari as best we can:
+			if(/(Version)\/(\d+)\.(\d+)(?:\.(\d+))?.*Safari\//.test(navigator.userAgent)) {
+				url=url.replace(/^data:([\w\/\-\+]+)/, defaultMime);
+				if(!window.open(url)){ // popup blocked, offer direct download:
+					if(confirm("Displaying New Document\n\nUse Save As... to download, then click back to return to this page.")){ location.href=url; }
+				}
+				return true;
+			}
+
+			//do iframe dataURL download (old ch+FF):
+			var f = document.createElement("iframe");
+			document.body.appendChild(f);
+
+			if(!winMode){ // force a mime that will download:
+				url="data:"+url.replace(/^data:([\w\/\-\+]+)/, defaultMime);
+			}
+			f.src=url;
+			setTimeout(function(){ document.body.removeChild(f); }, 333);
+
+		}//end saver
+
+
+
+
+		if (navigator.msSaveBlob) { // IE10+ : (has Blob, but not a[download] or URL)
+			return navigator.msSaveBlob(blob, fileName);
+		}
+
+		if(self.URL){ // simple fast and modern way using Blob and URL:
+			saver(self.URL.createObjectURL(blob), true);
+		}else{
+			// handle non-Blob()+non-URL browsers:
+			if(typeof blob === "string" || blob.constructor===toString ){
+				try{
+					return saver( "data:" +  mimeType   + ";base64,"  +  self.btoa(blob)  );
+				}catch(y){
+					return saver( "data:" +  mimeType   + "," + encodeURIComponent(blob)  );
+				}
+			}
+
+			// Blob but not URL support:
+			reader=new FileReader();
+			reader.onload=function(e){
+				saver(this.result);
+			};
+			reader.readAsDataURL(blob);
+		}
+		return true;
+	}; /* end download() */
+}));

polyfile/templates/hexdump.css

@@ -0,0 +1,268 @@
+body {
+  margin: 30px;
+  font-family: sans-serif;
+}
+
+.tree {
+  margin: 1em;
+  display: inline-block;
+  vertical-align: top;
+  overflow-y: auto;
+  height: 80vh;
+}
+
+.tree input {
+  position: absolute;
+  clip: rect(0, 0, 0, 0);
+}
+
+.tree input ~ ul { display: none; }
+
+.tree input:checked ~ ul { display: block; }
+
+.tree li {
+  line-height: 1.2;
+  position: relative;
+  padding: 0 0 1em 1em;
+}
+
+.tree ul {  padding-inline-start: 0px; }
+
+.tree ul li { padding: 1em 0 0 1em; list-style-type: none; }
+
+.tree > li:last-child { padding-bottom: 0; }
+
+.tree_label {
+  position: relative;
+  display: inline-block;
+  background: #fff;
+}
+
+label.tree_label { cursor: pointer; }
+
+label.tree_label:hover { color: #666; }
+
+.tree_label:hover > .download {
+  display: block;
+  float: right;
+}
+
+.download {
+  display: none;
+  color: blue;
+  padding-left: 1em;
+  padding-right: 1em;
+}
+
+label.tree_label:before {
+  background: #000;
+  color: #fff;
+  position: relative;
+  z-index: 1;
+  float: left;
+  margin: 0 1em 0 -2em;
+  width: 1em;
+  height: 1em;
+  border-radius: 1em;
+  content: '+';
+  text-align: center;
+  line-height: .9em;
+  }
+
+:checked ~ label.tree_label:before { content: '–'; }
+
+.tree li:before {
+  position: absolute;
+  top: 0;
+  bottom: 0;
+  left: -.5em;
+  display: block;
+  width: 0;
+  border-left: 1px solid #777;
+  content: "";
+}
+
+.tree_label:after {
+  position: absolute;
+  top: 0;
+  left: -1.5em;
+  display: block;
+  height: 0.5em;
+  width: 1em;
+  border-bottom: 1px solid #777;
+  border-left: 1px solid #777;
+  border-radius: 0 0 0 .3em;
+  content: '';
+}
+
+label.tree_label:after { border-bottom: 0; }
+
+:checked ~ label.tree_label:after {
+  border-radius: 0 .3em 0 0;
+  border-top: 1px solid #777;
+  border-right: 1px solid #777;
+  border-bottom: 0;
+  border-left: 0;
+  bottom: 0;
+  top: 0.5em;
+  height: auto;
+}
+
+.tree li:last-child:before {
+  height: 1em;
+  bottom: auto;
+}
+
+.tree > li:last-child:before { display: none; }
+
+.tree_custom {
+  display: block;
+  background: #eee;
+  padding: 1em;
+  border-radius: 0.3em;
+}
+
+.hexeditor {
+  font-family: monospace;
+  display: inline-block;
+  vertical-align:top;
+  overflow-x: auto;
+  height: 80vh;
+  overflow-y: hidden;
+}
+
+.hexeditor .hexdump {
+  padding: 0px;
+  vertical-align: top;
+  display: inline-block;
+}
+
+.hexeditor .bytes {
+  padding: 0px;
+  padding-right: 2em;
+  vertical-align: top;
+  display: inline-block;
+}
+
+.readablebyteswrapper {
+  padding: 0px;
+  padding-right: 2em;
+  vertical-align: top;
+  display: inline-block;
+  max-width: 300px;
+  overflow: auto;
+  height: 100%;
+}
+
+.byte {
+  display: inline-block;
+  text-align: center;
+}
+
+.hexeditor .hexdump .byte {
+  width: 30px;
+}
+
+.hexeditor .bytes .byte {
+  width: 10px;
+}
+
+.byterow {
+  display: inline-block;
+  height: 1.1em;
+  color: gray;
+}
+
+.highlighted {
+  background-color: #42bff5;
+  color: white;
+}
+
+.manually-focused {
+  background-color: #FF0000;
+  color: white;
+}
+
+.cursor {
+  background-color: #0000FF;
+  color: white;
+  cursor: none;
+}
+
+.byteline {
+  height: 1.2em;
+}
+
+.rawdump {
+  font-family: monospace;
+}
+
+.scrollbar {
+  min-height: 80vh;
+}
+
+.hexeditor .scrollcontainer {
+  overflow-y: scroll;
+  display: inline-block;
+  width: 3em;
+  vertical-align: top;
+  height: 100%;
+}
+
+.hexeditor .scrollcapture {
+  display: inline-block;
+  vertical-align: top;
+}
+
+.searchresult {
+    -webkit-box-shadow:0 0 20px #FFFF00;
+    -moz-box-shadow: 0 0 20px #FFFF00;
+    box-shadow:0 0 20px #FFFF00;
+    background-color:#FFFF00;
+}
+
+.overlay {
+  position: fixed;
+  top: 0;
+  bottom: 0;
+  left: 0;
+  right: 0;
+  background: rgba(0, 0, 0, 0.7);
+  transition: opacity 500ms;
+  visibility: hidden;
+  opacity: 0;
+}
+.overlay:target {
+  visibility: visible;
+  opacity: 1;
+}
+.popup {
+  margin: 70px auto;
+  padding: 20px;
+  background: #fff;
+  border-radius: 5px;
+  width: 60%;
+  position: relative;
+  transition: all 5s ease-in-out;
+}
+.popup h2 {
+  margin-top: 0;
+  color: #333;
+}
+.popup .close {
+  position: absolute;
+  top: 20px;
+  right: 30px;
+  transition: all 200ms;
+  font-size: 30px;
+  font-weight: bold;
+  text-decoration: none;
+  color: #333;
+}
+.popup .close:hover {
+  color: #06D85F;
+}
+.popup .content {
+  max-height: 30%;
+  overflow: auto;
+}