[next] [prev] [prev-tail] [tail] [up]

E.6.4 Paket System (p_system.py)

# -------------------------------------------------------------
# Projekt : Digitale Bibliotheken Projekt
# Uni-Frankfurt/M, Professur Telematik und
# verteilte Systeme, Prof. O. Drobnik
# Diplomarbeit, Matzen,Hans, 1997
#
# Dateiname : p_system.py
# Datum : 03.11.1997
# letzte Änderung :
# Autor : Hans Matzen, 1997, Frankfurt/M, Deutschland
# Sprache : Python v1.4
# Beschreibung : Paket System, fasst alle Systempaket Klassen
# zusammen
#
# Anmerkungen :
#
# -------------------------------------------------------------
 
import c_metadoc
import c_metasearch
import c_metaquery
 
Klasse c_metadoc
# -------------------------------------------------------------
# Projekt : Digitale Bibliotheken Projekt
# Uni-Frankfurt/M, Professur Telematik und
# verteilte Systeme, Prof. O. Drobnik
# Diplomarbeit, Matzen,Hans, 1998
# Dateiname : c_metadoc.py
# Datum : 09.12.1997
# letzte Änderung :
# Autor : Hans Matzen, 1997, Frankfurt/M, Deutschland
# Sprache : Python v1.4
# Beschreibung : Die klasse c_metadoc stellt Methoden zur
# Verfuegung um Informationen aus unseren Meta
# Docs zu extrahieren
# Anmerkungen : Diese Klasse wird von der Klasse
# c_sgmlread abgeleitet.
# -------------------------------------------------------------
 
# imports
import c_sgmlread
import regex
import string
import regsub
from sc_globals import *
 
 
class c_metadoc(c_sgmlread.c_sgmlread):
    #
    # Konstruktor, oeffnet das Metadokument
    #
    def __init__(self,fname):
        # Konstruktor der Basisklasse aufrufen
        c_sgmlread.c_sgmlread.__init__(self,fname)
        self.open()
     
    #
    # liefert eine Liste der Attribute des DOCTYPE
    # Tags zurueck
    #
    def get_dtd(self):
        import string
        self.seek_begin()
        doctypetag=self.get_doctype()
        doctypetag=doctypetag [2:-1]
        return string.split(doctypetag," ")
    #
    # liefert den Inhalt des kompletten
    # HEADER Tags zurueck
    #
    def get_header(self):
        self.seek_begin()
        return self.get_tagcontents("HEADER")
    #
    # liefert den Inhalt des INFO Tags zurueck
    #
    def get_info(self):
        self.seek_begin()
        return self.get_tagcontents("INFO")
    #
    # liefert ein Dictionary mit allen Attributen und ihren
    # Werten des PROPERTY Tags zurueck
    #
    def get_property(self):
        self.seek_begin()
        erg={}
        buff = self.get_tag("PROPERTY")
         
        pos1=regex.search("title=*\"",buff)
        pos2=regex.search("author=*\"",buff)
        pos3=regex.search("owner=*\"",buff)
        pos4=regex.search("ident=*\"",buff)
        pos5=regex.search("pubkey=*\"",buff)
        title =string.strip(buff[pos1:pos2])
        author=string.strip(buff[pos2:pos3])
        owner =string.strip(buff[pos3:pos4])
        ident =string.strip(buff[pos4:pos5])
        pubkey=string.strip(buff[pos5:])
 
        title =title[string.find(title,"\"")+1:string.rfind(title,"\"")]
        author=author[string.find(author,"\"")+1:string.rfind(author,"\"")]
        owner =owner[string.find(owner,"\"")+1:string.rfind(owner,"\"")]
        ident =ident[string.find(ident,"\"")+1:string.rfind(ident,"\"")]
        pubkey=pubkey[string.find(pubkey,"\"")+1:string.rfind(pubkey,"\"")]
 
        erg["title"] =title
        erg["author"]=author
        erg["owner"] =owner
        erg["ident"] =ident
        erg["pubkey"]=pubkey
        return erg
    #
    # liefert ein Dictionary alle dem Dokument zugeordneten
    # Methoden und ihrer Namen, sowie MIME-Types zurueck
    #
    def get_methods(self):
        self.seek_begin()
        erg={}
        buff = self.get_tag("METHOD")
        while buff!="":
            pos1=regex.search("name=*\"",buff)
            pos2=regex.search("code=*\"",buff)
            pos3=regex.search("mime=*\"",buff)
            name=string.strip(buff[pos1:pos2])
            code=string.strip(buff[pos2:pos3])
            mime=string.strip(buff[pos3:])
             
            name=name[string.find(name,"\"")+1:string.rfind(name,"\"")]
            code=code[string.find(code,"\"")+1:string.rfind(code,"\"")]
            mime=mime[string.find(mime,"\"")+1:string.rfind(mime,"\"")]
 
            erg[name]=[name,code,mime]
            buff = self.get_tag("METHOD")
 
        return erg
    #
    # liefert den Inhalt des Data-Tags zurueck
    #
    def get_data(self):
        self.seek_begin()
        buff= self.get_tagcontents("DATA")
        return string.strip(buff[string.find(buff,">")+1:string.rfind(buff,"</")])
 
    #
    # Destruktor, schliesst das Metadokument
    #
    def __del__(self):
        self.close()
 
Klasse c_metasearch
# -------------------------------------------------------------
# Projekt : Digitale Bibliotheken Projekt
# Uni-Frankfurt/M, Professur Telematik und
# verteilte Systeme, Prof. O. Drobnik
# Diplomarbeit, Matzen,Hans, 1998
# Dateiname : c_metasearch.py
# Datum : 09.12.1997
# letzte Änderung :
# Autor : Hans Matzen, 1997, Frankfurt/M, Deutschland
# Sprache : Python v1.4
# Beschreibung : Diese Klasse realisiert ein einfaches
# Suchinterface ueber alle gespeicherten
# Metadaten
# Anmerkungen :
# -------------------------------------------------------------
# imports
import pgpy
 
class c_metasearch:
    #
    # Konstruktor
    #
    def __init__(self):
        # Verbindungsobjekt zur Datenbank instanziieren
        self.conn=pgpy.pgconn(DL_PGHOST,DL_PGPORT,DL_DBNAME)
 
    #
    # Durchsucht die in der Datenbank gespeicherten
    # Metadaten nach searchstr und betrachtet dabei
    # jeweils nur das durch field gegeben Feld in der
    # doc_description Klasse. Es werden auch aehnliche
    # Ausdruecke gefunden.
    # Als Ergebnis wird eine ASCII Liste von Dokumenten ID's
    # zurueckgegeben
    #
    def metasearch(self,field,searchstr):
        # SQL Abfrage zusammenbauen
        query="select * from doc_description where "+field+"~*"+searchstr+";"
        # Abfrage ausfuehren
        res=self.conn.exec_query(query)
        # Fehler aufgetreten ?
        if res.get_tuple_count()==0:
            # wenn ja, -1 zurueckgeben
            return -1
        else:
            #wenn nein Ergebnis zurueckgeben
            erg=res.get_resultlist(1,"|",1,0)
            return erg
    #
    # sucht nach ident aehnlichen Dokumenten-ID's
    # Als Ergebnis wird eine ASCII Liste von Dokumenten ID's
    # zurueckgegeben
    #
    def metasearch_ident(self,ident):
        return self.metasearch("ident",searchstr)
    #
    # sucht nach searchstr aehnlichen INFO-Feldern
    # Als Ergebnis wird eine ASCII Liste von Dokumenten ID's
    # zurueckgegeben
    #
    def metasearch_info(self,searchstr):
        return self.metasearch("info",searchstr)
    #
    # sucht nach searchstr aehnlichen AUTHOR-Feldern
    # Als Ergebnis wird eine ASCII Liste von Dokumenten ID's
    # zurueckgegeben
    #
    def metasearch_author(self,searchstr):
        return self.metasearch("author",searchstr)
    #
    # sucht nach searchstr aehnlichen OWNER-Feldern
    # Als Ergebnis wird eine ASCII Liste von Dokumenten ID's
    # zurueckgegeben
    #
    def metasearch_owner(self,searchstr):
        return self.metasearch("owner",searchstr)
    #
    # sucht nach searchstr aehnlichen TITLE-Feldern
    # Als Ergebnis wird eine ASCII Liste von Dokumenten ID's
    # zurueckgegeben
    #
    def metasearch_title(self,searchstr):
        return self.metasearch("title",searchstr)
 
 
Klasse c_metaquery
# -------------------------------------------------------------
# Projekt : Digitale Bibliotheken Projekt
# Uni-Frankfurt/M, Professur Telematik und
# verteilte Systeme, Prof. O. Drobnik
# Diplomarbeit, Matzen,Hans, 1998
# Dateiname : c_metaquery.py
# Datum : 09.12.1997
# letzte Änderung :
# Autor : Hans Matzen, 1997, Frankfurt/M, Deutschland
# Sprache : Python v1.4
# Beschreibung : Klasse fuer Abfragen der Metadaten eines
# bestimmten Dokuments
# Anmerkungen :
#
# -------------------------------------------------------------
 
# imports
from sc_globals import *
import pgpy
 
class c_metaquery:
    #
    # Konstruktor, setzt Variable
    # ident gibt die Dokuent-ID des Dokuments an
    #
    def __init__(self,ident):
        # Verbidungsobjekt zur Datenbank instanziieren
        self.conn=pgpy.pgconn(DL_PGHOST,DL_PGPORT,DL_DBNAME)
        self.ident=ident
 
    #
    # liefert den Inahlt des INFO Tags des gespeicherten
    # Dokuments zurueck
    #
    def mquery_info(self):
        query="select info from doc_description where ident="+str(self.ident)+";"
        res=conn.exec_query(query)
        return res.get_fieldvalue(0,0)
 
    #
    # liefert ein Dictionary mit den Attributen und ihren Werten
    # des PROPERTY Tags zurueck
    #
    def mquery_property(self):
        query="select * from doc_description where ident="+str(self.ident)+";"
        res=conn.exec_query(query)
        erg={'author':'','ident':'','owner':'','pubkey':'','title':''}
        erg['author']=res.get_fieldvalue(0,3)
        erg['ident'] =res.get_fieldvalue(0,5)
        erg['owner'] =res.get_fieldvalue(0,4)
        erg['pubkey']=res.get_fieldvalue(0,6)
        erg['title'] =res.get_fieldvalue(0,2)
 
        return erg
 
    #
    # liefert ein Dictionary mit allen zu den Methoden
    # gespeicherten Informationen (MIME-Typ, Name, URL) zurueck
    #
    def mquery_methods(self):
        erg={}
 
        query="select * from doc_methods where ident="+str(self.ident)+";"
        res=conn.exec_query(query)
         
        count=res.get_tuple_count()
        j=0
        while j<count:
            mclass=res.get_fieldvalue(j,1)
            mloc =res.get_fieldvalue(j,2)
            mtyp =res.get_fieldvalue(j,3)
             
            erg[mclass]= [mclass,mloc,mtyp]
            j=j+1
 
        return erg
 
 
 

[next] [prev] [prev-tail] [front] [up]