PyQRCode-1.2.1/0000755000175000017500000000000012731661302013036 5ustar mikemike00000000000000PyQRCode-1.2.1/PKG-INFO0000644000175000017500000000727712731661302014150 0ustar mikemike00000000000000Metadata-Version: 1.1 Name: PyQRCode Version: 1.2.1 Summary: A QR code generator written purely in Python with SVG, EPS, PNG and terminal output. Home-page: https://github.com/mnooner256/pyqrcode Author: Michael Nooner Author-email: mnooner256@gmail.com License: BSD Description: ======== PyQRCode ======== .. contents:: The pyqrcode module is a QR code generator that is simple to use and written in pure python. The module can automates most of the building process for creating QR codes. Most codes can be created using only two lines of code! Unlike other generators, all of the helpers can be controlled manually. You are free to set any or all of the properties of your QR code. QR codes can be saved as SVG, PNG (by using the `pypng `_ module), and plain text. They can also be displayed directly in most Linux terminal emulators. PIL is not used to render the image files. The pyqrcode module attempts to follow the QR code standard as closely as possible. The terminology and the encodings used in pyqrcode come directly from the standard. This module also follows the algorithm laid out in the standard. **Homepage**: https://github.com/mnooner256/pyqrcode **Documentation**: http://pythonhosted.org/PyQRCode/ Requirements ============ The pyqrcode module only requires Python 2.6, Python 2.7, or Python 3. You may want to install `pypng `_ in order to render PNG files, but it is optional. Note, pypng is a pure python PNG writer which does not require any other libraries. Installation ============ Installation is simple. It can be installed from pip using the following command:: $ pip install pyqrcode Or from the terminal:: $ python setup.py install Usage ===== The pyqrcode module aims to be as simple to use as possible. Below is a simple example of creating a QR code for a URL. The code is rendered out as an svg file. :: >>> import pyqrcode >>> url = pyqrcode.create('http://uca.edu') >>> url.svg('uca-url.svg', scale=8) >>> url.eps('uca-url.eps', scale=2) >>> print(url.terminal(quiet_zone=1)) The pyqrcode module, while easy to use, is powerful. You can set every property of the QR code. If you install the optional `pypng `_ module, you can render the code as a PNG image. Below is a more complex example:: >>> big_code = pyqrcode.create('0987654321', error='L', version=27, mode='binary') >>> big_code.png('code.png', scale=6, module_color=[0, 0, 0, 128], background=[0xff, 0xff, 0xcc]) >>> big_code.show() Keywords: qrcode,qr Platform: UNKNOWN Classifier: Development Status :: 4 - Beta Classifier: Environment :: Console Classifier: Intended Audience :: Developers Classifier: License :: OSI Approved :: BSD License Classifier: Topic :: Software Development :: Libraries :: Python Modules Classifier: Natural Language :: English Classifier: Operating System :: OS Independent Classifier: Operating System :: POSIX Classifier: Operating System :: Microsoft :: Windows Classifier: Programming Language :: Python :: 3 Classifier: Programming Language :: Python :: 2.6 Classifier: Programming Language :: Python :: 2.7 PyQRCode-1.2.1/PyQRCode.egg-info/0000755000175000017500000000000012731661302016156 5ustar mikemike00000000000000PyQRCode-1.2.1/PyQRCode.egg-info/PKG-INFO0000644000175000017500000000727712731661302017270 0ustar mikemike00000000000000Metadata-Version: 1.1 Name: PyQRCode Version: 1.2.1 Summary: A QR code generator written purely in Python with SVG, EPS, PNG and terminal output. Home-page: https://github.com/mnooner256/pyqrcode Author: Michael Nooner Author-email: mnooner256@gmail.com License: BSD Description: ======== PyQRCode ======== .. contents:: The pyqrcode module is a QR code generator that is simple to use and written in pure python. The module can automates most of the building process for creating QR codes. Most codes can be created using only two lines of code! Unlike other generators, all of the helpers can be controlled manually. You are free to set any or all of the properties of your QR code. QR codes can be saved as SVG, PNG (by using the `pypng `_ module), and plain text. They can also be displayed directly in most Linux terminal emulators. PIL is not used to render the image files. The pyqrcode module attempts to follow the QR code standard as closely as possible. The terminology and the encodings used in pyqrcode come directly from the standard. This module also follows the algorithm laid out in the standard. **Homepage**: https://github.com/mnooner256/pyqrcode **Documentation**: http://pythonhosted.org/PyQRCode/ Requirements ============ The pyqrcode module only requires Python 2.6, Python 2.7, or Python 3. You may want to install `pypng `_ in order to render PNG files, but it is optional. Note, pypng is a pure python PNG writer which does not require any other libraries. Installation ============ Installation is simple. It can be installed from pip using the following command:: $ pip install pyqrcode Or from the terminal:: $ python setup.py install Usage ===== The pyqrcode module aims to be as simple to use as possible. Below is a simple example of creating a QR code for a URL. The code is rendered out as an svg file. :: >>> import pyqrcode >>> url = pyqrcode.create('http://uca.edu') >>> url.svg('uca-url.svg', scale=8) >>> url.eps('uca-url.eps', scale=2) >>> print(url.terminal(quiet_zone=1)) The pyqrcode module, while easy to use, is powerful. You can set every property of the QR code. If you install the optional `pypng `_ module, you can render the code as a PNG image. Below is a more complex example:: >>> big_code = pyqrcode.create('0987654321', error='L', version=27, mode='binary') >>> big_code.png('code.png', scale=6, module_color=[0, 0, 0, 128], background=[0xff, 0xff, 0xcc]) >>> big_code.show() Keywords: qrcode,qr Platform: UNKNOWN Classifier: Development Status :: 4 - Beta Classifier: Environment :: Console Classifier: Intended Audience :: Developers Classifier: License :: OSI Approved :: BSD License Classifier: Topic :: Software Development :: Libraries :: Python Modules Classifier: Natural Language :: English Classifier: Operating System :: OS Independent Classifier: Operating System :: POSIX Classifier: Operating System :: Microsoft :: Windows Classifier: Programming Language :: Python :: 3 Classifier: Programming Language :: Python :: 2.6 Classifier: Programming Language :: Python :: 2.7 PyQRCode-1.2.1/PyQRCode.egg-info/requires.txt0000644000175000017500000000002512731661302020553 0ustar mikemike00000000000000 [PNG] pypng>=0.0.13PyQRCode-1.2.1/PyQRCode.egg-info/top_level.txt0000644000175000017500000000001112731661302020700 0ustar mikemike00000000000000pyqrcode PyQRCode-1.2.1/PyQRCode.egg-info/dependency_links.txt0000644000175000017500000000000112731661302022224 0ustar mikemike00000000000000 PyQRCode-1.2.1/PyQRCode.egg-info/SOURCES.txt0000644000175000017500000000035612731661302020046 0ustar mikemike00000000000000README.rst setup.py PyQRCode.egg-info/PKG-INFO PyQRCode.egg-info/SOURCES.txt PyQRCode.egg-info/dependency_links.txt PyQRCode.egg-info/requires.txt PyQRCode.egg-info/top_level.txt pyqrcode/__init__.py pyqrcode/builder.py pyqrcode/tables.pyPyQRCode-1.2.1/pyqrcode/0000755000175000017500000000000012731661302014664 5ustar mikemike00000000000000PyQRCode-1.2.1/pyqrcode/builder.py0000644000175000017500000016114112716012360016665 0ustar mikemike00000000000000# -*- coding: utf-8 -*- # Copyright (c) 2013, Michael Nooner # All rights reserved. # # Redistribution and use in source and binary forms, with or without # modification, are permitted provided that the following conditions are met: # * Redistributions of source code must retain the above copyright # notice, this list of conditions and the following disclaimer. # * Redistributions in binary form must reproduce the above copyright # notice, this list of conditions and the following disclaimer in the # documentation and/or other materials provided with the distribution. # * Neither the name of the copyright holder nor the names of its # contributors may be used to endorse or promote products derived from # this software without specific prior written permission # # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" # AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE # IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE # ARE DISCLAIMED. IN NO EVENT SHALL BE LIABLE FOR ANY # DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES # (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; # LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND # ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS # SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. """This module does the actual generation of the QR codes. The QRCodeBuilder builds the code. While the various output methods draw the code into a file. """ #Imports required for 2.x support from __future__ import absolute_import, division, print_function, with_statement, unicode_literals import pyqrcode.tables as tables import io import itertools import math class QRCodeBuilder: """This class generates a QR code based on the standard. It is meant to be used internally, not by users!!! This class implements the tutorials found at: * http://www.thonky.com/qr-code-tutorial/ * http://www.matchadesign.com/blog/qr-code-demystified-part-6/ This class also uses the standard, which can be read online at: http://raidenii.net/files/datasheets/misc/qr_code.pdf Test codes were tested against: http://zxing.org/w/decode.jspx Also, reference codes were generat/ed at: http://www.morovia.com/free-online-barcode-generator/qrcode-maker.php http://demos.telerik.com/aspnet-ajax/barcode/examples/qrcode/defaultcs.aspx QR code Debugger: http://qrlogo.kaarposoft.dk/qrdecode.html """ def __init__(self, data, version, mode, error): """See :py:class:`pyqrcode.QRCode` for information on the parameters.""" #Set what data we are going to use to generate #the QR code self.data = data #Check that the user passed in a valid mode if mode in tables.modes: self.mode = tables.modes[mode] else: raise ValueError('{0} is not a valid mode.'.format(mode)) #Check that the user passed in a valid error level if error in tables.error_level: self.error = tables.error_level[error] else: raise ValueError('{0} is not a valid error ' 'level.'.format(error)) if 1 <= version <= 40: self.version = version else: raise ValueError("Illegal version {0}, version must be between " "1 and 40.".format(version)) #Look up the proper row for error correction code words self.error_code_words = tables.eccwbi[version][self.error] #This property will hold the binary string as it is built self.buffer = io.StringIO() #Create the binary data block self.add_data() #Create the actual QR code self.make_code() def grouper(self, n, iterable, fillvalue=None): """This generator yields a set of tuples, where the iterable is broken into n sized chunks. If the iterable is not evenly sized then fillvalue will be appended to the last tuple to make up the difference. This function is copied from the standard docs on itertools. """ args = [iter(iterable)] * n if hasattr(itertools, 'zip_longest'): return itertools.zip_longest(*args, fillvalue=fillvalue) return itertools.izip_longest(*args, fillvalue=fillvalue) def binary_string(self, data, length): """This method returns a string of length n that is the binary representation of the given data. This function is used to basically create bit fields of a given size. """ return '{{0:0{0}b}}'.format(length).format(int(data)) def get_data_length(self): """QR codes contain a "data length" field. This method creates this field. A binary string representing the appropriate length is returned. """ #The "data length" field varies by the type of code and its mode. #discover how long the "data length" field should be. if 1 <= self.version <= 9: max_version = 9 elif 10 <= self.version <= 26: max_version = 26 elif 27 <= self.version <= 40: max_version = 40 data_length = tables.data_length_field[max_version][self.mode] if self.mode != tables.modes['kanji']: length_string = self.binary_string(len(self.data), data_length) else: length_string = self.binary_string(len(self.data) / 2, data_length) if len(length_string) > data_length: raise ValueError('The supplied data will not fit ' 'within this version of a QRCode.') return length_string def encode(self): """This method encodes the data into a binary string using the appropriate algorithm specified by the mode. """ if self.mode == tables.modes['alphanumeric']: encoded = self.encode_alphanumeric() elif self.mode == tables.modes['numeric']: encoded = self.encode_numeric() elif self.mode == tables.modes['binary']: encoded = self.encode_bytes() elif self.mode == tables.modes['kanji']: encoded = self.encode_kanji() return encoded def encode_alphanumeric(self): """This method encodes the QR code's data if its mode is alphanumeric. It returns the data encoded as a binary string. """ #Convert the string to upper case self.data = self.data.upper() #Change the data such that it uses a QR code ascii table ascii = [] for char in self.data: if isinstance(char, int): ascii.append(tables.ascii_codes[chr(char)]) else: ascii.append(tables.ascii_codes[char]) #Now perform the algorithm that will make the ascii into bit fields with io.StringIO() as buf: for (a,b) in self.grouper(2, ascii): if b is not None: buf.write(self.binary_string((45*a)+b, 11)) else: #This occurs when there is an odd number #of characters in the data buf.write(self.binary_string(a, 6)) #Return the binary string return buf.getvalue() def encode_numeric(self): """This method encodes the QR code's data if its mode is numeric. It returns the data encoded as a binary string. """ with io.StringIO() as buf: #Break the number into groups of three digits for triplet in self.grouper(3, self.data): number = '' for digit in triplet: if isinstance(digit, int): digit = chr(digit) #Only build the string if digit is not None if digit: number = ''.join([number, digit]) else: break #If the number is one digits, make a 4 bit field if len(number) == 1: bin = self.binary_string(number, 4) #If the number is two digits, make a 7 bit field elif len(number) == 2: bin = self.binary_string(number, 7) #Three digit numbers use a 10 bit field else: bin = self.binary_string(number, 10) buf.write(bin) return buf.getvalue() def encode_bytes(self): """This method encodes the QR code's data if its mode is 8 bit mode. It returns the data encoded as a binary string. """ with io.StringIO() as buf: for char in self.data: if not isinstance(char, int): buf.write('{{0:0{0}b}}'.format(8).format(ord(char))) else: buf.write('{{0:0{0}b}}'.format(8).format(char)) return buf.getvalue() def encode_kanji(self): """This method encodes the QR code's data if its mode is kanji. It returns the data encoded as a binary string. """ def two_bytes(data): """Output two byte character code as a single integer.""" def next_byte(b): """Make sure that character code is an int. Python 2 and 3 compatibility. """ if not isinstance(b, int): return ord(b) else: return b #Go through the data by looping to every other character for i in range(0, len(data), 2): yield (next_byte(data[i]) << 8) | next_byte(data[i+1]) #Force the data into Kanji encoded bytes if isinstance(self.data, bytes): data = self.data.decode('shiftjis').encode('shiftjis') else: data = self.data.encode('shiftjis') #Now perform the algorithm that will make the kanji into 13 bit fields with io.StringIO() as buf: for asint in two_bytes(data): #Shift the two byte value as indicated by the standard if 0x8140 <= asint <= 0x9FFC: difference = asint - 0x8140 elif 0xE040 <= asint <= 0xEBBF: difference = asint - 0xC140 #Split the new value into most and least significant bytes msb = (difference >> 8) lsb = (difference & 0x00FF) #Calculate the actual 13 bit binary value buf.write('{0:013b}'.format((msb * 0xC0) + lsb)) #Return the binary string return buf.getvalue() def add_data(self): """This function properly constructs a QR code's data string. It takes into account the interleaving pattern required by the standard. """ #Encode the data into a QR code self.buffer.write(self.binary_string(self.mode, 4)) self.buffer.write(self.get_data_length()) self.buffer.write(self.encode()) #Converts the buffer into "code word" integers. #The online debugger outputs them this way, makes #for easier comparisons. #s = self.buffer.getvalue() #for i in range(0, len(s), 8): # print(int(s[i:i+8], 2), end=',') #print() #Fix for issue #3: https://github.com/mnooner256/pyqrcode/issues/3# #I was performing the terminate_bits() part in the encoding. #As per the standard, terminating bits are only supposed to #be added after the bit stream is complete. I took that to #mean after the encoding, but actually it is after the entire #bit stream has been constructed. bits = self.terminate_bits(self.buffer.getvalue()) if bits is not None: self.buffer.write(bits) #delimit_words and add_words can return None add_bits = self.delimit_words() if add_bits: self.buffer.write(add_bits) fill_bytes = self.add_words() if fill_bytes: self.buffer.write(fill_bytes) #Get a numeric representation of the data data = [int(''.join(x),2) for x in self.grouper(8, self.buffer.getvalue())] #This is the error information for the code error_info = tables.eccwbi[self.version][self.error] #This will hold our data blocks data_blocks = [] #This will hold our error blocks error_blocks = [] #Some codes have the data sliced into two different sized blocks #for example, first two 14 word sized blocks, then four 15 word #sized blocks. This means that slicing size can change over time. data_block_sizes = [error_info[2]] * error_info[1] if error_info[3] != 0: data_block_sizes.extend([error_info[4]] * error_info[3]) #For every block of data, slice the data into the appropriate #sized block current_byte = 0 for n_data_blocks in data_block_sizes: data_blocks.append(data[current_byte:current_byte+n_data_blocks]) current_byte += n_data_blocks #I am not sure about the test after the "and". This was added to #fix a bug where after delimit_words padded the bit stream, a zero #byte ends up being added. After checking around, it seems this extra #byte is supposed to be chopped off, but I cannot find that in the #standard! I am adding it to solve the bug, I believe it is correct. if current_byte < len(data): raise ValueError('Too much data for this code version.') #DEBUG CODE!!!! #Print out the data blocks #print('Data Blocks:\n{0}'.format(data_blocks)) #Calculate the error blocks for n, block in enumerate(data_blocks): error_blocks.append(self.make_error_block(block, n)) #DEBUG CODE!!!! #Print out the error blocks #print('Error Blocks:\n{0}'.format(error_blocks)) #Buffer we will write our data blocks into data_buffer = io.StringIO() #Add the data blocks #Write the buffer such that: block 1 byte 1, block 2 byte 1, etc. largest_block = max(error_info[2], error_info[4])+error_info[0] for i in range(largest_block): for block in data_blocks: if i < len(block): data_buffer.write(self.binary_string(block[i], 8)) #Add the error code blocks. #Write the buffer such that: block 1 byte 1, block 2 byte 2, etc. for i in range(error_info[0]): for block in error_blocks: data_buffer.write(self.binary_string(block[i], 8)) self.buffer = data_buffer def terminate_bits(self, payload): """This method adds zeros to the end of the encoded data so that the encoded data is of the correct length. It returns a binary string containing the bits to be added. """ data_capacity = tables.data_capacity[self.version][self.error][0] if len(payload) > data_capacity: raise ValueError('The supplied data will not fit ' 'within this version of a QR code.') #We must add up to 4 zeros to make up for any shortfall in the #length of the data field. if len(payload) == data_capacity: return None elif len(payload) <= data_capacity-4: bits = self.binary_string(0,4) else: #Make up any shortfall need with less than 4 zeros bits = self.binary_string(0, data_capacity - len(payload)) return bits def delimit_words(self): """This method takes the existing encoded binary string and returns a binary string that will pad it such that the encoded string contains only full bytes. """ bits_short = 8 - (len(self.buffer.getvalue()) % 8) #The string already falls on an byte boundary do nothing if bits_short == 0 or bits_short == 8: return None else: return self.binary_string(0, bits_short) def add_words(self): """The data block must fill the entire data capacity of the QR code. If we fall short, then we must add bytes to the end of the encoded data field. The value of these bytes are specified in the standard. """ data_blocks = len(self.buffer.getvalue()) // 8 total_blocks = tables.data_capacity[self.version][self.error][0] // 8 needed_blocks = total_blocks - data_blocks if needed_blocks == 0: return None #This will return item1, item2, item1, item2, etc. block = itertools.cycle(['11101100', '00010001']) #Create a string of the needed blocks return ''.join([next(block) for x in range(needed_blocks)]) def make_error_block(self, block, block_number): """This function constructs the error correction block of the given data block. This is *very complicated* process. To understand the code you need to read: * http://www.thonky.com/qr-code-tutorial/part-2-error-correction/ * http://www.matchadesign.com/blog/qr-code-demystified-part-4/ """ #Get the error information from the standards table error_info = tables.eccwbi[self.version][self.error] #This is the number of 8-bit words per block if block_number < error_info[1]: code_words_per_block = error_info[2] else: code_words_per_block = error_info[4] #This is the size of the error block error_block_size = error_info[0] #Copy the block as the message polynomial coefficients mp_co = block[:] #Add the error blocks to the message polynomial mp_co.extend([0] * (error_block_size)) #Get the generator polynomial generator = tables.generator_polynomials[error_block_size] #This will hold the temporary sum of the message coefficient and the #generator polynomial gen_result = [0] * len(generator) #Go through every code word in the block for i in range(code_words_per_block): #Get the first coefficient from the message polynomial coefficient = mp_co.pop(0) #Skip coefficients that are zero if coefficient == 0: continue else: #Turn the coefficient into an alpha exponent alpha_exp = tables.galois_antilog[coefficient] #Add the alpha to the generator polynomial for n in range(len(generator)): gen_result[n] = alpha_exp + generator[n] if gen_result[n] > 255: gen_result[n] = gen_result[n] % 255 #Convert the alpha notation back into coefficients gen_result[n] = tables.galois_log[gen_result[n]] #XOR the sum with the message coefficients mp_co[n] = gen_result[n] ^ mp_co[n] #Pad the end of the error blocks with zeros if needed if len(mp_co) < code_words_per_block: mp_co.extend([0] * (code_words_per_block - len(mp_co))) return mp_co def make_code(self): """This method returns the best possible QR code.""" from copy import deepcopy #Get the size of the underlying matrix matrix_size = tables.version_size[self.version] #Create a template matrix we will build the codes with row = [' ' for x in range(matrix_size)] template = [deepcopy(row) for x in range(matrix_size)] #Add mandatory information to the template self.add_detection_pattern(template) self.add_position_pattern(template) self.add_version_pattern(template) #Create the various types of masks of the template self.masks = self.make_masks(template) self.best_mask = self.choose_best_mask() self.code = self.masks[self.best_mask] def add_detection_pattern(self, m): """This method add the detection patterns to the QR code. This lets the scanner orient the pattern. It is required for all QR codes. The detection pattern consists of three boxes located at the upper left, upper right, and lower left corners of the matrix. Also, two special lines called the timing pattern is also necessary. Finally, a single black pixel is added just above the lower left black box. """ #Draw outer black box for i in range(7): inv = -(i+1) for j in [0,6,-1,-7]: m[j][i] = 1 m[i][j] = 1 m[inv][j] = 1 m[j][inv] = 1 #Draw inner white box for i in range(1, 6): inv = -(i+1) for j in [1, 5, -2, -6]: m[j][i] = 0 m[i][j] = 0 m[inv][j] = 0 m[j][inv] = 0 #Draw inner black box for i in range(2, 5): for j in range(2, 5): inv = -(i+1) m[i][j] = 1 m[inv][j] = 1 m[j][inv] = 1 #Draw white border for i in range(8): inv = -(i+1) for j in [7, -8]: m[i][j] = 0 m[j][i] = 0 m[inv][j] = 0 m[j][inv] = 0 #To keep the code short, it draws an extra box #in the lower right corner, this removes it. for i in range(-8, 0): for j in range(-8, 0): m[i][j] = ' ' #Add the timing pattern bit = itertools.cycle([1,0]) for i in range(8, (len(m)-8)): b = next(bit) m[i][6] = b m[6][i] = b #Add the extra black pixel m[-8][8] = 1 def add_position_pattern(self, m): """This method draws the position adjustment patterns onto the QR Code. All QR code versions larger than one require these special boxes called position adjustment patterns. """ #Version 1 does not have a position adjustment pattern if self.version == 1: return #Get the coordinates for where to place the boxes coordinates = tables.position_adjustment[self.version] #Get the max and min coordinates to handle special cases min_coord = coordinates[0] max_coord = coordinates[-1] #Draw a box at each intersection of the coordinates for i in coordinates: for j in coordinates: #Do not draw these boxes because they would #interfere with the detection pattern if (i == min_coord and j == min_coord) or \ (i == min_coord and j == max_coord) or \ (i == max_coord and j == min_coord): continue #Center black pixel m[i][j] = 1 #Surround the pixel with a white box for x in [-1,1]: m[i+x][j+x] = 0 m[i+x][j] = 0 m[i][j+x] = 0 m[i-x][j+x] = 0 m[i+x][j-x] = 0 #Surround the white box with a black box for x in [-2,2]: for y in [0,-1,1]: m[i+x][j+x] = 1 m[i+x][j+y] = 1 m[i+y][j+x] = 1 m[i-x][j+x] = 1 m[i+x][j-x] = 1 def add_version_pattern(self, m): """For QR codes with a version 7 or higher, a special pattern specifying the code's version is required. For further information see: http://www.thonky.com/qr-code-tutorial/format-version-information/#example-of-version-7-information-string """ if self.version < 7: return #Get the bit fields for this code's version #We will iterate across the string, the bit string #needs the least significant digit in the zero-th position field = iter(tables.version_pattern[self.version][::-1]) #Where to start placing the pattern start = len(m)-11 #The version pattern is pretty odd looking for i in range(6): #The pattern is three modules wide for j in range(start, start+3): bit = int(next(field)) #Bottom Left m[i][j] = bit #Upper right m[j][i] = bit def make_masks(self, template): """This method generates all seven masks so that the best mask can be determined. The template parameter is a code matrix that will server as the base for all the generated masks. """ from copy import deepcopy nmasks = len(tables.mask_patterns) masks = [''] * nmasks count = 0 for n in range(nmasks): cur_mask = deepcopy(template) masks[n] = cur_mask #Add the type pattern bits to the code self.add_type_pattern(cur_mask, tables.type_bits[self.error][n]) #Get the mask pattern pattern = tables.mask_patterns[n] #This will read the 1's and 0's one at a time bits = iter(self.buffer.getvalue()) #These will help us do the up, down, up, down pattern row_start = itertools.cycle([len(cur_mask)-1, 0]) row_stop = itertools.cycle([-1,len(cur_mask)]) direction = itertools.cycle([-1, 1]) #The data pattern is added using pairs of columns for column in range(len(cur_mask)-1, 0, -2): #The vertical timing pattern is an exception to the rules, #move the column counter over by one if column <= 6: column = column - 1 #This will let us fill in the pattern #right-left, right-left, etc. column_pair = itertools.cycle([column, column-1]) #Go through each row in the pattern moving up, then down for row in range(next(row_start), next(row_stop), next(direction)): #Fill in the right then left column for i in range(2): col = next(column_pair) #Go to the next column if we encounter a #preexisting pattern (usually an alignment pattern) if cur_mask[row][col] != ' ': continue #Some versions don't have enough bits. You then fill #in the rest of the pattern with 0's. These are #called "remainder bits." try: bit = int(next(bits)) except: bit = 0 #If the pattern is True then flip the bit if pattern(row, col): cur_mask[row][col] = bit ^ 1 else: cur_mask[row][col] = bit #DEBUG CODE!!! #Save all of the masks as png files #for i, m in enumerate(masks): # _png(m, self.version, 'mask-{0}.png'.format(i), 5) return masks def choose_best_mask(self): """This method returns the index of the "best" mask as defined by having the lowest total penalty score. The penalty rules are defined by the standard. The mask with the lowest total score should be the easiest to read by optical scanners. """ self.scores = [] for n in range(len(self.masks)): self.scores.append([0,0,0,0]) #Score penalty rule number 1 #Look for five consecutive squares with the same color. #Each one found gets a penalty of 3 + 1 for every #same color square after the first five in the row. for (n, mask) in enumerate(self.masks): current = mask[0][0] counter = 0 total = 0 #Examine the mask row wise for row in range(0,len(mask)): counter = 0 for col in range(0,len(mask)): bit = mask[row][col] if bit == current: counter += 1 else: if counter >= 5: total += (counter - 5) + 3 counter = 1 current = bit if counter >= 5: total += (counter - 5) + 3 #Examine the mask column wise for col in range(0,len(mask)): counter = 0 for row in range(0,len(mask)): bit = mask[row][col] if bit == current: counter += 1 else: if counter >= 5: total += (counter - 5) + 3 counter = 1 current = bit if counter >= 5: total += (counter - 5) + 3 self.scores[n][0] = total #Score penalty rule 2 #This rule will add 3 to the score for each 2x2 block of the same #colored pixels there are. for (n, mask) in enumerate(self.masks): count = 0 #Don't examine the 0th and Nth row/column for i in range(0, len(mask)-1): for j in range(0, len(mask)-1): if mask[i][j] == mask[i+1][j] and \ mask[i][j] == mask[i][j+1] and \ mask[i][j] == mask[i+1][j+1]: count += 1 self.scores[n][1] = count * 3 #Score penalty rule 3 #This rule looks for 1011101 within the mask prefixed #and/or suffixed by four zeros. patterns = [[0,0,0,0,1,0,1,1,1,0,1], [1,0,1,1,1,0,1,0,0,0,0],] #[0,0,0,0,1,0,1,1,1,0,1,0,0,0,0]] for (n, mask) in enumerate(self.masks): nmatches = 0 for i in range(len(mask)): for j in range(len(mask)): for pattern in patterns: match = True k = j #Look for row matches for p in pattern: if k >= len(mask) or mask[i][k] != p: match = False break k += 1 if match: nmatches += 1 match = True k = j #Look for column matches for p in pattern: if k >= len(mask) or mask[k][i] != p: match = False break k += 1 if match: nmatches += 1 self.scores[n][2] = nmatches * 40 #Score the last rule, penalty rule 4. This rule measures how close #the pattern is to being 50% black. The further it deviates from #this this ideal the higher the penalty. for (n, mask) in enumerate(self.masks): nblack = 0 for row in mask: nblack += sum(row) total_pixels = len(mask)**2 ratio = nblack / total_pixels percent = (ratio * 100) - 50 self.scores[n][3] = int((abs(int(percent)) / 5) * 10) #Calculate the total for each score totals = [0] * len(self.scores) for i in range(len(self.scores)): for j in range(len(self.scores[i])): totals[i] += self.scores[i][j] #DEBUG CODE!!! #Prints out a table of scores #print('Rule Scores\n 1 2 3 4 Total') #for i in range(len(self.scores)): # print(i, end='') # for s in self.scores[i]: # print('{0: >6}'.format(s), end='') # print('{0: >7}'.format(totals[i])) #print('Mask Chosen: {0}'.format(totals.index(min(totals)))) #The lowest total wins return totals.index(min(totals)) def add_type_pattern(self, m, type_bits): """This will add the pattern to the QR code that represents the error level and the type of mask used to make the code. """ field = iter(type_bits) for i in range(7): bit = int(next(field)) #Skip the timing bits if i < 6: m[8][i] = bit else: m[8][i+1] = bit if -8 < -(i+1): m[-(i+1)][8] = bit for i in range(-8,0): bit = int(next(field)) m[8][i] = bit i = -i #Skip timing column if i > 6: m[i][8] = bit else: m[i-1][8] = bit ############################################################################## ############################################################################## # # Output Functions # ############################################################################## ############################################################################## def _get_writable(stream_or_path, mode): """This method returns a tuple containing the stream and a flag to indicate if the stream should be automatically closed. The `stream_or_path` parameter is returned if it is an open writable stream. Otherwise, it treats the `stream_or_path` parameter as a file path and opens it with the given mode. It is used by the svg and png methods to interpret the file parameter. :type stream_or_path: str | io.BufferedIOBase :type mode: str | unicode :rtype: (io.BufferedIOBase, bool) """ is_stream = hasattr(stream_or_path, 'write') if not is_stream: # No stream provided, treat "stream_or_path" as path stream_or_path = open(stream_or_path, mode) return stream_or_path, not is_stream def _get_png_size(version, scale, quiet_zone=4): """See: QRCode.get_png_size This function was abstracted away from QRCode to allow for the output of QR codes during the build process, i.e. for debugging. It works just the same except you must specify the code's version. This is needed to calculate the PNG's size. """ #Formula: scale times number of modules plus the border on each side return (int(scale) * tables.version_size[version]) + (2 * quiet_zone * int(scale)) def _terminal(code, module_color='default', background='reverse', quiet_zone=4): """This method returns a string containing ASCII escape codes, such that if printed to a terminal, it will display a vaild QR code. The module_color and the background color should be keys in the tables.term_colors table for printing using the 8/16 color scheme. Alternatively, they can be a number between 0 and 256 in order to use the 88/256 color scheme. Otherwise, a ValueError will be raised. Note, the code is outputted by changing the background color. Then two spaces are written to the terminal. Finally, the terminal is reset back to how it was. """ buf = io.StringIO() def draw_border(): for i in range(quiet_zone): buf.write(background) if module_color in tables.term_colors: data = '\033[{0}m \033[0m'.format( tables.term_colors[module_color]) elif 0 <= module_color <= 256: data = '\033[48;5;{0}m \033[0m'.format(module_color) else: raise ValueError('The module color, {0}, must a key in ' 'pyqrcode.tables.term_colors or a number ' 'between 0 and 256.'.format( module_color)) if background in tables.term_colors: background = '\033[{0}m \033[0m'.format( tables.term_colors[background]) elif 0 <= background <= 256: background = '\033[48;5;{0}m \033[0m'.format(background) else: raise ValueError('The background color, {0}, must a key in ' 'pyqrcode.tables.term_colors or a number ' 'between 0 and 256.'.format( background)) #This will be the beginning and ending row for the code. border_row = background * (len(code[0]) + (2 * quiet_zone)) #Make sure we begin on a new line, and force the terminal back #to normal buf.write('\n') #QRCodes have a quiet zone consisting of background modules for i in range(quiet_zone): buf.write(border_row) buf.write('\n') for row in code: #Each code has a quiet zone on the left side, this is the left #border for this code draw_border() for bit in row: if bit == 1: buf.write(data) elif bit == 0: buf.write(background) #Each row ends with a quiet zone on the right side, this is the #right hand border background modules draw_border() buf.write('\n') #QRCodes have a background quiet zone row following the code for i in range(quiet_zone): buf.write(border_row) buf.write('\n') return buf.getvalue() def _text(code, quiet_zone=4): """This method returns a text based representation of the QR code. This is useful for debugging purposes. """ buf = io.StringIO() border_row = '0' * (len(code[0]) + (quiet_zone*2)) #Every QR code start with a quiet zone at the top for b in range(quiet_zone): buf.write(border_row) buf.write('\n') for row in code: #Draw the starting quiet zone for b in range(quiet_zone): buf.write('0') #Actually draw the QR code for bit in row: if bit == 1: buf.write('1') elif bit == 0: buf.write('0') #This is for debugging unfinished QR codes, #unset pixels will be spaces. else: buf.write(' ') #Draw the ending quiet zone for b in range(quiet_zone): buf.write('0') buf.write('\n') #Every QR code ends with a quiet zone at the bottom for b in range(quiet_zone): buf.write(border_row) buf.write('\n') return buf.getvalue() def _xbm(code, scale=1, quiet_zone=4): """This function will format the QR code as a X BitMap. This can be used to display the QR code with Tkinter. """ try: str = unicode # Python 2 except NameError: str = __builtins__['str'] buf = io.StringIO() # Calculate the width in pixels pixel_width = (len(code[0]) + quiet_zone * 2) * scale # Add the size information and open the pixel data section buf.write('#define im_width ') buf.write(str(pixel_width)) buf.write('\n') buf.write('#define im_height ') buf.write(str(pixel_width)) buf.write('\n') buf.write('static char im_bits[] = {\n') # Calculate the number of bytes per row byte_width = int(math.ceil(pixel_width / 8.0)) # Add the top quiet zone buf.write(('0x00,' * byte_width + '\n') * quiet_zone * scale) for row in code: # Add the left quiet zone row_bits = '0' * quiet_zone * scale # Add the actual QR code for pixel in row: row_bits += str(pixel) * scale # Add the right quiet zone row_bits += '0' * quiet_zone * scale # Format the row formated_row = '' for b in range(byte_width): formated_row += '0x{0:02x},'.format(int(row_bits[:8][::-1], 2)) row_bits = row_bits[8:] formated_row += '\n' # Add the formatted row buf.write(formated_row * scale) # Add the bottom quiet zone and close the pixel data section buf.write(('0x00,' * byte_width + '\n') * quiet_zone * scale) buf.write('};') return buf.getvalue() def _svg(code, version, file, scale=1, module_color='#000', background=None, quiet_zone=4, xmldecl=True, svgns=True, title=None, svgclass='pyqrcode', lineclass='pyqrline', omithw=False, debug=False): """This function writes the QR code out as an SVG document. The code is drawn by drawing only the modules corresponding to a 1. They are drawn using a line, such that contiguous modules in a row are drawn with a single line. The file parameter is used to specify where to write the document to. It can either be a writable (binary) stream or a file path. The scale parameter is sets how large to draw a single module. By default one pixel is used to draw a single module. This may make the code to small to be read efficiently. Increasing the scale will make the code larger. This method will accept fractional scales (e.g. 2.5). :param module_color: Color of the QR code (default: ``#000`` (black)) :param background: Optional background color. (default: ``None`` (no background)) :param quiet_zone: Border around the QR code (also known as quiet zone) (default: ``4``). Set to zero (``0``) if the code shouldn't have a border. :param xmldecl: Inidcates if the XML declaration header should be written (default: ``True``) :param svgns: Indicates if the SVG namespace should be written (default: ``True``) :param title: Optional title of the generated SVG document. :param svgclass: The CSS class of the SVG document (if set to ``None``, the SVG element won't have a class). :param lineclass: The CSS class of the path element (if set to ``None``, the path won't have a class). :param omithw: Indicates if width and height attributes should be omitted (default: ``False``). If these attributes are omitted, a ``viewBox`` attribute will be added to the document. :param debug: Inidicates if errors in the QR code should be added to the output (default: ``False``). """ from functools import partial from xml.sax.saxutils import quoteattr def write_unicode(write_meth, unicode_str): """\ Encodes the provided string into UTF-8 and writes the result using the `write_meth`. """ write_meth(unicode_str.encode('utf-8')) def line(x, y, length, relative): """Returns coordinates to draw a line with the provided length. """ return '{0}{1} {2}h{3}'.format(('m' if relative else 'M'), x, y, length) def errline(col_number, row_number): """Returns the coordinates to draw an error bit. """ # Debug path uses always absolute coordinates # .5 == stroke / 2 return line(col_number + quiet_zone, row_number + quiet_zone + .5, 1, False) f, autoclose = _get_writable(file, 'wb') write = partial(write_unicode, f.write) write_bytes = f.write # Write the document header if xmldecl: write_bytes(b'\n') write_bytes(b'') if title is not None: write('{0}'.format(title)) # Draw a background rectangle if necessary if background is not None: write('' .format(size, background)) write_bytes(b'') if debug and debug_path: write_bytes(b''.format(debug_path)) # Close document write_bytes(b'\n') if autoclose: f.close() def _png(code, version, file, scale=1, module_color=(0, 0, 0, 255), background=(255, 255, 255, 255), quiet_zone=4, debug=False): """See: pyqrcode.QRCode.png() This function was abstracted away from QRCode to allow for the output of QR codes during the build process, i.e. for debugging. It works just the same except you must specify the code's version. This is needed to calculate the PNG's size. This method will write the given file out as a PNG file. Note, it depends on the PyPNG module to do this. :param module_color: Color of the QR code (default: ``(0, 0, 0, 255)`` (black)) :param background: Optional background color. If set to ``None`` the PNG will have a transparent background. (default: ``(255, 255, 255, 255)`` (white)) :param quiet_zone: Border around the QR code (also known as quiet zone) (default: ``4``). Set to zero (``0``) if the code shouldn't have a border. :param debug: Inidicates if errors in the QR code should be added (as red modules) to the output (default: ``False``). """ import png # Coerce scale parameter into an integer try: scale = int(scale) except ValueError: raise ValueError('The scale parameter must be an integer') def scale_code(size): """To perform the scaling we need to inflate the number of bits. The PNG library expects all of the bits when it draws the PNG. Effectively, we double, tripple, etc. the number of columns and the number of rows. """ # This is one row's worth of each possible module # PNG's use 0 for black and 1 for white, this is the # reverse of the QR standard black = [0] * scale white = [1] * scale # Tuple to lookup colors # The 3rd color is the module_color unless "debug" is enabled colors = (white, black, (([2] * scale) if debug else black)) # Whitespace added on the left and right side border_module = white * quiet_zone # This is the row to show up at the top and bottom border border_row = [[1] * size] * scale * quiet_zone # This will hold the final PNG's bits bits = [] # Add scale rows before the code as a border, # as per the standard bits.extend(border_row) # Add each row of the to the final PNG bits for row in code: tmp_row = [] # Add one all white module to the beginning # to create the vertical border tmp_row.extend(border_module) # Go through each bit in the code for bit in row: # Use the standard color or the "debug" color tmp_row.extend(colors[(bit if bit in (0, 1) else 2)]) # Add one all white module to the end # to create the vertical border tmp_row.extend(border_module) # Copy each row scale times for n in range(scale): bits.append(tmp_row) # Add the bottom border bits.extend(border_row) return bits def png_pallete_color(color): """This creates a palette color from a list or tuple. The list or tuple must be of length 3 (for rgb) or 4 (for rgba). The values must be between 0 and 255. Note rgb colors will be given an added alpha component set to 255. The pallete color is represented as a list, this is what is returned. """ if color is None: return () if not isinstance(color, (tuple, list)): r, g, b = _hex_to_rgb(color) return r, g, b, 255 rgba = [] if not (3 <= len(color) <= 4): raise ValueError('Colors must be a list or tuple of length ' ' 3 or 4. You passed in "{0}".'.format(color)) for c in color: c = int(c) if 0 <= c <= 255: rgba.append(int(c)) else: raise ValueError('Color components must be between 0 and 255') # Make all colors have an alpha channel if len(rgba) == 3: rgba.append(255) return tuple(rgba) if module_color is None: raise ValueError('The module_color must not be None') bitdepth = 1 # foreground aka module color fg_col = png_pallete_color(module_color) transparent = background is None # If background color is set to None, the inverse color of the # foreground color is calculated bg_col = png_pallete_color(background) if background is not None else tuple([255 - c for c in fg_col]) # Assume greyscale if module color is black and background color is white greyscale = fg_col[:3] == (0, 0, 0) and (not debug and transparent or bg_col == (255, 255, 255, 255)) transparent_color = 1 if transparent and greyscale else None palette = [fg_col, bg_col] if not greyscale else None if debug: # Add "red" as color for error modules palette.append((255, 0, 0, 255)) bitdepth = 2 # The size of the PNG size = _get_png_size(version, scale, quiet_zone) # We need to increase the size of the code to match up to the # scale parameter. code_rows = scale_code(size) # Write out the PNG f, autoclose = _get_writable(file, 'wb') w = png.Writer(width=size, height=size, greyscale=greyscale, transparent=transparent_color, palette=palette, bitdepth=bitdepth) try: w.write(f, code_rows) finally: if autoclose: f.close() def _eps(code, version, file_or_path, scale=1, module_color=(0, 0, 0), background=None, quiet_zone=4): """This function writes the QR code out as an EPS document. The code is drawn by drawing only the modules corresponding to a 1. They are drawn using a line, such that contiguous modules in a row are drawn with a single line. The file parameter is used to specify where to write the document to. It can either be a writable (text) stream or a file path. The scale parameter is sets how large to draw a single module. By default one point (1/72 inch) is used to draw a single module. This may make the code to small to be read efficiently. Increasing the scale will make the code larger. This function will accept fractional scales (e.g. 2.5). :param module_color: Color of the QR code (default: ``(0, 0, 0)`` (black)) The color can be specified as triple of floats (range: 0 .. 1) or triple of integers (range: 0 .. 255) or as hexadecimal value (i.e. ``#36c`` or ``#33B200``). :param background: Optional background color. (default: ``None`` (no background)). See `module_color` for the supported values. :param quiet_zone: Border around the QR code (also known as quiet zone) (default: ``4``). Set to zero (``0``) if the code shouldn't have a border. """ from functools import partial import time import textwrap def write_line(writemeth, content): """\ Writes `content` and ``LF``. """ # Postscript: Max. 255 characters per line for line in textwrap.wrap(content, 255): writemeth(line) writemeth('\n') def line(offset, length): """\ Returns coordinates to draw a line with the provided length. """ res = '' if offset > 0: res = ' {0} 0 m'.format(offset) res += ' {0} 0 l'.format(length) return res def rgb_to_floats(color): """\ Converts the provided color into an acceptable format for Postscript's ``setrgbcolor`` """ def to_float(clr): if isinstance(clr, float): if not 0.0 <= clr <= 1.0: raise ValueError('Invalid color "{0}". Not in range 0 .. 1' .format(clr)) return clr if not 0 <= clr <= 255: raise ValueError('Invalid color "{0}". Not in range 0 .. 255' .format(clr)) return 1/255.0 * clr if clr != 1 else clr if not isinstance(color, (tuple, list)): color = _hex_to_rgb(color) return tuple([to_float(i) for i in color]) f, autoclose = _get_writable(file_or_path, 'w') writeline = partial(write_line, f.write) size = tables.version_size[version] * scale + (2 * quiet_zone * scale) # Write common header writeline('%!PS-Adobe-3.0 EPSF-3.0') writeline('%%Creator: PyQRCode ') writeline('%%CreationDate: {0}'.format(time.strftime("%Y-%m-%d %H:%M:%S"))) writeline('%%DocumentData: Clean7Bit') writeline('%%BoundingBox: 0 0 {0} {0}'.format(size)) # Write the shortcuts writeline('/M { moveto } bind def') writeline('/m { rmoveto } bind def') writeline('/l { rlineto } bind def') mod_color = module_color if module_color == (0, 0, 0) else rgb_to_floats(module_color) if background is not None: writeline('{0:f} {1:f} {2:f} setrgbcolor clippath fill' .format(*rgb_to_floats(background))) if mod_color == (0, 0, 0): # Reset RGB color back to black iff module color is black # In case module color != black set the module RGB color later writeline('0 0 0 setrgbcolor') if mod_color != (0, 0, 0): writeline('{0:f} {1:f} {2:f} setrgbcolor'.format(*mod_color)) if scale != 1: writeline('{0} {0} scale'.format(scale)) writeline('newpath') # Current pen position y-axis # Note: 0, 0 = lower left corner in PS coordinate system y = tables.version_size[version] + quiet_zone + .5 # .5 = linewidth / 2 last_bit = 1 # Loop through each row of the code for row in code: offset = 0 # Set x-offset of the pen length = 0 y -= 1 # Move pen along y-axis coord = '{0} {1} M'.format(quiet_zone, y) # Move pen to initial pos for bit in row: if bit != last_bit: if length: coord += line(offset, length) offset = 0 length = 0 last_bit = bit if bit == 1: length += 1 else: offset += 1 if length: coord += line(offset, length) writeline(coord) writeline('stroke') writeline('%%EOF') if autoclose: f.close() def _hex_to_rgb(color): """\ Helper function to convert a color provided in hexadecimal format as RGB triple. """ if color[0] == '#': color = color[1:] if len(color) == 3: color = color[0] * 2 + color[1] * 2 + color[2] * 2 if len(color) != 6: raise ValueError('Input #{0} is not in #RRGGBB format'.format(color)) return [int(n, 16) for n in (color[:2], color[2:4], color[4:])] PyQRCode-1.2.1/pyqrcode/__init__.py0000644000175000017500000007764012731660506017020 0ustar mikemike00000000000000# -*- coding: utf-8 -*- # Copyright (c) 2013, Michael Nooner # All rights reserved. # Redistribution and use in source and binary forms, with or without # modification, are permitted provided that the following conditions are met: # * Redistributions of source code must retain the above copyright # notice, this list of conditions and the following disclaimer. # * Redistributions in binary form must reproduce the above copyright # notice, this list of conditions and the following disclaimer in the # documentation and/or other materials provided with the distribution. # * Neither the name of the copyright holder nor the names of its # contributors may be used to endorse or promote products derived from # this software without specific prior written permission # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" # AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE # IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE # ARE DISCLAIMED. IN NO EVENT SHALL BE LIABLE FOR ANY # DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES # (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; # LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND # ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS # SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. """This module is used to create QR Codes. It is designed to be as simple and as possible. It does this by using sane defaults and autodetection to make creating a QR Code very simple. It is recommended that you use the :func:`pyqrcode.create` function to build the QRCode object. This results in cleaner looking code. Examples: >>> import pyqrcode >>> import sys >>> url = pyqrcode.create('http://uca.edu') >>> url.svg(sys.stdout, scale=1) >>> url.svg('uca.svg', scale=4) >>> number = pyqrcode.create(123456789012345) >>> number.png('big-number.png') """ #Imports required for 2.7 support from __future__ import absolute_import, division, print_function, with_statement, unicode_literals import pyqrcode.tables import pyqrcode.builder as builder try: str = unicode # Python 2 except NameError: pass def create(content, error='H', version=None, mode=None, encoding=None): """When creating a QR code only the content to be encoded is required, all the other properties of the code will be guessed based on the contents given. This function will return a :class:`QRCode` object. Unless you are familiar with QR code's inner workings it is recommended that you just specify the *content* and nothing else. However, there are cases where you may want to specify the various properties of the created code manually, this is what the other parameters do. Below, you will find a lengthy explanation of what each parameter is for. Note, the parameter names and values are taken directly from the standards. You may need to familiarize yourself with the terminology of QR codes for the names and their values to make sense. The *error* parameter sets the error correction level of the code. There are four levels defined by the standard. The first is level 'L' which allows for 7% of the code to be corrected. Second, is level 'M' which allows for 15% of the code to be corrected. Next, is level 'Q' which is the most common choice for error correction, it allow 25% of the code to be corrected. Finally, there is the highest level 'H' which allows for 30% of the code to be corrected. There are several ways to specify this parameter, you can use an upper or lower case letter, a float corresponding to the percentage of correction, or a string containing the percentage. See tables.modes for all the possible values. By default this parameter is set to 'H' which is the highest possible error correction, but it has the smallest available data capacity. The *version* parameter specifies the size and data capacity of the code. Versions are any integer between 1 and 40. Where version 1 is the smallest QR code, and version 40 is the largest. If this parameter is left unspecified, then the contents and error correction level will be used to guess the smallest possible QR code version that the content will fit inside of. You may want to specify this parameter for consistency when generating several QR codes with varying amounts of data. That way all of the generated codes would have the same size. The *mode* parameter specifies how the contents will be encoded. By default, the best possible mode for the contents is guessed. There are four possible modes. First, is 'numeric' which is used to encode integer numbers. Next, is 'alphanumeric' which is used to encode some ASCII characters. This mode uses only a limited set of characters. Most problematic is that it can only use upper case English characters, consequently, the content parameter will be subjected to str.upper() before encoding. See tables.ascii_codes for a complete list of available characters. The is 'kanji' mode can be used for Japanese characters, but only those that can be understood via the shift-jis string encoding. Finally, we then have 'binary' mode which just encodes the bytes directly into the QR code (this encoding is the least efficient). The *encoding* parameter specifies how the content will be interpreted. This parameter only matters if the *content* is a string, unicode, or byte array type. This parameter must be a valid encoding string or None. t will be passed the *content*'s encode/decode methods. """ return QRCode(content, error, version, mode, encoding) class QRCode: """This class represents a QR code. To use this class simply give the constructor a string representing the data to be encoded, it will then build a code in memory. You can then save it in various formats. Note, codes can be written out as PNG files but this requires the PyPNG module. You can find the PyPNG module at http://packages.python.org/pypng/. Examples: >>> from pyqrcode import QRCode >>> import sys >>> url = QRCode('http://uca.edu') >>> url.svg(sys.stdout, scale=1) >>> url.svg('uca.svg', scale=4) >>> number = QRCode(123456789012345) >>> number.png('big-number.png') .. note:: For what all of the parameters do, see the :func:`pyqrcode.create` function. """ def __init__(self, content, error='H', version=None, mode=None, encoding='iso-8859-1'): #Guess the mode of the code, this will also be used for #error checking guessed_content_type, encoding = self._detect_content_type(content, encoding) if encoding is None: encoding = 'iso-8859-1' #Store the encoding for use later if guessed_content_type == 'kanji': self.encoding = 'shiftjis' else: self.encoding = encoding if version is not None: if 1 <= version <= 40: self.version = version else: raise ValueError("Illegal version {0}, version must be between " "1 and 40.".format(version)) #Decode a 'byte array' contents into a string format if isinstance(content, bytes): self.data = content.decode(encoding) #Give a string an encoding elif hasattr(content, 'encode'): self.data = content.encode(self.encoding) #The contents are not a byte array or string, so #try naively converting to a string representation. else: self.data = str(content) # str == unicode in Py 2.x, see file head #Force a passed in mode to be lowercase if hasattr(mode, 'lower'): mode = mode.lower() #Check that the mode parameter is compatible with the contents if mode is None: #Use the guessed mode self.mode = guessed_content_type self.mode_num = tables.modes[self.mode] elif mode not in tables.modes.keys(): #Unknown mode raise ValueError('{0} is not a valid mode.'.format(mode)) elif guessed_content_type == 'binary' and \ tables.modes[mode] != tables.modes['binary']: #Binary is only guessed as a last resort, if the #passed in mode is not binary the data won't encode raise ValueError('The content provided cannot be encoded with ' 'the mode {}, it can only be encoded as ' 'binary.'.format(mode)) elif tables.modes[mode] == tables.modes['numeric'] and \ guessed_content_type != 'numeric': #If numeric encoding is requested make sure the data can #be encoded in that format raise ValueError('The content cannot be encoded as numeric.') elif tables.modes[mode] == tables.modes['kanji'] and \ guessed_content_type != 'kanji': raise ValueError('The content cannot be encoded as kanji.') else: #The data should encode with the passed in mode self.mode = mode self.mode_num = tables.modes[self.mode] #Check that the user passed in a valid error level if error in tables.error_level.keys(): self.error = tables.error_level[error] else: raise ValueError('{0} is not a valid error ' 'level.'.format(error)) #Guess the "best" version self.version = self._pick_best_fit(self.data) #If the user supplied a version, then check that it has #sufficient data capacity for the contents passed in if version: if version >= self.version: self.version = version else: raise ValueError('The data will not fit inside a version {} ' 'code with the given encoding and error ' 'level (the code must be at least a ' 'version {}).'.format(version, self.version)) #Build the QR code self.builder = builder.QRCodeBuilder(data=self.data, version=self.version, mode=self.mode, error=self.error) #Save the code for easier reference self.code = self.builder.code def __str__(self): return repr(self) def __unicode__(self): return self.__repr__() def __repr__(self): return "QRCode(content={0}, error='{1}', version={2}, mode='{3}')" \ .format(repr(self.data), self.error, self.version, self.mode) def _detect_content_type(self, content, encoding): """This method tries to auto-detect the type of the data. It first tries to see if the data is a valid integer, in which case it returns numeric. Next, it tests the data to see if it is 'alphanumeric.' QR Codes use a special table with very limited range of ASCII characters. The code's data is tested to make sure it fits inside this limited range. If all else fails, the data is determined to be of type 'binary.' Returns a tuple containing the detected mode and encoding. Note, encoding ECI is not yet implemented. """ def two_bytes(c): """Output two byte character code as a single integer.""" def next_byte(b): """Make sure that character code is an int. Python 2 and 3 compatibility. """ if not isinstance(b, int): return ord(b) else: return b #Go through the data by looping to every other character for i in range(0, len(c), 2): yield (next_byte(c[i]) << 8) | next_byte(c[i+1]) #See if the data is a number try: if str(content).isdigit(): return 'numeric', encoding except (TypeError, UnicodeError): pass #See if that data is alphanumeric based on the standards #special ASCII table valid_characters = ''.join(tables.ascii_codes.keys()) #Force the characters into a byte array valid_characters = valid_characters.encode('ASCII') try: if isinstance(content, bytes): c = content.decode('ASCII') else: c = str(content).encode('ASCII') if all(map(lambda x: x in valid_characters, c)): return 'alphanumeric', 'ASCII' #This occurs if the content does not contain ASCII characters. #Since the whole point of the if statement is to look for ASCII #characters, the resulting mode should not be alphanumeric. #Hence, this is not an error. except TypeError: pass except UnicodeError: pass try: if isinstance(content, bytes): if encoding is None: encoding = 'shiftjis' c = content.decode(encoding).encode('shiftjis') else: c = content.encode('shiftjis') #All kanji characters must be two bytes long, make sure the #string length is not odd. if len(c) % 2 != 0: return 'binary', encoding #Make sure the characters are actually in range. for asint in two_bytes(c): #Shift the two byte value as indicated by the standard if not (0x8140 <= asint <= 0x9FFC or 0xE040 <= asint <= 0xEBBF): return 'binary', encoding return 'kanji', encoding except UnicodeError: #This occurs if the content does not contain Shift JIS kanji #characters. Hence, the resulting mode should not be kanji. #This is not an error. pass #All of the other attempts failed. The content can only be binary. return 'binary', encoding def _pick_best_fit(self, content): """This method return the smallest possible QR code version number that will fit the specified data with the given error level. """ import math for version in range(1, 41): #Get the maximum possible capacity capacity = tables.data_capacity[version][self.error][self.mode_num] #Check the capacity #Kanji's count in the table is "characters" which are two bytes if (self.mode_num == tables.modes['kanji'] and capacity >= math.ceil(len(content) / 2)): return version if capacity >= len(content): return version raise ValueError('The data will not fit in any QR code version ' 'with the given encoding and error level.') def show(self, wait=1.2, scale=10, module_color=(0, 0, 0, 255), background=(255, 255, 255, 255), quiet_zone=4): """Displays this QR code. This method is mainly intended for debugging purposes. This method saves the output of the :py:meth:`png` method (with a default scaling factor of 10) to a temporary file and opens it with the standard PNG viewer application or within the standard webbrowser. The temporary file is deleted afterwards. If this method does not show any result, try to increase the `wait` parameter. This parameter specifies the time in seconds to wait till the temporary file is deleted. Note, that this method does not return until the provided amount of seconds (default: 1.2) has passed. The other parameters are simply passed on to the `png` method. """ import os import time import tempfile import webbrowser try: # Python 2 from urlparse import urljoin from urllib import pathname2url except ImportError: # Python 3 from urllib.parse import urljoin from urllib.request import pathname2url f = tempfile.NamedTemporaryFile('wb', suffix='.png', delete=False) self.png(f, scale=scale, module_color=module_color, background=background, quiet_zone=quiet_zone) f.close() webbrowser.open_new_tab(urljoin('file:', pathname2url(f.name))) time.sleep(wait) os.unlink(f.name) def get_png_size(self, scale=1, quiet_zone=4): """This is method helps users determine what *scale* to use when creating a PNG of this QR code. It is meant mostly to be used in the console to help the user determine the pixel size of the code using various scales. This method will return an integer representing the width and height of the QR code in pixels, as if it was drawn using the given *scale*. Because QR codes are square, the number represents both the width and height dimensions. The *quiet_zone* parameter sets how wide the quiet zone around the code should be. According to the standard this should be 4 modules. It is left settable because such a wide quiet zone is unnecessary in many applications where the QR code is not being printed. Example: >>> code = pyqrcode.QRCode("I don't like spam!") >>> print(code.get_png_size(1)) 31 >>> print(code.get_png_size(5)) 155 """ return builder._get_png_size(self.version, scale, quiet_zone) def png(self, file, scale=1, module_color=(0, 0, 0, 255), background=(255, 255, 255, 255), quiet_zone=4): """This method writes the QR code out as an PNG image. The resulting PNG has a bit depth of 1. The file parameter is used to specify where to write the image to. It can either be an writable stream or a file path. .. note:: This method depends on the pypng module to actually create the PNG file. This method will write the given *file* out as a PNG file. The file can be either a string file path, or a writable stream. The file will not be automatically closed if a stream is given. The *scale* parameter sets how large to draw a single module. By default one pixel is used to draw a single module. This may make the code too small to be read efficiently. Increasing the scale will make the code larger. Only integer scales are usable. This method will attempt to coerce the parameter into an integer (e.g. 2.5 will become 2, and '3' will become 3). You can use the :py:meth:`get_png_size` method to calculate the actual pixel size of the resulting PNG image. The *module_color* parameter sets what color to use for the encoded modules (the black part on most QR codes). The *background* parameter sets what color to use for the background (the white part on most QR codes). If either parameter is set, then both must be set or a ValueError is raised. Colors should be specified as either a list or a tuple of length 3 or 4. The components of the list must be integers between 0 and 255. The first three member give the RGB color. The fourth member gives the alpha component, where 0 is transparent and 255 is opaque. Note, many color combinations are unreadable by scanners, so be judicious. The *quiet_zone* parameter sets how wide the quiet zone around the code should be. According to the standard this should be 4 modules. It is left settable because such a wide quiet zone is unnecessary in many applications where the QR code is not being printed. Example: >>> code = pyqrcode.create('Are you suggesting coconuts migrate?') >>> code.png('swallow.png', scale=5) >>> code.png('swallow.png', scale=5, module_color=(0x66, 0x33, 0x0), #Dark brown background=(0xff, 0xff, 0xff, 0x88)) #50% transparent white """ builder._png(self.code, self.version, file, scale, module_color, background, quiet_zone) def png_as_base64_str(self, scale=1, module_color=(0, 0, 0, 255), background=(255, 255, 255, 255), quiet_zone=4): """This method uses the png render and returns the PNG image encoded as base64 string. This can be useful for creating dynamic PNG images for web development, since no file needs to be created. Example: >>> code = pyqrcode.create('Are you suggesting coconuts migrate?') >>> image_as_str = code.png_as_base64_str(scale=5) >>> html_img = ''.format(image_as_str) The parameters are passed directly to the :py:meth:`png` method. Refer to that method's documentation for the meaning behind the parameters. .. note:: This method depends on the pypng module to actually create the PNG image. """ import io import base64 with io.BytesIO() as virtual_file: self.png(file=virtual_file, scale=scale, module_color=module_color, background=background, quiet_zone=quiet_zone) image_as_str = base64.b64encode(virtual_file.getvalue()).decode("ascii") return image_as_str def xbm(self, scale=1, quiet_zone=4): """Returns a string representing an XBM image of the QR code. The XBM format is a black and white image format that looks like a C header file. Because displaying QR codes in Tkinter is the primary use case for this renderer, this method does not take a file parameter. Instead it retuns the rendered QR code data as a string. Example of using this renderer with Tkinter: >>> import pyqrcode >>> import tkinter >>> code = pyqrcode.create('Knights who say ni!') >>> code_xbm = code.xbm(scale=5) >>> >>> top = tkinter.Tk() >>> code_bmp = tkinter.BitmapImage(data=code_xbm) >>> code_bmp.config(foreground="black") >>> code_bmp.config(background="white") >>> label = tkinter.Label(image=code_bmp) >>> label.pack() The *scale* parameter sets how large to draw a single module. By default one pixel is used to draw a single module. This may make the code too small to be read efficiently. Increasing the scale will make the code larger. Only integer scales are usable. This method will attempt to coerce the parameter into an integer (e.g. 2.5 will become 2, and '3' will become 3). You can use the :py:meth:`get_png_size` method to calculate the actual pixel size of this image when displayed. The *quiet_zone* parameter sets how wide the quiet zone around the code should be. According to the standard this should be 4 modules. It is left settable because such a wide quiet zone is unnecessary in many applications where the QR code is not being printed. """ return builder._xbm(self.code, scale, quiet_zone) def svg(self, file, scale=1, module_color='#000', background=None, quiet_zone=4, xmldecl=True, svgns=True, title=None, svgclass='pyqrcode', lineclass='pyqrline', omithw=False, debug=False): """This method writes the QR code out as an SVG document. The code is drawn by drawing only the modules corresponding to a 1. They are drawn using a line, such that contiguous modules in a row are drawn with a single line. The *file* parameter is used to specify where to write the document to. It can either be a writable stream or a file path. The *scale* parameter sets how large to draw a single module. By default one pixel is used to draw a single module. This may make the code too small to be read efficiently. Increasing the scale will make the code larger. Unlike the png() method, this method will accept fractional scales (e.g. 2.5). Note, three things are done to make the code more appropriate for embedding in a HTML document. The "white" part of the code is actually transparent. The code itself has a class given by *svgclass* parameter. The path making up the QR code uses the class set using the *lineclass*. These should make the code easier to style using CSS. By default the output of this function is a complete SVG document. If only the code itself is desired, set the *xmldecl* to false. This will result in a fragment that contains only the "drawn" portion of the code. Likewise, you can set the *title* of the document. The SVG name space attribute can be suppressed by setting *svgns* to False. When True the *omithw* indicates if width and height attributes should be omitted. If these attributes are omitted, a ``viewBox`` attribute will be added to the document. You can also set the colors directly using the *module_color* and *background* parameters. The *module_color* parameter sets what color to use for the data modules (the black part on most QR codes). The *background* parameter sets what color to use for the background (the white part on most QR codes). The parameters can be set to any valid SVG or HTML color. If the background is set to None, then no background will be drawn, i.e. the background will be transparent. Note, many color combinations are unreadable by scanners, so be careful. The *quiet_zone* parameter sets how wide the quiet zone around the code should be. According to the standard this should be 4 modules. It is left settable because such a wide quiet zone is unnecessary in many applications where the QR code is not being printed. Example: >>> code = pyqrcode.create('Hello. Uhh, can we have your liver?') >>> code.svg('live-organ-transplants.svg', 3.6) >>> code.svg('live-organ-transplants.svg', scale=4, module_color='brown', background='0xFFFFFF') """ builder._svg(self.code, self.version, file, scale=scale, module_color=module_color, background=background, quiet_zone=quiet_zone, xmldecl=xmldecl, svgns=svgns, title=title, svgclass=svgclass, lineclass=lineclass, omithw=omithw, debug=debug) def eps(self, file, scale=1, module_color=(0, 0, 0), background=None, quiet_zone=4): """This method writes the QR code out as an EPS document. The code is drawn by only writing the data modules corresponding to a 1. They are drawn using a line, such that contiguous modules in a row are drawn with a single line. The *file* parameter is used to specify where to write the document to. It can either be a writable (text) stream or a file path. The *scale* parameter sets how large to draw a single module. By default one point (1/72 inch) is used to draw a single module. This may make the code to small to be read efficiently. Increasing the scale will make the code larger. This method will accept fractional scales (e.g. 2.5). The *module_color* parameter sets the color of the data modules. The *background* parameter sets the background (page) color to use. They are specified as either a triple of floats, e.g. (0.5, 0.5, 0.5), or a triple of integers, e.g. (128, 128, 128). The default *module_color* is black. The default *background* color is no background at all. The *quiet_zone* parameter sets how large to draw the border around the code. As per the standard, the default value is 4 modules. Examples: >>> qr = pyqrcode.create('Hello world') >>> qr.eps('hello-world.eps', scale=2.5, module_color='#36C') >>> qr.eps('hello-world2.eps', background='#eee') >>> out = io.StringIO() >>> qr.eps(out, module_color=(.4, .4, .4)) """ builder._eps(self.code, self.version, file, scale, module_color, background, quiet_zone) def terminal(self, module_color='default', background='reverse', quiet_zone=4): """This method returns a string containing ASCII escape codes, such that if printed to a compatible terminal, it will display a vaild QR code. The code is printed using ASCII escape codes that alter the coloring of the background. The *module_color* parameter sets what color to use for the data modules (the black part on most QR codes). Likewise, the *background* parameter sets what color to use for the background (the white part on most QR codes). There are two options for colors. The first, and most widely supported, is to use the 8 or 16 color scheme. This scheme uses eight to sixteen named colors. The following colors are supported the most widely supported: black, red, green, yellow, blue, magenta, and cyan. There are an some additional named colors that are supported by most terminals: light gray, dark gray, light red, light green, light blue, light yellow, light magenta, light cyan, and white. There are two special named colors. The first is the "default" color. This color is the color the background of the terminal is set to. The next color is the "reverse" color. This is not really a color at all but a special property that will reverse the current color. These two colors are the default values for *module_color* and *background* respectively. These values should work on most terminals. Finally, there is one more way to specify the color. Some terminals support 256 colors. The actual colors displayed in the terminal is system dependent. This is the least transportable option. To use the 256 color scheme set *module_color* and/or *background* to a number between 0 and 256. The *quiet_zone* parameter sets how wide the quiet zone around the code should be. According to the standard this should be 4 modules. It is left settable because such a wide quiet zone is unnecessary in many applications. Example: >>> code = pyqrcode.create('Example') >>> text = code.terminal() >>> print(text) """ return builder._terminal(self.code, module_color, background, quiet_zone) def text(self, quiet_zone=4): """This method returns a string based representation of the QR code. The data modules are represented by 1's and the background modules are represented by 0's. The main purpose of this method is to act a starting point for users to create their own renderers. The *quiet_zone* parameter sets how wide the quiet zone around the code should be. According to the standard this should be 4 modules. It is left settable because such a wide quiet zone is unnecessary in many applications. Example: >>> code = pyqrcode.create('Example') >>> text = code.text() >>> print(text) """ return builder._text(self.code, quiet_zone) PyQRCode-1.2.1/pyqrcode/tables.py0000644000175000017500000007532612663720643016535 0ustar mikemike00000000000000# -*- coding: utf-8 -*- # Copyright (c) 2013, Michael Nooner # All rights reserved. # # Redistribution and use in source and binary forms, with or without # modification, are permitted provided that the following conditions are met: # * Redistributions of source code must retain the above copyright # notice, this list of conditions and the following disclaimer. # * Redistributions in binary form must reproduce the above copyright # notice, this list of conditions and the following disclaimer in the # documentation and/or other materials provided with the distribution. # * Neither the name of the copyright holder nor the names of its # contributors may be used to endorse or promote products derived from # this software without specific prior written permission # # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" # AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE # IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE # ARE DISCLAIMED. IN NO EVENT SHALL BE LIABLE FOR ANY # DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES # (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; # LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND # ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS # SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. """This module lists out all of the tables needed to create a QR code. If you are viewing this in the HTML documentation, I recommend reading the actual file instead. The formating for the tables is much more readable. """ from __future__ import division, unicode_literals #: This defines the QR Code's 'mode' which sets what #: type of code it is along with its size. modes = { 'numeric': 1, 'alphanumeric': 2, 'binary': 4, 'kanji': 8, } #: This defines the amount of error correction. The dictionary #: allows the user to specify this in several ways. error_level = {'L': 'L', 'l': 'L', '7%': 'L', .7: 'L', 'M': 'M', 'm': 'M', '15%': 'M', .15: 'M', 'Q': 'Q', 'q': 'Q', '25%': 'Q', .25: 'Q', 'H': 'H', 'h': 'H', '30%': 'H', .30: 'H'} #: This is a dictionary holds how long the "data length" field is for #: each version and mode of the QR Code. data_length_field = {9: {1: 10, 2: 9, 4: 8, 8: 8}, 26: {1: 12, 2: 11, 4: 16, 8: 10}, 40: {1: 14, 2: 13, 4: 16, 8: 12}} #: QR Codes uses a unique ASCII-like table for the 'alphanumeric' mode. #: This is a dictionary representing that unique table, where the #: keys are the possible characters in the data and the values #: are the character's numeric representation. ascii_codes = {'0': 0, '1': 1, '2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8, '9': 9, 'A': 10, 'B': 11, 'C': 12, 'D': 13, 'E': 14, 'F': 15, 'G': 16, 'H': 17, 'I': 18, 'J': 19, 'K': 20, 'L': 21, 'M': 22, 'N': 23, 'O': 24, 'P': 25, 'Q': 26, 'R': 27, 'S': 28, 'T': 29, 'U': 30, 'V': 31, 'W': 32, 'X': 33, 'Y': 34, 'Z': 35, ' ': 36, '$': 37, '%': 38, '*': 39, '+': 40, '-': 41, '.': 42, '/': 43, ':': 44} #: This array specifies the size of a QR Code in pixels. These numbers are #: defined in the standard. The indexes correspond to the QR Code's #: version number. This array was taken from: #: #: http://www.denso-wave.com/qrcode/vertable1-e.html version_size = [None, 21, 25, 29, 33, 37, 41, 45, 49, 53, 57, 61, 65, 69, 73, 77, 81, 85, 89, 93, 97, 101, 105, 109, 113, 117, 121, 125, 129, 133, 137, 141, 145, 149, 153, 157, 161, 165, 169, 173, 177] #: This dictionary lists the data capacity for all possible QR Codes. #: This dictionary is organized where the first key corresponds to the #: QR Code version number. The next key corresponds to the error #: correction level, see error. The final key corresponds to #: the mode number, see modes. The zero mode number represents the #: possible "data bits." This table was taken from: #: #: http://www.denso-wave.com/qrcode/vertable1-e.html data_capacity = { 1: { "L": {0: 152, 1: 41, 2: 25, 4: 17, 8: 10, }, "M": {0: 128, 1: 34, 2: 20, 4: 14, 8: 8, }, "Q": {0: 104, 1: 27, 2: 16, 4: 11, 8: 7, }, "H": {0: 72, 1: 17, 2: 10, 4: 7, 8: 4, }}, 2: { "L": {0: 272, 1: 77, 2: 47, 4: 32, 8: 20, }, "M": {0: 224, 1: 63, 2: 38, 4: 26, 8: 16, }, "Q": {0: 176, 1: 48, 2: 29, 4: 20, 8: 12, }, "H": {0: 128, 1: 34, 2: 20, 4: 14, 8: 8, }}, 3: { "L": {0: 440, 1: 127, 2: 77, 4: 53, 8: 32, }, "M": {0: 352, 1: 101, 2: 61, 4: 42, 8: 26, }, "Q": {0: 272, 1: 77, 2: 47, 4: 32, 8: 20, }, "H": {0: 208, 1: 58, 2: 35, 4: 24, 8: 15, }}, 4: { "L": {0: 640, 1: 187, 2: 114, 4: 78, 8: 48, }, "M": {0: 512, 1: 149, 2: 90, 4: 62, 8: 38, }, "Q": {0: 384, 1: 111, 2: 67, 4: 46, 8: 28, }, "H": {0: 288, 1: 82, 2: 50, 4: 34, 8: 21, }}, 5: { "L": {0: 864, 1: 255, 2: 154, 4: 106, 8: 65, }, "M": {0: 688, 1: 202, 2: 122, 4: 84, 8: 52, }, "Q": {0: 496, 1: 144, 2: 87, 4: 60, 8: 37, }, "H": {0: 368, 1: 106, 2: 64, 4: 44, 8: 27, }}, 6: { "L": {0: 1088, 1: 322, 2: 195, 4: 134, 8: 82, }, "M": {0: 864, 1: 255, 2: 154, 4: 106, 8: 65, }, "Q": {0: 608, 1: 178, 2: 108, 4: 74, 8: 45, }, "H": {0: 480, 1: 139, 2: 84, 4: 58, 8: 36, }}, 7: { "L": {0: 1248, 1: 370, 2: 224, 4: 154, 8: 95, }, "M": {0: 992, 1: 293, 2: 178, 4: 122, 8: 75, }, "Q": {0: 704, 1: 207, 2: 125, 4: 86, 8: 53, }, "H": {0: 528, 1: 154, 2: 93, 4: 64, 8: 39, }}, 8: { "L": {0: 1552, 1: 461, 2: 279, 4: 192, 8: 118, }, "M": {0: 1232, 1: 365, 2: 221, 4: 152, 8: 93, }, "Q": {0: 880, 1: 259, 2: 157, 4: 108, 8: 66, }, "H": {0: 688, 1: 202, 2: 122, 4: 84, 8: 52, }}, 9: { "L": {0: 1856, 1: 552, 2: 335, 4: 230, 8: 141, }, "M": {0: 1456, 1: 432, 2: 262, 4: 180, 8: 111, }, "Q": {0: 1056, 1: 312, 2: 189, 4: 130, 8: 80, }, "H": {0: 800, 1: 235, 2: 143, 4: 98, 8: 60, }}, 10: { "L": {0: 2192, 1: 652, 2: 395, 4: 271, 8: 167, }, "M": {0: 1728, 1: 513, 2: 311, 4: 213, 8: 131, }, "Q": {0: 1232, 1: 364, 2: 221, 4: 151, 8: 93, }, "H": {0: 976, 1: 288, 2: 174, 4: 119, 8: 74, }}, 11: { "L": {0: 2592, 1: 772, 2: 468, 4: 321, 8: 198, }, "M": {0: 2032, 1: 604, 2: 366, 4: 251, 8: 155, }, "Q": {0: 1440, 1: 427, 2: 259, 4: 177, 8: 109, }, "H": {0: 1120, 1: 331, 2: 200, 4: 137, 8: 85, }}, 12: { "L": {0: 2960, 1: 883, 2: 535, 4: 367, 8: 226, }, "M": {0: 2320, 1: 691, 2: 419, 4: 287, 8: 177, }, "Q": {0: 1648, 1: 489, 2: 296, 4: 203, 8: 125, }, "H": {0: 1264, 1: 374, 2: 227, 4: 155, 8: 96, }}, 13: { "L": {0: 3424, 1: 1022, 2: 619, 4: 425, 8: 262, }, "M": {0: 2672, 1: 796, 2: 483, 4: 331, 8: 204, }, "Q": {0: 1952, 1: 580, 2: 352, 4: 241, 8: 149, }, "H": {0: 1440, 1: 427, 2: 259, 4: 177, 8: 109, }}, 14: { "L": {0: 3688, 1: 1101, 2: 667, 4: 458, 8: 282, }, "M": {0: 2920, 1: 871, 2: 528, 4: 362, 8: 223, }, "Q": {0: 2088, 1: 621, 2: 376, 4: 258, 8: 159, }, "H": {0: 1576, 1: 468, 2: 283, 4: 194, 8: 120, }}, 15: { "L": {0: 4184, 1: 1250, 2: 758, 4: 520, 8: 320, }, "M": {0: 3320, 1: 991, 2: 600, 4: 412, 8: 254, }, "Q": {0: 2360, 1: 703, 2: 426, 4: 292, 8: 180, }, "H": {0: 1784, 1: 530, 2: 321, 4: 220, 8: 136, }}, 16: { "L": {0: 4712, 1: 1408, 2: 854, 4: 586, 8: 361, }, "M": {0: 3624, 1: 1082, 2: 656, 4: 450, 8: 277, }, "Q": {0: 2600, 1: 775, 2: 470, 4: 322, 8: 198, }, "H": {0: 2024, 1: 602, 2: 365, 4: 250, 8: 154, }}, 17: { "L": {0: 5176, 1: 1548, 2: 938, 4: 644, 8: 397, }, "M": {0: 4056, 1: 1212, 2: 734, 4: 504, 8: 310, }, "Q": {0: 2936, 1: 876, 2: 531, 4: 364, 8: 224, }, "H": {0: 2264, 1: 674, 2: 408, 4: 280, 8: 173, }}, 18: { "L": {0: 5768, 1: 1725, 2: 1046, 4: 718, 8: 442, }, "M": {0: 4504, 1: 1346, 2: 816, 4: 560, 8: 345, }, "Q": {0: 3176, 1: 948, 2: 574, 4: 394, 8: 243, }, "H": {0: 2504, 1: 746, 2: 452, 4: 310, 8: 191, }}, 19: { "L": {0: 6360, 1: 1903, 2: 1153, 4: 792, 8: 488, }, "M": {0: 5016, 1: 1500, 2: 909, 4: 624, 8: 384, }, "Q": {0: 3560, 1: 1063, 2: 644, 4: 442, 8: 272, }, "H": {0: 2728, 1: 813, 2: 493, 4: 338, 8: 208, }}, 20: { "L": {0: 6888, 1: 2061, 2: 1249, 4: 858, 8: 528, }, "M": {0: 5352, 1: 1600, 2: 970, 4: 666, 8: 410, }, "Q": {0: 3880, 1: 1159, 2: 702, 4: 482, 8: 297, }, "H": {0: 3080, 1: 919, 2: 557, 4: 382, 8: 235, }}, 21: { "L": {0: 7456, 1: 2232, 2: 1352, 4: 929, 8: 572, }, "M": {0: 5712, 1: 1708, 2: 1035, 4: 711, 8: 438, }, "Q": {0: 4096, 1: 1224, 2: 742, 4: 509, 8: 314, }, "H": {0: 3248, 1: 969, 2: 587, 4: 403, 8: 248, }}, 22: { "L": {0: 8048, 1: 2409, 2: 1460, 4: 1003, 8: 618, }, "M": {0: 6256, 1: 1872, 2: 1134, 4: 779, 8: 480, }, "Q": {0: 4544, 1: 1358, 2: 823, 4: 565, 8: 348, }, "H": {0: 3536, 1: 1056, 2: 640, 4: 439, 8: 270, }}, 23: { "L": {0: 8752, 1: 2620, 2: 1588, 4: 1091, 8: 672, }, "M": {0: 6880, 1: 2059, 2: 1248, 4: 857, 8: 528, }, "Q": {0: 4912, 1: 1468, 2: 890, 4: 611, 8: 376, }, "H": {0: 3712, 1: 1108, 2: 672, 4: 461, 8: 284, }}, 24: { "L": {0: 9392, 1: 2812, 2: 1704, 4: 1171, 8: 721, }, "M": {0: 7312, 1: 2188, 2: 1326, 4: 911, 8: 561, }, "Q": {0: 5312, 1: 1588, 2: 963, 4: 661, 8: 407, }, "H": {0: 4112, 1: 1228, 2: 744, 4: 511, 8: 315, }}, 25: { "L": {0: 10208, 1: 3057, 2: 1853, 4: 1273, 8: 784, }, "M": {0: 8000, 1: 2395, 2: 1451, 4: 997, 8: 614, }, "Q": {0: 5744, 1: 1718, 2: 1041, 4: 715, 8: 440, }, "H": {0: 4304, 1: 1286, 2: 779, 4: 535, 8: 330, }}, 26: { "L": {0: 10960, 1: 3283, 2: 1990, 4: 1367, 8: 842, }, "M": {0: 8496, 1: 2544, 2: 1542, 4: 1059, 8: 652, }, "Q": {0: 6032, 1: 1804, 2: 1094, 4: 751, 8: 462, }, "H": {0: 4768, 1: 1425, 2: 864, 4: 593, 8: 365, }}, 27: { "L": {0: 11744, 1: 3514, 2: 2132, 4: 1465, 8: 902, }, "M": {0: 9024, 1: 2701, 2: 1637, 4: 1125, 8: 692, }, "Q": {0: 6464, 1: 1933, 2: 1172, 4: 805, 8: 496, }, "H": {0: 5024, 1: 1501, 2: 910, 4: 625, 8: 385, }}, 28: { "L": {0: 12248, 1: 3669, 2: 2223, 4: 1528, 8: 940, }, "M": {0: 9544, 1: 2857, 2: 1732, 4: 1190, 8: 732, }, "Q": {0: 6968, 1: 2085, 2: 1263, 4: 868, 8: 534, }, "H": {0: 5288, 1: 1581, 2: 958, 4: 658, 8: 405, }}, 29: { "L": {0: 13048, 1: 3909, 2: 2369, 4: 1628, 8: 1002, }, "M": {0: 10136, 1: 3035, 2: 1839, 4: 1264, 8: 778, }, "Q": {0: 7288, 1: 2181, 2: 1322, 4: 908, 8: 559, }, "H": {0: 5608, 1: 1677, 2: 1016, 4: 698, 8: 430, }}, 30: { "L": {0: 13880, 1: 4158, 2: 2520, 4: 1732, 8: 1066, }, "M": {0: 10984, 1: 3289, 2: 1994, 4: 1370, 8: 843, }, "Q": {0: 7880, 1: 2358, 2: 1429, 4: 982, 8: 604, }, "H": {0: 5960, 1: 1782, 2: 1080, 4: 742, 8: 457, }}, 31: { "L": {0: 14744, 1: 4417, 2: 2677, 4: 1840, 8: 1132, }, "M": {0: 11640, 1: 3486, 2: 2113, 4: 1452, 8: 894, }, "Q": {0: 8264, 1: 2473, 2: 1499, 4: 1030, 8: 634, }, "H": {0: 6344, 1: 1897, 2: 1150, 4: 790, 8: 486, }}, 32: { "L": {0: 15640, 1: 4686, 2: 2840, 4: 1952, 8: 1201, }, "M": {0: 12328, 1: 3693, 2: 2238, 4: 1538, 8: 947, }, "Q": {0: 8920, 1: 2670, 2: 1618, 4: 1112, 8: 684, }, "H": {0: 6760, 1: 2022, 2: 1226, 4: 842, 8: 518, }}, 33: { "L": {0: 16568, 1: 4965, 2: 3009, 4: 2068, 8: 1273, }, "M": {0: 13048, 1: 3909, 2: 2369, 4: 1628, 8: 1002, }, "Q": {0: 9368, 1: 2805, 2: 1700, 4: 1168, 8: 719, }, "H": {0: 7208, 1: 2157, 2: 1307, 4: 898, 8: 553, }}, 34: { "L": {0: 17528, 1: 5253, 2: 3183, 4: 2188, 8: 1347, }, "M": {0: 13800, 1: 4134, 2: 2506, 4: 1722, 8: 1060, }, "Q": {0: 9848, 1: 2949, 2: 1787, 4: 1228, 8: 756, }, "H": {0: 7688, 1: 2301, 2: 1394, 4: 958, 8: 590, }}, 35: { "L": {0: 18448, 1: 5529, 2: 3351, 4: 2303, 8: 1417, }, "M": {0: 14496, 1: 4343, 2: 2632, 4: 1809, 8: 1113, }, "Q": {0: 10288, 1: 3081, 2: 1867, 4: 1283, 8: 790, }, "H": {0: 7888, 1: 2361, 2: 1431, 4: 983, 8: 605, }}, 36: { "L": {0: 19472, 1: 5836, 2: 3537, 4: 2431, 8: 1496, }, "M": {0: 15312, 1: 4588, 2: 2780, 4: 1911, 8: 1176, }, "Q": {0: 10832, 1: 3244, 2: 1966, 4: 1351, 8: 832, }, "H": {0: 8432, 1: 2524, 2: 1530, 4: 1051, 8: 647, }}, 37: { "L": {0: 20528, 1: 6153, 2: 3729, 4: 2563, 8: 1577, }, "M": {0: 15936, 1: 4775, 2: 2894, 4: 1989, 8: 1224, }, "Q": {0: 11408, 1: 3417, 2: 2071, 4: 1423, 8: 876, }, "H": {0: 8768, 1: 2625, 2: 1591, 4: 1093, 8: 673, }}, 38: { "L": {0: 21616, 1: 6479, 2: 3927, 4: 2699, 8: 1661, }, "M": {0: 16816, 1: 5039, 2: 3054, 4: 2099, 8: 1292, }, "Q": {0: 12016, 1: 3599, 2: 2181, 4: 1499, 8: 923, }, "H": {0: 9136, 1: 2735, 2: 1658, 4: 1139, 8: 701, }}, 39: { "L": {0: 22496, 1: 6743, 2: 4087, 4: 2809, 8: 1729, }, "M": {0: 17728, 1: 5313, 2: 3220, 4: 2213, 8: 1362, }, "Q": {0: 12656, 1: 3791, 2: 2298, 4: 1579, 8: 972, }, "H": {0: 9776, 1: 2927, 2: 1774, 4: 1219, 8: 750, }}, 40: { "L": {0: 23648, 1: 7089, 2: 4296, 4: 2953, 8: 1817, }, "M": {0: 18672, 1: 5596, 2: 3391, 4: 2331, 8: 1435, }, "Q": {0: 13328, 1: 3993, 2: 2420, 4: 1663, 8: 1024, }, "H": {0: 10208, 1: 3057, 2: 1852, 4: 1273, 8: 784, }} } #: This table defines the "Error Correction Code Words and Block Information." #: The table lists the number of error correction words that are required #: to be generated for each version and error correction level. The table #: is accessed by first using the version number as a key and then the #: error level. The array values correspond to these columns from the source #: table: #: #: +----------------------------+ #: |0 | EC Code Words Per Block | #: +----------------------------+ #: |1 | Block 1 Count | #: +----------------------------+ #: |2 | Block 1 Data Code Words | #: +----------------------------+ #: |3 | Block 2 Count | #: +----------------------------+ #: |4 | Block 2 Data Code Words | #: +----------------------------+ #: #: This table was taken from: #: #: http://www.thonky.com/qr-code-tutorial/error-correction-table/ eccwbi = { 1: { 'L': [7, 1, 19, 0, 0, ], 'M': [10, 1, 16, 0, 0, ], 'Q': [13, 1, 13, 0, 0, ], 'H': [17, 1, 9, 0, 0, ], }, 2: { 'L': [10, 1, 34, 0, 0, ], 'M': [16, 1, 28, 0, 0, ], 'Q': [22, 1, 22, 0, 0, ], 'H': [28, 1, 16, 0, 0, ], }, 3: { 'L': [15, 1, 55, 0, 0, ], 'M': [26, 1, 44, 0, 0, ], 'Q': [18, 2, 17, 0, 0, ], 'H': [22, 2, 13, 0, 0, ], }, 4: { 'L': [20, 1, 80, 0, 0, ], 'M': [18, 2, 32, 0, 0, ], 'Q': [26, 2, 24, 0, 0, ], 'H': [16, 4, 9, 0, 0, ], }, 5: { 'L': [26, 1, 108, 0, 0, ], 'M': [24, 2, 43, 0, 0, ], 'Q': [18, 2, 15, 2, 16, ], 'H': [22, 2, 11, 2, 12, ], }, 6: { 'L': [18, 2, 68, 0, 0, ], 'M': [16, 4, 27, 0, 0, ], 'Q': [24, 4, 19, 0, 0, ], 'H': [28, 4, 15, 0, 0, ], }, 7: { 'L': [20, 2, 78, 0, 0, ], 'M': [18, 4, 31, 0, 0, ], 'Q': [18, 2, 14, 4, 15, ], 'H': [26, 4, 13, 1, 14, ], }, 8: { 'L': [24, 2, 97, 0, 0, ], 'M': [22, 2, 38, 2, 39, ], 'Q': [22, 4, 18, 2, 19, ], 'H': [26, 4, 14, 2, 15, ], }, 9: { 'L': [30, 2, 116, 0, 0, ], 'M': [22, 3, 36, 2, 37, ], 'Q': [20, 4, 16, 4, 17, ], 'H': [24, 4, 12, 4, 13, ], }, 10: { 'L': [18, 2, 68, 2, 69, ], 'M': [26, 4, 43, 1, 44, ], 'Q': [24, 6, 19, 2, 20, ], 'H': [28, 6, 15, 2, 16, ], }, 11: { 'L': [20, 4, 81, 0, 0, ], 'M': [30, 1, 50, 4, 51, ], 'Q': [28, 4, 22, 4, 23, ], 'H': [24, 3, 12, 8, 13, ], }, 12: { 'L': [24, 2, 92, 2, 93, ], 'M': [22, 6, 36, 2, 37, ], 'Q': [26, 4, 20, 6, 21, ], 'H': [28, 7, 14, 4, 15, ], }, 13: { 'L': [26, 4, 107, 0, 0, ], 'M': [22, 8, 37, 1, 38, ], 'Q': [24, 8, 20, 4, 21, ], 'H': [22, 12, 11, 4, 12, ], }, 14: { 'L': [30, 3, 115, 1, 116, ], 'M': [24, 4, 40, 5, 41, ], 'Q': [20, 11, 16, 5, 17, ], 'H': [24, 11, 12, 5, 13, ], }, 15: { 'L': [22, 5, 87, 1, 88, ], 'M': [24, 5, 41, 5, 42, ], 'Q': [30, 5, 24, 7, 25, ], 'H': [24, 11, 12, 7, 13, ], }, 16: { 'L': [24, 5, 98, 1, 99, ], 'M': [28, 7, 45, 3, 46, ], 'Q': [24, 15, 19, 2, 20, ], 'H': [30, 3, 15, 13, 16, ], }, 17: { 'L': [28, 1, 107, 5, 108, ], 'M': [28, 10, 46, 1, 47, ], 'Q': [28, 1, 22, 15, 23, ], 'H': [28, 2, 14, 17, 15, ], }, 18: { 'L': [30, 5, 120, 1, 121, ], 'M': [26, 9, 43, 4, 44, ], 'Q': [28, 17, 22, 1, 23, ], 'H': [28, 2, 14, 19, 15, ], }, 19: { 'L': [28, 3, 113, 4, 114, ], 'M': [26, 3, 44, 11, 45, ], 'Q': [26, 17, 21, 4, 22, ], 'H': [26, 9, 13, 16, 14, ], }, 20: { 'L': [28, 3, 107, 5, 108, ], 'M': [26, 3, 41, 13, 42, ], 'Q': [30, 15, 24, 5, 25, ], 'H': [28, 15, 15, 10, 16, ], }, 21: { 'L': [28, 4, 116, 4, 117, ], 'M': [26, 17, 42, 0, 0, ], 'Q': [28, 17, 22, 6, 23, ], 'H': [30, 19, 16, 6, 17, ], }, 22: { 'L': [28, 2, 111, 7, 112, ], 'M': [28, 17, 46, 0, 0, ], 'Q': [30, 7, 24, 16, 25, ], 'H': [24, 34, 13, 0, 0, ], }, 23: { 'L': [30, 4, 121, 5, 122, ], 'M': [28, 4, 47, 14, 48, ], 'Q': [30, 11, 24, 14, 25, ], 'H': [30, 16, 15, 14, 16, ], }, 24: { 'L': [30, 6, 117, 4, 118, ], 'M': [28, 6, 45, 14, 46, ], 'Q': [30, 11, 24, 16, 25, ], 'H': [30, 30, 16, 2, 17, ], }, 25: { 'L': [26, 8, 106, 4, 107, ], 'M': [28, 8, 47, 13, 48, ], 'Q': [30, 7, 24, 22, 25, ], 'H': [30, 22, 15, 13, 16, ], }, 26: { 'L': [28, 10, 114, 2, 115, ], 'M': [28, 19, 46, 4, 47, ], 'Q': [28, 28, 22, 6, 23, ], 'H': [30, 33, 16, 4, 17, ], }, 27: { 'L': [30, 8, 122, 4, 123, ], 'M': [28, 22, 45, 3, 46, ], 'Q': [30, 8, 23, 26, 24, ], 'H': [30, 12, 15, 28, 16, ], }, 28: { 'L': [30, 3, 117, 10, 118, ], 'M': [28, 3, 45, 23, 46, ], 'Q': [30, 4, 24, 31, 25, ], 'H': [30, 11, 15, 31, 16, ], }, 29: { 'L': [30, 7, 116, 7, 117, ], 'M': [28, 21, 45, 7, 46, ], 'Q': [30, 1, 23, 37, 24, ], 'H': [30, 19, 15, 26, 16, ], }, 30: { 'L': [30, 5, 115, 10, 116, ], 'M': [28, 19, 47, 10, 48, ], 'Q': [30, 15, 24, 25, 25, ], 'H': [30, 23, 15, 25, 16, ], }, 31: { 'L': [30, 13, 115, 3, 116, ], 'M': [28, 2, 46, 29, 47, ], 'Q': [30, 42, 24, 1, 25, ], 'H': [30, 23, 15, 28, 16, ], }, 32: { 'L': [30, 17, 115, 0, 0, ], 'M': [28, 10, 46, 23, 47, ], 'Q': [30, 10, 24, 35, 25, ], 'H': [30, 19, 15, 35, 16, ], }, 33: { 'L': [30, 17, 115, 1, 116, ], 'M': [28, 14, 46, 21, 47, ], 'Q': [30, 29, 24, 19, 25, ], 'H': [30, 11, 15, 46, 16, ], }, 34: { 'L': [30, 13, 115, 6, 116, ], 'M': [28, 14, 46, 23, 47, ], 'Q': [30, 44, 24, 7, 25, ], 'H': [30, 59, 16, 1, 17, ], }, 35: { 'L': [30, 12, 121, 7, 122, ], 'M': [28, 12, 47, 26, 48, ], 'Q': [30, 39, 24, 14, 25, ], 'H': [30, 22, 15, 41, 16, ], }, 36: { 'L': [30, 6, 121, 14, 122, ], 'M': [28, 6, 47, 34, 48, ], 'Q': [30, 46, 24, 10, 25, ], 'H': [30, 2, 15, 64, 16, ], }, 37: { 'L': [30, 17, 122, 4, 123, ], 'M': [28, 29, 46, 14, 47, ], 'Q': [30, 49, 24, 10, 25, ], 'H': [30, 24, 15, 46, 16, ], }, 38: { 'L': [30, 4, 122, 18, 123, ], 'M': [28, 13, 46, 32, 47, ], 'Q': [30, 48, 24, 14, 25, ], 'H': [30, 42, 15, 32, 16, ], }, 39: { 'L': [30, 20, 117, 4, 118, ], 'M': [28, 40, 47, 7, 48, ], 'Q': [30, 43, 24, 22, 25, ], 'H': [30, 10, 15, 67, 16, ], }, 40: { 'L': [30, 19, 118, 6, 119, ], 'M': [28, 18, 47, 31, 48, ], 'Q': [30, 34, 24, 34, 25, ], 'H': [30, 20, 15, 61, 16, ], }, } #: This table lists all of the generator polynomials used by QR Codes. #: They are indexed by the number of "ECC Code Words" (see table above). #: This table is taken from: #: #: http://www.matchadesign.com/blog/qr-code-demystified-part-4/ generator_polynomials = { 7: [87, 229, 146, 149, 238, 102, 21], 10: [251, 67, 46, 61, 118, 70, 64, 94, 32, 45], 13: [74, 152, 176, 100, 86, 100, 106, 104, 130, 218, 206, 140, 78], 15: [8, 183, 61, 91, 202, 37, 51, 58, 58, 237, 140, 124, 5, 99, 105], 16: [120, 104, 107, 109, 102, 161, 76, 3, 91, 191, 147, 169, 182, 194, 225, 120], 17: [43, 139, 206, 78, 43, 239, 123, 206, 214, 147, 24, 99, 150, 39, 243, 163, 136], 18: [215, 234, 158, 94, 184, 97, 118, 170, 79, 187, 152, 148, 252, 179, 5, 98, 96, 153], 20: [17, 60, 79, 50, 61, 163, 26, 187, 202, 180, 221, 225, 83, 239, 156, 164, 212, 212, 188, 190], 22: [210, 171, 247, 242, 93, 230, 14, 109, 221, 53, 200, 74, 8, 172, 98, 80, 219, 134, 160, 105, 165, 231], 24: [229, 121, 135, 48, 211, 117, 251, 126, 159, 180, 169, 152, 192, 226, 228, 218, 111, 0, 117, 232, 87, 96, 227, 21], 26: [173, 125, 158, 2, 103, 182, 118, 17, 145, 201, 111, 28, 165, 53, 161, 21, 245, 142, 13, 102, 48, 227, 153, 145, 218, 70], 28: [168, 223, 200, 104, 224, 234, 108, 180, 110, 190, 195, 147, 205, 27, 232, 201, 21, 43, 245, 87, 42, 195, 212, 119, 242, 37, 9, 123], 30: [41, 173, 145, 152, 216, 31, 179, 182, 50, 48, 110, 86, 239, 96, 222, 125, 42, 173, 226, 193, 224, 130, 156, 37, 251, 216, 238, 40, 192, 180] } #: This table contains the log and values used in GF(256) arithmetic. #: They are used to generate error correction codes for QR Codes. #: This table is taken from: #: #: vhttp://www.thonky.com/qr-code-tutorial/log-antilog-table/ galois_log = [ 1, 2, 4, 8, 16, 32, 64, 128, 29, 58, 116, 232, 205, 135, 19, 38, 76, 152, 45, 90, 180, 117, 234, 201, 143, 3, 6, 12, 24, 48, 96, 192, 157, 39, 78, 156, 37, 74, 148, 53, 106, 212, 181, 119, 238, 193, 159, 35, 70, 140, 5, 10, 20, 40, 80, 160, 93, 186, 105, 210, 185, 111, 222, 161, 95, 190, 97, 194, 153, 47, 94, 188, 101, 202, 137, 15, 30, 60, 120, 240, 253, 231, 211, 187, 107, 214, 177, 127, 254, 225, 223, 163, 91, 182, 113, 226, 217, 175, 67, 134, 17, 34, 68, 136, 13, 26, 52, 104, 208, 189, 103, 206, 129, 31, 62, 124, 248, 237, 199, 147, 59, 118, 236, 197, 151, 51, 102, 204, 133, 23, 46, 92, 184, 109, 218, 169, 79, 158, 33, 66, 132, 21, 42, 84, 168, 77, 154, 41, 82, 164, 85, 170, 73, 146, 57, 114, 228, 213, 183, 115, 230, 209, 191, 99, 198, 145, 63, 126, 252, 229, 215, 179, 123, 246, 241, 255, 227, 219, 171, 75, 150, 49, 98, 196, 149, 55, 110, 220, 165, 87, 174, 65, 130, 25, 50, 100, 200, 141, 7, 14, 28, 56, 112, 224, 221, 167, 83, 166, 81, 162, 89, 178, 121, 242, 249, 239, 195, 155, 43, 86, 172, 69, 138, 9, 18, 36, 72, 144, 61, 122, 244, 245, 247, 243, 251, 235, 203, 139, 11, 22, 44, 88, 176, 125, 250, 233, 207, 131, 27, 54, 108, 216, 173, 71, 142, 1,] #: This table contains the antilog and values used in GF(256) arithmetic. #: They are used to generate error correction codes for QR Codes. #: This table is taken from: #: #: http://www.thonky.com/qr-code-tutorial/log-antilog-table/ galois_antilog = [ None, 0, 1, 25, 2, 50, 26, 198, 3, 223, 51, 238, 27, 104, 199, 75, 4, 100, 224, 14, 52, 141, 239, 129, 28, 193, 105, 248, 200, 8, 76, 113, 5, 138, 101, 47, 225, 36, 15, 33, 53, 147, 142, 218, 240, 18, 130, 69, 29, 181, 194, 125, 106, 39, 249, 185, 201, 154, 9, 120, 77, 228, 114, 166, 6, 191, 139, 98, 102, 221, 48, 253, 226, 152, 37, 179, 16, 145, 34, 136, 54, 208, 148, 206, 143, 150, 219, 189, 241, 210, 19, 92, 131, 56, 70, 64, 30, 66, 182, 163, 195, 72, 126, 110, 107, 58, 40, 84, 250, 133, 186, 61, 202, 94, 155, 159, 10, 21, 121, 43, 78, 212, 229, 172, 115, 243, 167, 87, 7, 112, 192, 247, 140, 128, 99, 13, 103, 74, 222, 237, 49, 197, 254, 24, 227, 165, 153, 119, 38, 184, 180, 124, 17, 68, 146, 217, 35, 32, 137, 46, 55, 63, 209, 91, 149, 188, 207, 205, 144, 135, 151, 178, 220, 252, 190, 97, 242, 86, 211, 171, 20, 42, 93, 158, 132, 60, 57, 83, 71, 109, 65, 162, 31, 45, 67, 216, 183, 123, 164, 118, 196, 23, 73, 236, 127, 12, 111, 246, 108, 161, 59, 82, 41, 157, 85, 170, 251, 96, 134, 177, 187, 204, 62, 90, 203, 89, 95, 176, 156, 169, 160, 81, 11, 245, 22, 235, 122, 117, 44, 215, 79, 174, 213, 233, 230, 231, 173, 232, 116, 214, 244, 234, 168, 80, 88, 175,] #: This table contains the coordinates for the position adjustment patterns. #: The index of the table corresponds to the QR Code's version number. #: This table is taken from: #: #: http://www.thonky.com/qr-code-tutorial/part-3-mask-pattern/ position_adjustment = [ None, #There is not version 0 None, #Version 1 does not need adjustment [6, 18, ], [6, 22, ], [6, 26, ], [6, 30, ], [6, 34, ], [6, 22, 38, ], [6, 24, 42, ], [6, 26, 46, ], [6, 28, 50, ], [6, 30, 54, ], [6, 32, 58, ], [6, 34, 62, ], [6, 26, 46, 66, ], [6, 26, 48, 70, ], [6, 26, 50, 74, ], [6, 30, 54, 78, ], [6, 30, 56, 82, ], [6, 30, 58, 86, ], [6, 34, 62, 90, ], [6, 28, 50, 72, 94, ], [6, 26, 50, 74, 98, ], [6, 30, 54, 78, 102, ], [6, 28, 54, 80, 106, ], [6, 32, 58, 84, 110, ], [6, 30, 58, 86, 114, ], [6, 34, 62, 90, 118, ], [6, 26, 50, 74, 98, 122, ], [6, 30, 54, 78, 102, 126, ], [6, 26, 52, 78, 104, 130, ], [6, 30, 56, 82, 108, 134, ], [6, 34, 60, 86, 112, 138, ], [6, 30, 58, 86, 114, 142, ], [6, 34, 62, 90, 118, 146, ], [6, 30, 54, 78, 102, 126, 150, ], [6, 24, 50, 76, 102, 128, 154, ], [6, 28, 54, 80, 106, 132, 158, ], [6, 32, 58, 84, 110, 136, 162, ], [6, 26, 54, 82, 110, 138, 166, ], [6, 30, 58, 86, 114, 142, 170, ], ] #: This table specifies the bit pattern to be added to a QR Code's #: image to specify what version the code is. Note, this pattern #: is not used for versions 1-6. This table is taken from: #: #: http://www.thonky.com/qr-code-tutorial/part-3-mask-pattern/ version_pattern = [None, None, None, None, None, None, None, #0-6 '000111110010010100', '001000010110111100', '001001101010011001', '001010010011010011', '001011101111110110', '001100011101100010', '001101100001000111', '001110011000001101', '001111100100101000', '010000101101111000', '010001010001011101', '010010101000010111', '010011010100110010', '010100100110100110', '010101011010000011', '010110100011001001', '010111011111101100', '011000111011000100', '011001000111100001', '011010111110101011', '011011000010001110', '011100110000011010', '011101001100111111', '011110110101110101', '011111001001010000', '100000100111010101', '100001011011110000', '100010100010111010', '100011011110011111', '100100101100001011', '100101010000101110', '100110101001100100', '100111010101000001', '101000110001101001' ] #: This table contains the bit fields needed to specify the error code level and #: mask pattern used by a QR Code. This table is take from: #: #: http://www.thonky.com/qr-code-tutorial/part-3-mask-pattern/ type_bits = { 'L': { 0: '111011111000100', 1: '111001011110011', 2: '111110110101010', 3: '111100010011101', 4: '110011000101111', 5: '110001100011000', 6: '110110001000001', 7: '110100101110110', }, 'M': { 0: '101010000010010', 1: '101000100100101', 2: '101111001111100', 3: '101101101001011', 4: '100010111111001', 5: '100000011001110', 6: '100111110010111', 7: '100101010100000', }, 'Q': { 0: '011010101011111', 1: '011000001101000', 2: '011111100110001', 3: '011101000000110', 4: '010010010110100', 5: '010000110000011', 6: '010111011011010', 7: '010101111101101', }, 'H': { 0: '001011010001001', 1: '001001110111110', 2: '001110011100111', 3: '001100111010000', 4: '000011101100010', 5: '000001001010101', 6: '000110100001100', 7: '000100000111011', }, } #: This table contains *functions* to compute whether to change current bit when #: creating the masks. All of the functions in the table return a boolean value. #: A True result means you should add the bit to the QR Code exactly as is. A #: False result means you should add the opposite bit. This table was taken #: from: #: #: http://www.thonky.com/qr-code-tutorial/mask-patterns/ mask_patterns = [ lambda row, col: (row + col) % 2 == 0, lambda row, col: row % 2 == 0, lambda row, col: col % 3 == 0, lambda row, col: (row + col) % 3 == 0, lambda row, col: ((row // 2) + (col // 3)) % 2 == 0, lambda row, col: ((row * col) % 2) + ((row * col) % 3) == 0, lambda row, col: (((row * col) % 2) + ((row * col) % 3)) % 2 == 0, lambda row, col: (((row + col) % 2) + ((row * col) % 3)) % 2 == 0] #: This is a table of ASCII escape code for terminal colors. QR codes #: are drawn using a space with a colored background. Hence, only #: codes affecting background colors have been added. #: http://misc.flogisoft.com/bash/tip_colors_and_formatting term_colors = { 'default': 49, 'background': 49, 'reverse': 7, 'reversed': 7, 'inverse': 7, 'inverted': 7, 'black': 40, 'red': 41, 'green': 42, 'yellow': 43, 'blue': 44, 'magenta': 45, 'cyan': 46, 'light gray': 47, 'light grey': 47, 'dark gray': 100, 'dark grey': 100, 'light red': 101, 'light green': 102, 'light blue': 103, 'light yellow': 104, 'light magenta': 105, 'light cyan': 106, 'white': 107 } PyQRCode-1.2.1/setup.py0000644000175000017500000000623612731661054014563 0ustar mikemike00000000000000# Copyright (c) 2013, Michael Nooner # All rights reserved. # # Redistribution and use in source and binary forms, with or without # modification, are permitted provided that the following conditions are met: # * Redistributions of source code must retain the above copyright # notice, this list of conditions and the following disclaimer. # * Redistributions in binary form must reproduce the above copyright # notice, this list of conditions and the following disclaimer in the # documentation and/or other materials provided with the distribution. # * Neither the name of the copyright holder nor the names of its # contributors may be used to endorse or promote products derived from # this software without specific prior written permission # # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" # AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE # IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE # ARE DISCLAIMED. IN NO EVENT SHALL BE LIABLE FOR ANY # DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES # (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; # LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND # ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS # SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. from setuptools import setup import sys, os.path, shutil version = '1.2.1' if sys.version_info < (2, 6, 0) and sys.version_info < (3, 0, 0): sys.stderr.write("pyqrcode requires Python 2.6+ or 3.\n") sys.exit(1) #Make the README.rst file the long description #This only happens when we are building from the #source. if os.path.exists('docs/README.rst'): print('Reading README.rst file') with open( 'docs/README.rst', 'r') as f: longdesc = f.read() shutil.copyfile('docs/README.rst', 'README.rst') else: longdesc = None setup(name='PyQRCode', packages=['pyqrcode'], version=version, description='A QR code generator written purely in Python with SVG, EPS, PNG and terminal output.', author='Michael Nooner', author_email='mnooner256@gmail.com', url='https://github.com/mnooner256/pyqrcode', keywords=['qrcode', 'qr'], license='BSD', extras_require = { 'PNG': ["pypng>=0.0.13"], }, classifiers = [ 'Development Status :: 4 - Beta', 'Environment :: Console', 'Intended Audience :: Developers', 'License :: OSI Approved :: BSD License', 'Topic :: Software Development :: Libraries :: Python Modules', 'Natural Language :: English', 'Operating System :: OS Independent', 'Operating System :: POSIX', 'Operating System :: Microsoft :: Windows', 'Programming Language :: Python :: 3', 'Programming Language :: Python :: 2.6', 'Programming Language :: Python :: 2.7', ], long_description=longdesc, ) if os.path.exists('docs/README.rst'): os.remove('README.rst') PyQRCode-1.2.1/README.rst0000644000175000017500000000442412731661302014531 0ustar mikemike00000000000000======== PyQRCode ======== .. contents:: The pyqrcode module is a QR code generator that is simple to use and written in pure python. The module can automates most of the building process for creating QR codes. Most codes can be created using only two lines of code! Unlike other generators, all of the helpers can be controlled manually. You are free to set any or all of the properties of your QR code. QR codes can be saved as SVG, PNG (by using the `pypng `_ module), and plain text. They can also be displayed directly in most Linux terminal emulators. PIL is not used to render the image files. The pyqrcode module attempts to follow the QR code standard as closely as possible. The terminology and the encodings used in pyqrcode come directly from the standard. This module also follows the algorithm laid out in the standard. **Homepage**: https://github.com/mnooner256/pyqrcode **Documentation**: http://pythonhosted.org/PyQRCode/ Requirements ============ The pyqrcode module only requires Python 2.6, Python 2.7, or Python 3. You may want to install `pypng `_ in order to render PNG files, but it is optional. Note, pypng is a pure python PNG writer which does not require any other libraries. Installation ============ Installation is simple. It can be installed from pip using the following command:: $ pip install pyqrcode Or from the terminal:: $ python setup.py install Usage ===== The pyqrcode module aims to be as simple to use as possible. Below is a simple example of creating a QR code for a URL. The code is rendered out as an svg file. :: >>> import pyqrcode >>> url = pyqrcode.create('http://uca.edu') >>> url.svg('uca-url.svg', scale=8) >>> url.eps('uca-url.eps', scale=2) >>> print(url.terminal(quiet_zone=1)) The pyqrcode module, while easy to use, is powerful. You can set every property of the QR code. If you install the optional `pypng `_ module, you can render the code as a PNG image. Below is a more complex example:: >>> big_code = pyqrcode.create('0987654321', error='L', version=27, mode='binary') >>> big_code.png('code.png', scale=6, module_color=[0, 0, 0, 128], background=[0xff, 0xff, 0xcc]) >>> big_code.show() PyQRCode-1.2.1/setup.cfg0000644000175000017500000000007312731661302014657 0ustar mikemike00000000000000[egg_info] tag_build = tag_date = 0 tag_svn_revision = 0