0.17.0: fixed issues with reqif_io QUERY_PASSWORD and selecting configuraiton

Author: barny

.bumpversion.cfg

@@ -1,5 +1,5 @@
 [bumpversion]
-current_version = 0.15.0
+current_version = 0.17.0
 commit = True
 tag = True
 

README.md

@@ -8,7 +8,7 @@
 
  SPDX-License-Identifier: MIT
 
- version="0.15.0"
+ version="0.17.0"
 
 
 Introduction

elmclient/__meta__.py

@@ -9,7 +9,7 @@
 
 app = 'elmoslcquery'
 description = 'Commandline OSLC query for ELM'
-version = '0.15.0'
+version = '0.17.0'
 license = 'MIT'
 author_name = 'Ian Barnard'
 author_mail = 'ian.barnard@uk.ibm.com'

elmclient/_qm.py

@@ -104,7 +104,6 @@ def load_components_and_configurations(self,force=False):
             # get all components
             crx = self.execute_get_xml( components_uri, intent="Retrieve component definition" )
             logger.info( f"{crx=}" )
-            print( f"{crx=}" )
 #      <oslc_config:Component rdf:about="https://jazz.ibm.com:9443/qm/oslc_config/resources/com.ibm.team.vvc.Component/_iw4s4EB3Eeus6Zk4qsm_Cw">
 #        <dcterms:title rdf:parseType="Literal">SGC Agile</dcterms:title>
 #        <oslc:instanceShape rdf:resource="https://jazz.ibm.com:9443/qm/oslc_config/resourceShapes/com.ibm.team.vvc.Component"/>

elmclient/_queryparser.py

@@ -247,7 +247,7 @@ def term(self, s):
             #
             if op == "in":
                 # the "value" is actually a list of values, each of which must be resolved if it is an identifier
-                print( f"{value=}" )
+                logger.info( f"{value=}" )
                 if not isinstance(value, list):
                     value = [value]
                 resultlist = []
@@ -516,7 +516,6 @@ def inop(self, s):
 
     def scoped_term(self, s):
         logger.info( f"scoped_term {s=}" )
-        print( f"scoped_term {s=}" )
         return [s[0], "scope", s[1:]]
 
 # from https://tools.oasis-open.org/version-control/svn/oslc-core/trunk/specs/oslc-core.html#selectiveProperties
@@ -533,7 +532,7 @@ def scoped_term(self, s):
                     | "'" SPACYNAME "'"
 
 URI_REF_ESC     : /<https?:.*>/
-NAME            : /[a-zA-Z0-9_]\w*/
+NAME            : /[a-zA-Z0-9_][^, ]*/
 SPACYNAME           : /[a-zA-Z0-9_][^']*/
 """
 
@@ -578,9 +577,11 @@ def wildcard(self,s):
         return "*"
 
     def properties(self,s):
+        logger.info( f"properties {s=} {s[0]=}" )
         return s
 
     def property(self,s):
+        logger.info( f"property {s=} {s[0]=}" )
         return s[0]
 
     def sort_terms(self,s):
@@ -590,14 +591,17 @@ def sort_term(self,s):
         return s[0]
 
     def signedterm(self,s):
+        logger.info( f"signedterm {s=} {s[0]=}" )
         # mapping to always + or -
         signs = { ">": "+", "<": '-', "+": "+", "-": "-"}
         return signs[s[0]]+s[1]
 
     def scoped_sort_terms(self,s):
+        logger.info( f"scoped_sort_terms {s=} {s[0]=}" )
         return s
 
     def identifier(self, s):
+        logger.info( f"identifier {s=} {s[0]=}" )
         if len(s) == 1:
             resultname = s[0].value
         elif len(s) > 1:
@@ -622,7 +626,10 @@ def identifier(self, s):
                 raise Exception( f"Cannot resolve {resultname} - no name resolver provided! " )
         else:
             # a prefixed name is assumed to be usable directly (the prefix has been added to prefixes)
+            prefix = resultname.split( ":",1 )[0]
+            self.prefixes[rdfxml.RDF_DEFAULT_PREFIX[prefix]] = prefix
             result = resultname
+        logger.info( f"identifier1 {result=}" )
         return result
 
     def dottedname(self,s):
@@ -641,3 +648,4 @@ def dottedname(self,s):
         self.mapping_uri_to_identifer[result] = f"{shapename}.{propname}"
         logger.info( f"dottedname {s=} {s[0]=} returns {result}" )
         return result
+

elmclient/_rm.py

@@ -567,11 +567,31 @@ def _load_type_from_resource_shape(self, el, supershape=None):
                 logger.debug( f"ALREADY KNOWN" )
                 continue
 
+            # get the property definition
+            # a link has a Reference oslc:representation
+            if rdfxml.xml_find_element( el, "oslc:representation[@rdf:resource='http://open-services.net/ns/core#Reference']") is not None:
+                if propuri is not None:
+                # this could be a link type or an attribute datatype reference
+                # confirm this is a link type by checking for oslc:representation rdf:resource="http://open-services.net/ns/core#Reference"
+                
+                    # record the link type in the typesystem
+                    if propuri.startswith( self.reluri() ):
+                        linktype_x = self._get_typeuri_rdf(propuri)
+                        label = rdfxml.xml_find_element(linktype_x, './/rdfs:label').text
+                        ilabel = rdfxml.xml_find_element(linktype_x, './/rdfs:inverseLabel')
+                        inverselabel = ilabel.text if ilabel is not None else None
+                        rdfuri = None
+                    else:
+                        rdfuri = propuri
+                        label = property_title
+                        inverselabel = None
+                        
+                    self.register_linktype( property_title, propuri, label, inverselabel=inverselabel, rdfuri=rdfuri, shape_uri=uri )
             logger.info( f"Defining property {name}.{property_title} {propuri=} +++++++++++++++++++++++++++++++++++++++" )
 #            print( f"Defining property {name}.{property_title} {propuri=} {uri=} +++++++++++++++++++++++++++++++++++++++" )
 #            self.register_property(property_title,propuri, shape_uri=uri)
             self.register_property(property_title,propuri)
-
+            # load the attribute definitions
             n += 1
             for range_el in rdfxml.xml_find_elements(el, 'oslc:range'):
                 range_uri = range_el.get("{%s}resource" % rdfxml.RDF_DEFAULT_PREFIX["rdf"])

elmclient/_typesystem.py

@@ -26,6 +26,7 @@ def __init__(self,*args,**kwargs):
     def clear_typesystem(self):
         self.shapes = {}
         self.properties = {}
+        self.linktypes = {}
         self.enums = {}
         self.values = {}
         self.typesystem_loaded = False
@@ -47,9 +48,11 @@ def addtoreport(s, end='\n'):
             report += s + end
 
         reportedproperties = []
+        reportedlinktypes = []
         # print a nicely sorted report with shapes at left, then properties (with type, if defined) in that shape, then enumerations in that property
         for shapeuri in sorted(self.shapes.keys(),key=lambda k: self.shapes[k]['name'].lower()):
             rows.append( [f"{quote(self.shapes[shapeuri]['name']):25}"] )
+            # properties
             for propertyuri in sorted(self.shapes[shapeuri]['properties'], key=lambda k: self.properties[k]['name'].lower()):
                 reportedproperties.append(propertyuri)
                 rows.append( [ "",f"{quote(self.properties[propertyuri]['name'])}"] )
@@ -68,6 +71,21 @@ def addtoreport(s, end='\n'):
                     eid = self.enums[enum_uri].get('id') or enum_uri
                     rows.append( [""]*newrowlen+[f"{quote(self.enums[enum_uri]['name'])}",eid,enum_uri ] )
                     logger.info( f"appended for enum {rows[-1]}" )
+            # linktypes not reported on the shape as they're common to all shapes
+#            # link types
+#            for linktypeuri in sorted(self.shapes[shapeuri].get('linktypes',[]), key=lambda k: self.linktypes[k]['name'].lower()):
+#                reportedlinktypes.append(linktypeuri)
+#                rows.append( [ "",f"{quote(self.linktypes[linktypeuri]['name'])}"] )
+#                rows[-1].append( f"{rdfxml.uri_to_default_prefixed_tag(linktypeuri)}" )
+#                if self.linktypes[linktypeuri]['rdfuri'] is not None:
+#                    rows[-1].append( f"{rdfxml.uri_to_default_prefixed_tag(self.linktypes[linktypeuri]['rdfuri'])}" )
+#                else:
+#                    rows[-1].append("")
+#                rows[-1].append( f"{self.linktypes[linktypeuri]['label']}" )
+#                rows[-1].append( f"{self.linktypes[linktypeuri]['inverselabel']}" )
+                
+                newrowlen = len(rows[-1])-3
+            
         if len(rows)>0:
             addtoreport( "<h2>Shapes<h2>\n" )
             report += utils.print_in_html( rows,['Shape','Property Name','Property label','URI'] )
@@ -93,10 +111,26 @@ def addtoreport(s, end='\n'):
                     eid = self.enums[enum_uri].get('id') or enum_uri
                     rows.append( [""]*newrowlen+[f"{quote(self.enums[enum_uri]['name'])}",eid,enum_uri ] )
                     logger.info( f"appended for enum {rows[-1]}" )
-
         if len(rows)>0:
             addtoreport( "<h2>Properties with no shape</h2>\n" )
             report += utils.print_in_html( rows,['Shape','Property Name','Property label','URI'] )
+            
+        # now report link types
+        rows = []
+        for linktypeuri in sorted(self.linktypes, key=lambda k: self.linktypes[k]['name'].lower()):
+            rows.append( [ f"{quote(self.linktypes[linktypeuri]['name'])}"] )
+            rows[-1].append( f"{rdfxml.uri_to_default_prefixed_tag(linktypeuri)}" )
+            if self.linktypes[linktypeuri]['rdfuri'] is not None:
+                rows[-1].append( f"{rdfxml.uri_to_default_prefixed_tag(self.linktypes[linktypeuri]['rdfuri'])}" )
+            else:
+                rows[-1].append("")
+            rows[-1].append( f"{self.linktypes[linktypeuri]['label']}" )
+            rows[-1].append( f"{self.linktypes[linktypeuri]['inverselabel']}" )
+                
+        if len(rows)>0:
+            addtoreport( "<h2>Link Types</h2>\n" )
+            report += utils.print_in_html( rows,['Name', 'URI', 'RDF URI','Label','Inverse Label'] )
+            
 
         return report
 
@@ -127,7 +161,7 @@ def register_shape( self, shape_name, shape_uri ):
         if shape_uri in self.shapes:
             raise Exception( f"Shape {shape_uri} already defined!" )
         # add the URI as the main registration for the shape
-        self.shapes[shape_uri] = {'name':shape_name,'shape':shape_uri,'properties':[]}
+        self.shapes[shape_uri] = {'name':shape_name,'shape':shape_uri,'properties':[], 'linktypes':[]}
         self.loaded = True
 
     def get_shape_uri( self, shape_name ):
@@ -173,6 +207,17 @@ def register_property( self, property_name, property_uri, *, property_value_type
             self.shapes[shape_uri]['properties'].append(property_uri)
         self.loaded = True
 
+    def register_linktype( self, linktype_name, linktype_uri, label, *, inverselabel=None, rdfuri=None, shape_uri=None ):
+        logger.info( f"register_linktype {linktype_name=} {linktype_uri=} {label=} {inverselabel=} {rdfuri=}" )
+        linktype_uri = self.normalise_uri( 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 }
+        if shape_uri is not None:
+            self.shapes[shape_uri]['linktypes'].append(linktype_uri)
+        self.loaded = True
+
     def get_property_uri( self, property_name, *, shape_uri=None ):
         logger.info( f"get_property_uri {property_name=} {shape_uri=}" )
         shape_uri = self.normalise_uri( shape_uri )
@@ -269,5 +314,15 @@ def get_uri_name( self, uri ):
         return result
 
     def get_name_uri( self, name ):
-        result = self.get_shape_uri(name) or self.get_property_uri(name) or self.get_enum_uri(name) or self.get_value_uri(name)
+        result = self.get_shape_uri(name) or self.get_property_uri(name) or self.get_enum_uri(name) or self.get_value_uri(name) or self.get_linktype_uri(name)
         return result
+
+    def get_linktype_uri( self, name ):
+        linktypes = [k for k,v in self.linktypes.items() if v['name']==name]
+        if len(linktypes) > 1:
+            raise Exception( f"Multiple link types with same name '{name}'" )
+        if len(linktypes) == 0:
+            return None
+            
+        return linktypes[0]
+