From ad92cfe0d1bd4f43c253175950ebe18c9acc7d8f Mon Sep 17 00:00:00 2001
From: Daniel Cellucci <dwcellucci@gmail.com>
Date: Tue, 18 Oct 2022 00:40:56 +0000
Subject: [PATCH] first commit

---
 .gitignore                                    |    3 +
 README.md                                     |    0
 hirise_blender/__init__.py                    |   26 +
 .../__pycache__/__init__.cpython-310.pyc      |  Bin 0 -> 225 bytes
 .../hirise_blender.cpython-310.pyc            |  Bin 0 -> 844 bytes
 hirise_blender/hirise_blender.py              |  166 +++
 hirise_blender/planetaryimage/__init__.py     |   17 +
 .../__pycache__/__init__.cpython-310.pyc      |  Bin 0 -> 410 bytes
 .../__pycache__/cubefile.cpython-310.pyc      |  Bin 0 -> 7633 bytes
 .../__pycache__/decoders.cpython-310.pyc      |  Bin 0 -> 1906 bytes
 .../__pycache__/image.cpython-310.pyc         |  Bin 0 -> 6325 bytes
 .../__pycache__/pds3image.cpython-310.pyc     |  Bin 0 -> 9110 bytes
 .../__pycache__/specialpixels.cpython-310.pyc |  Bin 0 -> 1505 bytes
 hirise_blender/planetaryimage/cubefile.py     |  255 ++++
 hirise_blender/planetaryimage/decoders.py     |   49 +
 hirise_blender/planetaryimage/image.py        |  217 +++
 hirise_blender/planetaryimage/pds3image.py    |  349 +++++
 .../planetaryimage/specialpixels.py           |   84 ++
 hirise_blender/pvl/__init__.py                |  268 ++++
 .../pvl/__pycache__/__init__.cpython-310.pyc  |  Bin 0 -> 7658 bytes
 .../__pycache__/collections.cpython-310.pyc   |  Bin 0 -> 24724 bytes
 .../pvl/__pycache__/decoder.cpython-310.pyc   |  Bin 0 -> 16552 bytes
 .../pvl/__pycache__/encoder.cpython-310.pyc   |  Bin 0 -> 34585 bytes
 .../__pycache__/exceptions.cpython-310.pyc    |  Bin 0 -> 2972 bytes
 .../pvl/__pycache__/grammar.cpython-310.pyc   |  Bin 0 -> 8156 bytes
 .../pvl/__pycache__/lexer.cpython-310.pyc     |  Bin 0 -> 9466 bytes
 .../pvl/__pycache__/parser.cpython-310.pyc    |  Bin 0 -> 26379 bytes
 .../pvl/__pycache__/token.cpython-310.pyc     |  Bin 0 -> 10638 bytes
 hirise_blender/pvl/collections.py             |  704 ++++++++++
 hirise_blender/pvl/decoder.py                 |  552 ++++++++
 hirise_blender/pvl/encoder.py                 | 1178 +++++++++++++++++
 hirise_blender/pvl/exceptions.py              |   79 ++
 hirise_blender/pvl/grammar.py                 |  345 +++++
 hirise_blender/pvl/lexer.py                   |  435 ++++++
 hirise_blender/pvl/new.py                     |  209 +++
 hirise_blender/pvl/parser.py                  |  955 +++++++++++++
 hirise_blender/pvl/pvl_translate.py           |   89 ++
 hirise_blender/pvl/pvl_validate.py            |  253 ++++
 hirise_blender/pvl/token.py                   |  335 +++++
 hirise_blender/six/__init__.py                |    3 +
 .../six/__pycache__/__init__.cpython-310.pyc  |  Bin 0 -> 251 bytes
 .../six/__pycache__/six.cpython-310.pyc       |  Bin 0 -> 27584 bytes
 hirise_blender/six/six.py                     |  998 ++++++++++++++
 poetry.lock                                   |  180 +++
 pyproject.toml                                |   17 +
 45 files changed, 7766 insertions(+)
 create mode 100644 .gitignore
 create mode 100644 README.md
 create mode 100644 hirise_blender/__init__.py
 create mode 100644 hirise_blender/__pycache__/__init__.cpython-310.pyc
 create mode 100644 hirise_blender/__pycache__/hirise_blender.cpython-310.pyc
 create mode 100644 hirise_blender/hirise_blender.py
 create mode 100755 hirise_blender/planetaryimage/__init__.py
 create mode 100644 hirise_blender/planetaryimage/__pycache__/__init__.cpython-310.pyc
 create mode 100644 hirise_blender/planetaryimage/__pycache__/cubefile.cpython-310.pyc
 create mode 100644 hirise_blender/planetaryimage/__pycache__/decoders.cpython-310.pyc
 create mode 100644 hirise_blender/planetaryimage/__pycache__/image.cpython-310.pyc
 create mode 100644 hirise_blender/planetaryimage/__pycache__/pds3image.cpython-310.pyc
 create mode 100644 hirise_blender/planetaryimage/__pycache__/specialpixels.cpython-310.pyc
 create mode 100644 hirise_blender/planetaryimage/cubefile.py
 create mode 100644 hirise_blender/planetaryimage/decoders.py
 create mode 100644 hirise_blender/planetaryimage/image.py
 create mode 100644 hirise_blender/planetaryimage/pds3image.py
 create mode 100644 hirise_blender/planetaryimage/specialpixels.py
 create mode 100644 hirise_blender/pvl/__init__.py
 create mode 100644 hirise_blender/pvl/__pycache__/__init__.cpython-310.pyc
 create mode 100644 hirise_blender/pvl/__pycache__/collections.cpython-310.pyc
 create mode 100644 hirise_blender/pvl/__pycache__/decoder.cpython-310.pyc
 create mode 100644 hirise_blender/pvl/__pycache__/encoder.cpython-310.pyc
 create mode 100644 hirise_blender/pvl/__pycache__/exceptions.cpython-310.pyc
 create mode 100644 hirise_blender/pvl/__pycache__/grammar.cpython-310.pyc
 create mode 100644 hirise_blender/pvl/__pycache__/lexer.cpython-310.pyc
 create mode 100644 hirise_blender/pvl/__pycache__/parser.cpython-310.pyc
 create mode 100644 hirise_blender/pvl/__pycache__/token.cpython-310.pyc
 create mode 100644 hirise_blender/pvl/collections.py
 create mode 100644 hirise_blender/pvl/decoder.py
 create mode 100644 hirise_blender/pvl/encoder.py
 create mode 100644 hirise_blender/pvl/exceptions.py
 create mode 100755 hirise_blender/pvl/grammar.py
 create mode 100644 hirise_blender/pvl/lexer.py
 create mode 100755 hirise_blender/pvl/new.py
 create mode 100644 hirise_blender/pvl/parser.py
 create mode 100644 hirise_blender/pvl/pvl_translate.py
 create mode 100644 hirise_blender/pvl/pvl_validate.py
 create mode 100644 hirise_blender/pvl/token.py
 create mode 100644 hirise_blender/six/__init__.py
 create mode 100644 hirise_blender/six/__pycache__/__init__.cpython-310.pyc
 create mode 100644 hirise_blender/six/__pycache__/six.cpython-310.pyc
 create mode 100644 hirise_blender/six/six.py
 create mode 100644 poetry.lock
 create mode 100644 pyproject.toml

diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..666bb8d
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,3 @@
+.pytest_cache/
+tests/
+.zip
diff --git a/README.md b/README.md
new file mode 100644
index 0000000..e69de29
diff --git a/hirise_blender/__init__.py b/hirise_blender/__init__.py
new file mode 100644
index 0000000..6995358
--- /dev/null
+++ b/hirise_blender/__init__.py
@@ -0,0 +1,26 @@
+import bpy
+
+bl_info = {
+    "name": "Import HIRISE Image",
+    "blender": (3, 30, 0),
+    "category": "Object",
+}
+
+if 'bpy' in locals():
+    print('HIRISE Reloading')
+    from importlib import reload
+    import sys
+    for k, v in list(sys.modules.items()):
+        if k.startswith('hirise_blender.'):
+            reload(v)
+
+from .hirise_blender import ImportIMGData, menu_func_import
+
+# Register and add to the "file selector" menu (required to use F3 search "Text Import Operator" for quick access).
+def register():
+    bpy.utils.register_class(ImportIMGData)
+    bpy.types.TOPBAR_MT_file_import.append(menu_func_import)
+
+def unregister():
+    bpy.utils.unregister_class(ImportIMGData)
+    bpy.types.TOPBAR_MT_file_import.remove(menu_func_import)
\ No newline at end of file
diff --git a/hirise_blender/__pycache__/__init__.cpython-310.pyc b/hirise_blender/__pycache__/__init__.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..da5ea62a08fae9c48463b3fed49dc6c364de2824
GIT binary patch
literal 225
zcmd1j<>g`kf}_uUlbwL{V-N=!FabFZKwK;aBvKes7;_kM8KW2(8B&<i8Kam|n1dNK
zSza;%B{dmuaTKK{ro?;tx)*`8`DrrW;>*Y^$}CQePs&NnOGzyPi{E08k5A0WiH~2&
zP{ayU2PS^m>SyHVrs}68r{?68CMRd=r)QSvqv}TI#>Z#oWtPOp>lIYq;;_lhPbtkw
SwF5b&m<>qqFfcK3{09I*zc~^B

literal 0
HcmV?d00001

diff --git a/hirise_blender/__pycache__/hirise_blender.cpython-310.pyc b/hirise_blender/__pycache__/hirise_blender.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..fbceabe07407ce5166e55d97ba66e39d61260a3b
GIT binary patch
literal 844
zcmaJ<&u`N(6t*2Fal5V{Z45ZUH5Yo|iV$K*Xopou<rEH)7kjJM#EBetY$KJB2LA<z
z_Q-#Pd__XqjWa?j&zXR7;Ysg@-*evg`Mp%z+kFJ`>Dyuch9LCSA2tPY=ox799E?B$
z7pTN3#z+tm6eJBgPg5$W2tS}S6p@I*M=};{M$7{lT_Ly~Ogc?^*BBZl*!5n$m^?lx
z`H8%S1RCca>9_PC2toHjoA+QWI>k%U;uZEBK9c)rK`dY|X-ii43i#M?8TtAmXoJ&u
z$yR7VyQl|IX#2}8e-gnAi7vki7Ev25|5hVGXF(ga;XTwwP>tJIP{3g=o1i2dU;kXM
z*O!BXvaXC(`sCreh5G(wy*2^xO9qZqjiWWUQ^$^YBQ-Cj3u~jab<uHUN^XsRqN7zU
zwWESt?t+q^gHhTMUAyq@R2rG|T%1?h%5&@3u`1+EPapZ7X{h|r(g;31;{|x7z27pj
ztj=Us@@AIq7^yvEp)RH9Qc|Rmu07~yWOjhZkNwfKD&<JzvMA<xu0|)yj;6|}MrKEV
zC8YWP@lk!@n2}s$2Zt~HwwhfqyLgEExKH|c4>P<+7@^qQfkF=YkN9bH3m!mVVXc0R
z0>QA!*wNRru?aQ|Y8~GV<6#^vxzavre4ha}cYT&+@LHv_EMe)eF1VJKn~QE@H`5RG
zysR(G5H1_fxuf>yTR-3|+ko<uG94a!QdVMK$fy4QZEk}ZAO<gFgxz96AJg?OYOvJe

literal 0
HcmV?d00001

diff --git a/hirise_blender/hirise_blender.py b/hirise_blender/hirise_blender.py
new file mode 100644
index 0000000..b64e9f8
--- /dev/null
+++ b/hirise_blender/hirise_blender.py
@@ -0,0 +1,166 @@
+
+import bpy
+from .planetaryimage import PDS3Image
+import numpy as np
+import os
+
+
+def make_mesh(gridded_data, lower_res_factor = 4, quads = True):
+    data_width = gridded_data.shape[0]//lower_res_factor
+    data_height = gridded_data.shape[1]//lower_res_factor
+
+    vertices = np.zeros((data_width*data_height, 3))
+    if quads:
+        faces = np.zeros(((data_width-1)*(data_height-1), 4), dtype = 'int')
+    else:
+        faces = np.zeros(((data_width-1)*(data_height-1)*2, 3), dtype = 'int')
+    
+    for i in range(data_width):
+        for j in range(data_height):
+            vertices[i*data_height+j][0] = i*lower_res_factor
+            vertices[i*data_height+j][1] = j*lower_res_factor
+            if i == 0 or i == data_width-1 or j == 0 or j == data_height-1: 
+                vertices[i*data_height+j][2] = 0 
+            else:
+                vertices[i*data_height+j][2] = gridded_data[i*lower_res_factor][j*lower_res_factor]
+
+    for i in range(data_width-1):
+        for j in range(data_height-1):
+            if quads:
+                faces[(i*(data_height-1)+j)][0] = i*data_height+j
+                faces[(i*(data_height-1)+j)][1] = i*data_height+j+1
+                faces[(i*(data_height-1)+j)][2] = (i+1)*data_height+j+1
+                faces[(i*(data_height-1)+j)][3] = (i+1)*data_height+j
+            else:
+                faces[(i*(data_height-1)+j)*2][0] = i*data_height+j
+                faces[(i*(data_height-1)+j)*2][1] = i*data_height+j+1
+                faces[(i*(data_height-1)+j)*2][2] = (i+1)*data_height+j
+                
+                faces[(i*(data_height-1)+j)*2+1][0] = i*data_height+j+1
+                faces[(i*(data_height-1)+j)*2+1][1] = (i+1)*data_height+j+1
+                faces[(i*(data_height-1)+j)*2+1][2] = (i+1)*data_height+j
+    
+    mesh_data = bpy.data.meshes.new("cube_mesh_data")
+    #mesh_data.from_pydata(vertices, [], faces)
+    
+    print("adding vertices...")
+    mesh_data.vertices.add(vertices.shape[0])
+    mesh_data.vertices.foreach_set("co", vertices.flatten())
+    
+    print("adding vertex indices...")
+    mesh_data.loops.add(faces.size)
+    mesh_data.loops.foreach_set("vertex_index", faces.flatten())
+    
+    print("adding faces...")
+    mesh_data.polygons.add(faces.shape[0])
+    if quads:
+        mesh_data.polygons.foreach_set("loop_start", range(0, faces.size, 4))
+        mesh_data.polygons.foreach_set("loop_total", [4]*faces.shape[0])
+    else:
+        mesh_data.polygons.foreach_set("loop_start", range(0, faces.size, 3))
+        mesh_data.polygons.foreach_set("loop_total", [3]*faces.shape[0])
+
+    print("update mesh...")
+    mesh_data.update()
+    
+    print("validating mesh...")
+    mesh_data.validate()
+    
+    return mesh_data
+
+def read_img_data(context, filepath, ppgs, safety, quads):
+    print(context)
+    filename = os.path.basename(filepath)[:-4]
+    # Open IMAGE
+    image = PDS3Image.open(filepath)
+
+    maxval =  image.data.max()
+    minval = image.data.min()
+    remove_mask = np.where(image.data < -10000, 0, image.data)
+    minval = remove_mask.min()
+    
+    renormalized_masked = np.where(remove_mask != 0, remove_mask-minval, remove_mask)
+    
+    npdata = renormalized_masked[0]
+    
+    if not safety and ppgs < 4:
+        ppgs = 4
+    
+        
+    mesh_data = make_mesh(npdata, ppgs, quads)
+       
+    obj = bpy.data.objects.new(filename, mesh_data)
+
+    new_collection = bpy.data.collections.new(filename)
+    bpy.context.scene.collection.children.link(new_collection)
+    # add object to scene collection
+    new_collection.objects.link(obj)
+
+    return {'FINISHED'}
+
+
+# ImportHelper is a helper class, defines filename and
+# invoke() function which calls the file selector.
+from bpy_extras.io_utils import ImportHelper
+from bpy.props import StringProperty, BoolProperty, IntProperty
+from bpy.types import Operator
+
+
+class ImportIMGData(Operator, ImportHelper):
+    """This appears in the tooltip of the operator and in the generated docs"""
+    bl_idname = "import_test.img_data"  # important since its how bpy.ops.import_test.some_data is constructed
+    bl_label = "Import File"
+
+    # ImportHelper mixin class uses this
+    filename_ext = ".img"
+
+    filter_glob: StringProperty(
+        default="*.img",
+        options={'HIDDEN'},
+        maxlen=255,  # Max internal buffer length, longer would be clamped.
+    )
+    
+    ppgs: IntProperty(
+        name="Pixels Per Grid Square"
+      , description="Choose How Many Pixels in the IMG file will correspond to a single grid square (quad or tri) in the mesh."
+      , default=8
+      , max = 32
+      , min = 1
+    )
+    
+    safety: BoolProperty(
+        name="Safety"
+      , description="Enable to go below 4 pixels per grid. DO THIS ONLY IF YOU HAVE TONS OF RAM"
+      , default=False
+    )
+    
+    quads: BoolProperty(
+        name = "Use Quads"
+      , description="Use a quad mesh or a triangle mesh."
+      , default = True
+      )
+
+    def execute(self, context):
+        return read_img_data(context, self.filepath, self.ppgs, self.safety, self.quads)
+
+
+# Only needed if you want to add into a dynamic menu.
+def menu_func_import(self, context):
+    self.layout.operator(ImportIMGData.bl_idname, text="HIRISE .IMG")
+
+
+# Register and add to the "file selector" menu (required to use F3 search "Text Import Operator" for quick access).
+def register():
+    bpy.utils.register_class(ImportIMGData)
+    bpy.types.TOPBAR_MT_file_import.append(menu_func_import)
+
+
+def unregister():
+    bpy.utils.unregister_class(ImportIMGData)
+    bpy.types.TOPBAR_MT_file_import.remove(menu_func_import)
+
+
+if __name__ == "__main__":
+    register()
+    # test call
+    #bpy.ops.import_test.some_data('INVOKE_DEFAULT')
diff --git a/hirise_blender/planetaryimage/__init__.py b/hirise_blender/planetaryimage/__init__.py
new file mode 100755
index 0000000..7d965a3
--- /dev/null
+++ b/hirise_blender/planetaryimage/__init__.py
@@ -0,0 +1,17 @@
+# -*- coding: utf-8 -*-
+
+__author__ = 'PlanetaryPy Developers'
+__email__ = 'contact@planetarypy.com'
+__version__ = '0.4.1'
+__all__ = [
+    'PDS3Image',
+    'CubeFile',
+]
+
+__all__ = [
+    'CubeFile',
+    'PDS3Image',
+]
+
+from .cubefile import CubeFile
+from .pds3image import PDS3Image
diff --git a/hirise_blender/planetaryimage/__pycache__/__init__.cpython-310.pyc b/hirise_blender/planetaryimage/__pycache__/__init__.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..608edd0f94cb9487865cdd1f8753e1afe2bfe379
GIT binary patch
literal 410
zcmZ9HK}*9h6vvaSUEArv(>!?b+Dog<g9nj;Ll9I3yX6wP<hcdXrljql`$m4Hdi3O1
z@F2bx6!Ag+@BQ<_@4eXRbV4xP+mk$_guM6WZ!k0qJk>RdBAh77sbZX|k@B{TqpH!6
zeKj^-?sK0K<*UGq^MD6fhiei?huO+x1=N{qSMB){_F!xYt~#7bThy7X7v)dCY!hko
zgMX1+C6`^aTCV30dA5ZvylXaauMK?Qq9mrS-wjjmp5w5a2$41Q&N?BwNC?O?ZLmBN
zVvm!wEzkt`#^5avCBj}1Hc)s}s%ozLF$3<ExDcs>d_JZ-n?tH37}H3p)2*)4op!nc
yu`y66aR2S^X9i>{gf4U~L{he0c#~Vz7`W}%u4X76^QcD|W7PX%<6e*b6Z#D?Ja5kc

literal 0
HcmV?d00001

diff --git a/hirise_blender/planetaryimage/__pycache__/cubefile.cpython-310.pyc b/hirise_blender/planetaryimage/__pycache__/cubefile.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..c327a57e033bcf2e164dfb755725c789762daf07
GIT binary patch
literal 7633
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
W`C2TZ8>FsM#$~AZkUFML=>G*8|M!3Z

literal 0
HcmV?d00001

diff --git a/hirise_blender/planetaryimage/__pycache__/decoders.cpython-310.pyc b/hirise_blender/planetaryimage/__pycache__/decoders.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..9b47af1fedaed064ee6f61c13d33f7c0c3b3e6fe
GIT binary patch
literal 1906
zcmZ`(&2HQ_5GJXg)oQi&X0vIUH1Hv}4T|{IQ_vb|fcDV(;sOPP6oMkswzeznn$jL@
zNGHd~qOV{d^D2D=UV7-MPf(zj_8V#)uMLL)M>FJz9Dei7EQZ67Vf_B*kJ-;YV}Fsc
zIb0ZfnAMjMl1V;iG5d~5A)WV3I*Ok=v4HJL54LA*NAd$U_5a2nY(FEpIUE>!nAHmi
z#bPd5EM#C$<gugN?yPejd(xM^_bm49d42Qfby~^;b+S@rou~6RDqBdU_cMy|dXO$K
zzs0O}AR6AVgf#+^H+)84r*R-%$qv{DzCZPhC+pLtGG29@;uGYxDysZUnW##O<y<B2
zPHR<}LAEHCT2)oPD5tJ*D>XmVbf5M}1P~vXCOH57VfT1Zs9l+<`FxdS`R-9(?;htm
zuW;C0l?eN;xtyn^s#ATM7wHjx?H*UXT%MXBN%AtUlLQH372V@=p9ehTXFK;o^78tJ
zjKleQkWS!RXd);zy978hafNhg+L=1WD^~@s>@D>|uCm%bZOU~YyY^|F7{CMoz=+PN
z2=GXpJ-t5|a?8l&deBw$6dTBEC<ub-am_D9!!MDWnTzR7*cFB6Ux`+feeCuqmouOC
zubfsi;xd5VzX?CINzg+aX~ILjD5_fL<&kl<N~PY$vhI<fq?v#m4)eJ(JtUPf-#yl`
zk2OC2RcT>dnIbEc)s3h7U3x}XUFTzmk441Kp4|_@I-3^b9_6!43zZ}$Op*dPgJOw^
zlH_ES&bu8=xS9Z2Kv?x@7yD-)gSZ`zCUA*^6|Dy><iZbm<k<BLOSc9&?_pNYAU@U~
zmjadMNJqN(qME6K&EO~Cv#zsGml?%%tIVjp1eMpCRX0^)!Wt(g7VfFr(dwpzD55)1
zTOgiLxWpLZJy<{42<wLH^swtOhC+p6DfR~x5QV)3X<DZxa`CsK^;*C28h^stUM*%s
zJMwZR|4p<(6TD%+eBbtKPYSdP@7#g?O&eO<ZG3Bg)ef3L<3DC?)P#+P@384Z8(s*k
zM;GEyJYnrtEiQdaUAO6hxZBM(sEnHrQF*Yo5SeI4?Sp1pvSxGv<eCTFzs(j}F1rw~
z*vX5N=O<5_0BLddQIHlis_1FZwI7R}Wxl71B`9M_?&-8VQkvk<56OGnVLpLwym#oQ
zmGS0ziT2j(nq9R{QMVX%>9TFGiu;{~de)C{K<v^1#wAzOi*<^_b<aeTiv!w8pcyYa
zUX{NZmkx*r)=2CP@vt-2m*34kQH#2G^&BEX?gKvNff(@-w17|eNNn*?>~Qgq_|J{b
z#+%IOstyfaKgQqsa}q=)%PIZIYWe~$<ZBrhuz*LNrZw=@;_ENo%@kTA@y%{*1Z@k`
UcE{jVSJ_`vlGaC!+{wfL0m%2G`v3p{

literal 0
HcmV?d00001

diff --git a/hirise_blender/planetaryimage/__pycache__/image.cpython-310.pyc b/hirise_blender/planetaryimage/__pycache__/image.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..ab5ea8f363b1c589725d7710ba3fc6ad85b0255d
GIT binary patch
literal 6325
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

literal 0
HcmV?d00001

diff --git a/hirise_blender/planetaryimage/__pycache__/pds3image.cpython-310.pyc b/hirise_blender/planetaryimage/__pycache__/pds3image.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..00b0d26069e0bb1d884e9fe787616e06f70d430d
GIT binary patch
literal 9110
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

literal 0
HcmV?d00001

diff --git a/hirise_blender/planetaryimage/__pycache__/specialpixels.cpython-310.pyc b/hirise_blender/planetaryimage/__pycache__/specialpixels.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..f0ddf2fd9b63ac11ee42a9bec843b7fe521053ff
GIT binary patch
literal 1505
zcma)6OK%iM5bl}Tm)F>U4GC|WHyeoek^@2!N^p>3$+ny<2(*_~v(>xX&P>m$d&bxi
zk|V*D`~nWiB~tzizhF3W$(|zRh95gr&CbdzO9Z+#U)5Jz)zw{9+Hhv3%5a&tEA8Ja
zjJ+c=xn_}khoAii0a%lP1Fr8h9q_tN(}e;QU$UkLCA8Bn<F3He>oQc4m0%i<zzoc0
zmZNYCj>8<x!wEQ<S-yZT;S`*PGjJBpkwtoN9xl9aQC`d?&*i0DUe4u}OgeuQ;Od{w
zdNGf_2G_Ib8@arh%UUkK%H^$0QuOU{G<^NK)GUG9V6_GDm%|ue47H7fjx6tlhA&xV
zd804eO89(DZA#xRRI41<iqdyEf7p{eP+A3Xz&C`ifH0O>tl)hLSjgO0W8c3!I)V3u
z<vQdbBEiLmP`-HT%aPl%vUqBih(AL&KYS()e;URbxD`=sL?nTSnn##e;Z02(NF9xW
ze>@c2Q{CR@M=zVtNe!`4y2}M`he1D%M5IEUXFnAGk?bEoU`1?>D=IeszoG*iOtzZL
zHr5_2E`7h;T3dSZV7bwD$(%3J3-~SKXXg+iw(dM<&v9U1x!|5=*m7^R<|IXkw))aw
z?^(@FiaHMZTS>KJ!T_s_Z$+brM&qHw-^`Rz?EF;kg@LR?Tl#+7ZmW7%MfILC%E}h@
zQiC*yY2O!GM#5~VKy+o@j%F&G5W9dGr&@vdMYb^0JZ7+T{W-@>p%~EB1}VW1p;k^j
z9KNJLBh~b<Z3xOH9=0FBAYdg2blm}+qJ|i%QiA^oj{TOViV-*jE`di-AV{~-WhdQE
z)h@vv!9Kx|ARR%vZK<?Kc7FBlb-o$1-LbMaR`$oraIB<>ivjqz!_t3KTG<hICM~;@
zWN(t}Pm<vzp=0mVO39H&+N!RWaDOY32kdcZAgMO8Uow4Wq%Y}6cBM%QKTF{!r60l=
z+lLh{w^|UkTP;KHBqn?x8MPxRc9iafi5G}XLj}%8Vgl%GN#)xhgxHt&sCjlBq2N}g
hOK!z;%dT^<3-8_O1LiuP=9TG+Gu~D7Kg_FdJ^+o?;nV;C

literal 0
HcmV?d00001

diff --git a/hirise_blender/planetaryimage/cubefile.py b/hirise_blender/planetaryimage/cubefile.py
new file mode 100644
index 0000000..1266116
--- /dev/null
+++ b/hirise_blender/planetaryimage/cubefile.py
@@ -0,0 +1,255 @@
+# -*- coding: utf-8 -*-
+import numpy
+
+from .image import PlanetaryImage
+from .specialpixels import SPECIAL_PIXELS
+from .decoders import BandSequentialDecoder, TileDecoder
+
+
+class CubeFile(PlanetaryImage):
+    """A Isis Cube file reader.
+
+    Examples
+    --------
+      >>> from planetaryimage import CubeFile
+      >>> image = CubeFile.open('tests/data/pattern.cub')
+      >>> # Examples of CubeFile Attributes
+      >>> image.base
+      0.0
+      >>> image.multiplier
+      1.0
+      >>> image.specials['His']
+      -3.4028233e+38
+      >>> image.tile_lines
+      128
+      >>> image.tile_samples
+      128
+      >>> image.tile_shape
+      (128, 128)
+
+    """
+
+    PIXEL_TYPES = {
+        'UnsignedByte': numpy.dtype('uint8'),
+        'SignedByte': numpy.dtype('int8'),
+        'UnsignedWord': numpy.dtype('uint16'),
+        'SignedWord': numpy.dtype('int16'),
+        'UnsignedInteger': numpy.dtype('uint32'),
+        'SignedInteger': numpy.dtype('int32'),
+        'Real': numpy.dtype('float32'),
+        'Double': numpy.dtype('float64')
+    }
+
+    BYTE_ORDERS = {
+        'NoByteOrder': '=',  # system
+        'Lsb': '<',          # little-endian
+        'Msb': '>'           # big-endian
+    }
+
+    SPECIAL_PIXELS = SPECIAL_PIXELS
+
+    def _save(self, file_to_write, overwrite):
+        raise NotImplementedError
+
+    def _create_label(self, array):
+        raise NotImplementedError
+
+    @property
+    def _bands(self):
+        return self.label['IsisCube']['Core']['Dimensions']['Bands']
+
+    @property
+    def _lines(self):
+        return self.label['IsisCube']['Core']['Dimensions']['Lines']
+
+    @property
+    def _samples(self):
+        return self.label['IsisCube']['Core']['Dimensions']['Samples']
+
+    @property
+    def _format(self):
+        return self.label['IsisCube']['Core']['Format']
+
+    @property
+    def _start_byte(self):
+        return self.label['IsisCube']['Core']['StartByte'] - 1
+
+    @property
+    def _dtype(self):
+        return self._pixel_type.newbyteorder(self._byte_order)
+
+    @property
+    def base(self):
+        """An additive factor by which to offset pixel DN."""
+        return self.label['IsisCube']['Core']['Pixels']['Base']
+
+    @property
+    def multiplier(self):
+        """A multiplicative factor by which to scale pixel DN."""
+        return self.label['IsisCube']['Core']['Pixels']['Multiplier']
+
+    @property
+    def tile_lines(self):
+        """Number of lines per tile."""
+        if self.format != 'Tile':
+            return None
+        return self.label['IsisCube']['Core']['TileLines']
+
+    @property
+    def tile_samples(self):
+        """Number of samples per tile."""
+        if self.format != 'Tile':
+            return None
+        return self.label['IsisCube']['Core']['TileSamples']
+
+    @property
+    def tile_shape(self):
+        """Shape of tiles."""
+        if self.format != 'Tile':
+            return None
+        return (self.tile_lines, self.tile_samples)
+
+    @property
+    def _byte_order(self):
+        return self.BYTE_ORDERS[self._pixels_group['ByteOrder']]
+
+    @property
+    def _pixels_group(self):
+        return self.label['IsisCube']['Core']['Pixels']
+
+    @property
+    def _pixel_type(self):
+        return self.PIXEL_TYPES[self._pixels_group['Type']]
+
+    @property
+    def specials(self):
+        """Return the special pixel values"""
+        pixel_type = self._pixels_group['Type']
+        return self.SPECIAL_PIXELS[pixel_type]
+
+    @property
+    def data_filename(self):
+        """Return detached filename else None."""
+        return self.label['IsisCube']['Core'].get('^Core')
+
+    def apply_scaling(self, copy=True):
+        """Scale pixel values to there true DN.
+
+        Parameters
+        ----------
+        copy: bool [True]
+            Whether to apply the scaling to a copy of the pixel data
+            and leave the original unaffected
+
+        Returns
+        -------
+        Numpy Array
+            A scaled version of the pixel data
+
+        """
+        if copy:
+            return self.multiplier * self.data + self.base
+
+        if self.multiplier != 1:
+            self.data *= self.multiplier
+
+        if self.base != 0:
+            self.data += self.base
+
+        return self.data
+
+    def apply_numpy_specials(self, copy=True):
+        """Convert isis special pixel values to numpy special pixel values.
+
+            =======  =======
+             Isis     Numpy
+            =======  =======
+            Null     nan
+            Lrs      -inf
+            Lis      -inf
+            His      inf
+            Hrs      inf
+            =======  =======
+
+        Parameters
+        ----------
+        copy : bool [True]
+            Whether to apply the new special values to a copy of the
+            pixel data and leave the original unaffected
+
+        Returns
+        -------
+        Numpy Array
+            A numpy array with special values converted to numpy's nan, inf,
+            and -inf
+        """
+        if copy:
+            data = self.data.astype(numpy.float64)
+
+        elif self.data.dtype != numpy.float64:
+            data = self.data = self.data.astype(numpy.float64)
+
+        else:
+            data = self.data
+
+        data[data == self.specials['Null']] = numpy.nan
+        data[data < self.specials['Min']] = numpy.NINF
+        data[data > self.specials['Max']] = numpy.inf
+
+        return data
+
+    def specials_mask(self):
+        """Create a pixel map for special pixels.
+
+        Returns
+        -------
+        An array where the value is `False` if the pixel is special
+        and `True` otherwise
+        """
+        mask = self.data >= self.specials['Min']
+        mask &= self.data <= self.specials['Max']
+        return mask
+
+    def get_image_array(self):
+        """Create an array for use in making an image.
+
+        Creates a linear stretch of the image and scales it to between `0` and
+        `255`. `Null`, `Lis` and `Lrs` pixels are set to `0`. `His` and `Hrs`
+        pixels are set to `255`.
+
+        Usage::
+
+            from planetaryimage import CubeFile
+            from PIL import Image
+
+            # Read in the image and create the image data
+            image = CubeFile.open('test.cub')
+            data = image.get_image_array()
+
+            # Save the first band to a new file
+            Image.fromarray(data[0]).save('test.png')
+
+        Returns
+        -------
+            A uint8 array of pixel values.
+        """
+        specials_mask = self.specials_mask()
+        data = self.data.copy()
+
+        data[specials_mask] -= data[specials_mask].min()
+        data[specials_mask] *= 255 / data[specials_mask].max()
+
+        data[data == self.specials['His']] = 255
+        data[data == self.specials['Hrs']] = 255
+
+        return data.astype(numpy.uint8)
+
+    @property
+    def _decoder(self):
+        if self.format == 'BandSequential':
+            return BandSequentialDecoder(self.dtype, self.shape)
+
+        if self.format == 'Tile':
+            return TileDecoder(self.dtype, self.shape, self.tile_shape)
+
+        raise ValueError('Unkown format (%s)' % self.format)
diff --git a/hirise_blender/planetaryimage/decoders.py b/hirise_blender/planetaryimage/decoders.py
new file mode 100644
index 0000000..5044147
--- /dev/null
+++ b/hirise_blender/planetaryimage/decoders.py
@@ -0,0 +1,49 @@
+import numpy
+#from ..six.moves import range
+
+
+class BandSequentialDecoder(object):
+    def __init__(self, dtype, shape, compression=None):
+        self.dtype = dtype
+        self.shape = shape
+        self.sample_bytes = dtype.itemsize
+        self.compression = compression
+
+    @property
+    def size(self):
+        return numpy.product(self.shape)
+
+    def decode(self, stream):
+        if self.compression:
+            data = numpy.fromstring(stream.read(self.size*self.sample_bytes), self.dtype)
+        else:
+            data = numpy.fromfile(stream, self.dtype, self.size)
+        return data.reshape(self.shape)
+
+
+class TileDecoder(object):
+    def __init__(self, dtype, shape, tile_shape):
+        self.dtype = dtype
+        self.shape = shape
+        self.tile_shape = tile_shape
+
+    def decode(self, stream):
+        bands, lines, samples = self.shape
+        tile_lines, tile_samples = self.tile_shape
+        tile_size = tile_lines * tile_samples
+        data = numpy.empty(self.shape, dtype=self.dtype)
+
+        for band in data:
+            for line in range(0, lines, tile_lines):
+                for sample in range(0, samples, tile_samples):
+                    sample_end = sample + tile_samples
+                    line_end = line + tile_lines
+                    chunk = band[line:line_end, sample:sample_end]
+
+                    tile = numpy.fromfile(stream, self.dtype, tile_size)
+                    tile = tile.reshape((tile_lines, tile_samples))
+
+                    chunk_lines, chunk_samples = chunk.shape
+                    chunk[:] = tile[:chunk_lines, :chunk_samples]
+
+        return data
diff --git a/hirise_blender/planetaryimage/image.py b/hirise_blender/planetaryimage/image.py
new file mode 100644
index 0000000..e395b05
--- /dev/null
+++ b/hirise_blender/planetaryimage/image.py
@@ -0,0 +1,217 @@
+# -*- coding: utf-8 -*-
+import os
+import gzip
+import bz2
+from ..six import string_types # not found
+from ..pvl import load # not found
+import numpy
+
+
+class PlanetaryImage(object):
+    """A generic image reader. Parent object for PDS3Image and CubeFile
+
+    Parameters
+    ----------
+
+    stream
+        file object to read as an image file
+
+    filename : string
+        an optional filename to attach to the object
+
+    compression : string
+        an optional string that indicate the compression type 'bz2' or 'gz'
+
+    Attributes
+    ----------
+    compression : string
+        Compression type (i.e. 'gz', 'bz2', or None).
+
+    data : numpy array
+        A numpy array representing the image.
+
+    filename : string
+        The filename given.
+
+    label : pvl module
+        The image's label in dictionary form.
+
+    Examples
+    --------
+    >>> from planetaryimage import PDS3Image
+    >>> testfile = 'tests/mission_data/2p129641989eth0361p2600r8m1.img'
+    >>> image = PDS3Image.open(testfile)
+    >>> # Examples of attributes
+    >>> image.bands
+    1
+    >>> image.lines
+    64
+    >>> image.samples
+    64
+    >>> str(image.format)
+    'BAND_SEQUENTIAL'
+    >>> image.data_filename
+    >>> image.dtype
+    dtype('>i2')
+    >>> image.start_byte
+    34304
+    >>> image.shape
+    (1, 64, 64)
+    >>> image.size
+    4096
+
+    See https://planetaryimage.readthedocs.io/en/latest/usage.html to see how
+    to open images to view them and make manipulations.
+
+    """
+
+    @classmethod
+    def open(cls, filename):
+        """ Read an image file from disk
+
+        Parameters
+        ----------
+        filename : string
+            Name of file to read as an image file.  This file may be gzip
+            (``.gz``) or bzip2 (``.bz2``) compressed.
+        """
+        if filename.endswith('.gz'):
+            fp = gzip.open(filename, 'rb')
+            try:
+                return cls(fp, filename, compression='gz')
+            finally:
+                fp.close()
+        elif filename.endswith('.bz2'):
+            fp = bz2.BZ2File(filename, 'rb')
+            try:
+                return cls(fp, filename, compression='bz2')
+            finally:
+                fp.close()
+        else:
+            with open(filename, 'rb') as fp:
+                return cls(fp, filename)
+
+    def __init__(self, stream_string_or_array, filename=None, compression=None):
+        """
+        Create an Image object.
+        """
+        
+        if isinstance(stream_string_or_array, string_types):
+            error_msg = (
+                'A file like object is expected for stream. '
+                'Use %s.open(filename) to open a image file.'
+            )
+            raise TypeError(error_msg % type(self).__name__)
+        if isinstance(stream_string_or_array, numpy.ndarray):
+            self.filename = None
+            self.compression = None
+            self.data = stream_string_or_array
+            self.label = self._create_label(stream_string_or_array)
+        else:
+            #: The filename if given, otherwise none.
+            self.filename = filename
+
+            self.compression = compression
+
+            # TODO: rename to header and add footer?
+            #: The parsed label header in dictionary form.
+            self.label = self._load_label(stream_string_or_array)
+
+            #: A numpy array representing the image
+            self.data = self._load_data(stream_string_or_array)
+
+    def __repr__(self):
+        # TODO: pick a better repr
+        return self.filename
+
+    def save(self, file_to_write=None, overwrite=False):
+        self._save(file_to_write, overwrite)
+
+    @property
+    def image(self):
+        """An Image like array of ``self.data`` convenient for image processing tasks
+
+        * 2D array for single band, grayscale image data
+        * 3D array for three band, RGB image data
+
+        Enables working with ``self.data`` as if it were a PIL image.
+
+        See https://planetaryimage.readthedocs.io/en/latest/usage.html to see
+        how to open images to view them and make manipulations.
+
+        """
+        if self.bands == 1:
+            return self.data.squeeze()
+        elif self.bands == 3:
+            return numpy.dstack(self.data)
+        # TODO: what about multiband images with 2, and 4+ bands?
+
+    @property
+    def bands(self):
+        """Number of image bands."""
+        return self._bands
+
+    @property
+    def lines(self):
+        """Number of lines per band."""
+        return self._lines
+
+    @property
+    def samples(self):
+        """Number of samples per line."""
+        return self._samples
+
+    @property
+    def format(self):
+        """Image format."""
+        return self._format
+
+    _data_filename = None
+
+    @property
+    def data_filename(self):
+        """Return detached filename else None."""
+        return self._data_filename
+
+    @property
+    def dtype(self):
+        """Pixel data type."""
+        return self._dtype
+
+    @property
+    def start_byte(self):
+        """Index of the start of the image data (zero indexed)."""
+        return self._start_byte
+
+    @property
+    def shape(self):
+        """Tuple of images bands, lines and samples."""
+        return (self.bands, self.lines, self.samples)
+
+    @property
+    def size(self):
+        """Total number of pixels"""
+        return self.bands * self.lines * self.samples
+
+    def _load_label(self, stream):
+        return load(stream)
+
+    def _load_data(self, stream):
+        if self.data_filename is not None:
+            return self._load_detached_data()
+
+        stream.seek(self.start_byte)
+        return self._decode(stream)
+
+    def create_label(self, array):
+        self._create_label(array)
+
+    def _decode(self, stream):
+        return self._decoder.decode(stream)
+
+    def _load_detached_data(self):
+        dirpath = os.path.dirname(self.filename)
+        filename = os.path.abspath(os.path.join(dirpath, self.data_filename))
+
+        with open(filename, 'rb') as stream:
+            return self._decode(stream)
diff --git a/hirise_blender/planetaryimage/pds3image.py b/hirise_blender/planetaryimage/pds3image.py
new file mode 100644
index 0000000..e53fe14
--- /dev/null
+++ b/hirise_blender/planetaryimage/pds3image.py
@@ -0,0 +1,349 @@
+# -*- coding: utf-8 -*-
+import numpy
+from ..six import string_types, integer_types
+import os
+from ..pvl import dump, dumps, encoder, load, PVLModule, Units
+import collections
+
+from .image import PlanetaryImage
+from .decoders import BandSequentialDecoder
+
+
+class Pointer(collections.namedtuple('Pointer', ['filename', 'bytes'])):
+    @staticmethod
+    def _parse_bytes(value, record_bytes):
+        if isinstance(value, integer_types):
+            return (value - 1) * record_bytes
+
+        if isinstance(value, Units) and value.units == 'BYTES':
+            return value.value
+
+        raise ValueError('Unsupported pointer type')
+
+    @classmethod
+    def parse(cls, value, record_bytes):
+        """Parses the pointer label.
+
+        Parameters
+        ----------
+        pointer_data
+            Supported values for `pointer_data` are::
+
+                ^PTR = nnn
+                ^PTR = nnn <BYTES>
+                ^PTR = "filename"
+                ^PTR = ("filename")
+                ^PTR = ("filename", nnn)
+                ^PTR = ("filename", nnn <BYTES>)
+
+        record_bytes
+            Record multiplier value
+
+        Returns
+        -------
+        Pointer object
+        """
+        if isinstance(value, string_types):
+            return cls(value, 0)
+
+        if isinstance(value, list):
+            if len(value) == 1:
+                return cls(value[0], 0)
+
+            if len(value) == 2:
+                return cls(value[0], cls._parse_bytes(value[1], record_bytes))
+
+            raise ValueError('Unsupported pointer type')
+
+        return cls(None, cls._parse_bytes(value, record_bytes))
+
+
+class PDS3Image(PlanetaryImage):
+    """A PDS3 image reader.
+
+    Examples
+    --------
+      >>> from planetaryimage import PDS3Image
+      >>> testfile = 'tests/mission_data/2p129641989eth0361p2600r8m1.img'
+      >>> image = PDS3Image.open(testfile)
+      >>> # Examples of PDS3Image Attributes
+      >>> image.dtype
+      dtype('>i2')
+      >>> image.record_bytes
+      128
+      >>> image.data_filename
+
+    """
+
+    SAMPLE_TYPES = {
+        'MSB_INTEGER': '>i',
+        'INTEGER': '>i',
+        'MAC_INTEGER': '>i',
+        'SUN_INTEGER': '>i',
+
+        'MSB_UNSIGNED_INTEGER': '>u',
+        'UNSIGNED_INTEGER': '>u',
+        'MAC_UNSIGNED_INTEGER': '>u',
+        'SUN_UNSIGNED_INTEGER': '>u',
+
+        'LSB_INTEGER': '<i',
+        'PC_INTEGER': '<i',
+        'VAX_INTEGER': '<i',
+
+        'LSB_UNSIGNED_INTEGER': '<u',
+        'PC_UNSIGNED_INTEGER': '<u',
+        'VAX_UNSIGNED_INTEGER': '<u',
+
+        'IEEE_REAL': '>f',
+        'FLOAT': '>f',
+        'REAL': '>f',
+        'MAC_REAL': '>f',
+        'SUN_REAL': '>f',
+
+        'IEEE_COMPLEX': '>c',
+        'COMPLEX': '>c',
+        'MAC_COMPLEX': '>c',
+        'SUN_COMPLEX': '>c',
+
+        'PC_REAL': '<f',
+        'PC_COMPLEX': '<c',
+
+        'MSB_BIT_STRING': '>S',
+        'LSB_BIT_STRING': '<S',
+        'VAX_BIT_STRING': '<S',
+    }
+
+    DTYPES = {
+        '>i': 'MSB_INTEGER',
+        '>u': 'MSB_UNSIGNED_INTEGER',
+        '<i': 'LSB_INTEGER',
+        '<u': 'LSB_UNSIGNED_INTEGER',
+        '>f': 'IEEE_REAL',
+        '>c': 'IEEE_COMPLEX',
+        '<f': 'PC_REAL',
+        '<c': 'PC_COMPLEX',
+        '>S': 'MSB_BIT_STRING',
+        '<S': 'LSB_BIT_STRING',
+    }
+
+    def _save(self, file_to_write, overwrite):
+        """Save PDS3Image object as PDS3 file.
+
+        Parameters
+        ----------
+        filename: Set filename for the pds image to be saved.
+        Overwrite: Use this keyword to save image with same filename.
+
+        Usage: image.save('temp.IMG', overwrite=True)
+
+        """
+        if overwrite:
+            file_to_write = self.filename
+        elif os.path.isfile(file_to_write):
+            msg = 'File ' + file_to_write + ' already exists !\n' + \
+                  'Call save() with "overwrite = True" to overwrite the file.'
+            raise IOError(msg)
+
+        encoder = encoder.PDSLabelEncoder
+        serial_label = dumps(self.label, cls=encoder)
+        label_sz = len(serial_label)
+        image_pointer = int(label_sz / self.label['RECORD_BYTES']) + 1
+        self.label['^IMAGE'] = image_pointer + 1
+
+        if self._sample_bytes != self.label['IMAGE']['SAMPLE_BITS'] * 8:
+            self.label['IMAGE']['SAMPLE_BITS'] = self.data.itemsize * 8
+
+        sample_type_to_save = self.DTYPES[self._sample_type[0] + self.dtype.kind]
+        self.label['IMAGE']['SAMPLE_TYPE'] = sample_type_to_save
+
+        if len(self.data.shape) == 3:
+            self.label['IMAGE']['BANDS'] = self.data.shape[0]
+            self.label['IMAGE']['LINES'] = self.data.shape[1]
+            self.label['IMAGE']['LINE_SAMPLES'] = self.data.shape[2]
+        else:
+            self.label['IMAGE']['BANDS'] = 1
+            self.label['IMAGE']['LINES'] = self.data.shape[0]
+            self.label['IMAGE']['LINE_SAMPLES'] = self.data.shape[1]
+
+        diff = 0
+        if len(dumps(self.label, cls=encoder)) != label_sz:
+            diff = abs(label_sz - len(dumps(self.label, cls=encoder)))
+        dump(self.label, file_to_write, cls=encoder)
+        offset = image_pointer * self.label['RECORD_BYTES'] - label_sz
+        stream = open(file_to_write, 'a')
+        for i in range(0, offset+diff):
+            stream.write(" ")
+
+        if (self._bands > 1 and self._format != 'BAND_SEQUENTIAL'):
+            raise NotImplementedError
+        else:
+            self.data.tofile(stream, format='%' + self.dtype.kind)
+        stream.close()
+
+    def _create_label(self, array):
+        """Create sample PDS3 label for NumPy Array.
+        It is called by 'image.py' to create PDS3Image object
+        from Numpy Array.
+
+        Returns
+        -------
+        PVLModule label for the given NumPy array.
+
+        Usage: self.label = _create_label(array)
+
+        """
+        if len(array.shape) == 3:
+            bands = array.shape[0]
+            lines = array.shape[1]
+            line_samples = array.shape[2]
+        else:
+            bands = 1
+            lines = array.shape[0]
+            line_samples = array.shape[1]
+        record_bytes = line_samples * array.itemsize
+        label_module = PVLModule([
+            ('PDS_VERSION_ID', 'PDS3'),
+            ('RECORD_TYPE', 'FIXED_LENGTH'),
+            ('RECORD_BYTES', record_bytes),
+            ('LABEL_RECORDS', 1),
+            ('^IMAGE', 1),
+            ('IMAGE',
+                {'BANDS': bands,
+                 'LINES': lines,
+                 'LINE_SAMPLES': line_samples,
+                 'MAXIMUM': 0,
+                 'MEAN': 0,
+                 'MEDIAN': 0,
+                 'MINIMUM': 0,
+                 'SAMPLE_BITS': array.itemsize * 8,
+                 'SAMPLE_TYPE': 'MSB_INTEGER',
+                 'STANDARD_DEVIATION': 0})
+            ])
+        return self._update_label(label_module, array)
+
+    def _update_label(self, label, array):
+        """Update PDS3 label for NumPy Array.
+        It is called by '_create_label' to update label values
+        such as,
+        - ^IMAGE, RECORD_BYTES
+        - STANDARD_DEVIATION
+        - MAXIMUM, MINIMUM
+        - MEDIAN, MEAN
+
+        Returns
+        -------
+        Update label module for the NumPy array.
+
+        Usage: self.label = self._update_label(label, array)
+
+        """
+        maximum = float(numpy.max(array))
+        mean = float(numpy.mean(array))
+        median = float(numpy.median(array))
+        minimum = float(numpy.min(array))
+        stdev = float(numpy.std(array, ddof=1))
+
+        encoder = encoder.PDSLabelEncoder
+        serial_label = dumps(label, cls=encoder)
+        label_sz = len(serial_label)
+        image_pointer = int(label_sz / label['RECORD_BYTES']) + 1
+
+        label['^IMAGE'] = image_pointer + 1
+        label['LABEL_RECORDS'] = image_pointer
+        label['IMAGE']['MEAN'] = mean
+        label['IMAGE']['MAXIMUM'] = maximum
+        label['IMAGE']['MEDIAN'] = median
+        label['IMAGE']['MINIMUM'] = minimum
+        label['IMAGE']['STANDARD_DEVIATION'] = stdev
+
+        return label
+
+    @property
+    def _bands(self):
+        try:
+            if len(self.data.shape) == 3:
+                return self.data.shape[0]
+            else:
+                return 1
+        except AttributeError:
+            return self.label['IMAGE'].get('BANDS', 1)
+
+    @property
+    def _lines(self):
+        try:
+            if len(self.data.shape) == 3:
+                return self.data.shape[1]
+            else:
+                return self.data.shape[0]
+        except AttributeError:
+            return self.label['IMAGE']['LINES']
+
+    @property
+    def _samples(self):
+        try:
+            if len(self.data.shape) == 3:
+                return self.data.shape[2]
+            else:
+                return self.data.shape[1]
+        except AttributeError:
+            return self.label['IMAGE']['LINE_SAMPLES']
+
+    @property
+    def _format(self):
+        return self.label['IMAGE'].get('BAND_STORAGE_TYPE', 'BAND_SEQUENTIAL')
+
+    @property
+    def _start_byte(self):
+        return self._image_pointer.bytes
+
+    @property
+    def _data_filename(self):
+        return self._image_pointer.filename
+
+    @property
+    def _dtype(self):
+        return self._pixel_type.newbyteorder(self._byte_order)
+
+    @property
+    def record_bytes(self):
+        """Number of bytes for fixed length records."""
+        return self.label.get('RECORD_BYTES', 0)
+
+    @property
+    def _image_pointer(self):
+        return Pointer.parse(self.label['^IMAGE'], self.record_bytes)
+
+    @property
+    def _sample_type(self):
+        sample_type = self.label['IMAGE']['SAMPLE_TYPE']
+        try:
+            return self.SAMPLE_TYPES[sample_type]
+        except KeyError:
+            raise ValueError('Unsupported sample type: %r' % sample_type)
+
+    @property
+    def _sample_bytes(self):
+        # get bytes to match NumPy dtype expressions
+        try:
+            return self.data.itemsize
+        except AttributeError:
+            return int(self.label['IMAGE']['SAMPLE_BITS'] / 8)
+
+    # FIXME:  This dtype overrides the Image.dtype right?  Then whats the point
+    # of _dtype above here ^^, should we just rename this one _dtype and remove
+    # the other one?
+    @property
+    def dtype(self):
+        """Pixel data type."""
+        try:
+            return self.data.dtype
+        except AttributeError:
+            return numpy.dtype('%s%d' % (self._sample_type, self._sample_bytes))
+
+    @property
+    def _decoder(self):
+        if self.format == 'BAND_SEQUENTIAL':
+            return BandSequentialDecoder(
+                self.dtype, self.shape, self.compression
+            )
+        raise ValueError('Unkown format (%s)' % self.format)
diff --git a/hirise_blender/planetaryimage/specialpixels.py b/hirise_blender/planetaryimage/specialpixels.py
new file mode 100644
index 0000000..cfbb8f3
--- /dev/null
+++ b/hirise_blender/planetaryimage/specialpixels.py
@@ -0,0 +1,84 @@
+# -*- coding: utf-8 -*-
+
+""" Constants for Isis Special Pixels.
+
+    Min:  The minimum valid value for a pixel.
+    Null: Pixel has no data available.
+    Lis:  Pixel was lower bound saturated on the instrument.
+    His:  Pixel was higher bound saturated on the instrument.
+    Lrs:  Pixel was lower bound saturated during a computation.
+    Hrs:  Pixel was higher bound saturated during a computation.
+    Max:  The maximum valid value for a pixel.
+"""
+
+import numpy
+
+__all__ = ['SPECIAL_PIXELS']
+
+
+def _make_num(num, dtype):
+    return numpy.fromstring(num, dtype=dtype)[0]
+
+
+SPECIAL_PIXELS = {
+
+    'UnsignedByte': {
+        'Min': 1,
+        'Null': 0,
+        'Lrs': 0,
+        'Lis': 0,
+        'His': 255,
+        'Hrs': 255,
+        'Max': 254
+    },
+
+    'UnsignedWord': {
+        'Min': 3,
+        'Null': 0,
+        'Lrs': 1,
+        'Lis': 2,
+        'His': 65534,
+        'Hrs': 65535,
+        'Max': 65522
+    },
+
+    'SignedWord': {
+        'Min': -32752,
+        'Null': -32768,
+        'Lrs': -32767,
+        'Lis': -32766,
+        'His': -32765,
+        'Hrs': -32764,
+        'Max': 32767
+    },
+
+    'SignedInteger': {
+        'Min': -8388614,
+        'Null': -8388613,
+        'Lrs': -8388612,
+        'Lis': -8388611,
+        'His': -8388610,
+        'Hrs': -8388609,
+        'Max': 2147483647
+    },
+
+    'Real': {
+        'Min': _make_num(b'\xFF\x7F\xFF\xFA', '>f4'),
+        'Null': _make_num(b'\xFF\x7F\xFF\xFB', '>f4'),
+        'Lrs': _make_num(b'\xFF\x7F\xFF\xFC', '>f4'),
+        'Lis': _make_num(b'\xFF\x7F\xFF\xFD', '>f4'),
+        'His': _make_num(b'\xFF\x7F\xFF\xFE', '>f4'),
+        'Hrs': _make_num(b'\xFF\x7F\xFF\xFF', '>f4'),
+        'Max': numpy.finfo('f4').max
+    },
+
+    'Double': {
+        'Min': _make_num(b'\xFF\xEF\xFF\xFF\xFF\xFF\xFF\xFA', '>f8'),
+        'Null': _make_num(b'\xFF\xEF\xFF\xFF\xFF\xFF\xFF\xFB', '>f8'),
+        'Lrs': _make_num(b'\xFF\xEF\xFF\xFF\xFF\xFF\xFF\xFC', '>f8'),
+        'Lis': _make_num(b'\xFF\xEF\xFF\xFF\xFF\xFF\xFF\xFD', '>f8'),
+        'His': _make_num(b'\xFF\xEF\xFF\xFF\xFF\xFF\xFF\xFE', '>f8'),
+        'Hrs': _make_num(b'\xFF\xEF\xFF\xFF\xFF\xFF\xFF\xFF', '>f8'),
+        'Max': numpy.finfo('f8').max
+    }
+}
diff --git a/hirise_blender/pvl/__init__.py b/hirise_blender/pvl/__init__.py
new file mode 100644
index 0000000..8b71efd
--- /dev/null
+++ b/hirise_blender/pvl/__init__.py
@@ -0,0 +1,268 @@
+# -*- coding: utf-8 -*-
+"""Python implementation of PVL (Parameter Value Language)."""
+
+# Copyright 2015, 2017, 2019-2021, ``pvl`` library authors.
+#
+# Reuse is permitted under the terms of the license.
+# The AUTHORS file and the LICENSE file are at the
+# top level of this library.
+
+import inspect
+import io
+import urllib.request
+from pathlib import Path
+
+from .encoder import PDSLabelEncoder, PVLEncoder
+from .parser import PVLParser, OmniParser
+from .collections import (
+    PVLModule,
+    PVLGroup,
+    PVLObject,
+    Quantity,
+    Units,
+)
+
+__author__ = "The pvl Developers"
+__email__ = "rbeyer@rossbeyer.net"
+__version__ = "1.3.2"
+__all__ = [
+    "load",
+    "loads",
+    "dump",
+    "dumps",
+    "PVLModule",
+    "PVLGroup",
+    "PVLObject",
+    "Quantity",
+    "Units",
+]
+
+
+def load(
+        path,
+        parser=None,
+        grammar=None,
+        decoder=None,
+        encoding=None,
+        **kwargs
+):
+    """Returns a Python object from parsing the file at *path*.
+
+    :param path: an :class:`os.PathLike` which presumably has a
+        PVL Module in it to parse.
+    :param parser: defaults to :class:`pvl.parser.OmniParser()`.
+    :param grammar: defaults to :class:`pvl.grammar.OmniGrammar()`.
+    :param decoder: defaults to :class:`pvl.decoder.OmniDecoder()`.
+    :param encoding: defaults to None, and has the same meaning as
+        for :py:func:`open()`.
+    :param ``**kwargs``: the keyword arguments that will be passed
+        to :func:`loads()` and are described there.
+
+    If *path* is not an :class:`os.PathLike`, it will be assumed to be an
+    already-opened file object, and ``.read()`` will be applied
+    to extract the text.
+
+    If the :class:`os.PathLike` or file object contains some bytes
+    decodable as text, followed by some that is not (e.g. an ISIS
+    cube file), that's fine, this function will just extract the
+    decodable text.
+    """
+    return loads(
+        get_text_from(path, encoding=encoding),
+        parser=parser,
+        grammar=grammar,
+        decoder=decoder,
+        **kwargs
+    )
+
+
+def get_text_from(path, encoding=None) -> str:
+    try:
+        p = Path(path)
+        return p.read_text(encoding=encoding)
+    except UnicodeDecodeError:
+        # This may be the result of an ISIS cube file (or anything else)
+        # where the first set of bytes might be decodable, but once the
+        # image data starts, they won't be, and the above tidy function
+        # fails.  So open the file as a bytestream, and read until
+        # we can't decode.  We don't want to just run the .read_bytes()
+        # method of Path, because this could be a giant file.
+        with open(path, mode="rb") as f:
+            return decode_by_char(f)
+    except TypeError:
+        # Not an os.PathLike, maybe it is an already-opened file object
+        if path.readable():
+            position = path.tell()
+            try:
+                s = path.read()
+                if isinstance(s, bytes):
+                    # Oh, it was opened in 'b' mode, need to rewind and
+                    # decode.  Since the 'catch' below already does that,
+                    # we'll just emit a ... contrived ... UnicodeDecodeError
+                    # so we don't have to double-write the code:
+                    raise UnicodeDecodeError(
+                        "utf_8",
+                        "dummy".encode(),
+                        0,
+                        1,
+                        "file object in byte mode",
+                    )
+            except UnicodeDecodeError:
+                # All of the bytes weren't decodeable, maybe the initial
+                # sequence is (as above)?
+                path.seek(position)  # Reset after the previous .read():
+                s = decode_by_char(path)
+
+        else:
+            # Not a path, not an already-opened file.
+            raise TypeError(
+                "Expected an os.PathLike or an already-opened "
+                "file object, but did not get either."
+            )
+        return s
+
+
+def decode_by_char(f: io.RawIOBase) -> str:
+    """Returns a ``str`` decoded from the characters in *f*.
+
+    :param f: is expected to be a file object which has been
+        opened in binary mode ('rb') or just read mode ('r').
+
+    The *f* stream will have one character or byte at a time read from it,
+    and will attempt to decode each to a string and accumulate
+    those individual strings together.  Once the end of the file is found
+    or an element can no longer be decoded as UTF, the accumulated string will
+    be returned.
+    """
+    s = ""
+    try:
+        for elem in iter(lambda: f.read(1), b""):
+            if isinstance(elem, str):
+                if elem == "":
+                    break
+                s += elem
+            else:
+                s += elem.decode()
+
+    except UnicodeError:
+        # Expecting this to mean that we got to the end of decodable
+        # bytes, so we're all done, and pass through to return s.
+        pass
+
+    return s
+
+
+def loadu(url, parser=None, grammar=None, decoder=None, **kwargs):
+    """Returns a Python object from parsing *url*.
+
+        :param url: this will be passed to :func:`urllib.request.urlopen`
+            and can be a string or a :class:`urllib.request.Request` object.
+        :param parser: defaults to :class:`pvl.parser.OmniParser()`.
+        :param grammar: defaults to :class:`pvl.grammar.OmniGrammar()`.
+        :param decoder: defaults to :class:`pvl.decoder.OmniDecoder()`.
+        :param ``**kwargs``: the keyword arguments that will be passed
+            to :func:`urllib.request.urlopen` and to :func:`loads()`.
+
+        The ``**kwargs`` will first be scanned for arguments that
+        can be given to :func:`urllib.request.urlopen`.  If any are
+        found, they are extracted and used.  All remaining elements
+        will be passed on as keyword arguments to :func:`loads()`.
+
+        Note that *url* can be any URL that :func:`urllib.request.urlopen`
+        takes.  Certainly http and https URLs, but also file, ftp, rsync,
+        sftp and more!
+        """
+
+    # Peel off the args for urlopen:
+    url_args = dict()
+    for a in inspect.signature(urllib.request.urlopen).parameters.keys():
+        if a in kwargs:
+            url_args[a] = kwargs.pop(a)
+
+    # The object returned from urlopen will always have a .read()
+    # function that returns bytes, so:
+    with urllib.request.urlopen(url, **url_args) as resp:
+        s = decode_by_char(resp)
+
+    return loads(s, parser=parser, grammar=grammar, decoder=decoder, **kwargs)
+
+
+def loads(s: str, parser=None, grammar=None, decoder=None, **kwargs):
+    """Deserialize the string, *s*, as a Python object.
+
+    :param s: contains some PVL to parse.
+    :param parser: defaults to :class:`pvl.parser.OmniParser()`.
+    :param grammar: defaults to :class:`pvl.grammar.OmniGrammar()`.
+    :param decoder: defaults to :class:`pvl.decoder.OmniDecoder()`.
+    :param ``**kwargs``: the keyword arguments to pass to the *parser* class
+        if *parser* is none.
+    """
+    # decoder = __create_decoder(cls, strict, grammar=grammar, **kwargs)
+    # return decoder.decode(s)
+
+    if isinstance(s, bytes):
+        # Someone passed us an old-style bytes sequence.  Although it isn't
+        # a string, we can deal with it:
+        s = s.decode()
+
+    if parser is None:
+        parser = OmniParser(grammar=grammar, decoder=decoder, **kwargs)
+    elif not isinstance(parser, PVLParser):
+        raise TypeError("The parser must be an instance of pvl.PVLParser.")
+
+    return parser.parse(s)
+
+
+def dump(module, path, **kwargs):
+    """Serialize *module* as PVL text to the provided *path*.
+
+    :param module: a ``PVLModule`` or ``dict``-like object to serialize.
+    :param path: an :class:`os.PathLike`
+    :param ``**kwargs``: the keyword arguments to pass to :func:`dumps()`.
+
+    If *path* is an :class:`os.PathLike`, it will attempt to be opened
+    and the serialized module will be written into that file via
+    the :func:`pathlib.Path.write_text()` function, and will return
+    what that function returns.
+
+    If *path* is not an :class:`os.PathLike`, it will be assumed to be an
+    already-opened file object, and ``.write()`` will be applied
+    on that object to write the serialized module, and will return
+    what that function returns.
+    """
+    try:
+        p = Path(path)
+        return p.write_text(dumps(module, **kwargs))
+
+    except TypeError:
+        # Not an os.PathLike, maybe it is an already-opened file object
+        try:
+            if isinstance(path, io.TextIOBase):
+                return path.write(dumps(module, **kwargs))
+            else:
+                return path.write(dumps(module, **kwargs).encode())
+        except AttributeError:
+            # Not a path, not an already-opened file.
+            raise TypeError(
+                "Expected an os.PathLike or an already-opened "
+                "file object for writing, but got neither."
+            )
+
+
+def dumps(module, encoder=None, grammar=None, decoder=None, **kwargs) -> str:
+    """Returns a string where the *module* object has been serialized
+    to PVL syntax.
+
+    :param module: a ``PVLModule`` or ``dict`` like object to serialize.
+    :param encoder: defaults to :class:`pvl.parser.PDSLabelEncoder()`.
+    :param grammar: defaults to :class:`pvl.grammar.ODLGrammar()`.
+    :param decoder: defaults to :class:`pvl.decoder.ODLDecoder()`.
+    :param ``**kwargs``: the keyword arguments to pass to the encoder
+        class if *encoder* is none.
+    """
+    if encoder is None:
+        encoder = PDSLabelEncoder(grammar=grammar, decoder=decoder, **kwargs)
+    elif not isinstance(encoder, PVLEncoder):
+        raise TypeError("The encoder must be an instance of pvl.PVLEncoder.")
+
+    return encoder.encode(module)
diff --git a/hirise_blender/pvl/__pycache__/__init__.cpython-310.pyc b/hirise_blender/pvl/__pycache__/__init__.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..eb73bdf5795f14b6cf295f982cf4ac85db3c8fd2
GIT binary patch
literal 7658
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

literal 0
HcmV?d00001

diff --git a/hirise_blender/pvl/__pycache__/collections.cpython-310.pyc b/hirise_blender/pvl/__pycache__/collections.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..385e7a90d375f50ab589795f0caa8da409b88f86
GIT binary patch
literal 24724
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

literal 0
HcmV?d00001

diff --git a/hirise_blender/pvl/__pycache__/decoder.cpython-310.pyc b/hirise_blender/pvl/__pycache__/decoder.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..fc4bb0766539a4a1a8c9ef85c937fbdd33f7ad5c
GIT binary patch
literal 16552
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

literal 0
HcmV?d00001

diff --git a/hirise_blender/pvl/__pycache__/encoder.cpython-310.pyc b/hirise_blender/pvl/__pycache__/encoder.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..5b24167f503213a480242d2a8da02f0e0be7f3bd
GIT binary patch
literal 34585
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
O-{=)Np67A=)c*#UmffiU

literal 0
HcmV?d00001

diff --git a/hirise_blender/pvl/__pycache__/exceptions.cpython-310.pyc b/hirise_blender/pvl/__pycache__/exceptions.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..76ada5cb8303b2e847ada0b621327d752544f430
GIT binary patch
literal 2972
zcmZ`*OK%%D5avF#lGc*rI&I>lZNQ|j$W82?gQ8842D!NIBS8*AfyHV`*_*6(RdTns
zh0Vz>0`xBw1?*#PJ@yy$N9?IUPyP$Jq~CBQ%T8R{9C66uaQMxGn{~TBLo5FIHu|g0
z*uTV_ZcQ+E(e(gCus#!(w1h3~p(`BW9=Lr+EDH~FO=*i3<~`9C{z0SfK4fA+bPky4
z$i}|Y_rQ0>BKSqw1m6OGK`en^GJIRS^N95>PHy`Tb|X2?<1E#Dm?@rbOa6VR!ja6S
z;!nb)kbEN^s8H>#`IV!KLFJ4y9oevO)@baY-$&O=Af=VFlI>e7xWHwGgY57(i?Q!g
zqdwHS7?~r%hB;q_(p4U79&(IyuHtlyM_HPOaViCmQ!FG|x+Rs*(Q1KPJWK^&g(+q$
znH{G>?vl9CTJM-j^K5929>!^y7%kB@E*a4su>r^4;!5U)0t%!GYGcA=zEA0#&-Y}*
z+LU5&{&{P@S%18ZTj9UZa#$p_DByjv!IK(NzOyY;z9adwG}}4vWTVDdedcr^l4s9k
zdW#Q=obQBbe%@w2jA8cK>#iC07~Wt#t8x;V_H0F*A}_vVs)3(Z_t&?xkz5y%Op+ps
z;`OaKU*C>ZtYt939wF76?D&^tU7p0!+IX*Ond1Rv7b-QWU-A`&_%S-G9Fawp16@@^
z=b_3Yho+~E#$?HTbiE8xvO@$@X_wZKBWx2?&gAbOPx&k@MgzDLo=y-qn%^AkA&QDL
zr*MK(&Bf<JsoWvCIjoxh1Uz@*eA{4Yj5n&x#(^X?X2(oNDtj}RPJ?z8S6bx*neRxr
zb#~?~m^31tF1lKWE^fYBd!w>^MHhxc8ph(Dqfj20qH3WQh!7Sv@i3~|WQY;H3f5q|
z?5RbJBlI(k6jReTK_u&2s4KRx`pyeBL~RkyL96cyS2PY-zwv^(tnVRVy~^K^yHY(+
zDpTQA1jwUe5G6=m0@#!VvvdltEJ?B*0x1;2Bu|*|vC76$<+0Rv>WmoatvmcNGOS2Z
zZAM|9Bf}*f!bei;aI1C`aID2BS8}<V15{Ey4waU|I0UHHA_h}9Vw(KeN?E0l#1N)U
z!!S;!n+UcvtM}F3&y<pSoTY*!^NcdzsE@K_CWv7%N)b!{CrZwlHF6nsf?fX!f=cL?
z&c0o;z{+g|Fnen4+s_;HTiS<?fD>qZ<gBpgUcD|bra9qUX2053*dZKrWIb;R_pnhm
zMMHQri<wqw{mw+QY=E{(542r6pnll`UHHR)-p;*!cGxUg**>x@RA$)GqEmu)2^#{x
z^gtJ2BMUl$YISE*bzrw@fgE1|d1Y}Ep2x4zCe1r_7ED?|!~ipC@|#o|`J~n3sl?#M
zE9*wDYjWL`6%(0NL!ppSwvUrIuiU3uoPsG3AXO^};xx{KpmGo)Cip9_b{3@sTmcsG
zIFdcTa<xo`>I&ItvV<y&`hW-}gL)sNzew)~;wCU<Qdi9>UwH^N9P!es+Cg9fItb>8
zrB<-{HoCqB(y=<$CF`2AY^~U~<-N9FFS?#p|M}MB;ygpvX7)!^N@tD6Cq;~GgHMfL
z@k>5;(A}Xsv>&mT)@HAvu0!U$i}ft^AuYX81$>w;MG?s$xQk^|2CiC@_s-Zgljt=G
z<rEJ)P{z(tCW?f{ognzR2$ShbGYF7DP)tauk3g#K6exNOW?&ghIEhd_QWPd6t0`z&
z%(Xi0rHf`Z!o->8PC0!8gVXg$p!%R9(RWU}@0v=~s4Ee^N3=BMX7a_ol%KpZl&?D8
z!joQ?5WKbZ7Y5#<x>TsO&9|NvGQeaf-7sg!4&(%$70M3E3!Ab)k##7;m+@nus2V1c
zFl9VpqHmQJIS~VgL4uS%MAvl8qD5gcH~%C|YW1G_m^Obx<WnM_5i!71u|DN)POQ=2
z!{{4yO&lS8$yPM?7S0rWchSuU*%_P>Zat^!{!rkvA<p+|V86ZxC`aQ&o`qM$n%>VM
z*4s0ThbkNK*=BB1Nb0rCo_p?X<{>-B=yRC0L8i^_;M$7jHWB9(Kt10efv?S6RZg7d
zbtR$at@7t@kBP6UeewZoa4?EaA$M|W)%vmy`L75WO(o8?mKRpKOYNoW@3#H}af9qu

literal 0
HcmV?d00001

diff --git a/hirise_blender/pvl/__pycache__/grammar.cpython-310.pyc b/hirise_blender/pvl/__pycache__/grammar.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..4d072ac2eff415a8b97773dd1d31351333753e79
GIT binary patch
literal 8156
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

literal 0
HcmV?d00001

diff --git a/hirise_blender/pvl/__pycache__/lexer.cpython-310.pyc b/hirise_blender/pvl/__pycache__/lexer.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..acde5778f158016ba448ba9a1124ea96b88298d3
GIT binary patch
literal 9466
zcmd5?-ESP%b)UKOv9rVFilQXy!?HY*(o(yYDK|--qEHPhlH#hBDc6#%l&-oS?VTl;
z+TEe<%!(qrEF9AhMGL()K#Q~#&;l{~fub)#Ukc=<{U7GZKp%>rPeo9`RuZYdbMDOS
zl9Cb^fq^cycW3TB_v_sA@jK@#o}Ts%e1@OC)&BEu7{-6l%j9PkFK^(R{F`YQ(pWO2
zDMiohizU&wmMqhdmb80z-&u0_+3C6c%2I`&-JaL4E>-!t()0UMOH=*YQq45pG^8i1
z9~-h7iEV3XTKZ94PT^aN_Q~mJCaOpKI%3=Gc(N|{eQYo7-$gOAhsu}x<t(UXBWK%K
zJ<u_k`T)i|I5F-F#-)+#H1f8&Yo5A1B<DVMmJU9%=ixo`)#VX+6!RUD$1wg2(Ok!t
z$K{KtIXqEwLcWBWBl78a_kli;C((NJne&~B9JzPS8F^ZM1wD>&k78fH5>=RI)MGk&
zp;MQ?D(69UoH!9xw~daV6`?#M8`$5AvU%NTyu5kxZ57|^$|wnX(fvpTo#CLJcH==3
zbYc~}{od7uACV9=L}p(e4EvcK4%7HYkN~4$W<J{ARAIj#D!e&2;yckGuf7zuV;L#*
z^RLptmz9cD=5@L%N!Q|}O@mH;Xv8=0O`0eoW66YsiOAYEmTWE^E?q7wTzb;P4n*d?
zt)e7S_oBr{HS=1nLD-L4t;}z=`mr4L=(*Nv-5rKK-J&eakU8JFaP|7-ta9<%TW?)n
zyph@OE?&8jIluSrwHuc+fAQMlrOOwuymjH~Cx$uzdM+Nler_f1N9SZa>h*^0cK6(J
zH$At~Rox_N-R?yLY<TbM+P&U6=Ip}Sh9U(!h;LFu;Tf)}|9q2MGP}JJs>~(wew2A@
z`Mxq&Md?rt+O+WEL(dMr7x7INP>hU`kmgb2j!^qY=Eyi~q(*A43Mr)ZKy<`)L)VV@
zxnYN|3B!1Y2Tp=80I#~8ZX|=Ip1v6*sp<}vgK!{sH5aRD`T;(&+fIY-02JwZ{7O1p
z>qQGeaAPHU#(?YHUM~oH>)}Qc+>W?=3c_|gXoqPu2ubXMxHDb>P2D7(G#7j(zp>Iy
z0{jcLu%2lID^YK4LTZC_CB%A?0IXYs5O;AZB*@$wBMp{mOEhbeVosWkUYg~mctdA{
zZYLN-k&I+M@fA&XFYFC@ykH)OJx?2-=!$81WXN9-Ci%+G7W*7<<Cx9kDVZ-T;k_v6
zrb#f*E1M5^F7BK}X^_Uj2Oqqh3&aA;?gt<6*>E3Tjb2?&y%-N7J$H;nsdb2GkU%HF
z(ry~{Y3a0BEm=5rKDvOHa(j{?yaLz+;vKPr4n4Cl-{L1Cb9k-lD8#Q}Wi|-|OR}nS
zjXH!MHAlr^DoRCCqy$+FlGZBNa2z#>i=wt~&a4UbB2jqlxZjTkY0|dwT72la6#Ywh
z(Sn~Et0shhIu%d_a|Cw+kvB%xJwu(y6~ZE#ku@@o8d8)>p%uak|Le<Ah%YL<WN~Gb
zMylT(kesf>>vZreGaJnLQaM>Q3f?t?+hKw;g!-@mqA$dr6enzBG!|1<BOYUYrQ2Q!
z`r$@^>F8$=r_e_zRnF~k&)w2LA?mw?l=Q6>&D@^SLIyk?tw>8Ilx_0Fp}nlAWZEVb
zO=~=>c|Xpz^-ctvQ7CI66wO>&X)2nJrz-`zWK|*4w2+@`Ycz+MQLtg-fyQiRYxf1!
z^(l_fkv&IQOCIqO$OIO9e4mzctFV99K&Vw&uWpa2951v~*j&%`Nt6~^bLs`Cjyi^-
zVQa13M-`-ainI~6d-V4NHSJO2!*rwxOB^k=RV@71K%0;msL$0*&veC%X+QQH^%APG
zDpq>0Mf6#95ZzDtu}#`vd^|jqI{vSCNsW;Ms74y@rvRSY=0~Qqw%n0($+%VDs*EZl
z_nxVar$X8z_b(0Ue9t19yLAZ~*nsy(hOD6Xm60hu{C<68$ts+rmD;P0^yO4;4+OVf
zM5~{-y0TWbTC#H37}@Mj0bMc9`xvis$HK43e=X^iG?u1qOo#ve|I@m#C}<1wTxt5b
z)`bTkN63m3JkPqUg(@Wt2GSVz((Wrn&DM$gKV^A>Wfc$CCf$AkOoJ8p)^Gs9hG`pw
zy`a}k^vJzlybde476M~pD!sGalNBb8JT(D@G-zWe8DW_9Zo0ybzpx~w4mNY=2;-54
zT_EFdurY=^`A`@~+fkkt-ct4=c^2DUjMFQ9z#{Tvkz^QLx>*&%Ef*Mr!A-eKwlak?
zh``o}bf4ToxV8rOTkt!LdBW1#!KPy!m>48H2IGNA8%)Ngu-~BK?i$XpnPxjXVd^oR
ziq}*ZaH+SU{l6lxzWMSE9u+MFvOq*(1b{?5W-{!1)L%<C78>R!;*mJld?cFZHqTuI
z&*MRF14l`0BHImg!g5iHMLEcC2Ai)Eq>Kw{#xulqjNa~rNrIk`0C+H15^x3#Rj07P
z%xpd~&#BXRR9~TjOx<Fml376Nng1SPIUSW8c*YsA37jyCjA%S<5d#|SBo$+9L$+~g
zI@B`QVj0ZLwY}DIj;v+5(b8DHgU-oW6t!cXX$ubqQ_!DqAKOpF6VIcXIsVqrI%C14
z3iUENWNy3F9dzPd#*+*w8PJRPCa<9Y400$ofEk>HA!T?37-XYX018<T-0O%H2rO}(
zebm^t5nDOo4{*}&d>JvqF9(UVYE#6r@ueEA=R>01%DPGd*bna@iYD!nQM;Q^FcaR6
zhv}s5wjm(A_-D%jAQANUIUe;)gSDEwW0paVP!fy}Q-+$2ye0?fQ!HofT9d4vzvOtj
zVJZ^XY@hbrr64x6RI!(CxX+h%lGVMkJw@xz4f&sv<Q+j#JII2p#hJq0N1|FY?I-G0
zn%+z@t1Iuf;Tp>iJzMy)@X`?QujU<7xspOydb5rIze7Cj%~m0s#PzZ1=%~0KG?Qka
z`4S-C(B<Irb_9rx=mvA@@D<$VK#2lAt|i#H8L4=}&@CzoIC!_82t~L?eYL32Jm6@?
zr%*<Nntwnu$1<L6Q!Mj!yg#+aQbEZ!ZB}?^=3(sYCiZ3n?`-Th4f^|i#46W~bwpU3
z>i@XkutV_w7i^b!2Q!+E*+kwv0p_Gwk2k+aNu4V&t@qhrs;@nB|0R<90qvi19m1}g
zHJrM5qR0%j$!`=NLU$E>`JDd=52>+jY?-NvQqVJ<`*|Z3{3Oof?1A(eTUKfTn^`bX
zrnG^-=J5uDMbs#{<-Bosb|iM}k@e6tQHOrDEgKZV0e=x6+S}$e2pQ-W?#|+!`|dao
zF(#fJ%!QI@sn1bE)21$BN@{nh9r9P%{EOl|LY)W!z9D0*`Z|}f3pWvZpiq{%ItlR$
zaQ_988!_B$1SEw_!FU=TkU~f3U!=}7@^d=}ma12%Ag=Q<W)A5{q9|R|sIZ62Y=Tdj
z1(cxXQJuLOUSu|fT$#gZfrg{4g())=89;Jwiqdp@Ex=(?0a{*R23p)b`5|Z%vN!IO
zYx?+u3xhlJ;mYP98wag}kP_QcZ-68-m)j&3#fP3tG5I#OGP3EQIoL;!@=ZV#UW91i
zXhwqln7i%%f!MNe@Hq%CX>Ig&@O3+s9QgH=ln*r9)^7ULlVYc;dp(5NISldm2wsxK
z?$*dz^>?Pw51BT!Izv<4qPK4t5YZZqE^X;P5EJtoBUe_~3#(tSQuyoDY3VWTpY0kI
zJ{v7nc<sGoJF9i<=C5~AJ6P@0bo&q}eZQc?FNZS?KYSVN9ZU2$RYii;kA8`a;BIeE
z2B!}oT?p(`NxWy|L0HJkTu5+6!`#Lf^8VacJGu!cF%DS>D$|-6Sn6Cwf+!-PlnSB@
z4X_z*7U(=zF$$nJYk#ywPJ_UI7;K(U$gwRCx|<Y;=yaX71)M2ccx0YlWE`q+!!n_n
zjhS)YOmP@a{!z_Pv7ZXMe9@u#89ZgKHZs}%0TOyZ8~w0Hy4O-sR_zRXJs6<&idOKM
z;Q(2OmW+DcJ~DqQ$=ticIE|9bN34e5wXhw*8gQ&1&@?Bh7$e&Y^!hA^@3F&&MfnsI
z31Qg!u{u0G!08k3wEL-T(x3aY8OM7;{AZ0Yz!Uq4>xd__LOk~18@!p?f9Le|`u}+5
zLDQ@HpLr%)T>qy4y_ULyVPS^oX5lG}OMaQ%$3No%hS?k%IZSYN@cz(DrWrKY<Sr-|
zjxc>r0@*^}omJBP`P3$hfpFcC&I3U%K+Q9Sv+C|tU`fyh?KYv^U(-Ezyob;!SevV`
zG<uY)7=<Z0IWQjSD)%U;ZjP*-D#pJ_wY08=xA}doZov(OyfQFI*lrJj)Sga-CoA!=
zCn<lGb_bwk*TRCGC;jr+Z9;5ygj9&^*`O2l5M`Cw;K|q;^84JBx|a3DZz+=Y8vp{8
zWqsq5nNenbwc%$q@+z%7^cl->b^!N9k?OWvkbR|dJc**%B=fsTD{oYnP@yhUtwZs<
z%BIjL5pAa3epF!4u}J<7k#jbg<#JCpic`u3lTMisOY(JI-G;NV%{soGtHsZ@4_c^&
zFnSQiIZOP^c4i$2tWej{W!GKHG%BX365r%cFzR<G9c8ZK?r_VJ=9Zm`)LOOmP0N;(
z!s>3D03H7bf8ruFW$w763Z(IDT0wHELdmJr8&$SVJh|Tk^~i<yu|G1?Dm`zDEid)+
zr)oNd)Rs4b9~wE3IBUCtQSB{<{1T+_&ASISm(v<r;rG&M{Gz|CJg~R?w2q$C&!?W-
zuKL59#@z#>suV*b`7W=j`p{J01&z77?;h3B(+ocuJNwgFeK$)xy@VYB{J4}9dniC@
z?;Jq;6y4p9+p$Nqlw<fi2O;l&H}c;zwx&i?m=}IWiuV9&M^odv<gbW_13{~!FTn4i
zjUSrE7Vd{PEAY;>F^8nss{L_o-CWliR0{*d3uEN891S8Brtl7h+(Qcx1*klR#ckXI
z-%<wg?bWEAqcK*dB70tHP<{b+may<y3gUEjy_{lRLpegdI+abqU75|ffXouEyWp}C
z<Rs2C(`G~GW9Ic*=Go=w#5fv>5I%@Cx}1S#rCfcH!QSXbJxZ|*aka(6(<OnPUu!8d
zf)$YzdWc(58h3szitfx8!4T1-7WVXPa2wI7UJg=WJU46*ma!4Ycrc$LwRVS6Pdbd+
zz)qsvYBZOd<n*HZYha>I`p^vmW#ypkgErr+5wmk!q4QBqiI8ld=h;ICCq~!B`Q0HS
zS-oxC?vbwpzV37)1pwXK(AQea-FrBZvbylwgsibR^68jPvn4aM)7{*6V^^GbYSTMK
zP(mWdbg~hYZahyU-bR)W^!XMR8kYK97=WyjuQjvi9vjx6{1l;Uf|?&w==vRanp>4E
z3K|ehklf$J9W5-sU{Jo82bGyvc=efpx_X{u;r^O>{ckYOkICPO59f@{Bg~+M^Su~C
zmb|`Dk}=GG?wZt141l?596h)CHXirDc(sJOzr}p&eIlP@Sk3{!L{5y-VOcd|BMw`w
z7HJ#`X)_D_<cOC;KK9>i^i`Ee$hNBACb|RpWv1i|1*d`mN!V2+l#5m8iOPfW@M|^$
zx4^(f!k^I1v?3(bnAQ>b1seCas9>a0qL<9<?m;%01>w(3#5|Ewd$tZ2L@^YF8OaI;
z6Ce6@+o~g4@qu0rA|XfF4Era(hj$k!<%u^%X}Y=Etgs!|($2(#Gx2Qk(-V&P$q`pP
z@+#tU*At()Q@97gpZD0cY+*mH69W1WnCM?r2a_!}PGpr<OU7;dj|H1pt4N^uzbmlh
zDGHetJ3#WH>Rl=*Hp=|yemh#@|F*%0pm|LZI3l}L>2o7~Y6wYpF#13#g{V_87Le}5
zvAsbJjJ@pJaop4AMys6Q82et%eR$^)Ea1Odybi`0$={=}#Z0v(YQTasNLQZn#34d|
zlV4x>kKK9u5!b;53vf+<YXV%WgKK`p|6KgWvsy*oI(vH7KjDj)o<}3VcbwE`;+xN>
K@IOEP+W!JacH*)C

literal 0
HcmV?d00001

diff --git a/hirise_blender/pvl/__pycache__/parser.cpython-310.pyc b/hirise_blender/pvl/__pycache__/parser.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..2ea09c7c1ae18b04754614b415fa2c40546b8307
GIT binary patch
literal 26379
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
z%0D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

literal 0
HcmV?d00001

diff --git a/hirise_blender/pvl/__pycache__/token.cpython-310.pyc b/hirise_blender/pvl/__pycache__/token.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..a50471e2c10f1a920e537ac2edf2d7fe99dd27ad
GIT binary patch
literal 10638
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

literal 0
HcmV?d00001

diff --git a/hirise_blender/pvl/collections.py b/hirise_blender/pvl/collections.py
new file mode 100644
index 0000000..4687f2b
--- /dev/null
+++ b/hirise_blender/pvl/collections.py
@@ -0,0 +1,704 @@
+# -*- coding: utf-8 -*-
+"""Parameter Value Language container datatypes providing enhancements
+to Python general purpose built-in containers.
+
+To enable efficient operations on parsed PVL text, we need an object
+that acts as both a dict-like Mapping container and a list-like
+Sequence container, essentially an ordered multi-dict.  There is
+no existing object or even an Abstract Base Class in the Python
+Standard Library for such an object.  So we define the
+MutableMappingSequence ABC here, which is (as the name implies) an
+abstract base class that implements both the Python MutableMapping
+and Mutable Sequence ABCs. We also provide two implementations, the
+OrderedMultiDict, and the newer PVLMultiDict.
+
+Additionally, for PVL Values which also have an associated PVL Units
+Expression, they need to be returned as a quantity object which contains
+both a notion of a value and the units for that value.  Again, there
+is no fundamental Python type for a quantity, so we define the Quantity
+class (formerly the Units class).
+"""
+# Copyright 2015, 2017, 2019-2021, ``pvl`` library authors.
+#
+# Reuse is permitted under the terms of the license.
+# The AUTHORS file and the LICENSE file are at the
+# top level of this library.
+
+import pprint
+import warnings
+from abc import abstractmethod
+from collections import namedtuple, abc
+
+
+class MutableMappingSequence(abc.MutableMapping, abc.MutableSequence):
+    """ABC for a mutable object that has both mapping and
+    sequence characteristics.
+
+    Must implement `.getall(k)` and `.popall(k)` since a MutableMappingSequence
+    can have many values for a single key, while `.get(k)` and
+    `.pop(k)` return and operate on a single value, the *all*
+    versions return and operate on all values in the MutableMappingSequence
+    with the key `k`.
+
+    Furthermore, `.pop()` without an argument should function as the
+    MutableSequence pop() function and pop the last value when considering
+    the MutableMappingSequence in a list-like manner.
+    """
+
+    @abstractmethod
+    def append(self, key, value):
+        pass
+
+    @abstractmethod
+    def getall(self, key):
+        pass
+
+    @abstractmethod
+    def popall(self, key):
+        pass
+
+
+dict_setitem = dict.__setitem__
+dict_getitem = dict.__getitem__
+dict_delitem = dict.__delitem__
+dict_contains = dict.__contains__
+dict_clear = dict.clear
+
+
+class MappingView(object):
+    def __init__(self, mapping):
+        self._mapping = mapping
+
+    def __len__(self):
+        return len(self._mapping)
+
+    def __repr__(self):
+        return "{!s}({!r})".format(type(self).__name__, self._mapping)
+
+
+class KeysView(MappingView):
+    def __contains__(self, key):
+        return key in self._mapping
+
+    def __iter__(self):
+        for key, _ in self._mapping:
+            yield key
+
+    def __getitem__(self, index):
+        return self._mapping[index][0]
+
+    def __repr__(self):
+        keys = [key for key, _ in self._mapping]
+        return "{!s}({!r})".format(type(self).__name__, keys)
+
+    def index(self, key):
+        keys = [k for k, _ in self._mapping]
+        return keys.index(key)
+
+
+class ItemsView(MappingView):
+    def __contains__(self, item):
+        key, value = item
+        return value in self._mapping.getlist(key)
+
+    def __iter__(self):
+        for item in self._mapping:
+            yield item
+
+    def __getitem__(self, index):
+        return self._mapping[index]
+
+    def index(self, item):
+        items = [i for i in self._mapping]
+        return items.index(item)
+
+
+class ValuesView(MappingView):
+    def __contains__(self, value):
+        for _, v in self._mapping:
+            if v == value:
+                return True
+        return False
+
+    def __iter__(self):
+        for _, value in self._mapping:
+            yield value
+
+    def __getitem__(self, index):
+        return self._mapping[index][1]
+
+    def __repr__(self):
+        values = [value for _, value in self._mapping]
+        return "{!s}({!r})".format(type(self).__name__, values)
+
+    def index(self, value):
+        values = [val for _, val in self._mapping]
+        return values.index(value)
+
+
+class OrderedMultiDict(dict, MutableMappingSequence):
+    """A ``dict`` like container.
+
+    This container preserves the original ordering as well as
+    allows multiple values for the same key. It provides similar
+    semantics to a ``list`` of ``tuples`` but with ``dict`` style
+    access.
+
+    Using ``__setitem__`` syntax overwrites all fields with the
+    same key and ``__getitem__`` will return the first value with
+    the key.
+    """
+
+    def __init__(self, *args, **kwargs):
+        self.__items = []
+        self.extend(*args, **kwargs)
+
+    def __setitem__(self, key, value):
+        if key not in self:
+            return self.append(key, value)
+
+        dict_setitem(self, key, [value])
+        iteritems = iter(self.__items)
+
+        for index, (old_key, old_value) in enumerate(iteritems):
+            if old_key == key:
+                # replace first occurrence
+                self.__items[index] = (key, value)
+                break
+
+        tail = [item for item in iteritems if item[0] != key]
+        self.__items[index + 1:] = tail
+
+    def __getitem__(self, key):
+        if isinstance(key, (int, slice)):
+            return self.__items[key]
+        return dict_getitem(self, key)[0]
+
+    def __delitem__(self, key):
+        dict_delitem(self, key)
+        self.__items = [item for item in self.__items if item[0] != key]
+
+    def __iter__(self):
+        return iter(self.__items)
+
+    def __len__(self):
+        return len(self.__items)
+
+    def __eq__(self, other):
+        if not isinstance(other, type(self)):
+            return False
+
+        if len(self) != len(other):
+            return False
+
+        items1 = self.items()
+        items2 = other.items()
+
+        for ((key1, value1), (key2, value2)) in zip(items1, items2):
+            if key1 != key2:
+                return False
+
+            if value1 != value2:
+                return False
+
+        return True
+
+    def __ne__(self, other):
+        return not (self == other)
+
+    def __repr__(self):
+        if not self.__items:
+            return "{!s}([])".format(type(self).__name__)
+
+        lines = []
+        for item in self.__items:
+            for line in pprint.pformat(item).splitlines():
+                lines.append("  " + line)
+
+        return "{!s}([\n{!s}\n])".format(type(self).__name__, "\n".join(lines))
+
+    get = abc.MutableMapping.get
+    update = abc.MutableMapping.update
+
+    def keys(self):
+        return KeysView(self)
+
+    def values(self):
+        return ValuesView(self)
+
+    def items(self):
+        return ItemsView(self)
+
+    def clear(self):
+        dict_clear(self)
+        self.__items = []
+
+    def discard(self, key):
+
+        warnings.warn(
+            "The discard(k) function is deprecated in favor of .popall(k), "
+            "please begin using it, as .discard(k) may be removed in the "
+            "next major patch.",
+            PendingDeprecationWarning,
+        )
+
+        try:
+            del self[key]
+        except KeyError:
+            pass
+
+    def append(self, key, value):
+        """Adds a (name, value) pair, doesn't overwrite the value if
+        it already exists.
+        """
+        self.__items.append((key, value))
+
+        try:
+            dict_getitem(self, key).append(value)
+        except KeyError:
+            dict_setitem(self, key, [value])
+
+    def extend(self, *args, **kwargs):
+        """Add key value pairs for an iterable."""
+        if len(args) > 1:
+            raise TypeError(f"expected at most 1 arguments, got {len(args)}")
+
+        iterable = args[0] if args else None
+        if iterable:
+            if isinstance(iterable, abc.Mapping) or hasattr(iterable, "items"):
+                for key, value in iterable.items():
+                    self.append(key, value)
+            else:
+                for key, value in iterable:
+                    self.append(key, value)
+
+        for key, value in kwargs.items():
+            self.append(key, value)
+
+    def getall(self, key) -> abc.Sequence:
+        """Returns a list of all the values for a named field.
+        Returns KeyError if the key doesn't exist.
+        """
+        return list(dict_getitem(self, key))
+
+    def getlist(self, key) -> abc.Sequence:
+        """Returns a list of all the values for the named field.
+        Returns an empty list if the key doesn't exist.
+        """
+        warnings.warn(
+            "The getlist() function is deprecated in favor of .getall(), "
+            "please begin using it, as .getlist() may be removed in the "
+            "next major patch.",
+            PendingDeprecationWarning,
+        )
+
+        try:
+            return self.getall(key)
+        except KeyError:
+            return []
+
+    # Turns out that this super-class function, even though it doesn't have
+    # a concept of multiple keys, clears out multiple elements with the key,
+    # probably because of how __delitem__ is defined:
+    popall = abc.MutableMapping.pop
+
+    def pop(self, *args, **kwargs):
+        """Removes all items with the specified *key*."""
+
+        if len(args) == 0 and len(kwargs) == 0:
+            if not self:
+                raise KeyError(
+                    "pop(): {!s} ".format(type(self).__name__) + "is empty"
+                )
+
+            key, _ = item = self.__items.pop()
+            values = dict_getitem(self, key)
+            values.pop()
+
+            if not values:
+                dict_delitem(self, key)
+
+            return item
+
+        warnings.warn(
+            "The pop(k) function removes "
+            "all keys with value k to remain backwards compatible with the "
+            "pvl 0.x architecture, this concept of "
+            "operations for .pop(k) may change in future versions. "
+            "Consider using .popall(k) instead.",
+            FutureWarning,
+        )
+
+        return self.popall(*args, *kwargs)
+
+    def popitem(self):
+
+        warnings.warn(
+            "The popitem() function removes "
+            "and returns the last key, value pair to remain backwards "
+            "compatible with the pvl 0.x architecture, this concept of "
+            "operations for .popitem() may change in future versions. "
+            "Consider using the list-like .pop(), without an argument instead.",
+            FutureWarning,
+        )
+        return self.pop()
+
+    def copy(self):
+        return type(self)(self)
+
+    def insert(self, index: int, *args) -> None:
+        """Inserts at the index given by *index*.
+
+        The first positional argument will always be taken as the
+        *index* for insertion.
+
+        If three arguments are given, the second will be taken
+        as the *key*, and the third as the *value* to insert.
+
+        If only two arguments are given, the second must be a sequence.
+
+        If it is a sequence of pairs (such that every item in the sequence is
+        itself a sequence of length two), that sequence will be inserted
+        as key, value pairs.
+
+        If it happens to be a sequence of two items (the first of which is
+        not a sequence), the first will be taken as the *key* and the
+        second the *value* to insert.
+        """
+
+        if not isinstance(index, int):
+            raise TypeError(
+                "The first positional argument to pvl.MultiDict.insert()"
+                "must be an int."
+            )
+
+        kvlist = _insert_arg_helper(args)
+
+        for (key, value) in kvlist:
+            self.__items.insert(index, (key, value))
+            index += 1
+
+            # Make sure indexing works with the new item
+            if key in self:
+                value_list = [val for k, val in self.__items if k == key]
+                dict_setitem(self, key, value_list)
+            else:
+                dict_setitem(self, key, [value])
+
+        return
+
+    def key_index(self, key, instance: int = 0) -> int:
+        """Get the index of the key to insert before or after."""
+        if key not in self:
+            raise KeyError(str(key))
+
+        idxs = list()
+        for idx, k in enumerate(self.keys()):
+            if key == k:
+                idxs.append(idx)
+
+        try:
+            return idxs[instance]
+        except IndexError:
+            raise IndexError(
+                f"There are only {len(idxs)} elements with the key {key}, "
+                f"the provided index ({instance}) is out of bounds."
+            )
+
+    def insert_after(self, key, new_item: abc.Iterable, instance=0):
+        """Insert an item after a key"""
+        index = self.key_index(key, instance)
+        self.insert(index + 1, new_item)
+
+    def insert_before(self, key, new_item: abc.Iterable, instance=0):
+        """Insert an item before a key"""
+        index = self.key_index(key, instance)
+        self.insert(index, new_item)
+
+
+def _insert_arg_helper(args):
+    # Helper function to un-mangle the many and various ways that
+    # key, value pairs could be provided to the .insert() functions.
+    # Takes all of them, and returns a list of key, value pairs, even
+    # if there is only one.
+    if len(args) == 1:
+        if not isinstance(args, (abc.Sequence, abc.Mapping)):
+            raise TypeError(
+                "If a single argument is provided to the second positional "
+                "argument of insert(), it must have a Sequence or Mapping "
+                f"interface. Instead it was {type(args)}: {args}"
+            )
+
+        if isinstance(args[0], abc.Mapping):
+            return list(args[0].items())
+
+        else:
+            if len(args[0]) == 2 and (
+                isinstance(args[0][0], str)
+                or not isinstance(args[0][0], abc.Sequence)
+            ):
+                kvlist = (args[0],)
+            else:
+                for pair in args[0]:
+                    msg = (
+                        "One of the elements in the sequence passed to the "
+                        "second argument of insert() "
+                    )
+                    if not isinstance(pair, abc.Sequence):
+                        raise TypeError(
+                            msg + f"was not itself a sequence, it is: {pair}"
+                        )
+                    if not len(pair) == 2:
+                        raise TypeError(
+                            msg + f"was not a pair of values, it is: {pair}"
+                        )
+
+                kvlist = args[0]
+
+    elif len(args) == 2:
+        kvlist = (args,)
+    else:
+        raise TypeError(
+            f"insert() takes 2 or 3 positional arguments ({len(args)} given)."
+        )
+
+    return kvlist
+
+
+try:  # noqa: C901
+    # In order to access super class attributes for our derived class, we must
+    # import the native Python version, instead of the default Cython version.
+    from multidict._multidict_py import MultiDict
+
+    class PVLMultiDict(MultiDict, MutableMappingSequence):
+        """This is a new class that may be implemented as the default
+        structure to be returned from the pvl loaders in the future (replacing
+        OrderedMultiDict).
+
+        Here is a summary of the differences:
+
+        * OrderedMultiDict.getall('k') where k is not in the structure returns
+          an empty list, PVLMultiDict.getall('k') properly returns a KeyError.
+        * The .items(), .keys(), and .values() are proper iterators
+          and don't return sequences like OrderedMultiDict did.
+        * Calling list() on an OrderedMultiDict returns a list of tuples, which
+          is like calling list() on the results of a dict.items() iterator.
+          Calling list() on a PVLMultiDict returns just a list of keys,
+          which is semantically identical to calling list() on a dict.
+        * OrderedMultiDict.pop(k) removed all keys that matched k,
+          PVLMultiDict.pop(k) just removes the first occurrence.
+          PVLMultiDict.popall(k) would pop all.
+        * OrderedMultiDict.popitem() removes the last item from the underlying
+          list, PVLMultiDict.popitem() removes an arbitrary key, value pair,
+          semantically identical to .popitem() on a dict.
+        * OrderedMultiDict.__repr__() and .__str__() return identical strings,
+          PVLMultiDict provides a .__str__() that is pretty-printed similar
+          to OrderedMultiDict, but also a .__repr__() with a more compact
+          representation.
+        * Equality is different:  OrderedMultiDict has an isinstance()
+          check in the __eq__() operator, which I don't think was right,
+          since equality is about values, not about type.  PVLMultiDict
+          has a value-based notion of equality.  So an empty PVLGroup and an
+          empty PVLObject derived from PVLMultiDict could test equal,
+          but would fail an isinstance() check.
+        """
+
+        # Also evaluated the boltons.OrderedMultiDict, but its semantics were
+        # too different #52
+
+        def __init__(self, *args, **kwargs):
+            super().__init__(*args, **kwargs)
+
+        def __getitem__(self, key):
+            # Allow list-like access of the underlying structure
+            if isinstance(key, (int, slice)):
+                return list(self.items())[key]
+            return super().__getitem__(key)
+
+        def __repr__(self):
+            if len(self) == 0:
+                return f"{self.__class__.__name__}()"
+
+            return (
+                f"{self.__class__.__name__}(" + str(list(self.items())) + ")"
+            )
+
+        def __str__(self):
+            if len(self) == 0:
+                return self.__repr__()
+
+            lines = []
+            for item in self.items():
+                for line in pprint.pformat(item).splitlines():
+                    lines.append("  " + line)
+
+            return f"{self.__class__.__name__}([\n" + "\n".join(lines) + "\n])"
+
+        def key_index(self, key, ith: int = 0) -> int:
+            """Returns the index of the item in the underlying list
+            implementation that is the *ith* value of that *key*.
+
+            Effectively creates a list of all indexes that match *key*, and then
+            returns the original index of the *ith* element of that list.  The
+            *ith* integer can be any positive or negative integer and follows
+            the rules for list indexes.
+            """
+            if key not in self:
+                raise KeyError(str(key))
+            idxs = list()
+            for idx, (k, v) in enumerate(self.items()):
+                if key == k:
+                    idxs.append(idx)
+
+            try:
+                return idxs[ith]
+            except IndexError:
+                raise IndexError(
+                    f"There are only {len(idxs)} elements with the key {key}, "
+                    f"the provided index ({ith}) is out of bounds."
+                )
+
+        def _insert_item(
+            self, key, new_item: abc.Iterable, instance: int, is_after: bool
+        ):
+            """Insert a new item before or after another item."""
+            index = self.key_index(key, instance)
+            index = index + 1 if is_after else index
+
+            if isinstance(new_item, abc.Mapping):
+                tuple_iter = tuple(new_item.items())
+            else:
+                tuple_iter = new_item
+            self.insert(index, tuple_iter)
+
+        def insert(self, index: int, *args) -> None:
+            """Inserts at the index given by *index*.
+
+            The first positional argument will always be taken as the
+            *index* for insertion.
+
+            If three arguments are given, the second will be taken
+            as the *key*, and the third as the *value* to insert.
+
+            If only two arguments are given, the second must be a sequence.
+
+            If it is a sequence of pairs (such that every item in the sequence
+            is itself a sequence of length two), that sequence will be inserted
+            as key, value pairs.
+
+            If it happens to be a sequence of two items (the first of which is
+            not a sequence), the first will be taken as the *key* and the
+            second the *value* to insert.
+            """
+            if not isinstance(index, int):
+                raise TypeError(
+                    "The first positional argument to pvl.MultiDict.insert()"
+                    "must be an int."
+                )
+
+            kvlist = _insert_arg_helper(args)
+
+            for (key, value) in kvlist:
+                identity = self._title(key)
+                self._impl._items.insert(
+                    index, (identity, self._key(key), value)
+                )
+                self._impl.incr_version()
+                index += 1
+            return
+
+        def insert_after(self, key, new_item, instance=0):
+            """Insert an item after a key"""
+            self._insert_item(key, new_item, instance, True)
+
+        def insert_before(self, key, new_item, instance=0):
+            """Insert an item before a key"""
+            self._insert_item(key, new_item, instance, False)
+
+        def pop(self, *args, **kwargs):
+            """Returns a two-tuple or a single value, depending on how it is
+            called.
+
+            If no arguments are given, it removes and returns the last key,
+            value pair (list-like behavior).
+
+            If a *key* is given, the first instance of key is found and its
+            value is removed and returned.  If *default* is not given and
+            *key* is not in the dictionary, a KeyError is raised, otherwise
+            *default* is returned (dict-like behavior).
+            """
+            if len(args) == 0 and len(kwargs) == 0:
+                i, k, v = self._impl._items.pop()
+                self._impl.incr_version()
+                return i, v
+            else:
+                return super().pop(*args, **kwargs)
+
+        def append(self, key, value):
+            # Not sure why super() decided to go with the set-like add() instead
+            # of the more appropriate list-like append().  Fixed it for them.
+            self.add(key, value)
+
+    # New versions based on PVLMultiDict
+    class PVLModuleNew(PVLMultiDict):
+        pass
+
+    class PVLAggregationNew(PVLMultiDict):
+        pass
+
+    class PVLGroupNew(PVLAggregationNew):
+        pass
+
+    class PVLObjectNew(PVLAggregationNew):
+        pass
+
+
+except ImportError:
+    warnings.warn(
+        "The multidict library is not present, so the new PVLMultiDict "
+        "cannot be used. At this time, it is completely optional, and doesn't "
+        "impact the use of pvl.",
+        ImportWarning,
+    )
+
+
+class PVLModule(OrderedMultiDict):
+    pass
+
+
+class PVLAggregation(OrderedMultiDict):
+    pass
+
+
+class PVLGroup(PVLAggregation):
+    pass
+
+
+class PVLObject(PVLAggregation):
+    pass
+
+
+class Quantity(namedtuple("Quantity", ["value", "units"])):
+    """A simple collections.namedtuple object to contain
+    a value and units parameter.
+
+    If you need more comprehensive units handling, you
+    may want to use the astropy.units.Quantity object,
+    the pint.Quantity object, or some other 3rd party
+    object.  Please see the documentation on :doc:`quantities`
+    for how to use 3rd party Quantity objects with pvl.
+    """
+
+    def __int__(self):
+        return int(self.value)
+
+    def __float__(self):
+        return float(self.value)
+
+
+class Units(Quantity):
+    warnings.warn(
+        "The pvl.collections.Units object is deprecated, and may be removed at "
+        "the next major patch. Please use pvl.collections.Quantity instead.",
+        PendingDeprecationWarning,
+    )
diff --git a/hirise_blender/pvl/decoder.py b/hirise_blender/pvl/decoder.py
new file mode 100644
index 0000000..c98dd86
--- /dev/null
+++ b/hirise_blender/pvl/decoder.py
@@ -0,0 +1,552 @@
+# -*- coding: utf-8 -*-
+"""Parameter Value Language decoder.
+
+The definition of PVL used in this module is based on the Consultive
+Committee for Space Data Systems, and their Parameter Value
+Language Specification (CCSD0006 and CCSD0008), CCSDS 6441.0-B-2,
+referred to as the Blue Book with a date of June 2000.
+
+A decoder deals with converting strings given to it (typically
+by the parser) to the appropriate Python type.
+"""
+# Copyright 2015, 2017, 2019-2021, ``pvl`` library authors.
+#
+# Reuse is permitted under the terms of the license.
+# The AUTHORS file and the LICENSE file are at the
+# top level of this library.
+
+import re
+from datetime import datetime, timedelta, timezone
+from decimal import InvalidOperation
+from itertools import repeat, chain
+from warnings import warn
+
+from .grammar import PVLGrammar, ODLGrammar, PDSGrammar
+from .collections import Quantity
+from .exceptions import QuantityError
+
+
+def for_try_except(exception, function, *iterable):
+    """Return the result of the first successful application of *function*
+    to an element of *iterable*.  If the *function* raises an Exception
+    of type *exception*, it will continue to the next item of *iterable*.
+    If there are no successful applications an Exception of type
+    *exception* will be raised.
+
+    If additional *iterable* arguments are passed, *function* must
+    take that many arguments and is applied to the items from
+    all iterables in parallel (like ``map()``). With multiple iterables,
+    the iterator stops when the shortest iterable is exhausted.
+    """
+    for tup in zip(*iterable):
+        try:
+            return function(*tup)
+        except exception:
+            pass
+
+    raise exception
+
+
+class PVLDecoder(object):
+    """A decoder based on the rules in the CCSDS-641.0-B-2 'Blue Book'
+    which defines the PVL language.
+
+    :param grammar: defaults to a :class:`pvl.grammar.PVLGrammar`, but can
+        be any object that implements the :class:`pvl.grammar` interface.
+
+    :param quantity_cls: defaults to :class:`pvl.collections.Quantity`, but
+        could be any class object that takes two arguments, where the
+        first is the value, and the second is the units value.
+
+    :param real_cls: defaults to :class:`float`, but could be any class object
+        that can be constructed from a `str` object.
+    """
+
+    def __init__(self, grammar=None, quantity_cls=None, real_cls=None):
+        self.errors = []
+
+        if grammar is None:
+            self.grammar = PVLGrammar()
+        elif isinstance(grammar, PVLGrammar):
+            self.grammar = grammar
+        else:
+            raise Exception
+
+        if quantity_cls is None:
+            self.quantity_cls = Quantity
+        else:
+            self.quantity_cls = quantity_cls
+
+        if real_cls is None:
+            self.real_cls = float
+        else:
+            self.real_cls = real_cls
+
+    def decode(self, value: str):
+        """Returns a Python object based on *value*."""
+        return self.decode_simple_value(value)
+
+    def decode_simple_value(self, value: str):
+        """Returns a Python object based on *value*, assuming
+        that *value* can be decoded as a PVL Simple Value::
+
+         <Simple-Value> ::= (<Date-Time> | <Numeric> | <String>)
+        """
+        if value.casefold() == self.grammar.none_keyword.casefold():
+            return None
+
+        if value.casefold() == self.grammar.true_keyword.casefold():
+            return True
+
+        if value.casefold() == self.grammar.false_keyword.casefold():
+            return False
+
+        for d in (
+            self.decode_quoted_string,
+            self.decode_non_decimal,
+            self.decode_decimal,
+            self.decode_datetime,
+        ):
+            try:
+                return d(value)
+            except ValueError:
+                pass
+
+        return self.decode_unquoted_string(value)
+
+    def decode_unquoted_string(self, value: str) -> str:
+        """Returns a Python ``str`` if *value* can be decoded
+        as an unquoted string, based on this decoder's grammar.
+        Raises a ValueError otherwise.
+        """
+        for coll in (
+            ("a comment", chain.from_iterable(self.grammar.comments)),
+            ("some whitespace", self.grammar.whitespace),
+            ("a special character", self.grammar.reserved_characters),
+        ):
+            for item in coll[1]:
+                if item in value:
+                    raise ValueError(
+                        "Expected a Simple Value, but encountered "
+                        f'{coll[0]} in "{self}": "{item}".'
+                    )
+
+        agg_keywords = self.grammar.aggregation_keywords.items()
+        for kw in chain.from_iterable(agg_keywords):
+            if kw.casefold() == value.casefold():
+                raise ValueError(
+                    "Expected a Simple Value, but encountered "
+                    f'an aggregation keyword: "{value}".'
+                )
+
+        for es in self.grammar.end_statements:
+            if es.casefold() == value.casefold():
+                raise ValueError(
+                    "Expected a Simple Value, but encountered "
+                    f'an End-Statement: "{value}".'
+                )
+
+        # This try block is going to look illogical.  But the decode
+        # rules for Unquoted Strings spell out the things that they
+        # cannot be, so if it *can* be a datetime, then it *can't* be
+        # an Unquoted String, which is why we raise if it succeeds,
+        # and pass if it fails:
+        try:
+            self.decode_datetime(value)
+            raise ValueError
+        except ValueError:
+            pass
+
+        return str(value)
+
+    def decode_quoted_string(self, value: str) -> str:
+        """Returns a Python ``str`` if *value* begins and ends
+        with matching quote characters based on this decoder's
+        grammar.  Raises ValueError otherwise.
+        """
+        for q in self.grammar.quotes:
+            if value.startswith(q) and value.endswith(q) and len(value) > 1:
+                return str(value[1:-1])
+        raise ValueError(f'The object "{value}" is not a PVL Quoted String.')
+
+    def decode_decimal(self, value: str):
+        """Returns a Python ``int`` or ``self.real_cls`` object, as appropriate
+        based on *value*.  Raises a ValueError otherwise.
+        """
+        # Returns int or real_cls
+        try:
+            return int(value, base=10)
+        except ValueError:
+            try:
+                return self.real_cls(str(value))
+            except InvalidOperation as err:
+                raise ValueError from err
+
+    def decode_non_decimal(self, value: str) -> int:
+        """Returns a Python ``int`` as decoded from *value*
+        on the assumption that *value* conforms to a
+        non-decimal integer value as defined by this decoder's
+        grammar, raises ValueError otherwise.
+        """
+        # Non-Decimal (Binary, Hex, and Octal)
+        for nd_re in (
+            self.grammar.binary_re,
+            self.grammar.octal_re,
+            self.grammar.hex_re,
+        ):
+            match = nd_re.fullmatch(value)
+            if match is not None:
+                d = match.groupdict("")
+                return int(d["sign"] + d["non_decimal"], base=int(d["radix"]))
+        raise ValueError
+
+    def decode_datetime(self, value: str):  # noqa: C901
+        """Takes a string and attempts to convert it to the appropriate
+        Python ``datetime`` ``time``, ``date``, or ``datetime``
+        type based on this decoder's grammar, or in one case, a ``str``.
+
+        The PVL standard allows for the seconds value to range
+        from zero to 60, so that the 60 can accommodate leap
+        seconds.  However, the Python ``datetime`` classes don't
+        support second values for more than 59 seconds.
+
+        If a time with 60 seconds is encountered, it will not be
+        returned as a datetime object (since that is not representable
+        via Python datetime objects), but simply as a string.
+
+        The user can then then try and use the ``time`` module
+        to parse this string into a ``time.struct_time``.  We
+        chose not to do this with pvl because ``time.struct_time``
+        is a full *datetime* like object, even if it parsed
+        only a *time* like object, the year, month, and day
+        values in the ``time.struct_time`` would default, which
+        could be misleading.
+
+        Alternately, the pvl.grammar.PVLGrammar class contains
+        two regexes: ``leap_second_Ymd_re`` and ``leap_second_Yj_re``
+        which could be used along with the ``re.match`` object's
+        ``groupdict()`` function to extract the string representations
+        of the various numerical values, cast them to the appropriate
+        numerical types, and do something useful with them.
+        """
+        try:
+            # datetime.date objects will always be naive, so just return:
+            return for_try_except(
+                ValueError,
+                datetime.strptime,
+                repeat(value),
+                self.grammar.date_formats,
+            ).date()
+        except ValueError:
+            # datetime.time and datetime.datetime might be either:
+            d = None
+            try:
+                d = for_try_except(
+                    ValueError,
+                    datetime.strptime,
+                    repeat(value),
+                    self.grammar.time_formats,
+                ).time()
+            except ValueError:
+                try:
+                    d = for_try_except(
+                        ValueError,
+                        datetime.strptime,
+                        repeat(value),
+                        self.grammar.datetime_formats,
+                    )
+                except ValueError:
+                    pass
+            if d is not None:
+                if d.utcoffset() is None:
+                    if value.endswith("Z"):
+                        return d.replace(tzinfo=timezone.utc)
+                    elif self.grammar.default_timezone is not None:
+                        return d.replace(tzinfo=self.grammar.default_timezone)
+                return d
+
+        # if we can regex a 60-second time, return str
+        if self.is_leap_seconds(value):
+            return str(value)
+        else:
+            raise ValueError
+
+    def is_leap_seconds(self, value: str) -> bool:
+        """Returns True if *value* is a time that matches the
+        grammar's definition of a leap seconds time (a time string with
+        a value of 60 for the seconds value).  False otherwise."""
+        for r in (
+            self.grammar.leap_second_Ymd_re,
+            self.grammar.leap_second_Yj_re,
+        ):
+            if r is not None and r.fullmatch(value) is not None:
+                return True
+        else:
+            return False
+
+    def decode_quantity(self, value, unit):
+        """Returns a Python object that represents a value with
+           an associated unit, based on the values provided via
+           *value* and *unit*.  This function creates an object
+           based on the decoder's *quantity_cls*.
+        """
+        try:
+            return self.quantity_cls(value, str(unit))
+        except ValueError as err:
+            raise QuantityError(err)
+
+
+class ODLDecoder(PVLDecoder):
+    """A decoder based on the rules in the PDS3 Standards Reference
+    (version 3.8, 27 Feb 2009) Chapter 12: Object Description
+    Language Specification and Usage.
+
+    Extends PVLDecoder, and if *grammar* is not specified, it will
+    default to an ODLGrammar() object.
+    """
+
+    def __init__(self, grammar=None, quantity_cls=None, real_cls=None):
+        self.errors = []
+
+        if grammar is None:
+            grammar = ODLGrammar()
+
+        super().__init__(
+            grammar=grammar,
+            quantity_cls=quantity_cls,
+            real_cls=real_cls
+        )
+
+    def decode_datetime(self, value: str):
+        """Extends parent function to also deal with datetimes
+        and times with a time zone offset.
+
+        If it cannot, it will raise a ValueError.
+        """
+
+        try:
+            return super().decode_datetime(value)
+        except ValueError:
+            # if there is a +HH:MM or a -HH:MM suffix that
+            # can be stripped, then we're in business.
+            # Otherwise ...
+            match = re.fullmatch(
+                r"(?P<dt>.+?)"  # the part before the sign
+                r"(?P<sign>[+-])"  # required sign
+                r"(?P<hour>0?[0-9]|1[0-2])"  # 0 to 12
+                fr"(?:{self.grammar._M_frag})?",  # Minutes
+                value,
+            )
+            if match is not None:
+                gd = match.groupdict(default=0)
+                dt = super().decode_datetime(gd["dt"])
+                offset = timedelta(
+                    hours=int(gd["hour"]), minutes=int(gd["minute"])
+                )
+                if gd["sign"] == "-":
+                    offset = -1 * offset
+                return dt.replace(tzinfo=timezone(offset))
+            raise ValueError
+
+    def decode_non_decimal(self, value: str) -> int:
+        """Extends parent function by allowing the wider variety of
+        radix values that ODL permits over PVL.
+        """
+        match = self.grammar.nondecimal_re.fullmatch(value)
+        if match is not None:
+            d = match.groupdict("")
+            return int(d["sign"] + d["non_decimal"], base=int(d["radix"]))
+        raise ValueError
+
+    def decode_quoted_string(self, value: str) -> str:
+        """Extends parent function because the
+        ODL specification allows for a dash (-) line continuation
+        character that results in the dash, the line end, and any
+        leading whitespace on the next line to be removed.  It also
+        allows for a sequence of format effectors surrounded by
+        spacing characters to be collapsed to a single space.
+        """
+        s = super().decode_quoted_string(value)
+
+        # Deal with dash (-) continuation:
+        # sp = ''.join(self.grammar.spacing_characters)
+        fe = "".join(self.grammar.format_effectors)
+        ws = "".join(self.grammar.whitespace)
+        nodash = re.sub(fr"-[{fe}][{ws}]*", "", s)
+
+        # Originally thought that only format effectors surrounded
+        # by whitespace was to be collapsed
+        # foo = re.sub(fr'[{sp}]*[{fe}]+[{sp}]*', ' ', nodash)
+
+        # But really it collapses all whitespace and strips lead and trail.
+        return re.sub(fr"[{ws}]+", " ", nodash.strip(ws))
+
+    def decode_unquoted_string(self, value: str) -> str:
+        """Extends parent function to provide the extra enforcement that only
+        ODL Identifier text may be unquoted as a value.
+        """
+        s = super().decode_unquoted_string(value)
+
+        if self.is_identifier(s):
+            return s
+        else:
+            raise ValueError(
+                f"Only text that qualifies as an ODL Identifier may be "
+                f"unquoted as a value, and '{s}' is not."
+            )
+
+    @staticmethod
+    def is_identifier(value):
+        """Returns true if *value* is an ODL Identifier, false otherwise.
+
+        An ODL Identifier is composed of letters, digits, and underscores.
+        The first character must be a letter, and the last must not
+        be an underscore.
+        """
+        if isinstance(value, str):
+            if len(value) == 0:
+                return False
+
+            try:
+                # Ensure we're dealing with ASCII
+                value.encode(encoding="ascii")
+
+                # value can't start with a letter or end with an underbar
+                if not value[0].isalpha() or value.endswith("_"):
+                    return False
+
+                for c in value:
+                    if not (c.isalpha() or c.isdigit() or c == "_"):
+                        return False
+                else:
+                    return True
+
+            except UnicodeError:
+                return False
+        else:
+            return False
+
+
+class PDSLabelDecoder(ODLDecoder):
+    """A decoder based on the rules in the PDS3 Standards Reference
+    (version 3.8, 27 Feb 2009) Chapter 12: Object Description
+    Language Specification and Usage.
+
+    Extends ODLDecoder, and if *grammar* is not specified, it will
+    default to a PDS3Grammar() object.
+    """
+
+    def __init__(self, grammar=None, quantity_cls=None):
+        self.errors = []
+
+        if grammar is None:
+            super().__init__(grammar=PDSGrammar(), quantity_cls=quantity_cls)
+        else:
+            super().__init__(grammar=grammar, quantity_cls=quantity_cls)
+
+    def decode_datetime(self, value: str):
+        """Overrides parent function since PDS3 forbids a timezone
+        specification, and times with a precision more than miliseconds.
+
+        If it cannot decode properly, it will raise a ValueError.
+        """
+
+        t = super(ODLDecoder, self).decode_datetime(value)
+
+        if (
+            hasattr(t, "microsecond")
+            and t.microsecond != round(t.microsecond / 1000) * 1000
+        ):
+            raise ValueError(
+                f"The PDS specification does not allow time values with"
+                f"precision greater than miliseconds, and this has "
+                f"microsecond precision: {t}."
+            )
+
+        return t
+
+
+class OmniDecoder(ODLDecoder):
+    """A permissive decoder that attempts to parse all forms of
+    "PVL" that are thrown at it.
+
+    Extends ODLDecoder.
+    """
+
+    def decode_non_decimal(self, value: str) -> int:
+        """Extends parent function by allowing a plus or
+        minus sign to be in two different positions
+        in a non-decimal number, since PVL has one
+        specification, and ODL has another.
+        """
+        # Non-Decimal with a variety of radix values and sign
+        # positions.
+        match = self.grammar.nondecimal_re.fullmatch(value)
+        if match is not None:
+            d = match.groupdict("")
+            if "second_sign" in d:
+                if d["sign"] != "" and d["second_sign"] != "":
+                    raise ValueError(
+                        f'The non-decimal value, "{value}", ' "has two signs."
+                    )
+                elif d["sign"] != "":
+                    sign = d["sign"]
+                else:
+                    sign = d["second_sign"]
+            else:
+                sign = d["sign"]
+
+            return int(sign + d["non_decimal"], base=int(d["radix"]))
+        raise ValueError
+
+    def decode_datetime(self, value: str):
+        """Returns an appropriate Python datetime time, date, or datetime
+        object by using the 3rd party dateutil library (if present)
+        to parse an ISO 8601 datetime string in *value*.  If it cannot,
+        or the dateutil library is not present, it will raise a
+        ValueError.
+        """
+
+        try:
+            return super().decode_datetime(value)
+        except ValueError:
+            try:
+                from dateutil.parser import isoparser
+
+                isop = isoparser()
+
+                if len(value) > 3 and value[-2] == "+" and value[-1].isdigit():
+                    # This technically means that we accept slightly more
+                    # formats than ISO 8601 strings, since under that
+                    # specification, two digits after the '+' are required
+                    # for an hour offset, but ODL doesn't have this
+                    # requirement.  If we find only one digit, we'll
+                    # just assume it means an hour and insert a zero so
+                    # that it can be parsed.
+                    tokens = value.rpartition("+")
+                    value = tokens[0] + "+0" + tokens[-1]
+
+                try:
+                    return isop.parse_isodate(value)
+                except ValueError:
+                    try:
+                        return isop.parse_isotime(value)
+                    except ValueError:
+                        return isop.isoparse(value)
+
+            except ImportError:
+                warn(
+                    "The dateutil library is not present, so more "
+                    "exotic date and time formats beyond the PVL/ODL "
+                    "set cannot be parsed.",
+                    ImportWarning,
+                )
+
+            raise ValueError
+
+    def decode_unquoted_string(self, value: str) -> str:
+        """Overrides parent function since the ODLDecoder has a more narrow
+        definition of what is allowable as an unquoted string than the
+        PVLDecoder does.
+        """
+        return super(ODLDecoder, self).decode_unquoted_string(value)
diff --git a/hirise_blender/pvl/encoder.py b/hirise_blender/pvl/encoder.py
new file mode 100644
index 0000000..2a77ac3
--- /dev/null
+++ b/hirise_blender/pvl/encoder.py
@@ -0,0 +1,1178 @@
+# -*- coding: utf-8 -*-
+"""Parameter Value Langage encoder.
+
+An encoder deals with converting Python objects into
+string values that conform to a PVL specification.
+"""
+
+# Copyright 2015, 2019-2021, ``pvl`` library authors.
+#
+# Reuse is permitted under the terms of the license.
+# The AUTHORS file and the LICENSE file are at the
+# top level of this library.
+
+import datetime
+import re
+import textwrap
+
+from collections import abc, namedtuple
+from decimal import Decimal
+from warnings import warn
+
+from .collections import PVLObject, PVLGroup, Quantity
+from .grammar import PVLGrammar, ODLGrammar, PDSGrammar, ISISGrammar
+from .token import Token
+from .decoder import PVLDecoder, ODLDecoder, PDSLabelDecoder
+
+
+class QuantTup(namedtuple("QuantTup", ["cls", "value_prop", "units_prop"])):
+    """
+    This class is just a convenient namedtuple for internally keeping track
+    of quantity classes that encoders can deal with.  In general, users
+    should not be instantiating this, instead use your encoder's
+    add_quantity_cls() function.
+    """
+
+
+class PVLEncoder(object):
+    """An encoder based on the rules in the CCSDS-641.0-B-2 'Blue Book'
+    which defines the PVL language.
+
+    :param grammar: A pvl.grammar object, if None or not specified, it will
+                    be set to the grammar parameter of *decoder* (if
+                    *decoder* is not None) or will default to PVLGrammar().
+    :param grammar: defaults to pvl.grammar.PVLGrammar().
+    :param decoder: defaults to pvl.decoder.PVLDecoder().
+    :param indent: specifies the number of spaces that will be used to
+        indent each level of the PVL document, when Groups or Objects
+        are encountered, defaults to 2.
+    :param width: specifies the number of characters in width that each
+        line should have, defaults to 80.
+    :param aggregation_end: when True the encoder will print the value
+        of the aggregation's Block Name in the End Aggregation Statement
+        (e.g. END_GROUP = foo), and when false, it won't (e.g. END_GROUP).
+        Defaults to True.
+    :param end_delimiter: when True the encoder will print the grammar's
+        delimiter (e.g. ';' for PVL) after each statement, when False
+        it won't.  Defaults to True.
+    :param newline: is the string that will be placed at the end of each
+        'line' of output (and counts against *width*), defaults to '\\\\n'.
+    :param group_class: must this class will be tested against with
+        isinstance() to determine if various elements of the dict-like
+        passed to encode() should be encoded as a PVL Group or PVL Object,
+        defaults to PVLGroup.
+    :param object_class: must be a class that can take a *group_class*
+        object in its constructor (essentially converting a *group_class*
+        to an *object_class*), otherwise will raise TypeError.  Defaults
+        to PVLObject.
+    """
+
+    def __init__(
+        self,
+        grammar=None,
+        decoder=None,
+        indent: int = 2,
+        width: int = 80,
+        aggregation_end: bool = True,
+        end_delimiter: bool = True,
+        newline: str = "\n",
+        group_class=PVLGroup,
+        object_class=PVLObject,
+    ):
+
+        if grammar is None:
+            if decoder is not None:
+                self.grammar = decoder.grammar
+            else:
+                self.grammar = PVLGrammar()
+        elif isinstance(grammar, PVLGrammar):
+            self.grammar = grammar
+        else:
+            raise Exception
+
+        if decoder is None:
+            self.decoder = PVLDecoder(self.grammar)
+        elif isinstance(decoder, PVLDecoder):
+            self.decoder = decoder
+        else:
+            raise Exception
+
+        self.indent = indent
+        self.width = width
+        self.end_delimiter = end_delimiter
+        self.aggregation_end = aggregation_end
+        self.newline = newline
+
+        # This list of 3-tuples *always* has our own pvl quantity object,
+        # and should *only* be added to with self.add_quantity_cls().
+        self.quantities = [QuantTup(Quantity, "value", "units")]
+        self._import_quantities()
+
+        if issubclass(group_class, abc.Mapping):
+            self.grpcls = group_class
+        else:
+            raise TypeError("The group_class must be a Mapping type.")
+
+        if issubclass(object_class, abc.Mapping):
+            self.objcls = object_class
+        else:
+            raise TypeError("The object_class must be a Mapping type.")
+
+        try:
+            self.objcls(self.grpcls())
+        except TypeError:
+            raise TypeError(
+                f"The object_class type ({object_class}) cannot be "
+                f"instantiated with an argument that is of type "
+                f"group_class ({group_class})."
+            )
+
+        # Finally, let's keep track of everything we consider "numerical":
+        self.numeric_types = (int, float, self.decoder.real_cls, Decimal)
+
+    def _import_quantities(self):
+        warn_str = (
+            "The {} library is not present, so {} objects will "
+            "not be properly encoded."
+        )
+        try:
+            from astropy import units as u
+
+            self.add_quantity_cls(u.Quantity, "value", "unit")
+        except ImportError:
+            warn(
+                warn_str.format("astropy", "astropy.units.Quantity"),
+                ImportWarning,
+            )
+
+        try:
+            from pint import Quantity as q
+
+            self.add_quantity_cls(q, "magnitude", "units")
+        except ImportError:
+            warn(warn_str.format("pint", "pint.Quantity"), ImportWarning)
+
+    def add_quantity_cls(self, cls, value_prop: str, units_prop: str):
+        """Adds a quantity class to the list of possible
+        quantities that this encoder can handle.
+
+        :param cls: The name of a quantity class that can be tested
+            with ``isinstance()``.
+        :param value_prop: A string that is the property name of
+            *cls* that contains the value or magnitude of the quantity
+            object.
+        :param units_prop: A string that is the property name of
+            *cls* that contains the units element of the quantity
+            object.
+        """
+        if not isinstance(cls, type):
+            raise TypeError(f"The cls given ({cls}) is not a Python class.")
+
+        # If a quantity object can't encode "one meter" its probably not
+        # going to work for us.
+        test_cls = cls(1, "m")
+        for prop in (value_prop, units_prop):
+            if not hasattr(test_cls, prop):
+                raise AttributeError(
+                    f"The class ({cls}) does not have an "
+                    f" attribute named {prop}."
+                )
+
+        self.quantities.append(QuantTup(cls, value_prop, units_prop))
+
+    def format(self, s: str, level: int = 0) -> str:
+        """Returns a string derived from *s*, which
+        has leading space characters equal to
+        *level* times the number of spaces specified
+        by this encoder's indent property.
+
+        It uses the textwrap library to wrap long lines.
+        """
+
+        prefix = level * (self.indent * " ")
+
+        if len(prefix + s + self.newline) > self.width and "=" in s:
+            (preq, _, posteq) = s.partition("=")
+            new_prefix = prefix + preq.strip() + " = "
+
+            lines = textwrap.wrap(
+                posteq.strip(),
+                width=(self.width - len(self.newline)),
+                replace_whitespace=False,
+                initial_indent=new_prefix,
+                subsequent_indent=(" " * len(new_prefix)),
+                break_long_words=False,
+                break_on_hyphens=False,
+            )
+            return self.newline.join(lines)
+        else:
+            return prefix + s
+
+    def encode(self, module: abc.Mapping) -> str:
+        """Returns a ``str`` formatted as a PVL document based
+        on the dict-like *module* object
+        according to the rules of this encoder.
+        """
+        lines = list()
+        lines.append(self.encode_module(module, 0))
+
+        end_line = self.grammar.end_statements[0]
+        if self.end_delimiter:
+            end_line += self.grammar.delimiters[0]
+
+        lines.append(end_line)
+
+        # Final check to ensure we're sending out the right character set:
+        s = self.newline.join(lines)
+
+        for i, c in enumerate(s):
+            if not self.grammar.char_allowed(c):
+                raise ValueError(
+                    "Encountered a character that was not "
+                    "a valid character according to the "
+                    'grammar: "{}", it is in: '
+                    '"{}"'.format(c, s[i - 5, i + 5])
+                )
+
+        return self.newline.join(lines)
+
+    def encode_module(self, module: abc.Mapping, level: int = 0) -> str:
+        """Returns a ``str`` formatted as a PVL module based
+        on the dict-like *module* object according to the
+        rules of this encoder, with an indentation level
+        of *level*.
+        """
+        lines = list()
+
+        # To align things on the equals sign, just need to normalize
+        # the non-aggregation key length:
+
+        non_agg_key_lengths = list()
+        for k, v in module.items():
+            if not isinstance(v, abc.Mapping):
+                non_agg_key_lengths.append(len(k))
+        longest_key_len = max(non_agg_key_lengths, default=0)
+
+        for k, v in module.items():
+            if isinstance(v, abc.Mapping):
+                lines.append(self.encode_aggregation_block(k, v, level))
+            else:
+                lines.append(
+                    self.encode_assignment(k, v, level, longest_key_len)
+                )
+        return self.newline.join(lines)
+
+    def encode_aggregation_block(
+        self, key: str, value: abc.Mapping, level: int = 0
+    ) -> str:
+        """Returns a ``str`` formatted as a PVL Aggregation Block with
+        *key* as its name, and its contents based on the
+        dict-like *value* object according to the
+        rules of this encoder, with an indentation level
+        of *level*.
+        """
+        lines = list()
+
+        if isinstance(value, self.grpcls):
+            agg_keywords = self.grammar.group_pref_keywords
+        elif isinstance(value, abc.Mapping):
+            agg_keywords = self.grammar.object_pref_keywords
+        else:
+            raise ValueError("The value {value} is not dict-like.")
+
+        agg_begin = "{} = {}".format(agg_keywords[0], key)
+        if self.end_delimiter:
+            agg_begin += self.grammar.delimiters[0]
+        lines.append(self.format(agg_begin, level))
+
+        lines.append(self.encode_module(value, (level + 1)))
+
+        agg_end = ""
+        if self.aggregation_end:
+            agg_end += "{} = {}".format(agg_keywords[1], key)
+        else:
+            agg_end += agg_keywords[1]
+        if self.end_delimiter:
+            agg_end += self.grammar.delimiters[0]
+        lines.append(self.format(agg_end, level))
+
+        return self.newline.join(lines)
+
+    def encode_assignment(
+        self, key: str, value, level: int = 0, key_len: int = None
+    ) -> str:
+        """Returns a ``str`` formatted as a PVL Assignment Statement
+        with *key* as its Parameter Name, and its value based
+        on *value* object according to the rules of this encoder,
+        with an indentation level of *level*.  It also allows for
+        an optional *key_len* which indicates the width in characters
+        that the Assignment Statement should be set to, defaults to
+        the width of *key*.
+        """
+        if key_len is None:
+            key_len = len(key)
+
+        s = ""
+        s += "{} = ".format(key.ljust(key_len))
+
+        enc_val = self.encode_value(value)
+
+        if enc_val.startswith(self.grammar.quotes):
+            # deal with quoted lines that need to preserve
+            # newlines
+            s = self.format(s, level)
+            s += enc_val
+
+            if self.end_delimiter:
+                s += self.grammar.delimiters[0]
+
+            return s
+        else:
+            s += enc_val
+
+            if self.end_delimiter:
+                s += self.grammar.delimiters[0]
+
+            return self.format(s, level)
+
+    def encode_value(self, value) -> str:
+        """Returns a ``str`` formatted as a PVL Value based
+        on the *value* object according to the rules of this encoder.
+        """
+        try:
+            return self.encode_quantity(value)
+        except ValueError:
+            return self.encode_simple_value(value)
+
+    def encode_quantity(self, value) -> str:
+        """Returns a ``str`` formatted as a PVL Value followed by
+        a PVL Units Expression if the *value* object can be
+        encoded this way, otherwise raise ValueError."""
+        for (cls, v_prop, u_prop) in self.quantities:
+            if isinstance(value, cls):
+                return self.encode_value_units(
+                    getattr(value, v_prop), getattr(value, u_prop)
+                )
+
+        raise ValueError(
+            f"The value object {value} could not be "
+            "encoded as a PVL Value followed by a PVL "
+            f"Units Expression, it is of type {type(value)}"
+        )
+
+    def encode_value_units(self, value, units) -> str:
+        """Returns a ``str`` formatted as a PVL Value from *value*
+        followed by a PVL Units Expressions from *units*."""
+        value_str = self.encode_simple_value(value)
+        units_str = self.encode_units(str(units))
+        return f"{value_str} {units_str}"
+
+    def encode_simple_value(self, value) -> str:
+        """Returns a ``str`` formatted as a PVL Simple Value based
+        on the *value* object according to the rules of this encoder.
+        """
+        if value is None:
+            return self.grammar.none_keyword
+        elif isinstance(value, (set, frozenset)):
+            return self.encode_set(value)
+        elif isinstance(value, list):
+            return self.encode_sequence(value)
+        elif isinstance(
+            value, (datetime.datetime, datetime.date, datetime.time)
+        ):
+            return self.encode_datetype(value)
+        elif isinstance(value, bool):
+            if value:
+                return self.grammar.true_keyword
+            else:
+                return self.grammar.false_keyword
+        elif isinstance(value, self.numeric_types):
+            return str(value)
+        elif isinstance(value, str):
+            return self.encode_string(value)
+        else:
+            raise TypeError(f"{value!r} is not serializable.")
+
+    def encode_setseq(self, values: abc.Collection) -> str:
+        """This function provides shared functionality for
+        encode_sequence() and encode_set().
+        """
+        return ", ".join([self.encode_value(v) for v in values])
+
+    def encode_sequence(self, value: abc.Sequence) -> str:
+        """Returns a ``str`` formatted as a PVL Sequence based
+        on the *value* object according to the rules of this encoder.
+        """
+        return "(" + self.encode_setseq(value) + ")"
+
+    def encode_set(self, value: abc.Set) -> str:
+        """Returns a ``str`` formatted as a PVL Set based
+        on the *value* object according to the rules of this encoder.
+        """
+        return "{" + self.encode_setseq(value) + "}"
+
+    def encode_datetype(self, value) -> str:
+        """Returns a ``str`` formatted as a PVL Date/Time based
+        on the *value* object according to the rules of this encoder.
+        If *value* is not a datetime date, time, or datetime object,
+        it will raise TypeError.
+        """
+        if isinstance(value, datetime.datetime):
+            return self.encode_datetime(value)
+        elif isinstance(value, datetime.date):
+            return self.encode_date(value)
+        elif isinstance(value, datetime.time):
+            return self.encode_time(value)
+        else:
+            raise TypeError(f"{value!r} is not a datetime type.")
+
+    @staticmethod
+    def encode_date(value: datetime.date) -> str:
+        """Returns a ``str`` formatted as a PVL Date based
+        on the *value* object according to the rules of this encoder.
+        """
+        return f"{value:%Y-%m-%d}"
+
+    @staticmethod
+    def encode_time(value: datetime.time) -> str:
+        """Returns a ``str`` formatted as a PVL Time based
+        on the *value* object according to the rules of this encoder.
+        """
+        s = f"{value:%H:%M}"
+
+        if value.microsecond:
+            s += f":{value:%S.%f}"
+        elif value.second:
+            s += f":{value:%S}"
+
+        return s
+
+    def encode_datetime(self, value: datetime.datetime) -> str:
+        """Returns a ``str`` formatted as a PVL Date/Time based
+        on the *value* object according to the rules of this encoder.
+        """
+        date = self.encode_date(value)
+        time = self.encode_time(value)
+        return date + "T" + time
+
+    def needs_quotes(self, s: str) -> bool:
+        """Returns true if *s* must be quoted according to this
+        encoder's grammar, false otherwise.
+        """
+        if any(c in self.grammar.whitespace for c in s):
+            return True
+
+        if s in self.grammar.reserved_keywords:
+            return True
+
+        tok = Token(s, grammar=self.grammar, decoder=self.decoder)
+        return not tok.is_unquoted_string()
+
+    def encode_string(self, value) -> str:
+        """Returns a ``str`` formatted as a PVL String based
+        on the *value* object according to the rules of this encoder.
+        """
+        s = str(value)
+
+        if self.needs_quotes(s):
+            for q in self.grammar.quotes:
+                if q not in s:
+                    return q + s + q
+            else:
+                raise ValueError(
+                    "All of the quote characters, "
+                    f"{self.grammar.quotes}, were in the "
+                    f'string ("{s}"), so it could not be quoted.'
+                )
+        else:
+            return s
+
+    def encode_units(self, value: str) -> str:
+        """Returns a ``str`` formatted as a PVL Units Value based
+        on the *value* object according to the rules of this encoder.
+        """
+        return (
+            self.grammar.units_delimiters[0]
+            + value
+            + self.grammar.units_delimiters[1]
+        )
+
+
+class ODLEncoder(PVLEncoder):
+    """An encoder based on the rules in the PDS3 Standards Reference
+    (version 3.8, 27 Feb 2009) Chapter 12: Object Description
+    Language Specification and Usage for ODL only.  This is
+    almost certainly not what you want.  There are very rarely
+    cases where you'd want to use ODL that you wouldn't also want
+    to use the PDS Label restrictions, so you probably really want
+    the PDSLabelEncoder class, not this one.  Move along.
+
+    It extends PVLEncoder.
+
+    :param grammar: defaults to pvl.grammar.ODLGrammar().
+    :param decoder: defaults to pvl.decoder.ODLDecoder().
+    :param end_delimiter: defaults to False.
+    :param newline: defaults to '\\\\r\\\\n'.
+    """
+
+    def __init__(
+        self,
+        grammar=None,
+        decoder=None,
+        indent=2,
+        width=80,
+        aggregation_end=True,
+        end_delimiter=False,
+        newline="\r\n",
+        group_class=PVLGroup,
+        object_class=PVLObject
+    ):
+
+        if grammar is None:
+            grammar = ODLGrammar()
+
+        if decoder is None:
+            decoder = ODLDecoder(grammar)
+
+        if not callable(getattr(decoder, "is_identifier", None)):
+            raise TypeError(
+                f"The decoder for an ODLEncoder() must have the "
+                f"is_identifier() function, and this does not: {decoder}"
+            )
+
+        super().__init__(
+            grammar,
+            decoder,
+            indent,
+            width,
+            aggregation_end,
+            end_delimiter,
+            newline,
+            group_class=group_class,
+            object_class=object_class
+        )
+
+    def encode(self, module: abc.Mapping) -> str:
+        """Extends parent function, but ODL requires that there must be
+        a spacing or format character after the END statement and this
+        adds the encoder's ``newline`` sequence.
+        """
+        s = super().encode(module)
+        return s + self.newline
+
+    def is_scalar(self, value) -> bool:
+        """Returns a boolean indicating whether the *value* object
+        qualifies as an ODL 'scalar_value'.
+
+        ODL defines a 'scalar-value' as a numeric_value, a
+        date_time_string, a text_string_value, or a symbol_value.
+
+        For Python, these correspond to the following:
+
+        * numeric_value: any of self.numeric_types, and Quantity whose value
+          is one of the self.numeric_types.
+        * date_time_string: datetime objects
+        * text_string_value: str
+        * symbol_value: str
+
+        """
+        for quant in self.quantities:
+            if isinstance(value, quant.cls):
+                if isinstance(
+                    getattr(value, quant.value_prop), self.numeric_types
+                ):
+                    return True
+
+        scalar_types = (
+            *self.numeric_types,
+            datetime.date,
+            datetime.datetime,
+            datetime.time,
+            str
+        )
+        if isinstance(value, scalar_types):
+            return True
+
+        return False
+
+    def is_symbol(self, value) -> bool:
+        """Returns true if *value* is an ODL Symbol String, false otherwise.
+
+        An ODL Symbol String is enclosed by single quotes
+        and may not contain any of the following characters:
+
+        1. The apostrophe, which is reserved as the symbol string delimiter.
+        2. ODL Format Effectors
+        3. Control characters
+
+        This means that an ODL Symbol String is a subset of the PVL
+        quoted string, and will be represented in Python as a ``str``.
+        """
+        if isinstance(value, str):
+            if "'" in value:  # Item 1
+                return False
+
+            for fe in self.grammar.format_effectors:  # Item 2
+                if fe in value:
+                    return False
+
+            if len(value) > self.width / 2:
+                # This means that the string is long and it is very
+                # likely to get wrapped and have carriage returns,
+                # and thus "ODL Format Effectors" inserted later.
+                # Unfortunately, without knowing the width of the
+                # parameter term, and the current indent level, this
+                # still may end up being incorrect threshhold.
+                return False
+
+            if value.isprintable() and len(value) > 0:  # Item 3
+                return True
+        else:
+            return False
+
+    def needs_quotes(self, s: str) -> bool:
+        """Return true if *s* is an ODL Identifier, false otherwise.
+
+        Overrides parent function.
+        """
+        return not self.decoder.is_identifier(s)
+
+    def is_assignment_statement(self, s) -> bool:
+        """Returns true if *s* is an ODL Assignment Statement, false otherwise.
+
+        An ODL Assignment Statement is either an
+        element_identifier or a namespace_identifier
+        joined to an element_identifier with a colon.
+        """
+        if self.decoder.is_identifier(s):
+            return True
+
+        (ns, _, el) = s.partition(":")
+
+        if self.decoder.is_identifier(ns) and self.decoder.is_identifier(el):
+            return True
+
+        return False
+
+    def encode_assignment(self, key, value, level=0, key_len=None) -> str:
+        """Overrides parent function by restricting the length of
+        keywords and enforcing that they be ODL Identifiers
+        and uppercasing their characters.
+        """
+
+        if key_len is None:
+            key_len = len(key)
+
+        if len(key) > 30:
+            raise ValueError(
+                "ODL keywords must be 30 characters or less "
+                f"in length, this one is longer: {key}"
+            )
+
+        if (
+            key.startswith("^") and self.is_assignment_statement(key[1:])
+        ) or self.is_assignment_statement(key):
+            ident = key.upper()
+        else:
+            raise ValueError(
+                f'The keyword "{key}" is not a valid ODL ' "Identifier."
+            )
+
+        s = "{} = ".format(ident.ljust(key_len))
+        s += self.encode_value(value)
+
+        if self.end_delimiter:
+            s += self.grammar.delimiters[0]
+
+        return self.format(s, level)
+
+    def encode_sequence(self, value) -> str:
+        """Extends parent function, as ODL only allows one- and
+        two-dimensional sequences of ODL scalar_values.
+        """
+        if len(value) == 0:
+            raise ValueError("ODL does not allow empty Sequences.")
+
+        for v in value:  # check the first dimension (list of elements)
+            if isinstance(v, list):
+                for i in v:  # check the second dimension (list of lists)
+                    if isinstance(i, list):
+                        # Shouldn't be lists of lists of lists.
+                        raise ValueError(
+                            "ODL only allows one- and two- "
+                            "dimensional Sequences, but "
+                            f"this has more: {value}"
+                        )
+                    elif not self.is_scalar(i):
+                        raise ValueError(
+                            "ODL only allows scalar_values "
+                            f"within sequences: {v}"
+                        )
+
+            elif not self.is_scalar(v):
+                raise ValueError(
+                    "ODL only allows scalar_values within " f"sequences: {v}"
+                )
+
+        return super().encode_sequence(value)
+
+    def encode_set(self, values) -> str:
+        """Extends parent function, ODL only allows sets to contain
+        scalar values.
+        """
+
+        if not all(map(self.is_scalar, values)):
+            raise ValueError(
+                f"ODL only allows scalar values in sets: {values}"
+            )
+
+        return super().encode_set(values)
+
+    def encode_value(self, value):
+        """Extends parent function by only allowing Units Expressions for
+        numeric values.
+        """
+        for quant in self.quantities:
+            if isinstance(value, quant.cls):
+                if isinstance(
+                    getattr(value, quant.value_prop),
+                    self.numeric_types
+                ):
+                    return super().encode_value(value)
+                else:
+                    raise ValueError(
+                        "Unit expressions are only allowed "
+                        f"following numeric values: {value}"
+                    )
+
+        return super().encode_value(value)
+
+    def encode_string(self, value):
+        """Extends parent function by appropriately quoting Symbol
+        Strings.
+        """
+        if self.decoder.is_identifier(value):
+            return value
+        elif self.is_symbol(value):
+            return "'" + value + "'"
+        else:
+            return super().encode_string(value)
+
+    def encode_time(self, value: datetime.time) -> str:
+        """Extends parent function since ODL allows a time zone offset
+        from UTC to be included, and otherwise recommends that times
+        be suffixed with a 'Z' to clearly indicate that they are in UTC.
+        """
+        if value.tzinfo is None:
+            raise ValueError(
+                f"ODL cannot output local times, and this time does not "
+                f"have a timezone offset: {value}"
+            )
+
+        t = super().encode_time(value)
+
+        if value.utcoffset() == datetime.timedelta():
+            return t + "Z"
+        else:
+            td_str = str(value.utcoffset())
+            (h, m, s) = td_str.split(":")
+            if s != "00":
+                raise ValueError(
+                    "The datetime value had a timezone offset "
+                    f"with seconds values ({value}) which is "
+                    "not allowed in ODL."
+                )
+            if m == "00":
+                return t + f"+{h:0>2}"
+            else:
+                return t + f"+{h:0>2}:{m}"
+
+        return t
+
+    def encode_units(self, value) -> str:
+        """Overrides parent function since ODL limits what characters
+        and operators can be present in Units Expressions.
+        """
+
+        # if self.is_identifier(value.strip('*/()-')):
+        if self.decoder.is_identifier(re.sub(r"[\s*/()-]", "", value)):
+
+            if "**" in value:
+                exponents = re.findall(r"\*\*.+?", value)
+                for e in exponents:
+                    if re.search(r"\*\*-?\d+", e) is None:
+                        raise ValueError(
+                            "The exponentiation operator (**) in "
+                            f'this Units Expression "{value}" '
+                            "is not a decimal integer."
+                        )
+
+            return (
+                self.grammar.units_delimiters[0]
+                + value
+                + self.grammar.units_delimiters[1]
+            )
+        else:
+            raise ValueError(
+                f'The value, "{value}", does not conform to '
+                "the specification for an ODL Units Expression."
+            )
+
+
+class PDSLabelEncoder(ODLEncoder):
+    """An encoder based on the rules in the PDS3 Standards Reference
+    (version 3.8, 27 Feb 2009) Chapter 12: Object Description
+    Language Specification and Usage and writes out labels that
+    conform to the PDS 3 standards.
+
+    It extends ODLEncoder.
+
+    You are not allowed to chose *end_delimiter* or *newline*
+    as the parent class allows, because to be PDS-compliant,
+    those are fixed choices.  However, in some cases, the PDS3
+    Standards are asymmetric, allowing for a wider variety of
+    PVL-text on "read" and a more narrow variety of PVL-text
+    on "write".  The default values of the PDSLabelEncoder enforce
+    those strict "write" rules, but if you wish to alter them,
+    but still produce PVL-text that would validate against the PDS3
+    standard, you may alter them.
+
+    :param convert_group_to_object: Defaults to True, meaning that
+        if a GROUP does not conform to the PDS definition of a
+        GROUP, then it will be written out as an OBJECT.  If it is
+        False, then an exception will be thrown if incompatible
+        GROUPs are encountered. In PVL and ODL, the OBJECT and GROUP
+        aggregations are interchangeable, but the PDS applies
+        restrictions to what can appear in a GROUP.
+    :param tab_replace: Defaults to 4 and indicates the number of
+        space characters to replace horizontal tab characters with
+        (since tabs aren't allowed in PDS labels).  If this is set
+        to zero, tabs will not be replaced with spaces.
+    :param symbol_single_quotes: Defaults to True, and if a Python `str`
+        object qualifies as a PVL Symbol String, it will be written to
+        PVL-text as a single-quoted string.  If False, no special
+        handling is done, and any PVL Symbol String will be treated
+        as a PVL Text String, which is typically enclosed with double-quotes.
+    :param time_trailing_z: defaults to True, and suffixes a "Z" to
+        datetimes and times written to PVL-text as the PDS encoding
+        standard requires.  If False, no trailing "Z" is written.
+
+    """
+
+    def __init__(
+        self,
+        grammar=None,
+        decoder=None,
+        indent=2,
+        width=80,
+        aggregation_end=True,
+        group_class=PVLGroup,
+        object_class=PVLObject,
+        convert_group_to_object=True,
+        tab_replace=4,
+        symbol_single_quote=True,
+        time_trailing_z=True,
+    ):
+
+        if grammar is None:
+            grammar = PDSGrammar()
+
+        if decoder is None:
+            decoder = PDSLabelDecoder(grammar)
+
+        super().__init__(
+            grammar,
+            decoder,
+            indent,
+            width,
+            aggregation_end,
+            end_delimiter=False,
+            newline="\r\n",
+            group_class=group_class,
+            object_class=object_class
+        )
+
+        self.convert_group_to_object = convert_group_to_object
+        self.tab_replace = tab_replace
+        self.symbol_single_quote = symbol_single_quote
+        self.time_trailing_z = time_trailing_z
+
+    def count_aggs(
+        self, module: abc.Mapping, obj_count: int = 0, grp_count: int = 0
+    ) -> tuple((int, int)):
+        """Returns the count of OBJECT and GROUP aggregations
+        that are contained within the *module* as a two-tuple
+        in that order.
+        """
+        # This currently just counts the values in the passed
+        # in module, it does not 'recurse' if those aggregations also
+        # may contain aggregations.
+
+        for k, v in module.items():
+            if isinstance(v, abc.Mapping):
+                if isinstance(v, self.grpcls):
+                    grp_count += 1
+                elif isinstance(v, self.objcls):
+                    obj_count += 1
+                else:
+                    # We treat other dict-like Python objects as
+                    # PVL Objects for the purposes of this count,
+                    # because that is how they will be encoded.
+                    obj_count += 1
+
+        return obj_count, grp_count
+
+    def encode(self, module: abc.MutableMapping) -> str:
+        """Extends the parent function, by adding a restriction.
+        For PDS, if there are any GROUP elements, there must be at
+        least one OBJECT element in the label.  Behavior here
+        depends on the value of this encoder's convert_group_to_object
+        property.
+        """
+        (obj_count, grp_count) = self.count_aggs(module)
+
+        if grp_count > 0 and obj_count < 1:
+            if self.convert_group_to_object:
+                for k, v in module.items():
+                    # First try to convert any GROUPs that would not
+                    # be valid PDS GROUPs.
+                    if isinstance(v, self.grpcls) and not self.is_PDSgroup(v):
+                        module[k] = self.objcls(v)
+                        break
+                else:
+                    # Then just convert the first GROUP
+                    for k, v in module.items():
+                        if isinstance(v, self.grpcls):
+                            module[k] = self.objcls(v)
+                            break
+                    else:
+                        raise ValueError(
+                            "Couldn't convert any of the GROUPs " "to OBJECTs."
+                        )
+            else:
+                raise ValueError(
+                    "This module has a GROUP element, but no "
+                    "OBJECT elements, which is not allowed by "
+                    "the PDS.  You could set "
+                    "*convert_group_to_object* to *True* on the "
+                    "encoder to try and convert a GROUP "
+                    "to an OBJECT."
+                )
+
+        s = super().encode(module)
+        if self.tab_replace > 0:
+            return s.replace("\t", (" " * self.tab_replace))
+        else:
+            return s
+
+    def is_PDSgroup(self, group: abc.Mapping) -> bool:
+        """Returns true if the dict-like *group* qualifies as a PDS Group,
+        false otherwise.
+
+        PDS applies the following restrictions to GROUPS:
+
+        1. The GROUP structure may only be used in a data product
+           label which also contains one or more data OBJECT definitions.
+        2. The GROUP statement must contain only attribute assignment
+           statements, include pointers, or related information pointers
+           (i.e., no data location pointers). If there are multiple
+           values, a single statement must be used with either sequence
+           or set syntax; no attribute assignment statement or pointer
+           may be repeated.
+        3. GROUP statements may not be nested.
+        4. GROUP statements may not contain OBJECT definitions.
+        5. Only PSDD elements may appear within a GROUP statement.
+           *PSDD is not defined anywhere in the PDS document, so don't
+           know how to test for it.*
+        6. The keyword contents associated with a specific GROUP
+           identifier must be identical across all labels of a single data
+           set (with the exception of the “PARAMETERS” GROUP, as
+           explained).
+
+        Use of the GROUP structure must be coordinated with the
+        responsible PDS discipline Node.
+
+        Items 1 & 6 and the final sentence above, can't really be tested
+        by examining a single group, but must be dealt with in a larger
+        context.  The ODLEncoder.encode_module() handles #1, at least.
+        You're on your own for the other two issues.
+
+        Item 5: *PSDD* is not defined anywhere in the ODL PDS document,
+        so don't know how to test for it.
+        """
+        (obj_count, grp_count) = self.count_aggs(group)
+
+        # Items 3 and 4:
+        if obj_count != 0 or grp_count != 0:
+            return False
+
+        # Item 2, no data location pointers:
+        for k, v in group.items():
+            if k.startswith("^"):
+                if isinstance(v, int):
+                    return False
+                else:
+                    for quant in self.quantities:
+                        if isinstance(v, quant.cls) and isinstance(
+                            getattr(v, quant.value_prop), int
+                        ):
+                            return False
+
+        # Item 2, no repeated keys:
+        keys = list(group.keys())
+        if len(keys) != len(set(keys)):
+            return False
+
+        return True
+
+    def encode_aggregation_block(self, key, value, level=0):
+        """Extends parent function because PDS has restrictions on
+        what may be in a GROUP.
+
+        If the encoder's *convert_group_to_object* parameter is True,
+        and a GROUP does not conform to the PDS definition of a GROUP,
+        then it will be written out as an OBJECT.  If it is False,
+        then an exception will be thrown.
+        """
+
+        # print('value at top:')
+        # print(value)
+
+        if isinstance(value, self.grpcls) and not self.is_PDSgroup(value):
+            if self.convert_group_to_object:
+                value = self.objcls(value)
+            else:
+                raise ValueError(
+                    "This GROUP element is not a valid PDS "
+                    "GROUP.  You could set "
+                    "*convert_group_to_object* to *True* on the "
+                    "encoder to try and convert the GROUP"
+                    "to an OBJECT."
+                )
+
+        # print('value at bottom:')
+        # print(value)
+
+        return super().encode_aggregation_block(key, value, level)
+
+    def encode_set(self, values) -> str:
+        """Extends parent function because PDS only allows symbol values
+        and integers within sets.
+        """
+        for v in values:
+            if not self.is_symbol(v) and not isinstance(v, int):
+                raise ValueError(
+                    "The PDS only allows integers and symbols "
+                    f"in sets: {values}"
+                )
+
+        return super().encode_set(values)
+
+    def encode_string(self, value):
+        """Extends parent function to treat Symbol Strings as Text Strings,
+        which typically means that they are double-quoted and not
+        single-quoted.
+        """
+        if self.decoder.is_identifier(value):
+            return value
+        elif self.is_symbol(value) and self.symbol_single_quote:
+            return "'" + value + "'"
+        else:
+            return super(ODLEncoder, self).encode_string(value)
+
+    def encode_time(self, value: datetime.time) -> str:
+        """Overrides parent's encode_time() function because
+        even though ODL allows for timezones, PDS does not.
+
+        Not in the section on times, but at the end of the PDS
+        ODL document, in section 12.7.3, para 14, it indicates that
+        alternate time zones may not be used in a PDS label, only
+        these:
+        1. YYYY-MM-DDTHH:MM:SS.SSS.
+        2. YYYY-DDDTHH:MM:SS.SSS.
+
+        """
+        s = f"{value:%H:%M}"
+
+        if value.microsecond:
+            ms = round(value.microsecond / 1000)
+            if value.microsecond != ms * 1000:
+                raise ValueError(
+                    f"PDS labels can only encode time values to the milisecond "
+                    f"precision, and this time ({value}) has too much "
+                    f"precision."
+                )
+            else:
+                s += f":{value:%S}.{ms}"
+        elif value.second:
+            s += f":{value:%S}"
+
+        if (
+            value.tzinfo is None or
+            value.tzinfo.utcoffset(None) == datetime.timedelta(0)
+        ):
+            if self.time_trailing_z:
+                return s + "Z"
+            else:
+                return s
+        else:
+            raise ValueError(
+                "PDS labels should only have UTC times, but "
+                f"this time has a timezone: {value}"
+            )
+
+
+class ISISEncoder(PVLEncoder):
+    """An encoder for writing PVL text that can be parsed by the
+    ISIS PVL text parser.
+
+    The ISIS3 implementation (as of 3.9) of PVL/ODL (like) does not
+    strictly follow any of the published standards. It was based
+    on PDS3 ODL from the 1990s, but has several extensions adopted
+    from existing and prior data sets from ISIS2, PDS, JAXA, ISRO,
+    ..., and extensions used only within ISIS files (cub, net). This
+    is one of the reasons using ISIS cube files or PVL text written by
+    ISIS as an archive format has been strongly discouraged.
+
+    Since there is no specification, only a detailed analysis of
+    the ISIS software that parses and writes its PVL text would
+    yield a strategy for parsing it.  This encoder is most likely the
+    least reliable for that reason.  We welcome bug reports to help
+    extend our coverage of this flavor of PVL text.
+
+    :param grammar: defaults to pvl.grammar.ISISGrammar().
+    :param decoder: defaults to pvl.decoder.PVLDecoder().
+    :param end_delimiter: defaults to False.
+    :param newline: defaults to '\\\\n'.
+    """
+
+    def __init__(
+        self,
+        grammar=None,
+        decoder=None,
+        indent=2,
+        width=80,
+        aggregation_end=True,
+        end_delimiter=False,
+        newline="\n",
+        group_class=PVLGroup,
+        object_class=PVLObject
+    ):
+
+        if grammar is None:
+            grammar = ISISGrammar()
+
+        if decoder is None:
+            decoder = PVLDecoder(grammar)
+
+        super().__init__(
+            grammar,
+            decoder,
+            indent,
+            width,
+            aggregation_end,
+            end_delimiter,
+            newline,
+            group_class=group_class,
+            object_class=object_class
+        )
diff --git a/hirise_blender/pvl/exceptions.py b/hirise_blender/pvl/exceptions.py
new file mode 100644
index 0000000..9a87feb
--- /dev/null
+++ b/hirise_blender/pvl/exceptions.py
@@ -0,0 +1,79 @@
+# -*- coding: utf-8 -*-
+"""
+Exceptions for the Parameter Value Library.
+"""
+
+# Copyright 2019-2020, ``pvl`` library authors.
+#
+# Reuse is permitted under the terms of the license.
+# The AUTHORS file and the LICENSE file are at the
+# top level of this library.
+
+
+def firstpos(sub: str, pos: int):
+    """On the assumption that *sub* is a substring contained in a longer
+    string, and *pos* is the index in that longer string of the final
+    character in sub, returns the position of the first character of
+    sub in that longer string.
+
+    This is useful in the PVL library when we know the position of the
+    final character of a token, but want the position of the first
+    character.
+    """
+    return pos - len(sub) + 1
+
+
+def linecount(doc: str, end: int, start: int = 0):
+    """Returns the number of lines (by counting the
+    number of newline characters \\n, with the first line
+    being line number one) in the string *doc* between the
+    positions *start* and *end*.
+    """
+    return doc.count("\n", start, end) + 1
+
+
+class LexerError(ValueError):
+    """Subclass of ValueError with the following additional properties:
+
+    msg: The unformatted error message
+    doc: The PVL text being parsed
+    pos: The start index in doc where parsing failed
+    lineno: The line corresponding to pos
+    colno: The column corresponding to pos
+    """
+
+    def __init__(self, msg, doc, pos, lexeme):
+        self.pos = firstpos(lexeme, pos)
+        lineno = linecount(doc, self.pos)
+        colno = self.pos - doc.rfind("\n", 0, self.pos)
+        # Assemble a context string that consists of whole
+        # words, using fragments is hard to read.
+        context_tokens = doc[self.pos - 15: self.pos + 15].split(" ")
+        context = " ".join(context_tokens[1:-1])
+        errmsg = (
+            f"{msg}: line {lineno} column {colno} (char {pos}) "
+            f'near "{context}"'
+        )
+        super().__init__(self, errmsg)
+        self.msg = msg
+        self.doc = doc
+        self.lineno = lineno
+        self.colno = colno
+        self.lexeme = lexeme
+
+    def __reduce__(self):
+        return self.__class__, (self.msg, self.doc, self.pos, self.lexeme)
+
+
+class ParseError(Exception):
+    """An exception to signal errors in the pvl parser."""
+
+    def __init__(self, msg, token=None):
+        super().__init__(self, msg)
+        self.token = token
+
+
+class QuantityError(Exception):
+    """A simple exception to distinguish errors from Quantity classes."""
+
+    pass
diff --git a/hirise_blender/pvl/grammar.py b/hirise_blender/pvl/grammar.py
new file mode 100755
index 0000000..afa4e53
--- /dev/null
+++ b/hirise_blender/pvl/grammar.py
@@ -0,0 +1,345 @@
+# -*- coding: utf-8 -*-
+"""Describes the language aspects of PVL dialects.
+
+These grammar objects are not particularly meant to be easily
+user-modifiable during running of an external program, which is why
+they have no arguments at initiation time, nor are there any methods
+or functions to modify them.  This is because these grammar objects
+are used both for reading and writing PVL-text.  As such, objects
+like PVLGrammar and ODLGrammar shouldn't be altered, because if
+they are, then the PVL-text written out with them wouldn't conform
+to the spec.
+
+Certainly, these objects do have attributes that can be altered,
+but unless you've carefully read the code, it isn't recommended.
+
+Maybe someday we'll add a more user-friendly interface to allow that,
+but in the meantime, just leave an Issue on the GitHub repo.
+"""
+
+# Copyright 2019-2021, ``pvl`` library authors.
+#
+# Reuse is permitted under the terms of the license.
+# The AUTHORS file and the LICENSE file are at the
+# top level of this library.
+
+import re
+from collections import abc
+from datetime import timezone
+
+
+class PVLGrammar:
+    """Describes a PVL grammar for use by the lexer and parser.
+
+    The reference for this grammar is the CCSDS-641.0-B-2 'Blue Book'.
+    """
+
+    spacing_characters = (" ", "\t")
+    format_effectors = ("\n", "\r", "\v", "\f")
+
+    # Tuple of characters to be recognized as PVL White Space
+    # (used to separate syntactic elements and promote readability,
+    # but the amount or presence of White Space may not be used to
+    # provide different meanings).
+    whitespace = spacing_characters + format_effectors
+
+    # Tuple of characters that may not occur in Parameter Names,
+    # Unquoted Strings, nor Block Names.
+    reserved_characters = (
+        "&",
+        "<",
+        ">",
+        "'",
+        "{",
+        "}",
+        ",",
+        "[",
+        "]",
+        "=",
+        "!",
+        "#",
+        "(",
+        ")",
+        "%",
+        "+",
+        '"',
+        ";",
+        "~",
+        "|",
+    )
+
+    # If there are any reserved_characters that might start a number,
+    # they need to be added to numeric_start_chars, otherwise that
+    # character will get lexed separately from the rest.
+    # Technically, since '-' isn't in reserved_characters, it isn't needed,
+    # but it doesn't hurt to keep it here.
+    numeric_start_chars = ("+", "-")
+
+    delimiters = (";",)
+
+    # Tuple of two-tuples with each two-tuple containing a pair of character
+    # sequences that enclose a comment.
+    comments = (("/*", "*/"),)
+
+    # A note on keywords: they should always be compared with
+    # the str.casefold() function.
+    # So 'NULL'.casefold(), 'Null'.casefold(), and 'NuLl".casefold()
+    # all compare equals to none_keyword.casefold().
+    none_keyword = "NULL"
+    true_keyword = "TRUE"
+    false_keyword = "FALSE"
+    group_pref_keywords = ("BEGIN_GROUP", "END_GROUP")
+    group_keywords = {"GROUP": "END_GROUP", "BEGIN_GROUP": "END_GROUP"}
+    object_pref_keywords = ("BEGIN_OBJECT", "END_OBJECT")
+    object_keywords = {"OBJECT": "END_OBJECT", "BEGIN_OBJECT": "END_OBJECT"}
+    aggregation_keywords = dict()
+    aggregation_keywords.update(group_keywords)
+    aggregation_keywords.update(object_keywords)
+    end_statements = ("END",)
+    reserved_keywords = set(end_statements)
+    for p in aggregation_keywords.items():
+        reserved_keywords |= set(p)
+
+    quotes = ('"', "'")
+    set_delimiters = ("{", "}")
+    sequence_delimiters = ("(", ")")
+    units_delimiters = ("<", ">")
+
+    # [sign]radix#non_decimal_integer#
+    _s = r"(?P<sign>[+-]?)"
+    nondecimal_pre_re = re.compile(fr"{_s}(?P<radix>2|8|16)#")
+    binary_re = re.compile(fr"{_s}(?P<radix>2)#(?P<non_decimal>[01]+)#")
+    octal_re = re.compile(fr"{_s}(?P<radix>8)#(?P<non_decimal>[0-7]+)#")
+    hex_re = re.compile(fr"{_s}(?P<radix>16)#(?P<non_decimal>[0-9A-Fa-f]+)#")
+    nondecimal_re = re.compile(
+        fr"{nondecimal_pre_re.pattern}(?P<non_decimal>[0-9|A-Fa-f]+)#"
+    )
+
+    # The PVL Blue Book says that all PVl Date/Time Values are represented
+    # in Universal Coordinated Time
+    default_timezone = timezone.utc
+    _d_formats = ("%Y-%m-%d", "%Y-%j")
+    _t_formats = ("%H:%M", "%H:%M:%S", "%H:%M:%S.%f")
+    date_formats = _d_formats + tuple(x + "Z" for x in _d_formats)
+    time_formats = _t_formats + tuple(x + "Z" for x in _t_formats)
+    datetime_formats = list()
+    for d in _d_formats:
+        for t in _t_formats:
+            datetime_formats.append(f"{d}T{t}")
+            datetime_formats.append(f"{d}T{t}Z")
+
+    # I really didn't want to write these, because it is so easy to
+    # make a mistake with time regexes, but they're they only way
+    # to parse times with 60 seconds in them.  The above regexes and
+    # the datetime library are used for all other time parsing.
+    _H_frag = r"(?P<hour>0\d|1\d|2[0-3])"  # 00 to 23
+    _M_frag = r"(?P<minute>[0-5]\d)"  # 00 to 59
+    _f_frag = r"(\.(?P<microsecond>\d+))"  # 1 or more digits
+    _Y_frag = r"(?P<year>\d{3}[1-9])"  # 0001 to 9999
+    _m_frag = r"(?P<month>0[1-9]|1[0-2])"  # 01 to 12
+    _d_frag = r"(?P<day>0[1-9]|[12]\d|3[01])"  # 01 to 31
+    _Ymd_frag = fr"{_Y_frag}-{_m_frag}-{_d_frag}"
+    # 001 to 366:
+    _j_frag = r"(?P<doy>(00[1-9]|0[1-9]\d)|[12]\d{2}|3[0-5]\d|36[0-6])"
+    _Yj_frag = fr"{_Y_frag}-{_j_frag}"
+    _time_frag = fr"{_H_frag}:{_M_frag}:60{_f_frag}?Z?"  # Only times with 60 s
+    # _time_frag = fr'{_H_frag}:{_M_frag}]'  # Only times with 60 s
+    leap_second_Ymd_re = re.compile(fr"({_Ymd_frag}T)?{_time_frag}")
+    leap_second_Yj_re = re.compile(fr"({_Yj_frag}T)?{_time_frag}")
+
+    def char_allowed(self, char):
+        """Returns true if *char* is allowed in the PVL Character Set.
+
+        This is defined as most of the ISO 8859-1 'latin-1' character
+        set with some exclusions.
+        """
+        if len(char) != 1:
+            raise ValueError(
+                f"This function only takes single characters and it was given "
+                f"{len(char)} ('{char}')."
+            )
+
+        o = ord(char)
+
+        # The vertical tab, ord('\t') = 11, is mistakenly
+        # shaded on page B-3 of the PVL specification.
+        if (
+            o > 255
+            or (0 <= o <= 8)
+            or
+            # o == 11 or
+            (14 <= o <= 31)
+            or (127 <= o <= 159)
+        ):
+            return False
+        else:
+            return True
+
+
+class ODLGrammar(PVLGrammar):
+    """This defines an ODL grammar.
+
+    The reference for this grammar is the PDS3 Standards Reference
+    (version 3.8, 27 Feb 2009) Chapter 12: Object Description
+    Language Specification and Usage.
+    """
+
+    group_pref_keywords = ("GROUP", "END_GROUP")
+    object_pref_keywords = ("OBJECT", "END_OBJECT")
+
+    # ODL does not allow times with a seconds value of 60.
+    leap_second_Ymd_re = None
+    leap_second_Yj_re = None
+
+    # ODL allows "local" times without a timezone specifier.
+    default_timezone = None
+
+    # ODL allows the radix to be from 2 to 16, but the optional sign
+    # must be after the first octothorpe (#).  Why ODL thought this was
+    # an important difference to make from PVL, I have no idea.
+    # radix#[sign]non_decimal_integer#
+    nondecimal_pre_re = re.compile(fr"(?P<radix>[2-9]|1[0-6])#{PVLGrammar._s}")
+    nondecimal_re = re.compile(
+        fr"{nondecimal_pre_re.pattern}(?P<non_decimal>[0-9A-Fa-f]+)#"
+    )
+
+    def char_allowed(self, char):
+        """Returns true if *char* is allowed in the ODL Character Set.
+
+        The ODL Character Set is limited to ASCII.  This is fewer
+        characters than PVL, but appears to allow more control
+        characters to be in quoted strings than PVL does.
+        """
+        super().char_allowed(char)
+
+        try:
+            char.encode(encoding="ascii")
+            return True
+        except UnicodeError:
+            return False
+
+
+class PDSGrammar(ODLGrammar):
+    """This defines a PDS3 ODL grammar.
+
+    The reference for this grammar is the PDS3 Standards Reference
+    (version 3.8, 27 Feb 2009) Chapter 12: Object Description
+    Language Specification and Usage.
+    """
+
+    # The PDS spec only allows allows miliseconds, not microseconds,
+    # but there is only a %f microseconds time format specifier in
+    # Python, and no miliseconds format specifier, so dealing with
+    # only the miliseconds will have to be enforced at the encoder and
+    # decoder stages.
+
+    # PDSLabels default to UTC:
+    default_timezone = timezone.utc
+
+
+class ISISGrammar(PVLGrammar):
+    """This defines the ISIS version of PVL.
+
+       This is valid as of ISIS 3.9, and before, at least.
+
+       The ISIS 'Pvl' object typically writes out parameter
+       values and keywords in CamelCase (e.g. 'Group', 'End_Group',
+       'CenterLatitude', etc.), but it will accept all-uppercase
+       versions.
+
+       Technically, since the ISIS 'Pvl' object which parses
+       PVL text into C++ objects for ISIS programs to work with
+       does not recognize the 'BEGIN_<GROUP|OBJECT>' construction,
+       this means that ISIS does not parse PVL text that would be
+       valid according to the PVL, ODL, or PDS3 specs.
+    """
+
+    # The other thing that ISIS seems to be doing differently is to
+    # split any text of all kinds with a dash continuation character.  This
+    # is currently handled in the OmniParser.parse() function.
+
+    # At
+    # https://astrodiscuss.usgs.gov/t/what-pvl-specification-does-isis-conform-to/
+    #
+    # Stuart Sides, ISIS developer, says:
+    #     The ISIS3 implementation of PVL/ODL (like) does not strictly
+    #     follow any of the published standards. It was based on PDS3
+    #     ODL from the 1990s, but has several extensions (your example
+    #     of continuation lines) adopted from existing and prior data
+    #     sets from ISIS2, PDS, JAXA, ISRO, ..., and extensions used
+    #     only within ISIS3 files (cub, net). This is one of the
+    #     reasons using ISIS cube files as an archive format has been
+    #     strongly discouraged. So to answer your question, there is
+    #     no published specification for ISIS3 PVL.
+
+    # The ISIS parser (at least <=3.9) doesn't recognize the
+    # 'BEGIN_<GROUP|OBJECT>' construction, which is why we must
+    # have a separate grammar object.  Since we're at it, we might
+    # as well use the *_pref_keywords to indicate the CamelCase
+    # that ISIS folks are expecting.
+    group_pref_keywords = ("Group", "End_Group")
+    group_keywords = {"GROUP": "END_GROUP"}
+    object_pref_keywords = ("Object", "End_Object")
+    object_keywords = {"OBJECT": "END_OBJECT"}
+
+    # A single-line comment that starts with the octothorpe (#) is not part
+    # of PVL or ODL, but it is used when ISIS writes out comments.
+    comments = (("/*", "*/"), ("#", "\n"))
+
+    def __init__(self):
+        # ISIS allows for + characters in Unquoted String values.
+        self.reserved_characters = tuple(
+            self.adjust_reserved_characters(self.reserved_characters)
+        )
+
+    @staticmethod
+    def adjust_reserved_characters(chars: abc.Iterable):
+        # ISIS allows for + characters in Unquoted String values.
+        # Removing the plus from the reserved characters allows for
+        # that, but might lead to other parsing errors, so be on the lookout.
+        rc = list(chars)
+        rc.remove("+")
+        return rc
+
+
+class OmniGrammar(PVLGrammar):
+    """A broadly permissive grammar.
+
+    This grammar does not follow a specification, but is meant to allow
+    the broadest possible ingestion of PVL-like text that is found.
+
+    This grammar should not be used to write out Python objects to PVL,
+    instead please use one of the grammars that follows a published
+    specification, like the PVLGrammar or the ODLGrammar.
+    """
+
+    # Interestingly, a single-line comment that starts with the
+    # octothorpe (#) is neither part of PVL nor ODL, but people use
+    # it all the time.
+    comments = (("/*", "*/"), ("#", "\n"))
+
+    # ODL allows the radix to be from 2 to 16, and allows the sign to be
+    # 'inside' the octothorpes, so we need to allow for the wide variety
+    # of radix, and the variational placement of the optional sign:
+    # [sign]radix#[sign]non_decimal_integer#
+    _ss = r"(?P<second_sign>[+-]?)"
+    nondecimal_pre_re = re.compile(
+        PVLGrammar._s + fr"(?P<radix>[2-9]|1[0-6])#{_ss}"
+    )
+    nondecimal_re = re.compile(
+        nondecimal_pre_re.pattern + r"(?P<non_decimal>[0-9A-Fa-f]+)#"
+    )
+
+    def __init__(self):
+        # Handle the fact that ISIS writes out unquoted plus signs.
+        # See ISISGrammar for details.
+        # Also add the ASCII NULL ("\0") to the reserved_characters tuple.
+        self.reserved_characters = tuple(
+            ISISGrammar.adjust_reserved_characters(self.reserved_characters) +
+            ["\0", ]
+        )
+
+    def char_allowed(self, char):
+        """Takes all characters, could accept bad things, and the user must
+        beware."""
+        return True
diff --git a/hirise_blender/pvl/lexer.py b/hirise_blender/pvl/lexer.py
new file mode 100644
index 0000000..8fbba5d
--- /dev/null
+++ b/hirise_blender/pvl/lexer.py
@@ -0,0 +1,435 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+"""Provides lexer functions for PVL."""
+
+# Copyright 2019-2020, ``pvl`` library authors.
+#
+# Reuse is permitted under the terms of the license.
+# The AUTHORS file and the LICENSE file are at the
+# top level of this library.
+
+
+from enum import Enum, auto
+
+from .grammar import PVLGrammar
+from .token import Token
+from .decoder import PVLDecoder
+from .exceptions import LexerError, firstpos
+
+
+class Preserve(Enum):
+    FALSE = auto()
+    COMMENT = auto()
+    UNIT = auto()
+    QUOTE = auto()
+    NONDECIMAL = auto()
+
+
+def lex_preserve(char: str, lexeme: str, preserve: dict) -> tuple((str, dict)):
+    """Returns a modified *lexeme* string and a modified *preserve*
+    dict in a two-tuple.  The modified *lexeme* will always be
+    the concatenation of *lexeme* and *char*.
+
+    This is a lexer() helper function that is responsible for
+    changing the state of the *preserve* dict, if needed.
+
+    If the value for 'end' in *preserve* is the same as *char*,
+    then the modified *preserve* will have its 'state' value
+    set to ``Preserve.FALSE`` and its 'end' value set to None,
+    otherwise second item in the returned tuple will be *preserve*
+    unchanged.
+    """
+    # print(f'in preserve: char "{char}", lexeme "{lexeme}, p {preserve}"')
+    if char == preserve["end"]:
+        return lexeme + char, dict(state=Preserve.FALSE, end=None)
+    else:
+        return lexeme + char, preserve
+
+
+def lex_singlechar_comments(
+    char: str, lexeme: str, preserve: dict, comments: dict
+) -> tuple((str, dict)):
+    """Returns a modified *lexeme* string and a modified *preserve*
+    dict in a two-tuple.
+
+    This is a lexer() helper function for determining how to modify
+    *lexeme* and *preserve* based on the single character in *char*
+    which may or may not be a comment character.
+
+    If the *preserve* 'state' value is Preserve.COMMENT then
+    the value of lex_preserve() is returned.
+
+    If *char* is among the keys of the *comments* dict, then the
+    returned *lexeme* will be the concatenation of *lexeme* and
+    *char*.  returned *preserve* dict will have its 'state' value
+    set to Preserve.COMMENT and its 'end' value set to the value
+    of *comments[char]*.
+
+    Otherwise return *lexeme* and *preserve* unchanged in the
+    two-tuple.
+    """
+    if preserve["state"] == Preserve.COMMENT:
+        return lex_preserve(char, lexeme, preserve)
+    elif char in comments:
+        return (
+            lexeme + char,
+            dict(state=Preserve.COMMENT, end=comments[char]),
+        )
+
+    return lexeme, preserve
+
+
+def lex_multichar_comments(
+    char: str,
+    prev_char: str,
+    next_char: str,
+    lexeme: str,
+    preserve: dict,
+    comments: tuple(tuple((str, str))) = PVLGrammar().comments,
+) -> tuple((str, dict)):
+    """Returns a modified *lexeme* string and a modified *preserve*
+    dict in a two-tuple.
+
+    This is a lexer() helper function for determining how to
+    modify *lexeme* and *preserve* based on the single character
+    in *char* which may or may not be part of a multi-character
+    comment character group.
+
+    This function has an internal list of allowed pairs of
+    multi-character comments that it can deal with, if the
+    *comments* tuple contains any two-tuples that cannot be
+    handled, a NotImplementedError will be raised.
+
+    This function will determine whether to append *char* to
+    *lexeme* or not, and will set the value of the 'state' and
+    'end' values of *preserve* appropriately.
+    """
+    # print(f'lex_multichar got these comments: {comments}')
+    if len(comments) == 0:
+        raise ValueError("The variable provided to comments is empty.")
+
+    allowed_pairs = (("/*", "*/"),)
+    for p in comments:
+        if p not in allowed_pairs:
+            raise NotImplementedError(
+                "Can only handle these "
+                "multicharacter comments: "
+                f"{allowed_pairs}.  To handle "
+                "others this class must be extended."
+            )
+
+    if ("/*", "*/") in comments:
+        if char == "*":
+            if prev_char == "/":
+                return lexeme + "/*", dict(state=Preserve.COMMENT, end="*/")
+            elif next_char == "/":
+                return lexeme + "*/", dict(state=Preserve.FALSE, end=None)
+            else:
+                return lexeme + "*", preserve
+        elif char == "/":
+            # If part of a comment ignore, and let the char == '*' handler
+            # above deal with it, otherwise add it to the lexeme.
+            if prev_char != "*" and next_char != "*":
+                return lexeme + "/", preserve
+
+    return lexeme, preserve
+
+
+def lex_comment(
+    char: str,
+    prev_char: str,
+    next_char: str,
+    lexeme: str,
+    preserve: dict,
+    c_info: dict,
+) -> tuple((str, dict)):
+    """Returns a modified *lexeme* string and a modified *preserve*
+    dict in a two-tuple.
+
+    This is a lexer() helper function for determining how to
+    modify *lexeme* and *preserve* based on the single character
+    in *char* which may or may not be a comment character.
+
+    This function just makes the decision about whether to call
+    lex_multichar_comments() or lex_singlechar_comments(), and
+    then returns what they return.
+    """
+
+    if char in c_info["multi_chars"]:
+        return lex_multichar_comments(
+            char,
+            prev_char,
+            next_char,
+            lexeme,
+            preserve,
+            comments=c_info["multi_comments"],
+        )
+    else:
+        return lex_singlechar_comments(
+            char, lexeme, preserve, c_info["single_comments"]
+        )
+
+
+def _prev_char(s: str, idx: int):
+    """Returns the character from *s* at the position before *idx*
+    or None, if *idx* is zero.
+    """
+    if idx <= 0:
+        return None
+    else:
+        return s[idx - 1]
+
+
+def _next_char(s: str, idx: int):
+    """Returns the character from *s* at the position after *idx*
+    or None, if *idx* is the last position in *s*.
+    """
+    try:
+        return s[idx + 1]
+    except IndexError:
+        return None
+
+
+def _prepare_comment_tuples(comments: tuple(tuple((str, str)))) -> dict:
+    """Returns a dict of information based on the contents
+    of *comments*.
+
+    This is a lexer() helper function to prepare information
+    for lexer().
+    """
+    # I initially tried to avoid this function, if you
+    # don't pre-compute this stuff, you end up re-computing
+    # it every time you pass into the lex_comment() function,
+    # which seemed excessive.
+    d = dict()
+    m = list()
+    d["single_comments"] = dict()
+    d["multi_chars"] = set()
+    for pair in comments:
+        if len(pair[0]) == 1:
+            d["single_comments"][pair[0]] = pair[1]
+        else:
+            m.append(pair)
+            for p in pair:
+                d["multi_chars"] |= set(p)
+
+    d["chars"] = set(d["single_comments"].keys())
+    d["chars"] |= d["multi_chars"]
+    d["multi_comments"] = tuple(m)
+
+    # print(d)
+    return d
+
+
+def lex_char(
+    char: str,
+    prev_char: str,
+    next_char: str,
+    lexeme: str,
+    preserve: dict,
+    g: PVLGrammar,
+    c_info: dict,
+) -> tuple((str, dict)):
+    """Returns a modified *lexeme* string and a modified *preserve*
+    dict in a two-tuple.
+
+    This is the main lexer() helper function for determining how
+    to modify (or not) *lexeme* and *preserve* based on the
+    single character in *char* and the other values passed into
+    this function.
+    """
+
+    # When we are 'in' a comment or a units expression,
+    # we want those to consume everything, regardless.
+    # So we must handle the 'preserve' states first,
+    # and then after that we can check to see if the char
+    # should put us into one of those states.
+
+    # print(f'lex_char start: char "{char}", lexeme "{lexeme}", "{preserve}"')
+
+    if preserve["state"] != Preserve.FALSE:
+        if preserve["state"] == Preserve.COMMENT:
+            (lexeme, preserve) = lex_comment(
+                char, prev_char, next_char, lexeme, preserve, c_info
+            )
+        elif preserve["state"] in (
+            Preserve.UNIT,
+            Preserve.QUOTE,
+            Preserve.NONDECIMAL,
+        ):
+            (lexeme, preserve) = lex_preserve(char, lexeme, preserve)
+        else:
+            raise ValueError(
+                "{} is not a ".format(preserve["state"])
+                + "recognized preservation state."
+            )
+    elif (
+        char == "#"
+        and g.nondecimal_pre_re.fullmatch(lexeme + char) is not None
+    ):
+        lexeme += char
+        preserve = dict(state=Preserve.NONDECIMAL, end="#")
+    elif char in c_info["chars"]:
+        (lexeme, preserve) = lex_comment(
+            char, prev_char, next_char, lexeme, preserve, c_info
+        )
+    elif char in g.units_delimiters[0]:
+        lexeme += char
+        preserve = dict(state=Preserve.UNIT, end=g.units_delimiters[1])
+    elif char in g.quotes:
+        lexeme += char
+        preserve = dict(state=Preserve.QUOTE, end=char)
+    else:
+        if char not in g.whitespace:
+            lexeme += char  # adding a char each time
+
+    # print(f'lex_char end: char "{char}", lexeme "{lexeme}", "{preserve}"')
+    return lexeme, preserve
+
+
+def lex_continue(
+    char: str,
+    next_char: str,
+    lexeme: str,
+    token: Token,
+    preserve: dict,
+    g: PVLGrammar,
+) -> bool:
+    """Return True if accumulation of *lexeme* should continue based
+    on the values passed into this function, false otherwise.
+
+    This is a lexer() helper function.
+    """
+
+    if next_char is None:
+        return False
+
+    if not g.char_allowed(next_char):
+        return False
+
+    if preserve["state"] != Preserve.FALSE:
+        return True
+
+    # Since Numeric objects can begin with a reserved
+    # character, the reserved characters may split up
+    # the lexeme.
+    if (
+        char in g.numeric_start_chars
+        and Token(char + next_char, grammar=g).is_numeric()
+    ):
+        return True
+
+    # Since Non Decimal Numerics can have reserved characters in them.
+    if g.nondecimal_pre_re.fullmatch(lexeme + next_char) is not None:
+        return True
+
+    # Since the numeric signs could be in the reserved characters,
+    # make sure we can parse scientific notation correctly:
+    if (
+        char.lower() == "e"
+        and next_char in g.numeric_start_chars
+        and Token(lexeme + next_char + "2", grammar=g).is_numeric()
+    ):
+        return True
+
+    # Some datetimes can have trailing numeric tz offsets,
+    # if the decoder allows it, this means there could be
+    # a '+' that splits the lexeme that we don't want.
+    if next_char in g.numeric_start_chars and token.is_datetime():
+        return True
+
+    return False
+
+
+def lexer(s: str, g=PVLGrammar(), d=PVLDecoder()):
+    """This is a generator function that returns pvl.Token objects
+    based on the passed in string, *s*, when the generator's
+    next() is called.
+
+    A call to send(*t*) will 'return' the value *t* to the
+    generator, which will be yielded upon calling next().
+    This allows a user to 'peek' at the next token, but return it
+    if they don't like what they see.
+
+    *g* is expected to be an instance of pvl.grammar, and *d* an
+    instance of pvl.decoder.  The lexer will perform differently,
+    given different values of *g* and *d*.
+    """
+    c_info = _prepare_comment_tuples(g.comments)
+    # print(c_info)
+
+    lexeme = ""
+    preserve = dict(state=Preserve.FALSE, end=None)
+    for i, char in enumerate(s):
+        if not g.char_allowed(char):
+            raise LexerError(
+                f'The character "{char}" (ord: {ord(char)}) '
+                " is not allowed by the grammar.",
+                s,
+                i,
+                lexeme,
+            )
+
+        prev_char = _prev_char(s, i)
+        next_char = _next_char(s, i)
+
+        # print(repr(f'lexeme at top: ->{lexeme}<-, char: {char}, '
+        #            f'prev: {prev_char}, next: {next_char}, '
+        #            f'{preserve}'))
+
+        (lexeme, preserve) = lex_char(
+            char, prev_char, next_char, lexeme, preserve, g, c_info
+        )
+
+        # print(repr(f'       at bot: ->{lexeme}<-,          '
+        #            f'                  '
+        #            f'{preserve}'))
+
+        # Now having dealt with char, decide whether to
+        # go on continue accumulating the lexeme, or yield it.
+
+        if lexeme == "":
+            continue
+
+        try:
+            # The ``while t is not None: yield None; t = yield(t)``
+            # construction below allows a user of the lexer to
+            # yield a token, not like what they see, and then use
+            # the generator's send() function to put the token
+            # back into the generator.
+            #
+            # The first ``yield None`` in there allows the call to
+            # send() on this generator to return None, and keep the
+            # value of *t* ready for the next call of next() on the
+            # generator.  This is the magic that allows a user to
+            # 'return' a token to the generator.
+            tok = Token(lexeme, grammar=g, decoder=d, pos=firstpos(lexeme, i))
+
+            if lex_continue(char, next_char, lexeme, tok, preserve, g):
+                # Any lexeme state that we want to just allow
+                # to run around again and don't want to get
+                # caught by the clause in the elif, should
+                # test true via lex_continue()
+                continue
+
+            elif (
+                next_char is None
+                or not g.char_allowed(next_char)
+                or next_char in g.whitespace
+                or next_char in g.reserved_characters
+                or s.startswith(tuple(p[0] for p in g.comments), i + 1)
+                or lexeme.endswith(tuple(p[1] for p in g.comments))
+                or lexeme in g.reserved_characters
+                or tok.is_quoted_string()
+            ):
+                # print(f'yielding {tok}')
+                t = yield tok
+                while t is not None:
+                    yield None
+                    t = yield t
+                lexeme = ""
+            else:
+                continue
+
+        except ValueError as err:
+            raise LexerError(err, s, i, lexeme)
diff --git a/hirise_blender/pvl/new.py b/hirise_blender/pvl/new.py
new file mode 100755
index 0000000..4d6ac9b
--- /dev/null
+++ b/hirise_blender/pvl/new.py
@@ -0,0 +1,209 @@
+# -*- coding: utf-8 -*-
+"""Python implementation of PVL (Parameter Value Language), with upcoming
+features.
+
+If you currently use::
+
+    import pvl
+
+you can change to::
+
+    import pvl.new as pvl
+
+And then use all of the pvl functions as you usually would.  You
+will also need to have the 3rd party multidict library
+(https://github.com/aio-libs/multidict, conda installable) installed.
+But then, any objects that are returned by the load functions will
+be the new PVLMultiDict objects.
+"""
+
+# Copyright 2015, 2017, 2019-2021, ``pvl`` library authors.
+#
+# Reuse is permitted under the terms of the license.
+# The AUTHORS file and the LICENSE file are at the
+# top level of this library.
+
+import inspect
+import io
+import urllib.request
+from pathlib import Path
+
+try:  # noqa: C901
+    # In order to access super class attributes for our derived class, we must
+    # import the native Python version, instead of the default Cython version.
+    from multidict._multidict_py import MultiDict  # noqa: F401
+except ImportError as err:
+    raise ImportError(
+        "The multidict library is not present, so the new PVLMultiDict is not "
+        "available, and pvl.new can't be imported. In order to do so, install "
+        "the multidict package",
+        ImportWarning,
+    ) from err
+
+from pvl import *  # noqa: F401,F403
+from pvl import get_text_from, decode_by_char
+
+from .encoder import PDSLabelEncoder, PVLEncoder
+from .parser import PVLParser, OmniParser
+from .collections import PVLModuleNew, PVLGroupNew, PVLObjectNew
+
+__all__ = [
+    "PVLModuleNew",
+    "PVLGroupNew",
+    "PVLObjectNew",
+]
+
+
+def load(path, parser=None, grammar=None, decoder=None, **kwargs):
+    """Returns a Python object from parsing the file at *path*.
+
+    :param path: an :class:`os.PathLike` which presumably has a
+        PVL Module in it to parse.
+    :param parser: defaults to :class:`pvl.parser.OmniParser()`.
+    :param grammar: defaults to :class:`pvl.grammar.OmniGrammar()`.
+    :param decoder: defaults to :class:`pvl.decoder.OmniDecoder()`.
+    :param ``**kwargs``: the keyword arguments that will be passed
+        to :func:`loads()` and are described there.
+
+    If *path* is not an :class:`os.PathLike`, it will be assumed to be an
+    already-opened file object, and ``.read()`` will be applied
+    to extract the text.
+
+    If the :class:`os.PathLike` or file object contains some bytes
+    decodable as text, followed by some that is not (e.g. an ISIS
+    cube file), that's fine, this function will just extract the
+    decodable text.
+    """
+    return loads(
+        get_text_from(path),
+        parser=parser,
+        grammar=grammar,
+        decoder=decoder,
+        **kwargs
+    )
+
+
+def loadu(url, parser=None, grammar=None, decoder=None, **kwargs):
+    """Returns a Python object from parsing *url*.
+
+        :param url: this will be passed to :func:`urllib.request.urlopen`
+            and can be a string or a :class:`urllib.request.Request` object.
+        :param parser: defaults to :class:`pvl.parser.OmniParser()`.
+        :param grammar: defaults to :class:`pvl.grammar.OmniGrammar()`.
+        :param decoder: defaults to :class:`pvl.decoder.OmniDecoder()`.
+        :param ``**kwargs``: the keyword arguments that will be passed
+            to :func:`urllib.request.urlopen` and to :func:`loads()`.
+
+        The ``**kwargs`` will first be scanned for arguments that
+        can be given to :func:`urllib.request.urlopen`.  If any are
+        found, they are extracted and used.  All remaining elements
+        will be passed on as keyword arguments to :func:`loads()`.
+
+        Note that *url* can be any URL that :func:`urllib.request.urlopen`
+        takes.  Certainly http and https URLs, but also file, ftp, rsync,
+        sftp and more!
+        """
+
+    # Peel off the args for urlopen:
+    url_args = dict()
+    for a in inspect.signature(urllib.request.urlopen).parameters.keys():
+        if a in kwargs:
+            url_args[a] = kwargs.pop(a)
+
+    # The object returned from urlopen will always have a .read()
+    # function that returns bytes, so:
+    with urllib.request.urlopen(url, **url_args) as resp:
+        s = decode_by_char(resp)
+
+    return loads(s, parser=parser, grammar=grammar, decoder=decoder, **kwargs)
+
+
+def loads(s: str, parser=None, grammar=None, decoder=None, **kwargs):
+    """Deserialize the string, *s*, as a Python object.
+
+    :param s: contains some PVL to parse.
+    :param parser: defaults to :class:`pvl.parser.OmniParser() which will
+        return the new PVLMultiDict-derived objects`.
+    :param grammar: defaults to :class:`pvl.grammar.OmniGrammar()`.
+    :param decoder: defaults to :class:`pvl.decoder.OmniDecoder()`.
+    :param ``**kwargs``: the keyword arguments to pass to the *parser* class
+        if *parser* is none.
+    """
+    if isinstance(s, bytes):
+        # Someone passed us an old-style bytes sequence.  Although it isn't
+        # a string, we can deal with it:
+        s = s.decode()
+
+    if parser is None:
+        parser = OmniParser(
+            grammar=grammar,
+            decoder=decoder,
+            module_class=PVLModuleNew,
+            group_class=PVLGroupNew,
+            object_class=PVLObjectNew,
+            **kwargs
+        )
+    elif not isinstance(parser, PVLParser):
+        raise TypeError("The parser must be an instance of pvl.PVLParser.")
+
+    return parser.parse(s)
+
+
+def dump(module, path, **kwargs):
+    """Serialize *module* as PVL text to the provided *path*.
+
+    :param module: a ``PVLModule`` or ``dict``-like object to serialize.
+    :param path: an :class:`os.PathLike`
+    :param ``**kwargs``: the keyword arguments to pass to :func:`dumps()`.
+
+    If *path* is an :class:`os.PathLike`, it will attempt to be opened
+    and the serialized module will be written into that file via
+    the :func:`pathlib.Path.write_text()` function, and will return
+    what that function returns.
+
+    If *path* is not an :class:`os.PathLike`, it will be assumed to be an
+    already-opened file object, and ``.write()`` will be applied
+    on that object to write the serialized module, and will return
+    what that function returns.
+    """
+    try:
+        p = Path(path)
+        return p.write_text(dumps(module, **kwargs))
+
+    except TypeError:
+        # Not an os.PathLike, maybe it is an already-opened file object
+        try:
+            if isinstance(path, io.TextIOBase):
+                return path.write(dumps(module, **kwargs))
+            else:
+                return path.write(dumps(module, **kwargs).encode())
+        except AttributeError:
+            # Not a path, not an already-opened file.
+            raise TypeError(
+                "Expected an os.PathLike or an already-opened "
+                "file object for writing, but got neither."
+            )
+
+
+def dumps(module, encoder=None, grammar=None, decoder=None, **kwargs) -> str:
+    """Returns a string where the *module* object has been serialized
+    to PVL syntax.
+
+    :param module: a ``PVLModule`` or ``dict`` like object to serialize.
+    :param encoder: defaults to :class:`pvl.parser.PDSLabelEncoder()`.
+    :param grammar: defaults to :class:`pvl.grammar.ODLGrammar()`.
+    :param decoder: defaults to :class:`pvl.decoder.ODLDecoder()`.
+    :param ``**kwargs``: the keyword arguments to pass to the encoder
+        class if *encoder* is none.
+    """
+    if encoder is None:
+        encoder = PDSLabelEncoder(
+            grammar=grammar,
+            decoder=decoder,
+            group_class=PVLGroupNew,
+            object_class=PVLObjectNew,
+            **kwargs)
+    elif not isinstance(encoder, PVLEncoder):
+        raise TypeError("The encoder must be an instance of pvl.PVLEncoder.")
+
+    return encoder.encode(module)
diff --git a/hirise_blender/pvl/parser.py b/hirise_blender/pvl/parser.py
new file mode 100644
index 0000000..c7f312a
--- /dev/null
+++ b/hirise_blender/pvl/parser.py
@@ -0,0 +1,955 @@
+# -*- coding: utf-8 -*-
+"""Parameter Value Language parser.
+
+The definition of PVL used in this module is based on the Consultive
+Committee for Space Data Systems, and their Parameter Value
+Language Specification (CCSD0006 and CCSD0008), CCSDS 6441.0-B-2,
+referred to as the Blue Book with a date of June 2000.
+
+Some of the documention in this module represents the structure
+diagrams from the Blue Book for parsing PVL in a Backus–Naur
+form.
+
+So Figure 1-1 from the Blue Book would be represented as :
+
+ <Item-A> ::= ( [ <Item-B>+ | <Item-C> ] <Item-D> )*
+
+Finally, the Blue Book defines <WSC> as a possibly empty collection
+of white space characters or comments:
+
+ <WSC> ::= ( <white-space-character> | <comment> )*
+
+However, to help remember that <WSC> could be empty, we will typically
+always show it as <WSC>*.
+
+Likewise the <Statement-Delimiter> is defined as:
+
+ <Statement-Delimiter> ::= <WSC>* [ ';' | <EOF> ]
+
+However, since all elements are optional, we will typically
+show it as [<Statement-Delimiter>].
+
+The parser deals with managing the tokens that come out of the lexer.
+Once the parser gets to a state where it has something that needs to
+be converted to a Python object and returned, it uses the decoder to
+make that conversion.
+
+Throughout this module, various parser functions will take a *tokens:
+collections.abc.Generator* parameter.  In all cases, *tokens* is
+expected to be a *generator iterator* which provides ``pvl.token.Token``
+objects.  It should allow for a generated object to be 'returned'
+via the generator's send() function.  When parsing the first object
+from *tokens*, if an unexpected object is encountered, it will
+'return' the object to *tokens*, and raise a ``ValueError``, so
+that ``try``-``except`` blocks can be used, and the *generator
+iterator* is left in a good state. However, if a parsing anomaly
+is discovered deeper in parsing a PVL sequence, then a ``ValueError``
+will be thrown into the *tokens* generator iterator (via .throw()).
+"""
+
+# Copyright 2015, 2017, 2019-2020, ``pvl`` library authors.
+#
+# Reuse is permitted under the terms of the license.
+# The AUTHORS file and the LICENSE file are at the
+# top level of this library.
+
+import collections.abc as abc
+import re
+
+from .collections import MutableMappingSequence, PVLModule, PVLGroup, PVLObject
+from .token import Token
+from .grammar import PVLGrammar, OmniGrammar
+from .decoder import PVLDecoder, OmniDecoder
+from .lexer import lexer as Lexer
+from .exceptions import LexerError, ParseError, linecount
+
+
+class EmptyValueAtLine(str):
+    """Empty string to be used as a placeholder for a parameter without
+    a value.
+
+    When a label contains a parameter without a value, it is normally
+    considered a broken label in PVL. To allow parsing to continue,
+    we can rectify the broken parameter-value pair by setting the
+    value to have a value of EmptyValueAtLine, which is an empty
+    string (and can be treated as such) with some additional properties.
+
+    The argument *lineno* should be the line number of the error from
+    the original document, which will be available as a property.
+
+    Examples::
+      >>> from pvl.parser import EmptyValueAtLine
+      >>> EV1 = EmptyValueAtLine(1)
+      >>> EV1
+      EmptyValueAtLine(1 does not have a value. Treat as an empty string)
+      >>> EV1.lineno
+      1
+      >>> print(EV1)
+      <BLANKLINE>
+
+      >>> EV1 + 'foo'
+      'foo'
+      >>> # Can be turned into an integer and float as 0:
+      >>> int(EV1)
+      0
+      >>> float(EV1)
+      0.0
+    """
+
+    def __new__(cls, lineno, *args, **kwargs):
+        self = super(EmptyValueAtLine, cls).__new__(cls, "")
+        self.lineno = lineno
+        return self
+
+    def __int__(self):
+        return 0
+
+    def __float__(self):
+        return 0.0
+
+    def __repr__(self):
+        return (
+            "{}({} does not ".format(type(self).__name__, self.lineno)
+            + "have a value. Treat as an empty string)"
+        )
+
+
+class PVLParser(object):
+    """A parser based on the rules in the CCSDS-641.0-B-2 'Blue Book'
+    which defines the PVL language.
+
+    :param grammar: A pvl.grammar object, if None or not specified, it will
+                    be set to the grammar parameter of *decoder* (if
+                    *decoder* is not None) or will default to
+                    :class:`pvl.grammar.OmniGrammar()`.
+    :param decoder: defaults to :class:`pvl.decoder.OmniDecoder()`.
+    :param lexer_fn: must be a lexer function that takes a ``str``,
+        a grammar, and a decoder, as :func:`pvl.lexer.lexer()` does,
+        which is the default if none is given.
+    :param module_class: must be a subclass of PVLModule, and is the type
+        of object that will be returned from this parser's :func:`parse()`
+        function.
+    :param group_class: must be a subclass of PVLGroup, and is the type
+        that will be used to hold PVL elements when a PVL Group is
+        encountered during parsing, and must be able to be added to
+        via an ``.append()`` function which should take a two-tuple
+        of name and value.
+    :param object_class: must be a subclass of PVLObject, and is the type
+        that will be used to hold PVL elements when a PVL Object is
+        encountered during parsing, otherwise similar to *group_class*.
+    """
+
+    def __init__(
+        self,
+        grammar=None,
+        decoder=None,
+        lexer_fn=None,
+        module_class=PVLModule,
+        group_class=PVLGroup,
+        object_class=PVLObject,
+    ):
+
+        self.errors = []
+        self.doc = ""
+
+        if lexer_fn is None:
+            self.lexer = Lexer
+        else:
+            self.lexer = lexer_fn
+
+        if grammar is None:
+            if decoder is not None:
+                self.grammar = decoder.grammar
+            else:
+                self.grammar = OmniGrammar()
+        elif isinstance(grammar, PVLGrammar):
+            self.grammar = grammar
+        else:
+            raise TypeError("The grammar must be an instance of pvl.grammar.")
+
+        if decoder is None:
+            self.decoder = OmniDecoder(grammar=self.grammar)
+        elif isinstance(decoder, PVLDecoder):
+            self.decoder = decoder
+        else:
+            raise TypeError(
+                "The decode must be an instance of pvl.PVLDecoder."
+            )
+
+        if issubclass(module_class, MutableMappingSequence):
+            self.modcls = module_class
+        else:
+            raise TypeError(
+                "The module_class must be a "
+                "pvl.collections.MutableMappingSequence."
+            )
+
+        if issubclass(group_class, MutableMappingSequence):
+            self.grpcls = group_class
+        else:
+            raise TypeError(
+                "The group_class must be a "
+                "pvl.collections.MutableMappingSequence."
+            )
+
+        if issubclass(object_class, MutableMappingSequence):
+            self.objcls = object_class
+        else:
+            raise TypeError(
+                "The object_class must be a "
+                "pvl.collections.MutableMappingSequence."
+            )
+
+    def parse(self, s: str):
+        """Converts the string, *s* to a PVLModule."""
+        self.doc = s
+        tokens = self.lexer(s, g=self.grammar, d=self.decoder)
+        module = self.parse_module(tokens)
+        module.errors = sorted(self.errors)
+        return module
+
+    def aggregation_cls(self, begin: str):
+        """Returns an initiated object of the group_class or object_class
+        as specified on this parser's creation, according to the value
+        of *begin*.  If *begin* does not match the Group or Object
+        keywords for this parser's grammar, then it will raise a
+        ValueError.
+        """
+        begin_fold = begin.casefold()
+        for gk in self.grammar.group_keywords.keys():
+            if begin_fold == gk.casefold():
+                return self.grpcls()
+
+        for ok in self.grammar.object_keywords.keys():
+            if begin_fold == ok.casefold():
+                return self.objcls()
+
+        raise ValueError(
+            f'The value "{begin}" did not match a Begin '
+            "Aggregation Statement."
+        )
+
+    def parse_module(self, tokens: abc.Generator):
+        """Parses the tokens for a PVL Module.
+
+         <PVL-Module-Contents> ::=
+          ( <Assignment-Statement> | <WSC>* | <Aggregation-Block> )*
+          [<End-Statement>]
+
+        """
+        m = self.modcls()
+
+        parsing = True
+        while parsing:
+            # print(f'top of while parsing: {m}')
+            parsing = False
+            for p in (
+                self.parse_aggregation_block,
+                self.parse_assignment_statement,
+                self.parse_end_statement,
+            ):
+                try:
+                    self.parse_WSC_until(None, tokens)
+                    # t = next(tokens)
+                    # print(f'next token: {t}, {t.pos}')
+                    # tokens.send(t)
+                    parsed = p(tokens)
+                    # print(f'parsed: {parsed}')
+                    if parsed is None:  # because parse_end_statement returned
+                        return m
+                    else:
+                        m.append(*parsed)
+                        parsing = True
+                except LexerError:
+                    raise
+                except ValueError:
+                    pass
+            try:
+                (m, keep_parsing) = self.parse_module_post_hook(m, tokens)
+                if keep_parsing:
+                    parsing = True
+                else:
+                    return m
+            except Exception:
+                pass
+
+        # print(f'got to bottom: {m}')
+        t = next(tokens)
+        tokens.throw(
+            ValueError,
+            "Expecting an Aggregation Block, an Assignment "
+            "Statement, or an End Statement, but found "
+            f'"{t}" ',
+        )
+
+    def parse_module_post_hook(
+        self, module: MutableMappingSequence, tokens: abc.Generator
+    ):
+        """This function is meant to be overridden by subclasses
+        that may want to perform some extra processing if
+        'normal' parse_module() operations fail to complete.
+        See OmniParser for an example.
+
+        This function shall return a two-tuple, with the first item
+        being the *module* (altered by processing or unaltered), and
+        the second item being a boolean that will signal whether
+        the tokens should continue to be parsed to accumulate more
+        elements into the returned *module*, or whether the
+        *module* is in a good state and should be returned by
+        parse_module().
+
+        If the operations within this function are unsuccessful,
+        it should raise an exception (any exception descended from
+        Exception), which will result in the operation of parse_module()
+        as if it were not overridden.
+        """
+        raise Exception
+
+    def parse_aggregation_block(self, tokens: abc.Generator):  # noqa: C901
+        """Parses the tokens for an Aggregation Block, and returns
+        the modcls object that is the result of the parsing and
+        decoding.
+
+         <Aggregation-Block> ::= <Begin-Aggegation-Statement>
+             (<WSC>* (Assignment-Statement | Aggregation-Block) <WSC>*)+
+             <End-Aggregation-Statement>
+
+        The Begin-Aggregation-Statement Name must match the Block-Name
+        in the paired End-Aggregation-Statement if a Block-Name is
+        present in the End-Aggregation-Statement.
+        """
+        (begin, block_name) = self.parse_begin_aggregation_statement(tokens)
+
+        agg = self.aggregation_cls(begin)
+
+        while True:
+            self.parse_WSC_until(None, tokens)
+            try:
+                agg.append(*self.parse_aggregation_block(tokens))
+            except LexerError:
+                raise
+            except ValueError:
+                try:
+                    agg.append(*self.parse_assignment_statement(tokens))
+                    # print(f'agg: {agg}')
+                    # t = next(tokens)
+                    # print(f'next token is: {t}')
+                    # tokens.send(t)
+                except LexerError:
+                    raise
+                except ValueError:
+                    # t = next(tokens)
+                    # print(f'parsing agg block, next token is: {t}')
+                    # tokens.send(t)
+                    try:
+                        self.parse_end_aggregation(begin, block_name, tokens)
+                        break
+                    except LexerError:
+                        raise
+                    except ValueError as ve:
+                        try:
+                            (agg, keep_parsing) = self.parse_module_post_hook(
+                                agg, tokens
+                            )
+                            if not keep_parsing:
+                                raise ve
+                        except Exception:
+                            raise ve
+
+        return block_name, agg
+
+    def parse_around_equals(self, tokens: abc.Generator) -> None:
+        """Parses white space and comments on either side
+        of an equals sign.
+
+        *tokens* is expected to be a *generator iterator* which
+        provides ``pvl.token`` objects.
+
+        This is shared functionality for Begin Aggregation Statements
+        and Assignment Statements.  It basically covers parsing
+        anything that has a syntax diagram like this:
+
+          <WSC>* '=' <WSC>*
+
+        """
+        if not self.parse_WSC_until("=", tokens):
+            try:
+                t = next(tokens)
+                tokens.send(t)
+                raise ValueError(f'Expecting "=", got: {t}')
+            except StopIteration:
+                raise ParseError('Expecting "=", but ran out of tokens.')
+
+        self.parse_WSC_until(None, tokens)
+        return
+
+    def parse_begin_aggregation_statement(
+        self, tokens: abc.Generator
+    ) -> tuple:
+        """Parses the tokens for a Begin Aggregation Statement, and returns
+        the name Block Name as a ``str``.
+
+        <Begin-Aggregation-Statement-block> ::=
+             <Begin-Aggegation-Statement> <WSC>* '=' <WSC>*
+             <Block-Name> [<Statement-Delimiter>]
+
+        Where <Block-Name> ::= <Parameter-Name>
+
+        """
+        try:
+            begin = next(tokens)
+            if not begin.is_begin_aggregation():
+                tokens.send(begin)
+                raise ValueError(
+                    "Expecting a Begin-Aggegation-Statement, but "
+                    f"found: {begin}"
+                )
+        except StopIteration:
+            raise ValueError(
+                "Ran out of tokens before starting to parse "
+                "a Begin-Aggegation-Statement."
+            )
+
+        try:
+            self.parse_around_equals(tokens)
+        except ValueError:
+            tokens.throw(
+                ValueError, f'Expecting an equals sign after "{begin}" '
+            )
+
+        block_name = next(tokens)
+        if not block_name.is_parameter_name():
+            tokens.throw(
+                ValueError,
+                f'Expecting a Block-Name after "{begin} =" '
+                f'but found: "{block_name}"',
+            )
+
+        self.parse_statement_delimiter(tokens)
+
+        return begin, str(block_name)
+
+    def parse_end_aggregation(
+        self, begin_agg: str, block_name: str, tokens: abc.Generator
+    ) -> None:
+        """Parses the tokens for an End Aggregation Statement.
+
+        <End-Aggregation-Statement-block> ::=
+             <End-Aggegation-Statement> [<WSC>* '=' <WSC>*
+             <Block-Name>] [<Statement-Delimiter>]
+
+        Where <Block-Name> ::= <Parameter-Name>
+
+        """
+        end_agg = next(tokens)
+
+        # Need to do a little song and dance to case-independently
+        # match the keys:
+        for k in self.grammar.aggregation_keywords.keys():
+            if k.casefold() == begin_agg.casefold():
+                truecase_begin = k
+                break
+        if (
+            end_agg.casefold()
+            != self.grammar.aggregation_keywords[truecase_begin].casefold()
+        ):
+            tokens.send(end_agg)
+            raise ValueError(
+                "Expecting an End-Aggegation-Statement that "
+                "matched the Begin-Aggregation_Statement, "
+                f'"{begin_agg}" but found: {end_agg}'
+            )
+
+        try:
+            self.parse_around_equals(tokens)
+        except (ParseError, ValueError):  # No equals statement, which is fine.
+            self.parse_statement_delimiter(tokens)
+            return None
+
+        t = next(tokens)
+        if t != block_name:
+            tokens.send(t)
+            tokens.throw(
+                ValueError,
+                f'Expecting a Block-Name after "{end_agg} =" '
+                f'that matches "{block_name}", but found: '
+                f'"{t}"',
+            )
+
+        self.parse_statement_delimiter(tokens)
+
+        return None
+
+    def parse_end_statement(self, tokens: abc.Generator) -> None:
+        """Parses the tokens for an End Statement.
+
+        <End-Statement> ::= "END" ( <WSC>* | [<Statement-Delimiter>] )
+
+        """
+        try:
+            end = next(tokens)
+            if not end.is_end_statement():
+                tokens.send(end)
+                raise ValueError(
+                    "Expecting an End Statement, like "
+                    f'"{self.grammar.end_statements}" but found '
+                    f'"{end}"'
+                )
+
+            # The following commented code was originally put in place to deal
+            # with the possible future situation of being able to process
+            # the possible comment after an end-statement.
+            # In practice, an edge case was discovered (Issue 104) where "data"
+            # after an END statement *all* properly converted to UTF with no
+            # whitespace characters. So this request for the next token
+            # resulted in lexing more than 100 million "valid characters"
+            # and did not return in a prompt manner.  If we ever enable
+            # processing of comments, we'll have to figure out how to handle
+            # this case.  An alternate to removing this code is to leave it
+            # but put in a limit on the size that a lexeme can grow to,
+            # but that implies an additional if-statement for each character.
+            # This is the better solution for now.
+            # try:
+            #     t = next(tokens)
+            #     if t.is_WSC():
+            #         # maybe process comment
+            #         return
+            #     else:
+            #         tokens.send(t)
+            #         return
+            # except LexerError:
+            #     pass
+        except StopIteration:
+            pass
+
+        return
+
+    def parse_assignment_statement(self, tokens: abc.Generator) -> tuple:
+        """Parses the tokens for an Assignment Statement.
+
+        The returned two-tuple contains the Parameter Name in the
+        first element, and the Value in the second.
+
+         <Assignment-Statement> ::= <Parameter-Name> <WSC>* '=' <WSC>*
+                                     <Value> [<Statement-Delimiter>]
+
+        """
+        try:
+            t = next(tokens)
+            if t.is_parameter_name():
+                parameter_name = str(t)
+            else:
+                tokens.send(t)
+                raise ValueError(
+                    "Expecting a Parameter Name, but " f'found: "{t}"'
+                )
+        except StopIteration:
+            raise ValueError(
+                "Ran out of tokens before starting to parse "
+                "an Assignment-Statement."
+            )
+
+        self.parse_around_equals(tokens)
+
+        try:
+            # print(f'parameter name: {parameter_name}')
+            value = self.parse_value(tokens)
+        except StopIteration:
+            raise ParseError(
+                "Ran out of tokens to parse after the equals "
+                "sign in an Assignment-Statement: "
+                f'"{parameter_name} =".',
+                t,
+            )
+
+        self.parse_statement_delimiter(tokens)
+
+        return parameter_name, value
+
+    @staticmethod
+    def parse_WSC_until(token: str, tokens: abc.Generator) -> bool:
+        """Consumes objects from *tokens*, if the object's *.is_WSC()*
+        function returns *True*, it will continue until *token* is
+        encountered and will return *True*.  If it encounters an object
+        that does not meet these conditions, it will 'return' that
+        object to *tokens* and will return *False*.
+
+        *tokens* is expected to be a *generator iterator* which
+        provides ``pvl.token`` objects.
+        """
+        for t in tokens:
+            if t == token:
+                return True
+            elif t.is_WSC():
+                # If there's a comment, could parse here.
+                pass
+            else:
+                tokens.send(t)
+                return False
+
+    def _parse_set_seq(self, delimiters, tokens: abc.Generator) -> list:
+        """The internal parsing of PVL Sets and Sequences are very
+        similar, and this function provides that shared logic.
+
+        *delimiters* are a two-tuple containing the start and end
+        characters for the PVL Set or Sequence.
+        """
+        t = next(tokens)
+        if t != delimiters[0]:
+            tokens.send(t)
+            raise ValueError(
+                f'Expecting a begin delimiter "{delimiters[0]}" '
+                f'but found: "{t}"'
+            )
+        set_seq = list()
+        # Initial WSC and/or empty
+        if self.parse_WSC_until(delimiters[1], tokens):
+            return set_seq
+
+        # First item:
+        set_seq.append(self.parse_value(tokens))
+        if self.parse_WSC_until(delimiters[1], tokens):
+            return set_seq
+
+        # Remaining items, if any
+        for t in tokens:
+            # print(f'in loop, t: {t}, set_seq: {set_seq}')
+            if t == ",":
+                self.parse_WSC_until(None, tokens)  # consume WSC after ','
+                set_seq.append(self.parse_value(tokens))
+                if self.parse_WSC_until(delimiters[1], tokens):
+                    return set_seq
+            else:
+                tokens.send(t)
+                tokens.throw(
+                    ValueError,
+                    "While parsing, expected a comma (,)" f'but found: "{t}"',
+                )
+
+    def parse_set(self, tokens: abc.Generator) -> frozenset:
+        """Parses a PVL Set.
+
+         <Set> ::= "{" <WSC>*
+                   [ <Value> <WSC>* ( "," <WSC>* <Value> <WSC>* )* ]
+                   "}"
+
+        Returns the decoded <Set> as a Python ``frozenset``.  The PVL
+        specification doesn't seem to indicate that a PVL Set
+        has distinct values (like a Python ``set``), only that the
+        ordering of the values is unimportant.  For now, we will
+        implement PVL Sets as Python ``frozenset`` objects.
+
+        They are returned as ``frozenset`` objects because PVL Sets
+        can contain as their elements other PVL Sets, but since Python
+        ``set`` objects are non-hashable, they cannot be members of a set,
+        however, ``frozenset`` objects can.
+        """
+        return frozenset(
+            self._parse_set_seq(self.grammar.set_delimiters, tokens)
+        )
+
+    def parse_sequence(self, tokens: abc.Generator) -> list:
+        """Parses a PVL Sequence.
+
+         <Set> ::= "(" <WSC>*
+                   [ <Value> <WSC>* ( "," <WSC>* <Value> <WSC>* )* ]
+                   ")"
+
+        Returns the decoded <Sequence> as a Python ``list``.
+        """
+        return self._parse_set_seq(self.grammar.sequence_delimiters, tokens)
+
+    @staticmethod
+    def parse_statement_delimiter(tokens: abc.Generator) -> bool:
+        """Parses the tokens for a Statement Delimiter.
+
+        *tokens* is expected to be a *generator iterator* which
+        provides ``pvl.token`` objects.
+
+         <Statement-Delimiter> ::= <WSC>*
+                     (<white-space-character> | <comment> | ';' | <EOF>)
+
+        Although the above structure comes from Figure 2-4
+        of the Blue Book, the <white-space-character> and <comment>
+        elements are redundant with the presence of [WSC]*
+        so it can be simplified to:
+
+         <Statement-Delimiter> ::= <WSC>* [ ';' | <EOF> ]
+
+        Typically written [<Statement-Delimiter>].
+        """
+        for t in tokens:
+            if t.is_WSC():
+                # If there's a comment, could parse here.
+                pass
+            elif t.is_delimiter():
+                return True
+            else:
+                tokens.send(t)  # Put the next token back into the generator
+                return False
+
+    def parse_value(self, tokens: abc.Generator):
+        """Parses PVL Values.
+
+         <Value> ::= (<Simple-Value> | <Set> | <Sequence>)
+                     [<WSC>* <Units Expression>]
+
+        Returns the decoded <Value> as an appropriate Python object.
+        """
+        value = None
+
+        try:
+            t = next(tokens)
+            value = self.decoder.decode_simple_value(t)
+        except ValueError:
+            tokens.send(t)
+            for p in (
+                self.parse_set,
+                self.parse_sequence,
+                self.parse_value_post_hook,
+            ):
+                try:
+                    value = p(tokens)
+                    break
+                except LexerError:
+                    # A LexerError is a subclass of ValueError, but
+                    # if we get a LexerError, that's a problem and
+                    # we need to raise it, and not let it pass.
+                    raise
+                except ValueError:
+                    # Getting a ValueError is a normal consequence of
+                    # one of the parsing strategies not working,
+                    # this pass allows us to go to the next one.
+                    pass
+            else:
+                tokens.throw(
+                    ValueError,
+                    "Was expecting a Simple Value, or the "
+                    "beginning of a Set or Sequence, but "
+                    f'found: "{t}"',
+                )
+
+        # print(f'in parse_value, value is: {value}')
+        self.parse_WSC_until(None, tokens)
+        try:
+            return self.parse_units(value, tokens)
+        except (ValueError, StopIteration):
+            return value
+
+    def parse_value_post_hook(self, tokens):
+        """This function is meant to be overridden by subclasses
+        that may want to perform some extra processing if
+        'normal' parse_value() operations fail to yield a value.
+        See OmniParser for an example.
+
+        This function shall return an appropriate Python value,
+        similar to what parse_value() would return.
+
+        If the operations within this function are unsuccessful,
+        it should raise a ValueError which will result in the
+        operation of parse_value() as if it were not overridden.
+        """
+        raise ValueError
+
+    def parse_units(self, value, tokens: abc.Generator) -> str:
+        """Parses PVL Units Expression.
+
+         <Units-Expression> ::= "<" [<white-space>] <Units-Value>
+                                    [<white-space>] ">"
+
+        and
+
+         <Units-Value> ::= <units-character>
+                             [ [ <units-character> | <white-space> ]*
+                                 <units-character> ]
+
+        Returns the *value* and the <Units-Value> as a ``Units()``
+        object.
+        """
+        t = next(tokens)
+
+        if not t.startswith(self.grammar.units_delimiters[0]):
+            tokens.send(t)
+            raise ValueError(
+                "Was expecting the start units delimiter, "
+                + '"{}" '.format(self.grammar.units_delimiters[0])
+                + f'but found "{t}"'
+            )
+
+        if not t.endswith(self.grammar.units_delimiters[1]):
+            tokens.send(t)
+            raise ValueError(
+                "Was expecting the end units delimiter, "
+                + '"{}" '.format(self.grammar.units_delimiters[1])
+                + f'at the end, but found "{t}"'
+            )
+
+        delim_strip = t.strip("".join(self.grammar.units_delimiters))
+
+        units_value = delim_strip.strip("".join(self.grammar.whitespace))
+
+        for d in self.grammar.units_delimiters:
+            if d in units_value:
+                tokens.throw(
+                    ValueError,
+                    "Was expecting a units character, but found a "
+                    f'unit delimiter, "{d}" instead.',
+                )
+
+        return self.decoder.decode_quantity(value, units_value)
+
+
+class ODLParser(PVLParser):
+    """A parser based on the rules in the PDS3 Standards Reference
+       (version 3.8, 27 Feb 2009) Chapter 12: Object Description
+       Language Specification and Usage.
+
+       It extends PVLParser.
+    """
+
+    def parse_set(self, tokens: abc.Generator) -> set:
+        """Overrides the parent function to return
+        the decoded <Set> as a Python ``set``.
+
+        The ODL specification only allows scalar_values in Sets,
+        since ODL Sets cannot contain other ODL Sets, an ODL Set
+        can be represented as a Python ``set`` (unlike PVL Sets,
+        which must be represented as a Python ``frozenset`` objects).
+        """
+        return set(self._parse_set_seq(self.grammar.set_delimiters, tokens))
+
+    def parse_units(self, value, tokens: abc.Generator) -> str:
+        """Extends the parent function, since ODL only allows units
+        on numeric values, any others will result in a ValueError.
+        """
+
+        if isinstance(value, int) or isinstance(value, float):
+            return super().parse_units(value, tokens)
+
+        else:
+            raise ValueError(
+                "ODL Units Expressions can only follow " "numeric values."
+            )
+
+
+class OmniParser(PVLParser):
+    """A permissive PVL/ODL/ISIS label parser that attempts to parse
+    all forms of "PVL" that are thrown at it.
+    """
+
+    def _empty_value(self, pos):
+        eq_pos = self.doc.rfind("=", 0, pos)
+        lc = linecount(self.doc, eq_pos)
+        self.errors.append(lc)
+        return EmptyValueAtLine(lc)
+
+    def parse(self, s: str):
+        """Extends the parent function.
+
+        If *any* line ends with a dash (-) followed by a carriage
+        return, form-feed, or newline, plus one or more whitespace
+        characters on the following line, then those characters, and
+        all whitespace characters that begin the next line will
+        be removed.
+        """
+        nodash = re.sub(r"-[\n\r\f]\s*", "", s)
+        self.doc = nodash
+
+        return super().parse(nodash)
+
+    def parse_module_post_hook(
+        self, module: MutableMappingSequence, tokens: abc.Generator
+    ):
+        """Overrides the parent function to allow for more
+        permissive parsing.  If an Assignment-Statement
+        is blank, then the value will be assigned an
+        EmptyValueAtLine object.
+        """
+        # It enables this by checking to see if the next thing is an
+        # '=' which means there was an empty assignment at the previous
+        # equals sign, and then unwinding the stack to give the
+        # previous assignment the EmptyValueAtLine() object and trying
+        # to continue parsing.
+
+        # print('in hook')
+        try:
+            t = next(tokens)
+            if t == "=" and len(module) != 0:
+                (last_k, last_v) = module[-1]
+                last_token = Token(
+                    last_v, grammar=self.grammar, decoder=self.decoder
+                )
+                if last_token.is_parameter_name():
+                    # Fix the previous entry
+                    module.pop()
+                    module.append(last_k, self._empty_value(t.pos))
+                    # Now use last_token as the parameter name
+                    # for the next assignment, and we must
+                    # reproduce the last part of parse-assignment:
+                    try:
+                        # print(f'parameter name: {last_token}')
+                        self.parse_WSC_until(None, tokens)
+                        value = self.parse_value(tokens)
+                        self.parse_statement_delimiter(tokens)
+                        module.append(str(last_token), value)
+                    except StopIteration:
+                        module.append(
+                            str(last_token), self._empty_value(t.pos + 1)
+                        )
+                        return module, False  # return through parse_module()
+                else:
+                    tokens.send(t)
+            else:
+                # The next token isn't an equals sign or the module is
+                # empty, so we want return the token and signal
+                # parse_module() that it should ignore us.
+                tokens.send(t)
+                raise Exception
+
+            # Peeking at the next token gives us the opportunity to
+            # see if we're at the end of tokens, which we want to handle.
+            t = next(tokens)
+            tokens.send(t)
+            return module, True  # keep parsing
+        except StopIteration:
+            # If we're out of tokens, that's okay.
+            return module, False  # return through parse_module()
+
+    def parse_assignment_statement(self, tokens: abc.Generator) -> tuple:
+        """Extends the parent function to allow for more
+        permissive parsing.  If an Assignment-Statement
+        is blank, then the value will be assigned an
+        EmptyValueAtLine object.
+        """
+        try:
+            return super().parse_assignment_statement(tokens)
+        except ParseError as err:
+            if err.token is not None:
+                after_eq = self.doc.find("=", err.token.pos) + 1
+                return str(err.token), self._empty_value(after_eq)
+            else:
+                raise
+
+    def parse_value_post_hook(self, tokens: abc.Generator):
+        """Overrides the parent function to allow for more
+        permissive parsing.
+
+        If the next token is a reserved word or delimiter,
+        then it is returned to the *tokens* and an
+        EmptyValueAtLine object is returned as the value.
+        """
+
+        t = next(tokens)
+        # print(f't: {t}')
+        truecase_reserved = [
+            x.casefold() for x in self.grammar.reserved_keywords
+        ]
+        trucase_delim = [x.casefold() for x in self.grammar.delimiters]
+        if t.casefold() in (truecase_reserved + trucase_delim):
+            # print(f'kw: {kw}')
+            # if kw.casefold() == t.casefold():
+            # print('match')
+            tokens.send(t)
+            return self._empty_value(t.pos)
+        else:
+            raise ValueError
diff --git a/hirise_blender/pvl/pvl_translate.py b/hirise_blender/pvl/pvl_translate.py
new file mode 100644
index 0000000..9a786ed
--- /dev/null
+++ b/hirise_blender/pvl/pvl_translate.py
@@ -0,0 +1,89 @@
+# -*- coding: utf-8 -*-
+"""A program for converting PVL text to a specific PVL dialect.
+
+The ``pvl_translate`` program will read a file with PVL text (any
+of the kinds of files that :func:`pvl.load` reads) or STDIN and
+will convert that PVL text to a particular PVL dialect.  It is not
+particularly robust, and if it cannot make simple conversions, it
+will raise errors.
+"""
+
+# Copyright 2020-2021, ``pvl`` library authors.
+#
+# Reuse is permitted under the terms of the license.
+# The AUTHORS file and the LICENSE file are at the
+# top level of this library.
+
+import argparse
+import json
+import os
+import sys
+
+import pvl
+from .encoder import PVLEncoder, ODLEncoder, ISISEncoder, PDSLabelEncoder
+
+
+class Writer(object):
+    """Base class for writers.  Descendents must implement dump().
+    """
+
+    def dump(self, dictlike: dict, outfile: os.PathLike):
+        raise Exception
+
+
+class PVLWriter(Writer):
+    def __init__(self, encoder):
+        self.encoder = encoder
+
+    def dump(self, dictlike: dict, outfile: os.PathLike):
+        return pvl.dump(dictlike, outfile, encoder=self.encoder)
+
+
+class JSONWriter(Writer):
+    def dump(self, dictlike: dict, outfile: os.PathLike):
+        return json.dump(dictlike, outfile)
+
+
+formats = dict(
+    PDS3=PVLWriter(PDSLabelEncoder()),
+    ODL=PVLWriter(ODLEncoder()),
+    ISIS=PVLWriter(ISISEncoder()),
+    PVL=PVLWriter(PVLEncoder()),
+    JSON=JSONWriter(),
+)
+
+
+def arg_parser(formats):
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument(
+        "-of",
+        "--output_format",
+        required=True,
+        choices=formats.keys(),
+        help="Select the format to create the new file as.",
+    )
+    parser.add_argument(
+        "infile",
+        nargs="?",
+        type=argparse.FileType("r"),
+        default=sys.stdin,
+        help="file containing PVL text to translate, " "defaults to STDIN.",
+    )
+    parser.add_argument(
+        "outfile",
+        nargs="?",
+        type=argparse.FileType("w"),
+        default=sys.stdout,
+        help="file to write translated PVL to, defaults " "to STDOUT.",
+    )
+    parser.add_argument("--version", action="version", version=pvl.__version__)
+    return parser
+
+
+def main(argv=None):
+    args = arg_parser(formats).parse_args(argv)
+
+    some_pvl = pvl.load(args.infile)
+
+    formats[args.output_format].dump(some_pvl, args.outfile)
+    return
diff --git a/hirise_blender/pvl/pvl_validate.py b/hirise_blender/pvl/pvl_validate.py
new file mode 100644
index 0000000..96b9cbb
--- /dev/null
+++ b/hirise_blender/pvl/pvl_validate.py
@@ -0,0 +1,253 @@
+# -*- coding: utf-8 -*-
+"""A program for testing and validating PVL text.
+
+The ``pvl_validate`` program will read a file with PVL text (any of
+the kinds of files that :func:`pvl.load` reads) and will report
+on which of the various PVL dialects were able to load that PVL
+text, and then also reports on whether the ``pvl`` library can encode
+the Python Objects back out to PVL text.
+
+You can imagine some PVL text that could be loaded, but is not able
+to be written out in a particular strict PVL dialect (like PDS3
+labels).
+"""
+
+# Copyright 2020-2021, ``pvl`` library authors.
+#
+# Reuse is permitted under the terms of the license.
+# The AUTHORS file and the LICENSE file are at the
+# top level of this library.
+
+import argparse
+import logging
+from collections import OrderedDict
+
+import pvl
+from .lexer import LexerError
+from .grammar import (
+    PVLGrammar,
+    ODLGrammar,
+    PDSGrammar,
+    ISISGrammar,
+    OmniGrammar,
+)
+from .parser import ParseError, PVLParser, ODLParser, OmniParser
+from .decoder import PVLDecoder, ODLDecoder, PDSLabelDecoder, OmniDecoder
+from .encoder import PVLEncoder, ODLEncoder, ISISEncoder, PDSLabelEncoder
+
+# Some assembly required for the dialects.
+# We are going to be explicit here, because these arguments are
+# are different than the defaults for these classes, especially for the
+# parsers and decoders, as we want to be strict and not permissive here.
+_pvl_g = PVLGrammar()
+_pvl_d = PVLDecoder(grammar=_pvl_g)
+_odl_g = ODLGrammar()
+_odl_d = ODLDecoder(grammar=_odl_g)
+_pds_g = PDSGrammar()
+_pds_d = PDSLabelDecoder(grammar=_pds_g)
+_isis_g = ISISGrammar()
+_isis_d = OmniDecoder(grammar=_isis_g)
+_omni_g = OmniGrammar()
+_omni_d = OmniDecoder(grammar=_omni_g)
+
+dialects = OrderedDict(
+    PDS3=dict(
+        parser=ODLParser(grammar=_pds_g, decoder=_pds_d),
+        grammar=_pds_g,
+        decoder=_pds_d,
+        encoder=PDSLabelEncoder(grammar=_pds_g, decoder=_pds_d),
+    ),
+    ODL=dict(
+        parser=ODLParser(grammar=_odl_g, decoder=_odl_d),
+        grammar=_odl_g,
+        decoder=_odl_d,
+        encoder=ODLEncoder(grammar=_odl_g, decoder=_odl_d),
+    ),
+    PVL=dict(
+        parser=PVLParser(grammar=_pvl_g, decoder=_pvl_d),
+        grammar=_pvl_g,
+        decoder=_pvl_d,
+        encoder=PVLEncoder(grammar=_pvl_g, decoder=_pvl_d),
+    ),
+    ISIS=dict(
+        parser=OmniParser(grammar=_isis_g, decoder=_isis_d),
+        grammar=_isis_g,
+        decoder=_isis_d,
+        encoder=ISISEncoder(grammar=_isis_g, decoder=_isis_d),
+    ),
+    Omni=dict(
+        parser=OmniParser(grammar=_omni_g, decoder=_omni_d),
+        grammar=_omni_g,
+        decoder=_omni_d,
+        encoder=PVLEncoder(grammar=_omni_g, decoder=_omni_d),
+    ),
+)
+
+
+def arg_parser():
+    p = argparse.ArgumentParser(description=__doc__)
+    p.add_argument(
+        "-v",
+        "--verbose",
+        action="count",
+        default=0,
+        help="Will report the errors that are encountered.  A second v will "
+        "include tracebacks for non-pvl exceptions. ",
+    )
+    p.add_argument("--version", action="version", version=pvl.__version__)
+    p.add_argument(
+        "file", nargs="+", help="file containing PVL text to validate."
+    )
+    return p
+
+
+def main(argv=None):
+    args = arg_parser().parse_args(argv)
+
+    logging.basicConfig(
+        format="%(levelname)s: %(message)s", level=(60 - 20 * args.verbose)
+    )
+
+    results_list = list()
+    for f in args.file:
+        pvl_text = pvl.get_text_from(f)
+
+        results = dict()
+
+        for k, v in dialects.items():
+            results[k] = pvl_flavor(pvl_text, k, v, f, args.verbose)
+
+        results_list.append((f, results))
+
+    # Writing the flavors out again to preserve order.
+    if args.verbose > 0:
+        print(f"pvl library version: {pvl.__version__}")
+    print(report(results_list, list(dialects.keys())))
+    return
+
+
+def pvl_flavor(
+    text, dialect, decenc: dict, filename, verbose=False
+) -> tuple((bool, bool)):
+    """Returns a two-tuple of booleans which indicate
+    whether the *text* could be loaded and then encoded.
+
+    The first boolean in the two-tuple indicates whether the *text*
+    could be loaded with the given parser, grammar, and decoder.
+    The second indicates whether the loaded PVL object could be
+    encoded with the given encoder, grammar, and decoder.  If the
+    first element is False, the second will be None.
+    """
+    loads = None
+    encodes = None
+    try:
+        some_pvl = pvl.loads(text, **decenc)
+        loads = True
+
+        try:
+            pvl.dumps(some_pvl, **decenc)
+            encodes = True
+        except (LexerError, ParseError, ValueError) as err:
+            logging.error(f"{dialect} encode error {filename} {err}")
+            encodes = False
+    except (LexerError, ParseError) as err:
+        logging.error(f"{dialect} load error {filename} {err}")
+        loads = False
+    except:  # noqa E722
+        if verbose <= 1:
+            logging.error(
+                f"{dialect} load error {filename}, try -vv for more info."
+            )
+        else:
+            logging.exception(f"{dialect} load error {filename}")
+            logging.error(f"End {dialect} load error {filename}")
+        loads = False
+
+    return loads, encodes
+
+
+def report(reports: list, flavors: list) -> str:
+    """Returns a multi-line string which is the
+    pretty-printed report given the list of
+    *reports*.
+    """
+    if len(reports[0][1]) != len(flavors):
+        raise IndexError(
+            "The length of the report list keys "
+            f"({len(reports[0][1])}) "
+            "and the length of the flavors list "
+            f"({len(flavors)}) aren't the same."
+        )
+
+    if len(reports) > 1:
+        return report_many(reports, flavors)
+
+    r = reports[0][1]
+
+    lines = list()
+    loads = {True: "Loads", False: "does NOT load"}
+    encodes = {True: "Encodes", False: "does NOT encode", None: ""}
+
+    col1w = len(max(flavors, key=len))
+    col2w = len(max(loads.values(), key=len))
+    col3w = len(max(encodes.values(), key=len))
+
+    for k in flavors:
+        lines.append(
+            build_line(
+                [k, loads[r[k][0]], encodes[r[k][1]]], [col1w, col2w, col3w]
+            )
+        )
+    return "\n".join(lines)
+
+
+def report_many(r_list: list, flavors: list) -> str:
+    """Returns a multi-line, table-like string which
+    is the pretty-printed report of the items in *r_list*.
+    """
+
+    lines = list()
+    loads = {True: "L", False: "No L"}
+    encodes = {True: "E", False: "No E", None: ""}
+
+    col1w = len(max([x[0] for x in r_list], key=len))
+    col2w = len(max(loads.values(), key=len))
+    col3w = len(max(encodes.values(), key=len))
+    flavorw = col2w + col3w + 1
+
+    header = ["File"] + flavors
+    headerw = [col1w] + [flavorw] * len(flavors)
+    rule = [" " * col1w] + [" " * flavorw] * len(flavors)
+
+    rule_line = build_line(rule, headerw).replace("|", "+").replace(" ", "-")
+    lines.append(rule_line)
+    lines.append(build_line(header, headerw))
+    lines.append(rule_line)
+
+    for r in r_list:
+        cells = [r[0]]
+        widths = [col1w]
+        for f in flavors:
+            # cells.append(loads[r[1][f][0]] + ' ' + encodes[r[1][f][1]])
+            cells.append(
+                "{0:^{w2}} {1:^{w3}}".format(
+                    loads[r[1][f][0]], encodes[r[1][f][1]], w2=col2w, w3=col3w
+                )
+            )
+            widths.append(flavorw)
+        lines.append(build_line(cells, widths))
+
+    return "\n".join(lines)
+
+
+def build_line(elements: list, widths: list, sep=" | ") -> str:
+    """Returns a string formatted from the *elements* and *widths*
+       provided.
+    """
+    cells = list()
+    cells.append("{0:<{width}}".format(elements[0], width=widths[0]))
+
+    for e, w in zip(elements[1:], widths[1:]):
+        cells.append("{0:^{width}}".format(e, width=w))
+
+    return sep.join(cells)
diff --git a/hirise_blender/pvl/token.py b/hirise_blender/pvl/token.py
new file mode 100644
index 0000000..7478554
--- /dev/null
+++ b/hirise_blender/pvl/token.py
@@ -0,0 +1,335 @@
+# -*- coding: utf-8 -*-
+
+# Copyright 2019-2020, ``pvl`` library authors.
+#
+# Reuse is permitted under the terms of the license.
+# The AUTHORS file and the LICENSE file are at the
+# top level of this library.
+
+
+from .decoder import PVLDecoder
+from .grammar import PVLGrammar
+
+
+class Token(str):
+    """A PVL-aware string.
+
+    :var content: A string that is the Token text.
+
+    :var grammar: A pvl.grammar object, if None or not specified, it will
+                  be set to the grammar parameter of *decoder* (if
+                  *decoder* is not None) or will default to PVLGrammar().
+
+    :var decoder: A pvl.decoder object, defaults to
+                  PVLDecoder(grammar=*grammar*).
+
+    :var pos: Integer that describes the starting position of this
+              Token in the source string, defaults to zero.
+    """
+
+    def __new__(cls, content, grammar=None, decoder=None, pos=0):
+        return str.__new__(cls, content)
+
+    def __init__(self, content, grammar=None, decoder=None, pos=0):
+        if grammar is None:
+            if decoder is not None:
+                self.grammar = decoder.grammar
+            else:
+                self.grammar = PVLGrammar()
+        elif isinstance(grammar, PVLGrammar):
+            self.grammar = grammar
+        else:
+            raise TypeError("The grammar object is not of type PVLGrammar.")
+
+        if decoder is None:
+            self.decoder = PVLDecoder(grammar=self.grammar)
+        elif isinstance(decoder, PVLDecoder):
+            self.decoder = decoder
+        else:
+            raise TypeError("The decoder object is not of type PVLDecoder.")
+
+        self.pos = pos
+
+    def __repr__(self):
+        return f"{self.__class__.__name__}('{self}', " f"'{self.grammar}')"
+
+    def __index__(self):
+        if self.is_decimal():
+            try:
+                return self.decoder.decode_non_decimal(str(self))
+            except ValueError:
+                if int(str(self)) == float(str(self)):
+                    return int(str(self))
+
+        raise ValueError(f"The {self:r} cannot be used as an index.")
+
+    def __float__(self):
+        return float(self.decoder.decode_decimal(str(self)))
+
+    def split(self, sep=None, maxsplit=-1) -> list:
+        """Extends ``str.split()`` that calling split() on a Token
+        returns a list of Tokens.
+        """
+        str_list = super().split(sep, maxsplit)
+        tkn_list = list()
+        for t in str_list:
+            tkn_list.append(
+                Token(t, grammar=self.grammar, decoder=self.decoder)
+            )
+        return tkn_list
+
+    def replace(self, *args):
+        """Extends ``str.replace()`` to return a Token."""
+        return Token(
+            super().replace(*args), grammar=self.grammar, decoder=self.decoder
+        )
+
+    def lstrip(self, chars=None):
+        """Extends ``str.lstrip()`` to strip whitespace according
+        to the definition of whitespace in the Token's grammar
+        instead of the default Python whitespace definition.
+        """
+        return self._strip(super().lstrip, chars)
+
+    def rstrip(self, chars=None):
+        """Extends ``str.rstrip()`` to strip whitespace according
+        to the definition of whitespace in the Token's grammar
+        instead of the default Python whitespace definition.
+        """
+        return self._strip(super().rstrip, chars)
+
+    def strip(self, chars=None):
+        """Extends ``str.strip()`` to strip whitespace according
+        to the definition of whitespace in the Token's grammar
+        instead of the default Python whitespace definition.
+        """
+        return self._strip(super().strip, chars)
+
+    def _strip(self, strip_func, chars=None):
+        # Shared functionality for the various strip functions.
+        if chars is None:
+            chars = "".join(self.grammar.whitespace)
+        return Token(
+            strip_func(chars), grammar=self.grammar, decoder=self.decoder
+        )
+
+    def isspace(self) -> bool:
+        """Overrides ``str.isspace()`` to be the same as Token's
+        is_space() function, so that we don't get inconsisent
+        behavior if someone forgets an underbar.
+        """
+        # So that we don't get inconsisent behavior
+        # if someone forgets an underbar.
+        return self.is_space()
+
+    def is_space(self) -> bool:
+        """Return true if the Token contains whitespace according
+        to the definition of whitespace in the Token's grammar
+        and there is at least one character, false otherwise.
+        """
+        if len(self) == 0:
+            return False
+
+        return all(c in self.grammar.whitespace for c in self)
+
+    def is_WSC(self) -> bool:
+        """Return true if the Token is white space characters or comments
+        according to the Token's grammar, false otherwise.
+        """
+        if self.is_comment():
+            return True
+
+        if self.is_space():
+            return True
+
+        for ws in reversed(self.grammar.whitespace):
+            temp = self.replace(ws, " ")
+
+        return all(t.is_comment() for t in temp.split())
+
+    def is_comment(self) -> bool:
+        """Return true if the Token is a comment according to the
+        Token's grammar (defined as beginning and ending with
+        comment delimieters), false otherwise.
+        """
+        for pair in self.grammar.comments:
+            if self.startswith(pair[0]) and self.endswith(pair[1]):
+                return True
+        return False
+
+    def is_quote(self) -> bool:
+        """Return true if the Token is a quote character
+        according to the Token's grammar, false otherwise.
+        """
+        if self in self.grammar.quotes:
+            return True
+        else:
+            return False
+
+    def is_quoted_string(self) -> bool:
+        """Return true if the Token can be converted to a quoted
+        string by the Token's decoder, false otherwise.
+        """
+        try:
+            self.decoder.decode_quoted_string(self)
+            return True
+        except ValueError:
+            return False
+
+    def is_delimiter(self) -> bool:
+        """Return true if the Token is a delimiter character
+        (e.g. the ';' in PVL) according to the Token's grammar,
+        false otherwise.
+        """
+        if self in self.grammar.delimiters:
+            return True
+        return False
+
+    def is_begin_aggregation(self) -> bool:
+        """Return true if the Token is a begin aggregation
+        keyword (e.g. 'BEGIN_GROUP' in PVL) according to
+        the Token's grammar, false otherwise.
+        """
+        for k in self.grammar.aggregation_keywords.keys():
+            if self.casefold() == k.casefold():
+                return True
+        return False
+
+    def is_unquoted_string(self) -> bool:
+        """Return false if the Token has any
+        reserved characters, comment characters, whitespace
+        characters or could be interpreted as a number,
+        date, or time according to the Token's grammar,
+        true otherwise.
+        """
+        for char in self.grammar.reserved_characters:
+            if char in self:
+                return False
+
+        for pair in self.grammar.comments:
+            if pair[0] in self:
+                return False
+            if pair[1] in self:
+                return False
+
+        if self.is_numeric() or self.is_datetime():
+            return False
+
+        for char in self.grammar.whitespace:
+            if char in self:
+                return False
+
+        return True
+
+    def is_string(self) -> bool:
+        """Return true if either the Token's is_quoted_string()
+        or is_unquoted_string() return true, false otherwise.
+        """
+        if self.is_quoted_string() or self.is_unquoted_string():
+            return True
+        return False
+
+    def is_parameter_name(self) -> bool:
+        """Return true if the Token is an unquoted string that
+        isn't a reserved_keyword according to the Token's
+        grammar, false otherwise.
+        """
+        for word in self.grammar.reserved_keywords:
+            if word.casefold() == self.casefold():
+                return False
+
+        return self.is_unquoted_string()
+
+    def is_end_statement(self) -> bool:
+        """Return true if the Token matches an end statement
+        from its grammar, false otherwise.
+        """
+        for e in self.grammar.end_statements:
+            if e.casefold() == self.casefold():
+                return True
+        return False
+
+    def isnumeric(self) -> bool:
+        """Overrides ``str.isnumeric()`` to be the same as Token's
+        is_numeric() function, so that we don't get inconsisent behavior
+        if someone forgets an underbar.
+        """
+        return self.is_numeric()
+
+    def is_numeric(self) -> bool:
+        """Return true if the Token's is_decimal() or is_non_decimal()
+        functions return true, false otherwise.
+        """
+        if self.is_decimal() or self.is_non_decimal():
+            return True
+
+        return False
+
+    def is_decimal(self) -> bool:
+        """Return true if the Token's decoder can convert the Token
+        to a decimal value, false otherwise.
+        """
+        try:
+            self.decoder.decode_decimal(self)
+            return True
+        except ValueError:
+            return False
+
+    def is_non_decimal(self) -> bool:
+        """Return true if the Token's decoder can convert the Token
+        to a numeric non-decimal value, false otherwise.
+        """
+        try:
+            self.decoder.decode_non_decimal(self)
+            return True
+        except ValueError:
+            return False
+
+    # Took these out, since some grammars allow a much wider
+    # range of radix values.
+    #
+    # def is_binary(self) -> bool:
+    #     if self.grammar.binary_re.fullmatch(self) is None:
+    #         return False
+    #     else:
+    #         return True
+
+    # def is_octal(self) -> bool:
+    #     if self.grammar.octal_re.fullmatch(self) is None:
+    #         return False
+    #     else:
+    #         return True
+
+    # def is_hex(self) -> bool:
+    #     if self.grammar.hex_re.fullmatch(self) is None:
+    #         return False
+    #     else:
+    #         return True
+
+    def is_datetime(self) -> bool:
+        """Return true if the Token's decoder can convert the Token
+        to a datetime, false otherwise.
+
+        Separate is_date() or is_time() functions aren't needed,
+        since PVL parsing doesn't distinguish between them.
+        If a user needs that distinction the decoder's
+        decode_datetime(self) function should return a datetime
+        time, date, or datetime object, as appropriate, and
+        a user can use isinstance() to check.
+        """
+        try:
+            self.decoder.decode_datetime(self)
+            return True
+        except ValueError:
+            return False
+
+    def is_simple_value(self) -> bool:
+        """Return true if the Token's decoder can convert the Token
+        to a 'simple value', however the decoder defines that, false
+        otherwise.
+        """
+        try:
+            self.decoder.decode_simple_value(self)
+            return True
+        except ValueError:
+            return False
diff --git a/hirise_blender/six/__init__.py b/hirise_blender/six/__init__.py
new file mode 100644
index 0000000..9fed1ef
--- /dev/null
+++ b/hirise_blender/six/__init__.py
@@ -0,0 +1,3 @@
+from .six import string_types, integer_types
+
+__all__ = ["string_types", "integer_types"]
\ No newline at end of file
diff --git a/hirise_blender/six/__pycache__/__init__.cpython-310.pyc b/hirise_blender/six/__pycache__/__init__.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..0c2b13e9516ed36aacbf4f5377f21d2ed2c6a6f4
GIT binary patch
literal 251
zcmZ9GO=`n15QQb#ZAyrt2j~U7i7pUIa)5M`RlONfYmf)zA0!##BjrlkmMnUOt~#QN
zhCY}#e8b~0V^ysME8dRnJMYg7_fiadp76qEgpp44vXQ-NloUpp!m6e)<w?{JUy>uW
zN}CWp4Hn`uVMrAX5iR;(^tsO$Y;Sd$ia?jYOIiV(oddWE|CnRhz7M(^d(@^y=jOI0
pZ7J%GJOzXghl4@?AGuWn&_EGjJ1yyH*N<j)_?jOKCEK&us2>6PKh^*M

literal 0
HcmV?d00001

diff --git a/hirise_blender/six/__pycache__/six.cpython-310.pyc b/hirise_blender/six/__pycache__/six.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..87452d057358cf67619b18850568cf3b74dcdb35
GIT binary patch
literal 27584
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

literal 0
HcmV?d00001

diff --git a/hirise_blender/six/six.py b/hirise_blender/six/six.py
new file mode 100644
index 0000000..d4fe984
--- /dev/null
+++ b/hirise_blender/six/six.py
@@ -0,0 +1,998 @@
+# Copyright (c) 2010-2020 Benjamin Peterson
+#
+# 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.
+
+"""Utilities for writing code that runs on Python 2 and 3"""
+
+from __future__ import absolute_import
+
+import functools
+import itertools
+import operator
+import sys
+import types
+
+__author__ = "Benjamin Peterson <benjamin@python.org>"
+__version__ = "1.16.0"
+
+
+# Useful for very coarse version differentiation.
+PY2 = sys.version_info[0] == 2
+PY3 = sys.version_info[0] == 3
+PY34 = sys.version_info[0:2] >= (3, 4)
+
+if PY3:
+    string_types = str,
+    integer_types = int,
+    class_types = type,
+    text_type = str
+    binary_type = bytes
+
+    MAXSIZE = sys.maxsize
+else:
+    string_types = basestring,
+    integer_types = (int, long)
+    class_types = (type, types.ClassType)
+    text_type = unicode
+    binary_type = str
+
+    if sys.platform.startswith("java"):
+        # Jython always uses 32 bits.
+        MAXSIZE = int((1 << 31) - 1)
+    else:
+        # It's possible to have sizeof(long) != sizeof(Py_ssize_t).
+        class X(object):
+
+            def __len__(self):
+                return 1 << 31
+        try:
+            len(X())
+        except OverflowError:
+            # 32-bit
+            MAXSIZE = int((1 << 31) - 1)
+        else:
+            # 64-bit
+            MAXSIZE = int((1 << 63) - 1)
+        del X
+
+if PY34:
+    from importlib.util import spec_from_loader
+else:
+    spec_from_loader = None
+
+
+def _add_doc(func, doc):
+    """Add documentation to a function."""
+    func.__doc__ = doc
+
+
+def _import_module(name):
+    """Import module, returning the module after the last dot."""
+    __import__(name)
+    return sys.modules[name]
+
+
+class _LazyDescr(object):
+
+    def __init__(self, name):
+        self.name = name
+
+    def __get__(self, obj, tp):
+        result = self._resolve()
+        setattr(obj, self.name, result)  # Invokes __set__.
+        try:
+            # This is a bit ugly, but it avoids running this again by
+            # removing this descriptor.
+            delattr(obj.__class__, self.name)
+        except AttributeError:
+            pass
+        return result
+
+
+class MovedModule(_LazyDescr):
+
+    def __init__(self, name, old, new=None):
+        super(MovedModule, self).__init__(name)
+        if PY3:
+            if new is None:
+                new = name
+            self.mod = new
+        else:
+            self.mod = old
+
+    def _resolve(self):
+        return _import_module(self.mod)
+
+    def __getattr__(self, attr):
+        _module = self._resolve()
+        value = getattr(_module, attr)
+        setattr(self, attr, value)
+        return value
+
+
+class _LazyModule(types.ModuleType):
+
+    def __init__(self, name):
+        super(_LazyModule, self).__init__(name)
+        self.__doc__ = self.__class__.__doc__
+
+    def __dir__(self):
+        attrs = ["__doc__", "__name__"]
+        attrs += [attr.name for attr in self._moved_attributes]
+        return attrs
+
+    # Subclasses should override this
+    _moved_attributes = []
+
+
+class MovedAttribute(_LazyDescr):
+
+    def __init__(self, name, old_mod, new_mod, old_attr=None, new_attr=None):
+        super(MovedAttribute, self).__init__(name)
+        if PY3:
+            if new_mod is None:
+                new_mod = name
+            self.mod = new_mod
+            if new_attr is None:
+                if old_attr is None:
+                    new_attr = name
+                else:
+                    new_attr = old_attr
+            self.attr = new_attr
+        else:
+            self.mod = old_mod
+            if old_attr is None:
+                old_attr = name
+            self.attr = old_attr
+
+    def _resolve(self):
+        module = _import_module(self.mod)
+        return getattr(module, self.attr)
+
+
+class _SixMetaPathImporter(object):
+
+    """
+    A meta path importer to import six.moves and its submodules.
+
+    This class implements a PEP302 finder and loader. It should be compatible
+    with Python 2.5 and all existing versions of Python3
+    """
+
+    def __init__(self, six_module_name):
+        self.name = six_module_name
+        self.known_modules = {}
+
+    def _add_module(self, mod, *fullnames):
+        for fullname in fullnames:
+            self.known_modules[self.name + "." + fullname] = mod
+
+    def _get_module(self, fullname):
+        return self.known_modules[self.name + "." + fullname]
+
+    def find_module(self, fullname, path=None):
+        if fullname in self.known_modules:
+            return self
+        return None
+
+    def find_spec(self, fullname, path, target=None):
+        if fullname in self.known_modules:
+            return spec_from_loader(fullname, self)
+        return None
+
+    def __get_module(self, fullname):
+        try:
+            return self.known_modules[fullname]
+        except KeyError:
+            raise ImportError("This loader does not know module " + fullname)
+
+    def load_module(self, fullname):
+        try:
+            # in case of a reload
+            return sys.modules[fullname]
+        except KeyError:
+            pass
+        mod = self.__get_module(fullname)
+        if isinstance(mod, MovedModule):
+            mod = mod._resolve()
+        else:
+            mod.__loader__ = self
+        sys.modules[fullname] = mod
+        return mod
+
+    def is_package(self, fullname):
+        """
+        Return true, if the named module is a package.
+
+        We need this method to get correct spec objects with
+        Python 3.4 (see PEP451)
+        """
+        return hasattr(self.__get_module(fullname), "__path__")
+
+    def get_code(self, fullname):
+        """Return None
+
+        Required, if is_package is implemented"""
+        self.__get_module(fullname)  # eventually raises ImportError
+        return None
+    get_source = get_code  # same as get_code
+
+    def create_module(self, spec):
+        return self.load_module(spec.name)
+
+    def exec_module(self, module):
+        pass
+
+_importer = _SixMetaPathImporter(__name__)
+
+
+class _MovedItems(_LazyModule):
+
+    """Lazy loading of moved objects"""
+    __path__ = []  # mark as package
+
+
+_moved_attributes = [
+    MovedAttribute("cStringIO", "cStringIO", "io", "StringIO"),
+    MovedAttribute("filter", "itertools", "builtins", "ifilter", "filter"),
+    MovedAttribute("filterfalse", "itertools", "itertools", "ifilterfalse", "filterfalse"),
+    MovedAttribute("input", "__builtin__", "builtins", "raw_input", "input"),
+    MovedAttribute("intern", "__builtin__", "sys"),
+    MovedAttribute("map", "itertools", "builtins", "imap", "map"),
+    MovedAttribute("getcwd", "os", "os", "getcwdu", "getcwd"),
+    MovedAttribute("getcwdb", "os", "os", "getcwd", "getcwdb"),
+    MovedAttribute("getoutput", "commands", "subprocess"),
+    MovedAttribute("range", "__builtin__", "builtins", "xrange", "range"),
+    MovedAttribute("reload_module", "__builtin__", "importlib" if PY34 else "imp", "reload"),
+    MovedAttribute("reduce", "__builtin__", "functools"),
+    MovedAttribute("shlex_quote", "pipes", "shlex", "quote"),
+    MovedAttribute("StringIO", "StringIO", "io"),
+    MovedAttribute("UserDict", "UserDict", "collections", "IterableUserDict", "UserDict"),
+    MovedAttribute("UserList", "UserList", "collections"),
+    MovedAttribute("UserString", "UserString", "collections"),
+    MovedAttribute("xrange", "__builtin__", "builtins", "xrange", "range"),
+    MovedAttribute("zip", "itertools", "builtins", "izip", "zip"),
+    MovedAttribute("zip_longest", "itertools", "itertools", "izip_longest", "zip_longest"),
+    MovedModule("builtins", "__builtin__"),
+    MovedModule("configparser", "ConfigParser"),
+    MovedModule("collections_abc", "collections", "collections.abc" if sys.version_info >= (3, 3) else "collections"),
+    MovedModule("copyreg", "copy_reg"),
+    MovedModule("dbm_gnu", "gdbm", "dbm.gnu"),
+    MovedModule("dbm_ndbm", "dbm", "dbm.ndbm"),
+    MovedModule("_dummy_thread", "dummy_thread", "_dummy_thread" if sys.version_info < (3, 9) else "_thread"),
+    MovedModule("http_cookiejar", "cookielib", "http.cookiejar"),
+    MovedModule("http_cookies", "Cookie", "http.cookies"),
+    MovedModule("html_entities", "htmlentitydefs", "html.entities"),
+    MovedModule("html_parser", "HTMLParser", "html.parser"),
+    MovedModule("http_client", "httplib", "http.client"),
+    MovedModule("email_mime_base", "email.MIMEBase", "email.mime.base"),
+    MovedModule("email_mime_image", "email.MIMEImage", "email.mime.image"),
+    MovedModule("email_mime_multipart", "email.MIMEMultipart", "email.mime.multipart"),
+    MovedModule("email_mime_nonmultipart", "email.MIMENonMultipart", "email.mime.nonmultipart"),
+    MovedModule("email_mime_text", "email.MIMEText", "email.mime.text"),
+    MovedModule("BaseHTTPServer", "BaseHTTPServer", "http.server"),
+    MovedModule("CGIHTTPServer", "CGIHTTPServer", "http.server"),
+    MovedModule("SimpleHTTPServer", "SimpleHTTPServer", "http.server"),
+    MovedModule("cPickle", "cPickle", "pickle"),
+    MovedModule("queue", "Queue"),
+    MovedModule("reprlib", "repr"),
+    MovedModule("socketserver", "SocketServer"),
+    MovedModule("_thread", "thread", "_thread"),
+    MovedModule("tkinter", "Tkinter"),
+    MovedModule("tkinter_dialog", "Dialog", "tkinter.dialog"),
+    MovedModule("tkinter_filedialog", "FileDialog", "tkinter.filedialog"),
+    MovedModule("tkinter_scrolledtext", "ScrolledText", "tkinter.scrolledtext"),
+    MovedModule("tkinter_simpledialog", "SimpleDialog", "tkinter.simpledialog"),
+    MovedModule("tkinter_tix", "Tix", "tkinter.tix"),
+    MovedModule("tkinter_ttk", "ttk", "tkinter.ttk"),
+    MovedModule("tkinter_constants", "Tkconstants", "tkinter.constants"),
+    MovedModule("tkinter_dnd", "Tkdnd", "tkinter.dnd"),
+    MovedModule("tkinter_colorchooser", "tkColorChooser",
+                "tkinter.colorchooser"),
+    MovedModule("tkinter_commondialog", "tkCommonDialog",
+                "tkinter.commondialog"),
+    MovedModule("tkinter_tkfiledialog", "tkFileDialog", "tkinter.filedialog"),
+    MovedModule("tkinter_font", "tkFont", "tkinter.font"),
+    MovedModule("tkinter_messagebox", "tkMessageBox", "tkinter.messagebox"),
+    MovedModule("tkinter_tksimpledialog", "tkSimpleDialog",
+                "tkinter.simpledialog"),
+    MovedModule("urllib_parse", __name__ + ".moves.urllib_parse", "urllib.parse"),
+    MovedModule("urllib_error", __name__ + ".moves.urllib_error", "urllib.error"),
+    MovedModule("urllib", __name__ + ".moves.urllib", __name__ + ".moves.urllib"),
+    MovedModule("urllib_robotparser", "robotparser", "urllib.robotparser"),
+    MovedModule("xmlrpc_client", "xmlrpclib", "xmlrpc.client"),
+    MovedModule("xmlrpc_server", "SimpleXMLRPCServer", "xmlrpc.server"),
+]
+# Add windows specific modules.
+if sys.platform == "win32":
+    _moved_attributes += [
+        MovedModule("winreg", "_winreg"),
+    ]
+
+for attr in _moved_attributes:
+    setattr(_MovedItems, attr.name, attr)
+    if isinstance(attr, MovedModule):
+        _importer._add_module(attr, "moves." + attr.name)
+del attr
+
+_MovedItems._moved_attributes = _moved_attributes
+
+moves = _MovedItems(__name__ + ".moves")
+_importer._add_module(moves, "moves")
+
+
+class Module_six_moves_urllib_parse(_LazyModule):
+
+    """Lazy loading of moved objects in six.moves.urllib_parse"""
+
+
+_urllib_parse_moved_attributes = [
+    MovedAttribute("ParseResult", "urlparse", "urllib.parse"),
+    MovedAttribute("SplitResult", "urlparse", "urllib.parse"),
+    MovedAttribute("parse_qs", "urlparse", "urllib.parse"),
+    MovedAttribute("parse_qsl", "urlparse", "urllib.parse"),
+    MovedAttribute("urldefrag", "urlparse", "urllib.parse"),
+    MovedAttribute("urljoin", "urlparse", "urllib.parse"),
+    MovedAttribute("urlparse", "urlparse", "urllib.parse"),
+    MovedAttribute("urlsplit", "urlparse", "urllib.parse"),
+    MovedAttribute("urlunparse", "urlparse", "urllib.parse"),
+    MovedAttribute("urlunsplit", "urlparse", "urllib.parse"),
+    MovedAttribute("quote", "urllib", "urllib.parse"),
+    MovedAttribute("quote_plus", "urllib", "urllib.parse"),
+    MovedAttribute("unquote", "urllib", "urllib.parse"),
+    MovedAttribute("unquote_plus", "urllib", "urllib.parse"),
+    MovedAttribute("unquote_to_bytes", "urllib", "urllib.parse", "unquote", "unquote_to_bytes"),
+    MovedAttribute("urlencode", "urllib", "urllib.parse"),
+    MovedAttribute("splitquery", "urllib", "urllib.parse"),
+    MovedAttribute("splittag", "urllib", "urllib.parse"),
+    MovedAttribute("splituser", "urllib", "urllib.parse"),
+    MovedAttribute("splitvalue", "urllib", "urllib.parse"),
+    MovedAttribute("uses_fragment", "urlparse", "urllib.parse"),
+    MovedAttribute("uses_netloc", "urlparse", "urllib.parse"),
+    MovedAttribute("uses_params", "urlparse", "urllib.parse"),
+    MovedAttribute("uses_query", "urlparse", "urllib.parse"),
+    MovedAttribute("uses_relative", "urlparse", "urllib.parse"),
+]
+for attr in _urllib_parse_moved_attributes:
+    setattr(Module_six_moves_urllib_parse, attr.name, attr)
+del attr
+
+Module_six_moves_urllib_parse._moved_attributes = _urllib_parse_moved_attributes
+
+_importer._add_module(Module_six_moves_urllib_parse(__name__ + ".moves.urllib_parse"),
+                      "moves.urllib_parse", "moves.urllib.parse")
+
+
+class Module_six_moves_urllib_error(_LazyModule):
+
+    """Lazy loading of moved objects in six.moves.urllib_error"""
+
+
+_urllib_error_moved_attributes = [
+    MovedAttribute("URLError", "urllib2", "urllib.error"),
+    MovedAttribute("HTTPError", "urllib2", "urllib.error"),
+    MovedAttribute("ContentTooShortError", "urllib", "urllib.error"),
+]
+for attr in _urllib_error_moved_attributes:
+    setattr(Module_six_moves_urllib_error, attr.name, attr)
+del attr
+
+Module_six_moves_urllib_error._moved_attributes = _urllib_error_moved_attributes
+
+_importer._add_module(Module_six_moves_urllib_error(__name__ + ".moves.urllib.error"),
+                      "moves.urllib_error", "moves.urllib.error")
+
+
+class Module_six_moves_urllib_request(_LazyModule):
+
+    """Lazy loading of moved objects in six.moves.urllib_request"""
+
+
+_urllib_request_moved_attributes = [
+    MovedAttribute("urlopen", "urllib2", "urllib.request"),
+    MovedAttribute("install_opener", "urllib2", "urllib.request"),
+    MovedAttribute("build_opener", "urllib2", "urllib.request"),
+    MovedAttribute("pathname2url", "urllib", "urllib.request"),
+    MovedAttribute("url2pathname", "urllib", "urllib.request"),
+    MovedAttribute("getproxies", "urllib", "urllib.request"),
+    MovedAttribute("Request", "urllib2", "urllib.request"),
+    MovedAttribute("OpenerDirector", "urllib2", "urllib.request"),
+    MovedAttribute("HTTPDefaultErrorHandler", "urllib2", "urllib.request"),
+    MovedAttribute("HTTPRedirectHandler", "urllib2", "urllib.request"),
+    MovedAttribute("HTTPCookieProcessor", "urllib2", "urllib.request"),
+    MovedAttribute("ProxyHandler", "urllib2", "urllib.request"),
+    MovedAttribute("BaseHandler", "urllib2", "urllib.request"),
+    MovedAttribute("HTTPPasswordMgr", "urllib2", "urllib.request"),
+    MovedAttribute("HTTPPasswordMgrWithDefaultRealm", "urllib2", "urllib.request"),
+    MovedAttribute("AbstractBasicAuthHandler", "urllib2", "urllib.request"),
+    MovedAttribute("HTTPBasicAuthHandler", "urllib2", "urllib.request"),
+    MovedAttribute("ProxyBasicAuthHandler", "urllib2", "urllib.request"),
+    MovedAttribute("AbstractDigestAuthHandler", "urllib2", "urllib.request"),
+    MovedAttribute("HTTPDigestAuthHandler", "urllib2", "urllib.request"),
+    MovedAttribute("ProxyDigestAuthHandler", "urllib2", "urllib.request"),
+    MovedAttribute("HTTPHandler", "urllib2", "urllib.request"),
+    MovedAttribute("HTTPSHandler", "urllib2", "urllib.request"),
+    MovedAttribute("FileHandler", "urllib2", "urllib.request"),
+    MovedAttribute("FTPHandler", "urllib2", "urllib.request"),
+    MovedAttribute("CacheFTPHandler", "urllib2", "urllib.request"),
+    MovedAttribute("UnknownHandler", "urllib2", "urllib.request"),
+    MovedAttribute("HTTPErrorProcessor", "urllib2", "urllib.request"),
+    MovedAttribute("urlretrieve", "urllib", "urllib.request"),
+    MovedAttribute("urlcleanup", "urllib", "urllib.request"),
+    MovedAttribute("URLopener", "urllib", "urllib.request"),
+    MovedAttribute("FancyURLopener", "urllib", "urllib.request"),
+    MovedAttribute("proxy_bypass", "urllib", "urllib.request"),
+    MovedAttribute("parse_http_list", "urllib2", "urllib.request"),
+    MovedAttribute("parse_keqv_list", "urllib2", "urllib.request"),
+]
+for attr in _urllib_request_moved_attributes:
+    setattr(Module_six_moves_urllib_request, attr.name, attr)
+del attr
+
+Module_six_moves_urllib_request._moved_attributes = _urllib_request_moved_attributes
+
+_importer._add_module(Module_six_moves_urllib_request(__name__ + ".moves.urllib.request"),
+                      "moves.urllib_request", "moves.urllib.request")
+
+
+class Module_six_moves_urllib_response(_LazyModule):
+
+    """Lazy loading of moved objects in six.moves.urllib_response"""
+
+
+_urllib_response_moved_attributes = [
+    MovedAttribute("addbase", "urllib", "urllib.response"),
+    MovedAttribute("addclosehook", "urllib", "urllib.response"),
+    MovedAttribute("addinfo", "urllib", "urllib.response"),
+    MovedAttribute("addinfourl", "urllib", "urllib.response"),
+]
+for attr in _urllib_response_moved_attributes:
+    setattr(Module_six_moves_urllib_response, attr.name, attr)
+del attr
+
+Module_six_moves_urllib_response._moved_attributes = _urllib_response_moved_attributes
+
+_importer._add_module(Module_six_moves_urllib_response(__name__ + ".moves.urllib.response"),
+                      "moves.urllib_response", "moves.urllib.response")
+
+
+class Module_six_moves_urllib_robotparser(_LazyModule):
+
+    """Lazy loading of moved objects in six.moves.urllib_robotparser"""
+
+
+_urllib_robotparser_moved_attributes = [
+    MovedAttribute("RobotFileParser", "robotparser", "urllib.robotparser"),
+]
+for attr in _urllib_robotparser_moved_attributes:
+    setattr(Module_six_moves_urllib_robotparser, attr.name, attr)
+del attr
+
+Module_six_moves_urllib_robotparser._moved_attributes = _urllib_robotparser_moved_attributes
+
+_importer._add_module(Module_six_moves_urllib_robotparser(__name__ + ".moves.urllib.robotparser"),
+                      "moves.urllib_robotparser", "moves.urllib.robotparser")
+
+
+class Module_six_moves_urllib(types.ModuleType):
+
+    """Create a six.moves.urllib namespace that resembles the Python 3 namespace"""
+    __path__ = []  # mark as package
+    parse = _importer._get_module("moves.urllib_parse")
+    error = _importer._get_module("moves.urllib_error")
+    request = _importer._get_module("moves.urllib_request")
+    response = _importer._get_module("moves.urllib_response")
+    robotparser = _importer._get_module("moves.urllib_robotparser")
+
+    def __dir__(self):
+        return ['parse', 'error', 'request', 'response', 'robotparser']
+
+_importer._add_module(Module_six_moves_urllib(__name__ + ".moves.urllib"),
+                      "moves.urllib")
+
+
+def add_move(move):
+    """Add an item to six.moves."""
+    setattr(_MovedItems, move.name, move)
+
+
+def remove_move(name):
+    """Remove item from six.moves."""
+    try:
+        delattr(_MovedItems, name)
+    except AttributeError:
+        try:
+            del moves.__dict__[name]
+        except KeyError:
+            raise AttributeError("no such move, %r" % (name,))
+
+
+if PY3:
+    _meth_func = "__func__"
+    _meth_self = "__self__"
+
+    _func_closure = "__closure__"
+    _func_code = "__code__"
+    _func_defaults = "__defaults__"
+    _func_globals = "__globals__"
+else:
+    _meth_func = "im_func"
+    _meth_self = "im_self"
+
+    _func_closure = "func_closure"
+    _func_code = "func_code"
+    _func_defaults = "func_defaults"
+    _func_globals = "func_globals"
+
+
+try:
+    advance_iterator = next
+except NameError:
+    def advance_iterator(it):
+        return it.next()
+next = advance_iterator
+
+
+try:
+    callable = callable
+except NameError:
+    def callable(obj):
+        return any("__call__" in klass.__dict__ for klass in type(obj).__mro__)
+
+
+if PY3:
+    def get_unbound_function(unbound):
+        return unbound
+
+    create_bound_method = types.MethodType
+
+    def create_unbound_method(func, cls):
+        return func
+
+    Iterator = object
+else:
+    def get_unbound_function(unbound):
+        return unbound.im_func
+
+    def create_bound_method(func, obj):
+        return types.MethodType(func, obj, obj.__class__)
+
+    def create_unbound_method(func, cls):
+        return types.MethodType(func, None, cls)
+
+    class Iterator(object):
+
+        def next(self):
+            return type(self).__next__(self)
+
+    callable = callable
+_add_doc(get_unbound_function,
+         """Get the function out of a possibly unbound function""")
+
+
+get_method_function = operator.attrgetter(_meth_func)
+get_method_self = operator.attrgetter(_meth_self)
+get_function_closure = operator.attrgetter(_func_closure)
+get_function_code = operator.attrgetter(_func_code)
+get_function_defaults = operator.attrgetter(_func_defaults)
+get_function_globals = operator.attrgetter(_func_globals)
+
+
+if PY3:
+    def iterkeys(d, **kw):
+        return iter(d.keys(**kw))
+
+    def itervalues(d, **kw):
+        return iter(d.values(**kw))
+
+    def iteritems(d, **kw):
+        return iter(d.items(**kw))
+
+    def iterlists(d, **kw):
+        return iter(d.lists(**kw))
+
+    viewkeys = operator.methodcaller("keys")
+
+    viewvalues = operator.methodcaller("values")
+
+    viewitems = operator.methodcaller("items")
+else:
+    def iterkeys(d, **kw):
+        return d.iterkeys(**kw)
+
+    def itervalues(d, **kw):
+        return d.itervalues(**kw)
+
+    def iteritems(d, **kw):
+        return d.iteritems(**kw)
+
+    def iterlists(d, **kw):
+        return d.iterlists(**kw)
+
+    viewkeys = operator.methodcaller("viewkeys")
+
+    viewvalues = operator.methodcaller("viewvalues")
+
+    viewitems = operator.methodcaller("viewitems")
+
+_add_doc(iterkeys, "Return an iterator over the keys of a dictionary.")
+_add_doc(itervalues, "Return an iterator over the values of a dictionary.")
+_add_doc(iteritems,
+         "Return an iterator over the (key, value) pairs of a dictionary.")
+_add_doc(iterlists,
+         "Return an iterator over the (key, [values]) pairs of a dictionary.")
+
+
+if PY3:
+    def b(s):
+        return s.encode("latin-1")
+
+    def u(s):
+        return s
+    unichr = chr
+    import struct
+    int2byte = struct.Struct(">B").pack
+    del struct
+    byte2int = operator.itemgetter(0)
+    indexbytes = operator.getitem
+    iterbytes = iter
+    import io
+    StringIO = io.StringIO
+    BytesIO = io.BytesIO
+    del io
+    _assertCountEqual = "assertCountEqual"
+    if sys.version_info[1] <= 1:
+        _assertRaisesRegex = "assertRaisesRegexp"
+        _assertRegex = "assertRegexpMatches"
+        _assertNotRegex = "assertNotRegexpMatches"
+    else:
+        _assertRaisesRegex = "assertRaisesRegex"
+        _assertRegex = "assertRegex"
+        _assertNotRegex = "assertNotRegex"
+else:
+    def b(s):
+        return s
+    # Workaround for standalone backslash
+
+    def u(s):
+        return unicode(s.replace(r'\\', r'\\\\'), "unicode_escape")
+    unichr = unichr
+    int2byte = chr
+
+    def byte2int(bs):
+        return ord(bs[0])
+
+    def indexbytes(buf, i):
+        return ord(buf[i])
+    iterbytes = functools.partial(itertools.imap, ord)
+    import StringIO
+    StringIO = BytesIO = StringIO.StringIO
+    _assertCountEqual = "assertItemsEqual"
+    _assertRaisesRegex = "assertRaisesRegexp"
+    _assertRegex = "assertRegexpMatches"
+    _assertNotRegex = "assertNotRegexpMatches"
+_add_doc(b, """Byte literal""")
+_add_doc(u, """Text literal""")
+
+
+def assertCountEqual(self, *args, **kwargs):
+    return getattr(self, _assertCountEqual)(*args, **kwargs)
+
+
+def assertRaisesRegex(self, *args, **kwargs):
+    return getattr(self, _assertRaisesRegex)(*args, **kwargs)
+
+
+def assertRegex(self, *args, **kwargs):
+    return getattr(self, _assertRegex)(*args, **kwargs)
+
+
+def assertNotRegex(self, *args, **kwargs):
+    return getattr(self, _assertNotRegex)(*args, **kwargs)
+
+
+if PY3:
+    exec_ = getattr(moves.builtins, "exec")
+
+    def reraise(tp, value, tb=None):
+        try:
+            if value is None:
+                value = tp()
+            if value.__traceback__ is not tb:
+                raise value.with_traceback(tb)
+            raise value
+        finally:
+            value = None
+            tb = None
+
+else:
+    def exec_(_code_, _globs_=None, _locs_=None):
+        """Execute code in a namespace."""
+        if _globs_ is None:
+            frame = sys._getframe(1)
+            _globs_ = frame.f_globals
+            if _locs_ is None:
+                _locs_ = frame.f_locals
+            del frame
+        elif _locs_ is None:
+            _locs_ = _globs_
+        exec("""exec _code_ in _globs_, _locs_""")
+
+    exec_("""def reraise(tp, value, tb=None):
+    try:
+        raise tp, value, tb
+    finally:
+        tb = None
+""")
+
+
+if sys.version_info[:2] > (3,):
+    exec_("""def raise_from(value, from_value):
+    try:
+        raise value from from_value
+    finally:
+        value = None
+""")
+else:
+    def raise_from(value, from_value):
+        raise value
+
+
+print_ = getattr(moves.builtins, "print", None)
+if print_ is None:
+    def print_(*args, **kwargs):
+        """The new-style print function for Python 2.4 and 2.5."""
+        fp = kwargs.pop("file", sys.stdout)
+        if fp is None:
+            return
+
+        def write(data):
+            if not isinstance(data, basestring):
+                data = str(data)
+            # If the file has an encoding, encode unicode with it.
+            if (isinstance(fp, file) and
+                    isinstance(data, unicode) and
+                    fp.encoding is not None):
+                errors = getattr(fp, "errors", None)
+                if errors is None:
+                    errors = "strict"
+                data = data.encode(fp.encoding, errors)
+            fp.write(data)
+        want_unicode = False
+        sep = kwargs.pop("sep", None)
+        if sep is not None:
+            if isinstance(sep, unicode):
+                want_unicode = True
+            elif not isinstance(sep, str):
+                raise TypeError("sep must be None or a string")
+        end = kwargs.pop("end", None)
+        if end is not None:
+            if isinstance(end, unicode):
+                want_unicode = True
+            elif not isinstance(end, str):
+                raise TypeError("end must be None or a string")
+        if kwargs:
+            raise TypeError("invalid keyword arguments to print()")
+        if not want_unicode:
+            for arg in args:
+                if isinstance(arg, unicode):
+                    want_unicode = True
+                    break
+        if want_unicode:
+            newline = unicode("\n")
+            space = unicode(" ")
+        else:
+            newline = "\n"
+            space = " "
+        if sep is None:
+            sep = space
+        if end is None:
+            end = newline
+        for i, arg in enumerate(args):
+            if i:
+                write(sep)
+            write(arg)
+        write(end)
+if sys.version_info[:2] < (3, 3):
+    _print = print_
+
+    def print_(*args, **kwargs):
+        fp = kwargs.get("file", sys.stdout)
+        flush = kwargs.pop("flush", False)
+        _print(*args, **kwargs)
+        if flush and fp is not None:
+            fp.flush()
+
+_add_doc(reraise, """Reraise an exception.""")
+
+if sys.version_info[0:2] < (3, 4):
+    # This does exactly the same what the :func:`py3:functools.update_wrapper`
+    # function does on Python versions after 3.2. It sets the ``__wrapped__``
+    # attribute on ``wrapper`` object and it doesn't raise an error if any of
+    # the attributes mentioned in ``assigned`` and ``updated`` are missing on
+    # ``wrapped`` object.
+    def _update_wrapper(wrapper, wrapped,
+                        assigned=functools.WRAPPER_ASSIGNMENTS,
+                        updated=functools.WRAPPER_UPDATES):
+        for attr in assigned:
+            try:
+                value = getattr(wrapped, attr)
+            except AttributeError:
+                continue
+            else:
+                setattr(wrapper, attr, value)
+        for attr in updated:
+            getattr(wrapper, attr).update(getattr(wrapped, attr, {}))
+        wrapper.__wrapped__ = wrapped
+        return wrapper
+    _update_wrapper.__doc__ = functools.update_wrapper.__doc__
+
+    def wraps(wrapped, assigned=functools.WRAPPER_ASSIGNMENTS,
+              updated=functools.WRAPPER_UPDATES):
+        return functools.partial(_update_wrapper, wrapped=wrapped,
+                                 assigned=assigned, updated=updated)
+    wraps.__doc__ = functools.wraps.__doc__
+
+else:
+    wraps = functools.wraps
+
+
+def with_metaclass(meta, *bases):
+    """Create a base class with a metaclass."""
+    # This requires a bit of explanation: the basic idea is to make a dummy
+    # metaclass for one level of class instantiation that replaces itself with
+    # the actual metaclass.
+    class metaclass(type):
+
+        def __new__(cls, name, this_bases, d):
+            if sys.version_info[:2] >= (3, 7):
+                # This version introduced PEP 560 that requires a bit
+                # of extra care (we mimic what is done by __build_class__).
+                resolved_bases = types.resolve_bases(bases)
+                if resolved_bases is not bases:
+                    d['__orig_bases__'] = bases
+            else:
+                resolved_bases = bases
+            return meta(name, resolved_bases, d)
+
+        @classmethod
+        def __prepare__(cls, name, this_bases):
+            return meta.__prepare__(name, bases)
+    return type.__new__(metaclass, 'temporary_class', (), {})
+
+
+def add_metaclass(metaclass):
+    """Class decorator for creating a class with a metaclass."""
+    def wrapper(cls):
+        orig_vars = cls.__dict__.copy()
+        slots = orig_vars.get('__slots__')
+        if slots is not None:
+            if isinstance(slots, str):
+                slots = [slots]
+            for slots_var in slots:
+                orig_vars.pop(slots_var)
+        orig_vars.pop('__dict__', None)
+        orig_vars.pop('__weakref__', None)
+        if hasattr(cls, '__qualname__'):
+            orig_vars['__qualname__'] = cls.__qualname__
+        return metaclass(cls.__name__, cls.__bases__, orig_vars)
+    return wrapper
+
+
+def ensure_binary(s, encoding='utf-8', errors='strict'):
+    """Coerce **s** to six.binary_type.
+
+    For Python 2:
+      - `unicode` -> encoded to `str`
+      - `str` -> `str`
+
+    For Python 3:
+      - `str` -> encoded to `bytes`
+      - `bytes` -> `bytes`
+    """
+    if isinstance(s, binary_type):
+        return s
+    if isinstance(s, text_type):
+        return s.encode(encoding, errors)
+    raise TypeError("not expecting type '%s'" % type(s))
+
+
+def ensure_str(s, encoding='utf-8', errors='strict'):
+    """Coerce *s* to `str`.
+
+    For Python 2:
+      - `unicode` -> encoded to `str`
+      - `str` -> `str`
+
+    For Python 3:
+      - `str` -> `str`
+      - `bytes` -> decoded to `str`
+    """
+    # Optimization: Fast return for the common case.
+    if type(s) is str:
+        return s
+    if PY2 and isinstance(s, text_type):
+        return s.encode(encoding, errors)
+    elif PY3 and isinstance(s, binary_type):
+        return s.decode(encoding, errors)
+    elif not isinstance(s, (text_type, binary_type)):
+        raise TypeError("not expecting type '%s'" % type(s))
+    return s
+
+
+def ensure_text(s, encoding='utf-8', errors='strict'):
+    """Coerce *s* to six.text_type.
+
+    For Python 2:
+      - `unicode` -> `unicode`
+      - `str` -> `unicode`
+
+    For Python 3:
+      - `str` -> `str`
+      - `bytes` -> decoded to `str`
+    """
+    if isinstance(s, binary_type):
+        return s.decode(encoding, errors)
+    elif isinstance(s, text_type):
+        return s
+    else:
+        raise TypeError("not expecting type '%s'" % type(s))
+
+
+def python_2_unicode_compatible(klass):
+    """
+    A class decorator that defines __unicode__ and __str__ methods under Python 2.
+    Under Python 3 it does nothing.
+
+    To support Python 2 and 3 with a single code base, define a __str__ method
+    returning text and apply this decorator to the class.
+    """
+    if PY2:
+        if '__str__' not in klass.__dict__:
+            raise ValueError("@python_2_unicode_compatible cannot be applied "
+                             "to %s because it doesn't define __str__()." %
+                             klass.__name__)
+        klass.__unicode__ = klass.__str__
+        klass.__str__ = lambda self: self.__unicode__().encode('utf-8')
+    return klass
+
+
+# Complete the moves implementation.
+# This code is at the end of this module to speed up module loading.
+# Turn this module into a package.
+__path__ = []  # required for PEP 302 and PEP 451
+__package__ = __name__  # see PEP 366 @ReservedAssignment
+if globals().get("__spec__") is not None:
+    __spec__.submodule_search_locations = []  # PEP 451 @UndefinedVariable
+# Remove other six meta path importers, since they cause problems. This can
+# happen if six is removed from sys.modules and then reloaded. (Setuptools does
+# this for some reason.)
+if sys.meta_path:
+    for i, importer in enumerate(sys.meta_path):
+        # Here's some real nastiness: Another "instance" of the six module might
+        # be floating around. Therefore, we can't use isinstance() to check for
+        # the six meta path importer, since the other six instance will have
+        # inserted an importer with different class.
+        if (type(importer).__name__ == "_SixMetaPathImporter" and
+                importer.name == __name__):
+            del sys.meta_path[i]
+            break
+    del i, importer
+# Finally, add the importer to the meta path import hook.
+sys.meta_path.append(_importer)
diff --git a/poetry.lock b/poetry.lock
new file mode 100644
index 0000000..d11fc0e
--- /dev/null
+++ b/poetry.lock
@@ -0,0 +1,180 @@
+[[package]]
+name = "attrs"
+version = "22.1.0"
+description = "Classes Without Boilerplate"
+category = "main"
+optional = false
+python-versions = ">=3.5"
+
+[package.extras]
+dev = ["cloudpickle", "coverage[toml] (>=5.0.2)", "furo", "hypothesis", "mypy (>=0.900,!=0.940)", "pre-commit", "pympler", "pytest (>=4.3.0)", "pytest-mypy-plugins", "sphinx", "sphinx-notfound-page", "zope.interface"]
+docs = ["furo", "sphinx", "sphinx-notfound-page", "zope.interface"]
+tests = ["cloudpickle", "coverage[toml] (>=5.0.2)", "hypothesis", "mypy (>=0.900,!=0.940)", "pympler", "pytest (>=4.3.0)", "pytest-mypy-plugins", "zope.interface"]
+tests_no_zope = ["cloudpickle", "coverage[toml] (>=5.0.2)", "hypothesis", "mypy (>=0.900,!=0.940)", "pympler", "pytest (>=4.3.0)", "pytest-mypy-plugins"]
+
+[[package]]
+name = "colorama"
+version = "0.4.5"
+description = "Cross-platform colored terminal text."
+category = "main"
+optional = false
+python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*"
+
+[[package]]
+name = "iniconfig"
+version = "1.1.1"
+description = "iniconfig: brain-dead simple config-ini parsing"
+category = "main"
+optional = false
+python-versions = "*"
+
+[[package]]
+name = "numpy"
+version = "1.23.4"
+description = "NumPy is the fundamental package for array computing with Python."
+category = "main"
+optional = false
+python-versions = ">=3.8"
+
+[[package]]
+name = "packaging"
+version = "21.3"
+description = "Core utilities for Python packages"
+category = "main"
+optional = false
+python-versions = ">=3.6"
+
+[package.dependencies]
+pyparsing = ">=2.0.2,<3.0.5 || >3.0.5"
+
+[[package]]
+name = "pluggy"
+version = "1.0.0"
+description = "plugin and hook calling mechanisms for python"
+category = "main"
+optional = false
+python-versions = ">=3.6"
+
+[package.extras]
+dev = ["pre-commit", "tox"]
+testing = ["pytest", "pytest-benchmark"]
+
+[[package]]
+name = "py"
+version = "1.11.0"
+description = "library with cross-python path, ini-parsing, io, code, log facilities"
+category = "main"
+optional = false
+python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*"
+
+[[package]]
+name = "pyparsing"
+version = "3.0.9"
+description = "pyparsing module - Classes and methods to define and execute parsing grammars"
+category = "main"
+optional = false
+python-versions = ">=3.6.8"
+
+[package.extras]
+diagrams = ["jinja2", "railroad-diagrams"]
+
+[[package]]
+name = "pytest"
+version = "7.1.3"
+description = "pytest: simple powerful testing with Python"
+category = "main"
+optional = false
+python-versions = ">=3.7"
+
+[package.dependencies]
+attrs = ">=19.2.0"
+colorama = {version = "*", markers = "sys_platform == \"win32\""}
+iniconfig = "*"
+packaging = "*"
+pluggy = ">=0.12,<2.0"
+py = ">=1.8.2"
+tomli = ">=1.0.0"
+
+[package.extras]
+testing = ["argcomplete", "hypothesis (>=3.56)", "mock", "nose", "pygments (>=2.7.2)", "requests", "xmlschema"]
+
+[[package]]
+name = "tomli"
+version = "2.0.1"
+description = "A lil' TOML parser"
+category = "main"
+optional = false
+python-versions = ">=3.7"
+
+[metadata]
+lock-version = "1.1"
+python-versions = "^3.10"
+content-hash = "89f4bd34fda9d9f711e38dacb160780ecc3a847c867c3a83a4580cfa683e55ea"
+
+[metadata.files]
+attrs = [
+    {file = "attrs-22.1.0-py2.py3-none-any.whl", hash = "sha256:86efa402f67bf2df34f51a335487cf46b1ec130d02b8d39fd248abfd30da551c"},
+    {file = "attrs-22.1.0.tar.gz", hash = "sha256:29adc2665447e5191d0e7c568fde78b21f9672d344281d0c6e1ab085429b22b6"},
+]
+colorama = [
+    {file = "colorama-0.4.5-py2.py3-none-any.whl", hash = "sha256:854bf444933e37f5824ae7bfc1e98d5bce2ebe4160d46b5edf346a89358e99da"},
+    {file = "colorama-0.4.5.tar.gz", hash = "sha256:e6c6b4334fc50988a639d9b98aa429a0b57da6e17b9a44f0451f930b6967b7a4"},
+]
+iniconfig = [
+    {file = "iniconfig-1.1.1-py2.py3-none-any.whl", hash = "sha256:011e24c64b7f47f6ebd835bb12a743f2fbe9a26d4cecaa7f53bc4f35ee9da8b3"},
+    {file = "iniconfig-1.1.1.tar.gz", hash = "sha256:bc3af051d7d14b2ee5ef9969666def0cd1a000e121eaea580d4a313df4b37f32"},
+]
+numpy = [
+    {file = "numpy-1.23.4-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:95d79ada05005f6f4f337d3bb9de8a7774f259341c70bc88047a1f7b96a4bcb2"},
+    {file = "numpy-1.23.4-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:926db372bc4ac1edf81cfb6c59e2a881606b409ddc0d0920b988174b2e2a767f"},
+    {file = "numpy-1.23.4-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c237129f0e732885c9a6076a537e974160482eab8f10db6292e92154d4c67d71"},
+    {file = "numpy-1.23.4-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a8365b942f9c1a7d0f0dc974747d99dd0a0cdfc5949a33119caf05cb314682d3"},
+    {file = "numpy-1.23.4-cp310-cp310-win32.whl", hash = "sha256:2341f4ab6dba0834b685cce16dad5f9b6606ea8a00e6da154f5dbded70fdc4dd"},
+    {file = "numpy-1.23.4-cp310-cp310-win_amd64.whl", hash = "sha256:d331afac87c92373826af83d2b2b435f57b17a5c74e6268b79355b970626e329"},
+    {file = "numpy-1.23.4-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:488a66cb667359534bc70028d653ba1cf307bae88eab5929cd707c761ff037db"},
+    {file = "numpy-1.23.4-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:ce03305dd694c4873b9429274fd41fc7eb4e0e4dea07e0af97a933b079a5814f"},
+    {file = "numpy-1.23.4-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8981d9b5619569899666170c7c9748920f4a5005bf79c72c07d08c8a035757b0"},
+    {file = "numpy-1.23.4-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7a70a7d3ce4c0e9284e92285cba91a4a3f5214d87ee0e95928f3614a256a1488"},
+    {file = "numpy-1.23.4-cp311-cp311-win32.whl", hash = "sha256:5e13030f8793e9ee42f9c7d5777465a560eb78fa7e11b1c053427f2ccab90c79"},
+    {file = "numpy-1.23.4-cp311-cp311-win_amd64.whl", hash = "sha256:7607b598217745cc40f751da38ffd03512d33ec06f3523fb0b5f82e09f6f676d"},
+    {file = "numpy-1.23.4-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:7ab46e4e7ec63c8a5e6dbf5c1b9e1c92ba23a7ebecc86c336cb7bf3bd2fb10e5"},
+    {file = "numpy-1.23.4-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:a8aae2fb3180940011b4862b2dd3756616841c53db9734b27bb93813cd79fce6"},
+    {file = "numpy-1.23.4-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8c053d7557a8f022ec823196d242464b6955a7e7e5015b719e76003f63f82d0f"},
+    {file = "numpy-1.23.4-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a0882323e0ca4245eb0a3d0a74f88ce581cc33aedcfa396e415e5bba7bf05f68"},
+    {file = "numpy-1.23.4-cp38-cp38-win32.whl", hash = "sha256:dada341ebb79619fe00a291185bba370c9803b1e1d7051610e01ed809ef3a4ba"},
+    {file = "numpy-1.23.4-cp38-cp38-win_amd64.whl", hash = "sha256:0fe563fc8ed9dc4474cbf70742673fc4391d70f4363f917599a7fa99f042d5a8"},
+    {file = "numpy-1.23.4-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:c67b833dbccefe97cdd3f52798d430b9d3430396af7cdb2a0c32954c3ef73894"},
+    {file = "numpy-1.23.4-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:f76025acc8e2114bb664294a07ede0727aa75d63a06d2fae96bf29a81747e4a7"},
+    {file = "numpy-1.23.4-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:12ac457b63ec8ded85d85c1e17d85efd3c2b0967ca39560b307a35a6703a4735"},
+    {file = "numpy-1.23.4-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:95de7dc7dc47a312f6feddd3da2500826defdccbc41608d0031276a24181a2c0"},
+    {file = "numpy-1.23.4-cp39-cp39-win32.whl", hash = "sha256:f2f390aa4da44454db40a1f0201401f9036e8d578a25f01a6e237cea238337ef"},
+    {file = "numpy-1.23.4-cp39-cp39-win_amd64.whl", hash = "sha256:f260da502d7441a45695199b4e7fd8ca87db659ba1c78f2bbf31f934fe76ae0e"},
+    {file = "numpy-1.23.4-pp38-pypy38_pp73-macosx_10_9_x86_64.whl", hash = "sha256:61be02e3bf810b60ab74e81d6d0d36246dbfb644a462458bb53b595791251911"},
+    {file = "numpy-1.23.4-pp38-pypy38_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:296d17aed51161dbad3c67ed6d164e51fcd18dbcd5dd4f9d0a9c6055dce30810"},
+    {file = "numpy-1.23.4-pp38-pypy38_pp73-win_amd64.whl", hash = "sha256:4d52914c88b4930dafb6c48ba5115a96cbab40f45740239d9f4159c4ba779962"},
+    {file = "numpy-1.23.4.tar.gz", hash = "sha256:ed2cc92af0efad20198638c69bb0fc2870a58dabfba6eb722c933b48556c686c"},
+]
+packaging = [
+    {file = "packaging-21.3-py3-none-any.whl", hash = "sha256:ef103e05f519cdc783ae24ea4e2e0f508a9c99b2d4969652eed6a2e1ea5bd522"},
+    {file = "packaging-21.3.tar.gz", hash = "sha256:dd47c42927d89ab911e606518907cc2d3a1f38bbd026385970643f9c5b8ecfeb"},
+]
+pluggy = [
+    {file = "pluggy-1.0.0-py2.py3-none-any.whl", hash = "sha256:74134bbf457f031a36d68416e1509f34bd5ccc019f0bcc952c7b909d06b37bd3"},
+    {file = "pluggy-1.0.0.tar.gz", hash = "sha256:4224373bacce55f955a878bf9cfa763c1e360858e330072059e10bad68531159"},
+]
+py = [
+    {file = "py-1.11.0-py2.py3-none-any.whl", hash = "sha256:607c53218732647dff4acdfcd50cb62615cedf612e72d1724fb1a0cc6405b378"},
+    {file = "py-1.11.0.tar.gz", hash = "sha256:51c75c4126074b472f746a24399ad32f6053d1b34b68d2fa41e558e6f4a98719"},
+]
+pyparsing = [
+    {file = "pyparsing-3.0.9-py3-none-any.whl", hash = "sha256:5026bae9a10eeaefb61dab2f09052b9f4307d44aee4eda64b309723d8d206bbc"},
+    {file = "pyparsing-3.0.9.tar.gz", hash = "sha256:2b020ecf7d21b687f219b71ecad3631f644a47f01403fa1d1036b0c6416d70fb"},
+]
+pytest = [
+    {file = "pytest-7.1.3-py3-none-any.whl", hash = "sha256:1377bda3466d70b55e3f5cecfa55bb7cfcf219c7964629b967c37cf0bda818b7"},
+    {file = "pytest-7.1.3.tar.gz", hash = "sha256:4f365fec2dff9c1162f834d9f18af1ba13062db0c708bf7b946f8a5c76180c39"},
+]
+tomli = [
+    {file = "tomli-2.0.1-py3-none-any.whl", hash = "sha256:939de3e7a6161af0c887ef91b7d41a53e7c5a1ca976325f429cb46ea9bc30ecc"},
+    {file = "tomli-2.0.1.tar.gz", hash = "sha256:de526c12914f0c550d15924c62d72abc48d6fe7364aa87328337a31007fe8a4f"},
+]
diff --git a/pyproject.toml b/pyproject.toml
new file mode 100644
index 0000000..d2119aa
--- /dev/null
+++ b/pyproject.toml
@@ -0,0 +1,17 @@
+[tool.poetry]
+name = "hirise-blender"
+version = "0.1.0"
+description = ""
+authors = ["Daniel Cellucci <dwcellucci@gmail.com>"]
+readme = "README.md"
+packages = [{include = "hirise_blender"}]
+
+[tool.poetry.dependencies]
+python = "^3.10"
+numpy = "^1.23.4"
+pytest = "^7.1.3"
+
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"