revert chagnes to cwltool/schemas/*

Author: mr-c

cwltool/schemas/draft-2/draft-2/index.py

@@ -16,8 +16,7 @@
 linenum = 0
 for l in main:
     linenum += 1
-    l = l.rstrip().lower().replace(".", "").replace(
-        ",", "").replace(";", "").replace("-", " ")
+    l = l.rstrip().lower().replace(".", "").replace(",", "").replace(";", "").replace("-", " ")
     for w in l.split(" "):
         if w:
             if w not in words:

cwltool/schemas/draft-3/draft-3/index.py

@@ -17,8 +17,7 @@
 linenum = 0
 for l in main:
     linenum += 1
-    l = l.rstrip().lower().replace(".", "").replace(
-        ",", "").replace(";", "").replace("-", " ")
+    l = l.rstrip().lower().replace(".", "").replace(",", "").replace(";", "").replace("-", " ")
     for w in l.split(" "):
         if w:
             if w not in words:

cwltool/schemas/draft-3/salad/schema_salad/jsonld_context.py

@@ -17,7 +17,6 @@
 
 _logger = logging.getLogger("salad")
 
-
 def pred(datatype, field, name, context, defaultBase, namespaces):
     split = urlparse.urlsplit(name)
 
@@ -34,7 +33,7 @@ def pred(datatype, field, name, context, defaultBase, namespaces):
     if field and "jsonldPredicate" in field:
         if isinstance(field["jsonldPredicate"], dict):
             v = {("@"+k[1:] if k.startswith("_") else k): v
-                 for k,v in field["jsonldPredicate"].items()}
+                 for k,v in field["jsonldPredicate"].items() }
         else:
             v = field["jsonldPredicate"]
     elif "jsonldPredicate" in datatype:
@@ -52,15 +51,13 @@ def pred(datatype, field, name, context, defaultBase, namespaces):
 
     if name in context:
         if context[name] != v:
-            raise Exception("Predicate collision on %s, '%s' != '%s'" %
-                            (name, context[name], v))
+            raise Exception("Predicate collision on %s, '%s' != '%s'" % (name, context[name], v))
     else:
         _logger.debug("Adding to context '%s' %s (%s)", name, v, type(v))
         context[name] = v
 
     return v
 
-
 def process_type(t, g, context, defaultBase, namespaces, defaultPrefix):
     if t["type"] == "record":
         recordname = t["name"]
@@ -81,14 +78,12 @@ def process_type(t, g, context, defaultBase, namespaces, defaultPrefix):
             predicate = "%s:%s" % (defaultPrefix, recordname)
 
         if context.get(recordname, predicate) != predicate:
-            raise Exception("Predicate collision on '%s', '%s' != '%s'" %
-                            (recordname, context[t["name"]], predicate))
+            raise Exception("Predicate collision on '%s', '%s' != '%s'" % (recordname, context[t["name"]], predicate))
 
         if not recordname:
             raise Exception()
 
-        _logger.debug("Adding to context '%s' %s (%s)",
-                      recordname, predicate, type(predicate))
+        _logger.debug("Adding to context '%s' %s (%s)", recordname, predicate, type(predicate))
         context[recordname] = predicate
 
         for i in t.get("fields", []):
@@ -116,8 +111,7 @@ def process_type(t, g, context, defaultBase, namespaces, defaultPrefix):
                 # TODO generate range from datatype.
 
             if isinstance(i["type"], dict) and "name" in i["type"]:
-                process_type(
-                    i["type"], g, context, defaultBase, namespaces, defaultPrefix)
+                process_type(i["type"], g, context, defaultBase, namespaces, defaultPrefix)
 
         if "extends" in t:
             for e in aslist(t["extends"]):

cwltool/schemas/draft-3/salad/schema_salad/main.py

@@ -21,13 +21,10 @@
 import rdflib_jsonld.parser
 register('json-ld', Parser, 'rdflib_jsonld.parser', 'JsonLDParser')
 
-
 def printrdf(workflow, wf, ctx, sr):
-    g = Graph().parse(data=json.dumps(wf),
-                      format='json-ld', location=workflow, context=ctx)
+    g = Graph().parse(data=json.dumps(wf), format='json-ld', location=workflow, context=ctx)
     print(g.serialize(format=sr))
 
-
 def main(args=None):
     if args is None:
         args = sys.argv[1:]
@@ -38,41 +35,27 @@ def main(args=None):
                         default="turtle")
 
     exgroup = parser.add_mutually_exclusive_group()
-    exgroup.add_argument("--print-jsonld-context",
-                         action="store_true", help="Print JSON-LD context for schema")
-    exgroup.add_argument(
-        "--print-doc", action="store_true", help="Print HTML documentation from schema")
-    exgroup.add_argument(
-        "--print-rdfs", action="store_true", help="Print RDF schema")
-    exgroup.add_argument(
-        "--print-avro", action="store_true", help="Print Avro schema")
-
-    exgroup.add_argument("--print-rdf", action="store_true",
-                         help="Print corresponding RDF graph for document")
-    exgroup.add_argument(
-        "--print-pre", action="store_true", help="Print document after preprocessing")
-    exgroup.add_argument(
-        "--print-index", action="store_true", help="Print node index")
-    exgroup.add_argument(
-        "--print-metadata", action="store_true", help="Print document metadata")
-    exgroup.add_argument(
-        "--version", action="store_true", help="Print version")
+    exgroup.add_argument("--print-jsonld-context", action="store_true", help="Print JSON-LD context for schema")
+    exgroup.add_argument("--print-doc", action="store_true", help="Print HTML documentation from schema")
+    exgroup.add_argument("--print-rdfs", action="store_true", help="Print RDF schema")
+    exgroup.add_argument("--print-avro", action="store_true", help="Print Avro schema")
+
+    exgroup.add_argument("--print-rdf", action="store_true", help="Print corresponding RDF graph for document")
+    exgroup.add_argument("--print-pre", action="store_true", help="Print document after preprocessing")
+    exgroup.add_argument("--print-index", action="store_true", help="Print node index")
+    exgroup.add_argument("--print-metadata", action="store_true", help="Print document metadata")
+    exgroup.add_argument("--version", action="store_true", help="Print version")
 
     exgroup = parser.add_mutually_exclusive_group()
-    exgroup.add_argument(
-        "--strict", action="store_true", help="Strict validation (unrecognized or out of place fields are error)",
+    exgroup.add_argument("--strict", action="store_true", help="Strict validation (unrecognized or out of place fields are error)",
                          default=True, dest="strict")
-    exgroup.add_argument(
-        "--non-strict", action="store_false", help="Lenient validation (ignore unrecognized fields)",
+    exgroup.add_argument("--non-strict", action="store_false", help="Lenient validation (ignore unrecognized fields)",
                          default=True, dest="strict")
 
     exgroup = parser.add_mutually_exclusive_group()
-    exgroup.add_argument(
-        "--verbose", action="store_true", help="Default logging")
-    exgroup.add_argument(
-        "--quiet", action="store_true", help="Only print warnings and errors.")
-    exgroup.add_argument(
-        "--debug", action="store_true", help="Print even more logging")
+    exgroup.add_argument("--verbose", action="store_true", help="Default logging")
+    exgroup.add_argument("--quiet", action="store_true", help="Only print warnings and errors.")
+    exgroup.add_argument("--debug", action="store_true", help="Print even more logging")
 
     parser.add_argument("schema", type=str)
     parser.add_argument("document", type=str, nargs="?", default=None)
@@ -93,17 +76,15 @@ def main(args=None):
             _logger.info("%s %s", sys.argv[0], pkg[0].version)
 
     # Get the metaschema to validate the schema
-    metaschema_names, metaschema_doc, metaschema_loader = schema.get_metaschema(
-    )
+    metaschema_names, metaschema_doc, metaschema_loader = schema.get_metaschema()
 
     # Load schema document and resolve refs
 
     schema_uri = args.schema
     if not urlparse.urlparse(schema_uri)[0]:
         schema_uri = "file://" + os.path.abspath(schema_uri)
     schema_raw_doc = metaschema_loader.fetch(schema_uri)
-    schema_doc, schema_metadata = metaschema_loader.resolve_all(
-        schema_raw_doc, schema_uri)
+    schema_doc, schema_metadata = metaschema_loader.resolve_all(schema_raw_doc, schema_uri)
 
     # Optionally print the schema after ref resolution
     if not args.document and args.print_pre:
@@ -118,19 +99,16 @@ def main(args=None):
     try:
         metaschema_loader.validate_links(schema_doc)
     except (validate.ValidationException) as e:
-        _logger.error("Schema `%s` failed link checking:\n%s",
-                      args.schema, e, exc_info=(e if args.debug else False))
+        _logger.error("Schema `%s` failed link checking:\n%s", args.schema, e, exc_info=(e if args.debug else False))
         _logger.debug("Index is %s", metaschema_loader.idx.keys())
         _logger.debug("Vocabulary is %s", metaschema_loader.vocab.keys())
         return 1
 
     # Validate the schema document against the metaschema
     try:
-        schema.validate_doc(
-            metaschema_names, schema_doc, metaschema_loader, args.strict)
+        schema.validate_doc(metaschema_names, schema_doc, metaschema_loader, args.strict)
     except validate.ValidationException as e:
-        _logger.error("While validating schema `%s`:\n%s" %
-                      (args.schema, str(e)))
+        _logger.error("While validating schema `%s`:\n%s" % (args.schema, str(e)))
         return 1
 
     # Get the json-ld context and RDFS representation from the schema
@@ -139,20 +117,16 @@ def main(args=None):
         metactx = schema_raw_doc.get("$namespaces", {})
         if "$base" in schema_raw_doc:
             metactx["@base"] = schema_raw_doc["$base"]
-    (schema_ctx, rdfs) = jsonld_context.salad_to_jsonld_context(
-        schema_doc, metactx)
+    (schema_ctx, rdfs) = jsonld_context.salad_to_jsonld_context(schema_doc, metactx)
 
     # Create the loader that will be used to load the target document.
     document_loader = Loader(schema_ctx)
 
-    # Make the Avro validation that will be used to validate the target
-    # document
-    (avsc_names, avsc_obj) = schema.make_avro_schema(
-        schema_doc, document_loader)
+    # Make the Avro validation that will be used to validate the target document
+    (avsc_names, avsc_obj) = schema.make_avro_schema(schema_doc, document_loader)
 
     if isinstance(avsc_names, Exception):
-        _logger.error("Schema `%s` error:\n%s", args.schema,
-                      avsc_names, exc_info=(avsc_names if args.debug else False))
+        _logger.error("Schema `%s` error:\n%s", args.schema, avsc_names, exc_info=(avsc_names if args.debug else False))
         if args.print_avro:
             print json.dumps(avsc_obj, indent=4)
         return 1
@@ -194,8 +168,7 @@ def main(args=None):
             doc = "file://" + os.path.abspath(uri)
         document, doc_metadata = document_loader.resolve_ref(uri)
     except (validate.ValidationException, RuntimeError) as e:
-        _logger.error("Document `%s` failed validation:\n%s",
-                      args.document, e, exc_info=(e if args.debug else False))
+        _logger.error("Document `%s` failed validation:\n%s", args.document, e, exc_info=(e if args.debug else False))
         return 1
 
     # Optionally print the document after ref resolution
@@ -211,18 +184,15 @@ def main(args=None):
     try:
         document_loader.validate_links(document)
     except (validate.ValidationException) as e:
-        _logger.error("Document `%s` failed link checking:\n%s",
-                      args.document, e, exc_info=(e if args.debug else False))
-        _logger.debug("Index is %s", json.dumps(
-            document_loader.idx.keys(), indent=4))
+        _logger.error("Document `%s` failed link checking:\n%s", args.document, e, exc_info=(e if args.debug else False))
+        _logger.debug("Index is %s", json.dumps(document_loader.idx.keys(), indent=4))
         return 1
 
     # Validate the schema document against the metaschema
     try:
         schema.validate_doc(avsc_names, document, document_loader, args.strict)
     except validate.ValidationException as e:
-        _logger.error("While validating document `%s`:\n%s" %
-                      (args.document, str(e)))
+        _logger.error("While validating document `%s`:\n%s" % (args.document, str(e)))
         return 1
 
     # Optionally convert the document to RDF