#!/usr/bin/env python3

# compressor.py
from subprocess import Popen, PIPE

def compress(value):
    """Compresses a byte array with the xz binary"""

    process = Popen(["xz", "--compress", "--force"], stdin=PIPE, stdout=PIPE)
    return process.communicate(value)[0]

def decompress(value):
    """Decompresses a byte array with the xz binary"""

    process = Popen(["xz", "--decompress", "--stdout", "--force"],
                    stdin=PIPE, stdout=PIPE)
    return process.communicate(value)[0]

def compress_file(path):
    """Compress the file at 'path' with the xz binary"""

    process = Popen(["xz", "--compress", "--force", "--stdout", path], stdout=PIPE)
    return process.communicate()[0]

# compressor.py

import os
import sys
from optparse import OptionParser
from sys import argv
import base64
try:
    import cPickle as pickle
except ImportError:
    import pickle
from io import BytesIO

from os.path import basename
from errno import EPIPE

def load():
    ppds_compressed = base64.b64decode(ppds_compressed_b64)
    ppds_decompressed = decompress(ppds_compressed)
    ppds = pickle.loads(ppds_decompressed)
    return ppds

def ls():
    binary_name = basename(argv[0])
    ppds = load()
    for key, value in ppds.items():
        if key == 'ARCHIVE': continue
        for ppd in value[2]:
            try:
                print(ppd.replace('"', '"' + binary_name + ':', 1))
            except IOError as e:
                # Errors like broken pipes (program which takes the standard
                # output terminates before this program terminates) should not
                # generate a traceback.
                if e.errno == EPIPE: exit(0)
                raise

def cat(ppd):
    # Ignore driver's name, take only PPD's
    ppd = ppd.split(":")[-1]
    # Remove also the index
    ppd = "0/" + ppd[ppd.find("/")+1:]

    ppds = load()
    ppds['ARCHIVE'] = BytesIO(decompress(ppds['ARCHIVE']))

    if ppd in ppds:
        start = ppds[ppd][0]
        length = ppds[ppd][1]
        ppds['ARCHIVE'].seek(start)
        return ppds['ARCHIVE'].read(length)

def main():
    usage = "usage: %prog list\n" \
            "       %prog cat URI"
    version = "%prog 1.0.2\n" \
              "Copyright (c) 2013 Vitor Baptista.\n" \
              "This is free software; see the source for copying conditions.\n" \
              "There is NO warranty; not even for MERCHANTABILITY or\n" \
              "FITNESS FOR A PARTICULAR PURPOSE."
    parser = OptionParser(usage=usage,
                          version=version)
    (options, args) = parser.parse_args()

    if len(args) == 0 or len(args) > 2:
        parser.error("incorrect number of arguments")

    if args[0].lower() == 'list':
        ls()
    elif args[0].lower() == 'cat':
        if not len(args) == 2:
            parser.error("incorrect number of arguments")
        ppd = cat(args[1])
        if not ppd:
            parser.error("Printer '%s' does not have default driver!" % args[1])
        try:
            # avoid any assumption of encoding or system locale; just print the
            # bytes of the PPD as they are
            if sys.version_info.major < 3:
                sys.stdout.write(ppd)
            else:
                sys.stdout.buffer.write(ppd)
        except IOError as e:
            # Errors like broken pipes (program which takes the standard output
            # terminates before this program terminates) should not generate a
            # traceback.
            if e.errno == EPIPE: exit(0)
            raise
    else:
        parser.error("argument " + args[0] + " invalid")

# PPDs Archive
ppds_compressed_b64 = b"/Td6WFoAAATm1rRGAgAhARYAAAB0L+Wj4CpEGYZdAEAAyynXgKBkKXF2v/boY8vTM9MktbLOpatIGjz3QEXi/jpWYIhyvau9psw0xK8h1hWT6SLEHxWybkk+bNDHRc8fg/hTVUGP3kcAriKfVF8Ji9GB8iPo14HHtZfokKaQfiFTlSNo2v01MnnuIp08Cc6y5EyWCmQHqsItVsvF9GUTe5nehU4praKMhnCZTWvmMR09yYABw/x7v3g2SVDHUfGlAT8Zj210Zue8h0TP7VLe+W3ggxZakf7v0kSo6zzfApzOkc7Au8h11VKG6KgkDuXRGuR6ZknefIY3zvWBWe5f0jn2IsgA0ZyBaOprvNEu7vKJ74SxefmhPxQe4N5uJD8uo1XnJotzOdB3SOmbpW0BFA4luxbQZ26R2RnjQmt3y6L9A2jTfNC+p6EkCSn9jIFVzn3O7msvqNvwVoNLe4v6BE6kMkzpi3/GcR/zbBfQlcJ/sPFcUP+39d3hAQV+EEnaa0ccPF1In1iuTzCmv/4PkOcdlrIFDj5bLPs1FMZ7mPgnLGm4rZzFgYVcgdhF7NKk/Z1EuuYVoKey8ukHqD2TLo94R+NZgcF2/kjCJzc8tp0YEjZpl5VCfHQ+oHrFSVSJLIeMYVjuhLV3qUy01l4el8FB7ySb/oaUau8PDyiDEYmk/Q5fgjTeO5OIQ894r8qcC4n3+Mq8VEjoxwyQ0/kgtgZ/pp7zdtqOU8yFiOPhzOsMxzRQD8EdPIjdKL1uqoyJ0lSRpHcfEwgeQbEmIwfVSOPVxLZXz/OL07T5FvEaUEpN1joKV2c2pe4fcfaSji0lxj8fw0BdOHJyQDSy+R5fOValucAMJtDuUF8b6uza0fCdRY5e+56Jb4m33tMPcFAHuRxEm/fdeQKs+yNBUcObp4YeIWmCISud4fVZryRihspNqRDJzpbm98kUbiA1TwW4vwDlFyl9vd80DiAHFCEprjYL1/M1HozSJVE9x3yTAUrpXNU+pW7bBbSsZSuTrMZjLAs/uoaDHDlCPH8oPewSzUJuVkdl+LHEhbOdYiTxu+rlCbbozpbLFsd04fxAhtc02SW0o2MVgwqennlyGH15X3YWpC2uSZV5w30VM6qrZURlj6piwiRBqYW61CSVtvmHYUA44w/8eFfRumne6KQ4yRK8pNZ7nEEbCGjsEOASysQof9yY5W2IJ0ZHzpxA212M1JXASExyhlHvwAgk5OTc6/CbBTd4nPYhYJwHl9rhpri/BQfjsfMFmUgDvWql4ppH54pgtaAQGHLsXp+Hx4aBd8UTGHwXSBHQ8vig3C1UMvqECex3GXsbDBlkOGV7vCcGcBhny7pwtm0KBtl/FA+CVzpzRZ0sdtiy+6+yUat/nUu25TqaO1nmYj30bcJPiQ6AADWA8ZDF7xW7UGbfe+s55Wbh7dPAyhtJW8cR0MnOz8IMXAzz9jLsorTCa6RO3lwB5q73RA4ZKQdb3UlvkG+tKC73MrA8LIV6ITGVttGoPfZDxVPiTt2N2hDeWbWoaJzjuSqm7xwAnJ7g3FMSyYSir73AIMrZocamL05ZJzTRBrwuBvMddglnFOuFzvu0zjOVKpZNqsOP0XVeNFEl6nrmo6W5Tc9owHm2p6IwZ4Ffb4b1x886Va1ebkX1ZKK2QVsyb11+F/+NhYz1elOOK/ExCebXkSZvln/4Lr//3djnDtgMQ5h2oG9eUxbWwFQzTX4KTytjQqUuOykuT23r/Hb3hl/qx516Fby9lsfY5VNvMxOvHdr6k4moI69iqxpbGtQFOUfBsKWv3aaelGAiVMVYPJ9biS3P1Ky87cU77zcH1ALelhfrxWiYIagCs2WKi1lB7/QpiLi9x7OjH63GKnNfkr0ZM2RZG9PM/QTBlAMcFAb93/7NWZnNh5xJc4AsfaXg6abb76/NqUkNed9BzehJ205id4iiiK2Uu8z8FqagsKCLxw5hTNW+Tc14H0+K3Ltvz3jQCSfShvZ0SbScY9pq+YRMqDTisF7Gb+zLk5eIE+9ghrytRpsbirdKC383kpl/trQzVn6HR1xd/c3bEIAmgbLIuaCIbb2aC/CwgPoqTKH/ZihaXuFxo112MptuAcS67l5vLivtiH3lP1A127UE41u1R1Kjt1Kg0Pa/WAbhh/+tZr27HZkElcbMPLxngnZ+cOAUxjNONL6gV1BYC8W4mtjzsqc9Fnj5E9NGOlvjTQt0WQFMOMwkxXaEOXgoaD/hNxQOcOX55RtUmRaslOklFO7pR5w00EfqbMyAuaPXcL1HjXLEwLJSt4SIVC+NKElJee3Z6AF3EY4BNnBAayx6369Qf3UB+uZShHDLRNUohVKI4keoAW6qg6YIeIlc8F1bPxj66b28TvZ7CpCf/dfv1vP0P8AwBCEiyLx3Q9VP/+6ha4c2/KeUm+TrubxRmCugvEd2Zkg7mSZuo/rRUthRk0dYdfNhKDZmLMDDipeoXb2rXBHfG1/Xfmv2QVkRE+cxcuY8Pdr0aStjyiXUuZAv1PVZ7/wP2eE982V2ghyjlj/byKI9kRP5zsttenXvQjIK97tZRjefEw0dreQWEzUUUi6cZmryFsTQ+bL+UiHsEX+vV3HbRMugzhfvlaPvX3vwnFLxd3c+3cQSJZEStby+RKy4mdrIFigZua33cqBJ+gb8aUBtI4QK0wAxi6v/e/eUQI8Cr34w255ZSeHjn+5IO8c59yx3mErH90MoVs55Fy9TOIo+GHyA9NVb8NaQg0CYKNKzWe0GV/ZC1n4UQarYFq8g0xyNxnCU/fngukMjUezcWmYVuxkqEVq8cFhQaYYWmurA2CXQSYzXfC32bmaC2LSCEZHVLz0iOwLJBep8l1L0zhszpqVM/2qsUOqDtwVAsUBVQQzvXeLMFf9Yi13GovdGbG+lKf7ElRgEMIbTFwhmLMgQtxbHHTOZTegPdtCJ54Z4iIe6Ra1LkDg0JA07oFPkeTv21YhoEME7R9J7/YpKPiM4SFyiTePlbt0oSrS9OPY1ZxPeO7cnpJg4b/WTQFtcU/KygRRY3Iq3/9OUypZKUN2kmrOoJ+iAHvfc/y9IQK79juslGGilPVOS/Q4cKevw54cgBhdkF7D0K/5sdlJPorbkHjpbujLuqH/uJu9J3fSXCwxlJx3jrMfMLfffil6j3qw9cSHpGOW/SJFvdkD/uNKgn0Jg7h1BzSRyTExAnppQNM3LcOFpN9bbJ0cKMlW0PMiRwEeNciFGRIBHMsQCZySEPYH+EBeFT/pLhDyxumLPlzVfO0gcxOGaeSk38auqLEr0Zgo+FuR8q+sOwmYEwCdDPmPhe5UeQm5jaMaXpZRDy/8V8kTmjIIJWopZ7XhCarfBh2TsbrRYvoeWhleqzIAp9hV2Zbzwew8DZXIg+l92xo4icrVM1LHPyOi5QK5PG7sWRlJ9OHUw3EjJalKoowZK5eQ/9CFtwfqS/DvPrIHsEJxCC1e0MBZsFl3tzBopk1LJW4Kc7AwHyCo81Ikn+yiwx/JBSi3fNUraxN5rXDcSbm1uyQYpSOPR6mfPiHTY3gYywIsMhPRBDwRNtFfht1rgdJItuo2jF1zzNrpA07AYwEjnNUo1yt0J7FmyAfuqS4wXqHJeT9NvapiOJF4vSsa0lct2JTeaYzsX4HMhJdcyh5VOu8FslYj9NMVRdNhckx3n9ePOU/fLFtDqvO6nnV30hOptxfeMdUPz/pcgKd6++3Dy5U3+G5q6IN8M+/1v4F88BMt3061bfCnAEN5LP/F3BC7b6l11/Sc7rlcr96ZTVhGLFEb3UD4KKda7CZ8bBlkP3t5ni2D7P2YIzzfo5xmRUIZObkdd9daE8TxlTz9dRsRP0yMswxRwnvCr8sv6puRCoY857AerExXamqjlyAmlPyZaT5I4Fh5ZuUqHLR1ZAXHdCqJ4Vked2oGDA5F3ISjFopBl4AbQ7S3rpnwicUhxw+81x43ruIMJvPMKaT433tqpMoRE6rJhogWcTaPvc1uwfHVCmBDkFwOnTjkk49bbcOwdcGWbb/RMqXat5lF6fSQ3TzHH8tgcCttPuBUjOV1+sYhphKmjcd43Akgxzg2Fvfk5NpB7kbH6mq5dW8UTcnOqZbLYQPkvOswEud9TuOTAE7QVuGnROxaJFF7AvlHnW1TdXXK4fuQGVCFarpQUZxI57k0Qa6+j0MTlUBSfEiLhUsNydrEVX727us7YNZCo3aogLj0IHM0LpFFRdANrHqSd02aloSDtNC6jDqcCfgEG2h5M0l+duPBtgXDChfMPumzGXV54X0HOzklGAy8H1B/PhCDkU/gOkWU19KXm/4JkjxzwOTJDEN57csLgpMlhSPuQnkjHdYsYClhL3ZNyq8Vb2ySWk7Mm+eRGp/5hiakkvtPlP0huNr+HM0+fC0gTppd+gi5OGrSpu2D/VjoLS7LHD8WZmQCkGrVRb0q2ZacHUYWr3FZe+BN2iquZ//L8iCV/Bl22qEcSmBmI6RhMggqPcWH7z5R6xsa82NstyR/btlz8/nb8qkb4oHj0ulgajgqngBqtsU+fte54TzQFg8Jqd72Lq95+VJqCKLkcCw/VzYnfjbvdsYCpph/MXMOrzCRoESPB/6rnqZcw52fkW1Fa86kNQyuIv5t2nZrdFDHy2JT32nWcBZZz5QCX1FPkgvNPUg15XPFaqA0rJ0n8pE63Xo8U8y8D+nVXHefE2pxpPVlbbus8mY9kHBr2oq970olDB+cguqMFRmWU0sv/S/KOLUZ3Z1MvaGs8xyUifiNXoxKUe2XXt6EK70PIQBMgio6EBz8toYJm4CR49hKekMREbs9iR24lPiYM2ObTBDXoj7GQO93zIdWwa5iZK8nZ3GDqOCMmzC/LMMjzx7WzqqO4IzuGhGslHW3mTDXMm15TYSpzwZ2EnlzDI9OIZCgZzlW/0Mm3cyHcQXvK5OtxPK04q1wm7CSXOnWGteFT8UwtR5/JtYYgDL3Z1i8zaFchA+lHXPgb5U7kGNK5GqpPCB/VIMS8OzJoLIaVO4Biz+zEeijrkX+G0D/KSwOfBI9W3tHqciHLr17nvFfEa+MwsW8VwkR4dXuoznzcdWDMMYhy1VCuGGDOYO/c+4gxlXCE3d5Yh3/hx0Y1bXwyEIpAOMbUngrF2jOi2/cJv0Pae7bRe984DDrQf3JoYb4XQS04mG7GXpnYbuxU0wUuaqKN2oNbek/pgFsiwwFqGd1x+Kua3/fKxRn9JCKfa44vasgx70poxvoJRV9geDxHsEuC9p+gtmG87QWSsvY8FB9lsECXU/Q9dgJiNe+pYvbNbhOEUdfESgkzR3VJ/VuPkrH8GNa8y8fuv9igYPdyskSk2XT2E9Y6Gj74QAi9l1l0KAgYrdw0CR1tL8zsUpivAVhxUeTBif7PmoizChhEjRhU4rOBdforMbRQoqunVJyOqovboDqVtdBUJqVi3D2LtxrMK2Y7WXoZ1pnUj5wI1IEkPcOOGL4ClgCXe5LzjP0YETPkumAaGmOG71sUBPuLXAi0ptvUtLDFuZj10FI8vB+ABMOvLN+x7HeCfBDoZuvN4vnrtyD3wLTcjbUzwZxZSOMjpN5zNG46g6jfw3d1eXKm9S+3mWPJMP2/pTAQC9v+TQC14wnNeEhsokViyNE1ZvbGS/qX/C2WQOZiJkgFGYXOyOavaaZxxvxrIc954KeR7fTh2F5wHNNVprUpdRZL9MBggp8pzbwdwIN0p36GLICzoHGfRlkKMWgZi+LDf1FjdNEKYgmeRF5/vgF7QBLdoYhSKd4wa69WXxp7pV6+XP/jqYN1zzMD8OAIkgsL17Jml/onbueQqgQ9C6lQIwXnAbxsch0qp21GPdIknqglUCnkDcU9I77GWhMpBAAsiiwUc6X++wyjpcw0Gwb3wjSkj4RRqfynewcr+OiwEvk8ZkLjbcyJ5wjhG6Vp4THVN2Znapi+c2c1AaW4Fesj+FbQDvF8Zzp3QBW/aRYXzqhfQqoH5qls8Y+IlSpYv320Nmz5oZT65f16UOqCUDwefJIBAQU9XCMqdFbP40lc1SD5bCm3wUSdxKyXgnnFOa7ZK6WnT7ubNjKN7Q9E7r4zdvFspjrExPMpdIB785sMnquxOJ8r+MOU9oW21nox8gtbVq6rrolpdOmNde40J5OysqdXH41WHIP4yg/+MEx739IcAGrWftdR0Z0HM1ZJ63rZCq0ouFp67oz2nkJyml0z+ca+QGU6yTRv5rPwRF88u4Sds1o5Tcdf9vUz7N0QUjzfoYxO2+rvpa8RsgFh6dPXpZUXcSsPz4Fuv3CMvpPva7Y7eYl659FrkP8WXLfJIgr64VwdK+uOvo3ImYcU7LnP4SpLd077s66iBdhQgTolNlxgId2zHzgK9TUxh955S1Xi8e1l7UxlMkmW4Ud7N80CLgWxUs+M1UaiVHkVRkBDe9bwgh5MSaGewQk246TGlBzaBRRtALxqV6Z3HQnBi4bdX1zkLHBZ3CWbN7d+Jv9WAd2UHcCa4I7rTJ/XJT8oyJ8xzT44tttbY0N+bSwghylL5svjRgoqp37Oe48nEnYU6cwenxVIt6Ep6Uh6yS+jvScnytVY2EV/YdkFXH33Bi4gb/179m+X7nddz5OclMAI5+hJVvEj3u2OXKAAcx0Hfsvc9yc1Byr1oZnwD3aw3BLyNVPzXjZsGFQzyp88iEQVl57Q+Y1GVWugyH3U2Xggt0FEXqVOpH4c2JzgdVJFW7pmwTLgtII8ALV7dVaKbv/y9TF1IBajDlDPRM01NCcQ6yaypaBrx6Vav85/3+dR2TULlTNBDZwOJ89g4wKjHRKIaL2WNw9o4Jb4V9YuowQXQBqpMhVvORFTsePBp/X45Yox5wP0tgcRA9hhlAFiQqxSAUT7xuCywWB5/ckMu711AxaQbzqN1+EjiV5u9YAdMfi0Ln443xcRI7mefXt4ByXczlf8SJyFMf0xShbxCZmqnfThlsVkLV0nMVr/LxLZ/gmtlVDOOh9FFUVZR0qjT2K2MVNmf3bEoyQP2Mwl9wYXQ0J/GCKOeVWnOUJLUvQfn9eBt9rfJSAmNPG+g1TW0P48ADCni156D63R0WI9tEA1yhI3DhLGt5fjLvL08/JQo6n35HOv0qRCwkTpL5rXy5KUiVVuVUkWzkqYu+duykT5GH7N8gdOB4zy53fbWXtwdOA7V8I1RcciMNWIUsvi/XDrIaCsWYswQPU322vBFK3wLky0M1wW/RNZhip9tPnSXq5XkXJ+9IG+8HhiMhckhp+uHQ3k2W0Brelh7Pt4q16bd0qnmRcicjsS1Mv17ZbaQDyvp3wgyXGe7ubkXr/ttDaZDw5oPzmXiI1l4Exeu2AvILzde2pQms6uSMccivMJHaf7QKZr/Wl8qzkP9QrocHld0h3wW4FMVayZcYtf5yonGymVK1b7iEI0gQA7aolXmQOpee5mOFybrSrY7zZ92A7r+vVmGQ4JU6AIAYplzVdOGtXIB5rxHBzTTNGmBQJxQ/GYv+ICCw1LVUiGoOF3nyY5CNVua5PEdnBHRln6Y2Mr6hIuTtpKkKcKA9ilyGKLiigU/LMuB1bo+lNR4l8E6YpT5p4Z94fnV8bNrAHIZN0xc2JHzelgXC/rYWyC3kd2/xJDtcYwBFI+jtwU4zU3UzDZYOm+mN3tn3SU/mi3oZhBVWhQZgTYqD0DPgJn7ZfQTBFRIkqMtB/UaxBCM4GhnU9hsbQbzVWHZpomzgtOrKVFaVfkhD0xkpJCDDzy9pyMyrkdOEcaAYq92QwBfL+dg4fkPRbDPzd7R/i9HacP/oH/qjLa84pn9LOXUleBCDMOSh6eLE6p1ZY3RLanCZF3hfzkYGpWHWXixbzXKiNIpHsCd4ULOmCAf0swYdytRRxaKfcnWi0+eY3yyEqbSEtqXdiTnKJTkwWmsH8T060JWyuseWVh622hQM+w+5fCSZWOmltMqlXFiG5t53wUfKX9ziUdMHycQizH/dp+WN8bxfrj0g+5aR2Jg1wcnVEdD9hlmYjb3nA5b6r2WdQrdR53fSfnbkN9OQQ5bIt3jiaULkzJIz0omWgyJs+moUWwLDkEWiB00B/qBjp4t0iiirXSnb9Lj+D68r//EChvFeEqIMMfD5D1Y8S2oGlUVVJIxDr9DSnQtelTR9bLZRMr+tfUnGkXlw8Jnf014C3wg410YwPqwcLKD6USTrTJty9sQv7Im8xW67xnEyIVPbuK3SfrpsHCYmppe5kcmuQhsHp26xnq4pK7DJG0dBHBSgMaFE5phBKDjtjfkbJn2SWYArwOjHx3+pDrYOj3ES30CD734gSYRZYc9H4iSm36kuIuf2AYLp6hcmKJnTas/ItEdk9yehUv8qMInhR56u1hi8Xn0I3e59vsw/y2C9ab0eRLiaZDMbELY0E8hI4bgeUJsXGSmc2n2hYZT81b3/kdMKe+d55KWWEtbkF79pB4QM2KbxY5tPnrQDT7Rg3wJFu/tqfRJt/badowzfYfRwdRp9Fr1Cyd1QN3R6/cjwmpKubxCP5L9DPIBTodZRui4HDQFRIpMCNAyBKh2GKUxqEKBKDctwpPuhaG/qnl5OpB8u18DevBdkAPkURcVm2XQP05i6lY75Rti7b/ENzXZN74fWCO4gGYhusIJIJXEXhhq4OIMOKZG72RWu/OfOP/hgGioJuzN7i5Q8YCk3xqUmwK89Et8pyMGRGHzgd6CWYtreFP+hhlT7MRGNxVgr5+FNR8dUBTQFJeXgdAYvalpW/QZMKVe6Ha+mvTD8vnVTJacwAAAJS9jnDHB0tPAAGiM8VUAAA2PiZbscRn+wIAAAAABFla"

if __name__ == "__main__":
    try:
        main()
    except KeyboardInterrupt:
        # We don't want a KeyboardInterrupt throwing a
        # traceback into stdout.
        pass
