Index by: file name |
procedure name |
procedure call |
annotation
gscope_bird.tcl
(annotations | original source)
#rR gscope_bird.tcl
proc BirdEstDisponible {{Value ""}} {
global BirdEstDisponible
if {$Value!=""} { set BirdEstDisponible $Value }
if { ! [info exists BirdEstDisponible]} { set BirdEstDisponible 0 }
return $BirdEstDisponible
}
proc TestPost {} {
set query [::http::formatQuery "ka" "va" "kb" "vb\navecNL" "kc" "vc"]
set token [::http::geturl "http://ena/wscoperr?Zero&CaVa" -query $query]
upvar #0 $token state
set body $state(body)
::http::cleanup $token
return $body
}
proc DbFetchForMacsim {{Quoi ""}} {
regsub -all "aLaLiGnE" $Quoi "\n" Quoi
set LesId {}
foreach Ligne [split $Quoi "\n"] {
if { ! [regexp "ID (.+)" $Ligne Match Id]} { continue }
regsub "\;.*" $Id "" Id
lappend LesId $Id
}
set Uniprot [DbFetchGET uniprot $LesId]
# return $Uniprot
set Interpro [DbFetchGET interpro $LesId]
return $Interpro
}
proc TestBirdFromTheBlast {} {
BirdFromTheBlast EF001
return [BirdWeb "uniprot" "UniRef50_Q057N6"]
}
proc BirdFromTheBlast {Nom {DB ""} {Qui ""}} {
if { ! [BirdEstDisponible]} { Warne "Attention Bird n'est pas disponible" ; return "" }
global BirdFromTheBlast
if {$Nom=="Reset"} {
if {[info exists BirdFromTheBlast]} { unset BirdFromTheBlast }
return ""
}
if {[info exists BirdFromTheBlast($Nom)]} { return $BirdFromTheBlast($Nom) }
if {$DB==""} { set DB "uniprot" }
set FichierBlast [GscopeFile $Nom "blastp"]
if { ! [file exists $FichierBlast]} { return "" }
DecortiqueBlast $FichierBlast "" "" Query lBanqueId lAccess
set Query {}
foreach BanqueId $lBanqueId {
set BanqueIdOrigine $BanqueId
regsub -nocase {^Uniref[^\_]+_} $BanqueId "" BanqueId
#rR a rajouté 2014/11/25
if {[regexp "\|" $BanqueId]} {
set BanqueId [lindex [split $BanqueId "|"] 2]
}
set Origine($BanqueId) $BanqueIdOrigine
lappend LesBanqueId $BanqueId
lappend Query "ID $BanqueId DB $DB"
lappend Query "FM FLAT"
}
set Query [join $Query "\n"]
set R [BirdFromQueryText $Query]
set Id ""
set LesAc {}
set LaSeq {}
foreach Ligne [split $R "\n"] {
if {[string trim $Ligne]==""} { continue }
if {[regexp "^//" $Ligne]} {
lappend LaSeq $Ligne
set Seq [join $LaSeq "\n"]
lappend LesSeqDe($Id) $Seq
foreach Ac $LesAc {
lappend LesSeqDe($Ac) $Seq
}
set Id ""
set LesAc {}
set LaSeq {}
continue
}
lappend LaSeq $Ligne
set IdLu ""
set LesAcLu ""
if {[regexp {^ID ([^ ]+)} $Ligne Match IdLu]} { set Id $IdLu }
if {[regexp {^AC (.*)} $Ligne Match AcLu]} {
regsub -all {[ \;]+} $AcLu " " AcLu
set LesAc [split [string trim $AcLu " "] " "]
}
}
foreach BanqueId $LesBanqueId {
if { ! [info exists LesSeqDe($BanqueId)]} {
lappend LeResultat [list $BanqueId "NotFound"]
continue
}
if {[llength $LesSeqDe($BanqueId)]>1} { FaireLire "$BanqueId has more than 1 hits" }
lappend LeResultat [list $BanqueId [lindex $LesSeqDe($BanqueId) 0]]
}
foreach R $LeResultat {
lassign $R K V
set BirdFromTheBlast($K) $V
set BirdFromTheBlast($Origine($K)) $V
}
if {$Qui!=""} { return [BirdFromTheBlast $Qui] }
return $LeResultat
}
proc BirdQL {query {BirdUrl ""}} {
if { ! [BirdEstDisponible]} { Warne "Attention Bird n'est pas disponible" ; return "" }
#rR ce BirdQL est de pris Nicolas Gagniere avec mes modifs
#rR j'y ai rajoute BirdEntry et BirdFasta pris aussi dans gagniere/gscopublic au cas ou ... package require http
if {$BirdUrl==""} { set BirdUrl [BirdUrl] }
set BirdBsearchUrl $BirdUrl
if { ! [regexp "bsearch" $BirdUrl]} { set BirdBsearchUrl "$BirdUrl/bsearch" }
set query [::http::formatQuery "service" "birdql" "query" $query]
set token [::http::geturl $BirdBsearchUrl -query $query]
upvar #0 $token state
set body $state(body)
::http::cleanup $token
return $body
}
proc TestBirdQL {} {
set LaQuery {}
lappend LaQuery "ID CO8B_HUMAN DB Uniprot"
lappend LaQuery "FD AC,ID,DR,GN"
lappend LaQuery "FM FLAT"
lappend LaQuery "AC P12345 DB Uniprot"
lappend LaQuery "FD AC,ID,DR,GN"
lappend LaQuery "FM FLAT"
set Query [join $LaQuery "\n"]
return [BirdFromQueryText $Query]
return [BirdQL $Query]
}
proc BirdEntry {ListeAcOuIds {ListeDBs "UNIPROT"}} {
if { ! [BirdEstDisponible]} { Warne "Attention Bird n'est pas disponible" ; return "" }
if {$ListeAcOuIds eq "" || $ListeDBs eq ""} {return ""}
package require http
set url [BirdUrl]
#rR set url "http://bird.u-strasbg.fr:8080/bird/bsearch"
#set url "http://d1.crihan.fr:8080/bird/bsearch"
set query [::http::formatQuery "service" "birdql" "query" "ID [join $ListeAcOuIds ","] DB [join $ListeDBs ","]"]
set token [::http::geturl $url -query $query]
upvar #0 $token state
set body $state(body)
::http::cleanup $token
set entries {}
set entryStart 0
foreach location [regexp -inline -all -indices -line {^//$} $body] {
foreach {start stop} $location {}
lappend entries "[string trim [string range $body $entryStart [expr $start - 1]]]\n//\n"
set entryStart [expr $stop + 1]
}
return $entries
}
proc BirdFastaOldDeRaymond {ListeAcOuIds {ListeDBs "UNIPROT"}} {
if {$ListeAcOuIds eq "" || $ListeDBs eq ""} {return ""}
package require http
set url [BirdUrl]
#set url "http://bird.u-strasbg.fr:8080/bird/bsearch"
#rR set url "http://d1.crihan.fr:8080/bird/bsearch"
set query ""
foreach acOuId $ListeAcOuIds {
append query "ID $acOuId DB [join $ListeDBs ", "]\nFM FASTA\n//\n"
}
#set query [::http::formatQuery "service" "birdql" "query" "ID [join $ListeAcOuIds ","] DB [join $ListeDBs ", "]\nFM FASTA"]
set query [::http::formatQuery "service" "birdql" "query" $query]
set token [::http::geturl $url -query $query]
upvar #0 $token state
set body $state(body)
::http::cleanup $token
set entries {}
set entryStart 0
foreach location [regexp -inline -all -indices -line {^\s*$} $body] {
foreach {start stop} $location {}
set entry "[string trim [string range $body $entryStart [expr $start - 1]]]\n"
if {[string trim $entry] ne ""} {
lappend entries $entry
}
set entryStart [expr $stop + 1]
}
return $entries
}
proc BirdShowTable {Schema Table} {
set ShowTable [HttpGetTextFromUrl "[BirdUrl]/detail?metadata=$Schema.$Table"]
return $ShowTable
}
proc BirdMetadata {{Qui ""} {Quoi ""}} {
global BirdMetadata
if {$Qui==""} {
set Qui "ListOf"
set Quoi "BankType"
}
if {[info exists BirdMetadata($Qui,$Quoi)]} { return $BirdMetadata($Qui,$Quoi) }
if {[info exists BirdMetadata("EstCharge")]} { return "" }
set BirdMetadata("EstCharge") 1
# set MetadataUrl "[BirdUrl]/bsearch?service=metadata&db=all"
# set MetadataUrl "http://bird.u-strasbg.fr:8080/bird/temp/metadata.xml"
set MetadataUrl "[BirdUrl]/temp/metadata.xml"
set Metadata [HttpGetTextFromUrl $MetadataUrl]
set XML $Metadata
set Id [dom parse $XML]
set Root [$Id documentElement]
set BirdMetadata(ListOf,BankType) {}
set BirdMetadata(ListOf,BankName) {}
set LesBankList [$Root selectNodes "bird-bank-meta"]
foreach BankElement $LesBankList {
set BankType [$BankElement getAttribute "type"]
set BankSchemas [$BankElement getAttribute "schema"]
set BankMetadata [$BankElement getAttribute "metadata"]
set BankFormats [$BankElement getAttribute "format_out"]
regsub -all "," $BankFormats " " BankFormats
set LesBankFormat [LesMotsDeLaLigne $BankFormats]
set BirdMetadata($BankType,BankMetadata) $BankMetadata
set BirdMetadata($BankType,BankFormats) $LesBankFormat
regsub -all "," $BankSchemas " " BankSchemas
set LesBankSchemas [LesMotsDeLaLigne $BankSchemas]
lappend BirdMetadata(ListOf,BankType) $BankType
set BirdMetadata($BankType,BankSchemas) {}
foreach BankSchema $LesBankSchemas {
regsub {\(.*} $BankSchema "" BankSchema
if {[string trim $BankSchema]==""} { continue }
lappend BirdMetadata(ListOf,BankSchema) $BankSchema
lappend BirdMetadata($BankType,BankSchemas) $BankSchema
set BirdMetadata($BankSchema,BankType) $BankType
}
set LesKeys [$BankElement selectNodes "key"]
set BirdMetadata($BankType,KeyDisplays) {}
set BirdMetadata($BankType,AliasBirdqls) {}
set BirdMetadata($BankType,Comments) {}
foreach Key $LesKeys {
set KeyDisplay [$Key getAttribute "keyDisplay"]
set AliasBirdql [$Key getAttribute "alias_birdql"]
set Comment [$Key getAttribute "comment"]
lappend BirdMetadata(ListOf,KeyDisplay) $KeyDisplay
lappend BirdMetadata(ListOf,AliasBirdql) $AliasBirdql
lappend BirdMetadata(ListOf,Comment) $Comment
lappend BirdMetadata($BankType,KeyDisplays) $KeyDisplay
lappend BirdMetadata($BankType,AliasBirdqls) $AliasBirdql
lappend BirdMetadata($BankType,Comments) $Comment
set BirdMetadata($BankType:K:$KeyDisplay,KeyDisplay) $KeyDisplay
set BirdMetadata($BankType:K:$KeyDisplay,AliasBirdql) $AliasBirdql
set BirdMetadata($BankType:K:$KeyDisplay,Comment) $Comment
set BirdMetadata($BankType:A:$AliasBirdql,KeyDisplay) $KeyDisplay
set BirdMetadata($BankType:A:$AliasBirdql,AliasBirdql) $AliasBirdql
set BirdMetadata($BankType:A:$AliasBirdql,Comment) $Comment
}
}
set BirdMetadata(ListOf,KeyDisplay) [lsort -unique $BirdMetadata(ListOf,KeyDisplay)]
set BirdMetadata(ListOf,AliasBirdql) [lsort -unique $BirdMetadata(ListOf,AliasBirdql)]
set BirdMetadata(ListOf,Comment) [lsort -unique $BirdMetadata(ListOf,Comment)]
foreach K [array names BirdMetadata] {
regsub "," $K " " K
scan $K "%s %s" I O
lappend BirdMetadata(ListOf,Quoi) $O
lappend BirdMetadata(ListOf,QuiQuoi) "$I $O"
if {$I=="ListOf"} { lappend BirdMetadata(ListOf,ListOf) $O }
}
lappend lappend BirdMetadata(ListOf,Quoi) "ListOf"
set BirdMetadata(ListOf,Quoi) [lsort -unique $BirdMetadata(ListOf,Quoi)]
return [BirdMetadata $Qui $Quoi]
}
proc TestBirdFromQueryText {} {
set Query {}
# foreach Access [list NP_000035 NP_001009012 NP_001028083 XP_001504915 NP_001003053 NP_038504 NP_036634 NP_999479 XP_001376683] {}
foreach Access [list P12345999 PAX2_HUMAN] {
lappend Query "ID $Access DB uniprot"
lappend Query "FM FLAT"
}
set Query [join $Query "\n"]
Espionne $Query
set R [BirdFromQueryText $Query]
return $R
}
proc BirdGscopeQueries {} {
set FichierBirdGscopeQueries [Fiches "BirdGscopeQueries.ql"]
if {[FileAbsent $FichierBirdGscopeQueries]} {
set BaseGscope [file tail [RepertoireDuGenome]]
set LaReq {}
lappend LaReq "ID * DB $BaseGscope"
lappend LaReq "LM 1"
lappend LaReq "FM XML"
set Req [join $LaReq "\n"]
return $Req
}
return [ContenuDuFichier $FichierBirdGscopeQueries]
}
proc BirdGscopeSearch {} {
set K [AfficheListe [BirdGscopeKeywords] "SetWidth9" "Possible_Keywords"]
set Queries [BirdGscopeQueries]
set Req [EntreTexte $Queries]
if {$Req==""} { return "" }
set Retour [BirdFromQueryText $Req]
set Sep [string repeat "*" 80]
set Texte "Result of following BirdQuery\n$Sep\n$Req\n$Sep\nIf you want to know more, select a Nom:... and press SearchOnBoard\n$Sep\n$Retour"
set F [AfficheVariable $Texte "AvecBird" "Result_of_BirdGscopeSearch"]
BoutonneLaFenetre $F "New Bird Search" "BirdGscopeSearch"
return $F
}
proc BirdGscopeKeywords {{BaseGscope ""} {Format ""}} {
if {$BaseGscope==""} { set BaseGscope [file tail [RepertoireDuGenome]] }
return [BirdKeywords $BaseGscope $Format]
}
proc BirdKeywords {{BaseBird ""} {Format ""}} {
if {$Format==""} { set Format "FLAT" }
set LaReq {}
lappend LaReq "ID * DB $BaseBird"
lappend LaReq "LM 1"
lappend LaReq "FM $Format"
set Req [join $LaReq "\n"]
set Tout [BirdFromQueryText $Req]
set LesClefs {}
if {$Format == "XML"} {
set Entry "[string tolower $BaseBird].entry"
set Avant 1
foreach Ligne [split $Tout "\n"] {
if {$Avant} {
if { [regexp "<$Entry.*>" $Ligne]} { set Avant 0 }
continue
}
if { [regexp {</?resultset>} $Ligne]} { continue }
if { [regexp "</$Entry.*>" $Ligne]} { continue }
regsub {>.*} $Ligne "" Clef
regsub {<} $Clef "" Clef
lappend LesClefs $Clef
}
} else {
foreach Ligne [split $Tout "\n"] {
if { ! [regexp -nocase {^[a-z0-9_\-]+} $Ligne Clef]} { continue }
lappend LesClefs $Clef
}
}
set LesClefs [lsort -unique $LesClefs]
return $LesClefs
}
proc BirdFromQueryText {Texte {OutFile ""} {BirdUrl ""}} {
if { ! [BirdEstDisponible]} { Warne "Attention Bird n'est pas disponible" ; return "" }
set Retour [BirdQL $Texte $BirdUrl]
if {$OutFile==""} { return $Retour }
return [Sauve $Retour dans $OutFile]
}
proc BirdFromQueryFile {Fichier {OutFile ""} {BirdUrl ""}} {
return [BirdFromQueryText [ContenuDuFichier $Fichier] $OutFile $BirdUrl]
#rR reste est obsolete mais marche quand meme On utilise curl
if {$BirdUrl==""} { set BirdUrl [BirdUrl] }
set Retour [eval exec curl -stderr /dev/null -F upload=@$Fichier "$BirdUrl/bsearch?service=birdql"]
if {$OutFile==""} { return $Retour }
return [Sauve $Retour dans $OutFile]
}
proc BirdStar4FromQueryFile {Fichier {Options ""} {Racine ""} {KeepZip ""} {TarFile ""}} {
set Options [string trim $Options " \t\n"]
if {$Options!="" && ! [regexp {^\&} $Options]} { set Options "&$Options" }
set KeepZip [string equal -nocase $KeepZip "KeepZip"]
if {$Racine==""} { set Racine "BirdResult" }
set Delete 0
if {$TarFile==""} {
set Delete 1
set TarFile "[TmpFile].bird.tar.gz"
}
set CommandeBird "curl -s -F upload=@$Fichier \
\"http://star4:8080/mybiodb/bsearch?service=bird_explorer&out_file=${Racine}${Options}\" \
-o $TarFile"
Espionne $CommandeBird
if {[catch {eval exec $CommandeBird} Message]} {Espionne "Error from curl : START of message\n$Message\nEND of message"}
if {$KeepZip} { return $TarFile }
set Retour [exec zcat $TarFile]
if {$Delete} { file delete $TarFile }
return $Retour
}
proc LesDefinitionsDuMsf FichierMsf {
set NombreDeSequences [DecortiqueUnMSF $FichierMSF LesSequencesDansLOrdre]
foreach NomSeq $LesSequencesDansLOrdre {
regsub "spt_" $NomSeq "" Access
set DE [BirdWeb UNIPROT $Access]
Espionne "$Access $DE"
}
return
}
proc BirdWebFromTFAs {Database Accession {Fields ""}} {
if {$Fields==""} { set Fields "all" }
set FieldAuto(DBXREF) 1
set LesFieldsDemandes {}
foreach FieldDemande [split $Fields ","] {
if {$FieldDemande==""} { continue }
if { ! [info exists FieldAuto([string toupper $FieldDemande])]} {
lappend LesFieldsDemandes $FieldDemande
}
set AAfficher([string toupper $FieldDemande]) 1
lappend LesFieldsAAfficher $FieldDemande
}
set Param "&field=[join $LesFieldsDemandes ","]"
set Url "[BirdUrl]/bsearch?db=$Database&accession=$Accession&format=flat$Param"
set Tout [HttpGetTextFromUrl $Url]
return $Tout
}
proc BirdWeb {Database Accession {Fields ""}} {
if { ! [BirdEstDisponible]} { Warne "Attention Bird n'est pas disponible" ; return "" }
if {$Fields==""} { set Fields "all" }
#rR on peut deja avoir cherche et memorise tous les access d'un blast (rajout du 2014/03/11)
if {$Fields=="all" && [string equal -nocase "uniprot" $Database]} {
# Espionne "I'll try BirdFromTheBlast $Accession"
if {[set Info [BirdFromTheBlast $Accession]]!=""} {
if {$Info=="NotFound"} { return "" }
return $Info
}
}
set FieldAuto(DBXREF) 1
set LesFieldsDemandes {}
foreach FieldDemande [split $Fields ","] {
if {$FieldDemande=="all"} { continue }
if {$FieldDemande==""} { continue }
if { ! [info exists FieldAuto([string toupper $FieldDemande])]} {
lappend LesFieldsDemandes $FieldDemande
}
set AAfficher([string toupper $FieldDemande]) 1
lappend LesFieldsAAfficher $FieldDemande
}
set Param ""
if {$LesFieldsDemandes!={} || $Fields!="all"} {
set LesKeysDemandes {}
foreach F $LesFieldsDemandes {
set K $F
# if {[set K [BirdMetadata "$Database:K:$F AliasBirdql"]]==""} { set K $F }
lappend LesKeysDemandes $K
}
set Param "&field=[join $LesKeysDemandes ","]"
}
set Url "[BirdUrl]/bsearch?db=$Database&accession=$Accession$Param"
if {[catch {set Tout [string trim [HttpGetTextFromUrl $Url]]} Message] } {
Warne "Error from Bird with message : $Message"
return ""
}
if {[string equal -nocase $Fields "all"]} { return $Tout }
set LaSortie {}
set YaEuSQ 0
foreach Ligne [split $Tout "\n"] {
if {[regexp "^SQ " $Ligne]} {
set YaEuSQ 1
set Seq ""
continue
}
if {$YaEuSQ} {
if {[regexp " " $Ligne]} { append Seq [string trim $Ligne] ; continue }
lappend LaSortie "$Seq"
set $YaEuSQ 0
continue
}
if {[regexp "^//" $Ligne]} { continue }
if {[regexp -nocase {[a-z_0-9]+([= ])} $Ligne Match PremierSeparateur]} {
set F [lindex [split $Ligne $PremierSeparateur] 0]
# set K [BirdMetadata $F "Key"]
set K $F
if { ! [info exists AAfficher([string toupper $F])] && ! [info exists AAfficher([string toupper $K])]} { continue }
set Valeur [string trim [StringSuivant $PremierSeparateur dans $Ligne]]
# set Valeur $Ligne
# regsub {[^=]*=} $Valeur "" Valeur
lappend LaSortie $Valeur
} else {
set F [lindex [split $Ligne " "] 0]
# set K [BirdMetadata $F "Key"]
set K $F
if { ! [info exists AAfficher([string toupper $F])] && ! [info exists AAfficher([string toupper $K])]} { continue }
set Valeur $Ligne
regsub {[^ ]* +} $Valeur "" Valeur
lappend LaSortie $Valeur
}
}
return [join $LaSortie "\n"]
}
proc BirdGet {NM {Field ""}} {
if {$Field==""} { set Field "accession" }
return [BirdGetFields $NM $Field "WithoutField"]
}
proc BirdGetFields {NM {Fields ""} {WithoutField ""}} {
if { ! [BirdEstDisponible]} { Warne "Attention Bird n'est pas disponible" ; return "" }
set WithoutField [string equal -nocase $WithoutField "WithoutField"]
set LesFieldsAAfficher {}
if {$Fields==""} {
set Param ""
} else {
set FIELDS [string toupper $Fields]
set LesFieldsDemandes {}
foreach FieldDemande [split $FIELDS ","] {
if {$FieldDemande==""} { continue }
if { ! [regexp {^(DBXREF|GO_COMPONENT|GO_FUNCTION|GO_PROCESS)$} $FieldDemande]} {
lappend LesFieldsDemandes $FieldDemande
}
set AAfficher($FieldDemande) 1
lappend LesFieldsAAfficher $FieldDemande
}
set Param "&field=[join $LesFieldsDemandes ","]"
}
set Tout [HttpGetTextFromUrl "[BirdUrl]/getprotein?db=REFSEQRNA&accession=$NM"]
set Tout [string trim $Tout " \n\t"]
set LesBons {}
set LesClefs {}
foreach Ligne [split $Tout "\n"] {
if { ! [regexp {^[^=]+} $Ligne Clef]} {
lappend LesBons $Ligne
continue
}
set CLEF [string toupper $Clef]
set Valeur [StringSuivant "=" dans $Ligne]
if { ! [info exists DejaVu($CLEF)]} { lappend LesCLEFS $CLEF ; set DejaVu($CLEF) 1}
lappend LesValeurs($CLEF) $Valeur
}
foreach CLEF $LesFieldsAAfficher {
set TexteClef "$CLEF="
if {$WithoutField} { set TexteClef "" }
if { ! [info exists LesValeurs($CLEF)]} {
if {[info exists AAfficher($CLEF)]} { lappend LesBons "$TexteClef" }
continue
}
if {[llength $LesValeurs($CLEF)]==1} {
if {[info exists AAfficher($CLEF)]} { lappend LesBons "$TexteClef[string trim [lindex $LesValeurs($CLEF) 0] ";"]" }
continue
}
set LesBonnesValeurs {}
foreach Valeur $LesValeurs($CLEF) {
regsub -all ";" $Valeur ",," Valeur
lappend LesBonnesValeurs $Valeur
}
if {[info exists AAfficher($CLEF)]} {
lappend LesBons "$TexteClef[join $LesBonnesValeurs ";"]"
}
}
set Bon [join $LesBons "\n"]
return $Bon
}
proc NPduNM NM {
# set NP [HttpGetTextFromUrl "[BirdUrl]/getprotein?db=REFSEQRNA&accession=$NM"]
# set NP [string trim $NP " \n\t"]
set NP [BirdGet $NM "accession"]
regsub {\..*} $NP "" NP
return $NP
# set Query "select cds.protein_id from refseqRNA.ft_cds as cds,refseqRNA.entry as entry where entry.accession='$NM' and cds.key_fk=entry.oid"
# set NP [Bird $Query "flat"]
# return $NP
}
proc BirdSendQueryAndGetFromUrl {Query {Url ""} {Options ""}} {
if { ! [BirdEstDisponible]} { Warne "Attention Bird n'est pas disponible" ; return "" }
package require http
if {$Url==""} { set Url "[BirdUrl]/bsearch" }
set QueryEncode [::http::formatQuery querytext $Query]
# Espionne $QueryEncode
if {$Options!=""} { append QueryEncode "&$Options" }
set Token [eval ::http::geturl $Url -query $QueryEncode]
return [::http::data $Token]
}
proc BirdSendQueryUrlAndGetFromUrl {QueryUrl {Url ""} {Options ""}} {
if { ! [BirdEstDisponible]} { Warne "Attention Bird n'est pas disponible" ; return "" }
package require http
if {$Url==""} { set Url "[BirdUrl]/bsearch" }
set QueryUrlEncode [eval ::http::formatQuery querytext "\"$QueryUrl\""]
# regsub -all {\+} $QueryUrlEncode {%20} QueryUrlEncode
if {$Options!=""} { append QueryUrlEncode "&$Options" }
set Token [::http::geturl $Url -query $QueryUrlEncode]
return [::http::data $Token]
}
proc BirdPostFileAndGetFromUrl {Filename {Url ""} {Options ""}} {
if { ! [BirdEstDisponible]} { Warne "Attention Bird n'est pas disponible" ; return "" }
package require http
if {$Url==""} { set Url "[BirdUrl]/bsearch" }
set f [open $Filename r]
set Query [read -nonewline $f]
close $f
set PostEncode [eval ::http::formatQuery querytext $Query]
if {$Options!=""} { append PostEncode "&$Options" }
set Token [::http::geturl $Url -query $PostEncode]
return [::http::data $Token]
}
proc TestBird {} {
set Query "select * from ucschuman.refgene where txend < 990000 and txstart >= 924207 and chrom='chr1'"
Espionne [Bird $Query xml]
}
proc Bird {Query {Format ""} {Out ""}} {
if { ! [BirdEstDisponible]} { Warne "Attention Bird n'est pas disponible" ; return "" }
#nG if {$Out==""} { set Out "GetResult" }BirdSendQueryUrlAndGetFromUrl
if {$Out==""} { set Out "GetResult" }
if {[string equal -nocase $Out "GetResult"]} {
set OutFile "/dev/null"
} else {
set OutFile $$Out
}
if {$Format==""} { set Format "xml" }
set GetRootNode 0
if {[string equal -nocase $Format "documentElement"]} {
set Format "xml"
set GetRootNode 1
}
set FichierQueryTmp "[TmpFile].sql"
Sauve $Query dans $FichierQueryTmp
set FichierQuery $FichierQueryTmp
#rR AFAIRE
# set Q "http://star4:8080/mybiodb/bsearch?querytext=select%20NAME,%20TXSTART,%20TXEND,%20STRAND%20from%20ucscmouse.refgene%20where%20chrom='chr1'%20and%20txStart%3C=95452457&format=xml"
#rR
set RetourBird [exec bird_explorer_ucsc $FichierQuery $OutFile format=$Format display=yes]
if {[info exists FichierQueryTmp] && [file exists $FichierQueryTmp]} {file delete $FichierQueryTmp}
if {$Format=="xml" && $GetRootNode} {
package require tdom
set RootNode [[dom parse $RetourBird] "documentElement"]
return $RootNode
}
if {$Out=="GetResult"} { return $RetourBird }
return $OutFile
}
proc BirdUrl {} {
# set Url "http://decrypthon.u-strasbg.fr:8080/bird"
# set Url "http://star4:8080/bird"
# set Url "http://bird.u-strasbg.fr:8080/bird"
# set Url "http://bird.igbmc.fr:8080/bird"
set Url "http://kbm.u-strasbg.fr:8080/birdsnp"
# set Url "http://d1.crihan.fr:8080/bird"
# set Url "http://195.221.22.98:8080/bird"
return $Url
}
Index by: file name |
procedure name |
procedure call |
annotation
File generated 2022-04-05 at 12:55.