1from ctypes import * 2from enum import Enum 3import datetime, string, random, sys, os, platform 4 5PY3 = sys.version_info[ 0 ] == 3 6 7if PY3 : 8 def xrange( *args, **kwargs ) : 9 return iter( range( *args, **kwargs ) ) 10 11def to_bytes( s ) : 12 if PY3 and ( type( s ) == str ) : 13 return str.encode( s ) 14 return s 15 16def to_char_p( s ) : 17 if PY3 and ( type( s ) == str ) : 18 return c_char_p( str.encode( s ) ) 19 return c_char_p( s ) 20 21 22class CreateMode( Enum ) : 23 Open = 0 24 Init = 1 25 Create = 2 26 MD5 = ( 1 << 6 ) 27 28class TypeDomain( Enum ) : 29 Bool = 1 30 UInt = 2 31 Int = 3 32 Float = 4 33 Ascii = 5 34 Unicode = 6 35 36class CursorMode( Enum ) : 37 Update = 0 38 Replace = 1 39 Insert = 2 40 41class OpenMode( Enum ) : 42 Read = 0 43 Write = 1 44 45class RepoCat( Enum ) : 46 Bad = 0 47 User = 1 48 Site = 2 49 Remote = 3 50 51class RepoSubCat( Enum ) : 52 Bad = 0 53 Main = 1 54 Aux = 2 55 Protected = 3 56 57class RemoteProto( Enum ) : 58 Http = 0 59 Fasp = 1 60 FaspHttp = 2 61 HttpFasp = 3 62 63class ResolvEnable( Enum ) : 64 UseConfig = 0 65 AlwaysEnable = 1 66 AlwaysDisable = 2 67 68class PathType( Enum ) : 69 NotFound = 0 70 BadPath = 1 71 File = 2 72 Dir = 3 73 CharDev = 4 74 BlockDev = 5 75 Fifo = 6 76 ZombieFile = 7 77 FakeRoot = 8 78 Dataset = 9 79 Datatype = 10 80 Database = 11 81 Table = 12 82 Index = 13 83 Column = 14, 84 Metadata = 15 85 PrereleaseTbl = 16 86 Alias = 128 87 88class IndexType( Enum ) : 89 Text = 0 90 UInt64 = 1 91 Text_reverse = 128 92 UInt64_reverse = 129 93 94RepoCatDict = { RepoCat.Bad : "Bad", RepoCat.User : "User", RepoCat.Site : "Site", RepoCat.Remote : "Remote" } 95def RepoCat2String( cat ) : 96 x = RepoCatDict[ cat ] 97 if x == None : 98 x = "Bad" 99 return x 100 101RepoSubCatDict = { RepoSubCat.Bad : "Bad", RepoSubCat.Main : "Main", RepoSubCat.Aux : "Aux", RepoSubCat.Protected : "Protected" } 102def RepoSubCat2String( cat ) : 103 x = RepoSubCatDict[ cat ] 104 if x == None : 105 x = "Bad" 106 return x 107 108class vdb_string( Structure ) : 109 _fields_ = [ ( "addr", c_char_p ), ( "size", c_int ), ( "len", c_int ) ] 110 111 def __str__( self ) : 112 return self.addr.value 113 114class vdb_vector( Structure ) : 115 _fields_ = [ ( "v", c_void_p ), ( "start", c_int ), ( "len", c_int ), ( "mask", c_int ) ] 116 117 118#------------------------------------------------------------------------------------------------------------ 119class version : 120 major = 0 121 minor = 0 122 release = 0 123 124 def __init__( self, s ) : 125 if PY3 : 126 string_types = str 127 else : 128 string_types = basestring 129 if isinstance( s, string_types ) : 130 a = s.split( '.' ) 131 l = len( a ) 132 if l > 0 : 133 self.major = int( a[ 0 ] ) 134 if l > 1 : 135 self.minor = int( a[ 1 ] ) 136 if l > 2 : 137 self.release = int( a[ 2 ] ) 138 elif isinstance( s, int ) : 139 self.major = ( s & 0xFF000000 ) >> 24 140 self.minor = ( s & 0xFF0000 ) >> 16 141 self.release = s & 0xFFFF 142 143 def __str__( self ) : 144 return "%d.%d.%d"%( self.major, self.minor, self.release ) 145 146 def __cmp__( self, other ) : 147 if not isinstance( other, version ) : 148 return NotImplemented 149 d = cmp( self.major, other.major ) 150 if d != 0 : 151 return d 152 d = cmp( self.minor, other.minor ) 153 if d != 0 : 154 return d 155 return cmp( self.release, other.release ) 156 157 158#------------------------------------------------------------------------------------------------------------ 159class vdb_error( Exception ) : 160 """Exception thrown by vdb-objects like mananger, schema, database, table, cursor, column 161 162 Args: 163 rc (int) : rc-code from vdb-library call 164 msg ( string ) : explanation of error 165 obj : object that caused the error ( manager, schema, database, table, cursor, column ) 166 """ 167 def __init__( self, rc, msg, obj ) : 168 super( vdb_error, self ).__init__( "%s.%s"%( obj.__class__.__name__, msg ) ) 169 self.obj_name = obj.__class__.__name__ 170 self.rc = rc 171 172 173#------------------------------------------------------------------------------------------------------------ 174class KNamelist : 175 def __init__( self, mgr, ptr ) : 176 self.__mgr = mgr 177 self.__ptr = ptr 178 179 def __del__( self ) : 180 rc = self.__mgr.KNamelistRelease( self.__ptr ) 181 if rc != 0 : 182 self.__mgr.raise_rc( rc, "KNamelistRelease()", self ) 183 184 def count( self ) : 185 n = c_int() 186 rc = self.__mgr.KNamelistCount( self.__ptr, byref( n ) ) 187 if rc != 0 : 188 self.__mgr.raise_rc( rc, "KNamelistCount()", self ) 189 return n.value 190 191 def to_list( self ) : 192 res = list() 193 for idx in xrange( 0, self.count() ) : 194 name = c_char_p() 195 rc = self.__mgr.KNamelistGet( self.__ptr, idx, byref( name ) ) 196 if rc != 0 : 197 self.__mgr.raise_rc( rc, "KNamelistGet( %d )"%( idx ), self ) 198 if PY3 : 199 res.append( name.value.decode( "utf-8" ) ) 200 else : 201 res.append( name.value ) 202 return res 203 204 205#------------------------------------------------------------------------------------------------------------ 206def random_string( size = 12, chars = string.ascii_uppercase + string.ascii_lowercase + string.digits ) : 207 return ''.join( random.choice( chars ) for _ in xrange( size ) ) 208 209def random_data( count, min_value, max_value ) : 210 res = list() 211 for _ in xrange( count ) : 212 res.append( random.randint( min_value, max_value ) ) 213 return res 214 215#------------------------------------------------------------------------------------------------------------ 216class typedecl( Structure ) : 217 _fields_ = [ ( "type_id", c_int ), ( "dim", c_int ) ] 218 219 def __str__( self ) : 220 return "( type_id=%d, dim=%d )"%( self.type_id, self.dim ) 221 222class typedesc( Structure ) : 223 _fields_ = [ ( "bits", c_int ), ( "dim", c_int ), ( "domain", c_int ) ] 224 225 def __str__( self ) : 226 return "( bits=%d, dim=%d, domain=%d )"%( self.bits, self.dim, self.domain ) 227 228 229#------------------------------------------------------------------------------------------------------------ 230uint_xf = { 1 : c_ubyte, 8 : c_ubyte, 16 : c_ushort, 32 : c_uint, 64 : c_ulonglong } 231int_xf = { 1 : c_byte, 8 : c_byte, 16 : c_short, 32 : c_int, 64 : c_longlong } 232float_xf = { 32 : c_float, 64 : c_double } 233txt_xf = { 8 : c_char } 234 235if platform.system() == "Windows" : 236 type_xf = { TypeDomain.Bool : ( uint_xf, c_ubyte ), 237 TypeDomain.UInt : ( uint_xf, c_ubyte ), 238 TypeDomain.Int : ( int_xf, c_byte ), 239 TypeDomain.Float : ( float_xf, c_double ), 240 TypeDomain.Ascii : ( txt_xf, c_char ), 241 TypeDomain.Unicode : ( txt_xf, c_char ) } 242 243else : 244 type_xf = { TypeDomain.Bool.value : ( uint_xf, c_ubyte ), 245 TypeDomain.UInt.value : ( uint_xf, c_ubyte ), 246 TypeDomain.Int.value : ( int_xf, c_byte ), 247 TypeDomain.Float.value : ( float_xf, c_double ), 248 TypeDomain.Ascii.value : ( txt_xf, c_char ), 249 TypeDomain.Unicode.value : ( txt_xf, c_char ) } 250 251 252#------------------------------------------------------------------------------------------------------------ 253class VColumn : 254 """representing a column of a vdb-cursor 255 """ 256 def __init__( self, mgr, cur, id, name, tabname ) : 257 self.__mgr = mgr 258 self.__cur = cur 259 self.__id = id 260 p1 = name.find( '(' ) 261 p2 = name.find( ')' ) 262 if p1 > -1 and p2 > -1 : 263 self.cast = name[ p1 + 1 : p2 ] 264 self.name = name[ p2 + 1 : ] 265 else : 266 self.cast = "" 267 self.name = name 268 self.tabname = tabname 269 self.__tdec = typedecl( 0, 0 ) 270 self.__tdes = typedesc( 0, 0, 0 ) 271 self.column_type = None 272 self.min_value = None 273 self.max_value = None 274 275 def __str__( self ) : 276 return "%s.%s: (%d) %s %s"%( self.tabname, self.name, self.__id, self.tdec, self.tdes ) 277 278 def __enter__( self ) : 279 return self 280 281 def __exit__( self, type, value, traceback ) : 282 pass 283 284 def _update( self ) : 285 rc = self.__mgr.VCursorDatatype( self.__cur._VCursor__ptr, self.__id, byref( self.__tdec ), byref( self.__tdes ) ) 286 if rc != 0 : 287 self.__mgr.raise_rc( rc, "VCursorDatatype( '%s.%s' )"%( self.tabname, self.name ), self ) 288 ( dict, dflt ) = type_xf[ self.__tdes.domain ] 289 self.column_type = dict[ self.__tdes.bits ] 290 if self.column_type == None : 291 self.column_type == dflt 292 293 def domain( self ) : 294 return TypeDomain( self.__tdes.domain ) 295 296 def bits( self ) : 297 return self.__tdes.bits 298 299 def dim( self ) : 300 return self.__tdes.dim 301 302 def Read( self, row ) : 303 """read values from a column 304 returns either a string or a list of integer, float, boolean values 305 306 Args: 307 row (longlong) : row to read from 308 """ 309 if self.column_type == None : 310 raise vdb_error( 0, "read: undefined column-type", self ) 311 row_id = c_longlong( row ) 312 elem_bits = c_int() 313 data = c_void_p() 314 row_len = c_int() 315 rc = self.__mgr.VCursorCellDataDirect( self.__cur._VCursor__ptr, row_id, self.__id, byref( elem_bits ), byref( data ), None, byref( row_len ) ) 316 if rc != 0 : 317 self.__mgr.raise_rc( rc, "VCursorCellDataDirect( '%s.%s', #%d )"%( self.tabname, self.name, row ), self ) 318 if self.column_type == c_char : 319 tmp = string_at( data, row_len.value ) 320 if PY3 and isinstance( tmp, bytes ) : 321 return tmp.decode( "utf-8" ) 322 return tmp 323 else : 324 typed_ptr = cast( data, POINTER( self.column_type ) ) 325 e_count = row_len.value 326 if elem_bits.value < 8 : 327 e_count *= elem_bits.value 328 if PY3 : 329 e_count //= 8 330 else : 331 e_count /= 8 332 l = list() 333 for idx in xrange( 0, e_count ) : 334 l.append( typed_ptr[ idx ] ) 335 return l 336 337 def __write_values( self, data ) : 338 if isinstance( data, list ) : 339 l = len( data ) 340 t = self.column_type * l 341 arr = t() 342 idx = 0 343 for x in data : 344 arr[ idx ] = x 345 idx += 1 346 else : 347 l = 1 348 t = self.column_type * l 349 arr = t() 350 arr[ 0 ] = data 351 352 bits = c_int( self.__tdes.bits ) 353 rc = self.__mgr.VCursorWrite( self.__cur._VCursor__ptr, self.__id, bits, arr, c_int( 0 ), c_int( l ) ) 354 if rc != 0 : 355 self.__mgr.raise_rc( rc, "VCursorWrite( %s.%s )"%( self.tabname, self.name ), self ) 356 357 def __write_string( self, data ) : 358 p = create_string_buffer( to_bytes( data ) ) 359 rc = self.__mgr.VCursorWrite( self.__cur._VCursor__ptr, self.__id, c_int( 8 ), p, c_int( 0 ), c_int( len( data ) ) ) 360 if rc != 0 : 361 self.__mgr.raise_rc( rc, "VCursorWrite( %s.%s, %s )"%( self.tabname, self.name, data ), self ) 362 363 def write( self, data ) : 364 """write values to a column 365 raises vdb_error if error occurs 366 367 Args: 368 data ( list of values or string ) : data to be written 369 """ 370 if self.column_type == None : 371 raise vdb_error( 0, "write: undefined column-type", self ) 372 elif self.column_type == c_char : 373 self.__write_string( data ) 374 else : 375 self.__write_values( data ) 376 377 def write_rand( self, count = 1, max_value = 255, min_value = 0 ) : 378 if self.column_type == None : 379 raise vdb_error( 0, "write_rand: undefined column-type", self ) 380 else : 381 dom = self.domain() 382 if dom == TypeDomain.Ascii or dom == TypeDomain.Unicode : 383 self.__write_string( random_string( count ) ) 384 elif dom == TypeDomain.Bool : 385 self.__write_values( random_data( count, 0, 1 ) ) 386 else : 387 self.__write_values( random_data( count, min_value, max_value ) ) 388 389 def set_default( self, data ) : 390 if isinstance( data, list ) : 391 l = len( data ) 392 t = self.column_type * l 393 arr = t() 394 idx = 0 395 for x in data : 396 arr[ idx ] = x 397 idx += 1 398 else : 399 l = 1 400 t = self.column_type * l 401 arr = t() 402 arr[ 0 ] = data 403 404 bits = c_int( self.__tdes.bits ) 405 rc = self.__mgr.VCursorDefault( self.__cur._VCursor__ptr, self.__id, bits, arr, c_int( 0 ), c_int( l ) ) 406 if rc != 0 : 407 self.__mgr.raise_rc( rc, "VCursorDefault( %s.%s )"%( self.tabname, self.name ), self ) 408 409 def default_string( self, data ) : 410 p = create_string_buffer( data ) 411 rc = self.__mgr.VCursorDefault( self.__cur._VCursor__ptr, self.__id, c_int( 8 ), p, c_int( 0 ), c_int( len( data ) ) ) 412 if rc != 0 : 413 self.__mgr.raise_rc( rc, "VCursorDefault( %s.%s, %s )"%( self.tabname, self.name, data ), self ) 414 415 def default( self, data ) : 416 if self.column_type == None : 417 raise vdb_error( 0, "default: undefined column-type", self ) 418 if self.column_type == c_char : 419 return self.default_string( data ) 420 else : 421 return self.default_values( data ) 422 423 def row_range( self ) : 424 first = c_longlong() 425 count = c_longlong() 426 rc = self.__mgr.VCursorIdRange( self.__cur._VCursor__ptr, self.__id, byref( first ), byref( count ) ) 427 if rc != 0 : 428 self.__mgr.raise_rc( rc, "VCursorIdRange( '%s.%s' )"%( self.tabname, self.name ), self ) 429 return ( first.value, count.value ) 430 431 def range( self ) : 432 ( first, count ) = self.row_range() 433 return xrange( first, first + count ) 434 435 def next_row( self, current_row ) : 436 res = c_longlong( 0 ) 437 rc = self.__mgr.VCursorFindNextRowIdDirect( self.__cur._VCursor__ptr, self.__id, c_longlong( current_row ), byref( res ) ) 438 if rc != 0 : 439 return None 440 else : 441 return res.value 442 443 444#------------------------------------------------------------------------------------------------------------ 445class ReferenceObj : 446 def __init__( self, mgr, ptr ) : 447 self.__mgr = mgr 448 self.__ptr = ptr 449 450 def __del__( self ) : 451 self.__mgr.ReferenceObj_Release( self.__ptr ) 452 453 def __str__( self ) : 454 idx = self.Idx() 455 start, stop = self.IdRange() 456 seq_id = self.SeqId() 457 name = self.Name() 458 return "Idx\t%d\nIdRange\t%d..%d\nSeqId\t%s\nName\t%s"%( idx, start, stop, seq_id, name ) 459 460 def Idx( self ) : 461 res = c_int() 462 rc = self.__mgr.ReferenceObj_Idx( self.__ptr, byref( res ) ) 463 if rc != 0 : 464 self.__mgr.raise_rc( rc, "ReferenceObj_Idx()", self ) 465 return res.value 466 467 def IdRange( self ) : 468 start = c_longlong() 469 stop = c_longlong() 470 rc = self.__mgr.ReferenceObj_IdRange( self.__ptr, byref( start ), byref( stop ) ) 471 if rc != 0 : 472 self.__mgr.raise_rc( rc, "ReferenceObj_IdRange()", self ) 473 return ( start.value, stop.value ) 474 475 def Bin( self ) : 476 res = c_int() 477 rc = self.__mgr.ReferenceObj_Bin( self.__ptr, byref( res ) ) 478 if rc != 0 : 479 self.__mgr.raise_rc( rc, "ReferenceObj_Bin()", self ) 480 return res.value 481 482 def SeqId( self ) : 483 res = c_char_p() 484 rc = self.__mgr.ReferenceObj_SeqId( self.__ptr, byref( res ) ) 485 if rc != 0 : 486 self.__mgr.raise_rc( rc, "ReferenceObj_SeqId()", self ) 487 return res.value 488 489 def Name( self ) : 490 res = c_char_p() 491 rc = self.__mgr.ReferenceObj_Name( self.__ptr, byref( res ) ) 492 if rc != 0 : 493 self.__mgr.raise_rc( rc, "ReferenceObj_Name()", self ) 494 return res.value 495 496 def SeqLength( self ) : 497 res = c_int() 498 rc = self.__mgr.ReferenceObj_SeqLength( self.__ptr, byref( res ) ) 499 if rc != 0 : 500 self.__mgr.raise_rc( rc, "ReferenceObj_SeqLength()", self ) 501 return res.value 502 503 def Circular( self ) : 504 res = c_bool() 505 rc = self.__mgr.ReferenceObj_Circular( self.__ptr, byref( res ) ) 506 if rc != 0 : 507 self.__mgr.raise_rc( rc, "ReferenceObj_Circular()", self ) 508 return res.value 509 510 def External( self ) : 511 res = c_bool() 512 rc = self.__mgr.ReferenceObj_External( self.__ptr, byref( res ), c_void_p( 0 ) ) 513 if rc != 0 : 514 self.__mgr.raise_rc( rc, "ReferenceObj_External()", self ) 515 return res.value 516 517 def Read( self, offs, len ) : 518 buffer = create_string_buffer( len ) 519 written = c_int() 520 rc = self.__mgr.ReferenceObj_Read( self.__ptr, c_int( offs ), c_int( len ), buffer, byref( written ) ) 521 if rc != 0 : 522 self.__mgr.raise_rc( rc, "ReferenceObj_Read( %d.%d )" % ( offs, len ), self ) 523 if PY3 : 524 return buffer.value.decode( "utf-8" ) 525 return buffer.value 526 527 def GetIdCount( self, row_id ) : 528 res = c_int() 529 rc = self.__mgr.ReferenceObj_GetIdCount( self.__ptr, c_longlong( row_id ), byref( res ) ) 530 if rc != 0 : 531 self.__mgr.raise_rc( rc, "ReferenceObj_GetIdCount( %d )" % row_id, self ) 532 return res.value 533 534 535#------------------------------------------------------------------------------------------------------------ 536class ReferenceList : 537 def __init__( self, mgr, ptr ) : 538 self.__mgr = mgr 539 self.__ptr = ptr 540 541 def __del__( self ) : 542 rc = self.__mgr.ReferenceList_Release( self.__ptr ) 543 if rc != 0 : 544 self.__mgr.raise_rc( rc, "ReferenceList_Release()", self ) 545 546 def count( self ) : 547 res = c_int() 548 rc = self.__mgr.ReferenceList_Count( self.__ptr, byref( res ) ) 549 if rc != 0 : 550 self.__mgr.raise_rc( rc, "ReferenceList_Count()", self ) 551 return res.value 552 553 def find( self, name ) : 554 ptr = c_void_p() 555 rc = self.__mgr.ReferenceList_Find( self.__ptr, byref( ptr ), to_char_p( name ), c_int( len( name ) ) ) 556 if rc != 0 : 557 self.__mgr.raise_rc( rc, "ReferenceList_Find( '%s' )" % name, self ) 558 return ReferenceObj( self.__mgr, ptr ) 559 560 def get( self, idx ) : 561 ptr = c_void_p() 562 rc = self.mgr.ReferenceList_Get( self.__ptr, byref( ptr ), c_int( idx ) ) 563 if rc != 0 : 564 self.__mgr.raise_rc( rc, "ReferenceList_Get( %d )" % idx, self ) 565 return ReferenceObj( self.__mgr, ptr ) 566 567 568#------------------------------------------------------------------------------------------------------------ 569def read_row( cols, row_id ) : 570 res = {} 571 try : 572 for ( name, column ) in cols.iteritems() : 573 res[ name ] = column.Read( row_id ) 574 except AttributeError : 575 for ( name, column ) in cols.items() : 576 res[ name ] = column.Read( row_id ) 577 return res 578 579 580#------------------------------------------------------------------------------------------------------------ 581def first_none_static_col( cols ) : 582 res = None 583 try : 584 v = cols.itervalues() 585 except AttributeError : 586 v = cols.values() 587 for c in v : 588 rr = c.row_range() 589 if res == None and rr[ 1 ] > 0 : 590 res = c 591 return res 592 593 594#------------------------------------------------------------------------------------------------------------ 595def row_gen( cols, row_range = None ) : 596 if isinstance( cols, dict ) : 597 first_col = first_none_static_col( cols ) 598 if first_col != None : 599 if row_range == None : 600 row_id = 1 601 while row_id != None : 602 yield read_row( cols, row_id ) 603 row_id = first_col.next_row( row_id + 1 ) 604 else : 605 range_idx = 0 606 try : 607 row_id = row_range[ range_idx ] 608 except : 609 row_id = None 610 while row_id != None : 611 yield read_row( cols, row_id ) 612 range_idx += 1 613 try : 614 row_id = first_col.next_row( row_range[ range_idx ] ) 615 except : 616 row_id = None 617 else : 618 if row_range == None : 619 row_id = 1 620 while row_id != None : 621 yield cols.Read( row_id ) 622 row_id = cols.next_row( row_id + 1 ) 623 else : 624 range_idx = 0 625 try : 626 row_id = row_range[ range_idx ] 627 except : 628 row_id = None 629 while row_id != None : 630 yield cols.Read( row_id ) 631 range_idx += 1 632 try : 633 row_id = cols.next_row( row_range[ range_idx ] ) 634 except : 635 row_id = None 636 637 638#------------------------------------------------------------------------------------------------------------ 639class VCursor : 640 def __init__( self, tab, ptr ) : 641 self.__mgr = tab._VTable__mgr 642 self.__tab = tab 643 self.__ptr = ptr 644 645 def __del__( self ) : 646 rc = self.__mgr.VCursorRelease( self.__ptr ) 647 if rc != 0 : 648 self.__mgr.raise_rc( rc, "VCursorRelease( '%s' )"%( self.__tab._VTable__name ), self ) 649 650 def __enter__( self ) : 651 return self 652 653 def __exit__( self, type, value, traceback ) : 654 pass 655 656 def OpenColumns( self, col_names ) : 657 if isinstance( col_names, list ) : 658 res = {} 659 for name in col_names : 660 res[ name ] = self.AddColumn( name ) 661 self.Open() 662 try : 663 v = res.itervalues() 664 except AttributeError : 665 v = res.values() 666 for c in v : 667 c._update() 668 return res 669 elif isinstance( col_names, str ) : 670 c = self.AddColumn( col_names ) 671 self.Open() 672 c._update() 673 return c 674 else : 675 raise vdb_error( 0, "cursor.open( x ) x is not list or string", self ) 676 677 def AddColumn( self, name ) : 678 idx = c_int() 679 rc = self.__mgr.VCursorAddColumn( self.__ptr, byref( idx ), to_char_p( name ) ) 680 if rc != 0 : 681 self.__mgr.raise_rc( rc, "VCursorAddColumn( %s.%s )"%( self.__tab.name, name ), self ) 682 return VColumn( self.__mgr, self, idx.value, name, self.__tab._VTable__name ) 683 684 def Open( self ) : 685 rc = self.__mgr.VCursorOpen( self.__ptr ) 686 if rc != 0 : 687 self.__mgr.raise_rc( rc, "VCursorOpen( '%s' )"%( self.__tab._VTable__name ), self ) 688 689 def Commit( self ) : 690 rc = self.__mgr.VCursorCommit( self.__ptr ) 691 if rc != 0 : 692 self.__mgr.raise_rc( rc, "VCursorCommit( %s )"%( self.__tab._VTable__name ), self ) 693 694 def OpenRow( self ) : 695 rc = self.__mgr.VCursorOpenRow( self.__ptr ) 696 if rc != 0 : 697 self.__mgr.raise_rc( rc, "VCursorOpenRow( '%s' )"%( self.__tab._VTable__name ), self ) 698 699 def CommitRow( self ) : 700 rc = self.__mgr.VCursorCommitRow( self.__ptr ) 701 if rc != 0 : 702 self.__mgr.raise_rc( rc, "VCursorCommitRow( '%s' )"%( self.__tab._VTable__name ), self ) 703 704 def RepeatRow( self, count ) : 705 rc = self.__mgr.VCursorRepeatRow( self.__ptr, count ) 706 if rc != 0 : 707 self.__mgr.raise_rc( rc, "VCursorRepeatRow( '%s', %d )"%( self.__tab._VTable__name, count ), self ) 708 709 def CloseRow( self ) : 710 rc = self.__mgr.VCursorCloseRow( self.__ptr ) 711 if rc != 0 : 712 self.__mgr.raise_rc( rc, "VCursorCloseRow( '%s' )"%( self.__tab._VTable__name ), self ) 713 714 def FlushPage( self ) : 715 rc = self.__mgr.VCursorFlushPage( self.__ptr ) 716 if rc != 0 : 717 self.__mgr.raise_rc( rc, "VCursorFlushPage( '%s' )"%( self.__tab._VTable__name ), self ) 718 719 def RowId( self ) : 720 row_id = c_longlong() 721 rc = self.__mgr.VCursorRowId( self.__ptr, byref( row_id ) ) 722 if rc != 0 : 723 self.__mgr.raise_rc( rc, "VCursorRowId( '%s' )"%( self.__tab._VTable__name ), self ) 724 return row_id.value 725 726 def SetRowId( self, value ) : 727 rc = self.__mgr.VCursorSetRowId( self.__ptr, value ) 728 if rc != 0 : 729 self.__mgr.raise_rc( rc, "VCursorSetRowId( '%s', %d )"%( self.__tab._VTable__name, value ), self ) 730 731 def ReferenceList( self ) : 732 reflist_ptr = c_void_p() 733 rc = self.__mgr.ReferenceList_MakeCursor( byref( reflist_ptr ), self.__ptr, c_int( 0 ), c_char_p( 0 ), c_int( 0 ) ) 734 if rc != 0 : 735 self.__mgr.raise_rc( rc, "ReferenceList_MakeCursor()", self ) 736 return ReferenceList( self.__mgr, reflist_ptr ) 737 738 739def max_colname_len( cols, colnames ) : 740 res = 0 741 if colnames == None : 742 try : 743 for ( name, column ) in cols.iteritems() : 744 l = len( name ) 745 if l > res : 746 res = l 747 except AttributeError : 748 for ( name, column ) in cols.items() : 749 l = len( name ) 750 if l > res : 751 res = l 752 else : 753 for name in colnames : 754 l = len( name ) 755 if l > res : 756 res = l 757 return res 758 759 760#------------------------------------------------------------------------------------------------------------ 761# cols ....... dictionay : key = colname, value = column-object 762# rowrange ... a xrange - iterator ( None: all rows ) 763# colnames ... a list of string ( None: all columns ) 764# prefix ..... a string printed at the beginning of each line 765def print_cols( cols, rowrange, colnames = None, prefix = "" ) : 766 if cols != None : 767 if rowrange == None : 768 try : 769 column = cols.itervalues().next() 770 except AttributeError : 771 column = list( cols.values() )[ 0 ] 772 rr = column.range() 773 else : 774 rr = rowrange 775 w = max_colname_len( cols, colnames ) 776 for row_id in rr : 777 if colnames == None : 778 try : 779 for ( name, column ) in sorted( cols.iteritems() ) : 780 print( '{0}{1:<{width}}.{2} : {3}'.format( prefix, name, row_id, column.Read( row_id ), width = w ) ) 781 except AttributeError : 782 for ( name, column ) in sorted( cols.items() ) : 783 print( '{0}{1:<{width}}.{2} : {3}'.format( prefix, name, row_id, column.Read( row_id ), width = w ) ) 784 else : 785 for name in colnames : 786 column = cols[ name ] 787 if column != None : 788 print( '{0}{1:<{width}}.{2} : {3}'.format( prefix, name, row_id, column.Read( row_id ), width = w ) ) 789 print( "%s."%( prefix ) ) 790 791 792#------------------------------------------------------------------------------------------------------------ 793class KIndex : 794 def __init__( self, mgr, ptr, name ) : 795 self.__mgr = mgr 796 self.__ptr = ptr 797 self.__name = name 798 799 def __del__( self ) : 800 rc = self.__mgr.KIndexRelease( self.__ptr ) 801 if rc != 0 : 802 self.__mgr.raise_rc( rc, "KIndexRelease( '%s' )"%( self.__name ), self ) 803 804 def Version( self ) : 805 vers = c_int() 806 rc = self.__mgr.KIndexVersion( self.__ptr, byref( vers ) ) 807 if rc != 0 : 808 self.__mgr.raise_rc( rc, "KIndexVersion( '%s' )"%( self.__name ), self ) 809 return version( vers.value ) 810 811 def Type( self ) : 812 type = c_int() 813 rc = self.__mgr.KIndexType( self.__ptr, byref( type ) ) 814 if rc != 0 : 815 self.__mgr.raise_rc( rc, "KIndexType( '%s' )"%( self.__name ), self ) 816 return IndexType( type.value ) 817 818 def Locked( self ) : 819 return self.__mgr.KIndexLocked( self.__ptr ) 820 821 def FindText( self, key ) : 822 start_id = c_longlong() 823 id_count = c_longlong() 824 rc = self.__mgr.KIndexFindText( self.__ptr, to_char_p( key ), byref( start_id ), by_ref( id_count ), c_void_p( 0 ), c_void_p( 0 ) ) 825 if rc != 0 : 826 self.__mgr.raise_rc( rc, "KIndexFindText( %s, %s )"%( self.__name, key ), self ) 827 return ( start_id.value, id_count.value ) 828 829 def ProjectText( self, row_id, bufsize = 1024 ) : 830 buffer = create_string_buffer( bufsize ) 831 start_id = c_longlong() 832 id_count = c_longlong() 833 num_writ = c_int( 0 ) 834 rc = self.__mgr.KIndexProjectText( self.__ptr, c_longlong( row_id ), byref( start_id ), byref( id_count ), buffer, c_int( bufsize ), byref( num_writ ) ) 835 if rc != 0 : 836 self.__mgr.raise_rc( rc, "KIndexProjectText( %s, %d )"%( self.__name, row_id ), self ) 837 if PY3 : 838 return ( buffer.value.decode( "utf-8" ), start_id.value, id_count.value ) 839 return ( buffer.value, start_id.value, id_count.value ) 840 841 def Commit( self ) : 842 rc = self.__mgr.KIndexCommit( self.__ptr ) 843 if rc != 0 : 844 self.__mgr.raise_rc( rc, "KIndexCommit( %s )"%( self.__name ), self ) 845 846 def InsertText( self, unique, key, value ) : 847 rc = self.__mgr.KIndexInsertText( self.__ptr, c_bool( unique ), to_char_p( key ), c_longlong( value ) ) 848 if rc != 0 : 849 self.__mgr.raise_rc( rc, "KIndexInsertText( %s, k=%s, v=%d )"%( self.__name, key, value ), self ) 850 851 def DeleteText( self, key ) : 852 rc = self.__mgr.KIndexDeleteText( self.__ptr, to_char_p( key ) ) 853 if rc != 0 : 854 self.__mgr.raise_rc( rc, "KIndexDeleteText( %s, k=%s )"%( self.__name, key ), self ) 855 856 def InsertU64( self, unique, key_start, keylen, value_start, value_len ) : 857 rc = self.__mgr.KIndexInsertU64( self.__ptr, c_bool( unique ), c_longlong( key_start ), c_longlong( key_len ), c_longlong( value_start ), c_longlong( value_len ) ) 858 if rc != 0 : 859 self.__mgr.raise_rc( rc, "KIndexInsertU64( %s, k=%d.%d, v=%d.%d )"%( self.__name, key_start, key_len, value_start, value_len ), self ) 860 861 def DeleteU64( self, key ) : 862 rc = self.__mgr.KIndexDeleteU64( self.__ptr, c_longlong( key ) ) 863 if rc != 0 : 864 self.__mgr.raise_rc( rc, "KIndexDeleteU64( %s, k=%d )"%( self.__name, key ), self ) 865 866 867#------------------------------------------------------------------------------------------------------------ 868class KMDataNode : 869 def __init__( self, mgr, ptr ) : 870 self.__mgr = mgr 871 self.__ptr = ptr 872 873 def __del__( self ) : 874 rc = self.__mgr.KMDataNodeRelease( self.__ptr ) 875 if rc != 0 : 876 self.__mgr.raise_rc( rc, "KMDataNodeRelease()", self ) 877 878 def __enter__( self ) : 879 return self 880 881 def __exit__( self, type, value, traceback ) : 882 pass 883 884 def OpenNode( self, path, open_mode = OpenMode.Read ) : 885 node = c_void_p() 886 if open_mode == OpenMode.Write : 887 rc = self.__mgr.KMDataNodeOpenNodeUpdate( self.__ptr, byref( node ), to_char_p( path ) ) 888 if rc != 0 : 889 self.__mgr.raise_rc( rc, "KMDataNodeOpenNodeUpdate( %s )"%( path ), self ) 890 else : 891 rc = self.__mgr.KMDataNodeOpenNodeRead( self.__ptr, byref( node ), to_char_p( path ) ) 892 if rc != 0 : 893 self.__mgr.raise_rc( rc, "KMDataNodeOpenNodeRead( %s )"%( path ), self ) 894 return KMDataNode( self.__mgr, node ) 895 896 def ByteOrder( self ) : 897 order = c_bool() 898 rc = self.__mgr.KMDataNodeByteOrder( self.__ptr, byref( order ) ) 899 if rc != 0 : 900 self.__mgr.raise_rc( rc, "KMDataNodeByteOrder()", self ) 901 return order.value 902 903 def ListChildren( self ) : 904 l = c_void_p() 905 rc = self.__mgr.KMDataNodeListChildren( self.__ptr, byref( l ) ) 906 if rc == 0 : 907 return KNamelist( self.__mgr, l ).to_list() 908 return [] 909 910 def ListAttr( self ) : 911 l = c_void_p() 912 rc = self.__mgr.KMDataNodeListAttr( self.__ptr, byref( l ) ) 913 if rc == 0 : 914 return KNamelist( self.__mgr, l ).to_list() 915 return [] 916 917 def size( self ) : 918 buffer = create_string_buffer( 16 ) 919 num_read = c_size_t() 920 remaining = c_size_t() 921 rc = self.__mgr.KMDataNodeRead( self.__ptr, c_size_t( 0 ), buffer, c_size_t( 16 ), byref( num_read ), byref( remaining ) ) 922 if rc != 0 : 923 self.__mgr.raise_rc( rc, "KMDataNodeRead()", self ) 924 return num_read.value + remaining.value 925 926 def to_read( self, req_len ) : 927 ns = self.size() 928 if req_len > 0 : 929 return min( req_len, ns ) 930 return ns 931 932 def Read( self, buffer_size, to_read, offset ) : 933 buffer = create_string_buffer( int( buffer_size ) ) 934 num_read = c_size_t() 935 remaining = c_size_t() 936 rc = self.__mgr.KMDataNodeRead( self.__ptr, c_size_t( offset ), buffer, c_size_t( to_read ), byref( num_read ), byref( remaining ) ) 937 if rc != 0 : 938 self.__mgr.raise_rc( rc, "KMDataNodeRead( offset = %d )"%( offset ), self ) 939 if PY3 : 940 return buffer.value.decode( "utf-8" ) 941 return buffer.value 942 943 def as_string( self, req_len = 0, offset = 0 ) : 944 n_bytes = self.to_read( req_len ) 945 if n_bytes < 1 : 946 return "" 947 return self.Read( n_bytes, n_bytes, offset ) 948 949 def read_buffer_as( self, t = c_ubyte, align = 1, req_len = 0, offset = 0 ) : 950 n_bytes = self.to_read( req_len ) 951 if n_bytes < 1 : 952 return [] 953 n_values = n_bytes 954 if align > 1 : 955 if PY3 : 956 n_values = n_bytes / align 957 else : 958 n_values = n_bytes // align 959 if n_bytes > ( n_values * align ) : 960 n_values += 1 961 buffer = self.Read( n_values * align, n_bytes, offset ) 962 ptr = cast( buffer, POINTER( t ) ) 963 l = list() 964 for idx in xrange( 0, int( n_values ) ) : 965 l.append( ptr[ idx ] ) 966 return l 967 968 def as_uint8( self, req_len = 0, offset = 0 ) : 969 return self.read_buffer_as( c_ubyte, 1, req_len, offset ) 970 971 def as_int8( self, req_len = 0, offset = 0 ) : 972 return self.read_buffer_as( c_byte, 1, req_len, offset ) 973 974 def as_uint16( self, req_len = 0, offset = 0 ) : 975 return self.read_buffer_as( c_ushort, 2, req_len, offset ) 976 977 def as_int16( self, req_len = 0, offset = 0 ) : 978 return self.read_buffer_as( c_short, 2, req_len, offset ) 979 980 def as_uint32( self, req_len = 0, offset = 0 ) : 981 return self.read_buffer_as( c_uint, 4, req_len, offset ) 982 983 def as_int32( self, req_len = 0, offset = 0 ) : 984 return self.read_buffer_as( c_int, 4, req_len, offset ) 985 986 def as_uint64( self, req_len = 0, offset = 0 ) : 987 return self.read_buffer_as( c_ulonglong, 8, req_len, offset ) 988 989 def as_int64( self, req_len = 0, offset = 0 ) : 990 return self.read_buffer_as( c_longlong, 8, req_len, offset ) 991 992 def write_string( self, data, append = False ) : 993 p = create_string_buffer( data ) 994 if append : 995 rc = self.__mgr.KMDataNodeAppend( self.__ptr, p, c_size_t( len( data ) ) ) 996 if rc != 0 : 997 self.__mgr.raise_rc( rc, "KMDataNodeAppend()", self ) 998 else : 999 rc = self.__mgr.KMDataNodeWrite( self.__ptr, p, c_size_t( len( data ) ) ) 1000 if rc != 0 : 1001 self.__mgr.raise_rc( rc, "KMDataNodeWrite()", self ) 1002 1003 def write_values( self, data, ct, ct_size, append ) : 1004 if isinstance( data, list ) : 1005 l = len( data ) 1006 t = ct * l 1007 arr = t() 1008 idx = 0 1009 for x in data : 1010 arr[ idx ] = x 1011 idx += 1 1012 else : 1013 l = 1 1014 t = ct * l 1015 arr = t() 1016 arr[ 0 ] = data 1017 if append : 1018 rc = self.__mgr.KMDataNodeAppend( self.__ptr, arr, c_size_t( l * ct_size ) ) 1019 if rc != 0 : 1020 self.__mgr.raise_rc( rc, "KMDataNodeAppend()", self ) 1021 else : 1022 rc = self.__mgr.KMDataNodeWrite( self.__ptr, arr, c_size_t( l * ct_size ) ) 1023 if rc != 0 : 1024 self.__mgr.raise_rc( rc, "KMDataNodeWrite()", self ) 1025 1026 def write_uint8( self, data, append = False ) : 1027 self.write_values( data, c_ubyte, 1, append ) 1028 1029 def write_int8( self, data, append = False ) : 1030 self.write_values( data, c_byte, 1, append ) 1031 1032 def write_uint16( self, data, append = False ) : 1033 self.write_values( data, c_ushort, 2, append ) 1034 1035 def write_int16( self, data, append = False ) : 1036 self.write_values( data, c_short, 2, append ) 1037 1038 def write_uint32( self, data, append = False ) : 1039 self.write_values( data, c_uint, 4, append ) 1040 1041 def write_int32( self, data, append = False ) : 1042 self.write_values( data, c_int, 4, append ) 1043 1044 def write_uint64( self, data, append = False ) : 1045 self.write_values( data, c_ulonglong, 8, append ) 1046 1047 def write_int64( self, data, append = False ) : 1048 self.write_values( data, c_longlong, 8, append ) 1049 1050 1051#------------------------------------------------------------------------------------------------------------ 1052class KMetadata : 1053 def __init__( self, mgr, ptr ) : 1054 self.__mgr = mgr 1055 self.__ptr = ptr 1056 1057 def __del__( self ) : 1058 rc = self.__mgr.KMetadataRelease( self.__ptr ) 1059 if rc != 0 : 1060 self.__mgr.raise_rc( rc, "KMetadataRelease()", self ) 1061 1062 def __enter__( self ) : 1063 return self 1064 1065 def __exit__( self, type, value, traceback ) : 1066 pass 1067 1068 def Version( self ) : 1069 vers = c_int() 1070 rc = self.__mgr.KMetadataVersion( self.__ptr, byref( vers ) ) 1071 if rc != 0 : 1072 self.__mgr.raise_rc( rc, "KMetadataVersion()", self ) 1073 return version( vers.value ) 1074 1075 def ByteOrder( self ) : 1076 order = c_bool() 1077 rc = self.__mgr.KMetadataByteOrder( self.__ptr, byref( order ) ) 1078 if rc != 0 : 1079 self.__mgr.raise_rc( rc, "KMetadataByteOrder()", self ) 1080 return order.value 1081 1082 def Revision( self ) : 1083 rev = c_int() 1084 rc = self.__mgr.KMetadataRevision( self.__ptr, byref( rev ) ) 1085 if rc != 0 : 1086 self.__mgr.raise_rc( rc, "KMetadataRevision()", self ) 1087 return rev.value 1088 1089 def MaxRevision( self ) : 1090 rev = c_int() 1091 rc = self.__mgr.KMetadataMaxRevision( self.__ptr, byref( rev ) ) 1092 if rc != 0 : 1093 self.__mgr.raise_rc( rc, "KMetadataMaxRevision()", self ) 1094 return rev.value 1095 1096 def Commit( self ) : 1097 rc = self.__mgr.KMetadataCommit( self.__ptr ) 1098 if rc != 0 : 1099 self.__mgr.raise_rc( rc, "KMetadataCommit()", self ) 1100 1101 def Freeze( self ) : 1102 rc = self.__mgr.KMetadataFreeze( self.__ptr ) 1103 if rc != 0 : 1104 self.__mgr.raise_rc( rc, "KMetadataFreeze()", self ) 1105 1106 def OpenRevision( self, rev_nr ) : 1107 k_meta = c_void_p() 1108 rc = self.__mgr.KMetadataOpenRevision( self.__ptr, byref( k_meta ), c_int( rev_nr ) ) 1109 if rc != 0 : 1110 self.__mgr.raise_rc( rc, "KMetadataOpenRevision( %d )"%rev_nr, self ) 1111 return KMetadata( self.__mgr, k_meta ) 1112 1113 def GetSequence( self, name ) : 1114 value = c_longlong() 1115 rc = self.__mgr.KMetadataGetSequence( self.__ptr, to_char_p( name ), byref( value ) ) 1116 if rc != 0 : 1117 self.__mgr.raise_rc( rc, "KMetadataGetSequence( %s )"%name, self ) 1118 return value.value 1119 1120 def SetSequence( self, name, value ) : 1121 rc = self.__mgr.KMetadataSetSequence( self.__ptr, to_char_p( name ), c_longlong( value ) ) 1122 if rc != 0 : 1123 self.__mgr.raise_rc( rc, "KMetadataSetSequence( %s, %d )"%( name, value ), self ) 1124 1125 def NextSequence( self, name ) : 1126 value = c_longlong() 1127 rc = self.__mgr.KMetadataNextSequence( self.__ptr, to_char_p( name ), byref( value ) ) 1128 if rc != 0 : 1129 self.__mgr.raise_rc( rc, "KMetadataNextSequence( %s )"%( name ), self ) 1130 return value.value 1131 1132 def OpenNode( self, path, open_mode = OpenMode.Read ) : 1133 ptr = c_void_p() 1134 if open_mode == OpenMode.Write : 1135 rc = self.__mgr.KMetadataOpenNodeUpdate( self.__ptr, byref( ptr ), to_char_p( path ) ) 1136 if rc != 0 : 1137 self.__mgr.raise_rc( rc, "KMetadataOpenNodeUpdate( %s )"%( path ), self ) 1138 else : 1139 rc = self.__mgr.KMetadataOpenNodeRead( self.__ptr, byref( ptr ), to_char_p( path ) ) 1140 if rc != 0 : 1141 self.__mgr.raise_rc( rc, "KMetadataOpenNodeRead( %s )"%( path ), self ) 1142 return KMDataNode( self.__mgr, ptr ) 1143 1144 1145#------------------------------------------------------------------------------------------------------------ 1146class VTable : 1147 def __init__( self, mgr, ptr, name ) : 1148 self.__mgr = mgr 1149 self.__ptr = ptr 1150 self.__kdb_ptr = None 1151 self.__name = name 1152 self.p_cur = None 1153 self.p_cols = None 1154 1155 def __del__( self ) : 1156 rc = self.__mgr.VTableRelease( self.__ptr ) 1157 if rc != 0 : 1158 self.__mgr.raise_rc( rc, "VTableRelease( %s )"%( self.__name ), self ) 1159 if self.__kdb_ptr != None : 1160 rc = self.__mgr.KTableRelease( self.__kdb_ptr ) 1161 if rc != 0 : 1162 self.__mgr.raise_rc( rc, "KTableRelease( %s )"%( self.__name ), self ) 1163 1164 def __enter__( self ) : 1165 return self 1166 1167 def __exit__( self, type, value, traceback ) : 1168 pass 1169 1170 def Name( self ) : 1171 return self.__name 1172 1173 def ListCol( self ) : 1174 l = c_void_p() 1175 rc = self.__mgr.VTableListCol( self.__ptr, byref( l ) ) 1176 if rc != 0 : 1177 self.__mgr.raise_rc( rc, "VTableListCol( %s )"%( self.__name ), self ) 1178 return KNamelist( self.__mgr, l ).to_list() 1179 1180 def __OpenKTableRead__( self ) : 1181 k_table = c_void_p() 1182 rc = self.__mgr.VTableOpenKTableRead( self.__ptr, byref( k_table ) ) 1183 if rc != 0 : 1184 self.__mgr.raise_rc( rc, "VTableOpenKTableRead( '%s' )"%( self.__name ), self ) 1185 self.__kdb_ptr = k_table 1186 1187 def __OpenKTableUpdate__( self ) : 1188 k_table = c_void_p() 1189 rc = self.__mgr.VTableOpenKTableUpdate( self.__ptr, byref( k_table ) ) 1190 if rc != 0 : 1191 self.__mgr.raise_rc( rc, "VTableOpenKTableUpdate( '%s' )"%( self.__name ), self ) 1192 self.__kdb_ptr = k_table 1193 1194 def ListIdx( self ) : 1195 if self.__kdb_ptr == None : 1196 self.__OpenKTableRead__() 1197 l = c_void_p() 1198 rc = self.__mgr.KTableListIdx( self.__kdb_ptr, byref( l ) ) 1199 if rc == 0 : 1200 return KNamelist( self.__mgr, l ).to_list() 1201 return [] 1202 1203 def OpenIndexRead( self, name ) : 1204 if self.__kdb_ptr == None : 1205 self.__OpenKTableUpdate__() 1206 k_idx = c_void_p() 1207 rc = self.__mgr.KTableOpenIndexRead( self.__kdb_ptr, byref( k_idx ), to_char_p( name ) ) 1208 if rc != 0 : 1209 self.__mgr.raise_rc( rc, "KTableOpenIndexRead( '%s' )"%( self.__name ), self ) 1210 return KIndex( self.__mgr, k_idx, name ) 1211 1212 def CreateIndex( self, name, idx_type = IndexType.Text, create_mode = CreateMode.Init ) : 1213 if self.__kdb_ptr == None : 1214 self.__OpenKTableUpdate__() 1215 k_idx = c_void_p() 1216 rc = self.__mgr.KTableCreateIndex( self.__kdb_ptr, byref( k_idx ), c_int( idx_type.value ), c_int( create_mode.value ), to_char_p( name ) ) 1217 if rc != 0 : 1218 self.__mgr.raise_rc( rc, "KTableCreateIndex( '%s' )"%( self.__name ), self ) 1219 return KIndex( self.__mgr, k_idx, name ) 1220 1221 def OpenMetadata( self, open_mode = OpenMode.Read ) : 1222 k_meta = c_void_p() 1223 if open_mode == OpenMode.Write : 1224 rc = self.__mgr.VTableOpenMetadataUpdate(self.__ptr, byref(k_meta)) 1225 if rc != 0 : 1226 self.__mgr.raise_rc( rc, "VTableOpenMetadataUpdate( '%s' )"%( self.__name ), self ) 1227 else : 1228 if self.__kdb_ptr == None : 1229 self.__OpenKTableRead__() 1230 rc = self.__mgr.KTableOpenMetadataRead( self.__kdb_ptr, byref( k_meta ) ) 1231 if rc != 0 : 1232 self.__mgr.raise_rc( rc, "KTableOpenMetadataRead( '%s' )"%( self.__name ), self ) 1233 return KMetadata( self.__mgr, k_meta ) 1234 1235 def CreateCursor( self, open_mode = OpenMode.Read, ins_mode = CursorMode.Insert ) : 1236 c = c_void_p() 1237 if open_mode == OpenMode.Write : 1238 rc = self.__mgr.VTableCreateCursorWrite( self.__ptr, byref( c ), c_int( ins_mode.value ) ) 1239 if rc != 0 : 1240 self.__mgr.raise_rc( rc, "VTableCreateCursorWrite( %s )"%( self.__name ), self ) 1241 else : 1242 rc = self.__mgr.VTableCreateCursorRead( self.__ptr, byref( c ) ) 1243 if rc != 0 : 1244 self.__mgr.raise_rc( rc, "VTableCreateCursorRead( %s )"%( self.__name ), self ) 1245 return VCursor( self, c ) 1246 1247 def CreateCachedCursorRead( self, cache_size ) : 1248 c = c_void_p() 1249 rc = self.__mgr.VTableCreateCachedCursorRead( self.__ptr, byref( c ), c_longlong( cache_size ) ) 1250 if rc != 0 : 1251 self.__mgr.raise_rc( rc, "VTableCreateCachedCursorRead( %s, %d )"%( self.__name, cache_size ), self ) 1252 return VCursor( self, c ) 1253 1254 def Locked( self ) : 1255 return self.__mgr.VTableLocked( self.__ptr ) 1256 1257 def ReferenceList( self, options = 2 ) : 1258 ptr = c_void_p() 1259 rc = self.__mgr.ReferenceList_MakeTable( byref( ptr ), self.__ptr, c_int( options ), c_int( 0 ), c_char_p( 0 ), c_int( 0 ) ) 1260 if rc != 0 : 1261 self.__mgr.raise_rc( rc, "ReferenceList_MakeTable( '%s' )"%( self.__name ), self ) 1262 return ReferenceList( self.__mgr, ptr ) 1263 1264 def print_rows( self, colrange = None, colnames = None, prefix = "" ) : 1265 if self.p_cur == None : 1266 self.p_cur = self.CreateCursor() 1267 if self.p_cur != None : 1268 if self.p_cols == None : 1269 if colnames == None : 1270 self.p_cols = self.p_cur.OpenColumns( self.ListCol() ) 1271 else : 1272 self.p_cols = self.p_cur.OpenColumns( colnames ) 1273 elif colnames != None : 1274 more_to_open = 0 1275 for name in colnames : 1276 if self.p_cols[ name ] == None : 1277 more_to_open += 1 1278 if more_to_open > 0 : 1279 self.p_cur = None 1280 self.p_cols = None 1281 self.p_cur = self.CreateCursor() 1282 if self.p_cur != None : 1283 self.p_cols = self.p_cur.OpenColumns( colnames ) 1284 if self.p_cols != None : 1285 print_cols( self.p_cols, colrange, colnames, prefix ) 1286 1287 1288#------------------------------------------------------------------------------------------------------------ 1289class VDatabase : 1290 def __init__( self, mgr, ptr, name ) : 1291 self.__mgr = mgr 1292 self.__ptr = ptr 1293 self.__name = name 1294 1295 def __del__( self ) : 1296 rc = self.__mgr.VDatabaseRelease( self.__ptr ) 1297 if rc != 0 : 1298 self.__mgr.raise_rc( rc, "VDatabaseRelease( %s )"%( self.__name ), self ) 1299 1300 def __enter__( self ) : 1301 return self 1302 1303 def __exit__( self, type, value, traceback ) : 1304 pass 1305 1306 def Name( self ) : 1307 return self.__name 1308 1309 def ListTbl( self ) : 1310 l = c_void_p() 1311 rc = self.__mgr.VDatabaseListTbl( self.__ptr, byref( l ) ) 1312 if rc != 0 : 1313 self.__mgr.raise_rc( rc, "VDatabaseListTbl( %s )"%( self.__name ), self ) 1314 return KNamelist( self.__mgr, l ).to_list() 1315 1316 def ListDB( self ) : 1317 l = c_void_p() 1318 rc = self.__mgr.VDatabaseListDB( self.__ptr, byref( l ) ) 1319 if rc != 0 : 1320 self.__mgr.raise_rc( rc, "VDatabaseListDB( %s )"%( self.__name ), self ) 1321 return KNamelist( self.__mgr, l ).to_list() 1322 1323 def OpenTable( self, name, mode = OpenMode.Read ) : 1324 f = self.__mgr.VDatabaseOpenTableUpdate if mode == OpenMode.Write else self.__mgr.VDatabaseOpenTableRead 1325 tab = c_void_p() 1326 rc = f( self.__ptr, byref( tab ), to_char_p( name ) ) 1327 if rc != 0 : 1328 self.__mgr.raise_rc( rc, "VDatabaseOpenTable( %s.%s )"%( self.__name, name ), self ) 1329 return VTable( self.__mgr, tab, name ) 1330 1331 def OpenDB( self, name, mode = OpenMode.Read ) : 1332 f = self.__mgr.VDatabaseOpenDBUpdate if mode == OpenMode.Write else self.__mgr.VDatabaseOpenDBRead 1333 db = c_void_p() 1334 rc = f( self.__ptr, byref( db ), to_char_p( name ) ) 1335 if rc != 0 : 1336 self.__mgr.raise_rc( rc, "VDatabaseOpenDB( %s.%s )"%( self.__name, name ), self ) 1337 return VDatabase( self.__mgr, db, name ) 1338 1339 def CreateTable( self, spec, name = None, mode = CreateMode.Init ) : 1340 tab = c_void_p() 1341 p = to_char_p( name if name != None else spec ) 1342 rc = self.__mgr.VDatabaseCreateTable( self.__ptr, byref( tab ), to_char_p( spec ), c_int( mode.value ), p ) 1343 if rc != 0 : 1344 self.__mgr.raise_rc( rc, "VDatabaseCreateTable( %s.%s )"%( self.__name, spec ), self ) 1345 return VTable( self.__mgr, tab, p.value ) 1346 1347 def CreateDB( self, spec, name = None, mode = CreateMode.Init ) : 1348 new_db = c_void_p() 1349 p = to_char_p( name if name != None else spec ) 1350 rc = self.__mgr.VDatabaseCreateDB( self.__ptr, byref( new_db ), to_char_p( spec ), c_int( mode.value ), p ) 1351 if rc != 0 : 1352 self.__mgr.raise_rc( rc, "VDatabaseCreateDB( %s.%s )"%( self.__name, spec ), self ) 1353 return VDatabase( self.__mgr, new_db, p.value ) 1354 1355 def DropTable( self, name ) : 1356 rc = self.__mgr.VDatabaseDropTable( self.__ptr, to_char_p( name ) ) 1357 if rc != 0 : 1358 self.__mgr.raise_rc( rc, "VDatabaseDropTable( %s.%s )"%( self.__name, name ), self ) 1359 1360 def DropDB( self, name ) : 1361 rc = self.__mgr.VDatabaseDropDB( self.__ptr, to_char_p( name ) ) 1362 if rc != 0 : 1363 self.__mgr.raise_rc( rc, "VDatabaseDropDB( %s.%s )"%( self.__name, name ), self ) 1364 1365 def Lock( self, name, what ) : 1366 rc = self.__mgr.VDatabaseLock( self.__ptr, c_int( what ), to_char_p( name ) ) 1367 if rc != 0 : 1368 self.__mgr.raise_rc( rc, "VDatabaseLock( %s.%s )"%( self.__name, name ), self ) 1369 1370 def UnLock( self, name, what ) : 1371 rc = self.__mgr.VDatabaseUnlock( self.__ptr, c_int( what ), to_char_p( name ) ) 1372 if rc != 0 : 1373 self.__mgr.raise_rc( rc, "VDatabaseUnlock( %s.%s )"%( self.__name, name ), self ) 1374 1375 def Locked( self ) : 1376 return self.__mgr.VDatabaseLocked( self.__ptr ) 1377 1378 def ReferenceList( self, options = 2 ) : 1379 ptr = c_void_p() 1380 rc = self.__mgr.ReferenceList_MakeDatabase( byref( ptr ), self.__ptr, c_int( options ), c_int( 0 ), c_char_p( 0 ), c_int( 0 ) ) 1381 if rc != 0 : 1382 self.__mgr.raise_rc( rc, "ReferenceList_MakeDatabase( %s )"%( self.__name ), self ) 1383 return ReferenceList( self.__mgr, ptr ) 1384 1385 1386#------------------------------------------------------------------------------------------------------------ 1387class VSchema : 1388 def __init__( self, mgr, ptr ) : 1389 self.__mgr = mgr 1390 self.__ptr = ptr 1391 1392 def __del__( self ) : 1393 rc = self.__mgr.VSchemaRelease( self.__ptr ) 1394 if rc != 0 : 1395 self.__mgr.raise_rc( rc, "VSchemaRelease()", self ) 1396 1397 def __enter__( self ) : 1398 return self 1399 1400 def __exit__( self, type, value, traceback ) : 1401 pass 1402 1403 def ParseText( self, schema_txt ) : 1404 txt = to_char_p( schema_txt ) 1405 l = len( schema_txt ) 1406 rc = self.__mgr.VSchemaParseText( self.__ptr, c_char_p( 0 ), txt, c_int( l ) ) 1407 if rc != 0 : 1408 self.__mgr.raise_rc( rc, "VSchemaParseText()", self ) 1409 1410 def ParseFile( self, schema_file ) : 1411 rc = self.__mgr.VSchemaParseFile( self.__ptr, to_char_p( schema_file ) ) 1412 if rc != 0 : 1413 self.mgr.raise_rc( rc, "VSchemaParseFile( '%s' )"%schema_file, self ) 1414 1415 def AddIncludePath( self, path ) : 1416 rc = self.__mgr.VSchemaAddIncludePath( self.__ptr, to_char_p( path ) ) 1417 if rc != 0 : 1418 self.__mgr.raise_rc( rc, "VSchemaAddIncludePath( '%s' )"%path, self ) 1419 1420 1421#------------------------------------------------------------------------------------------------------------ 1422class KRepository : 1423 def __init__( self, mgr, ptr ) : 1424 self.__mgr = mgr 1425 self.__ptr = ptr 1426 1427 def __del__( self ) : 1428 rc = self.__mgr.KRepositoryRelease( self.__ptr ) 1429 if rc != 0 : 1430 self.__mgr.raise_rc( rc, "KRepositoryRelease()", self ) 1431 1432 def __enter__( self ) : 1433 return self 1434 1435 def __exit__( self, type, value, traceback ) : 1436 pass 1437 1438 def __str__( self ) : 1439 lst = [ "'%s'"%( self.Name() ) ] 1440 lst.append( "%s"%( RepoCat( self.Category() ) ) ) 1441 lst.append( "%s"%( RepoSubCat( self.SubCategory() ) ) ) 1442 lst.append( "display: %s"%( self.DisplayName() ) ) 1443 lst.append( "root: %s"%( self.Root() ) ) 1444 lst.append( "resolver: %s"%( self.Resolver() ) ) 1445 lst.append( "disabled: %r"%( self.Disabled() ) ) 1446 lst.append( "cached: %r"%( self.CacheEnabled() ) ) 1447 return ", ".join( lst ) 1448 1449 def AddRef ( self ) : 1450 rc = self.__mgr.KRepositoryAddRef( self.__ptr ) 1451 if rc != 0 : 1452 self.__mgr.raise_rc( rc, "KRepositoryAddRef()", self ) 1453 1454 def Category( self ) : 1455 res = self.__mgr.KRepositoryCategory( self.__ptr ) 1456 return res; 1457 1458 def SubCategory( self ) : 1459 return self.__mgr.KRepositorySubCategory( self.__ptr ) 1460 1461 def Name( self ) : 1462 p = create_string_buffer( 1024 ) 1463 n = c_int( 0 ) 1464 rc = self.__mgr.KRepositoryName( self.__ptr, p, sizeof( p ), byref( n ) ) 1465 if rc != 0 : 1466 self.__mgr.raise_rc( rc, "KRepositoryName()", self ) 1467 if PY3 : 1468 return p.value.decode( "utf-8" ) 1469 return p.value 1470 1471 def DisplayName( self ) : 1472 p = create_string_buffer( 1024 ) 1473 n = c_int( 0 ) 1474 rc = self.__mgr.KRepositoryDisplayName( self.__ptr, p, sizeof( p ), byref( n ) ) 1475 if rc != 0 : 1476 self.__mgr.raise_rc( rc, "KRepositoryDisplayName()", self ) 1477 if PY3 : 1478 return p.value.decode( "utf-8" ) 1479 return p.value 1480 1481 def Root( self ) : 1482 p = create_string_buffer( 1024 ) 1483 n = c_int( 0 ) 1484 rc = self.__mgr.KRepositoryRoot( self.__ptr, p, sizeof( p ), byref( n ) ) 1485 if rc != 0 : 1486 return "" 1487 if PY3 : 1488 return p.value.decode( "utf-8" ) 1489 return p.value 1490 1491 def SetRoot( self, root ) : 1492 rc = self.__mgr.KRepositorySetRoot( self.__ptr, to_char_p( root ), c_int( len( root ) ) ) 1493 if rc != 0 : 1494 self.__mgr.raise_rc( rc, "KRepositorySetRoot( '%s' )"%( root ), self ) 1495 1496 def Resolver( self ) : 1497 p = create_string_buffer( 1024 ) 1498 n = c_int( 0 ) 1499 rc = self.__mgr.KRepositoryResolver( self.__ptr, p, sizeof( p ), byref( n ) ) 1500 if rc != 0 : 1501 return "" 1502 if PY3 : 1503 return p.value.decode( "utf-8" ) 1504 return p.value 1505 1506 def Disabled( self ) : 1507 return self.__mgr.KRepositoryDisabled( self.__ptr ) 1508 1509 def SetDisabled( self, value ) : 1510 rc = self.__mgr.KRepositorySetDisabled( self.__ptr, c_bool( value ) ) 1511 if rc != 0 : 1512 self.__mgr.raise_rc( rc, "KRepositorySetDisabled()", self ) 1513 1514 def CacheEnabled( self ) : 1515 return self.__mgr.KRepositoryCacheEnabled( self.__ptr ) 1516 1517 1518#------------------------------------------------------------------------------------------------------------ 1519class KRepositoryMgr : 1520 def __init__( self, mgr, ptr ) : 1521 self.__mgr = mgr 1522 self.__ptr = ptr 1523 1524 def __del__( self ) : 1525 rc = self.__mgr.KRepositoryMgrRelease( self.__ptr ) 1526 if rc != 0 : 1527 self.__mgr.raise_rc( rc, "KRepositoryMgrRelease()", self ) 1528 1529 def __enter__( self ) : 1530 return self 1531 1532 def __exit__( self, type, value, traceback ) : 1533 pass 1534 1535 def HasRemoteAccess( self ) : 1536 return self.__mgr.KRepositoryMgrHasRemoteAccess( self.__ptr ); 1537 1538 def __vector_2_list__( self, v ) : 1539 res = list() 1540 for i in xrange( v.start, v.start + v.len ) : 1541 r = KRepository( self.__mgr, self.__mgr.VectorGet( byref( v ), c_int( i ) ) ) 1542 r.AddRef() 1543 res.append( r ) 1544 self.__mgr.KRepositoryVectorWhack( byref( v ) ) 1545 return res 1546 1547 def UserRepositories( self ) : 1548 v = vdb_vector() 1549 rc = self.__mgr.KRepositoryMgrUserRepositories( self.__ptr, byref( v ) ) 1550 if rc != 0 : 1551 self.__mgr.raise_rc( rc, "KRepositoryMgrUserRepositories()", self ) 1552 return self.__vector_2_list__( v ) 1553 1554 def SiteRepositories( self ) : 1555 v = vdb_vector() 1556 rc = self.__mgr.KRepositoryMgrSiteRepositories( self.__ptr, byref( v ) ) 1557 if rc != 0 : 1558 self.__mgr.raise_rc( rc, "KRepositoryMgrSiteRepositories()", self ) 1559 return self.__vector_2_list__( v ) 1560 1561 def RemoteRepositories( self ) : 1562 v = vdb_vector() 1563 rc = self.__mgr.KRepositoryMgrRemoteRepositories( self.__ptr, byref( v ) ) 1564 if rc != 0 : 1565 self.__mgr.raise_rc( rc, "KRepositoryMgrRemoteRepositories()", self ) 1566 return self.__vector_2_list__( v ) 1567 1568 def CategoryDisabled( self, cat ) : 1569 return self.__mgr.KRepositoryMgrCategoryDisabled( self.__ptr, c_int( cat ) ) 1570 1571 def CategorySetDisabled( self, cat, value ) : 1572 return self.__mgr.KRepositoryMgrCategorySetDisabled( self.__ptr, c_int( cat ), c_bool( value ) ) 1573 1574 def AllRepos( self ) : 1575 return [ self.UserRepositories(), self.SiteRepositories(), self.RemoteRepositories() ] 1576 1577#------------------------------------------------------------------------------------------------------------ 1578class KConfig : 1579 def __init__( self, mgr, ptr ) : 1580 self.__mgr = mgr 1581 self.__ptr = ptr 1582 1583 def __del__( self ) : 1584 rc = self.__mgr.KConfigRelease( self.__ptr ) 1585 if rc != 0 : 1586 self.__mgr.raise_rc( rc, "KConfigRelease()", self ) 1587 1588 def __enter__( self ) : 1589 return self 1590 1591 def __exit__( self, type, value, traceback ) : 1592 pass 1593 1594 def Commit( self ) : 1595 rc = self.__mgr.KConfigCommit( self.__ptr ) 1596 if rc != 0 : 1597 self.__mgr.raise_rc( rc, "KConfigCommit()", self ) 1598 return rc 1599 1600 def ReadBool( self, path ) : 1601 value = c_bool() 1602 rc = self.__mgr.KConfigReadBool( self.__ptr, to_char_p( path ), byref( value ) ) 1603 if rc != 0 : 1604 self.__mgr.raise_rc( rc, "KConfigReadBool( '%s' )"%( path ), self ) 1605 return value.value 1606 1607 def WriteBool( self, path, value ) : 1608 rc = self.__mgr.KConfigWriteBool( self.__ptr, to_char_p( path ), c_bool( value ) ) 1609 if rc != 0 : 1610 self.__mgr.raise_rc( rc, "KConfigWriteBool( '%s', %s )"%( path, value ), self ) 1611 return rc 1612 1613 def ReadString( self, path ) : 1614 s = vdb_string( None, 0, 0 ) 1615 sp = pointer( s ) 1616 rc = self.__mgr.KConfigReadString( self.__ptr, to_char_p( path ), byref( sp ) ) 1617 if rc != 0 : 1618 self.__mgr.raise_rc( rc, "KConfigReadString( '%s' )"%( path ), self ) 1619 res = sp.contents.addr 1620 self.__mgr.string_whack( sp.contents ) 1621 return res 1622 1623 def WriteString( self, path, value ) : 1624 rc = self.__mgr.KConfigWriteString( self.__ptr, to_char_p( path ), to_char_p( value ) ) 1625 if rc != 0 : 1626 self.__mgr.raise_rc( rc, "KConfigWriteString( '%s', '%s' )"%( path, value ), self ) 1627 return rc 1628 1629 def ReadI64( self, path ) : 1630 value = c_longlong() 1631 rc = self.__mgr.KConfigReadI64( self.__ptr, to_char_p( path ), byref( value ) ) 1632 if rc != 0 : 1633 self.__mgr.raise_rc( rc, "KConfigReadI64( '%s' )"%( path ), self ) 1634 return value.value 1635 1636 def ReadU64( self, path ) : 1637 value = c_ulonglong() 1638 rc = self.__mgr.KConfigReadU64( self.__ptr, to_char_p( path ), byref( value ) ) 1639 if rc != 0 : 1640 self.__mgr.raise_rc( rc, "KConfigReadU64( '%s' )"%( path ), self ) 1641 return value.value 1642 1643 def ReadF64( self, path ) : 1644 value = c_double() 1645 rc = self.__mgr.KConfigReadF64( self.__ptr, to_char_p( path ), byref( value ) ) 1646 if rc != 0 : 1647 self.__mgr.raise_rc( rc, "KConfigReadF64( '%s' )"%( path ), self ) 1648 return value.value 1649 1650 def DisableUserSettings( self ) : 1651 rc = self.__mgr.KConfigDisableUserSettings( self.__ptr ) 1652 if rc != 0 : 1653 self.__mgr.raise_rc( rc, "KConfigDisableUserSettings()", self ) 1654 return value.value 1655 1656 def MakeRepositoryMgr( self, mode = OpenMode.Read ) : 1657 ptr = c_void_p() 1658 rc = 0 1659 if mode == OpenMode.Read : 1660 rc = self.__mgr.KConfigMakeRepositoryMgrRead( self.__ptr, byref( ptr ) ) 1661 if rc != 0 : 1662 self.__mgr.raise_rc( rc, "KConfigMakeRepositoryMgrRead()", self ) 1663 else : 1664 rc = self.__mgr.KConfigMakeRepositoryMgrUpdate( self.__ptr, byref( ptr ) ) 1665 if rc != 0 : 1666 self.__mgr.raise_rc( rc, "KConfigMakeRepositoryMgrUpdate()", self ) 1667 return KRepositoryMgr( self.__mgr, ptr ) 1668 1669 1670#------------------------------------------------------------------------------------------------------------ 1671class VPath : 1672 def __init__( self, mgr, ptr ) : 1673 self.mgr = __mgr 1674 self.ptr = __ptr 1675 1676 def __str__( self ) : 1677 if self.__ptr : 1678 s = vdb_string( None, 0, 0 ) 1679 sp = pointer( s ) 1680 rc = VPathMakeString( self.__ptr, byref( sp ) ) 1681 if rc != 0 : 1682 self.__mgr.raise_rc( rc, "VPathMakeString()", self ) 1683 res = sp.contents.addr 1684 self.__mgr.string_whack( sp.contents ) 1685 else : 1686 res = "" 1687 return res 1688 1689 1690#------------------------------------------------------------------------------------------------------------ 1691class VResolver : 1692 def __init__( self, mgr, ptr ) : 1693 self.__mgr = mgr 1694 self.__ptr = ptr 1695 1696 def __del__( self ) : 1697 rc = self.__mgr.VResolverRelease( self.__ptr ) 1698 if rc != 0 : 1699 self.__mgr.raise_rc( rc, "VResolverRelease()", self ) 1700 1701 def __enter__( self ) : 1702 return self 1703 1704 def __exit__( self, type, value, traceback ) : 1705 pass 1706 1707 def QueryLocal( self, path ) : 1708 loc = c_void_p() 1709 rc = self.__mgr.VResolverQuery( self.__ptr, c_int( 0 ), path.__ptr, byref( loc ), 0, 0 ) 1710 if rc != 0 : 1711 return vpath( self.__mgr, 0 ) 1712 return vpath( self.__mgr, loc ) 1713 1714 def QueryRemote( self, path, remote_prot = RemoteProto.Http ) : 1715 rem = c_void_p() 1716 rc = self.__mgr.fVResolverQuery( self.__ptr, c_int( remote_prot ), path.__ptr, 0, byref( rem ), 0 ) 1717 if rc != 0 : 1718 return vpath( self.__mgr, 0 ) 1719 return vpath( self.__mgr, rem ) 1720 1721 def QueryCache( self, path ) : 1722 cache = c_void_p() 1723 rc = self.__mgr.VResolverQuery( self.__ptr, c_int( 0 ), path.__ptr, 0, 0, byref( cache ) ) 1724 if rc != 0 : 1725 return vpath( self.__mgr, 0 ) 1726 return vpath( self.__mgr, cache ) 1727 1728 def RemoteEnable( self, state = ResolvEnable.UseConfig ) : 1729 rc = self.__mgr.VResolverRemoteEnable( self.__ptr, c_int( state ) ) 1730 if rc != 0 : 1731 self.__mgr.raise_rc( rc, "VResolverRemoteEnable()", self ) 1732 1733 1734#------------------------------------------------------------------------------------------------------------ 1735class VFSManager : 1736 def __init__( self, mgr, ptr ) : 1737 self.__mgr = mgr 1738 self.__ptr = ptr 1739 1740 def __del__( self ) : 1741 rc = self.__mgr.VFSManagerRelease( self.__ptr ) 1742 if rc != 0 : 1743 self.__mgr.raise_rc( rc, "VFSManagerRelease()", self ) 1744 1745 def __enter__( self ) : 1746 return self 1747 1748 def __exit__( self, type, value, traceback ) : 1749 pass 1750 1751 def GetResolver( self ) : 1752 ptr = c_void_p() 1753 rc = self.__mgr.VFSManagerGetResolver( self.__ptr, byref( ptr ) ) 1754 if rc != 0 : 1755 self.__mgr.raise_rc( rc, "VFSManagerGetResolver()", self ) 1756 return VResolver( self.__mgr, ptr ) 1757 1758 def MakeResolver( self, cfg ) : 1759 ptr = c_void_p() 1760 rc = self.__mgr.VFSManagerMakeResolver( self.__ptr, byref( ptr ), cfg.__ptr ) 1761 if rc != 0 : 1762 self.__mgr.raise_rc( rc, "VFSManagerMakeResolver()", self ) 1763 return VResolver( self.__mgr, ptr ) 1764 1765 def MakePath( self, s_path ) : 1766 path = c_void_p() 1767 rc = self.__mgr.VFSManagerMakePath( self.__ptr, byref( path ), to_char_p( s_path ) ) 1768 if rc != 0 : 1769 self.__mgr.raise_rc( rc, "VFSManagerMakePath( '%s' )"%( s_paht ), self ) 1770 return VPath( self.__mgr, path ) 1771 1772 1773#------------------------------------------------------------------------------------------------------------ 1774class RefVariation : 1775 def __init__( self, mgr, ptr ) : 1776 self.__mgr = mgr 1777 self.__ptr = ptr 1778 1779 def __del__( self ) : 1780 rc = self.__mgr.RefVariationRelease( self.__ptr ) 1781 if rc != 0 : 1782 self.__mgr.raise_rc( rc, "RefVariationRelease()", self ) 1783 1784 def __enter__( self ) : 1785 return self 1786 1787 def __exit__( self, type, value, traceback ) : 1788 pass 1789 1790 def GetIUPACSearchQuery( self ) : 1791 txt = c_char_p() 1792 len = c_int() 1793 start = c_int() 1794 rc = self.__mgr.RefVariationGetIUPACSearchQuery( self.__ptr, byref( txt ), byref( len ), byref( start ) ) 1795 if rc != 0 : 1796 self.__mgr.raise_rc( rc, "RefVariationGetIUPACSearchQuery()", self ) 1797 return ( txt.value, len.value, start.value ) 1798 1799 def GetSearchQueryLenOnRef( self ) : 1800 len = c_int() 1801 rc = self.__mgr.RefVariationGetSearchQueryLenOnRef( self.__ptr, byref( len ) ) 1802 if rc != 0 : 1803 self.__mgr.raise_rc( rc, "RefVariationGetSearchQueryLenOnRef()", self ) 1804 return len.value 1805 1806 def GetAllele( self ) : 1807 txt = c_char_p() 1808 len = c_int() 1809 start = c_int() 1810 rc = self.__mgr.RefVariationGetAllele( self.__ptr, byref( txt ), byref( len ), byref( start ) ) 1811 if rc != 0 : 1812 self.__mgr.raise_rc( rc, "RefVariationGetAllele()", self ) 1813 return ( txt.value, len.value, start.value ) 1814 1815 def GetAlleleLenOnRef( self ) : 1816 len = c_int() 1817 rc = self.__mgr.RefVariationGetAlleleLenOnRef( self.__ptr, byref( len ) ) 1818 if rc != 0 : 1819 self.__mgr.raise_rc( rc, "RefVariationGetAlleleLenOnRef()", self ) 1820 return len.value 1821 1822 1823#------------------------------------------------------------------------------------------------------------ 1824def make_lib_name( mode, prefix = None ) : 1825 libname = None 1826 if platform.system() == "Windows": 1827 libname = "ncbi-wvdb.dll" if mode == OpenMode.Write else "ncbi-vdb.dll" 1828 elif platform.system() == "Darwin": 1829 libname = "libncbi-wvdb.dylib" if mode == OpenMode.Write else "libncbi-vdb.dylib" 1830 elif platform.system() == "Linux" : 1831 libname = "libncbi-wvdb.so" if mode == OpenMode.Write else "libncbi-vdb.so" 1832 if libname == None : 1833 return None 1834 if prefix != None : 1835 return os.path.join( os.path.sep, prefix, libname ) 1836 return libname 1837 1838def check_lib_path( mode, path ) : 1839 res = None 1840 if path != None : 1841 if not os.path.isfile( path ) : 1842 raise vdb_error( 0, "lib '%s' does not exist"% path, None ) 1843 else : 1844 res = path 1845 else : 1846 res = make_lib_name( mode ) 1847 if res == None : 1848 raise vdb_error( 0, "cannot load lib: unknow platform", None ) 1849 else : 1850 if not os.path.isfile( res ) : 1851 home_ncbi_lib64 = os.path.join( os.path.sep, os.path.expanduser( "~" ), ".ncbi", "lib64" ) 1852 res = make_lib_name( mode, home_ncbi_lib64 ) 1853 if not os.path.isfile( res ) : 1854 raise vdb_error( 0, "cannot find lib: '%s'"%path, None ) 1855 return res 1856 1857 1858class manager : 1859 def __init__( self, mode = OpenMode.Read, path = None ) : 1860 self.__mode = mode 1861 self.__dir = None 1862 self.__ptr = None 1863 1864 p = check_lib_path( mode, path ) 1865 try : 1866 self.__lib = cdll.LoadLibrary( p ) 1867 except : 1868 raise vdb_error( 0, "cannot load library '%s'"%p, None ) 1869 1870 #we need this one first, because we need it to throw a vdb-error ( used in manager.explain() ) 1871 self.string_printf = self.__func__( "string_printf", [ c_void_p, c_int, c_void_p, c_char_p, c_int ] ) 1872 1873 self.KDirectoryNativeDir = self.__func__( "KDirectoryNativeDir_v1", [ c_void_p ] ) 1874 self.KDirectoryRelease = self.__func__( "KDirectoryRelease_v1", [ c_void_p ] ) 1875 1876 self.VDBManagerRelease = self.__func__( "VDBManagerRelease", [ c_void_p ] ) 1877 self.VDBManagerVersion = self.__func__( "VDBManagerVersion", [ c_void_p, c_void_p ] ) 1878 self.VDBManagerPathType = self.__func__( "VDBManagerPathType", [ c_void_p, c_char_p ] ) 1879 self.VDBManagerGetObjVersion = self.__func__( "VDBManagerGetObjVersion", [ c_void_p, c_void_p, c_char_p ] ) 1880 self.VDBManagerGetObjModDate = self.__func__( "VDBManagerGetObjModDate", [ c_void_p, c_void_p, c_char_p ] ) 1881 self.VDBManagerOpenDBRead = self.__func__( "VDBManagerOpenDBRead", [ c_void_p, c_void_p, c_void_p, c_char_p ] ) 1882 self.VDBManagerOpenTableRead = self.__func__( "VDBManagerOpenTableRead", [ c_void_p, c_void_p, c_void_p, c_char_p ] ) 1883 self.VDBManagerMakeSchema = self.__func__( "VDBManagerMakeSchema", [ c_void_p, c_void_p ] ) 1884 1885 self.VDatabaseOpenDBRead = self.__func__( "VDatabaseOpenDBRead", [ c_void_p, c_void_p, c_char_p ] ) 1886 self.VDatabaseRelease = self.__func__( "VDatabaseRelease", [ c_void_p ] ) 1887 self.VDatabaseOpenTableRead = self.__func__( "VDatabaseOpenTableRead", [ c_void_p, c_void_p, c_char_p ] ) 1888 self.VDatabaseListTbl = self.__func__( "VDatabaseListTbl", [ c_void_p, c_void_p ] ) 1889 self.VDatabaseListDB = self.__func__( "VDatabaseListDB", [ c_void_p, c_void_p ] ) 1890 self.VDatabaseLocked = self.__func__( "VDatabaseLocked", [ c_void_p ], c_bool ) 1891 1892 self.VTableRelease = self.__func__( "VTableRelease", [ c_void_p ] ) 1893 self.VTableListCol = self.__func__( "VTableListCol", [ c_void_p, c_void_p ] ) 1894 self.VTableCreateCursorRead = self.__func__( "VTableCreateCursorRead", [ c_void_p, c_void_p ] ) 1895 self.VTableCreateCachedCursorRead = self.__func__( "VTableCreateCachedCursorRead", [ c_void_p, c_void_p, c_longlong ] ) 1896 self.VTableLocked = self.__func__( "VTableLocked", [ c_void_p ], c_bool ) 1897 self.VTableOpenKTableRead = self.__func__( "VTableOpenKTableRead", [ c_void_p, c_void_p ] ) 1898 self.VTableOpenMetadataRead = self.__func__("VTableOpenMetadataRead", [ c_void_p, c_void_p ] ) 1899 self.VTableOpenMetadataUpdate = self.__func__("VTableOpenMetadataUpdate", [ c_void_p, c_void_p ] ) 1900 1901 self.KNamelistCount = self.__func__( "KNamelistCount", [ c_void_p, c_void_p ] ) 1902 self.KNamelistGet = self.__func__( "KNamelistGet", [ c_void_p, c_int, c_void_p ] ) 1903 self.KNamelistRelease = self.__func__( "KNamelistRelease", [ c_void_p ] ) 1904 1905 self.VSchemaRelease = self.__func__( "VSchemaRelease", [ c_void_p ] ) 1906 self.VSchemaParseText = self.__func__( "VSchemaParseText", [ c_void_p, c_char_p, c_char_p, c_int ] ) 1907 self.VSchemaParseFile = self.__func__( "VSchemaParseFile", [ c_void_p, c_char_p ] ) 1908 self.VSchemaAddIncludePath = self.__func__( "VSchemaAddIncludePath", [ c_void_p, c_char_p ] ) 1909 1910 self.VCursorRelease = self.__func__( "VCursorRelease", [ c_void_p ] ) 1911 self.VCursorAddColumn = self.__func__( "VCursorAddColumn", [ c_void_p, c_void_p, c_char_p ] ) 1912 self.VCursorOpen = self.__func__( "VCursorOpen", [ c_void_p ] ) 1913 self.VCursorDatatype = self.__func__( "VCursorDatatype", [ c_void_p, c_int, c_void_p, c_void_p ] ) 1914 self.VCursorCellDataDirect = self.__func__( "VCursorCellDataDirect", [ c_void_p, c_longlong, c_int, c_void_p, c_void_p, c_void_p, c_void_p ] ) 1915 self.VCursorCloseRow = self.__func__( "VCursorCloseRow", [ c_void_p ] ) 1916 self.VCursorIdRange = self.__func__( "VCursorIdRange", [ c_void_p, c_int, c_void_p, c_void_p ] ) 1917 self.VCursorRowId = self.__func__( "VCursorRowId", [ c_void_p, c_void_p ] ) 1918 self.VCursorSetRowId = self.__func__( "VCursorSetRowId", [ c_void_p, c_longlong ] ) 1919 self.VCursorOpenRow = self.__func__( "VCursorOpenRow", [ c_void_p ] ) 1920 self.VCursorFindNextRowIdDirect = self.__func__( "VCursorFindNextRowIdDirect", [ c_void_p, c_int, c_longlong, c_void_p ] ) 1921 1922 self.KTableRelease = self.__func__( "KTableRelease", [ c_void_p ] ) 1923 self.KTableListIdx = self.__func__( "KTableListIdx", [ c_void_p, c_void_p ] ) 1924 self.KTableOpenIndexRead = self.__func__( "KTableOpenIndexRead", [ c_void_p, c_void_p, c_char_p ] ) 1925 self.KTableOpenMetadataRead = self.__func__( "KTableOpenMetadataRead", [ c_void_p, c_void_p ] ) 1926 1927 self.KIndexRelease = self.__func__( "KIndexRelease", [ c_void_p ] ) 1928 self.KIndexVersion = self.__func__( "KIndexVersion", [ c_void_p, c_void_p ] ) 1929 self.KIndexType = self.__func__( "KIndexType", [ c_void_p, c_void_p ] ) 1930 self.KIndexLocked = self.__func__( "KIndexLocked", [ c_void_p ], c_bool ) 1931 self.KIndexFindText = self.__func__( "KIndexFindText", [ c_void_p, c_char_p, c_void_p, c_void_p, c_void_p, c_void_p ] ) 1932 self.KIndexProjectText = self.__func__( "KIndexProjectText", [ c_void_p, c_longlong, c_void_p, c_void_p, c_char_p, c_int, c_void_p ] ) 1933 1934 self.KMetadataRelease = self.__func__( "KMetadataRelease", [ c_void_p ] ) 1935 self.KMetadataVersion = self.__func__( "KMetadataVersion", [ c_void_p, c_void_p ] ) 1936 self.KMetadataByteOrder = self.__func__( "KMetadataByteOrder", [ c_void_p, c_void_p ] ) 1937 self.KMetadataRevision = self.__func__( "KMetadataRevision", [ c_void_p, c_void_p ] ) 1938 self.KMetadataMaxRevision = self.__func__( "KMetadataMaxRevision", [ c_void_p, c_void_p ] ) 1939 self.KMetadataOpenRevision = self.__func__( "KMetadataOpenRevision", [ c_void_p, c_void_p, c_int ] ) 1940 self.KMetadataGetSequence = self.__func__( "KMetadataGetSequence", [ c_void_p, c_char_p, c_void_p ] ) 1941 self.KMetadataOpenNodeRead = self.__func__( "KMetadataOpenNodeRead", [ c_void_p, c_void_p, c_char_p ] ) 1942 1943 self.KMDataNodeOpenNodeRead = self.__func__( "KMDataNodeOpenNodeRead", [ c_void_p, c_void_p, c_char_p ] ) 1944 self.KMDataNodeRelease = self.__func__( "KMDataNodeRelease", [ c_void_p ] ) 1945 self.KMDataNodeListAttr = self.__func__( "KMDataNodeListAttr", [ c_void_p ] ) 1946 self.KMDataNodeListChildren = self.__func__( "KMDataNodeListChildren", [ c_void_p ] ) 1947 self.KMDataNodeByteOrder = self.__func__( "KMDataNodeByteOrder", [ c_void_p, c_void_p ] ) 1948 self.KMDataNodeRead = self.__func__( "KMDataNodeRead", [ c_void_p, c_size_t, c_void_p, c_size_t, c_void_p, c_void_p ] ) 1949 1950 if mode == OpenMode.Write : 1951 self.VDBManagerMakeUpdate = self.__func__( "VDBManagerMakeUpdate", [ c_void_p, c_void_p ] ) 1952 self.VDBManagerCreateTable = self.__func__( "VDBManagerCreateTable", [ c_void_p, c_void_p, c_void_p, c_char_p, c_int, c_char_p ] ) 1953 self.VDBManagerCreateDB = self.__func__( "VDBManagerCreateDB", [ c_void_p, c_void_p, c_void_p, c_char_p, c_int, c_char_p ] ) 1954 self.VDBManagerOpenTableUpdate = self.__func__( "VDBManagerOpenTableUpdate", [ c_void_p, c_void_p, c_void_p, c_char_p ] ) 1955 self.VDBManagerOpenDBUpdate = self.__func__( "VDBManagerOpenDBUpdate", [ c_void_p, c_void_p, c_void_p, c_char_p ] ) 1956 1957 self.VTableCreateCursorWrite = self.__func__( "VTableCreateCursorWrite", [ c_void_p, c_void_p, c_int ] ) 1958 self.VTableOpenKTableUpdate = self.__func__( "VTableOpenKTableUpdate", [ c_void_p, c_void_p ] ) 1959 1960 self.VCursorCommitRow = self.__func__( "VCursorCommitRow", [ c_void_p ] ) 1961 self.VCursorRepeatRow = self.__func__( "VCursorRepeatRow", [ c_void_p, c_longlong ] ) 1962 self.VCursorFlushPage = self.__func__( "VCursorFlushPage", [ c_void_p ] ) 1963 self.VCursorCommit = self.__func__( "VCursorCommit", [ c_void_p ] ) 1964 self.VCursorWrite = self.__func__( "VCursorWrite", [ c_void_p, c_int, c_int, c_void_p, c_int, c_int ] ) 1965 self.VCursorDefault = self.__func__( "VCursorDefault", [ c_void_p, c_int, c_int, c_void_p, c_int, c_int ] ) 1966 1967 self.VDatabaseCreateDB = self.__func__( "VDatabaseCreateDB", [ c_void_p, c_void_p, c_char_p, c_int, c_char_p ] ) 1968 self.VDatabaseOpenTableUpdate = self.__func__( "VDatabaseOpenTableUpdate", [ c_void_p, c_void_p, c_char_p ] ) 1969 self.VDatabaseOpenDBUpdate = self.__func__( "VDatabaseOpenDBUpdate", [ c_void_p, c_void_p, c_char_p ] ) 1970 self.VDatabaseCreateTable = self.__func__( "VDatabaseCreateTable", [ c_void_p, c_void_p, c_char_p, c_int, c_char_p ] ) 1971 self.VDatabaseDropDB = self.__func__( "VDatabaseDropDB", [ c_void_p, c_char_p ] ) 1972 self.VDatabaseDropTable = self.__func__( "VDatabaseDropTable", [ c_void_p, c_char_p ] ) 1973 self.VDatabaseLock = self.__func__( "VDatabaseLock", [ c_void_p, c_int, c_char_p ] ) 1974 self.VDatabaseUnlock = self.__func__( "VDatabaseUnlock", [ c_void_p, c_int, c_char_p ] ) 1975 1976 self.KTableCreateIndex = self.__func__( "KTableCreateIndex", [ c_void_p, c_void_p, c_int, c_int, c_char_p ] ) 1977 self.KIndexCommit = self.__func__( "KIndexCommit", [ c_void_p ] ) 1978 self.KIndexInsertText = self.__func__( "KIndexInsertText", [ c_void_p, c_bool, c_char_p, c_longlong ] ) 1979 self.KIndexDeleteText = self.__func__( "KIndexDeleteText", [ c_void_p, c_char_p ] ) 1980 self.KIndexInsertU64 = self.__func__( "KIndexInsertU64", [ c_void_p, c_bool, c_longlong, c_longlong, c_longlong, c_longlong ] ) 1981 self.KIndexDeleteU64 = self.__func__( "KIndexDeleteU64", [ c_void_p, c_longlong ] ) 1982 1983 self.KTableOpenMetadataUpdate = self.__func__( "KTableOpenMetadataUpdate", [ c_void_p, c_void_p ] ) 1984 1985 self.KMetadataCommit = self.__func__( "KMetadataCommit", [ c_void_p ] ) 1986 self.KMetadataFreeze = self.__func__( "KMetadataFreeze", [ c_void_p ] ) 1987 self.KMetadataSetSequence = self.__func__( "KMetadataSetSequence", [ c_void_p, c_char_p, c_longlong ] ) 1988 self.KMetadataNextSequence = self.__func__( "KMetadataNextSequence", [ c_void_p, c_char_p, c_void_p ] ) 1989 self.KMetadataOpenNodeUpdate = self.__func__( "KMetadataOpenNodeUpdate", [ c_void_p, c_void_p, c_char_p ] ) 1990 1991 self.KMDataNodeOpenNodeUpdate = self.__func__( "KMDataNodeOpenNodeUpdate", [ c_void_p, c_void_p, c_char_p ] ) 1992 self.KMDataNodeWrite = self.__func__( "KMDataNodeWrite", [ c_void_p, c_void_p, c_size_t ] ) 1993 self.KMDataNodeAppend = self.__func__( "KMDataNodeAppend", [ c_void_p, c_void_p, c_size_t ] ) 1994 1995 else : 1996 self.VDBManagerMakeRead = self.__func__( "VDBManagerMakeRead", [ c_void_p, c_void_p ] ) 1997 1998 self.KConfigMake = self.__func__( "KConfigMake", [ c_void_p, c_void_p ] ) 1999 self.KConfigRelease = self.__func__( "KConfigRelease", [ c_void_p ] ) 2000 self.KConfigCommit = self.__func__( "KConfigCommit", [ c_void_p ] ) 2001 self.KConfigReadBool = self.__func__( "KConfigReadBool", [ c_void_p, c_char_p, c_void_p ] ) 2002 self.KConfigWriteBool = self.__func__( "KConfigWriteBool", [ c_void_p, c_char_p, c_bool ] ) 2003 self.KConfigReadString = self.__func__( "KConfigReadString", [ c_void_p, c_char_p, c_void_p ] ) 2004 self.KConfigWriteString = self.__func__( "KConfigWriteString", [ c_void_p, c_char_p, c_char_p ] ) 2005 self.KConfigReadI64 = self.__func__( "KConfigReadI64", [ c_void_p, c_char_p, c_void_p ] ) 2006 self.KConfigReadU64 = self.__func__( "KConfigReadU64", [ c_void_p, c_char_p, c_void_p ] ) 2007 self.KConfigReadF64 = self.__func__( "KConfigReadF64", [ c_void_p, c_char_p, c_void_p ] ) 2008 self.KConfigDisableUserSettings = self.__func__( "KConfigDisableUserSettings", [] ) 2009 self.KConfigMakeRepositoryMgrRead = self.__func__( "KConfigMakeRepositoryMgrRead", [ c_void_p, c_void_p ] ) 2010 self.KConfigMakeRepositoryMgrUpdate = self.__func__( "KConfigMakeRepositoryMgrUpdate", [ c_void_p, c_void_p ] ) 2011 2012 self.KRepositoryMgrRelease = self.__func__( "KRepositoryMgrRelease", [ c_void_p ] ) 2013 self.KRepositoryMgrHasRemoteAccess = self.__func__( "KRepositoryMgrHasRemoteAccess", [ c_void_p ], c_bool ) 2014 self.KRepositoryMgrUserRepositories = self.__func__( "KRepositoryMgrUserRepositories", [ c_void_p, c_void_p ] ) 2015 self.KRepositoryMgrSiteRepositories = self.__func__( "KRepositoryMgrSiteRepositories", [ c_void_p, c_void_p ] ) 2016 self.KRepositoryMgrRemoteRepositories = self.__func__( "KRepositoryMgrRemoteRepositories", [ c_void_p, c_void_p ] ) 2017 self.KRepositoryMgrCategoryDisabled = self.__func__( "KRepositoryMgrCategoryDisabled", [ c_void_p, c_int ], c_bool ) 2018 self.KRepositoryMgrCategorySetDisabled = self.__func__( "KRepositoryMgrCategorySetDisabled", [ c_void_p, c_int, c_bool ] ) 2019 self.KRepositoryVectorWhack = self.__func__( "KRepositoryVectorWhack", [ c_void_p ] ) 2020 self.KRepositoryAddRef = self.__func__( "KRepositoryAddRef", [ c_void_p ] ) 2021 self.KRepositoryRelease = self.__func__( "KRepositoryRelease", [ c_void_p ] ) 2022 self.KRepositoryCategory = self.__func__( "KRepositoryCategory", [ c_void_p ] ) 2023 self.KRepositorySubCategory = self.__func__( "KRepositorySubCategory", [ c_void_p ] ) 2024 self.KRepositoryName = self.__func__( "KRepositoryName", [ c_void_p, c_char_p, c_int, c_void_p ] ) 2025 self.KRepositoryDisplayName = self.__func__( "KRepositoryDisplayName", [ c_void_p, c_char_p, c_int, c_void_p ] ) 2026 self.KRepositoryRoot = self.__func__( "KRepositoryRoot", [ c_void_p, c_char_p, c_int, c_void_p ] ) 2027 self.KRepositorySetRoot = self.__func__( "KRepositorySetRoot", [ c_void_p, c_char_p, c_int ] ) 2028 self.KRepositoryResolver = self.__func__( "KRepositoryResolver", [ c_void_p, c_char_p, c_int, c_void_p ] ) 2029 self.KRepositoryDisabled = self.__func__( "KRepositoryDisabled", [ c_void_p ], c_bool ) 2030 self.KRepositorySetDisabled = self.__func__( "KRepositorySetDisabled", [ c_void_p, c_bool ] ) 2031 self.KRepositoryCacheEnabled = self.__func__( "KRepositoryCacheEnabled", [ c_void_p ], c_bool ) 2032 2033 self.VFSManagerMake = self.__func__( "VFSManagerMake", [ c_void_p ] ) 2034 self.VFSManagerRelease = self.__func__( "VFSManagerRelease", [ c_void_p ] ) 2035 self.VFSManagerGetResolver = self.__func__( "VFSManagerGetResolver", [ c_void_p, c_void_p ] ) 2036 self.VFSManagerMakeResolver = self.__func__( "VFSManagerMakeResolver", [ c_void_p, c_void_p, c_void_p ] ) 2037 self.VFSManagerMakePath = self.__func__( "VFSManagerMakePath", [ c_void_p, c_void_p, c_void_p ] ) 2038 2039 self.VResolverRelease = self.__func__( "VResolverRelease", [ c_void_p ] ) 2040 self.VResolverQuery = self.__func__( "VResolverQuery", [ c_void_p, c_int, c_void_p, c_void_p, c_void_p, c_void_p ] ) 2041 self.VResolverRemoteEnable = self.__func__( "VResolverRemoteEnable", [ c_void_p, c_int ] ) 2042 2043 self.RefVariationIUPACMake = self.__func__( "RefVariationIUPACMake", [ c_void_p, c_char_p, c_longlong, c_longlong, c_longlong, c_char_p, c_longlong, c_int ] ) 2044 self.RefVariationRelease = self.__func__( "RefVariationRelease", [ c_void_p ] ) 2045 self.RefVariationGetIUPACSearchQuery = self.__func__( "RefVariationGetIUPACSearchQuery", [ c_void_p, c_void_p, c_void_p, c_void_p ] ) 2046 self.RefVariationGetSearchQueryLenOnRef = self.__func__( "RefVariationGetSearchQueryLenOnRef", [ c_void_p, c_void_p ] ) 2047 self.RefVariationGetAllele = self.__func__( "RefVariationGetAllele", [ c_void_p, c_void_p, c_void_p, c_void_p ] ) 2048 self.RefVariationGetAlleleLenOnRef = self.__func__( "RefVariationGetAlleleLenOnRef", [ c_void_p, c_void_p ] ) 2049 2050 self.ReferenceList_MakeCursor = self.__func__( "ReferenceList_MakeCursor", [ c_void_p, c_void_p, c_int, c_char_p, c_int ] ) 2051 self.ReferenceList_MakeTable = self.__func__( "ReferenceList_MakeTable", [ c_void_p, c_void_p, c_int, c_int, c_char_p, c_int ] ) 2052 self.ReferenceList_MakeDatabase = self.__func__( "ReferenceList_MakeDatabase", [ c_void_p, c_void_p, c_int, c_int, c_char_p, c_int ] ) 2053 self.ReferenceList_MakePath = self.__func__( "ReferenceList_MakePath", [ c_void_p, c_void_p, c_char_p, c_int, c_int, c_char_p, c_int ] ) 2054 self.ReferenceList_Release = self.__func__( "ReferenceList_Release", [ c_void_p ] ) 2055 self.ReferenceList_Count = self.__func__( "ReferenceList_Count", [ c_void_p, c_void_p ] ) 2056 self.ReferenceList_Find = self.__func__( "ReferenceList_Find", [ c_void_p, c_void_p, c_char_p, c_int ] ) 2057 self.ReferenceList_Get = self.__func__( "ReferenceList_Get", [ c_void_p, c_void_p, c_int ] ) 2058 2059 self.ReferenceObj_Release = self.__func__( "ReferenceObj_Release", [ c_void_p ] ) 2060 self.ReferenceObj_Idx = self.__func__( "ReferenceObj_Idx", [ c_void_p, c_void_p ] ) 2061 self.ReferenceObj_IdRange = self.__func__( "ReferenceObj_IdRange", [ c_void_p, c_void_p, c_void_p ] ) 2062 self.ReferenceObj_Bin = self.__func__( "ReferenceObj_Bin", [ c_void_p, c_void_p ] ) 2063 self.ReferenceObj_SeqId = self.__func__( "ReferenceObj_SeqId", [ c_void_p, c_void_p ] ) 2064 self.ReferenceObj_Name = self.__func__( "ReferenceObj_Name", [ c_void_p, c_void_p ] ) 2065 self.ReferenceObj_SeqLength = self.__func__( "ReferenceObj_SeqLength", [ c_void_p, c_void_p ] ) 2066 self.ReferenceObj_Circular = self.__func__( "ReferenceObj_Circular", [ c_void_p, c_void_p ] ) 2067 self.ReferenceObj_External = self.__func__( "ReferenceObj_External", [ c_void_p, c_void_p, c_void_p ] ) 2068 self.ReferenceObj_Read = self.__func__( "ReferenceObj_Read", [ c_void_p, c_int, c_int, c_void_p, c_void_p ] ) 2069 self.ReferenceObj_GetIdCount = self.__func__( "ReferenceObj_GetIdCount", [ c_void_p, c_longlong, c_void_p ] ) 2070 2071 self.VPathMakeString = self.__func__( "VPathMakeString", [ c_void_p, c_void_p ] ) 2072 self.VectorGet = self.__func__( "VectorGet", [ c_void_p, c_int ], c_void_p ) 2073 self.StringWhack = self.__func__( "StringWhack", [ c_void_p ] ) 2074 2075 self.__dir = self.__make_native_dir__() 2076 self.__ptr = self.__make_mgr__( mode ) 2077 2078 2079 def __del__( self ) : 2080 if self.__ptr != None : 2081 if self.VDBManagerRelease != None : 2082 self.VDBManagerRelease( self.__ptr ) 2083 if self.__dir != None : 2084 if self.KDirectoryRelease != None : 2085 self.KDirectoryRelease( self.__dir ) 2086 2087 def __enter__( self ) : 2088 return self 2089 2090 def __exit__( self, type, value, traceback ) : 2091 pass 2092 2093 def string_whack( self, str ) : 2094 self.StringWhack( byref( str ) ) 2095 2096 def __make_native_dir__( self ) : 2097 res = c_void_p() 2098 if self.KDirectoryNativeDir == None : 2099 raise "'KDirectoryNativeDir' not found in lib" 2100 else : 2101 rc = self.KDirectoryNativeDir( byref( res ) ) 2102 if rc != 0 : 2103 self.raise_rc( rc, "KDirectoryNativeDir()", self ) 2104 return res; 2105 2106 def __make_mgr__( self, mode ) : 2107 res = c_void_p() 2108 if mode == OpenMode.Write : 2109 rc = self.VDBManagerMakeUpdate( byref( res ), self.__dir ) 2110 else : 2111 rc = self.VDBManagerMakeRead( byref( res ), self.__dir ) 2112 if rc != 0 : 2113 self.raise_rc( rc, "make_mgr()", self ) 2114 return res 2115 2116 def __func__( self, name, argt, rest = c_int ) : 2117 res = None 2118 try : 2119 res = getattr( self.__lib, name ) 2120 res.argtypes = argt 2121 res.restype = rest 2122 except : 2123 pass 2124 return res 2125 2126 def explain( self, rc ) : 2127 buffer = create_string_buffer( 1024 ) 2128 num_writ = c_int( 0 ) 2129 fmt = create_string_buffer( to_bytes( "%R" ) ) 2130 if self.string_printf( buffer, c_int( 1024 ), byref( num_writ ), fmt, c_int( rc ) ) == 0 : 2131 if PY3 : 2132 return buffer.value.decode( "utf-8" ) 2133 return buffer.value 2134 return "cannot explain %d"%( rc ) 2135 2136 def raise_rc( self, rc, funcname, obj ) : 2137 msg = "%s -> %s"%( funcname, self.explain( rc ) ) 2138 raise vdb_error( rc, msg, obj ) 2139 2140 def Version( self ) : 2141 vers = c_int( 0 ) 2142 rc = self.VDBManagerVersion( self.__ptr, byref( vers ) ) 2143 if rc != 0 : 2144 self.raise_rc( rc, "version()", self ) 2145 return version( vers.value ) 2146 2147 def writable( self ) : 2148 return self.__mode == OpenMode.Write 2149 2150 def PathType( self, path ) : 2151 return PathType( self.VDBManagerPathType( self.__ptr, to_char_p( path ) ) ) 2152 2153 def GetObjVersion( self, path ) : 2154 vers = c_int() 2155 rc = self.VDBManagerGetObjVersion( self.__ptr, byref( vers ), to_char_p( path ) ) 2156 if rc != 0 : 2157 self.raise_rc( rc, "obj_vers( '%s' )"%( path ), self ) 2158 return version( vers.value ) 2159 2160 def GetObjModDate( self, path ) : 2161 t = c_int() 2162 rc = self.VDBManagerGetObjModDate( self.__ptr, byref( t ), to_char_p( path ) ) 2163 if rc != 0 : 2164 self.raise_rc( rc, "obj_time( '%s' )"%( path ), self ) 2165 return datetime.datetime.fromtimestamp( t.value ) 2166 2167 def OpenDB( self, path, writable = False, schema = None ) : 2168 f = self.VDBManagerOpenDBUpdate if writable else self.VDBManagerOpenDBRead 2169 db = c_void_p() 2170 vdb_schema_ptr = schema.__ptr if schema != None else c_void_p( 0 ) 2171 rc = f( self.__ptr, byref( db ), vdb_schema_ptr, to_char_p( path ) ) 2172 if rc != 0 : 2173 self.raise_rc( rc, "open_db( %s )"%( path ), self ) 2174 return VDatabase( self, db, path ) 2175 2176 def OpenTable( self, path, writable = False, schema = None ) : 2177 f = self.VDBManagerOpenTableUpdate if writable else self.VDBManagerOpenTableRead 2178 tab = c_void_p() 2179 vdb_schema_ptr = schema.__ptr if schema != None else c_void_p( 0 ) 2180 rc = f( self.__ptr, byref( tab ), vdb_schema_ptr, to_char_p( path ) ) 2181 if rc != 0 : 2182 self.raise_rc( rc, "VDBManagerOpenTable( %s )"%( path ), self ) 2183 return VTable( self, tab, path ) 2184 2185 def CreateDB( self, schema, spec, path = None, mode = CreateMode.Init ) : 2186 if schema == None : 2187 raise vdb_error( "CreateDB(): schema missing", self, 0 ) 2188 if spec == None : 2189 raise vdb_error( "CreateDB(): spec missing", self, 0 ) 2190 db = c_void_p() 2191 px = path if path != None else spec 2192 p = to_char_p( px ) 2193 rc = self.VDBManagerCreateDB( self.__ptr, byref( db ), schema._VSchema__ptr, to_char_p( spec ), c_int( mode.value ), p ) 2194 if rc != 0 : 2195 self.raise_rc( rc, "vdb_manger.VDBManagerCreateDB( %s )"%( px ), self ) 2196 return VDatabase( self, db, px ) 2197 2198 def CreateTable( self, schema, spec, path = None, mode = CreateMode.Init ) : 2199 if schema == None : 2200 raise vdb_error( "CreateTable(): schema missing", self, 0 ) 2201 if spec == None : 2202 raise vdb_error( "CreateTable(): spec missing", self, 0 ) 2203 tab = c_void_p() 2204 px = path if path != None else spec 2205 p = to_char_p( px ) 2206 rc = self.VDBManagerCreateTable( self.__ptr, byref( tab ), schema._VSchema__ptr, to_char_p( spec ), c_int( mode.value ), p ) 2207 if rc != 0 : 2208 self.raise_rc( rc, "VDBManagerCreateTable( %s )"%( px ), self ) 2209 return VTable( self, tab, px ) 2210 2211 def MakeSchema( self, schema_text = None ) : 2212 vdb_schema_ptr = c_void_p() 2213 rc = self.VDBManagerMakeSchema( self.__ptr, byref( vdb_schema_ptr ) ) 2214 if rc != 0 : 2215 self.raise_rc( rc, "VDBManagerMakeSchema()", self ) 2216 res = VSchema( self, vdb_schema_ptr ) 2217 if schema_text != None : 2218 res.ParseText( schema_text ) 2219 return res 2220 2221 def MakeKConfig( self ) : 2222 ptr = c_void_p() 2223 rc = self.KConfigMake( byref( ptr ), c_void_p( 0 ) ) 2224 if rc != 0 : 2225 self.raise_rc( rc, "KConfigMake()", self ) 2226 return KConfig( self, ptr ) 2227 2228 def MakeVFSManager( self ) : 2229 ptr = c_void_p() 2230 rc = self.VFSManagerMake( byref( ptr ) ) 2231 if rc != 0 : 2232 self.raise_rc( rc, "VFSManagerMake()", self ) 2233 return VFSManager( self, ptr ) 2234 2235 def ReferenceList( self, path, options = 2 ) : 2236 ptr = c_void_p() 2237 rc = self.ReferenceList_MakePath( byref( ptr ), self.__ptr, to_char_p( path ), c_int( options ), c_int( 0 ), c_char_p( 0 ), c_int( 0 ) ) 2238 if rc != 0 : 2239 self.raise_rc( rc, "ReferenceList_MakePath( '%s' )" % path, self ) 2240 return ReferenceList( self, ptr ) 2241 2242 def RefVariation( self, ref_bases, del_pos, del_len, insertion, algo = 2 ) : 2243 ptr = c_void_p() 2244 ref = to_char_p( ref_bases ) 2245 ref_len = c_longlong( len( ref_bases ) ) 2246 ins = to_char_p( insertion ) 2247 ins_len = c_longlong( len( insertion ) ) 2248 rc = self.RefVariationIUPACMake( byref( ptr ), ref, ref_len, c_longlong( del_pos ), c_longlong( del_len ), ins, ins_len, c_int( algo ) ) 2249 if rc != 0 : 2250 self.raise_rc( rc, "RefVariationIUPACMake( %s )"%( ref_bases ), self ) 2251 return RefVariation( self, ptr ) 2252