#!/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 0.4.9\n" \
              "Copyright (c) 2010 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+Wj4CpsGaldAEAAyynXgKBkJ1IWv/boY8vTM9MktbLOpatIGjz3QEXi/jpWYIhyvau9pwPzxqg+zs296STl+/8J9jeemizbwLGMBTI9pIzct7Swd/5EjEobZyOupKPix5m29r3bwHsSpn0YlkfZRcwqhcVkjGpEGOaEIiKZPxWY+rgtqKHJ9fgVNQBwND/mDAjse6c9G6rhKxKFzUz3KoAGC5AIG+3mY/dotHJ/lLzHJ1NtbQbXLmllYEw1loJ2tZGek2LXDq7+a2pBy9Cc8a+POcXlxHrNA/YXOHc8KCkDFwBCJeinKpaXLFFZ7ardtLyHhJL9TJE9R56WgNKGf60Oq5nzyR9HtyuBd6ERkFKV/5PR4Ff1aTHwcC2e6eN+wtpViAplQSdqduzNUURwsgb17oou7e3WS/WxgMBqckCfdTHpqpRumakY4wyAx4fPRW4m4Z5DF3w3oRYnMq4np5SGj3KoGLG+gSbhaQYGFsJucxrrLX3be0SLu4i4VIADvZwjWtWQTFpowcoNKstGif1RPFVq+PF+Ey9zO17L1G/XGfRDPJgXFF+Zg8y559PHm1lPVTujUUpKbXvN4BBz5LtiggIzteZaJAU4nmE0/542w1d1qZe6Xh3NZO1FPwmmgRIutQcKX/vDeXu4pUH/MXL7N0PI1WBPAxn+p2dbSsNR7bBoYlardY0pe5GDVyRXFjLJRLc3Um6aIIaR3lJ5G//UFpIlOhYJkOFy/Rw21W3EK4fRSgEDCcFeQdO0eDFDggMrpYli/KcpylX1ZgN0k8rKdl+OgfIQtXNfmtODJC3DjGLFWsl+cXH06vfYhN/EiuAVPiL81AMiSfO6U8n09eKwOhrq1isDbk9u2cuW5izianhYMHGWNv47LYC7B5WY32aHA2ybyYOD3ym15g2KTIYpwGVnGY9n3uWdVRrLC85wfmZf58QiCS2hbs1ze56FXvA+POqEawPYePi91dv/Yu1pwgh36uK6whjvwshp7dTIwBRy93tezMA0dlddKWLSmpNFv0lkOt4yjIZLp/RljH1sY0cRa9FyZC9mBMT3pu8FB59+7F8jLWiEAhp8wLwZJbGPjymN+Dq1Vd+EcHHCq8DjXApEPSrOyUiuwIlqTaSwtFuUqdHnx2yqNhy2o/LJ5Cy+9mj+P23Hple7S87zc1YW2+Nmcan613NLg8Jk7L9D/czcYyeHu9pubw5cTShBFXNfHPomADcPF62/w/7ZJ3ETaBt/9ScQJXwNBDpUSQld7RRdZwoV3c+K17nbnTWrLR0lcQAAog9DDHeIsnWCzfUICOE+9JW9sLydUNqom7Egkzy1GVZmyX4/WFjfUTDEEZnYGXL3JBKLVh2c42LxOZuA6EoRC8ka6kC5nhkTrW00NSaX1mBml9st/VMtw9tUvsyxmaBA6TuYmJcEcomD+LVkMxsKjJ1gBv74RXdRV4abVdkKbX/lHOmaI3SFo2i9SYrkGML3abg+5hbUV8wzHYVubUAWRngGzc0DgCGrrk/I+60QBjHYdedNWOfjOmrnad5oJfxYQc+el80nP4AO6EG9ki4ponH7tL+Lj8DKD+9ORKRXwDFQQhb0F43BgeNWQTHlO5oNICdgxU+/0/ZJ6h1RwgvnGOB2UH6mcf0pAQqQ1ucwdxJbGRH6Ho2uxVvP/WLhb1tWOISqZWiQYtxybcQK5F/EepQBCwzWDuDWqfq5frtvgv+P3LXsJ70ohW/CfFXl3jPy50Sk6lgqol3VQhflF3Ey4pdYAwmhhIyH4OZk+U0dV81sIrtKpqfQPR1fAF4MKJaje2ZV6LUcAbZE1Bv7DmOhF7Ci07BK+RCtyMppF/dOH2SUWfu+5cihG33ETkAuNSiokhUYskbmkiGFzZ2rLCyZnD0pGaR8ME/kGxln7gt3fqz2ndKIRmrKzh7vYwqo8dHqSL4URGka7iWxu2uuiN+DSLBHz3PY0UqfC2XB+K92gfM1ZabgG32tLS+HXELPTqbS8r3oIp7MdzrE76X5fNTETX6+1irZ3YLPSdneqcgA421FuOmSbxyKURVUczj58m5ZmYvoX+dV5yOPav5hcOKif4w2jJFEpK1ykLUYW1iixlfrHqQXdW9pHhCzQSXIFjbmVzfHP0UJsylKCEn8gJCYp49G68f45GD+sv3F7LHQpn6dS/KVT9CHH2h7N3z3Bqq0xkT0776SCrELjkXDK2gnCFhJNROWZfqV09ApBSfq63ehzEWyYW6cg7mSMnVryhqP9Aqaw3Ss0c910D4wWPgfMnW14bjeSY00TXkTXwXwgKNpl8T/UqwJj2oBvNmA79NpMO64M7hekJ8Do8YLROOJigPYKwlqQsHk6Fk5vdN5qmBZZ153hNdMJWsit1WnORph6RbYkoBPLGW7oJTNgvNEilV3g4mJHVfM7Deu1I6QQL6JTJS9i8vwZ53qLjk3VNUdG5cK+j27VwsyJ3ABOlo8plaiec7KxqxKQ3q+Zban6Dkann0S9glRRJXUsCY5Ek/fxVmhp2IbK7hN/pA/BRjheuK8jdDPZvl+KILvLzwopfS1imU8A9ApGVER1SHcoSk5AuiCThwb+d1aT0ZomEBXvKcS02aE7klcrw+4aByGb+LT6R4BwpLGsTFaJFRY231ShWteOmfsuqrnS+eOMBvehip3ysswaZyIlC6fDo9FrDVkWWXjtpjTuNORfVhwHT3csxGdbgcuahLcwSJBp5rUdJ7DelxatPAeZMrJQz4wf6OypMz1OI+BLIbJW5vAaME+odoM7UHK1Km26BWlX1v1C75ulma/Sa7Njn1KbZFLi8Z7+6pfaLkjM+XkcQvsOkPCW/SsPBOVUimfS4eOUwRGXIm8K6oCGb2oh3nRnrO/VwBkGsZh15P6uJy9p/i+h0Q9c5nOR8zF62mAVItM83NOaI0bYjHbx2Do5ferW9ww7q2o8BTuQ7MsebyuZd+2V6i4KkUtmPK9PZyayYsvyYS30sakva7ABSZK79tbagDF8crhQjQ1tN6OcvcC8ff8o1g+gkUKX5FQtgOI99Fq2MvDPst26hAX7dS2c4P0Z7UJ7v6BRwN+wArCupU0hX79xSyuSevzCOtRMlxByYvEKBfvlTu9VrQkbyuUIN1wJel+eIvpMtmZZJii8tdJ2VfmHAe6bbT9MHhatjiyXGiB665yZdix6ivcbamiYqZwWuJVcc0LWNnHsFiwH/nZw70AqRtcJrd4yXjNjAOr0yznexzu1jPJJ2hJggvcaiF/KzW+j908ZODl8AG0DuTm7W+mmXaWOHv21qUBLF6yRFlakhw7Ee9YmNOWWnrExGYAIFER9KeKjFBDiY/bhtKFROXQiuJLYYHKRaTqwsQFnmQVAXebGxXLJIwx3sMHXvr1r0Jkr/DxY9Y19hlZK++c4rf00UEA5V9d015h2ypdsYgnysgvjmXJThG2WENBEYHE3HYoEciRGElnr1VrL6KM6L+VNVmxYbXK6YvXAnVM96MprOMQtWeKirzabIhQQ6ROfDTtV9C0O9M2opus2fZRYT/hrViqmnO/YXEX8NTBNsRo7fDZlrLVCzbkBlJ2yDMrCpIe84zjhsPD1hryXMrprT4XJ+itnJKELlFFzG9e+dQvobnznclGB7uYFExsOH+SknsWkea7HgrVX3b32Dk6QiNZ0hF02Gox3N2nU0rLLmodzjqc5kOt0pEEomGLxlaSb8Qs0TeIxUrryEUUKu8EGDAG7PNlkkTW5EV7JRZK/Q5zJPPBkoTyCl5NS/YK4xLPrJvpLeq6vKWx/U2SlcPGhuMCyuv6jAAqXVHTev/LU/J2+C5reSLSLzfE6GC/k9xx0JSonnAqrfyuo48a8/gvOpwIz/b3TWRgWbmVlrqvVV/1Q+xBPiaD49KpLqXSbWmUnJwUySffe78f7YraLXqW2kC0Igl0h8BslSJ/PBbkvVNPmP6Hya7JMgUfWdw5XUyYa64ztlczDoMgMREdgI5ldMpNhNVEHXy6+9pBsMhdrHrWcs3Pyb2GVyRtys6NMByoy2japfrNb3z/GweZlfaBMyAKJ4x390yIvRJi92bDjR7pJbJlLHibW2+ywVBdM+qkvEpXx5KOkZkJCTvnIH1+npY9BYpxnKr3z1GNibopyUcB8pZZCbN0+TpeJJyO/6rCHGyYf+KRgBOQT+TCujhPCchkl3oP+pmP1GT70CRDlo4bj7j2a08xRBRlYf5Ugr+lTk1cE/kD8bVQesuTlRrEYuvxFLHwDamvxIFzr1z+gX0OenadfCpJxynbp8/plSeKsHsWrrmXefYe8mCvbBCJb9DOVq6/Qg18XVYxsXP6rvmDsiBKLPYWZHOTIn7JIWnUdHPtbPhoQYQXsQl2sl7jeGgYpmCrwWCxakgaQ5zVAWEL1k8LT7buk86DcOZ4vva5Vn000PjaEJWnnWaV29TLzhShHB0h+Hia1UT7KHM08JRJ2A4g2QlRUKrUXDouRMZQipXR7bGVnnnFCSNN25IJ/Kr4c2R7a1bAz79UJKhWPIRBnvDcqDh1k2JycDj0Ok+3xWsYGw92+JlioGi7OtuJaFFDDKTFz2DX8rhuI4fFTNRRM+YiM1IDnAkwM3j4CgWQ0xRc1rtlb+iCJ7bVba4mCeYZkjtP4tONOUTKAoHUJSfkBnaJXo9RK/JD5cUEfQFae5DQ8BIYXcx1djstZnMasPraSO4XNiA9osvglcARzI7GwCCX3/nDP6ehOz8ZpFiiKCeZsgia2MGVCqQAs82cEj507tNN4NobsbuA6yvXjA1JoEIiq7UenFJSj5w+mjHzVMCZHDlY9ZcbDmGfqDOQe2K5YJwHD7Fak6UyELKnnnHOK2aKZpIhoShaLkB2swFAggsyj6lasv35icPLzLm3pIlcDFYcd2b7nRXE8W3DYUML7LTbFJxrpFt0ZjCKMC39+pmAYKwk07rlgwtF9gN783if+xu8vR4O5wxJm+Sf95bZNR9f3ch6TdKNbEg+mThZFASyHnRQ8P+PZ2rj80iVAZqKEO442ASD1zJfVS+9j/iqjNDPzM5UoaD/Ac/UvGf8Ev6saBBJmRKNr5dwEllGcyc3NIL7qZAhIoRGeLrcxtlpH++9Tu7FWZcTOhH0XR3UrChbsWyRy4tikyYt8GHCCK4/4cYb15xVwtl8WHGZOvXOgQadz8GoLxgpPyaaRNnf8sOZOsuOrAeTL/oes/bIB4ow6rV5A5ePEAt580TAbYHdhE4lEEthERqAMguyPtoyUfds5IbzJ0VZZ5d9UScs3LMI8E8U0q7IMm/GwlR9y33B6/NsduHby0wSP6K7+GUyAnCJ4cf4apUeZW+mgKd7EfHpfpoIPHjiBR5k+Q+jWE1+u4gw/vmD4uBqxaiN2lcsgw71HwmaDv2D67RR7CoHdePz5bExaXIyz/NXMCwqhRCGMAo8nMFjtlFs9FhtXDNtZr64ZKzSI/MIhkZcg2GzWMp/i4RM1iVB3lk9NN5H/hfG4cvW6kPB9Ivm0NeIw2fbA3BXXCPLhw7EMw+Z5jcYGBTyLFsItoYZjvvf5nb340skWJhqaDAkwwbnlkEoJEq7IjLDpYJt6INijkHf5KsZDEqcxa65/t1Vd389PlaVjSgPfiZpG7v67aOqCEyWT0NCO9rISVD0kS4BTdL+HicUSqO/bB1azQpdhqkhqIFcSnJWkjpC89BEIXIs2jC+SQ6aKGW8nQeNFFn1Mww43dnjcnTITwtQye+jalAFpuHTu1Wewr5Zb8bHZhIjUFgvctp4qjLZRcEZclaA6XHNQ+O+3IrUYaT0nH7jcJFnQW439URtTPqjZZqb6hz+8ygC0+4H8txa07HgnA2G4lc4wwb1NFN4ilHorbEuV8GhAqvc4ZDLQ0kei7a5r/gOY/ljkMVO0yMAaRPHcuufBULDBzme0dXLHttakUluMqWOcm99xYLvITteklM5QpyCLtyhXvuNLLSJn+jPR5fQDrGze0MLhYddcKtDs2JmErqV4GrjBYdigVaKhodca80gXK9M2sRNawi+ueeJHPbSHdhTY0a2tz6RE5Y6o815Vy6vQM3vc5gFgGstYf8iqAo8L84sVCqfm+6z+BFCLXMzeVL159zPHJ8nAP40fe5v9/9Mpz/1SnSeS/gSmdKn0zE6cdHTibp8IT+E+Ay9A+Gq/dSgF4HdMLiEj8WeMzRkFGcd7gxlCh6sbgP98rfMitFPqzh5mRBIZQBgp3+g2z5T0sf74FeLzws7DxYRbXxRhmP20QjH/2sqgKkv9FHBIEXwo0lKfaJdqcI+a7K3GRv25kDqeYU59AJVliP/TTKo2irvA3AMgHwJj34JOfkVXvBPA+8+2LKNehshqaeRz6oeNbVRyvNJpu1cIJyNAUqSawQr5+JZXO6KzoMrzCqmSpKtgQXQ685Ztmba4nGPdgIy2xfTQA6/pf3N42TcAY+u/XIEKGWA9//NmB6OcipFP2cpYey37Bep4Qq+jkQjgVZ+4nwAdrvlEDuhXGbS5XBbIejDRJvchlNLBfHa1xduM5pOqO6QzvOIjs/ziQsYiFi4Jx2xVTmmrOV4ddIiXXkKabM2v/mxfHPlyPk2NiB2mIFl4ztqlp0y+E2B8AzYfqVMfj1zm6jHElnN4tHDBXp4UVQa2jgqaHUI/aw8XeOQrGrMPhyogrDbpyIBd71jVcR0THQQKZH/VvgoxyYIUT7ka3WUI2B+fpkLmglY4qwRdm/Rd02hlvEaY0D1Pwi3PkegTUnbaTBTDZ6v8FyOAUVjDAOWlqkVxfjnd84HsCtMPx2SxVbbF7iQTy3Hsv2UcMC2Fz8nsuXY4Myb5EqoCJwG8WK/PdgeLgU27W+yPWZz/4+vRXKW8YjPJkT31+8iu/qVVwCoFjCov3FzipVHjTFsp+3npF4FTfoOz96Txx1DVNJgdecQbQy6vIO7uvq+ywVvxtLHaWy7Vu3gnTixJOpc8ytfCLUNq6OaY0uxN4Dr7iDf1LvP70fopoablUG84mzcL3ON83OOL+3f2TtB1vEDrQQSP6DrrX7tyI4zvDTEP9fG3yzGZNl0CqrueXwjSgfK0Qc6cmo3NoGETmQVeZXWz5sdGiIu2JIhzOVKh6TaK243rcbYcjQwwim8FsEJg05c/rzkM2TMDD7LZZf6LtE/ivcLcFqXFGyyJrI/oyRzyst8FmDyuQZcomODBBAEFxkwNJi84nQo8vFuVDt+9hJTG0G1gnHP+bvelewUvD/TiSgrugqFIR4f/lCiGaBWvI6SRLRsc1pHL+8z5b4tofryiJO3w5/I9g2/3d4b9Nk7XdyHd8jmj37SP+mYixcqLAoV5WlCqCdVO5cc+MKyz+ruMs/kOTH7wFyiE4s94tF5tmEZOtwLu7YVGVNSX8U/5ATGP1eVPq0hw7IgpVq5UEtI9kFvbtvadbwkfbvFsR/ZRgWIX1KxKcN6BguxjoxCe+fOe4zQiAqa+GBprxeVC8HirdanydAmIHtkdFMF03NrLEPMK422E2OH92pt9QeQOz8r+JkiwzPh8/RVLW8FcW8v6X3x7z4Azdl0Bbhbtyik+sq8oS/2jtVYqZPxqtsTPgB75qvjTjCAy2HAelnm/6y3W1omLGgT7sXESvw8cZEt0f7U1WSuec1b3iKlZBpmV4GcpmKV4M1vXzIHTheuZnbyX/UV578NIaPUvlYiV3qb8c++tQv8giuOxZwQt/36iUig48v76NQFNWT2aMdcFH1+7XOCXE5IPsdO1Hvlkiugr8mfYLSjXy7/SShM90aWNzaeJHqrmmhl6xQIApHDB/85auV9+wllRdfpc3wRZDBn/liTWX16vR0q3NYLHYtr7kW5adhdabAtHHCLJrsObarxKM//o9jDE1zaN9dLB23A1mGpo4B1LBNZjPhfbxmDIVTyV3zdPaSI3bGz0teQRVwH6ulFvWPL2iDdN92G6DErd6tm41fNY2m17sQYHn+zBEPod5cXo7JZhHaxINoLDPVFFh7fgOSWqiDqBFAuG2STPu/X/dI7E9SqFItNlPBx0hMkw8vtS7iJ4n+N2SeknN3NLZzDAxL+fwCTl1xO0ZD2HRArf688dNpD96F8RAVmnrBbJ3qIYL88OkloMr1FQTYKU0qtLGe+Rs3RJpUuD9J95W/kdXqLdcZaFeqHLstJA0ZlL2kV9/m8U/x6g8v5X/yQWChAVm3e03xdBo89/vk3TwKwcmRzbahYHDZEwpMIdo048oP68qKd0cHi4bXA/Y4uelj1qyL6V+P29eNGEVhfVCMS7F+uSGF7hioyw7qBQdj6y3tjnLvlfKqkHR+RbBa0h0uXdnEGQs7N3W3Jl6fBthhOH+ByCHw9xPNHkhg02ttOKLpoMCFzL9IhY4gA8upuODarrRa7yYLfZdmJWbmkHroMBvn+fSddFkIVRW1PmADx7TQixz1Eq7uaUgOBj9f1OtIY8FdEaZmp6tkT8s7Pa1Zp+choNduFFYJaTBNs0jeYBBbWaZ94OEi9HKT5SXzczLGLg6ZOjGqzP41uJSHmGEpy3A3Q0qel58iSa7XmpIHIRwwvUmqRywbcEfQCks3evAJWuW2jmGgWuYU4+SffKghdwE1xGa61pyjiIz3OFalcIj42c5QWqimrdU9W7BWSmwqZCNTGChUjuzSy67vCzuNdN0VOT9gyyepjOzv7pFtIL+62QlAMLLt2ZY4ZbVNv34nhmzkqBGC0hqSvSjmBI0vSYLypQTh2picnlP+9INF1cGhs+OneyBaNsnMUVVuIQ44OHJw8xX8W4M/S3luBZHYSqvWIbv6/hQ7NjU44dDLeWUxzTkSrUV/GAAAAAA6Bgu2H2p94AAHFM+1UAAAFhlErscRn+wIAAAAABFla"

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