Changeset 98

Show
Ignore:
Timestamp:
02/09/08 16:04:53 (4 years ago)
Author:
phil
Message:

This reflects a change of all Descriptor names from a prefix of rdflib to rdf
This fixes improves the behavior of Literal for Decimal and datetime types
It also moves rdfSubject into a different file name
adds one unit test for literals

Location:
rdfalchemy/trunk
Files:
3 added
1 removed
13 modified

Legend:

Unmodified
Added
Removed

  • rdfalchemy/trunk/rdfalchemy/descriptors.py

    r97 r98  
    88""" 
    99 
    10 from rdflib import Literal, URIRef, BNode, Namespace 
     10from rdflib import URIRef, BNode, Namespace 
    1111from rdflib.Identifier import Identifier  
    12 from rdfalchemy import rdfSubject 
    13 from  copy import copy 
     12from rdfalchemy import rdfSubject, Literal  
     13from copy import copy 
    1414 
    1515#from rdfalchemy import rdfSubject 
    … …  
    1818##formatter = logging.Formatter('%(name)-12s: %(levelname)-8s %(message)s') 
    1919##console.setFormatter(formatter) 
    20 log=logging.getLogger('rdfalchemy') 
     20log=logging.getLogger(__name__) 
    2121 
    2222RDF  = Namespace("http://www.w3.org/1999/02/22-rdf-syntax-ns#") 
    … …  
    8080################################################################################## 
    8181 
    82 class rdflibAbstract(object): 
     82class rdfAbstract(object): 
    8383    """Abstract base class for descriptors 
    8484    Descriptors are to map class instance variables to predicates 
    … …  
    121121 
    122122                     
    123 class rdflibSingle(rdflibAbstract): 
     123class rdfSingle(rdfAbstract): 
    124124    '''This is a Discriptor 
    125125    Takes a the URI of the predicate at initialization 
    … …  
    128128    ONLY triple with that subject,predicate pair''' 
    129129    def __init__(self, pred, cacheName=None, range_type=None): 
    130         super(rdflibSingle, self).__init__(pred, cacheName, range_type) 
     130        super(rdfSingle, self).__init__(pred, cacheName, range_type) 
    131131         
    132132    def __get__(self, obj, cls): 
    … …  
    150150         
    151151    
    152 class rdflibMultiple(rdflibAbstract): 
     152class rdfMultiple(rdfAbstract): 
    153153    '''This is a Discriptor     
    154154       Expects to return a list of values (could be a list of one)''' 
    155155    def __init__(self, pred, cacheName=None, range_type=None): 
    156         super(rdflibMultiple, self).__init__(pred, cacheName, range_type) 
     156        super(rdfMultiple, self).__init__(pred, cacheName, range_type) 
    157157         
    158158    def __get__(self, obj, cls): 
    … …  
    180180        log.debug("SET with descriptor value %s of type %s"%(newvals,type(newvals))) 
    181181        if not isinstance(newvals, list): 
    182             raise AttributeError("to set a rdflibMulti you must pass in a list (it can be a list of one)") 
     182            raise AttributeError("to set a rdfMulti you must pass in a list (it can be a list of one)") 
    183183        try: 
    184184            oldvals = obj.__dict__[self.name] 
    … …  
    197197         
    198198 
    199 class rdflibList(rdflibMultiple): 
     199class rdfList(rdfMultiple): 
    200200    '''This is a Discriptor     
    201201       Expects to return a list of values (could be a list of one) 
    202202       `__set__` will set the predicate as a RDF List''' 
    203203    def __init__(self, pred, range_type=None): 
    204         super(rdflibMultiple, self).__init__(pred, range_type) 
     204        super(rdfMultiple, self).__init__(pred, range_type) 
    205205         
    206206    def __get__(self, obj, cls): 
    … …  
    231231        log.debug("SET with descriptor value %s of type %s"%(newvals,type(newvals))) 
    232232        if not isinstance(newvals, list): 
    233             raise AttributeError("to set a rdflibList you must pass in a list (it can be a list of one)") 
     233            raise AttributeError("to set a rdfList you must pass in a list (it can be a list of one)") 
    234234        try: 
    235235            oldvals = obj.__dict__[self.name] 
    … …  
    265265 
    266266         
    267 class rdflibContainer(rdflibMultiple): 
     267class rdfContainer(rdfMultiple): 
    268268    '''This is a Discriptor     
    269269       Expects to return a list of values (could be a list of one) 
    270270       `__set__` will set the predicate as a RDF Container type (defaults to rdf:Seq)''' 
    271271    def __init__(self, pred,  range_type=None, container_type="http://www.w3.org/1999/02/22-rdf-syntax-ns#Seq"): 
    272         super(rdflibMultiple, self).__init__(pred,  range_type) 
     272        super(rdfMultiple, self).__init__(pred,  range_type) 
    273273        self.container_type = container_type 
    274274         
    … …  
    301301        log.debug("SET with descriptor value %s of type %s"%(newvals,type(newvals))) 
    302302        if not isinstance(newvals, list): 
    303             raise AttributeError("to set a rdflibList you must pass in a list (it can be a list of one)") 
     303            raise AttributeError("to set a rdfList you must pass in a list (it can be a list of one)") 
    304304        seq = obj.db.value(obj.resUri, self.pred) 
    305305        if not seq: 

  • rdfalchemy/trunk/rdfalchemy/__init__.py

    r91 r98  
    1 from rdfalchemy import * 
    2 from descriptors import * 
     1from rdflib import Namespace 
     2from rdfalchemy.Literal import Literal 
     3from rdfalchemy.rdfSubject import rdfSubject 
     4from rdfalchemy.descriptors import * 

  • rdfalchemy/trunk/rdfalchemy/orm.py

    r92 r98  
    88""" 
    99 
    10 from rdfalchemy import rdfSubject 
    11 from descriptors import rdflibAbstract 
     10from rdfalchemy.rdfSubject import rdfSubject 
     11from rdfalchemy.descriptors import rdfAbstract 
    1212 
    1313import logging 
    14 log=logging.getLogger('rdfAlchemy') 
     14log=logging.getLogger(__name__) 
    1515 
    1616def allsub(cl, beenthere = set([])): 
    … …  
    3535    for cl in classes:  # for each class 
    3636        for v in cl.__dict__.values():  # for each desciptor 
    37             if isinstance(v,rdflibAbstract) and v.range_type:  #if its a descriptor with a range 
     37            if isinstance(v,rdfAbstract) and v.range_type:  #if its a descriptor with a range 
    3838                try: 
    3939                    v._mappedClass = class_dict[str(v.range_type)]  

  • rdfalchemy/trunk/rdfalchemy/samples/company.py

    r91 r98  
    1111class Company(rdfSubject): 
    1212    rdf_type = ov.Company 
    13     symbol = rdflibSingle(ov.symbol,) 
    14     cik = rdflibSingle(ov.secCik,'cik') 
    15     companyName = rdflibSingle(ov.companyName,'companyName') 
    16     stockDescription = rdflibSingle(ov.stockDescription,'stockDescription') 
    17     stock = rdflibMultiple(ov.hasIssue) 
     13    symbol = rdfSingle(ov.symbol,) 
     14    cik = rdfSingle(ov.secCik,'cik') 
     15    companyName = rdfSingle(ov.companyName,'companyName') 
     16    stockDescription = rdfSingle(ov.stockDescription,'stockDescription') 
     17    stock = rdfMultiple(ov.hasIssue) 
    1818         
    1919                                                                                                                                         
    … …  
    2121class EdgarFiling(rdfSubject): 
    2222    rdf_type = edgarns.xbrlFiling 
    23     accessionNumber = rdflibSingle(edgarns.accessionNumber) 
    24     companyName = rdflibSingle(edgarns.companyName) 
    25     filingDate = rdflibSingle(edgarns.filingDate) 
    26     formType = rdflibSingle(edgarns.formType) 
     23    accessionNumber = rdfSingle(edgarns.accessionNumber) 
     24    companyName = rdfSingle(edgarns.companyName) 
     25    filingDate = rdfSingle(edgarns.filingDate) 
     26    formType = rdfSingle(edgarns.formType) 
    2727                                                                                                                                                                                                                                                                                                                                                                    

  • rdfalchemy/trunk/rdfalchemy/samples/doap.py

    r91 r98  
    1 from rdfalchemy import rdfSubject, rdflibSingle, rdflibMultiple 
     1from rdfalchemy import rdfSubject, rdfSingle, rdfMultiple 
    22from rdflib import Namespace 
    33 
    … …  
    88class Project(rdfSubject): 
    99    rdf_type = DOAP.Project 
    10     name = rdflibSingle(DOAP.name) 
    11     created = rdflibSingle(DOAP.created) 
    12     homepage = rdflibSingle(DOAP.homepage) 
    13     shortdesc = rdflibMultiple(DOAP.shortdesc) 
    14     releases = rdflibMultiple(DOAP.release) 
    15     language = rdflibSingle(DOAP['programming-language']) # the hyphen means we can't use DOAP.programming-language 
    16     maintainer = rdflibSingle(DOAP.maintainer,range_type=FOAF.Person) 
     10    name = rdfSingle(DOAP.name) 
     11    created = rdfSingle(DOAP.created) 
     12    homepage = rdfSingle(DOAP.homepage) 
     13    shortdesc = rdfMultiple(DOAP.shortdesc) 
     14    releases = rdfMultiple(DOAP.release) 
     15    language = rdfSingle(DOAP['programming-language']) # the hyphen means we can't use DOAP.programming-language 
     16    maintainer = rdfSingle(DOAP.maintainer,range_type=FOAF.Person) 
    1717 
    1818if __name__ == '__main__': 

  • rdfalchemy/trunk/rdfalchemy/samples/example.py

    r94 r98  
    1 from rdfalchemy import rdfSubject, rdflibSingle, rdflibMultiple 
     1from rdfalchemy import rdfSubject, rdfSingle, rdfMultiple 
    22from rdflib import ConjunctiveGraph, Namespace, Literal 
    33 
    … …  
    1010class Company(rdfSubject): 
    1111    rdf_type = OV.Company 
    12     symbol = rdflibSingle(OV.symbol,'symbol') 
    13     cik = rdflibSingle(OV.secCik,'cik') 
    14     companyName = rdflibSingle(OV.companyName) 
    15     address = rdflibSingle(VCARD.adr) 
     12    symbol = rdfSingle(OV.symbol,'symbol') 
     13    cik = rdfSingle(OV.secCik,'cik') 
     14    companyName = rdfSingle(OV.companyName) 
     15    address = rdfSingle(VCARD.adr) 
    1616 
    1717 
    … …  
    3535 
    3636## Add a descriptor on the fly 
    37 Company.stockDescription = rdflibSingle(OV.stockDescription,'stockDescription') 
     37Company.stockDescription = rdfSingle(OV.stockDescription,'stockDescription') 
    3838 
    3939print "%s: %s"%(c.companyName,c.stockDescription) 
    … …  
    4646 
    4747## add another descriptor on the fly 
    48 Company.industry = rdflibSingle(OV.yindustry,'industry') 
     48Company.industry = rdfSingle(OV.yindustry,'industry') 
    4949 
    5050## add an attribute (from the database) 

  • rdfalchemy/trunk/rdfalchemy/samples/foaf.py

    r92 r98  
    77Copyright (c) 2007 Openvest. All rights reserved. 
    88""" 
    9 from rdfalchemy import rdfSubject, rdflibSingle, rdflibMultiple 
     9from rdfalchemy import rdfSubject, rdfSingle, rdfMultiple 
    1010from rdflib import Namespace 
    1111 
    … …  
    1414class Agent(rdfSubject): 
    1515    rdf_type = FOAF.Agent 
    16     name = rdflibSingle(FOAF.name) 
    17     mbox = rdflibSingle(FOAF.mbox) 
    18     openid = rdflibSingle(FOAF.openid)     
     16    name = rdfSingle(FOAF.name) 
     17    mbox = rdfSingle(FOAF.mbox) 
     18    openid = rdfSingle(FOAF.openid)     
    1919 
    2020 
    2121class Person(Agent): 
    2222    rdf_type = FOAF.Person 
    23     first = rdflibSingle(FOAF.firstName,'first') 
    24     last = rdflibSingle(FOAF.surname,'last') 
    25     givenname = rdflibSingle(FOAF.givenname,'first') 
    26     surname = rdflibSingle(FOAF.surname,'last') 
     23    first = rdfSingle(FOAF.firstName,'first') 
     24    last = rdfSingle(FOAF.surname,'last') 
     25    givenname = rdfSingle(FOAF.givenname,'first') 
     26    surname = rdfSingle(FOAF.surname,'last') 

  • rdfalchemy/trunk/rdfalchemy/sesame2.py

    r96 r98  
    1010import simplejson 
    1111 
    12 log=logging.getLogger('rdfAlchemy') 
     12log=logging.getLogger(__name__) 
    1313 
    1414RDF  =Namespace("http://www.w3.org/1999/02/22-rdf-syntax-ns#") 

  • rdfalchemy/trunk/rdfalchemy/sparql.py

    r94 r98  
    1010import logging 
    1111 
    12 log=logging.getLogger('rdfAlchemy') 
     12log=logging.getLogger(__name__) 
    1313 
    1414class DumpSink(object): 

  • rdfalchemy/trunk/test/company_test.py

    r95 r98  
    1 from rdfalchemy import rdfSubject, rdflibSingle, rdflibMultiple 
     1from rdfalchemy import rdfSubject, rdfSingle, rdfMultiple 
    22from rdflib import ConjunctiveGraph, Namespace, Literal, BNode, URIRef 
    33 
    … …  
    4040class Company(rdfSubject): 
    4141    rdf_type = OV.Company 
    42     symbol = rdflibSingle(OV.symbol,'symbol') 
    43     cik = rdflibSingle(OV.secCik,'cik') 
    44     companyName = rdflibSingle(OV.companyName) 
    45     address = rdflibSingle(VCARD.adr) 
     42    symbol = rdfSingle(OV.symbol,'symbol') 
     43    cik = rdfSingle(OV.secCik,'cik') 
     44    companyName = rdfSingle(OV.companyName) 
     45    address = rdfSingle(VCARD.adr) 
    4646 
    4747 
    … …  
    6969def test_2(): 
    7070    ## Add a descriptor on the fly 
    71     Company.stockDescription = rdflibSingle(OV.stockDescription,'stockDescription') 
     71    Company.stockDescription = rdfSingle(OV.stockDescription,'stockDescription') 
    7272 
    7373    assert  c.companyName == c[OV.companyName] 
    … …  
    7575     
    7676## add another descriptor on the fly 
    77 Company.industry = rdflibSingle(OV.yindustry,'industry') 
     77Company.industry = rdfSingle(OV.yindustry,'industry') 
    7878 
    7979## add an attribute (from the database) 

  • rdfalchemy/trunk/test/count_test.py

    r91 r98  
    2020 
    2121 
    22 Person.m=rdflibMultiple(FOAF.multi) 
    23 Person.l=rdflibList(FOAF.list) 
    24 Person.c=rdflibContainer(FOAF.seq) 
     22Person.m=rdfMultiple(FOAF.multi) 
     23Person.l=rdfList(FOAF.list) 
     24Person.c=rdfContainer(FOAF.seq) 
    2525 
    2626def test_multi(): 

  • rdfalchemy/trunk/test/delete_test.py

    r94 r98  
    22from rdfalchemy.samples.doap import * 
    33from rdfalchemy.samples.foaf import * 
     4from rdfalchemy.orm import mapper 
    45from rdflib import ConjunctiveGraph 
    56 
    … …  
    1213 
    1314Person.db=ConjunctiveGraph() 
    14 Person.knows = rdflibMultiple(FOAF.knows, range_type=FOAF.Person)         
     15Person.knows = rdfMultiple(FOAF.knows, range_type=FOAF.Person)         
    1516 
    1617 
    … …  
    2122 
    2223def test_addBNodeKnowsL(): 
    23     Person.knows = rdflibList(FOAF.knows, range_type=FOAF.Person)         
     24    Person.knows = rdfList(FOAF.knows, range_type=FOAF.Person)         
     25    mapper() 
    2426    p1=Person.get_by(first="Philip") 
    2527    p2=Person(last="Cooper" , first="Ben") 
    … …  
    3436     
    3537def test_addBNodeKnowsM(): 
    36     Person.knows = rdflibMultiple(FOAF.knows, range_type=FOAF.Person)         
     38    Person.knows = rdfMultiple(FOAF.knows, range_type=FOAF.Person)         
    3739    p1=Person.get_by(first="Philip") 
    3840    p2=Person(last="Cooper" , first="Ben") 

  • rdfalchemy/trunk/test/get_test.py

    r97 r98  
    11from rdfalchemy import * 
     2from rdfalchemy.orm import mapper 
    23from rdfalchemy.samples.doap import * 
    34from rdfalchemy.samples.foaf import * 
    … …  
    56 
    67import logging 
    7 log = logging.getLogger('rdfalchemy') 
     8log = logging.getLogger() 
    89if not log.handlers: 
    910    log.addHandler(logging.StreamHandler()) 
    … …  
    1516 
    1617def test_addBNodeKnowsL(): 
    17     Person.knows = rdflibList(FOAF.knowsL, range_type=FOAF.Person)         
     18    Person.knows = rdfList(FOAF.knowsL, range_type=FOAF.Person)         
    1819    p1=Person(first="PhilipL") 
    1920    p2=Person(last="Cooper" , first="Ben") 
    … …  
    2627     
    2728def test_addBNodeKnowsC(): 
    28     Person.knows = rdflibContainer(FOAF.knowsC, range_type=FOAF.Person)         
     29    Person.knows = rdfContainer(FOAF.knowsC, range_type=FOAF.Person)        
     30    mapper()  
    2931    p1=Person(first="PhilipC") 
    3032    p2=Person(last="Cooper" , first="Ben") 
    … …  
    3739     
    3840def test_addBNodeKnowsM(): 
    39     Person.knows = rdflibMultiple(FOAF.knowsM, range_type=FOAF.Person)         
     41    Person.knows = rdfMultiple(FOAF.knowsM, range_type=FOAF.Person)         
     42    mapper() 
    4043    p1=Person(first="PhilipM") 
    4144    p2=Person(last="Cooper" , first="Ben")