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