├── .gitignore ├── README.md ├── _pySmartIdEngine.so ├── bundle_mock_smart_idreader.zip ├── pySmartIdEngine.py └── smart_idreader_telegram_bot.py /.gitignore: -------------------------------------------------------------------------------- 1 | # Byte-compiled / optimized / DLL files 2 | __pycache__/ 3 | *.py[cod] 4 | *$py.class 5 | 6 | # Distribution / packaging 7 | .Python 8 | build/ 9 | develop-eggs/ 10 | dist/ 11 | downloads/ 12 | eggs/ 13 | .eggs/ 14 | lib/ 15 | lib64/ 16 | parts/ 17 | sdist/ 18 | var/ 19 | wheels/ 20 | *.egg-info/ 21 | .installed.cfg 22 | *.egg 23 | MANIFEST 24 | 25 | # PyInstaller 26 | # Usually these files are written by a python script from a template 27 | # before PyInstaller builds the exe, so as to inject date/other infos into it. 28 | *.manifest 29 | *.spec 30 | 31 | # Installer logs 32 | pip-log.txt 33 | pip-delete-this-directory.txt 34 | 35 | # Unit test / coverage reports 36 | htmlcov/ 37 | .tox/ 38 | .coverage 39 | .coverage.* 40 | .cache 41 | nosetests.xml 42 | coverage.xml 43 | *.cover 44 | .hypothesis/ 45 | 46 | # Translations 47 | *.mo 48 | *.pot 49 | 50 | # PyBuilder 51 | target/ 52 | 53 | # pyenv 54 | .python-version 55 | 56 | # Environments 57 | .env 58 | .venv 59 | env/ 60 | venv/ 61 | ENV/ 62 | env.bak/ 63 | venv.bak/ 64 | 65 | # mkdocs documentation 66 | /site 67 | 68 | # Custom 69 | downloaded_images/* -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # Smart IDReader SDK for Python - Telegram Bot example - Demo version 2 | 3 | This is a **DEMO** version of [Smart IDReader](https://smartengines.com/ocr-engines/) Python SDK by [Smart Engines](https://smartengines.com) which demonstrates the usage of Smart IDReader library/SDK without actually providing any recognition functionality. 4 | Instead, it outputs fake results for document search, field segmentation, recognition and photo image extraction. 5 | 6 | For more information please see our other demo repositories: 7 | 8 | Smart IDReader iOS SDK: https://github.com/SmartEngines/SmartIDReader-iOS-SDK 9 | Smart IDReader Android SDK: https://github.com/SmartEngines/SmartIDReader-Android-SDK 10 | 11 | Free demonstrational applications with full functionality are available at [App Store](https://itunes.apple.com/app/smart-idreader/id1157877082) and [Google Play](https://play.google.com/store/apps/details?id=biz.smartengines.smartid). 12 | 13 | If you'd like to obtain a trial or full version of Smart IDReader please contact us via: 14 | * sales@smartengines.com 15 | * http://smartengines.com/contacts 16 | * http://smartengines.ru/contacts 17 | 18 | ## Telegram bot usage 19 | 20 | Starting telegram bot: 21 | 22 | ``` 23 | python smart_idreader_telegram_bot.py --token YOUR_TELEGRAM_BOT_TOKEN_HERE 24 | ``` 25 | 26 | This is a basic example so feel free to modify it however you want. 27 | -------------------------------------------------------------------------------- /_pySmartIdEngine.so: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/SmartEngines/SmartIDReader-Telegram-Bot/0be8f72cf07a1c6f17320660fadcc3de7ac950f5/_pySmartIdEngine.so -------------------------------------------------------------------------------- /bundle_mock_smart_idreader.zip: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/SmartEngines/SmartIDReader-Telegram-Bot/0be8f72cf07a1c6f17320660fadcc3de7ac950f5/bundle_mock_smart_idreader.zip -------------------------------------------------------------------------------- /pySmartIdEngine.py: -------------------------------------------------------------------------------- 1 | # This file was automatically generated by SWIG (http://www.swig.org). 2 | # Version 3.0.12 3 | # 4 | # Do not make changes to this file unless you know what you are doing--modify 5 | # the SWIG interface file instead. 6 | 7 | from sys import version_info as _swig_python_version_info 8 | if _swig_python_version_info >= (2, 7, 0): 9 | def swig_import_helper(): 10 | import importlib 11 | pkg = __name__.rpartition('.')[0] 12 | mname = '.'.join((pkg, '_pySmartIdEngine')).lstrip('.') 13 | try: 14 | return importlib.import_module(mname) 15 | except ImportError: 16 | return importlib.import_module('_pySmartIdEngine') 17 | _pySmartIdEngine = swig_import_helper() 18 | del swig_import_helper 19 | elif _swig_python_version_info >= (2, 6, 0): 20 | def swig_import_helper(): 21 | from os.path import dirname 22 | import imp 23 | fp = None 24 | try: 25 | fp, pathname, description = imp.find_module('_pySmartIdEngine', [dirname(__file__)]) 26 | except ImportError: 27 | import _pySmartIdEngine 28 | return _pySmartIdEngine 29 | try: 30 | _mod = imp.load_module('_pySmartIdEngine', fp, pathname, description) 31 | finally: 32 | if fp is not None: 33 | fp.close() 34 | return _mod 35 | _pySmartIdEngine = swig_import_helper() 36 | del swig_import_helper 37 | else: 38 | import _pySmartIdEngine 39 | del _swig_python_version_info 40 | 41 | try: 42 | _swig_property = property 43 | except NameError: 44 | pass # Python < 2.2 doesn't have 'property'. 45 | 46 | try: 47 | import builtins as __builtin__ 48 | except ImportError: 49 | import __builtin__ 50 | 51 | def _swig_setattr_nondynamic(self, class_type, name, value, static=1): 52 | if (name == "thisown"): 53 | return self.this.own(value) 54 | if (name == "this"): 55 | if type(value).__name__ == 'SwigPyObject': 56 | self.__dict__[name] = value 57 | return 58 | method = class_type.__swig_setmethods__.get(name, None) 59 | if method: 60 | return method(self, value) 61 | if (not static): 62 | if _newclass: 63 | object.__setattr__(self, name, value) 64 | else: 65 | self.__dict__[name] = value 66 | else: 67 | raise AttributeError("You cannot add attributes to %s" % self) 68 | 69 | 70 | def _swig_setattr(self, class_type, name, value): 71 | return _swig_setattr_nondynamic(self, class_type, name, value, 0) 72 | 73 | 74 | def _swig_getattr(self, class_type, name): 75 | if (name == "thisown"): 76 | return self.this.own() 77 | method = class_type.__swig_getmethods__.get(name, None) 78 | if method: 79 | return method(self) 80 | raise AttributeError("'%s' object has no attribute '%s'" % (class_type.__name__, name)) 81 | 82 | 83 | def _swig_repr(self): 84 | try: 85 | strthis = "proxy of " + self.this.__repr__() 86 | except __builtin__.Exception: 87 | strthis = "" 88 | return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,) 89 | 90 | try: 91 | _object = object 92 | _newclass = 1 93 | except __builtin__.Exception: 94 | class _object: 95 | pass 96 | _newclass = 0 97 | 98 | class SwigPyIterator(_object): 99 | __swig_setmethods__ = {} 100 | __setattr__ = lambda self, name, value: _swig_setattr(self, SwigPyIterator, name, value) 101 | __swig_getmethods__ = {} 102 | __getattr__ = lambda self, name: _swig_getattr(self, SwigPyIterator, name) 103 | 104 | def __init__(self, *args, **kwargs): 105 | raise AttributeError("No constructor defined - class is abstract") 106 | __repr__ = _swig_repr 107 | __swig_destroy__ = _pySmartIdEngine.delete_SwigPyIterator 108 | __del__ = lambda self: None 109 | 110 | def value(self): 111 | return _pySmartIdEngine.SwigPyIterator_value(self) 112 | 113 | def incr(self, n=1): 114 | return _pySmartIdEngine.SwigPyIterator_incr(self, n) 115 | 116 | def decr(self, n=1): 117 | return _pySmartIdEngine.SwigPyIterator_decr(self, n) 118 | 119 | def distance(self, x): 120 | return _pySmartIdEngine.SwigPyIterator_distance(self, x) 121 | 122 | def equal(self, x): 123 | return _pySmartIdEngine.SwigPyIterator_equal(self, x) 124 | 125 | def copy(self): 126 | return _pySmartIdEngine.SwigPyIterator_copy(self) 127 | 128 | def next(self): 129 | return _pySmartIdEngine.SwigPyIterator_next(self) 130 | 131 | def __next__(self): 132 | return _pySmartIdEngine.SwigPyIterator___next__(self) 133 | 134 | def previous(self): 135 | return _pySmartIdEngine.SwigPyIterator_previous(self) 136 | 137 | def advance(self, n): 138 | return _pySmartIdEngine.SwigPyIterator_advance(self, n) 139 | 140 | def __eq__(self, x): 141 | return _pySmartIdEngine.SwigPyIterator___eq__(self, x) 142 | 143 | def __ne__(self, x): 144 | return _pySmartIdEngine.SwigPyIterator___ne__(self, x) 145 | 146 | def __iadd__(self, n): 147 | return _pySmartIdEngine.SwigPyIterator___iadd__(self, n) 148 | 149 | def __isub__(self, n): 150 | return _pySmartIdEngine.SwigPyIterator___isub__(self, n) 151 | 152 | def __add__(self, n): 153 | return _pySmartIdEngine.SwigPyIterator___add__(self, n) 154 | 155 | def __sub__(self, *args): 156 | return _pySmartIdEngine.SwigPyIterator___sub__(self, *args) 157 | def __iter__(self): 158 | return self 159 | SwigPyIterator_swigregister = _pySmartIdEngine.SwigPyIterator_swigregister 160 | SwigPyIterator_swigregister(SwigPyIterator) 161 | 162 | class Rectangle(_object): 163 | __swig_setmethods__ = {} 164 | __setattr__ = lambda self, name, value: _swig_setattr(self, Rectangle, name, value) 165 | __swig_getmethods__ = {} 166 | __getattr__ = lambda self, name: _swig_getattr(self, Rectangle, name) 167 | __repr__ = _swig_repr 168 | __swig_destroy__ = _pySmartIdEngine.delete_Rectangle 169 | __del__ = lambda self: None 170 | 171 | def __init__(self, *args): 172 | this = _pySmartIdEngine.new_Rectangle(*args) 173 | try: 174 | self.this.append(this) 175 | except __builtin__.Exception: 176 | self.this = this 177 | __swig_setmethods__["x"] = _pySmartIdEngine.Rectangle_x_set 178 | __swig_getmethods__["x"] = _pySmartIdEngine.Rectangle_x_get 179 | if _newclass: 180 | x = _swig_property(_pySmartIdEngine.Rectangle_x_get, _pySmartIdEngine.Rectangle_x_set) 181 | __swig_setmethods__["y"] = _pySmartIdEngine.Rectangle_y_set 182 | __swig_getmethods__["y"] = _pySmartIdEngine.Rectangle_y_get 183 | if _newclass: 184 | y = _swig_property(_pySmartIdEngine.Rectangle_y_get, _pySmartIdEngine.Rectangle_y_set) 185 | __swig_setmethods__["width"] = _pySmartIdEngine.Rectangle_width_set 186 | __swig_getmethods__["width"] = _pySmartIdEngine.Rectangle_width_get 187 | if _newclass: 188 | width = _swig_property(_pySmartIdEngine.Rectangle_width_get, _pySmartIdEngine.Rectangle_width_set) 189 | __swig_setmethods__["height"] = _pySmartIdEngine.Rectangle_height_set 190 | __swig_getmethods__["height"] = _pySmartIdEngine.Rectangle_height_get 191 | if _newclass: 192 | height = _swig_property(_pySmartIdEngine.Rectangle_height_get, _pySmartIdEngine.Rectangle_height_set) 193 | Rectangle_swigregister = _pySmartIdEngine.Rectangle_swigregister 194 | Rectangle_swigregister(Rectangle) 195 | 196 | class Point(_object): 197 | __swig_setmethods__ = {} 198 | __setattr__ = lambda self, name, value: _swig_setattr(self, Point, name, value) 199 | __swig_getmethods__ = {} 200 | __getattr__ = lambda self, name: _swig_getattr(self, Point, name) 201 | __repr__ = _swig_repr 202 | __swig_destroy__ = _pySmartIdEngine.delete_Point 203 | __del__ = lambda self: None 204 | 205 | def __init__(self, *args): 206 | this = _pySmartIdEngine.new_Point(*args) 207 | try: 208 | self.this.append(this) 209 | except __builtin__.Exception: 210 | self.this = this 211 | __swig_setmethods__["x"] = _pySmartIdEngine.Point_x_set 212 | __swig_getmethods__["x"] = _pySmartIdEngine.Point_x_get 213 | if _newclass: 214 | x = _swig_property(_pySmartIdEngine.Point_x_get, _pySmartIdEngine.Point_x_set) 215 | __swig_setmethods__["y"] = _pySmartIdEngine.Point_y_set 216 | __swig_getmethods__["y"] = _pySmartIdEngine.Point_y_get 217 | if _newclass: 218 | y = _swig_property(_pySmartIdEngine.Point_y_get, _pySmartIdEngine.Point_y_set) 219 | Point_swigregister = _pySmartIdEngine.Point_swigregister 220 | Point_swigregister(Point) 221 | 222 | class Quadrangle(_object): 223 | __swig_setmethods__ = {} 224 | __setattr__ = lambda self, name, value: _swig_setattr(self, Quadrangle, name, value) 225 | __swig_getmethods__ = {} 226 | __getattr__ = lambda self, name: _swig_getattr(self, Quadrangle, name) 227 | __repr__ = _swig_repr 228 | __swig_destroy__ = _pySmartIdEngine.delete_Quadrangle 229 | __del__ = lambda self: None 230 | 231 | def __init__(self, *args): 232 | this = _pySmartIdEngine.new_Quadrangle(*args) 233 | try: 234 | self.this.append(this) 235 | except __builtin__.Exception: 236 | self.this = this 237 | 238 | def GetPoint(self, index): 239 | return _pySmartIdEngine.Quadrangle_GetPoint(self, index) 240 | 241 | def SetPoint(self, index, value): 242 | return _pySmartIdEngine.Quadrangle_SetPoint(self, index, value) 243 | 244 | def GetBoundingRectangle(self): 245 | return _pySmartIdEngine.Quadrangle_GetBoundingRectangle(self) 246 | Quadrangle_swigregister = _pySmartIdEngine.Quadrangle_swigregister 247 | Quadrangle_swigregister(Quadrangle) 248 | 249 | class Image(_object): 250 | __swig_setmethods__ = {} 251 | __setattr__ = lambda self, name, value: _swig_setattr(self, Image, name, value) 252 | __swig_getmethods__ = {} 253 | __getattr__ = lambda self, name: _swig_getattr(self, Image, name) 254 | __repr__ = _swig_repr 255 | 256 | def __init__(self, *args): 257 | this = _pySmartIdEngine.new_Image(*args) 258 | try: 259 | self.this.append(this) 260 | except __builtin__.Exception: 261 | self.this = this 262 | __swig_destroy__ = _pySmartIdEngine.delete_Image 263 | __del__ = lambda self: None 264 | 265 | def Save(self, image_filename): 266 | return _pySmartIdEngine.Image_Save(self, image_filename) 267 | 268 | def GetRequiredBufferLength(self): 269 | return _pySmartIdEngine.Image_GetRequiredBufferLength(self) 270 | 271 | def CopyToBuffer(self, out_buffer, buffer_length): 272 | return _pySmartIdEngine.Image_CopyToBuffer(self, out_buffer, buffer_length) 273 | 274 | def EstimateFocusScore(self, quantile=0.95): 275 | return _pySmartIdEngine.Image_EstimateFocusScore(self, quantile) 276 | 277 | def GetRequiredBase64BufferLength(self): 278 | return _pySmartIdEngine.Image_GetRequiredBase64BufferLength(self) 279 | 280 | def CopyBase64ToBuffer(self, out_buffer, buffer_length): 281 | return _pySmartIdEngine.Image_CopyBase64ToBuffer(self, out_buffer, buffer_length) 282 | 283 | def GetBase64String(self): 284 | return _pySmartIdEngine.Image_GetBase64String(self) 285 | 286 | def Clear(self): 287 | return _pySmartIdEngine.Image_Clear(self) 288 | 289 | def GetWidth(self): 290 | return _pySmartIdEngine.Image_GetWidth(self) 291 | 292 | def GetHeight(self): 293 | return _pySmartIdEngine.Image_GetHeight(self) 294 | 295 | def GetStride(self): 296 | return _pySmartIdEngine.Image_GetStride(self) 297 | 298 | def GetChannels(self): 299 | return _pySmartIdEngine.Image_GetChannels(self) 300 | 301 | def IsMemoryOwner(self): 302 | return _pySmartIdEngine.Image_IsMemoryOwner(self) 303 | 304 | def ForceMemoryOwner(self): 305 | return _pySmartIdEngine.Image_ForceMemoryOwner(self) 306 | 307 | def Resize(self, new_width, new_height): 308 | return _pySmartIdEngine.Image_Resize(self, new_width, new_height) 309 | 310 | def Crop(self, *args): 311 | return _pySmartIdEngine.Image_Crop(self, *args) 312 | 313 | def MaskImageRegionRectangle(self, rect, pixel_expand=0): 314 | return _pySmartIdEngine.Image_MaskImageRegionRectangle(self, rect, pixel_expand) 315 | 316 | def MaskImageRegionQuadrangle(self, quad, pixel_expand=0): 317 | return _pySmartIdEngine.Image_MaskImageRegionQuadrangle(self, quad, pixel_expand) 318 | 319 | def FlipVertical(self): 320 | return _pySmartIdEngine.Image_FlipVertical(self) 321 | 322 | def FlipHorizontal(self): 323 | return _pySmartIdEngine.Image_FlipHorizontal(self) 324 | Image_swigregister = _pySmartIdEngine.Image_swigregister 325 | Image_swigregister(Image) 326 | 327 | Landscape = _pySmartIdEngine.Landscape 328 | Portrait = _pySmartIdEngine.Portrait 329 | InvertedLandscape = _pySmartIdEngine.InvertedLandscape 330 | InvertedPortrait = _pySmartIdEngine.InvertedPortrait 331 | class OcrCharVariant(_object): 332 | __swig_setmethods__ = {} 333 | __setattr__ = lambda self, name, value: _swig_setattr(self, OcrCharVariant, name, value) 334 | __swig_getmethods__ = {} 335 | __getattr__ = lambda self, name: _swig_getattr(self, OcrCharVariant, name) 336 | __repr__ = _swig_repr 337 | __swig_destroy__ = _pySmartIdEngine.delete_OcrCharVariant 338 | __del__ = lambda self: None 339 | 340 | def __init__(self, *args): 341 | this = _pySmartIdEngine.new_OcrCharVariant(*args) 342 | try: 343 | self.this.append(this) 344 | except __builtin__.Exception: 345 | self.this = this 346 | 347 | def GetUtf16Character(self): 348 | return _pySmartIdEngine.OcrCharVariant_GetUtf16Character(self) 349 | 350 | def GetUtf8Character(self): 351 | return _pySmartIdEngine.OcrCharVariant_GetUtf8Character(self) 352 | 353 | def GetConfidence(self): 354 | return _pySmartIdEngine.OcrCharVariant_GetConfidence(self) 355 | OcrCharVariant_swigregister = _pySmartIdEngine.OcrCharVariant_swigregister 356 | OcrCharVariant_swigregister(OcrCharVariant) 357 | 358 | class OcrChar(_object): 359 | __swig_setmethods__ = {} 360 | __setattr__ = lambda self, name, value: _swig_setattr(self, OcrChar, name, value) 361 | __swig_getmethods__ = {} 362 | __getattr__ = lambda self, name: _swig_getattr(self, OcrChar, name) 363 | __repr__ = _swig_repr 364 | 365 | def __init__(self, *args): 366 | this = _pySmartIdEngine.new_OcrChar(*args) 367 | try: 368 | self.this.append(this) 369 | except __builtin__.Exception: 370 | self.this = this 371 | __swig_destroy__ = _pySmartIdEngine.delete_OcrChar 372 | __del__ = lambda self: None 373 | 374 | def GetOcrCharVariants(self): 375 | return _pySmartIdEngine.OcrChar_GetOcrCharVariants(self) 376 | 377 | def IsHighlighted(self): 378 | return _pySmartIdEngine.OcrChar_IsHighlighted(self) 379 | 380 | def IsCorrected(self): 381 | return _pySmartIdEngine.OcrChar_IsCorrected(self) 382 | 383 | def GetUtf16Character(self): 384 | return _pySmartIdEngine.OcrChar_GetUtf16Character(self) 385 | 386 | def GetUtf8Character(self): 387 | return _pySmartIdEngine.OcrChar_GetUtf8Character(self) 388 | 389 | def GetRectangle(self): 390 | return _pySmartIdEngine.OcrChar_GetRectangle(self) 391 | OcrChar_swigregister = _pySmartIdEngine.OcrChar_swigregister 392 | OcrChar_swigregister(OcrChar) 393 | 394 | class OcrString(_object): 395 | __swig_setmethods__ = {} 396 | __setattr__ = lambda self, name, value: _swig_setattr(self, OcrString, name, value) 397 | __swig_getmethods__ = {} 398 | __getattr__ = lambda self, name: _swig_getattr(self, OcrString, name) 399 | __repr__ = _swig_repr 400 | 401 | def __init__(self, *args): 402 | this = _pySmartIdEngine.new_OcrString(*args) 403 | try: 404 | self.this.append(this) 405 | except __builtin__.Exception: 406 | self.this = this 407 | __swig_destroy__ = _pySmartIdEngine.delete_OcrString 408 | __del__ = lambda self: None 409 | 410 | def GetOcrChars(self): 411 | return _pySmartIdEngine.OcrString_GetOcrChars(self) 412 | 413 | def GetUtf8String(self): 414 | return _pySmartIdEngine.OcrString_GetUtf8String(self) 415 | 416 | def GetUtf16String(self): 417 | return _pySmartIdEngine.OcrString_GetUtf16String(self) 418 | OcrString_swigregister = _pySmartIdEngine.OcrString_swigregister 419 | OcrString_swigregister(OcrString) 420 | 421 | class StringField(_object): 422 | __swig_setmethods__ = {} 423 | __setattr__ = lambda self, name, value: _swig_setattr(self, StringField, name, value) 424 | __swig_getmethods__ = {} 425 | __getattr__ = lambda self, name: _swig_getattr(self, StringField, name) 426 | __repr__ = _swig_repr 427 | 428 | def __init__(self, *args): 429 | this = _pySmartIdEngine.new_StringField(*args) 430 | try: 431 | self.this.append(this) 432 | except __builtin__.Exception: 433 | self.this = this 434 | __swig_destroy__ = _pySmartIdEngine.delete_StringField 435 | __del__ = lambda self: None 436 | 437 | def GetName(self): 438 | return _pySmartIdEngine.StringField_GetName(self) 439 | 440 | def GetValue(self): 441 | return _pySmartIdEngine.StringField_GetValue(self) 442 | 443 | def GetUtf8Value(self): 444 | return _pySmartIdEngine.StringField_GetUtf8Value(self) 445 | 446 | def IsAccepted(self): 447 | return _pySmartIdEngine.StringField_IsAccepted(self) 448 | 449 | def GetConfidence(self): 450 | return _pySmartIdEngine.StringField_GetConfidence(self) 451 | 452 | def GetAttributeNames(self): 453 | return _pySmartIdEngine.StringField_GetAttributeNames(self) 454 | 455 | def GetAttributes(self): 456 | return _pySmartIdEngine.StringField_GetAttributes(self) 457 | 458 | def HasAttribute(self, attribute_name): 459 | return _pySmartIdEngine.StringField_HasAttribute(self, attribute_name) 460 | 461 | def GetAttribute(self, attribute_name): 462 | return _pySmartIdEngine.StringField_GetAttribute(self, attribute_name) 463 | StringField_swigregister = _pySmartIdEngine.StringField_swigregister 464 | StringField_swigregister(StringField) 465 | 466 | class ImageField(_object): 467 | __swig_setmethods__ = {} 468 | __setattr__ = lambda self, name, value: _swig_setattr(self, ImageField, name, value) 469 | __swig_getmethods__ = {} 470 | __getattr__ = lambda self, name: _swig_getattr(self, ImageField, name) 471 | __repr__ = _swig_repr 472 | 473 | def __init__(self, *args): 474 | this = _pySmartIdEngine.new_ImageField(*args) 475 | try: 476 | self.this.append(this) 477 | except __builtin__.Exception: 478 | self.this = this 479 | __swig_destroy__ = _pySmartIdEngine.delete_ImageField 480 | __del__ = lambda self: None 481 | 482 | def GetName(self): 483 | return _pySmartIdEngine.ImageField_GetName(self) 484 | 485 | def GetValue(self): 486 | return _pySmartIdEngine.ImageField_GetValue(self) 487 | 488 | def IsAccepted(self): 489 | return _pySmartIdEngine.ImageField_IsAccepted(self) 490 | 491 | def GetConfidence(self): 492 | return _pySmartIdEngine.ImageField_GetConfidence(self) 493 | 494 | def GetAttributeNames(self): 495 | return _pySmartIdEngine.ImageField_GetAttributeNames(self) 496 | 497 | def GetAttributes(self): 498 | return _pySmartIdEngine.ImageField_GetAttributes(self) 499 | 500 | def HasAttribute(self, attribute_name): 501 | return _pySmartIdEngine.ImageField_HasAttribute(self, attribute_name) 502 | 503 | def GetAttribute(self, attribute_name): 504 | return _pySmartIdEngine.ImageField_GetAttribute(self, attribute_name) 505 | ImageField_swigregister = _pySmartIdEngine.ImageField_swigregister 506 | ImageField_swigregister(ImageField) 507 | 508 | class MatchResult(_object): 509 | __swig_setmethods__ = {} 510 | __setattr__ = lambda self, name, value: _swig_setattr(self, MatchResult, name, value) 511 | __swig_getmethods__ = {} 512 | __getattr__ = lambda self, name: _swig_getattr(self, MatchResult, name) 513 | __repr__ = _swig_repr 514 | 515 | def __init__(self, *args): 516 | this = _pySmartIdEngine.new_MatchResult(*args) 517 | try: 518 | self.this.append(this) 519 | except __builtin__.Exception: 520 | self.this = this 521 | __swig_destroy__ = _pySmartIdEngine.delete_MatchResult 522 | __del__ = lambda self: None 523 | 524 | def GetTemplateType(self): 525 | return _pySmartIdEngine.MatchResult_GetTemplateType(self) 526 | 527 | def GetQuadrangle(self): 528 | return _pySmartIdEngine.MatchResult_GetQuadrangle(self) 529 | 530 | def GetStandardWidth(self): 531 | return _pySmartIdEngine.MatchResult_GetStandardWidth(self) 532 | 533 | def GetStandardHeight(self): 534 | return _pySmartIdEngine.MatchResult_GetStandardHeight(self) 535 | 536 | def GetAccepted(self): 537 | return _pySmartIdEngine.MatchResult_GetAccepted(self) 538 | 539 | def GetConfidence(self): 540 | return _pySmartIdEngine.MatchResult_GetConfidence(self) 541 | MatchResult_swigregister = _pySmartIdEngine.MatchResult_swigregister 542 | MatchResult_swigregister(MatchResult) 543 | 544 | class ForensicField(_object): 545 | __swig_setmethods__ = {} 546 | __setattr__ = lambda self, name, value: _swig_setattr(self, ForensicField, name, value) 547 | __swig_getmethods__ = {} 548 | __getattr__ = lambda self, name: _swig_getattr(self, ForensicField, name) 549 | __repr__ = _swig_repr 550 | 551 | def __init__(self, *args): 552 | this = _pySmartIdEngine.new_ForensicField(*args) 553 | try: 554 | self.this.append(this) 555 | except __builtin__.Exception: 556 | self.this = this 557 | __swig_destroy__ = _pySmartIdEngine.delete_ForensicField 558 | __del__ = lambda self: None 559 | 560 | def GetName(self): 561 | return _pySmartIdEngine.ForensicField_GetName(self) 562 | 563 | def GetValue(self): 564 | return _pySmartIdEngine.ForensicField_GetValue(self) 565 | 566 | def IsAccepted(self): 567 | return _pySmartIdEngine.ForensicField_IsAccepted(self) 568 | 569 | def GetConfidence(self): 570 | return _pySmartIdEngine.ForensicField_GetConfidence(self) 571 | 572 | def GetAttributeNames(self): 573 | return _pySmartIdEngine.ForensicField_GetAttributeNames(self) 574 | 575 | def GetAttributes(self): 576 | return _pySmartIdEngine.ForensicField_GetAttributes(self) 577 | 578 | def HasAttribute(self, attribute_name): 579 | return _pySmartIdEngine.ForensicField_HasAttribute(self, attribute_name) 580 | 581 | def GetAttribute(self, attribute_name): 582 | return _pySmartIdEngine.ForensicField_GetAttribute(self, attribute_name) 583 | ForensicField_swigregister = _pySmartIdEngine.ForensicField_swigregister 584 | ForensicField_swigregister(ForensicField) 585 | 586 | class SegmentationResult(_object): 587 | __swig_setmethods__ = {} 588 | __setattr__ = lambda self, name, value: _swig_setattr(self, SegmentationResult, name, value) 589 | __swig_getmethods__ = {} 590 | __getattr__ = lambda self, name: _swig_getattr(self, SegmentationResult, name) 591 | __repr__ = _swig_repr 592 | 593 | def __init__(self, *args): 594 | this = _pySmartIdEngine.new_SegmentationResult(*args) 595 | try: 596 | self.this.append(this) 597 | except __builtin__.Exception: 598 | self.this = this 599 | __swig_destroy__ = _pySmartIdEngine.delete_SegmentationResult 600 | __del__ = lambda self: None 601 | 602 | def GetRawFieldsNames(self): 603 | return _pySmartIdEngine.SegmentationResult_GetRawFieldsNames(self) 604 | 605 | def HasRawFieldQuadrangle(self, raw_field_name): 606 | return _pySmartIdEngine.SegmentationResult_HasRawFieldQuadrangle(self, raw_field_name) 607 | 608 | def GetRawFieldQuadrangle(self, raw_field_name): 609 | return _pySmartIdEngine.SegmentationResult_GetRawFieldQuadrangle(self, raw_field_name) 610 | 611 | def GetRawFieldQuadrangles(self): 612 | return _pySmartIdEngine.SegmentationResult_GetRawFieldQuadrangles(self) 613 | 614 | def GetRawFieldTemplateQuadrangle(self, raw_field_name): 615 | return _pySmartIdEngine.SegmentationResult_GetRawFieldTemplateQuadrangle(self, raw_field_name) 616 | 617 | def GetRawFieldTemplateQuadrangles(self): 618 | return _pySmartIdEngine.SegmentationResult_GetRawFieldTemplateQuadrangles(self) 619 | 620 | def GetAccepted(self): 621 | return _pySmartIdEngine.SegmentationResult_GetAccepted(self) 622 | SegmentationResult_swigregister = _pySmartIdEngine.SegmentationResult_swigregister 623 | SegmentationResult_swigregister(SegmentationResult) 624 | 625 | class RecognitionResult(_object): 626 | __swig_setmethods__ = {} 627 | __setattr__ = lambda self, name, value: _swig_setattr(self, RecognitionResult, name, value) 628 | __swig_getmethods__ = {} 629 | __getattr__ = lambda self, name: _swig_getattr(self, RecognitionResult, name) 630 | __repr__ = _swig_repr 631 | 632 | def __init__(self, *args): 633 | this = _pySmartIdEngine.new_RecognitionResult(*args) 634 | try: 635 | self.this.append(this) 636 | except __builtin__.Exception: 637 | self.this = this 638 | __swig_destroy__ = _pySmartIdEngine.delete_RecognitionResult 639 | __del__ = lambda self: None 640 | 641 | def GetStringFieldNames(self): 642 | return _pySmartIdEngine.RecognitionResult_GetStringFieldNames(self) 643 | 644 | def HasStringField(self, name): 645 | return _pySmartIdEngine.RecognitionResult_HasStringField(self, name) 646 | 647 | def GetStringField(self, name): 648 | return _pySmartIdEngine.RecognitionResult_GetStringField(self, name) 649 | 650 | def GetStringFields(self, *args): 651 | return _pySmartIdEngine.RecognitionResult_GetStringFields(self, *args) 652 | 653 | def SetStringFields(self, string_fields): 654 | return _pySmartIdEngine.RecognitionResult_SetStringFields(self, string_fields) 655 | 656 | def GetImageFieldNames(self): 657 | return _pySmartIdEngine.RecognitionResult_GetImageFieldNames(self) 658 | 659 | def HasImageField(self, name): 660 | return _pySmartIdEngine.RecognitionResult_HasImageField(self, name) 661 | 662 | def GetImageField(self, name): 663 | return _pySmartIdEngine.RecognitionResult_GetImageField(self, name) 664 | 665 | def GetImageFields(self, *args): 666 | return _pySmartIdEngine.RecognitionResult_GetImageFields(self, *args) 667 | 668 | def SetImageFields(self, image_fields): 669 | return _pySmartIdEngine.RecognitionResult_SetImageFields(self, image_fields) 670 | 671 | def GetForensicFieldNames(self): 672 | return _pySmartIdEngine.RecognitionResult_GetForensicFieldNames(self) 673 | 674 | def HasForensicField(self, name): 675 | return _pySmartIdEngine.RecognitionResult_HasForensicField(self, name) 676 | 677 | def GetForensicField(self, name): 678 | return _pySmartIdEngine.RecognitionResult_GetForensicField(self, name) 679 | 680 | def GetForensicFields(self, *args): 681 | return _pySmartIdEngine.RecognitionResult_GetForensicFields(self, *args) 682 | 683 | def SetForensicFields(self, forensic_fields): 684 | return _pySmartIdEngine.RecognitionResult_SetForensicFields(self, forensic_fields) 685 | 686 | def GetRawStringFieldNames(self): 687 | return _pySmartIdEngine.RecognitionResult_GetRawStringFieldNames(self) 688 | 689 | def HasRawStringField(self, name): 690 | return _pySmartIdEngine.RecognitionResult_HasRawStringField(self, name) 691 | 692 | def GetRawStringField(self, name): 693 | return _pySmartIdEngine.RecognitionResult_GetRawStringField(self, name) 694 | 695 | def GetRawStringFields(self, *args): 696 | return _pySmartIdEngine.RecognitionResult_GetRawStringFields(self, *args) 697 | 698 | def SetRawStringFields(self, raw_string_fields): 699 | return _pySmartIdEngine.RecognitionResult_SetRawStringFields(self, raw_string_fields) 700 | 701 | def GetRawImageFieldNames(self): 702 | return _pySmartIdEngine.RecognitionResult_GetRawImageFieldNames(self) 703 | 704 | def HasRawImageField(self, name): 705 | return _pySmartIdEngine.RecognitionResult_HasRawImageField(self, name) 706 | 707 | def GetRawImageField(self, name): 708 | return _pySmartIdEngine.RecognitionResult_GetRawImageField(self, name) 709 | 710 | def GetRawImageFields(self, *args): 711 | return _pySmartIdEngine.RecognitionResult_GetRawImageFields(self, *args) 712 | 713 | def SetRawImageFields(self, raw_image_fields): 714 | return _pySmartIdEngine.RecognitionResult_SetRawImageFields(self, raw_image_fields) 715 | 716 | def GetDocumentType(self): 717 | return _pySmartIdEngine.RecognitionResult_GetDocumentType(self) 718 | 719 | def SetDocumentType(self, doctype): 720 | return _pySmartIdEngine.RecognitionResult_SetDocumentType(self, doctype) 721 | 722 | def GetMatchResults(self): 723 | return _pySmartIdEngine.RecognitionResult_GetMatchResults(self) 724 | 725 | def SetMatchResults(self, match_results): 726 | return _pySmartIdEngine.RecognitionResult_SetMatchResults(self, match_results) 727 | 728 | def GetSegmentationResults(self): 729 | return _pySmartIdEngine.RecognitionResult_GetSegmentationResults(self) 730 | 731 | def SetSegmentationResults(self, segmentation_results): 732 | return _pySmartIdEngine.RecognitionResult_SetSegmentationResults(self, segmentation_results) 733 | 734 | def IsTerminal(self): 735 | return _pySmartIdEngine.RecognitionResult_IsTerminal(self) 736 | 737 | def SetIsTerminal(self, is_terminal): 738 | return _pySmartIdEngine.RecognitionResult_SetIsTerminal(self, is_terminal) 739 | 740 | def GetJpegCompression(self): 741 | return _pySmartIdEngine.RecognitionResult_GetJpegCompression(self) 742 | 743 | def SetJpegCompression(self, jpeg_compression): 744 | return _pySmartIdEngine.RecognitionResult_SetJpegCompression(self, jpeg_compression) 745 | RecognitionResult_swigregister = _pySmartIdEngine.RecognitionResult_swigregister 746 | RecognitionResult_swigregister(RecognitionResult) 747 | 748 | class ProcessingFeedback(_object): 749 | __swig_setmethods__ = {} 750 | __setattr__ = lambda self, name, value: _swig_setattr(self, ProcessingFeedback, name, value) 751 | __swig_getmethods__ = {} 752 | __getattr__ = lambda self, name: _swig_getattr(self, ProcessingFeedback, name) 753 | __repr__ = _swig_repr 754 | 755 | def __init__(self, *args): 756 | this = _pySmartIdEngine.new_ProcessingFeedback(*args) 757 | try: 758 | self.this.append(this) 759 | except __builtin__.Exception: 760 | self.this = this 761 | __swig_destroy__ = _pySmartIdEngine.delete_ProcessingFeedback 762 | __del__ = lambda self: None 763 | 764 | def GetQuadrangles(self): 765 | return _pySmartIdEngine.ProcessingFeedback_GetQuadrangles(self) 766 | ProcessingFeedback_swigregister = _pySmartIdEngine.ProcessingFeedback_swigregister 767 | ProcessingFeedback_swigregister(ProcessingFeedback) 768 | 769 | class ResultReporterInterface(_object): 770 | __swig_setmethods__ = {} 771 | __setattr__ = lambda self, name, value: _swig_setattr(self, ResultReporterInterface, name, value) 772 | __swig_getmethods__ = {} 773 | __getattr__ = lambda self, name: _swig_getattr(self, ResultReporterInterface, name) 774 | 775 | def __init__(self, *args, **kwargs): 776 | raise AttributeError("No constructor defined - class is abstract") 777 | __repr__ = _swig_repr 778 | 779 | def SnapshotRejected(self): 780 | return _pySmartIdEngine.ResultReporterInterface_SnapshotRejected(self) 781 | 782 | def FeedbackReceived(self, processing_feedback): 783 | return _pySmartIdEngine.ResultReporterInterface_FeedbackReceived(self, processing_feedback) 784 | 785 | def DocumentMatched(self, match_results): 786 | return _pySmartIdEngine.ResultReporterInterface_DocumentMatched(self, match_results) 787 | 788 | def DocumentSegmented(self, segmentation_results): 789 | return _pySmartIdEngine.ResultReporterInterface_DocumentSegmented(self, segmentation_results) 790 | 791 | def SnapshotProcessed(self, recog_result): 792 | return _pySmartIdEngine.ResultReporterInterface_SnapshotProcessed(self, recog_result) 793 | 794 | def SessionEnded(self): 795 | return _pySmartIdEngine.ResultReporterInterface_SessionEnded(self) 796 | __swig_destroy__ = _pySmartIdEngine.delete_ResultReporterInterface 797 | __del__ = lambda self: None 798 | ResultReporterInterface_swigregister = _pySmartIdEngine.ResultReporterInterface_swigregister 799 | ResultReporterInterface_swigregister(ResultReporterInterface) 800 | 801 | class IntegratedFieldState(_object): 802 | __swig_setmethods__ = {} 803 | __setattr__ = lambda self, name, value: _swig_setattr(self, IntegratedFieldState, name, value) 804 | __swig_getmethods__ = {} 805 | __getattr__ = lambda self, name: _swig_getattr(self, IntegratedFieldState, name) 806 | __repr__ = _swig_repr 807 | 808 | def __init__(self, is_terminal=False): 809 | this = _pySmartIdEngine.new_IntegratedFieldState(is_terminal) 810 | try: 811 | self.this.append(this) 812 | except __builtin__.Exception: 813 | self.this = this 814 | 815 | def IsTerminal(self): 816 | return _pySmartIdEngine.IntegratedFieldState_IsTerminal(self) 817 | 818 | def SetIsTerminal(self, is_terminal): 819 | return _pySmartIdEngine.IntegratedFieldState_SetIsTerminal(self, is_terminal) 820 | __swig_destroy__ = _pySmartIdEngine.delete_IntegratedFieldState 821 | __del__ = lambda self: None 822 | IntegratedFieldState_swigregister = _pySmartIdEngine.IntegratedFieldState_swigregister 823 | IntegratedFieldState_swigregister(IntegratedFieldState) 824 | 825 | class SessionState(_object): 826 | __swig_setmethods__ = {} 827 | __setattr__ = lambda self, name, value: _swig_setattr(self, SessionState, name, value) 828 | __swig_getmethods__ = {} 829 | __getattr__ = lambda self, name: _swig_getattr(self, SessionState, name) 830 | 831 | def __init__(self, *args, **kwargs): 832 | raise AttributeError("No constructor defined") 833 | __repr__ = _swig_repr 834 | __swig_destroy__ = _pySmartIdEngine.delete_SessionState 835 | __del__ = lambda self: None 836 | 837 | def GetIntegratedFieldStateNames(self): 838 | return _pySmartIdEngine.SessionState_GetIntegratedFieldStateNames(self) 839 | 840 | def HasIntegratedFieldState(self, name): 841 | return _pySmartIdEngine.SessionState_HasIntegratedFieldState(self, name) 842 | 843 | def GetStringFieldState(self, name): 844 | return _pySmartIdEngine.SessionState_GetStringFieldState(self, name) 845 | 846 | def SetIntegratedFieldStates(self, integrated_field_states): 847 | return _pySmartIdEngine.SessionState_SetIntegratedFieldStates(self, integrated_field_states) 848 | 849 | def GetSnapshotsProcessed(self): 850 | return _pySmartIdEngine.SessionState_GetSnapshotsProcessed(self) 851 | SessionState_swigregister = _pySmartIdEngine.SessionState_swigregister 852 | SessionState_swigregister(SessionState) 853 | 854 | class SessionSettings(_object): 855 | __swig_setmethods__ = {} 856 | __setattr__ = lambda self, name, value: _swig_setattr(self, SessionSettings, name, value) 857 | __swig_getmethods__ = {} 858 | __getattr__ = lambda self, name: _swig_getattr(self, SessionSettings, name) 859 | 860 | def __init__(self, *args, **kwargs): 861 | raise AttributeError("No constructor defined - class is abstract") 862 | __repr__ = _swig_repr 863 | __swig_destroy__ = _pySmartIdEngine.delete_SessionSettings 864 | __del__ = lambda self: None 865 | 866 | def Clone(self): 867 | return _pySmartIdEngine.SessionSettings_Clone(self) 868 | 869 | def GetEnabledDocumentTypes(self): 870 | return _pySmartIdEngine.SessionSettings_GetEnabledDocumentTypes(self) 871 | 872 | def AddEnabledDocumentTypes(self, doctype_mask): 873 | return _pySmartIdEngine.SessionSettings_AddEnabledDocumentTypes(self, doctype_mask) 874 | 875 | def RemoveEnabledDocumentTypes(self, doctype_mask): 876 | return _pySmartIdEngine.SessionSettings_RemoveEnabledDocumentTypes(self, doctype_mask) 877 | 878 | def SetEnabledDocumentTypes(self, document_types): 879 | return _pySmartIdEngine.SessionSettings_SetEnabledDocumentTypes(self, document_types) 880 | 881 | def GetSupportedDocumentTypes(self): 882 | return _pySmartIdEngine.SessionSettings_GetSupportedDocumentTypes(self) 883 | 884 | def GetOptionNames(self): 885 | return _pySmartIdEngine.SessionSettings_GetOptionNames(self) 886 | 887 | def HasOption(self, name): 888 | return _pySmartIdEngine.SessionSettings_HasOption(self, name) 889 | 890 | def GetOption(self, name): 891 | return _pySmartIdEngine.SessionSettings_GetOption(self, name) 892 | 893 | def SetOption(self, name, value): 894 | return _pySmartIdEngine.SessionSettings_SetOption(self, name, value) 895 | 896 | def RemoveOption(self, name): 897 | return _pySmartIdEngine.SessionSettings_RemoveOption(self, name) 898 | 899 | def GetEnabledFieldNames(self): 900 | return _pySmartIdEngine.SessionSettings_GetEnabledFieldNames(self) 901 | 902 | def EnableField(self, doctype, field_name): 903 | return _pySmartIdEngine.SessionSettings_EnableField(self, doctype, field_name) 904 | 905 | def DisableField(self, doctype, field_name): 906 | return _pySmartIdEngine.SessionSettings_DisableField(self, doctype, field_name) 907 | 908 | def SetEnabledFields(self, doctype, field_names): 909 | return _pySmartIdEngine.SessionSettings_SetEnabledFields(self, doctype, field_names) 910 | 911 | def GetSupportedFieldNames(self, doctype): 912 | return _pySmartIdEngine.SessionSettings_GetSupportedFieldNames(self, doctype) 913 | 914 | def GetEnabledForensicFieldNames(self): 915 | return _pySmartIdEngine.SessionSettings_GetEnabledForensicFieldNames(self) 916 | 917 | def EnableForensicField(self, doctype, field_name): 918 | return _pySmartIdEngine.SessionSettings_EnableForensicField(self, doctype, field_name) 919 | 920 | def DisableForensicField(self, doctype, field_name): 921 | return _pySmartIdEngine.SessionSettings_DisableForensicField(self, doctype, field_name) 922 | 923 | def SetEnabledForensicFields(self, doctype, field_names): 924 | return _pySmartIdEngine.SessionSettings_SetEnabledForensicFields(self, doctype, field_names) 925 | 926 | def GetSupportedForensicFieldNames(self, doctype): 927 | return _pySmartIdEngine.SessionSettings_GetSupportedForensicFieldNames(self, doctype) 928 | 929 | def GetCurrentMode(self): 930 | return _pySmartIdEngine.SessionSettings_GetCurrentMode(self) 931 | 932 | def SetCurrentMode(self, mode): 933 | return _pySmartIdEngine.SessionSettings_SetCurrentMode(self, mode) 934 | 935 | def GetAvailableModes(self): 936 | return _pySmartIdEngine.SessionSettings_GetAvailableModes(self) 937 | SessionSettings_swigregister = _pySmartIdEngine.SessionSettings_swigregister 938 | SessionSettings_swigregister(SessionSettings) 939 | 940 | class RecognitionSession(_object): 941 | __swig_setmethods__ = {} 942 | __setattr__ = lambda self, name, value: _swig_setattr(self, RecognitionSession, name, value) 943 | __swig_getmethods__ = {} 944 | __getattr__ = lambda self, name: _swig_getattr(self, RecognitionSession, name) 945 | 946 | def __init__(self, *args, **kwargs): 947 | raise AttributeError("No constructor defined - class is abstract") 948 | __repr__ = _swig_repr 949 | __swig_destroy__ = _pySmartIdEngine.delete_RecognitionSession 950 | __del__ = lambda self: None 951 | 952 | def ProcessSnapshot(self, *args): 953 | return _pySmartIdEngine.RecognitionSession_ProcessSnapshot(self, *args) 954 | 955 | def ProcessYUVSnapshot(self, *args): 956 | return _pySmartIdEngine.RecognitionSession_ProcessYUVSnapshot(self, *args) 957 | 958 | def ProcessImage(self, *args): 959 | return _pySmartIdEngine.RecognitionSession_ProcessImage(self, *args) 960 | 961 | def ProcessImageFile(self, *args): 962 | return _pySmartIdEngine.RecognitionSession_ProcessImageFile(self, *args) 963 | 964 | def ProcessImageData(self, *args): 965 | return _pySmartIdEngine.RecognitionSession_ProcessImageData(self, *args) 966 | 967 | def ProcessImageDataBase64(self, *args): 968 | return _pySmartIdEngine.RecognitionSession_ProcessImageDataBase64(self, *args) 969 | 970 | def GetSessionState(self): 971 | return _pySmartIdEngine.RecognitionSession_GetSessionState(self) 972 | 973 | def Reset(self): 974 | return _pySmartIdEngine.RecognitionSession_Reset(self) 975 | RecognitionSession_swigregister = _pySmartIdEngine.RecognitionSession_swigregister 976 | RecognitionSession_swigregister(RecognitionSession) 977 | 978 | class RecognitionEngine(_object): 979 | __swig_setmethods__ = {} 980 | __setattr__ = lambda self, name, value: _swig_setattr(self, RecognitionEngine, name, value) 981 | __swig_getmethods__ = {} 982 | __getattr__ = lambda self, name: _swig_getattr(self, RecognitionEngine, name) 983 | __repr__ = _swig_repr 984 | 985 | def __init__(self, *args): 986 | this = _pySmartIdEngine.new_RecognitionEngine(*args) 987 | try: 988 | self.this.append(this) 989 | except __builtin__.Exception: 990 | self.this = this 991 | __swig_destroy__ = _pySmartIdEngine.delete_RecognitionEngine 992 | __del__ = lambda self: None 993 | 994 | def CreateSessionSettings(self): 995 | return _pySmartIdEngine.RecognitionEngine_CreateSessionSettings(self) 996 | 997 | def SpawnSession(self, session_settings, result_reporter=None): 998 | return _pySmartIdEngine.RecognitionEngine_SpawnSession(self, session_settings, result_reporter) 999 | if _newclass: 1000 | GetVersion = staticmethod(_pySmartIdEngine.RecognitionEngine_GetVersion) 1001 | else: 1002 | GetVersion = _pySmartIdEngine.RecognitionEngine_GetVersion 1003 | RecognitionEngine_swigregister = _pySmartIdEngine.RecognitionEngine_swigregister 1004 | RecognitionEngine_swigregister(RecognitionEngine) 1005 | 1006 | def RecognitionEngine_GetVersion(): 1007 | return _pySmartIdEngine.RecognitionEngine_GetVersion() 1008 | RecognitionEngine_GetVersion = _pySmartIdEngine.RecognitionEngine_GetVersion 1009 | 1010 | class Utf16CharVector(_object): 1011 | __swig_setmethods__ = {} 1012 | __setattr__ = lambda self, name, value: _swig_setattr(self, Utf16CharVector, name, value) 1013 | __swig_getmethods__ = {} 1014 | __getattr__ = lambda self, name: _swig_getattr(self, Utf16CharVector, name) 1015 | __repr__ = _swig_repr 1016 | 1017 | def iterator(self): 1018 | return _pySmartIdEngine.Utf16CharVector_iterator(self) 1019 | def __iter__(self): 1020 | return self.iterator() 1021 | 1022 | def __nonzero__(self): 1023 | return _pySmartIdEngine.Utf16CharVector___nonzero__(self) 1024 | 1025 | def __bool__(self): 1026 | return _pySmartIdEngine.Utf16CharVector___bool__(self) 1027 | 1028 | def __len__(self): 1029 | return _pySmartIdEngine.Utf16CharVector___len__(self) 1030 | 1031 | def __getslice__(self, i, j): 1032 | return _pySmartIdEngine.Utf16CharVector___getslice__(self, i, j) 1033 | 1034 | def __setslice__(self, *args): 1035 | return _pySmartIdEngine.Utf16CharVector___setslice__(self, *args) 1036 | 1037 | def __delslice__(self, i, j): 1038 | return _pySmartIdEngine.Utf16CharVector___delslice__(self, i, j) 1039 | 1040 | def __delitem__(self, *args): 1041 | return _pySmartIdEngine.Utf16CharVector___delitem__(self, *args) 1042 | 1043 | def __getitem__(self, *args): 1044 | return _pySmartIdEngine.Utf16CharVector___getitem__(self, *args) 1045 | 1046 | def __setitem__(self, *args): 1047 | return _pySmartIdEngine.Utf16CharVector___setitem__(self, *args) 1048 | 1049 | def pop(self): 1050 | return _pySmartIdEngine.Utf16CharVector_pop(self) 1051 | 1052 | def append(self, x): 1053 | return _pySmartIdEngine.Utf16CharVector_append(self, x) 1054 | 1055 | def empty(self): 1056 | return _pySmartIdEngine.Utf16CharVector_empty(self) 1057 | 1058 | def size(self): 1059 | return _pySmartIdEngine.Utf16CharVector_size(self) 1060 | 1061 | def swap(self, v): 1062 | return _pySmartIdEngine.Utf16CharVector_swap(self, v) 1063 | 1064 | def begin(self): 1065 | return _pySmartIdEngine.Utf16CharVector_begin(self) 1066 | 1067 | def end(self): 1068 | return _pySmartIdEngine.Utf16CharVector_end(self) 1069 | 1070 | def rbegin(self): 1071 | return _pySmartIdEngine.Utf16CharVector_rbegin(self) 1072 | 1073 | def rend(self): 1074 | return _pySmartIdEngine.Utf16CharVector_rend(self) 1075 | 1076 | def clear(self): 1077 | return _pySmartIdEngine.Utf16CharVector_clear(self) 1078 | 1079 | def get_allocator(self): 1080 | return _pySmartIdEngine.Utf16CharVector_get_allocator(self) 1081 | 1082 | def pop_back(self): 1083 | return _pySmartIdEngine.Utf16CharVector_pop_back(self) 1084 | 1085 | def erase(self, *args): 1086 | return _pySmartIdEngine.Utf16CharVector_erase(self, *args) 1087 | 1088 | def __init__(self, *args): 1089 | this = _pySmartIdEngine.new_Utf16CharVector(*args) 1090 | try: 1091 | self.this.append(this) 1092 | except __builtin__.Exception: 1093 | self.this = this 1094 | 1095 | def push_back(self, x): 1096 | return _pySmartIdEngine.Utf16CharVector_push_back(self, x) 1097 | 1098 | def front(self): 1099 | return _pySmartIdEngine.Utf16CharVector_front(self) 1100 | 1101 | def back(self): 1102 | return _pySmartIdEngine.Utf16CharVector_back(self) 1103 | 1104 | def assign(self, n, x): 1105 | return _pySmartIdEngine.Utf16CharVector_assign(self, n, x) 1106 | 1107 | def resize(self, *args): 1108 | return _pySmartIdEngine.Utf16CharVector_resize(self, *args) 1109 | 1110 | def insert(self, *args): 1111 | return _pySmartIdEngine.Utf16CharVector_insert(self, *args) 1112 | 1113 | def reserve(self, n): 1114 | return _pySmartIdEngine.Utf16CharVector_reserve(self, n) 1115 | 1116 | def capacity(self): 1117 | return _pySmartIdEngine.Utf16CharVector_capacity(self) 1118 | __swig_destroy__ = _pySmartIdEngine.delete_Utf16CharVector 1119 | __del__ = lambda self: None 1120 | Utf16CharVector_swigregister = _pySmartIdEngine.Utf16CharVector_swigregister 1121 | Utf16CharVector_swigregister(Utf16CharVector) 1122 | 1123 | class StringVector(_object): 1124 | __swig_setmethods__ = {} 1125 | __setattr__ = lambda self, name, value: _swig_setattr(self, StringVector, name, value) 1126 | __swig_getmethods__ = {} 1127 | __getattr__ = lambda self, name: _swig_getattr(self, StringVector, name) 1128 | __repr__ = _swig_repr 1129 | 1130 | def iterator(self): 1131 | return _pySmartIdEngine.StringVector_iterator(self) 1132 | def __iter__(self): 1133 | return self.iterator() 1134 | 1135 | def __nonzero__(self): 1136 | return _pySmartIdEngine.StringVector___nonzero__(self) 1137 | 1138 | def __bool__(self): 1139 | return _pySmartIdEngine.StringVector___bool__(self) 1140 | 1141 | def __len__(self): 1142 | return _pySmartIdEngine.StringVector___len__(self) 1143 | 1144 | def __getslice__(self, i, j): 1145 | return _pySmartIdEngine.StringVector___getslice__(self, i, j) 1146 | 1147 | def __setslice__(self, *args): 1148 | return _pySmartIdEngine.StringVector___setslice__(self, *args) 1149 | 1150 | def __delslice__(self, i, j): 1151 | return _pySmartIdEngine.StringVector___delslice__(self, i, j) 1152 | 1153 | def __delitem__(self, *args): 1154 | return _pySmartIdEngine.StringVector___delitem__(self, *args) 1155 | 1156 | def __getitem__(self, *args): 1157 | return _pySmartIdEngine.StringVector___getitem__(self, *args) 1158 | 1159 | def __setitem__(self, *args): 1160 | return _pySmartIdEngine.StringVector___setitem__(self, *args) 1161 | 1162 | def pop(self): 1163 | return _pySmartIdEngine.StringVector_pop(self) 1164 | 1165 | def append(self, x): 1166 | return _pySmartIdEngine.StringVector_append(self, x) 1167 | 1168 | def empty(self): 1169 | return _pySmartIdEngine.StringVector_empty(self) 1170 | 1171 | def size(self): 1172 | return _pySmartIdEngine.StringVector_size(self) 1173 | 1174 | def swap(self, v): 1175 | return _pySmartIdEngine.StringVector_swap(self, v) 1176 | 1177 | def begin(self): 1178 | return _pySmartIdEngine.StringVector_begin(self) 1179 | 1180 | def end(self): 1181 | return _pySmartIdEngine.StringVector_end(self) 1182 | 1183 | def rbegin(self): 1184 | return _pySmartIdEngine.StringVector_rbegin(self) 1185 | 1186 | def rend(self): 1187 | return _pySmartIdEngine.StringVector_rend(self) 1188 | 1189 | def clear(self): 1190 | return _pySmartIdEngine.StringVector_clear(self) 1191 | 1192 | def get_allocator(self): 1193 | return _pySmartIdEngine.StringVector_get_allocator(self) 1194 | 1195 | def pop_back(self): 1196 | return _pySmartIdEngine.StringVector_pop_back(self) 1197 | 1198 | def erase(self, *args): 1199 | return _pySmartIdEngine.StringVector_erase(self, *args) 1200 | 1201 | def __init__(self, *args): 1202 | this = _pySmartIdEngine.new_StringVector(*args) 1203 | try: 1204 | self.this.append(this) 1205 | except __builtin__.Exception: 1206 | self.this = this 1207 | 1208 | def push_back(self, x): 1209 | return _pySmartIdEngine.StringVector_push_back(self, x) 1210 | 1211 | def front(self): 1212 | return _pySmartIdEngine.StringVector_front(self) 1213 | 1214 | def back(self): 1215 | return _pySmartIdEngine.StringVector_back(self) 1216 | 1217 | def assign(self, n, x): 1218 | return _pySmartIdEngine.StringVector_assign(self, n, x) 1219 | 1220 | def resize(self, *args): 1221 | return _pySmartIdEngine.StringVector_resize(self, *args) 1222 | 1223 | def insert(self, *args): 1224 | return _pySmartIdEngine.StringVector_insert(self, *args) 1225 | 1226 | def reserve(self, n): 1227 | return _pySmartIdEngine.StringVector_reserve(self, n) 1228 | 1229 | def capacity(self): 1230 | return _pySmartIdEngine.StringVector_capacity(self) 1231 | __swig_destroy__ = _pySmartIdEngine.delete_StringVector 1232 | __del__ = lambda self: None 1233 | StringVector_swigregister = _pySmartIdEngine.StringVector_swigregister 1234 | StringVector_swigregister(StringVector) 1235 | 1236 | class StringVector2d(_object): 1237 | __swig_setmethods__ = {} 1238 | __setattr__ = lambda self, name, value: _swig_setattr(self, StringVector2d, name, value) 1239 | __swig_getmethods__ = {} 1240 | __getattr__ = lambda self, name: _swig_getattr(self, StringVector2d, name) 1241 | __repr__ = _swig_repr 1242 | 1243 | def iterator(self): 1244 | return _pySmartIdEngine.StringVector2d_iterator(self) 1245 | def __iter__(self): 1246 | return self.iterator() 1247 | 1248 | def __nonzero__(self): 1249 | return _pySmartIdEngine.StringVector2d___nonzero__(self) 1250 | 1251 | def __bool__(self): 1252 | return _pySmartIdEngine.StringVector2d___bool__(self) 1253 | 1254 | def __len__(self): 1255 | return _pySmartIdEngine.StringVector2d___len__(self) 1256 | 1257 | def __getslice__(self, i, j): 1258 | return _pySmartIdEngine.StringVector2d___getslice__(self, i, j) 1259 | 1260 | def __setslice__(self, *args): 1261 | return _pySmartIdEngine.StringVector2d___setslice__(self, *args) 1262 | 1263 | def __delslice__(self, i, j): 1264 | return _pySmartIdEngine.StringVector2d___delslice__(self, i, j) 1265 | 1266 | def __delitem__(self, *args): 1267 | return _pySmartIdEngine.StringVector2d___delitem__(self, *args) 1268 | 1269 | def __getitem__(self, *args): 1270 | return _pySmartIdEngine.StringVector2d___getitem__(self, *args) 1271 | 1272 | def __setitem__(self, *args): 1273 | return _pySmartIdEngine.StringVector2d___setitem__(self, *args) 1274 | 1275 | def pop(self): 1276 | return _pySmartIdEngine.StringVector2d_pop(self) 1277 | 1278 | def append(self, x): 1279 | return _pySmartIdEngine.StringVector2d_append(self, x) 1280 | 1281 | def empty(self): 1282 | return _pySmartIdEngine.StringVector2d_empty(self) 1283 | 1284 | def size(self): 1285 | return _pySmartIdEngine.StringVector2d_size(self) 1286 | 1287 | def swap(self, v): 1288 | return _pySmartIdEngine.StringVector2d_swap(self, v) 1289 | 1290 | def begin(self): 1291 | return _pySmartIdEngine.StringVector2d_begin(self) 1292 | 1293 | def end(self): 1294 | return _pySmartIdEngine.StringVector2d_end(self) 1295 | 1296 | def rbegin(self): 1297 | return _pySmartIdEngine.StringVector2d_rbegin(self) 1298 | 1299 | def rend(self): 1300 | return _pySmartIdEngine.StringVector2d_rend(self) 1301 | 1302 | def clear(self): 1303 | return _pySmartIdEngine.StringVector2d_clear(self) 1304 | 1305 | def get_allocator(self): 1306 | return _pySmartIdEngine.StringVector2d_get_allocator(self) 1307 | 1308 | def pop_back(self): 1309 | return _pySmartIdEngine.StringVector2d_pop_back(self) 1310 | 1311 | def erase(self, *args): 1312 | return _pySmartIdEngine.StringVector2d_erase(self, *args) 1313 | 1314 | def __init__(self, *args): 1315 | this = _pySmartIdEngine.new_StringVector2d(*args) 1316 | try: 1317 | self.this.append(this) 1318 | except __builtin__.Exception: 1319 | self.this = this 1320 | 1321 | def push_back(self, x): 1322 | return _pySmartIdEngine.StringVector2d_push_back(self, x) 1323 | 1324 | def front(self): 1325 | return _pySmartIdEngine.StringVector2d_front(self) 1326 | 1327 | def back(self): 1328 | return _pySmartIdEngine.StringVector2d_back(self) 1329 | 1330 | def assign(self, n, x): 1331 | return _pySmartIdEngine.StringVector2d_assign(self, n, x) 1332 | 1333 | def resize(self, *args): 1334 | return _pySmartIdEngine.StringVector2d_resize(self, *args) 1335 | 1336 | def insert(self, *args): 1337 | return _pySmartIdEngine.StringVector2d_insert(self, *args) 1338 | 1339 | def reserve(self, n): 1340 | return _pySmartIdEngine.StringVector2d_reserve(self, n) 1341 | 1342 | def capacity(self): 1343 | return _pySmartIdEngine.StringVector2d_capacity(self) 1344 | __swig_destroy__ = _pySmartIdEngine.delete_StringVector2d 1345 | __del__ = lambda self: None 1346 | StringVector2d_swigregister = _pySmartIdEngine.StringVector2d_swigregister 1347 | StringVector2d_swigregister(StringVector2d) 1348 | 1349 | class OcrCharVariantVector(_object): 1350 | __swig_setmethods__ = {} 1351 | __setattr__ = lambda self, name, value: _swig_setattr(self, OcrCharVariantVector, name, value) 1352 | __swig_getmethods__ = {} 1353 | __getattr__ = lambda self, name: _swig_getattr(self, OcrCharVariantVector, name) 1354 | __repr__ = _swig_repr 1355 | 1356 | def iterator(self): 1357 | return _pySmartIdEngine.OcrCharVariantVector_iterator(self) 1358 | def __iter__(self): 1359 | return self.iterator() 1360 | 1361 | def __nonzero__(self): 1362 | return _pySmartIdEngine.OcrCharVariantVector___nonzero__(self) 1363 | 1364 | def __bool__(self): 1365 | return _pySmartIdEngine.OcrCharVariantVector___bool__(self) 1366 | 1367 | def __len__(self): 1368 | return _pySmartIdEngine.OcrCharVariantVector___len__(self) 1369 | 1370 | def __getslice__(self, i, j): 1371 | return _pySmartIdEngine.OcrCharVariantVector___getslice__(self, i, j) 1372 | 1373 | def __setslice__(self, *args): 1374 | return _pySmartIdEngine.OcrCharVariantVector___setslice__(self, *args) 1375 | 1376 | def __delslice__(self, i, j): 1377 | return _pySmartIdEngine.OcrCharVariantVector___delslice__(self, i, j) 1378 | 1379 | def __delitem__(self, *args): 1380 | return _pySmartIdEngine.OcrCharVariantVector___delitem__(self, *args) 1381 | 1382 | def __getitem__(self, *args): 1383 | return _pySmartIdEngine.OcrCharVariantVector___getitem__(self, *args) 1384 | 1385 | def __setitem__(self, *args): 1386 | return _pySmartIdEngine.OcrCharVariantVector___setitem__(self, *args) 1387 | 1388 | def pop(self): 1389 | return _pySmartIdEngine.OcrCharVariantVector_pop(self) 1390 | 1391 | def append(self, x): 1392 | return _pySmartIdEngine.OcrCharVariantVector_append(self, x) 1393 | 1394 | def empty(self): 1395 | return _pySmartIdEngine.OcrCharVariantVector_empty(self) 1396 | 1397 | def size(self): 1398 | return _pySmartIdEngine.OcrCharVariantVector_size(self) 1399 | 1400 | def swap(self, v): 1401 | return _pySmartIdEngine.OcrCharVariantVector_swap(self, v) 1402 | 1403 | def begin(self): 1404 | return _pySmartIdEngine.OcrCharVariantVector_begin(self) 1405 | 1406 | def end(self): 1407 | return _pySmartIdEngine.OcrCharVariantVector_end(self) 1408 | 1409 | def rbegin(self): 1410 | return _pySmartIdEngine.OcrCharVariantVector_rbegin(self) 1411 | 1412 | def rend(self): 1413 | return _pySmartIdEngine.OcrCharVariantVector_rend(self) 1414 | 1415 | def clear(self): 1416 | return _pySmartIdEngine.OcrCharVariantVector_clear(self) 1417 | 1418 | def get_allocator(self): 1419 | return _pySmartIdEngine.OcrCharVariantVector_get_allocator(self) 1420 | 1421 | def pop_back(self): 1422 | return _pySmartIdEngine.OcrCharVariantVector_pop_back(self) 1423 | 1424 | def erase(self, *args): 1425 | return _pySmartIdEngine.OcrCharVariantVector_erase(self, *args) 1426 | 1427 | def __init__(self, *args): 1428 | this = _pySmartIdEngine.new_OcrCharVariantVector(*args) 1429 | try: 1430 | self.this.append(this) 1431 | except __builtin__.Exception: 1432 | self.this = this 1433 | 1434 | def push_back(self, x): 1435 | return _pySmartIdEngine.OcrCharVariantVector_push_back(self, x) 1436 | 1437 | def front(self): 1438 | return _pySmartIdEngine.OcrCharVariantVector_front(self) 1439 | 1440 | def back(self): 1441 | return _pySmartIdEngine.OcrCharVariantVector_back(self) 1442 | 1443 | def assign(self, n, x): 1444 | return _pySmartIdEngine.OcrCharVariantVector_assign(self, n, x) 1445 | 1446 | def resize(self, *args): 1447 | return _pySmartIdEngine.OcrCharVariantVector_resize(self, *args) 1448 | 1449 | def insert(self, *args): 1450 | return _pySmartIdEngine.OcrCharVariantVector_insert(self, *args) 1451 | 1452 | def reserve(self, n): 1453 | return _pySmartIdEngine.OcrCharVariantVector_reserve(self, n) 1454 | 1455 | def capacity(self): 1456 | return _pySmartIdEngine.OcrCharVariantVector_capacity(self) 1457 | __swig_destroy__ = _pySmartIdEngine.delete_OcrCharVariantVector 1458 | __del__ = lambda self: None 1459 | OcrCharVariantVector_swigregister = _pySmartIdEngine.OcrCharVariantVector_swigregister 1460 | OcrCharVariantVector_swigregister(OcrCharVariantVector) 1461 | 1462 | class OcrCharVector(_object): 1463 | __swig_setmethods__ = {} 1464 | __setattr__ = lambda self, name, value: _swig_setattr(self, OcrCharVector, name, value) 1465 | __swig_getmethods__ = {} 1466 | __getattr__ = lambda self, name: _swig_getattr(self, OcrCharVector, name) 1467 | __repr__ = _swig_repr 1468 | 1469 | def iterator(self): 1470 | return _pySmartIdEngine.OcrCharVector_iterator(self) 1471 | def __iter__(self): 1472 | return self.iterator() 1473 | 1474 | def __nonzero__(self): 1475 | return _pySmartIdEngine.OcrCharVector___nonzero__(self) 1476 | 1477 | def __bool__(self): 1478 | return _pySmartIdEngine.OcrCharVector___bool__(self) 1479 | 1480 | def __len__(self): 1481 | return _pySmartIdEngine.OcrCharVector___len__(self) 1482 | 1483 | def __getslice__(self, i, j): 1484 | return _pySmartIdEngine.OcrCharVector___getslice__(self, i, j) 1485 | 1486 | def __setslice__(self, *args): 1487 | return _pySmartIdEngine.OcrCharVector___setslice__(self, *args) 1488 | 1489 | def __delslice__(self, i, j): 1490 | return _pySmartIdEngine.OcrCharVector___delslice__(self, i, j) 1491 | 1492 | def __delitem__(self, *args): 1493 | return _pySmartIdEngine.OcrCharVector___delitem__(self, *args) 1494 | 1495 | def __getitem__(self, *args): 1496 | return _pySmartIdEngine.OcrCharVector___getitem__(self, *args) 1497 | 1498 | def __setitem__(self, *args): 1499 | return _pySmartIdEngine.OcrCharVector___setitem__(self, *args) 1500 | 1501 | def pop(self): 1502 | return _pySmartIdEngine.OcrCharVector_pop(self) 1503 | 1504 | def append(self, x): 1505 | return _pySmartIdEngine.OcrCharVector_append(self, x) 1506 | 1507 | def empty(self): 1508 | return _pySmartIdEngine.OcrCharVector_empty(self) 1509 | 1510 | def size(self): 1511 | return _pySmartIdEngine.OcrCharVector_size(self) 1512 | 1513 | def swap(self, v): 1514 | return _pySmartIdEngine.OcrCharVector_swap(self, v) 1515 | 1516 | def begin(self): 1517 | return _pySmartIdEngine.OcrCharVector_begin(self) 1518 | 1519 | def end(self): 1520 | return _pySmartIdEngine.OcrCharVector_end(self) 1521 | 1522 | def rbegin(self): 1523 | return _pySmartIdEngine.OcrCharVector_rbegin(self) 1524 | 1525 | def rend(self): 1526 | return _pySmartIdEngine.OcrCharVector_rend(self) 1527 | 1528 | def clear(self): 1529 | return _pySmartIdEngine.OcrCharVector_clear(self) 1530 | 1531 | def get_allocator(self): 1532 | return _pySmartIdEngine.OcrCharVector_get_allocator(self) 1533 | 1534 | def pop_back(self): 1535 | return _pySmartIdEngine.OcrCharVector_pop_back(self) 1536 | 1537 | def erase(self, *args): 1538 | return _pySmartIdEngine.OcrCharVector_erase(self, *args) 1539 | 1540 | def __init__(self, *args): 1541 | this = _pySmartIdEngine.new_OcrCharVector(*args) 1542 | try: 1543 | self.this.append(this) 1544 | except __builtin__.Exception: 1545 | self.this = this 1546 | 1547 | def push_back(self, x): 1548 | return _pySmartIdEngine.OcrCharVector_push_back(self, x) 1549 | 1550 | def front(self): 1551 | return _pySmartIdEngine.OcrCharVector_front(self) 1552 | 1553 | def back(self): 1554 | return _pySmartIdEngine.OcrCharVector_back(self) 1555 | 1556 | def assign(self, n, x): 1557 | return _pySmartIdEngine.OcrCharVector_assign(self, n, x) 1558 | 1559 | def resize(self, *args): 1560 | return _pySmartIdEngine.OcrCharVector_resize(self, *args) 1561 | 1562 | def insert(self, *args): 1563 | return _pySmartIdEngine.OcrCharVector_insert(self, *args) 1564 | 1565 | def reserve(self, n): 1566 | return _pySmartIdEngine.OcrCharVector_reserve(self, n) 1567 | 1568 | def capacity(self): 1569 | return _pySmartIdEngine.OcrCharVector_capacity(self) 1570 | __swig_destroy__ = _pySmartIdEngine.delete_OcrCharVector 1571 | __del__ = lambda self: None 1572 | OcrCharVector_swigregister = _pySmartIdEngine.OcrCharVector_swigregister 1573 | OcrCharVector_swigregister(OcrCharVector) 1574 | 1575 | class MatchResultVector(_object): 1576 | __swig_setmethods__ = {} 1577 | __setattr__ = lambda self, name, value: _swig_setattr(self, MatchResultVector, name, value) 1578 | __swig_getmethods__ = {} 1579 | __getattr__ = lambda self, name: _swig_getattr(self, MatchResultVector, name) 1580 | __repr__ = _swig_repr 1581 | 1582 | def iterator(self): 1583 | return _pySmartIdEngine.MatchResultVector_iterator(self) 1584 | def __iter__(self): 1585 | return self.iterator() 1586 | 1587 | def __nonzero__(self): 1588 | return _pySmartIdEngine.MatchResultVector___nonzero__(self) 1589 | 1590 | def __bool__(self): 1591 | return _pySmartIdEngine.MatchResultVector___bool__(self) 1592 | 1593 | def __len__(self): 1594 | return _pySmartIdEngine.MatchResultVector___len__(self) 1595 | 1596 | def __getslice__(self, i, j): 1597 | return _pySmartIdEngine.MatchResultVector___getslice__(self, i, j) 1598 | 1599 | def __setslice__(self, *args): 1600 | return _pySmartIdEngine.MatchResultVector___setslice__(self, *args) 1601 | 1602 | def __delslice__(self, i, j): 1603 | return _pySmartIdEngine.MatchResultVector___delslice__(self, i, j) 1604 | 1605 | def __delitem__(self, *args): 1606 | return _pySmartIdEngine.MatchResultVector___delitem__(self, *args) 1607 | 1608 | def __getitem__(self, *args): 1609 | return _pySmartIdEngine.MatchResultVector___getitem__(self, *args) 1610 | 1611 | def __setitem__(self, *args): 1612 | return _pySmartIdEngine.MatchResultVector___setitem__(self, *args) 1613 | 1614 | def pop(self): 1615 | return _pySmartIdEngine.MatchResultVector_pop(self) 1616 | 1617 | def append(self, x): 1618 | return _pySmartIdEngine.MatchResultVector_append(self, x) 1619 | 1620 | def empty(self): 1621 | return _pySmartIdEngine.MatchResultVector_empty(self) 1622 | 1623 | def size(self): 1624 | return _pySmartIdEngine.MatchResultVector_size(self) 1625 | 1626 | def swap(self, v): 1627 | return _pySmartIdEngine.MatchResultVector_swap(self, v) 1628 | 1629 | def begin(self): 1630 | return _pySmartIdEngine.MatchResultVector_begin(self) 1631 | 1632 | def end(self): 1633 | return _pySmartIdEngine.MatchResultVector_end(self) 1634 | 1635 | def rbegin(self): 1636 | return _pySmartIdEngine.MatchResultVector_rbegin(self) 1637 | 1638 | def rend(self): 1639 | return _pySmartIdEngine.MatchResultVector_rend(self) 1640 | 1641 | def clear(self): 1642 | return _pySmartIdEngine.MatchResultVector_clear(self) 1643 | 1644 | def get_allocator(self): 1645 | return _pySmartIdEngine.MatchResultVector_get_allocator(self) 1646 | 1647 | def pop_back(self): 1648 | return _pySmartIdEngine.MatchResultVector_pop_back(self) 1649 | 1650 | def erase(self, *args): 1651 | return _pySmartIdEngine.MatchResultVector_erase(self, *args) 1652 | 1653 | def __init__(self, *args): 1654 | this = _pySmartIdEngine.new_MatchResultVector(*args) 1655 | try: 1656 | self.this.append(this) 1657 | except __builtin__.Exception: 1658 | self.this = this 1659 | 1660 | def push_back(self, x): 1661 | return _pySmartIdEngine.MatchResultVector_push_back(self, x) 1662 | 1663 | def front(self): 1664 | return _pySmartIdEngine.MatchResultVector_front(self) 1665 | 1666 | def back(self): 1667 | return _pySmartIdEngine.MatchResultVector_back(self) 1668 | 1669 | def assign(self, n, x): 1670 | return _pySmartIdEngine.MatchResultVector_assign(self, n, x) 1671 | 1672 | def resize(self, *args): 1673 | return _pySmartIdEngine.MatchResultVector_resize(self, *args) 1674 | 1675 | def insert(self, *args): 1676 | return _pySmartIdEngine.MatchResultVector_insert(self, *args) 1677 | 1678 | def reserve(self, n): 1679 | return _pySmartIdEngine.MatchResultVector_reserve(self, n) 1680 | 1681 | def capacity(self): 1682 | return _pySmartIdEngine.MatchResultVector_capacity(self) 1683 | __swig_destroy__ = _pySmartIdEngine.delete_MatchResultVector 1684 | __del__ = lambda self: None 1685 | MatchResultVector_swigregister = _pySmartIdEngine.MatchResultVector_swigregister 1686 | MatchResultVector_swigregister(MatchResultVector) 1687 | 1688 | class SegmentationResultVector(_object): 1689 | __swig_setmethods__ = {} 1690 | __setattr__ = lambda self, name, value: _swig_setattr(self, SegmentationResultVector, name, value) 1691 | __swig_getmethods__ = {} 1692 | __getattr__ = lambda self, name: _swig_getattr(self, SegmentationResultVector, name) 1693 | __repr__ = _swig_repr 1694 | 1695 | def iterator(self): 1696 | return _pySmartIdEngine.SegmentationResultVector_iterator(self) 1697 | def __iter__(self): 1698 | return self.iterator() 1699 | 1700 | def __nonzero__(self): 1701 | return _pySmartIdEngine.SegmentationResultVector___nonzero__(self) 1702 | 1703 | def __bool__(self): 1704 | return _pySmartIdEngine.SegmentationResultVector___bool__(self) 1705 | 1706 | def __len__(self): 1707 | return _pySmartIdEngine.SegmentationResultVector___len__(self) 1708 | 1709 | def __getslice__(self, i, j): 1710 | return _pySmartIdEngine.SegmentationResultVector___getslice__(self, i, j) 1711 | 1712 | def __setslice__(self, *args): 1713 | return _pySmartIdEngine.SegmentationResultVector___setslice__(self, *args) 1714 | 1715 | def __delslice__(self, i, j): 1716 | return _pySmartIdEngine.SegmentationResultVector___delslice__(self, i, j) 1717 | 1718 | def __delitem__(self, *args): 1719 | return _pySmartIdEngine.SegmentationResultVector___delitem__(self, *args) 1720 | 1721 | def __getitem__(self, *args): 1722 | return _pySmartIdEngine.SegmentationResultVector___getitem__(self, *args) 1723 | 1724 | def __setitem__(self, *args): 1725 | return _pySmartIdEngine.SegmentationResultVector___setitem__(self, *args) 1726 | 1727 | def pop(self): 1728 | return _pySmartIdEngine.SegmentationResultVector_pop(self) 1729 | 1730 | def append(self, x): 1731 | return _pySmartIdEngine.SegmentationResultVector_append(self, x) 1732 | 1733 | def empty(self): 1734 | return _pySmartIdEngine.SegmentationResultVector_empty(self) 1735 | 1736 | def size(self): 1737 | return _pySmartIdEngine.SegmentationResultVector_size(self) 1738 | 1739 | def swap(self, v): 1740 | return _pySmartIdEngine.SegmentationResultVector_swap(self, v) 1741 | 1742 | def begin(self): 1743 | return _pySmartIdEngine.SegmentationResultVector_begin(self) 1744 | 1745 | def end(self): 1746 | return _pySmartIdEngine.SegmentationResultVector_end(self) 1747 | 1748 | def rbegin(self): 1749 | return _pySmartIdEngine.SegmentationResultVector_rbegin(self) 1750 | 1751 | def rend(self): 1752 | return _pySmartIdEngine.SegmentationResultVector_rend(self) 1753 | 1754 | def clear(self): 1755 | return _pySmartIdEngine.SegmentationResultVector_clear(self) 1756 | 1757 | def get_allocator(self): 1758 | return _pySmartIdEngine.SegmentationResultVector_get_allocator(self) 1759 | 1760 | def pop_back(self): 1761 | return _pySmartIdEngine.SegmentationResultVector_pop_back(self) 1762 | 1763 | def erase(self, *args): 1764 | return _pySmartIdEngine.SegmentationResultVector_erase(self, *args) 1765 | 1766 | def __init__(self, *args): 1767 | this = _pySmartIdEngine.new_SegmentationResultVector(*args) 1768 | try: 1769 | self.this.append(this) 1770 | except __builtin__.Exception: 1771 | self.this = this 1772 | 1773 | def push_back(self, x): 1774 | return _pySmartIdEngine.SegmentationResultVector_push_back(self, x) 1775 | 1776 | def front(self): 1777 | return _pySmartIdEngine.SegmentationResultVector_front(self) 1778 | 1779 | def back(self): 1780 | return _pySmartIdEngine.SegmentationResultVector_back(self) 1781 | 1782 | def assign(self, n, x): 1783 | return _pySmartIdEngine.SegmentationResultVector_assign(self, n, x) 1784 | 1785 | def resize(self, *args): 1786 | return _pySmartIdEngine.SegmentationResultVector_resize(self, *args) 1787 | 1788 | def insert(self, *args): 1789 | return _pySmartIdEngine.SegmentationResultVector_insert(self, *args) 1790 | 1791 | def reserve(self, n): 1792 | return _pySmartIdEngine.SegmentationResultVector_reserve(self, n) 1793 | 1794 | def capacity(self): 1795 | return _pySmartIdEngine.SegmentationResultVector_capacity(self) 1796 | __swig_destroy__ = _pySmartIdEngine.delete_SegmentationResultVector 1797 | __del__ = lambda self: None 1798 | SegmentationResultVector_swigregister = _pySmartIdEngine.SegmentationResultVector_swigregister 1799 | SegmentationResultVector_swigregister(SegmentationResultVector) 1800 | 1801 | class StringCollection(_object): 1802 | __swig_setmethods__ = {} 1803 | __setattr__ = lambda self, name, value: _swig_setattr(self, StringCollection, name, value) 1804 | __swig_getmethods__ = {} 1805 | __getattr__ = lambda self, name: _swig_getattr(self, StringCollection, name) 1806 | __repr__ = _swig_repr 1807 | 1808 | def iterator(self): 1809 | return _pySmartIdEngine.StringCollection_iterator(self) 1810 | def __iter__(self): 1811 | return self.iterator() 1812 | 1813 | def __nonzero__(self): 1814 | return _pySmartIdEngine.StringCollection___nonzero__(self) 1815 | 1816 | def __bool__(self): 1817 | return _pySmartIdEngine.StringCollection___bool__(self) 1818 | 1819 | def __len__(self): 1820 | return _pySmartIdEngine.StringCollection___len__(self) 1821 | def __iter__(self): 1822 | return self.key_iterator() 1823 | def iterkeys(self): 1824 | return self.key_iterator() 1825 | def itervalues(self): 1826 | return self.value_iterator() 1827 | def iteritems(self): 1828 | return self.iterator() 1829 | 1830 | def __getitem__(self, key): 1831 | return _pySmartIdEngine.StringCollection___getitem__(self, key) 1832 | 1833 | def __delitem__(self, key): 1834 | return _pySmartIdEngine.StringCollection___delitem__(self, key) 1835 | 1836 | def has_key(self, key): 1837 | return _pySmartIdEngine.StringCollection_has_key(self, key) 1838 | 1839 | def keys(self): 1840 | return _pySmartIdEngine.StringCollection_keys(self) 1841 | 1842 | def values(self): 1843 | return _pySmartIdEngine.StringCollection_values(self) 1844 | 1845 | def items(self): 1846 | return _pySmartIdEngine.StringCollection_items(self) 1847 | 1848 | def __contains__(self, key): 1849 | return _pySmartIdEngine.StringCollection___contains__(self, key) 1850 | 1851 | def key_iterator(self): 1852 | return _pySmartIdEngine.StringCollection_key_iterator(self) 1853 | 1854 | def value_iterator(self): 1855 | return _pySmartIdEngine.StringCollection_value_iterator(self) 1856 | 1857 | def __setitem__(self, *args): 1858 | return _pySmartIdEngine.StringCollection___setitem__(self, *args) 1859 | 1860 | def asdict(self): 1861 | return _pySmartIdEngine.StringCollection_asdict(self) 1862 | 1863 | def __init__(self, *args): 1864 | this = _pySmartIdEngine.new_StringCollection(*args) 1865 | try: 1866 | self.this.append(this) 1867 | except __builtin__.Exception: 1868 | self.this = this 1869 | 1870 | def empty(self): 1871 | return _pySmartIdEngine.StringCollection_empty(self) 1872 | 1873 | def size(self): 1874 | return _pySmartIdEngine.StringCollection_size(self) 1875 | 1876 | def swap(self, v): 1877 | return _pySmartIdEngine.StringCollection_swap(self, v) 1878 | 1879 | def begin(self): 1880 | return _pySmartIdEngine.StringCollection_begin(self) 1881 | 1882 | def end(self): 1883 | return _pySmartIdEngine.StringCollection_end(self) 1884 | 1885 | def rbegin(self): 1886 | return _pySmartIdEngine.StringCollection_rbegin(self) 1887 | 1888 | def rend(self): 1889 | return _pySmartIdEngine.StringCollection_rend(self) 1890 | 1891 | def clear(self): 1892 | return _pySmartIdEngine.StringCollection_clear(self) 1893 | 1894 | def get_allocator(self): 1895 | return _pySmartIdEngine.StringCollection_get_allocator(self) 1896 | 1897 | def count(self, x): 1898 | return _pySmartIdEngine.StringCollection_count(self, x) 1899 | 1900 | def erase(self, *args): 1901 | return _pySmartIdEngine.StringCollection_erase(self, *args) 1902 | 1903 | def find(self, x): 1904 | return _pySmartIdEngine.StringCollection_find(self, x) 1905 | 1906 | def lower_bound(self, x): 1907 | return _pySmartIdEngine.StringCollection_lower_bound(self, x) 1908 | 1909 | def upper_bound(self, x): 1910 | return _pySmartIdEngine.StringCollection_upper_bound(self, x) 1911 | __swig_destroy__ = _pySmartIdEngine.delete_StringCollection 1912 | __del__ = lambda self: None 1913 | StringCollection_swigregister = _pySmartIdEngine.StringCollection_swigregister 1914 | StringCollection_swigregister(StringCollection) 1915 | 1916 | class StringVectorCollection(_object): 1917 | __swig_setmethods__ = {} 1918 | __setattr__ = lambda self, name, value: _swig_setattr(self, StringVectorCollection, name, value) 1919 | __swig_getmethods__ = {} 1920 | __getattr__ = lambda self, name: _swig_getattr(self, StringVectorCollection, name) 1921 | __repr__ = _swig_repr 1922 | 1923 | def iterator(self): 1924 | return _pySmartIdEngine.StringVectorCollection_iterator(self) 1925 | def __iter__(self): 1926 | return self.iterator() 1927 | 1928 | def __nonzero__(self): 1929 | return _pySmartIdEngine.StringVectorCollection___nonzero__(self) 1930 | 1931 | def __bool__(self): 1932 | return _pySmartIdEngine.StringVectorCollection___bool__(self) 1933 | 1934 | def __len__(self): 1935 | return _pySmartIdEngine.StringVectorCollection___len__(self) 1936 | def __iter__(self): 1937 | return self.key_iterator() 1938 | def iterkeys(self): 1939 | return self.key_iterator() 1940 | def itervalues(self): 1941 | return self.value_iterator() 1942 | def iteritems(self): 1943 | return self.iterator() 1944 | 1945 | def __getitem__(self, key): 1946 | return _pySmartIdEngine.StringVectorCollection___getitem__(self, key) 1947 | 1948 | def __delitem__(self, key): 1949 | return _pySmartIdEngine.StringVectorCollection___delitem__(self, key) 1950 | 1951 | def has_key(self, key): 1952 | return _pySmartIdEngine.StringVectorCollection_has_key(self, key) 1953 | 1954 | def keys(self): 1955 | return _pySmartIdEngine.StringVectorCollection_keys(self) 1956 | 1957 | def values(self): 1958 | return _pySmartIdEngine.StringVectorCollection_values(self) 1959 | 1960 | def items(self): 1961 | return _pySmartIdEngine.StringVectorCollection_items(self) 1962 | 1963 | def __contains__(self, key): 1964 | return _pySmartIdEngine.StringVectorCollection___contains__(self, key) 1965 | 1966 | def key_iterator(self): 1967 | return _pySmartIdEngine.StringVectorCollection_key_iterator(self) 1968 | 1969 | def value_iterator(self): 1970 | return _pySmartIdEngine.StringVectorCollection_value_iterator(self) 1971 | 1972 | def __setitem__(self, *args): 1973 | return _pySmartIdEngine.StringVectorCollection___setitem__(self, *args) 1974 | 1975 | def asdict(self): 1976 | return _pySmartIdEngine.StringVectorCollection_asdict(self) 1977 | 1978 | def __init__(self, *args): 1979 | this = _pySmartIdEngine.new_StringVectorCollection(*args) 1980 | try: 1981 | self.this.append(this) 1982 | except __builtin__.Exception: 1983 | self.this = this 1984 | 1985 | def empty(self): 1986 | return _pySmartIdEngine.StringVectorCollection_empty(self) 1987 | 1988 | def size(self): 1989 | return _pySmartIdEngine.StringVectorCollection_size(self) 1990 | 1991 | def swap(self, v): 1992 | return _pySmartIdEngine.StringVectorCollection_swap(self, v) 1993 | 1994 | def begin(self): 1995 | return _pySmartIdEngine.StringVectorCollection_begin(self) 1996 | 1997 | def end(self): 1998 | return _pySmartIdEngine.StringVectorCollection_end(self) 1999 | 2000 | def rbegin(self): 2001 | return _pySmartIdEngine.StringVectorCollection_rbegin(self) 2002 | 2003 | def rend(self): 2004 | return _pySmartIdEngine.StringVectorCollection_rend(self) 2005 | 2006 | def clear(self): 2007 | return _pySmartIdEngine.StringVectorCollection_clear(self) 2008 | 2009 | def get_allocator(self): 2010 | return _pySmartIdEngine.StringVectorCollection_get_allocator(self) 2011 | 2012 | def count(self, x): 2013 | return _pySmartIdEngine.StringVectorCollection_count(self, x) 2014 | 2015 | def erase(self, *args): 2016 | return _pySmartIdEngine.StringVectorCollection_erase(self, *args) 2017 | 2018 | def find(self, x): 2019 | return _pySmartIdEngine.StringVectorCollection_find(self, x) 2020 | 2021 | def lower_bound(self, x): 2022 | return _pySmartIdEngine.StringVectorCollection_lower_bound(self, x) 2023 | 2024 | def upper_bound(self, x): 2025 | return _pySmartIdEngine.StringVectorCollection_upper_bound(self, x) 2026 | __swig_destroy__ = _pySmartIdEngine.delete_StringVectorCollection 2027 | __del__ = lambda self: None 2028 | StringVectorCollection_swigregister = _pySmartIdEngine.StringVectorCollection_swigregister 2029 | StringVectorCollection_swigregister(StringVectorCollection) 2030 | 2031 | class ImageFieldCollection(_object): 2032 | __swig_setmethods__ = {} 2033 | __setattr__ = lambda self, name, value: _swig_setattr(self, ImageFieldCollection, name, value) 2034 | __swig_getmethods__ = {} 2035 | __getattr__ = lambda self, name: _swig_getattr(self, ImageFieldCollection, name) 2036 | __repr__ = _swig_repr 2037 | 2038 | def iterator(self): 2039 | return _pySmartIdEngine.ImageFieldCollection_iterator(self) 2040 | def __iter__(self): 2041 | return self.iterator() 2042 | 2043 | def __nonzero__(self): 2044 | return _pySmartIdEngine.ImageFieldCollection___nonzero__(self) 2045 | 2046 | def __bool__(self): 2047 | return _pySmartIdEngine.ImageFieldCollection___bool__(self) 2048 | 2049 | def __len__(self): 2050 | return _pySmartIdEngine.ImageFieldCollection___len__(self) 2051 | def __iter__(self): 2052 | return self.key_iterator() 2053 | def iterkeys(self): 2054 | return self.key_iterator() 2055 | def itervalues(self): 2056 | return self.value_iterator() 2057 | def iteritems(self): 2058 | return self.iterator() 2059 | 2060 | def __getitem__(self, key): 2061 | return _pySmartIdEngine.ImageFieldCollection___getitem__(self, key) 2062 | 2063 | def __delitem__(self, key): 2064 | return _pySmartIdEngine.ImageFieldCollection___delitem__(self, key) 2065 | 2066 | def has_key(self, key): 2067 | return _pySmartIdEngine.ImageFieldCollection_has_key(self, key) 2068 | 2069 | def keys(self): 2070 | return _pySmartIdEngine.ImageFieldCollection_keys(self) 2071 | 2072 | def values(self): 2073 | return _pySmartIdEngine.ImageFieldCollection_values(self) 2074 | 2075 | def items(self): 2076 | return _pySmartIdEngine.ImageFieldCollection_items(self) 2077 | 2078 | def __contains__(self, key): 2079 | return _pySmartIdEngine.ImageFieldCollection___contains__(self, key) 2080 | 2081 | def key_iterator(self): 2082 | return _pySmartIdEngine.ImageFieldCollection_key_iterator(self) 2083 | 2084 | def value_iterator(self): 2085 | return _pySmartIdEngine.ImageFieldCollection_value_iterator(self) 2086 | 2087 | def __setitem__(self, *args): 2088 | return _pySmartIdEngine.ImageFieldCollection___setitem__(self, *args) 2089 | 2090 | def asdict(self): 2091 | return _pySmartIdEngine.ImageFieldCollection_asdict(self) 2092 | 2093 | def __init__(self, *args): 2094 | this = _pySmartIdEngine.new_ImageFieldCollection(*args) 2095 | try: 2096 | self.this.append(this) 2097 | except __builtin__.Exception: 2098 | self.this = this 2099 | 2100 | def empty(self): 2101 | return _pySmartIdEngine.ImageFieldCollection_empty(self) 2102 | 2103 | def size(self): 2104 | return _pySmartIdEngine.ImageFieldCollection_size(self) 2105 | 2106 | def swap(self, v): 2107 | return _pySmartIdEngine.ImageFieldCollection_swap(self, v) 2108 | 2109 | def begin(self): 2110 | return _pySmartIdEngine.ImageFieldCollection_begin(self) 2111 | 2112 | def end(self): 2113 | return _pySmartIdEngine.ImageFieldCollection_end(self) 2114 | 2115 | def rbegin(self): 2116 | return _pySmartIdEngine.ImageFieldCollection_rbegin(self) 2117 | 2118 | def rend(self): 2119 | return _pySmartIdEngine.ImageFieldCollection_rend(self) 2120 | 2121 | def clear(self): 2122 | return _pySmartIdEngine.ImageFieldCollection_clear(self) 2123 | 2124 | def get_allocator(self): 2125 | return _pySmartIdEngine.ImageFieldCollection_get_allocator(self) 2126 | 2127 | def count(self, x): 2128 | return _pySmartIdEngine.ImageFieldCollection_count(self, x) 2129 | 2130 | def erase(self, *args): 2131 | return _pySmartIdEngine.ImageFieldCollection_erase(self, *args) 2132 | 2133 | def find(self, x): 2134 | return _pySmartIdEngine.ImageFieldCollection_find(self, x) 2135 | 2136 | def lower_bound(self, x): 2137 | return _pySmartIdEngine.ImageFieldCollection_lower_bound(self, x) 2138 | 2139 | def upper_bound(self, x): 2140 | return _pySmartIdEngine.ImageFieldCollection_upper_bound(self, x) 2141 | __swig_destroy__ = _pySmartIdEngine.delete_ImageFieldCollection 2142 | __del__ = lambda self: None 2143 | ImageFieldCollection_swigregister = _pySmartIdEngine.ImageFieldCollection_swigregister 2144 | ImageFieldCollection_swigregister(ImageFieldCollection) 2145 | 2146 | class StringFieldCollection(_object): 2147 | __swig_setmethods__ = {} 2148 | __setattr__ = lambda self, name, value: _swig_setattr(self, StringFieldCollection, name, value) 2149 | __swig_getmethods__ = {} 2150 | __getattr__ = lambda self, name: _swig_getattr(self, StringFieldCollection, name) 2151 | __repr__ = _swig_repr 2152 | 2153 | def iterator(self): 2154 | return _pySmartIdEngine.StringFieldCollection_iterator(self) 2155 | def __iter__(self): 2156 | return self.iterator() 2157 | 2158 | def __nonzero__(self): 2159 | return _pySmartIdEngine.StringFieldCollection___nonzero__(self) 2160 | 2161 | def __bool__(self): 2162 | return _pySmartIdEngine.StringFieldCollection___bool__(self) 2163 | 2164 | def __len__(self): 2165 | return _pySmartIdEngine.StringFieldCollection___len__(self) 2166 | def __iter__(self): 2167 | return self.key_iterator() 2168 | def iterkeys(self): 2169 | return self.key_iterator() 2170 | def itervalues(self): 2171 | return self.value_iterator() 2172 | def iteritems(self): 2173 | return self.iterator() 2174 | 2175 | def __getitem__(self, key): 2176 | return _pySmartIdEngine.StringFieldCollection___getitem__(self, key) 2177 | 2178 | def __delitem__(self, key): 2179 | return _pySmartIdEngine.StringFieldCollection___delitem__(self, key) 2180 | 2181 | def has_key(self, key): 2182 | return _pySmartIdEngine.StringFieldCollection_has_key(self, key) 2183 | 2184 | def keys(self): 2185 | return _pySmartIdEngine.StringFieldCollection_keys(self) 2186 | 2187 | def values(self): 2188 | return _pySmartIdEngine.StringFieldCollection_values(self) 2189 | 2190 | def items(self): 2191 | return _pySmartIdEngine.StringFieldCollection_items(self) 2192 | 2193 | def __contains__(self, key): 2194 | return _pySmartIdEngine.StringFieldCollection___contains__(self, key) 2195 | 2196 | def key_iterator(self): 2197 | return _pySmartIdEngine.StringFieldCollection_key_iterator(self) 2198 | 2199 | def value_iterator(self): 2200 | return _pySmartIdEngine.StringFieldCollection_value_iterator(self) 2201 | 2202 | def __setitem__(self, *args): 2203 | return _pySmartIdEngine.StringFieldCollection___setitem__(self, *args) 2204 | 2205 | def asdict(self): 2206 | return _pySmartIdEngine.StringFieldCollection_asdict(self) 2207 | 2208 | def __init__(self, *args): 2209 | this = _pySmartIdEngine.new_StringFieldCollection(*args) 2210 | try: 2211 | self.this.append(this) 2212 | except __builtin__.Exception: 2213 | self.this = this 2214 | 2215 | def empty(self): 2216 | return _pySmartIdEngine.StringFieldCollection_empty(self) 2217 | 2218 | def size(self): 2219 | return _pySmartIdEngine.StringFieldCollection_size(self) 2220 | 2221 | def swap(self, v): 2222 | return _pySmartIdEngine.StringFieldCollection_swap(self, v) 2223 | 2224 | def begin(self): 2225 | return _pySmartIdEngine.StringFieldCollection_begin(self) 2226 | 2227 | def end(self): 2228 | return _pySmartIdEngine.StringFieldCollection_end(self) 2229 | 2230 | def rbegin(self): 2231 | return _pySmartIdEngine.StringFieldCollection_rbegin(self) 2232 | 2233 | def rend(self): 2234 | return _pySmartIdEngine.StringFieldCollection_rend(self) 2235 | 2236 | def clear(self): 2237 | return _pySmartIdEngine.StringFieldCollection_clear(self) 2238 | 2239 | def get_allocator(self): 2240 | return _pySmartIdEngine.StringFieldCollection_get_allocator(self) 2241 | 2242 | def count(self, x): 2243 | return _pySmartIdEngine.StringFieldCollection_count(self, x) 2244 | 2245 | def erase(self, *args): 2246 | return _pySmartIdEngine.StringFieldCollection_erase(self, *args) 2247 | 2248 | def find(self, x): 2249 | return _pySmartIdEngine.StringFieldCollection_find(self, x) 2250 | 2251 | def lower_bound(self, x): 2252 | return _pySmartIdEngine.StringFieldCollection_lower_bound(self, x) 2253 | 2254 | def upper_bound(self, x): 2255 | return _pySmartIdEngine.StringFieldCollection_upper_bound(self, x) 2256 | __swig_destroy__ = _pySmartIdEngine.delete_StringFieldCollection 2257 | __del__ = lambda self: None 2258 | StringFieldCollection_swigregister = _pySmartIdEngine.StringFieldCollection_swigregister 2259 | StringFieldCollection_swigregister(StringFieldCollection) 2260 | 2261 | class ForensicFieldCollection(_object): 2262 | __swig_setmethods__ = {} 2263 | __setattr__ = lambda self, name, value: _swig_setattr(self, ForensicFieldCollection, name, value) 2264 | __swig_getmethods__ = {} 2265 | __getattr__ = lambda self, name: _swig_getattr(self, ForensicFieldCollection, name) 2266 | __repr__ = _swig_repr 2267 | 2268 | def iterator(self): 2269 | return _pySmartIdEngine.ForensicFieldCollection_iterator(self) 2270 | def __iter__(self): 2271 | return self.iterator() 2272 | 2273 | def __nonzero__(self): 2274 | return _pySmartIdEngine.ForensicFieldCollection___nonzero__(self) 2275 | 2276 | def __bool__(self): 2277 | return _pySmartIdEngine.ForensicFieldCollection___bool__(self) 2278 | 2279 | def __len__(self): 2280 | return _pySmartIdEngine.ForensicFieldCollection___len__(self) 2281 | def __iter__(self): 2282 | return self.key_iterator() 2283 | def iterkeys(self): 2284 | return self.key_iterator() 2285 | def itervalues(self): 2286 | return self.value_iterator() 2287 | def iteritems(self): 2288 | return self.iterator() 2289 | 2290 | def __getitem__(self, key): 2291 | return _pySmartIdEngine.ForensicFieldCollection___getitem__(self, key) 2292 | 2293 | def __delitem__(self, key): 2294 | return _pySmartIdEngine.ForensicFieldCollection___delitem__(self, key) 2295 | 2296 | def has_key(self, key): 2297 | return _pySmartIdEngine.ForensicFieldCollection_has_key(self, key) 2298 | 2299 | def keys(self): 2300 | return _pySmartIdEngine.ForensicFieldCollection_keys(self) 2301 | 2302 | def values(self): 2303 | return _pySmartIdEngine.ForensicFieldCollection_values(self) 2304 | 2305 | def items(self): 2306 | return _pySmartIdEngine.ForensicFieldCollection_items(self) 2307 | 2308 | def __contains__(self, key): 2309 | return _pySmartIdEngine.ForensicFieldCollection___contains__(self, key) 2310 | 2311 | def key_iterator(self): 2312 | return _pySmartIdEngine.ForensicFieldCollection_key_iterator(self) 2313 | 2314 | def value_iterator(self): 2315 | return _pySmartIdEngine.ForensicFieldCollection_value_iterator(self) 2316 | 2317 | def __setitem__(self, *args): 2318 | return _pySmartIdEngine.ForensicFieldCollection___setitem__(self, *args) 2319 | 2320 | def asdict(self): 2321 | return _pySmartIdEngine.ForensicFieldCollection_asdict(self) 2322 | 2323 | def __init__(self, *args): 2324 | this = _pySmartIdEngine.new_ForensicFieldCollection(*args) 2325 | try: 2326 | self.this.append(this) 2327 | except __builtin__.Exception: 2328 | self.this = this 2329 | 2330 | def empty(self): 2331 | return _pySmartIdEngine.ForensicFieldCollection_empty(self) 2332 | 2333 | def size(self): 2334 | return _pySmartIdEngine.ForensicFieldCollection_size(self) 2335 | 2336 | def swap(self, v): 2337 | return _pySmartIdEngine.ForensicFieldCollection_swap(self, v) 2338 | 2339 | def begin(self): 2340 | return _pySmartIdEngine.ForensicFieldCollection_begin(self) 2341 | 2342 | def end(self): 2343 | return _pySmartIdEngine.ForensicFieldCollection_end(self) 2344 | 2345 | def rbegin(self): 2346 | return _pySmartIdEngine.ForensicFieldCollection_rbegin(self) 2347 | 2348 | def rend(self): 2349 | return _pySmartIdEngine.ForensicFieldCollection_rend(self) 2350 | 2351 | def clear(self): 2352 | return _pySmartIdEngine.ForensicFieldCollection_clear(self) 2353 | 2354 | def get_allocator(self): 2355 | return _pySmartIdEngine.ForensicFieldCollection_get_allocator(self) 2356 | 2357 | def count(self, x): 2358 | return _pySmartIdEngine.ForensicFieldCollection_count(self, x) 2359 | 2360 | def erase(self, *args): 2361 | return _pySmartIdEngine.ForensicFieldCollection_erase(self, *args) 2362 | 2363 | def find(self, x): 2364 | return _pySmartIdEngine.ForensicFieldCollection_find(self, x) 2365 | 2366 | def lower_bound(self, x): 2367 | return _pySmartIdEngine.ForensicFieldCollection_lower_bound(self, x) 2368 | 2369 | def upper_bound(self, x): 2370 | return _pySmartIdEngine.ForensicFieldCollection_upper_bound(self, x) 2371 | __swig_destroy__ = _pySmartIdEngine.delete_ForensicFieldCollection 2372 | __del__ = lambda self: None 2373 | ForensicFieldCollection_swigregister = _pySmartIdEngine.ForensicFieldCollection_swigregister 2374 | ForensicFieldCollection_swigregister(ForensicFieldCollection) 2375 | 2376 | class QuadrangleCollection(_object): 2377 | __swig_setmethods__ = {} 2378 | __setattr__ = lambda self, name, value: _swig_setattr(self, QuadrangleCollection, name, value) 2379 | __swig_getmethods__ = {} 2380 | __getattr__ = lambda self, name: _swig_getattr(self, QuadrangleCollection, name) 2381 | __repr__ = _swig_repr 2382 | 2383 | def iterator(self): 2384 | return _pySmartIdEngine.QuadrangleCollection_iterator(self) 2385 | def __iter__(self): 2386 | return self.iterator() 2387 | 2388 | def __nonzero__(self): 2389 | return _pySmartIdEngine.QuadrangleCollection___nonzero__(self) 2390 | 2391 | def __bool__(self): 2392 | return _pySmartIdEngine.QuadrangleCollection___bool__(self) 2393 | 2394 | def __len__(self): 2395 | return _pySmartIdEngine.QuadrangleCollection___len__(self) 2396 | def __iter__(self): 2397 | return self.key_iterator() 2398 | def iterkeys(self): 2399 | return self.key_iterator() 2400 | def itervalues(self): 2401 | return self.value_iterator() 2402 | def iteritems(self): 2403 | return self.iterator() 2404 | 2405 | def __getitem__(self, key): 2406 | return _pySmartIdEngine.QuadrangleCollection___getitem__(self, key) 2407 | 2408 | def __delitem__(self, key): 2409 | return _pySmartIdEngine.QuadrangleCollection___delitem__(self, key) 2410 | 2411 | def has_key(self, key): 2412 | return _pySmartIdEngine.QuadrangleCollection_has_key(self, key) 2413 | 2414 | def keys(self): 2415 | return _pySmartIdEngine.QuadrangleCollection_keys(self) 2416 | 2417 | def values(self): 2418 | return _pySmartIdEngine.QuadrangleCollection_values(self) 2419 | 2420 | def items(self): 2421 | return _pySmartIdEngine.QuadrangleCollection_items(self) 2422 | 2423 | def __contains__(self, key): 2424 | return _pySmartIdEngine.QuadrangleCollection___contains__(self, key) 2425 | 2426 | def key_iterator(self): 2427 | return _pySmartIdEngine.QuadrangleCollection_key_iterator(self) 2428 | 2429 | def value_iterator(self): 2430 | return _pySmartIdEngine.QuadrangleCollection_value_iterator(self) 2431 | 2432 | def __setitem__(self, *args): 2433 | return _pySmartIdEngine.QuadrangleCollection___setitem__(self, *args) 2434 | 2435 | def asdict(self): 2436 | return _pySmartIdEngine.QuadrangleCollection_asdict(self) 2437 | 2438 | def __init__(self, *args): 2439 | this = _pySmartIdEngine.new_QuadrangleCollection(*args) 2440 | try: 2441 | self.this.append(this) 2442 | except __builtin__.Exception: 2443 | self.this = this 2444 | 2445 | def empty(self): 2446 | return _pySmartIdEngine.QuadrangleCollection_empty(self) 2447 | 2448 | def size(self): 2449 | return _pySmartIdEngine.QuadrangleCollection_size(self) 2450 | 2451 | def swap(self, v): 2452 | return _pySmartIdEngine.QuadrangleCollection_swap(self, v) 2453 | 2454 | def begin(self): 2455 | return _pySmartIdEngine.QuadrangleCollection_begin(self) 2456 | 2457 | def end(self): 2458 | return _pySmartIdEngine.QuadrangleCollection_end(self) 2459 | 2460 | def rbegin(self): 2461 | return _pySmartIdEngine.QuadrangleCollection_rbegin(self) 2462 | 2463 | def rend(self): 2464 | return _pySmartIdEngine.QuadrangleCollection_rend(self) 2465 | 2466 | def clear(self): 2467 | return _pySmartIdEngine.QuadrangleCollection_clear(self) 2468 | 2469 | def get_allocator(self): 2470 | return _pySmartIdEngine.QuadrangleCollection_get_allocator(self) 2471 | 2472 | def count(self, x): 2473 | return _pySmartIdEngine.QuadrangleCollection_count(self, x) 2474 | 2475 | def erase(self, *args): 2476 | return _pySmartIdEngine.QuadrangleCollection_erase(self, *args) 2477 | 2478 | def find(self, x): 2479 | return _pySmartIdEngine.QuadrangleCollection_find(self, x) 2480 | 2481 | def lower_bound(self, x): 2482 | return _pySmartIdEngine.QuadrangleCollection_lower_bound(self, x) 2483 | 2484 | def upper_bound(self, x): 2485 | return _pySmartIdEngine.QuadrangleCollection_upper_bound(self, x) 2486 | __swig_destroy__ = _pySmartIdEngine.delete_QuadrangleCollection 2487 | __del__ = lambda self: None 2488 | QuadrangleCollection_swigregister = _pySmartIdEngine.QuadrangleCollection_swigregister 2489 | QuadrangleCollection_swigregister(QuadrangleCollection) 2490 | 2491 | class IntegratedFieldStateCollection(_object): 2492 | __swig_setmethods__ = {} 2493 | __setattr__ = lambda self, name, value: _swig_setattr(self, IntegratedFieldStateCollection, name, value) 2494 | __swig_getmethods__ = {} 2495 | __getattr__ = lambda self, name: _swig_getattr(self, IntegratedFieldStateCollection, name) 2496 | __repr__ = _swig_repr 2497 | 2498 | def iterator(self): 2499 | return _pySmartIdEngine.IntegratedFieldStateCollection_iterator(self) 2500 | def __iter__(self): 2501 | return self.iterator() 2502 | 2503 | def __nonzero__(self): 2504 | return _pySmartIdEngine.IntegratedFieldStateCollection___nonzero__(self) 2505 | 2506 | def __bool__(self): 2507 | return _pySmartIdEngine.IntegratedFieldStateCollection___bool__(self) 2508 | 2509 | def __len__(self): 2510 | return _pySmartIdEngine.IntegratedFieldStateCollection___len__(self) 2511 | def __iter__(self): 2512 | return self.key_iterator() 2513 | def iterkeys(self): 2514 | return self.key_iterator() 2515 | def itervalues(self): 2516 | return self.value_iterator() 2517 | def iteritems(self): 2518 | return self.iterator() 2519 | 2520 | def __getitem__(self, key): 2521 | return _pySmartIdEngine.IntegratedFieldStateCollection___getitem__(self, key) 2522 | 2523 | def __delitem__(self, key): 2524 | return _pySmartIdEngine.IntegratedFieldStateCollection___delitem__(self, key) 2525 | 2526 | def has_key(self, key): 2527 | return _pySmartIdEngine.IntegratedFieldStateCollection_has_key(self, key) 2528 | 2529 | def keys(self): 2530 | return _pySmartIdEngine.IntegratedFieldStateCollection_keys(self) 2531 | 2532 | def values(self): 2533 | return _pySmartIdEngine.IntegratedFieldStateCollection_values(self) 2534 | 2535 | def items(self): 2536 | return _pySmartIdEngine.IntegratedFieldStateCollection_items(self) 2537 | 2538 | def __contains__(self, key): 2539 | return _pySmartIdEngine.IntegratedFieldStateCollection___contains__(self, key) 2540 | 2541 | def key_iterator(self): 2542 | return _pySmartIdEngine.IntegratedFieldStateCollection_key_iterator(self) 2543 | 2544 | def value_iterator(self): 2545 | return _pySmartIdEngine.IntegratedFieldStateCollection_value_iterator(self) 2546 | 2547 | def __setitem__(self, *args): 2548 | return _pySmartIdEngine.IntegratedFieldStateCollection___setitem__(self, *args) 2549 | 2550 | def asdict(self): 2551 | return _pySmartIdEngine.IntegratedFieldStateCollection_asdict(self) 2552 | 2553 | def __init__(self, *args): 2554 | this = _pySmartIdEngine.new_IntegratedFieldStateCollection(*args) 2555 | try: 2556 | self.this.append(this) 2557 | except __builtin__.Exception: 2558 | self.this = this 2559 | 2560 | def empty(self): 2561 | return _pySmartIdEngine.IntegratedFieldStateCollection_empty(self) 2562 | 2563 | def size(self): 2564 | return _pySmartIdEngine.IntegratedFieldStateCollection_size(self) 2565 | 2566 | def swap(self, v): 2567 | return _pySmartIdEngine.IntegratedFieldStateCollection_swap(self, v) 2568 | 2569 | def begin(self): 2570 | return _pySmartIdEngine.IntegratedFieldStateCollection_begin(self) 2571 | 2572 | def end(self): 2573 | return _pySmartIdEngine.IntegratedFieldStateCollection_end(self) 2574 | 2575 | def rbegin(self): 2576 | return _pySmartIdEngine.IntegratedFieldStateCollection_rbegin(self) 2577 | 2578 | def rend(self): 2579 | return _pySmartIdEngine.IntegratedFieldStateCollection_rend(self) 2580 | 2581 | def clear(self): 2582 | return _pySmartIdEngine.IntegratedFieldStateCollection_clear(self) 2583 | 2584 | def get_allocator(self): 2585 | return _pySmartIdEngine.IntegratedFieldStateCollection_get_allocator(self) 2586 | 2587 | def count(self, x): 2588 | return _pySmartIdEngine.IntegratedFieldStateCollection_count(self, x) 2589 | 2590 | def erase(self, *args): 2591 | return _pySmartIdEngine.IntegratedFieldStateCollection_erase(self, *args) 2592 | 2593 | def find(self, x): 2594 | return _pySmartIdEngine.IntegratedFieldStateCollection_find(self, x) 2595 | 2596 | def lower_bound(self, x): 2597 | return _pySmartIdEngine.IntegratedFieldStateCollection_lower_bound(self, x) 2598 | 2599 | def upper_bound(self, x): 2600 | return _pySmartIdEngine.IntegratedFieldStateCollection_upper_bound(self, x) 2601 | __swig_destroy__ = _pySmartIdEngine.delete_IntegratedFieldStateCollection 2602 | __del__ = lambda self: None 2603 | IntegratedFieldStateCollection_swigregister = _pySmartIdEngine.IntegratedFieldStateCollection_swigregister 2604 | IntegratedFieldStateCollection_swigregister(IntegratedFieldStateCollection) 2605 | 2606 | # This file is compatible with both classic and new-style classes. 2607 | 2608 | 2609 | -------------------------------------------------------------------------------- /smart_idreader_telegram_bot.py: -------------------------------------------------------------------------------- 1 | # Copyright (c) 2012-2020, Smart Engines Ltd 2 | # All rights reserved. 3 | 4 | # Redistribution and use in source and binary forms, with or without modification, 5 | # are permitted provided that the following conditions are met: 6 | 7 | # * Redistributions of source code must retain the above copyright notice, 8 | # this list of conditions and the following disclaimer. 9 | # * Redistributions in binary form must reproduce the above copyright notice, 10 | # this list of conditions and the following disclaimer in the documentation 11 | # and/or other materials provided with the distribution. 12 | # * Neither the name of the Smart Engines Ltd nor the names of its 13 | # contributors may be used to endorse or promote products derived from this 14 | # software without specific prior written permission. 15 | 16 | # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND 17 | # ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 18 | # WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 19 | # DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE 20 | # FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 21 | # DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR 22 | # SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER 23 | # CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, 24 | # OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 25 | # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 26 | 27 | from telegram.ext import Updater, CommandHandler, MessageHandler, Filters 28 | import json 29 | import time 30 | import os 31 | import sys 32 | from argparse import ArgumentParser 33 | 34 | import pySmartIdEngine as se # Smart IDReader by Smart Engines 35 | 36 | class SmartIDReaderEngine(): 37 | def __init__(self, config_path): 38 | self.smartid_engine = se.RecognitionEngine(config_path) 39 | 40 | def recognize_image_file(self, image_file_path): 41 | # Create session settings and enable document types 42 | session_settings = self.smartid_engine.CreateSessionSettings() 43 | session_settings.AddEnabledDocumentTypes('rus.passport.national') 44 | 45 | # Create recognition session 46 | session = self.smartid_engine.SpawnSession(session_settings) 47 | 48 | # Recognize image file 49 | result = session.ProcessImageFile(image_file_path) 50 | 51 | # Convert string fields from recognition results to dictionary 52 | recognized_fields = {} 53 | for field_name in result.GetStringFieldNames(): 54 | field = result.GetStringField(field_name) 55 | recognized_fields[field_name] = field.GetValue().GetUtf8String() 56 | 57 | # Return JSON dictionary as string 58 | return json.dumps(recognized_fields, ensure_ascii=False, indent=2) 59 | 60 | def on_chat_photo(self, update, context): 61 | # Creating downloads directory and downloading photo 62 | temp_path = get_photo(update) 63 | 64 | # Recognizing it and sending message with result 65 | recognition_result_str = self.recognize_image_file(temp_path) 66 | update.message.reply_text(recognition_result_str) 67 | print(recognition_result_str) 68 | os.remove(temp_path) 69 | 70 | def on_chat_image(self, update, context): 71 | # Creating downloads directory and downloading image file 72 | temp_path = get_image(update) 73 | 74 | # Recognizing it and sending message with result 75 | recognition_result_str = self.recognize_image_file(temp_path) 76 | update.message.reply_text(recognition_result_str) 77 | print(recognition_result_str) 78 | os.remove(temp_path) 79 | 80 | def get_photo(update): 81 | # Creating downloads directory and downloading image file 82 | downloads_dir = 'downloaded_images' 83 | os.makedirs(downloads_dir, exist_ok=True) 84 | temp_path = os.path.join(downloads_dir, 85 | 'file_%s_id_%d_temp.png' % (update.message.photo[-1].file_id, update.message.message_id)) 86 | update.message.photo[-1].get_file().download(temp_path) 87 | return temp_path 88 | 89 | def get_image(update): 90 | # Creating downloads directory and downloading image file 91 | downloads_dir = 'downloaded_images' 92 | os.makedirs(downloads_dir, exist_ok=True) 93 | temp_path = os.path.join(downloads_dir, update.message.document.file_name) 94 | update.message.document.get_file().download(custom_path = temp_path) 95 | return temp_path 96 | 97 | def echo(update, context): 98 | """Echo the user message.""" 99 | update.message.reply_text("Please send me a photo and I'll recognize it!") 100 | 101 | def error(update, context): 102 | """Log Errors caused by Updates.""" 103 | logger.warning('Update "%s" caused error "%s"', update, context.error) 104 | 105 | 106 | def main(): 107 | parser = ArgumentParser() 108 | parser.add_argument('--token', type=str, ) 109 | parser.add_argument('--smartid-config', type=str, default='bundle_mock_smart_idreader.zip') 110 | args = parser.parse_args() 111 | 112 | """Start the bot.""" 113 | # Create the Updater and pass it your bot's token. 114 | # Make sure to set use_context=True to use the new context based callbacks 115 | # Post version 12 this will no longer be necessary 116 | 117 | 118 | updater = Updater(args.token, use_context=True) 119 | 120 | # create an instance of SmartIdReader engine 121 | smartid_engine = SmartIDReaderEngine(args.smartid_config) 122 | 123 | # Get the dispatcher to register handlers 124 | dp = updater.dispatcher 125 | 126 | # on noncommand i.e message - echo the message on Telegram 127 | dp.add_handler(MessageHandler(Filters.text, echo)) 128 | 129 | # on photo - recognize it with SmartIdReader 130 | dp.add_handler(MessageHandler(Filters.photo, smartid_engine.on_chat_photo)) 131 | dp.add_handler(MessageHandler(Filters.document.image, smartid_engine.on_chat_image)) 132 | # log all errors 133 | dp.add_error_handler(error) 134 | 135 | # Start the Bot 136 | updater.start_polling() 137 | 138 | # Run the bot until you press Ctrl-C or the process receives SIGINT, 139 | # SIGTERM or SIGABRT. This should be used most of the time, since 140 | # start_polling() is non-blocking and will stop the bot gracefully. 141 | updater.idle() 142 | 143 | 144 | if __name__ == '__main__': 145 | main() 146 | --------------------------------------------------------------------------------