dn resource scenarios 1-4 now working. Changes to _rm/, _typesystem,/resource.py to implement resources creating artifact, linking, assigning properties

Author: barny

elmclient/_project.py

@@ -302,8 +302,10 @@ def resolve_property_name_to_uri(self, name, shapeuri=None, exception_if_not_fou
     # the context is the attribute definition - needed to be specified ultimately by the user when enumeration value names aren't unique
     def resolve_enum_name_to_uri(self, name, propertyuri=None, exception_if_not_found=True):
         logger.info( f"resolve_enum_name_to_uri {name=} {propertyuri=}" )
+#        print( f"resolve_enum_name_to_uri {name=} {propertyuri=}" )
         result = self.get_enum_id(name,propertyuri)
         logger.info( f"resolve_enum_name_to_uri {name=} {propertyuri=} {result=}" )
+#        print( f"resolve_enum_name_to_uri {name=} {propertyuri=} {result=}" )
         return result
 
     # for OSLC query, given a type URI, return its name

elmclient/_queryparser.py

@@ -270,9 +270,13 @@ def term(self, s):
             else:
                 t1 = type(value)
                 logger.info( f"t1 {value} {t1=}" )
+#                print( f"t1 {value} {t1=}" )
                 if isinstance(value, str) and not value.startswith('"') and not value.startswith("'") and ':' not in value and not re.match(r"\d",value):
                     # this is a valueidentifier - try to resolve it as an enum in the context of identifier
                     if self.resolverobject.resolve_enum_name_to_uri is not None:
+#                        print( f"{self.resolverobject.resolve_enum_name_to_uri(value, identifier)=}" )
+#                        print( f"{self.resolverobject=}" )
+#                        print( f"{self.resolverobject.resolve_enum_name_to_uri=}" )
                         result = self.resolverobject.resolve_enum_name_to_uri(value, identifier)
                         if result is None:
                             raise Exception(f"Single ref {value} not resolved in context {identifier}")
@@ -281,6 +285,7 @@ def term(self, s):
                         else:
                             s[2] = '"'+result+'"'
         logger.info( f"Term returning {s}" )
+#        print( f"Term returning {s}" )
         return s
 
     def simpleidentifier(self,s):

elmclient/_rm.py

@@ -1079,37 +1079,36 @@ def _load_type_from_resource_shape(self, el, supershape=None):
             if property_title_x is None:
                 burp
             property_title = property_title_x.text
-            print( f"Loading prop {property_title}" )
+#            print( f"Loading prop {property_title}" )
 #            propuri = rdfxml.xml_find_element( el, 'oslc:propertyDefinition').get( "{%s}resource" % rdfxml.RDF_DEFAULT_PREFIX["rdf"])
             propuri = rdfxml.xmlrdf_get_resource_uri( el, 'oslc:propertyDefinition')
-            print( f"{propuri=}" )
+#            print( f"{propuri=}" )
             # prefer range over valueType (doesn't nmatter for rm but does for qm which has both in a property definition)
             proptype = rdfxml.xmlrdf_get_resource_uri( el,'oslc:range' )
             if proptype is None:
                 proptype = rdfxml.xmlrdf_get_resource_uri(el,'oslc:valueType' ) 
-            print( f"{proptype=}" )
+#            print( f"{proptype=}" )
             # lookup the codec, if there is one
             propcodec = valueTypeToCodec.get( proptype )
-            print( f"{propcodec=}" )
+#            print( f"{propcodec=}" )
 
             # work out if multivalued
             mvtext_x = rdfxml.xmlrdf_get_resource_uri( el, "oslc:occurs" )            
             isMultiValued = mvtext_x=="http://open-services.net/ns/core#Zero-or-many"
 #            print( f"{property_title} {isMultiValued=} {mvtext_x=}" )
 
-            self.register_property( property_title, propuri, isMultiValued=isMultiValued, shape_uri=uri, typeCodec=propcodec )
-
             if self.is_known_property_uri( propuri ):
                 logger.debug( f"ALREADY KNOWN" )
-                print( f"ALREADY KNOWN" )
+#                print( f"ALREADY KNOWN" )
                 continue
 
+            self.register_property( property_title, propuri, isMultiValued=isMultiValued, shape_uri=uri, typeCodec=propcodec )
 
             # get the property definition
             # all links have a Reference oslc:representation
             # true links have         <oslc:range rdf:resource="http://open-services.net/ns/core#Resource"/>
             if rdfxml.xml_find_element( el, "oslc:representation[@rdf:resource='http://open-services.net/ns/core#Reference']") is not None and ( rdfxml.xml_find_element( el, "oslc:range[@rdf:resource='http://open-services.net/ns/core#Resource']" ) is not None or rdfxml.xml_find_element( el, "oslc:valueType[@rdf:resource='http://open-services.net/ns/core#Resource']" ) is not None):
-                print( f"Ref {propuri=}" )
+#                print( f"Ref {propuri=}" )
                 if propuri is not None:
 #                    print( f"Ref1 {propuri=}" )
                     if propcodec is None: # don't override if the codec is already set!
@@ -1131,7 +1130,7 @@ def _load_type_from_resource_shape(self, el, supershape=None):
                     self.register_linktype( property_title, propuri, label, inverselabel=inverselabel, rdfuri=rdfuri, typeCodec=propcodec, isMultiValued=isMultiValued )
             if True:
                 logger.info( f"Defining property {name}.{property_title} {propuri=}  {propcodec=} +++++++++++++++++++++++++++++++++++++++" )
-                print( f"Defining property {name}.{property_title} {propuri=} {uri=} {propcodec=} +++++++++++++++++++++++++++++++++++++++" )
+#                print( f"Defining property {name}.{property_title} {propuri=} {uri=} {propcodec=} +++++++++++++++++++++++++++++++++++++++" )
 #            self.register_property(property_title,propuri, shape_uri=uri)
 
 #            if property_title=="Residual POHS":
@@ -1777,7 +1776,7 @@ def deliver( self, *, targetstream_u=None, policy=None ):
 
             for apolicy in policies:
                 policyxml += f'<rm_config:policy rdf:resource="{apolicy}" />'
-        print( f"{policyxml=}" )
+#        print( f"{policyxml=}" )
 
         body=f"""<rdf:RDF
     xmlns:dcterms="http://purl.org/dc/terms/"

elmclient/_typesystem.py

@@ -5,14 +5,31 @@
 
 
 import logging
+import keyword
 
 from . import rdfxml
 from . import utils
 
+
 logger = logging.getLogger(__name__)
 
 #################################################################################################
 
+def makeSafeAttributeName( name, propuri ):
+#    print( f"Make safe name fror {name } so it can be used as a Python object attribute" )
+    res = ""
+    for c in name:
+        if not c.isalpha():
+            c = "_"
+        res += c
+    if keyword.iskeyword( res ) or keyword.issoftkeyword( res ):
+#        print( f"unsafe {name}" )
+        res = makeSafeAttributeName( rdfxml.uri_to_prefixed_tag( propuri ), propuri )
+#    print( f"Make safe name fror {name } {res}" )
+    return res
+
+#################################################################################################
+
 class No_Type_System_Mixin():
     def __init__(self,*args,**kwargs):
         self.has_typesystem=False
@@ -179,7 +196,7 @@ def is_known_linktype_uri( self, uri ):
 
     def register_shape( self, shape_name, shape_uri, *, rdfuri=None, shape_formats=None ):
         logger.info( f"register_shape {shape_name=} {shape_uri=}" )
-        print( f"register_shape {shape_name=} {shape_uri=}" )
+#        print( f"register_shape {shape_name=} {shape_uri=}" )
         shape_uri = self.normalise_uri( shape_uri)
         if shape_uri in self.shapes:
             raise Exception( f"Shape {shape_uri} already defined!" )
@@ -222,19 +239,24 @@ def is_known_property_uri( self, property_uri, *, raiseifnotfound=True ):
 #    def register_property( self, property_name, property_uri, *, property_value_type=None, shape_uri=None, altname = None, do_not_overwrite=True, property_definition_uri=None, isMultiValued=False, typeCodec=None ):
     def register_property( self, property_name, property_uri, *, shape_uri=None, property_value_type=None, altname = None, do_not_overwrite=True, property_definition_uri=None, isMultiValued=False, typeCodec=None ):
         logger.info( f"register_property {property_name=} {property_uri=} {isMultiValued=} {typeCodec=}" )
-        print( f"register_property {property_name=} {property_uri=} {isMultiValued=} {typeCodec=}" )
+#        print( f"register_property {property_name=} {property_uri=} {isMultiValued=} {typeCodec=}" )
         if property_uri in self.properties:
 #            print( f"Already defined {self.properties[property_uri]=}" )
 #            burp
             pass
         property_uri = self.normalise_uri( property_uri )
+        safeName = makeSafeAttributeName( property_name, property_uri )
 #        shape_uri = self.normalise_uri( shape_uri )
+
         if not do_not_overwrite or property_uri not in self.properties:
 #            self.properties[property_uri] = {'name': property_name, 'shape': shape_uri, 'enums': [], 'value_type': property_value_type, 'altname':altname, 'isMultiValued':isMultiValued, 'typeCodec': typeCodec }
-            self.properties[property_uri] = {'name': property_name, 'enums': [], 'value_type': property_value_type, 'altname':altname, 'isMultiValued':isMultiValued, 'typeCodec': typeCodec }
+            self.properties[property_uri] = {'name': property_name, 'safeName': safeName, 'enums': [], 'value_type': property_value_type, 'altname':altname, 'isMultiValued':isMultiValued, 'typeCodec': typeCodec }
+
         if altname and property_definition_uri and ( not do_not_overwrite or property_definition_uri not in self.properties):
             self.properties[property_definition_uri] = {'name': altname, 'enums': [], 'value_type': property_value_type, 'altname':None, 'isMultiValued':isMultiValued, 'typeCodec': typeCodec }
             self.properties[rdfxml.uri_to_default_prefixed_tag(property_definition_uri)] = {'name': altname, 'enums': [], 'value_type': property_value_type, 'altname':None, 'isMultiValued':isMultiValued, 'typeCode': typeCodec }
+            
+        # make sure the property is recorded on the shape
         if shape_uri is not None and property_uri not in self.shapes[shape_uri]['properties']:
             self.shapes[shape_uri]['properties'].append(property_uri)
 
@@ -253,10 +275,13 @@ def register_property_codec( self, property_name, property_uri, codec ):
     def register_linktype( self, linktype_name, linktype_uri, label, *, inverselabel=None, rdfuri=None, isMultiValued=False, typeCodec=None ):
         logger.info( f"register_linktype {linktype_name=} {linktype_uri=} {label=} {inverselabel=} {rdfuri=} {typeCodec=}" )
         linktype_uri = self.normalise_uri( linktype_uri )
+        
+        safeName = makeSafeAttributeName( linktype_name, linktype_uri )
+        
 #        shape_uri = self.normalise_uri( shape_uri )
         if linktype_uri not in self.linktypes:
 #            self.linktypes[linktype_uri] = {'name': label, 'inverselabel': inverselabel, 'shape': shape_uri, 'rdfuri': rdfuri }
-            self.linktypes[linktype_uri] = {'name': linktype_name, 'label': label, 'inverselabel': inverselabel, 'rdfuri': rdfuri, 'typeCodec': typeCodec }
+            self.linktypes[linktype_uri] = {'name': linktype_name, 'safeName': safeName, 'label': label, 'inverselabel': inverselabel, 'rdfuri': rdfuri, 'typeCodec': typeCodec }
 #        if shape_uri is not None:
 #            self.shapes[shape_uri]['linktypes'].append(linktype_uri)
 
@@ -325,6 +350,7 @@ def is_known_enum_uri( self, enum_uri ):
 
     def register_enum( self, enum_name, enum_uri, property_uri, *, id=None ):
         logger.info( f"register_enum {enum_name=} {enum_uri=} {property_uri=} {id=}" )
+#        print( f"register_enum {enum_name=} {enum_uri=} {property_uri=} {id=}" )
         # add the enum  to the property
         enum_uri = self.normalise_uri( enum_uri )
         property_uri = self.normalise_uri( property_uri )
@@ -349,16 +375,20 @@ def get_enum_name( self, enum_uri ):
 
     def get_enum_id( self, enum_name, property_uri ):
         logger.info( f"get_enum_id {enum_name=} {property_uri=}" )
+#        print( f"get_enum_id {enum_name=} {property_uri=}" )
         property_uri = self.normalise_uri( property_uri )
         result = None
         logger.info( f"{self.properties[property_uri]=}" )
+#        print( f"{self.properties[property_uri]=}" )
         logger.info( f"{self.properties[property_uri]['enums']=}" )
+#        print( f"{self.properties[property_uri]['enums']=}" )
         for enum_uri in self.properties[property_uri]['enums']:
             if self.enums[enum_uri]['name']==enum_name:
                 result = self.enums[enum_uri]['id'] or enum_uri
 #                result = enum_uri # this makes ccm queries for e.g. rc:cm:type=Defect not work - ccm doens't like getting a URI - # unfortunately I can't remember why I added this line :-(
                 break
         logger.info( f"get_enum_id {enum_name=} {property_uri=} {result=}" )
+#        print( f"get_enum_id {enum_name=} {property_uri=} {result=}" )
         return result
 
     # generic uri/name

elmclient/examples/dn_resource_scenario2.py

@@ -59,7 +59,7 @@
 # 0=fully cached (but code below specifies queries aren't cached) - if you need to clear the cache, delet efolder .web_cache
 # 1=clear cache initially then continue with cache enabled
 # 2=clear cache and disable caching
-caching = 0
+caching = 2
 
 ##################################################################################
 if __name__=="__main__":

elmclient/examples/dn_resource_scenario3.py

@@ -59,7 +59,7 @@
 # 0=fully cached (but code below specifies queries aren't cached) - if you need to clear the cache, delet efolder .web_cache
 # 1=clear cache initially then continue with cache enabled
 # 2=clear cache and disable caching
-caching = 0
+caching = 2
 
 ##################################################################################
 if __name__=="__main__":
@@ -95,14 +95,14 @@
     # create a stakeholder requirement
     reqt1 = c.createCoreResource( "Stakeholder Requirement" )
 
-    print( f"New artifact ID is {reqt1.Identifier=}" )
+    print( f"New artifact ID is {reqt1.Identifier}" )
 
-    print( f"{reqt1=}" )
+    print( f"Your new Stakeholder Requirement is:{reqt1}" )
 
 #    reqt1.Primary_Text = "Hello, World"
     reqt1.Primary_Text = '<div xmlns="http://www.w3.org/1999/xhtml">Hello, World</div>'
 
     reqt1.put()
 
-    print( f"{reqt1=}" )
+    print( f"With the Primary_Text set your Stakeholder Requirement is:{reqt1}" )
 

elmclient/examples/dn_resource_scenario4.py

@@ -60,7 +60,7 @@
 # 0=fully cached (but code below specifies queries aren't cached) - if you need to clear the cache, delet efolder .web_cache
 # 1=clear cache initially then continue with cache enabled
 # 2=clear cache and disable caching
-caching = 0
+caching = 2
 
 ##################################################################################
 if __name__=="__main__":
@@ -92,47 +92,50 @@
     print( f"{config_u=}" )
     c.set_local_config(config_u)
 
-# find an example with a pre-created link
-#    coresys=c.resourceQuery( "Identifier=4736",returnBindings=False )
+## find an example with a pre-created link so you can see the format
+#    coresys=c.resourceQuery( "Identifier=4770",returnBindings=False )
 #    print( f"{coresys=}" )
 
     #####################################################################################################
     # create a stakeholder requirement
     reqt1 = c.createCoreResource( "Stakeholder Requirement" )
 
-    print( f"Stakeholder Requirement artifact ID is {reqt1.Identifier=}" )
+    print( f"Stakeholder Requirement artifact ID is {reqt1.Identifier}" )
 
-#    print( f"{reqt1=}" )
+#    print( f"{reqt1}" )
 
     reqt1.Primary_Text = '<div xmlns="http://www.w3.org/1999/xhtml">I am what a Stakeholder wants!</div>'
 
     reqt1.put()
 
-    print( f"With the updated primaryText your Stakeholder Requirement is:\n{reqt1=}" )
+    print( f"With the updated primaryText your Stakeholder Requirement is:\n{reqt1}" )
 
     #####################################################################################################
     # create a system requirement
     reqt2 = c.createCoreResource( "System Requirement" )
 
-    print( f"System Requirement artifact ID is {reqt2.Identifier=}" )
+    print( f"System Requirement artifact ID is {reqt2.Identifier}" )
 
-#    print( f"{reqt2=}" )
+#    print( f"{reqt2}" )
 
     reqt2.Primary_Text = '<div xmlns="http://www.w3.org/1999/xhtml">I am what a Systems Engineer wants!</div>'
 
     reqt2.put()
 
-    print( f"With the updated primaryText your System Requirement is:\n{reqt2=}" )
+    print( f"With the updated primaryText your System Requirement is:\n{reqt2}" )
 
     #####################################################################################################
     # create Satisfies link from the System Requirement to the Stakeholder Requirement
     reqt2.Questions="There is a question"
+    reqt2.Test_Criteria="There are some criteria"
+    
     reqt2.put()
-    print( f"With the Questions set your System Requirement is: {reqt2=}" )
-    burp
+    
+    print( f"With the Questions set your System Requirement is: {reqt2}" )
+    
     # create the link to the reqt1 id
     reqt2.Satisfies=reqt1.Identifier
 
     reqt2.put()
 
-    print( f"With the Satisfies link your System Requirement is: {reqt2=}" )
+    print( f"With the Satisfies link your System Requirement is: {reqt2}" )

elmclient/examples/dn_resource_test.py

@@ -96,7 +96,7 @@
     print( f"{mores[0]=}" )
     mores[0].Title = mores[0].Title+"1"
     print( f"{mores[0]=}" )
-    mores[0].addCoreArtifactLink( "Satisfies", 2854 )
+#    mores[0].addCoreArtifactLink( "Satisfies", 2854 )
     print( f"After add link {mores[0]=}" )
     mores[0].to_etree()
     mores[0].put()