Source code for

# Copyright(C) 2011  Pierre Mazière
# This file is part of woob.
# woob is free software: you can redistribute it and/or modify
# it under the terms of the GNU Lesser General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
# woob is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# GNU Lesser General Public License for more details.
# You should have received a copy of the GNU Lesser General Public License
# along with woob. If not, see <>.

from __future__ import annotations

import hashlib
import tempfile
from typing import IO, ClassVar, TYPE_CHECKING

    from woob.browser import Browser

    from PIL import Image
except ImportError:
    raise ImportError('Please install python-imaging')

[docs]class VirtKeyboardError(Exception): pass
[docs]class VirtKeyboard: """ Handle a virtual keyboard. """ margin = None """ Margin used by :meth:`get_symbol_coords` to reduce size of each "key" of the virtual keyboard. This attribute is always converted to a 4-tuple, and has the same semantic as the CSS ``margin`` property (top, right, bottom, right), in pixels. """ codesep = '' """ Output separator between code strings. See :func:`get_string_code`. """ def __init__(self, file=None, coords=None, color=None, convert=None): # file: virtual keyboard image # coords: dictionary <value to return>:<tuple(x1,y1,x2,y2)> # color: color of the symbols in the image # depending on the image, it can be a single value or a tuple # convert: if not None, convert image to this target type (for example 'RGB') if file is not None: assert color, 'No color provided !' self.load_image(file, color, convert) if type(self.margin) in (int, float): self.margin = (self.margin,) * 4 elif self.margin is not None: if len(self.margin) == 2: self.margin = self.margin + self.margin elif len(self.margin) == 3: self.margin = self.margin + (self.margin[1],) assert len(self.margin) == 4 if coords is not None: self.load_symbols(coords)
[docs] def load_image(self, file, color, convert=None): self.image = if convert is not None: self.image = self.image.convert(convert) self.bands = self.image.getbands() if isinstance(color, int) and not isinstance(self.bands, str) and len(self.bands) != 1: raise VirtKeyboardError("Color requires %i component but only 1 is provided" % len(self.bands)) if not isinstance(color, int) and len(color) != len(self.bands): raise VirtKeyboardError("Color requires %i components but %i are provided" % (len(self.bands), len(color))) self.color = color self.width, self.height = self.image.size self.pixar = self.image.load()
[docs] def load_symbols(self, coords): self.coords = {} self.md5 = {} for i in coords: coord = self.get_symbol_coords(coords[i]) if coord == (-1, -1, -1, -1): continue self.coords[i] = coord self.md5[i] = self.checksum(self.coords[i])
[docs] def check_color(self, pixel): return pixel == self.color
[docs] def get_symbol_coords(self, coords): """Return narrow coordinates around symbol.""" (x1, y1, x2, y2) = coords if self.margin: top, right, bottom, left = self.margin x1, y1, x2, y2 = x1 + left, y1 + top, x2 - right, y2 - bottom newY1 = -1 newY2 = -1 for y in range(y1, min(y2 + 1, self.height)): empty_line = True for x in range(x1, min(x2 + 1, self.width)): if self.check_color(self.pixar[x, y]): empty_line = False if newY1 < 0: newY1 = y break if newY1 >= 0 and not empty_line: newY2 = y newX1 = -1 newX2 = -1 for x in range(x1, min(x2 + 1, self.width)): empty_column = True for y in range(y1, min(y2 + 1, self.height)): if self.check_color(self.pixar[x, y]): empty_column = False if newX1 < 0: newX1 = x break if newX1 >= 0 and not empty_column: newX2 = x return (newX1, newY1, newX2, newY2)
[docs] def checksum(self, coords): (x1, y1, x2, y2) = coords s = b'' for y in range(y1, min(y2 + 1, self.height)): for x in range(x1, min(x2 + 1, self.width)): if self.check_color(self.pixar[x, y]): s += b"." else: s += b" " return hashlib.md5(s).hexdigest()
[docs] def get_symbol_code(self, all_known_md5_for_symbol): if isinstance(all_known_md5_for_symbol, str): all_known_md5_for_symbol = [all_known_md5_for_symbol] current_md5_in_keyboard = self.md5 for known_md5 in all_known_md5_for_symbol: for code, cur_md5 in current_md5_in_keyboard.items(): if known_md5 == cur_md5: return code raise VirtKeyboardError( 'Code not found for these hashes "%s".' % all_known_md5_for_symbol)
[docs] def get_string_code(self, string): return self.codesep.join(self.get_symbol_code(self.symbols[c]) for c in string)
[docs] def check_symbols(self, symbols, dirname): # symbols: dictionary <symbol>:<md5 value> for s in symbols: try: self.get_symbol_code(symbols[s]) except VirtKeyboardError: if dirname is None: dirname = tempfile.mkdtemp(prefix='woob_session_') self.generate_MD5(dirname) raise VirtKeyboardError("Symbol '%s' not found; all symbol hashes are available in %s" % (s, dirname))
[docs] def generate_MD5(self, dir): for i in self.coords: width = self.coords[i][2] - self.coords[i][0] + 1 height = self.coords[i][3] - self.coords[i][1] + 1 img =''.join(self.bands), (width, height)) matrix = img.load() for y in range(height): for x in range(width): matrix[x, y] = self.pixar[self.coords[i][0] + x, self.coords[i][1] + y] + "/" + self.md5[i] + ".png") + "/image.png")
[docs]class MappedVirtKeyboard(VirtKeyboard): def __init__(self, file, document, img_element, color, map_attr="onclick", convert=None): map_id = img_element.attrib.get("usemap")[1:] map = document.find('//map[@id="%s"]' % map_id) if map is None: map = document.find('//map[@name="%s"]' % map_id) coords = {} for area in map.iter("area"): code = area.attrib.get(map_attr) area_coords = [] for coord in area.attrib.get("coords").split(' ')[0].split(','): area_coords.append(int(coord)) coords[code] = tuple(area_coords) super(MappedVirtKeyboard, self).__init__(file, coords, color, convert)
[docs]class GridVirtKeyboard(VirtKeyboard): """ Make a virtual keyboard where "keys" are distributed on a grid. Example here: :param symbols: Sequence of symbols, ordered in the grid from left to right and up to down :type symbols: iterable :param cols: Column count of the grid :type cols: int :param rows: Row count of the grid :type rows: int :param image: File-like object to be used as data source :type image: file :param color: Color of the meaningful pixels :type color: 3-tuple :param convert: Mode to which convert color of pixels, see :meth:`Image.Image.convert` for more information """ symbols = {} """Assocation table between symbols and md5s""" def __init__(self, symbols, cols, rows, image, color, convert=None): self.load_image(image, color, convert) tileW = self.width / cols tileH = self.height / rows positions = ((s, i * tileW % self.width, i // cols * tileH) for i, s in enumerate(symbols)) coords = dict((s, tuple(map(int, (x, y, x + tileW, y + tileH)))) for (s, x, y) in positions) super(GridVirtKeyboard, self).__init__() self.load_symbols(coords)
[docs]class SplitKeyboard: """Virtual keyboard for when the chars are in individual images, not a single grid""" char_to_hash = None """dict mapping password characters to image hashes""" codesep = '' """Output separator between symbols""" def __init__(self, code_to_filedata): """Create a SplitKeyboard :param code_to_filedata: dict mapping site codes to images data :type code_to_filedata: dict[str, str] """ hash_to_code = { self.checksum(data): code for code, data in code_to_filedata.items() } self.char_to_code = {} for char, hashes in self.char_to_hash.items(): if isinstance(hashes, str): hashes = (hashes,) for hash in hash_to_code: if hash in hashes: self.char_to_code[char] = hash_to_code.pop(hash) break else: path = tempfile.mkdtemp(prefix='woob_session_') self.dump(code_to_filedata.values(), path) raise VirtKeyboardError("Symbol '%s' not found; all symbol hashes are available in %s" % (char, path))
[docs] def checksum(self, buffer): return hashlib.md5(self.convert(buffer)).hexdigest()
[docs] def dump(self, files, path): for dat in files: md5 = hashlib.md5(dat).hexdigest() with open('%s/%s.png' % (path, md5), 'wb') as fd: fd.write(dat)
[docs] def get_string_code(self, password): symbols = [] for c in password: symbols.append(self.char_to_code[c]) return self.codesep.join(symbols)
[docs] def convert(self, buffer): return buffer
[docs] @classmethod def create_from_url(cls, browser, code_to_url): code_to_file = { code: for code, url in code_to_url } return cls(code_to_file)
[docs]class Tile: """Tile of a image grid for SimpleVirtualKeyboard""" def __init__(self, matching_symbol, coords, image=None, md5=None): self.matching_symbol = matching_symbol self.coords = coords self.image = image self.md5 = md5
[docs]class SimpleVirtualKeyboard: """Handle a virtual keyboard where "keys" are distributed on a simple grid. :param cols: Column count of the grid :param rows: Row count of the grid :param file: File-like object to be used as data source :param convert: Mode to which convert color of pixels, see :meth:`Image.Image.convert` for more information :param matching_symbols: symbol that match all case of image grid from left to right and top to down, European reading way. :param matching_symbols_coords: dict mapping matching website symbols to their image coords (x0, y0, x1, y1) on grid image from left to right and top to down, European reading way. It's not symbols in the image. :param browser: Browser of woob session. Allow to dump tiles files in same directory than session folder """ codesep: ClassVar[str] = '' """Output separator between matching symbols""" margin: ClassVar[tuple[int, int, int, int] | tuple[int, int] | int | None] = None """ 4-tuple(int), same as HTML margin: (top, right, bottom, left). or 2-tuple(int), (top = bottom, right = left), or int, top = right = bottom = left """ tile_margin: ClassVar[tuple[int, int, int, int] | tuple[int, int] | int | None] = None """ 4-tuple(int), same as HTML margin: (top, right, bottom, left). or 2-tuple(int), (top = bottom, right = left), or int, top = right = bottom = left """ symbols: ClassVar[dict[str, str | tuple[str, ...]]] = None """ Association table between image symbols and md5s """ convert: ClassVar[str | None] = None """ Mode to which convert color of pixels, see :meth:`Image.Image.convert` for more information """ tile_klass = Tile def __init__( self, file: IO, cols: int, rows: int, matching_symbols: list[str] | None = None, matching_symbols_coords: dict[str, tuple[int, int, int, int]] | None = None, browser: Browser | None = None ): self.cols = cols self.rows = rows # Needed even if init is overwrite self.path = self.build_path(browser) # Get self.image self.load_image(file, self.margin, self.convert) # Get self.tiles self.get_tiles( matching_symbols=matching_symbols, matching_symbols_coords=matching_symbols_coords ) # Tiles processing self.cut_tiles(self.tile_margin) self.hash_md5_tiles()
[docs] def build_path(self, browser=None): if browser and browser.responses_dirname: return browser.responses_dirname else: return tempfile.mkdtemp(prefix='woob_session_')
[docs] def load_image(self, file, margin=None, convert=None): self.image = # Resize image if margin is given if margin: self.image = self.cut_margin(self.image, margin) if convert: self.image = self.image.convert(convert) # Give possibility to alter image before get tiles, overwrite :func:`alter_image`. self.alter_image() self.width, self.height = self.image.size
[docs] def alter_image(self): pass
[docs] def cut_margin(self, image, margin): width, height = image.size # Verify the magin value format if type(margin) is int: margin = (margin, margin, margin, margin) elif len(margin) == 2: margin = (margin[0], margin[1], margin[0], margin[1]) elif len(margin) == 4: margin = margin else: assert (len(margin) == 3) & (len(margin) > 4), \ "Margin format is wrong." assert ((margin[0] + margin[2]) < height) & ((margin[1] + margin[3]) < width), \ "Margin is too high, there is not enough pixel to cut." image = image.crop(( 0 + margin[3], 0 + margin[0], width - margin[1], height - margin[2] )) return image
[docs] def get_tiles(self, matching_symbols=None, matching_symbols_coords=None): self.tiles = [] # Tiles coords are given if matching_symbols_coords: for matching_symbol in matching_symbols_coords: self.tiles.append( self.tile_klass( matching_symbol=matching_symbol, coords=matching_symbols_coords[matching_symbol] ) ) return assert (not self.width%self.cols) & (not self.height%self.rows), \ "Image width and height are not multiple of cols and rows. Please resize image with attribute `margin`." # Tiles coords aren't given, calculate them self.tileW = self.width // self.cols self.tileH = self.height // self.rows # Matching symbols aren't given, default value is range(columns*rows) if not matching_symbols: matching_symbols = ['%s' % i for i in range(self.cols*self.rows)] assert len(matching_symbols) == (self.cols*self.rows), \ "Number of website matching symbols is not equal to the number of cases on the image." # Calculate tiles coords for each matching symbol from 1-dimension to 2-dimensions for index, matching_symbol in enumerate(matching_symbols): coords = self.get_tile_coords_in_grid(index) self.tiles.append(self.tile_klass(matching_symbol=matching_symbol, coords=coords))
[docs] def get_tile_coords_in_grid(self, case_index): # Get the top left pixel coords of the tile x0 = (case_index % self.cols) * self.tileW y0 = (case_index // self.cols) * self.tileH # Get the bottom right coords of the tile x1 = x0 + self.tileW y1 = y0 + self.tileH coords = (x0, y0, x1, y1) return(coords)
[docs] def cut_tiles(self, tile_margin=None): for tile in self.tiles: tile.image = self.image.crop(tile.coords) # Resize tile if margin is given if tile_margin: for tile in self.tiles: tile.image = self.cut_margin(tile.image, tile_margin)
[docs] def hash_md5_tiles(self): for tile in self.tiles: tile.md5 = hashlib.md5(tile.image.tobytes()).hexdigest()
[docs] def dump_tiles(self, path): for tile in self.tiles:'{}/{}.png'.format(path, tile.md5))
[docs] def get_string_code(self, password): word = [] for digit in password: for tile in self.tiles: if tile.md5 in self.symbols[digit]: word.append(tile.matching_symbol) break else: # Dump file only if the symbol is not found self.dump_tiles(self.path) raise VirtKeyboardError( "Symbol '%s' not found; all symbol hashes are available in %s" % (digit, self.path) ) return self.codesep.join(word)