PythonDataset/train/cwltool-task-instances.jsonl.all

{"repo": "common-workflow-language/cwltool", "pull_number": 95, "instance_id": "common-workflow-language__cwltool-95", "issue_numbers": "", "base_commit": "efc29f3610e7062287037fa9cd834c56397bff62", "patch": "diff --git a/cwltool/builder.py b/cwltool/builder.py\n--- a/cwltool/builder.py\n+++ b/cwltool/builder.py\n@@ -34,9 +34,9 @@ class Builder(object):\n     def __init__(self):  # type: () -> None\n         self.names = None  # type: avro.schema.Names\n         self.schemaDefs = None  # type: Dict[str,Dict[unicode, Any]]\n-        self.files = None  # type: List[Dict[str, str]]\n+        self.files = None  # type: List[Dict[unicode, unicode]]\n         self.fs_access = None  # type: StdFsAccess\n-        self.job = None  # type: Dict[str, Any]\n+        self.job = None  # type: Dict[unicode, Union[Dict[unicode, Any], List, unicode]]\n         self.requirements = None  # type: List[Dict[str,Any]]\n         self.outdir = None  # type: str\n         self.tmpdir = None  # type: str\ndiff --git a/cwltool/cwlrdf.py b/cwltool/cwlrdf.py\n--- a/cwltool/cwlrdf.py\n+++ b/cwltool/cwlrdf.py\n@@ -6,7 +6,7 @@\n from typing import Any, Union, Dict, IO\n \n def makerdf(workflow, wf, ctx):\n-    # type: (Union[str, unicode], Dict[str,Any], Loader.ContextType) -> Graph\n+    # type: (Union[str, unicode], Union[List[Dict[unicode, Any]], Dict[unicode, Any]], Loader.ContextType) -> Graph\n     prefixes = {}\n     for k,v in ctx.iteritems():\n         if isinstance(v, dict):\n@@ -18,7 +18,11 @@ def makerdf(workflow, wf, ctx):\n             p, _ = frg.split(\"/\")\n             prefixes[p] = u\"%s#%s/\" % (doc_url, p)\n \n-    wf[\"@context\"] = ctx\n+    if isinstance(wf, list):\n+        for entry in wf:\n+            entry[\"@context\"] = ctx\n+    else:\n+        wf[\"@context\"] = ctx\n     g = Graph().parse(data=json.dumps(wf), format='json-ld', location=workflow)\n \n     # Bug in json-ld loader causes @id fields to be added to the graph\n@@ -31,7 +35,7 @@ def makerdf(workflow, wf, ctx):\n     return g\n \n def printrdf(workflow, wf, ctx, sr, stdout):\n-    # type: (Union[str, unicode], Dict[str, Any], Loader.ContextType, str, IO[Any]) -> None\n+    # type: (Union[str, unicode], Union[List[Dict[unicode, Any]], Dict[unicode, Any]], Loader.ContextType, str, IO[Any]) -> None\n     stdout.write(makerdf(workflow, wf, ctx).serialize(format=sr))\n \n def lastpart(uri):  # type: (Any) -> str\n@@ -172,7 +176,7 @@ def dot_without_parameters(g, stdout):  # type: (Graph, IO[Any]) -> None\n \n \n def printdot(workflow, wf, ctx, stdout, include_parameters=False):\n-    # type: (Union[str, unicode], Dict[str, Any], Loader.ContextType, Any, bool) -> None\n+    # type: (Union[str, unicode], Union[List[Dict[unicode, Any]], Dict[unicode, Any]], Loader.ContextType, Any, bool) -> None\n     g = makerdf(workflow, wf, ctx)\n \n     stdout.write(\"digraph {\")\ndiff --git a/cwltool/draft2tool.py b/cwltool/draft2tool.py\n--- a/cwltool/draft2tool.py\n+++ b/cwltool/draft2tool.py\n@@ -30,7 +30,7 @@\n \n class ExpressionTool(Process):\n     def __init__(self, toolpath_object, **kwargs):\n-        # type: (Dict[str,List[None]], **Any) -> None\n+        # type: (Dict[unicode, Any], **Any) -> None\n         super(ExpressionTool, self).__init__(toolpath_object, **kwargs)\n \n     class ExpressionJob(object):\n@@ -53,7 +53,7 @@ def run(self, **kwargs):  # type: (**Any) -> None\n                 self.output_callback({}, \"permanentFail\")\n \n     def job(self, joborder, output_callback, **kwargs):\n-        # type: (Dict[str,str], str, Callable[[Any, Any], Any], **Any) -> Generator[ExpressionTool.ExpressionJob, None, None]\n+        # type: (Dict[unicode, unicode], Callable[[Any, Any], Any], **Any) -> Generator[ExpressionTool.ExpressionJob, None, None]\n         builder = self._init_job(joborder, **kwargs)\n \n         j = ExpressionTool.ExpressionJob()\n@@ -113,14 +113,14 @@ def run(self, **kwargs):\n \n class CommandLineTool(Process):\n     def __init__(self, toolpath_object, **kwargs):\n-        # type: (Dict[str,Any], **Any) -> None\n+        # type: (Dict[unicode, Any], **Any) -> None\n         super(CommandLineTool, self).__init__(toolpath_object, **kwargs)\n \n     def makeJobRunner(self):  # type: () -> CommandLineJob\n         return CommandLineJob()\n \n     def makePathMapper(self, reffiles, **kwargs):\n-        # type: (Set[str], str, **Any) -> PathMapper\n+        # type: (Set[unicode], **Any) -> PathMapper\n         dockerReq, _ = self.get_requirement(\"DockerRequirement\")\n         try:\n             if dockerReq and kwargs.get(\"use_container\"):\n@@ -132,7 +132,7 @@ def makePathMapper(self, reffiles, **kwargs):\n                 raise WorkflowException(u\"Missing input file %s\" % e)\n \n     def job(self, joborder, output_callback, **kwargs):\n-        # type: (Dict[str,str], str, Callable[..., Any], **Any) -> Generator[Union[CommandLineJob, CallbackJob], None, None]\n+        # type: (Dict[unicode, unicode], Callable[..., Any], **Any) -> Generator[Union[CommandLineJob, CallbackJob], None, None]\n \n         jobname = uniquename(kwargs.get(\"name\", shortname(self.tool.get(\"id\", \"job\"))))\n \n@@ -149,7 +149,7 @@ def job(self, joborder, output_callback, **kwargs):\n             if docker_req and kwargs.get(\"use_container\") is not False:\n                 dockerimg = docker_req.get(\"dockerImageId\") or docker_req.get(\"dockerPull\")\n                 cmdline = [\"docker\", \"run\", dockerimg] + cmdline\n-            keydict = {\"cmdline\": cmdline}\n+            keydict = {u\"cmdline\": cmdline}\n \n             for _,f in cachebuilder.pathmapper.items():\n                 st = os.stat(f[0])\n@@ -200,7 +200,7 @@ def rm_pending_output_callback(output_callback, jobcachepending,\n \n         builder = self._init_job(joborder, **kwargs)\n \n-        reffiles = set((f[\"path\"] for f in builder.files))\n+        reffiles = set((f[u\"path\"] for f in builder.files))\n \n         j = self.makeJobRunner()\n         j.builder = builder\n@@ -292,9 +292,9 @@ def _check_adjust(f):  # type: (Dict[str,Any]) -> Dict[str,Any]\n         yield j\n \n     def collect_output_ports(self, ports, builder, outdir):\n-        # type: (Set[Dict[str,Any]], Builder, str) -> Dict[str,Union[str,List[Any],Dict[str,Any]]]\n+        # type: (Set[Dict[str,Any]], Builder, str) -> Dict[unicode, Union[unicode, List[Any], Dict[unicode, Any]]]\n         try:\n-            ret = {}  # type: Dict[str,Union[str,List[Any],Dict[str,Any]]]\n+            ret = {}  # type: Dict[unicode, Union[unicode, List[Any], Dict[unicode, Any]]]\n             custom_output = os.path.join(outdir, \"cwl.output.json\")\n             if builder.fs_access.exists(custom_output):\n                 with builder.fs_access.open(custom_output, \"r\") as f:\n@@ -323,7 +323,7 @@ def collect_output_ports(self, ports, builder, outdir):\n             raise WorkflowException(\"Error validating output record, \" + str(e) + \"\\n in \" + json.dumps(ret, indent=4))\n \n     def collect_output(self, schema, builder, outdir):\n-        # type: (Dict[str,Any], Builder, str) -> Union[Dict[str, Any], List[Union[Dict[str, Any], str]]]\n+        # type: (Dict[str,Any], Builder, str) -> Union[Dict[unicode, Any], List[Union[Dict[unicode, Any], unicode]]]\n         r = []  # type: List[Any]\n         if \"outputBinding\" in schema:\n             binding = schema[\"outputBinding\"]\ndiff --git a/cwltool/expression.py b/cwltool/expression.py\n--- a/cwltool/expression.py\n+++ b/cwltool/expression.py\n@@ -19,7 +19,7 @@ def jshead(engineConfig, rootvars):\n     return u\"\\n\".join(engineConfig + [u\"var %s = %s;\" % (k, json.dumps(v, indent=4)) for k, v in rootvars.items()])\n \n def exeval(ex, jobinput, requirements, outdir, tmpdir, context, pull_image):\n-    # type: (Dict[str,Any], Dict[str,str], List[Dict[str, Any]], str, str, Any, bool) -> sandboxjs.JSON\n+    # type: (Dict[str, Any], Dict[unicode, Union[Dict, List, unicode]], List[Dict[str, Any]], str, str, Any, bool) -> sandboxjs.JSON\n \n     if ex[\"engine\"] == \"https://w3id.org/cwl/cwl#JavascriptEngine\":\n         engineConfig = []  # type: List[unicode]\n@@ -126,7 +126,7 @@ def param_interpolate(ex, obj, strip=True):\n \n def do_eval(ex, jobinput, requirements, outdir, tmpdir, resources,\n             context=None, pull_image=True, timeout=None):\n-    # type: (Any, Dict[str,str], List[Dict[str,Any]], str, str, Dict[str, Union[int, str]], Any, bool, int) -> Any\n+    # type: (Union[dict, unicode], Dict[unicode, Union[Dict, List, unicode]], List[Dict[str, Any]], str, str, Dict[str, Union[int, str]], Any, bool, int) -> Any\n \n     runtime = resources.copy()\n     runtime[\"tmpdir\"] = tmpdir\n@@ -140,7 +140,7 @@ def do_eval(ex, jobinput, requirements, outdir, tmpdir, resources,\n \n     if isinstance(ex, dict) and \"engine\" in ex and \"script\" in ex:\n         return exeval(ex, jobinput, requirements, outdir, tmpdir, context, pull_image)\n-    if isinstance(ex, basestring):\n+    if isinstance(ex, (str, unicode)):\n         for r in requirements:\n             if r[\"class\"] == \"InlineJavascriptRequirement\":\n                 return sandboxjs.interpolate(str(ex), jshead(r.get(\"expressionLib\", []), rootvars),\ndiff --git a/cwltool/job.py b/cwltool/job.py\n--- a/cwltool/job.py\n+++ b/cwltool/job.py\n@@ -42,7 +42,7 @@ class CommandLineJob(object):\n \n     def __init__(self):  # type: () -> None\n         self.builder = None  # type: Builder\n-        self.joborder = None  # type: Dict[str,str]\n+        self.joborder = None  # type: Dict[unicode, Union[Dict[unicode, Any], List, unicode]]\n         self.stdin = None  # type: str\n         self.stdout = None  # type: str\n         self.successCodes = None  # type: Iterable[int]\ndiff --git a/cwltool/load_tool.py b/cwltool/load_tool.py\n--- a/cwltool/load_tool.py\n+++ b/cwltool/load_tool.py\n@@ -44,7 +44,7 @@ def fetch_document(argsworkflow):\n \n def validate_document(document_loader, workflowobj, uri,\n                       enable_dev=False, strict=True, preprocess_only=False):\n-    # type: (Loader, Dict[unicode, Any], unicode, bool, bool, bool) -> Tuple[Loader, Names, Any, Dict[str, str], unicode]\n+    # type: (Loader, Dict[unicode, Any], unicode, bool, bool, bool) -> Tuple[Loader, Names, Union[Dict[unicode, Any], List[Dict[unicode, Any]]], Dict[unicode, Any], unicode]\n     \"\"\"Validate a CWL document.\"\"\"\n     jobobj = None\n     if \"cwl:tool\" in workflowobj:\n@@ -83,8 +83,13 @@ def validate_document(document_loader, workflowobj, uri,\n \n     workflowobj[\"id\"] = fileuri\n     processobj, metadata = document_loader.resolve_all(workflowobj, fileuri)\n+    if not isinstance(processobj, (dict, list)):\n+        raise validate.ValidationException(\"Workflow must be a dict or list.\")\n \n     if not metadata:\n+        if not isinstance(processobj, dict):\n+            raise validate.ValidationException(\n+                    \"Draft-2 workflows must be a dict.\")\n         metadata = {\"$namespaces\": processobj.get(\"$namespaces\", {}),\n                    \"$schemas\": processobj.get(\"$schemas\", []),\n                    \"cwlVersion\": processobj[\"cwlVersion\"]}\n@@ -92,7 +97,6 @@ def validate_document(document_loader, workflowobj, uri,\n     if preprocess_only:\n         return document_loader, avsc_names, processobj, metadata, uri\n \n-    document_loader.validate_links(processobj)\n     schema.validate_doc(avsc_names, processobj, document_loader, strict)\n \n     if metadata.get(\"cwlVersion\") != update.LATEST:\n@@ -100,14 +104,13 @@ def validate_document(document_loader, workflowobj, uri,\n             processobj, document_loader, fileuri, enable_dev, metadata)\n \n     if jobobj:\n-        metadata[\"cwl:defaults\"] = jobobj\n+        metadata[u\"cwl:defaults\"] = jobobj\n \n     return document_loader, avsc_names, processobj, metadata, uri\n \n \n-def make_tool(document_loader, avsc_names, processobj, metadata, uri, makeTool,\n-              kwargs):\n-    # type: (Loader, Names, Dict[str, Any], Dict[str, Any], unicode, Callable[..., Process], Dict[str, Any]) -> Process\n+def make_tool(document_loader, avsc_names, metadata, uri, makeTool, kwargs):\n+    # type: (Loader, Names, Dict[unicode, Any], unicode, Callable[..., Process], Dict[str, Any]) -> Process\n     \"\"\"Make a Python CWL object.\"\"\"\n     resolveduri = document_loader.resolve_ref(uri)[0]\n \n@@ -121,7 +124,7 @@ def make_tool(document_loader, avsc_names, processobj, metadata, uri, makeTool,\n                     urlparse.urldefrag(i[\"id\"])[1] for i in resolveduri\n                     if \"id\" in i))\n     else:\n-        processobj = cast(Dict[str, Any], resolveduri)\n+        processobj = resolveduri\n \n     kwargs = kwargs.copy()\n     kwargs.update({\n@@ -149,5 +152,5 @@ def load_tool(argsworkflow, makeTool, kwargs=None,\n     document_loader, avsc_names, processobj, metadata, uri = validate_document(\n         document_loader, workflowobj, uri, enable_dev=enable_dev,\n         strict=strict)\n-    return make_tool(document_loader, avsc_names, processobj, metadata, uri,\n+    return make_tool(document_loader, avsc_names, metadata, uri,\n                      makeTool, kwargs if kwargs else {})\ndiff --git a/cwltool/main.py b/cwltool/main.py\n--- a/cwltool/main.py\n+++ b/cwltool/main.py\n@@ -152,7 +152,7 @@ def arg_parser():  # type: () -> argparse.ArgumentParser\n \n \n def single_job_executor(t, job_order_object, **kwargs):\n-    # type: (Process, Dict[str,Any], str, argparse.Namespace,**Any) -> Union[str,Dict[str,str]]\n+    # type: (Process, Dict[unicode, Any], **Any) -> Union[str,Dict[str,str]]\n     final_output = []\n     final_status = []\n \n@@ -238,7 +238,7 @@ def __call__(self, parser, namespace, values, option_string=None):\n \n \n def generate_parser(toolparser, tool, namemap):\n-    # type: (argparse.ArgumentParser, Process,Dict[str,str]) -> argparse.ArgumentParser\n+    # type: (argparse.ArgumentParser, Process, Dict[unicode, unicode]) -> argparse.ArgumentParser\n     toolparser.add_argument(\"job_order\", nargs=\"?\", help=\"Job input json file\")\n     namemap[\"job_order\"] = \"job_order\"\n \n@@ -298,14 +298,15 @@ def generate_parser(toolparser, tool, namemap):\n         else:\n             typekw = {}\n \n-        toolparser.add_argument(flag + name, required=required,\n-                help=ahelp, action=action, default=default, **typekw)\n+        toolparser.add_argument(  # type: ignore\n+                args=flag + name, required=required, help=ahelp, action=action,\n+                default=default, **typekw)\n \n     return toolparser\n \n \n def load_job_order(args, t, stdin, print_input_deps=False, relative_deps=False, stdout=sys.stdout):\n-    # type: (argparse.Namespace, Process, argparse.ArgumentParser, IO[Any], bool, bool, IO[Any]) -> Union[int,Tuple[Dict[str,Any],str]]\n+    # type: (argparse.Namespace, Process, IO[Any], bool, bool, IO[Any]) -> Union[int,Tuple[Dict[str,Any],str]]\n \n     job_order_object = None\n \n@@ -313,9 +314,9 @@ def load_job_order(args, t, stdin, print_input_deps=False, relative_deps=False,\n         loader = Loader({})\n     else:\n         jobloaderctx = {\n-                \"path\": {\"@type\": \"@id\"},\n-                \"format\": {\"@type\": \"@id\"},\n-                \"id\": \"@id\"}\n+                u\"path\": {u\"@type\": u\"@id\"},\n+                u\"format\": {u\"@type\": u\"@id\"},\n+                u\"id\": u\"@id\"}\n         jobloaderctx.update(t.metadata.get(\"$namespaces\", {}))\n         loader = Loader(jobloaderctx)\n \n@@ -332,14 +333,14 @@ def load_job_order(args, t, stdin, print_input_deps=False, relative_deps=False,\n     elif job_order_file:\n         input_basedir = args.basedir if args.basedir else os.path.abspath(os.path.dirname(job_order_file))\n         try:\n-            job_order_object, _ = loader.resolve_ref(job_order_file)\n+            job_order_object, _ = loader.resolve_ref(job_order_file, checklinks=False)\n         except Exception as e:\n             _logger.error(str(e), exc_info=(e if args.debug else False))\n             return 1\n         toolparser = None\n     else:\n         input_basedir = args.basedir if args.basedir else os.getcwd()\n-        namemap = {}  # type: Dict[str,str]\n+        namemap = {}  # type: Dict[unicode, unicode]\n         toolparser = generate_parser(argparse.ArgumentParser(prog=args.workflow), t, namemap)\n         if toolparser:\n             if args.tool_help:\n@@ -419,7 +420,7 @@ def makeRelative(u):\n \n     stdout.write(json.dumps(deps, indent=4))\n \n-def flatten_deps(d, files):\n+def flatten_deps(d, files):  # type: (Any, Set[unicode]) -> None\n     if isinstance(d, list):\n         for s in d:\n             flatten_deps(s, files)\n@@ -428,33 +429,36 @@ def flatten_deps(d, files):\n         if \"secondaryFiles\" in d:\n             flatten_deps(d[\"secondaryFiles\"], files)\n \n-def find_run(d, runs):\n+def find_run(d, runs):  # type: (Any, Set[unicode]) -> None\n     if isinstance(d, list):\n         for s in d:\n             find_run(s, runs)\n     elif isinstance(d, dict):\n-        if \"run\" in d and isinstance(d[\"run\"], basestring):\n+        if \"run\" in d and isinstance(d[\"run\"], (str, unicode)):\n             runs.add(d[\"run\"])\n         for s in d.values():\n             find_run(s, runs)\n \n def replace_refs(d, rewrite, stem, newstem):\n+    # type: (Any, Dict[unicode, unicode], unicode, unicode) -> None\n     if isinstance(d, list):\n         for s,v in enumerate(d):\n-            if isinstance(v, basestring) and v.startswith(stem):\n+            if isinstance(v, (str, unicode)) and v.startswith(stem):\n                 d[s] = newstem + v[len(stem):]\n             else:\n                 replace_refs(v, rewrite, stem, newstem)\n     elif isinstance(d, dict):\n-        if \"run\" in d and isinstance(d[\"run\"], basestring):\n+        if \"run\" in d and isinstance(d[\"run\"], (str, unicode)):\n             d[\"run\"] = rewrite[d[\"run\"]]\n         for s,v in d.items():\n-            if isinstance(v, basestring) and v.startswith(stem):\n+            if isinstance(v, (str, unicode)) and v.startswith(stem):\n                 d[s] = newstem + v[len(stem):]\n             replace_refs(v, rewrite, stem, newstem)\n \n def print_pack(document_loader, processobj, uri, metadata):\n+    # type: (Loader, Any, unicode, Dict[unicode, unicode]) -> str\n     def loadref(b, u):\n+        # type: (unicode, unicode) -> Union[Dict, List, unicode]\n         return document_loader.resolve_ref(u, base_url=b)[0]\n     deps = process.scandeps(uri, processobj,\n                             set((\"run\",)), set(), loadref)\n@@ -462,7 +466,7 @@ def loadref(b, u):\n     fdeps = set((uri,))\n     flatten_deps(deps, fdeps)\n \n-    runs = set()\n+    runs = set()  # type: Set[unicode]\n     for f in fdeps:\n         find_run(document_loader.idx[f], runs)\n \n@@ -476,9 +480,10 @@ def loadref(b, u):\n     for r in runs:\n         rewrite[r] = \"#\" + shortname(r)\n \n-    packed = {\"$graph\": [], \"cwlVersion\": metadata[\"cwlVersion\"]}\n+    packed = {\"$graph\": [], \"cwlVersion\": metadata[\"cwlVersion\"]\n+            }  # type: Dict[unicode, Any]\n     for r,v in rewrite.items():\n-        dc = copy.deepcopy(document_loader.idx[r])\n+        dc = cast(Dict[unicode, Any], copy.deepcopy(document_loader.idx[r]))\n         dc[\"id\"] = v\n         dc[\"name\"] = v\n         replace_refs(dc, rewrite, r+\"/\" if \"#\" in r else r+\"#\", v+\"/\")\n@@ -508,7 +513,7 @@ def main(argsl=None,\n          stderr=sys.stderr,\n          versionfunc=versionstring,\n          job_order_object=None):\n-    # type: (List[str],Callable[...,Union[str,Dict[str,str]]],Callable[...,Process],Callable[[Dict[str,int]],Dict[str,int]],argparse.ArgumentParser,IO[Any],IO[Any],IO[Any],Callable[[],unicode]) -> int\n+    # type: (List[str], argparse.Namespace, Callable[..., Union[str, Dict[str, str]]], Callable[..., Process], Callable[[Dict[str, int]], Dict[str, int]], IO[Any], IO[Any], IO[Any], Callable[[], unicode], Union[int, Tuple[Dict[str, Any], str]]) -> int\n \n     _logger.removeHandler(defaultStreamHandler)\n     stderr_handler = logging.StreamHandler(stderr)\n@@ -588,8 +593,8 @@ def main(argsl=None,\n                 printdot(uri, processobj, document_loader.ctx, stdout)\n                 return 0\n \n-            tool = make_tool(document_loader, avsc_names, processobj, metadata,\n-                             uri, makeTool, {})\n+            tool = make_tool(document_loader, avsc_names, metadata, uri,\n+                    makeTool, {})\n         except (validate.ValidationException) as exc:\n             _logger.error(u\"Tool definition failed validation:\\n%s\", exc,\n                           exc_info=(exc if args.debug else False))\n@@ -611,14 +616,15 @@ def main(argsl=None,\n \n         if args.tmp_outdir_prefix != 'tmp':\n             # Use user defined temp directory (if it exists)\n-            args.tmp_outdir_prefix = os.path.abspath(args.tmp_outdir_prefix)\n+            setattr(args, 'tmp_outdir_prefix',\n+                    os.path.abspath(args.tmp_outdir_prefix))\n             if not os.path.exists(args.tmp_outdir_prefix):\n                 _logger.error(\"Intermediate output directory prefix doesn't exist.\")\n                 return 1\n \n         if args.tmpdir_prefix != 'tmp':\n             # Use user defined prefix (if the folder exists)\n-            args.tmpdir_prefix = os.path.abspath(args.tmpdir_prefix)\n+            setattr(args, 'tmpdir_prefix', os.path.abspath(args.tmpdir_prefix))\n             if not os.path.exists(args.tmpdir_prefix):\n                 _logger.error(\"Temporary directory prefix doesn't exist.\")\n                 return 1\n@@ -633,12 +639,13 @@ def main(argsl=None,\n             return job_order_object\n \n         if args.cachedir:\n-            args.cachedir = os.path.abspath(args.cachedir)\n-            args.move_outputs = False\n+            setattr(args, 'cachedir', os.path.abspath(args.cachedir))\n+            setattr(args, 'move_outputs', False)\n \n         try:\n-            args.tmp_outdir_prefix = args.cachedir if args.cachedir else args.tmp_outdir_prefix\n-            args.basedir = job_order_object[1]\n+            setattr(args, 'tmp_outdir_prefix',\n+                    args.cachedir if args.cachedir else args.tmp_outdir_prefix)\n+            setattr(args, 'basedir', job_order_object[1])\n             del args.workflow\n             del args.job_order\n             out = executor(tool, job_order_object[0],\ndiff --git a/cwltool/pathmapper.py b/cwltool/pathmapper.py\n--- a/cwltool/pathmapper.py\n+++ b/cwltool/pathmapper.py\n@@ -7,8 +7,8 @@\n _logger = logging.getLogger(\"cwltool\")\n \n \n-def abspath(src, basedir):  # type: (str,str) -> str\n-    if src.startswith(\"file://\"):\n+def abspath(src, basedir):  # type: (unicode, unicode) -> unicode\n+    if src.startswith(u\"file://\"):\n         ab = src[7:]\n     else:\n         ab = src if os.path.isabs(src) else os.path.join(basedir, src)\n@@ -21,31 +21,31 @@ class PathMapper(object):\n     (absolute local path, absolute container path)\"\"\"\n \n     def __init__(self, referenced_files, basedir):\n-        # type: (Set[str], str) -> None\n-        self._pathmap = {}  # type: Dict[str, Tuple[str, str]]\n+        # type: (Set[unicode], unicode) -> None\n+        self._pathmap = {}  # type: Dict[unicode, Tuple[unicode, unicode]]\n         self.setup(referenced_files, basedir)\n \n     def setup(self, referenced_files, basedir):\n-        # type: (Set[str], str) -> None\n+        # type: (Set[unicode], unicode) -> None\n         for src in referenced_files:\n             ab = abspath(src, basedir)\n             self._pathmap[src] = (ab, ab)\n \n-    def mapper(self, src):  # type: (str) -> Tuple[str,str]\n-        if \"#\" in src:\n-            i = src.index(\"#\")\n+    def mapper(self, src):  # type: (unicode) -> Tuple[unicode, unicode]\n+        if u\"#\" in src:\n+            i = src.index(u\"#\")\n             p = self._pathmap[src[:i]]\n             return (p[0], p[1] + src[i:])\n         else:\n             return self._pathmap[src]\n \n-    def files(self):  # type: () -> List[str]\n+    def files(self):  # type: () -> List[unicode]\n         return self._pathmap.keys()\n \n-    def items(self):  # type: () -> List[Tuple[str,Tuple[str,str]]]\n+    def items(self):  # type: () -> List[Tuple[unicode, Tuple[unicode, unicode]]]\n         return self._pathmap.items()\n \n-    def reversemap(self, target):  # type: (str) -> Tuple[str, str]\n+    def reversemap(self, target):  # type: (unicode) -> Tuple[unicode, unicode]\n         for k, v in self._pathmap.items():\n             if v[1] == target:\n                 return (k, v[0])\n@@ -55,8 +55,8 @@ def reversemap(self, target):  # type: (str) -> Tuple[str, str]\n class DockerPathMapper(PathMapper):\n \n     def __init__(self, referenced_files, basedir):\n-        # type: (Set[str], str) -> None\n-        self.dirs = {}  # type: Dict[str, Union[bool, str]]\n+        # type: (Set[unicode], unicode) -> None\n+        self.dirs = {}  # type: Dict[unicode, Union[bool, unicode]]\n         super(DockerPathMapper, self).__init__(referenced_files, basedir)\n \n     def setup(self, referenced_files, basedir):\n@@ -77,16 +77,16 @@ def setup(self, referenced_files, basedir):\n                         del self.dirs[d]\n                 self.dirs[dirn] = True\n \n-        prefix = \"job\" + str(random.randint(1, 1000000000)) + \"_\"\n+        prefix = u\"job\" + str(random.randint(1, 1000000000)) + u\"_\"\n \n-        names = set()  # type: Set[str]\n+        names = set()  # type: Set[unicode]\n         for d in self.dirs:\n-            name = os.path.join(\"/var/lib/cwl\", prefix + os.path.basename(d))\n+            name = os.path.join(u\"/var/lib/cwl\", prefix + os.path.basename(d))\n             i = 1\n             while name in names:\n                 i += 1\n-                name = os.path.join(\"/var/lib/cwl\",\n-                        prefix + os.path.basename(d) + str(i))\n+                name = os.path.join(u\"/var/lib/cwl\",\n+                        prefix + os.path.basename(d) + unicode(i))\n             names.add(name)\n             self.dirs[d] = name\n \ndiff --git a/cwltool/process.py b/cwltool/process.py\n--- a/cwltool/process.py\n+++ b/cwltool/process.py\n@@ -20,7 +20,8 @@\n import glob\n from .errors import WorkflowException\n from .pathmapper import abspath\n-from typing import Any, Callable, Generator, Union, IO, AnyStr, Tuple\n+from typing import (Any, AnyStr, Callable, cast, Dict, List, Generator, IO,\n+        Tuple, Union)\n from collections import Iterable\n from rdflib import URIRef\n from rdflib.namespace import RDFS, OWL\n@@ -52,6 +53,7 @@\n               \"invocation.md\")\n \n salad_files = ('metaschema.yml',\n+               'metaschema_base.yml',\n               'salad.md',\n               'field_name.yml',\n               'import_include.md',\n@@ -72,9 +74,9 @@\n               'vocab_res_src.yml',\n               'vocab_res_proc.yml')\n \n-SCHEMA_CACHE = {}  # type: Dict[str, Tuple[Loader, Union[avro.schema.Names, avro.schema.SchemaParseException], Dict[unicode,Any], Loader]]\n-SCHEMA_FILE = None\n-SCHEMA_ANY = None\n+SCHEMA_CACHE = {}  # type: Dict[str, Tuple[Loader, Union[avro.schema.Names, avro.schema.SchemaParseException], Dict[unicode, Any], Loader]]\n+SCHEMA_FILE = None  # type: Dict[unicode, Any]\n+SCHEMA_ANY = None  # type: Dict[unicode, Any]\n \n def get_schema(version):\n     # type: (str) -> Tuple[Loader, Union[avro.schema.Names, avro.schema.SchemaParseException], Dict[unicode,Any], Loader]\n@@ -107,18 +109,20 @@ def get_schema(version):\n         \"https://w3id.org/cwl/CommonWorkflowLanguage.yml\", cache=cache)\n \n     global SCHEMA_FILE, SCHEMA_ANY  # pylint: disable=global-statement\n-    SCHEMA_FILE = SCHEMA_CACHE[version][3].idx[\"https://w3id.org/cwl/cwl#File\"]\n-    SCHEMA_ANY = SCHEMA_CACHE[version][3].idx[\"https://w3id.org/cwl/salad#Any\"]\n+    SCHEMA_FILE = cast(Dict[unicode, Any],\n+            SCHEMA_CACHE[version][3].idx[\"https://w3id.org/cwl/cwl#File\"])\n+    SCHEMA_ANY = cast(Dict[unicode, Any],\n+            SCHEMA_CACHE[version][3].idx[\"https://w3id.org/cwl/salad#Any\"])\n \n     return SCHEMA_CACHE[version]\n \n def shortname(inputid):\n-    # type: (Union[str, unicode]) -> str\n+    # type: (unicode) -> unicode\n     d = urlparse.urlparse(inputid)\n     if d.fragment:\n-        return d.fragment.split(\"/\")[-1].split(\".\")[-1]\n+        return d.fragment.split(u\"/\")[-1].split(u\".\")[-1]\n     else:\n-        return d.path.split(\"/\")[-1]\n+        return d.path.split(u\"/\")[-1]\n \n \n class UnsupportedRequirement(Exception):\n@@ -202,7 +206,7 @@ def formatSubclassOf(fmt, cls, ontology, visited):\n \n \n def checkFormat(actualFile, inputFormats, ontology):\n-    # type: (Union[Dict[str, Any], List[Dict[str, Any]]], Any, Graph) -> None\n+    # type: (Union[Dict[unicode, Any], List, unicode], Union[List[unicode], unicode], Graph) -> None\n     for af in aslist(actualFile):\n         if \"format\" not in af:\n             raise validate.ValidationException(u\"Missing required 'format' for File %s\" % af)\n@@ -212,13 +216,13 @@ def checkFormat(actualFile, inputFormats, ontology):\n         raise validate.ValidationException(u\"Incompatible file format %s required format(s) %s\" % (af[\"format\"], inputFormats))\n \n def fillInDefaults(inputs, job):\n-    # type: (List[Dict[str, str]], Dict[str, str]) -> None\n+    # type: (List[Dict[unicode, unicode]], Dict[unicode, Union[Dict[unicode, Any], List, unicode]]) -> None\n     for inp in inputs:\n-        if shortname(inp[\"id\"]) in job:\n+        if shortname(inp[u\"id\"]) in job:\n             pass\n-        elif shortname(inp[\"id\"]) not in job and \"default\" in inp:\n-            job[shortname(inp[\"id\"])] = copy.copy(inp[\"default\"])\n-        elif shortname(inp[\"id\"]) not in job and inp[\"type\"][0] == \"null\":\n+        elif shortname(inp[u\"id\"]) not in job and u\"default\" in inp:\n+            job[shortname(inp[u\"id\"])] = copy.copy(inp[u\"default\"])\n+        elif shortname(inp[u\"id\"]) not in job and inp[u\"type\"][0] == u\"null\":\n             pass\n         else:\n             raise validate.ValidationException(\"Missing input parameter `%s`\" % shortname(inp[\"id\"]))\n@@ -227,7 +231,7 @@ class Process(object):\n     __metaclass__ = abc.ABCMeta\n \n     def __init__(self, toolpath_object, **kwargs):\n-        # type: (Dict[str, Any], **Any) -> None\n+        # type: (Dict[unicode, Any], **Any) -> None\n         self.metadata = kwargs.get(\"metadata\", {})  # type: Dict[str,Any]\n         self.names = None  # type: avro.schema.Names\n         names = schema_salad.schema.make_avro_schema(\n@@ -298,11 +302,12 @@ def __init__(self, toolpath_object, **kwargs):\n \n \n     def _init_job(self, joborder, **kwargs):\n-        # type: (Dict[str, str], str, **Any) -> Builder\n+        # type: (Dict[unicode, unicode], **Any) -> Builder\n         builder = Builder()\n-        builder.job = copy.deepcopy(joborder)\n+        builder.job = cast(Dict[unicode, Union[Dict[unicode, Any], List,\n+            unicode]], copy.deepcopy(joborder))\n \n-        fillInDefaults(self.tool[\"inputs\"], builder.job)\n+        fillInDefaults(self.tool[u\"inputs\"], builder.job)\n \n         # Validate job order\n         try:\n@@ -427,7 +432,7 @@ def visit(self, op):\n \n     @abc.abstractmethod\n     def job(self, job_order, output_callbacks, **kwargs):\n-        # type: (Dict[str, str], str, Callable[[Any, Any], Any], **Any) -> Generator[Any, None, None]\n+        # type: (Dict[unicode, unicode], Callable[[Any, Any], Any], **Any) -> Generator[Any, None, None]\n         return None\n \n def empty_subtree(dirpath):  # type: (AnyStr) -> bool\n@@ -461,7 +466,7 @@ def uniquename(stem):  # type: (unicode) -> unicode\n     return u\n \n def scandeps(base, doc, reffields, urlfields, loadref):\n-    # type: (str, Any, Set[str], Set[str], Callable[[str, str], Any]) -> List[Dict[str, str]]\n+    # type: (unicode, Any, Set[str], Set[str], Callable[[unicode, str], Any]) -> List[Dict[str, str]]\n     r = []\n     if isinstance(doc, dict):\n         if \"id\" in doc:\ndiff --git a/cwltool/schemas/draft-4/salad/schema_salad/__init__.py b/cwltool/schemas/draft-4/salad/schema_salad/__init__.py\n--- a/cwltool/schemas/draft-4/salad/schema_salad/__init__.py\n+++ b/cwltool/schemas/draft-4/salad/schema_salad/__init__.py\n@@ -1,7 +1,6 @@\n import logging\n import sys\n-if sys.version_info >= (2,7):\n-    import typing\n+import typing\n \n __author__ = 'peter.amstutz@curoverse.com'\n \ndiff --git a/cwltool/schemas/draft-4/salad/schema_salad/__main__.py b/cwltool/schemas/draft-4/salad/schema_salad/__main__.py\n--- a/cwltool/schemas/draft-4/salad/schema_salad/__main__.py\n+++ b/cwltool/schemas/draft-4/salad/schema_salad/__main__.py\n@@ -1,6 +1,5 @@\n from . import main\n import sys\n-if sys.version_info >= (2,7):\n-    import typing\n+import typing\n \n sys.exit(main.main())\ndiff --git a/cwltool/schemas/draft-4/salad/schema_salad/add_dictlist.py b/cwltool/schemas/draft-4/salad/schema_salad/add_dictlist.py\n--- a/cwltool/schemas/draft-4/salad/schema_salad/add_dictlist.py\n+++ b/cwltool/schemas/draft-4/salad/schema_salad/add_dictlist.py\n@@ -1,8 +1,7 @@\n import sys\n-if sys.version_info >= (2,7):\n-    import typing\n+from typing import Any, Dict\n \n-def add_dictlist(di, key, val):\n+def add_dictlist(di, key, val):  # type: (Dict, Any, Any) -> None\n     if key not in di:\n         di[key] = []\n     di[key].append(val)\ndiff --git a/cwltool/schemas/draft-4/salad/schema_salad/aslist.py b/cwltool/schemas/draft-4/salad/schema_salad/aslist.py\n--- a/cwltool/schemas/draft-4/salad/schema_salad/aslist.py\n+++ b/cwltool/schemas/draft-4/salad/schema_salad/aslist.py\n@@ -1,8 +1,7 @@\n import sys\n-if sys.version_info >= (2,7):\n-    import typing\n+from typing import Any, List\n \n-def aslist(l):\n+def aslist(l):  # type: (Any) -> List\n     \"\"\"Convenience function to wrap single items and lists, and return lists unchanged.\"\"\"\n \n     if isinstance(l, list):\ndiff --git a/cwltool/schemas/draft-4/salad/schema_salad/flatten.py b/cwltool/schemas/draft-4/salad/schema_salad/flatten.py\n--- a/cwltool/schemas/draft-4/salad/schema_salad/flatten.py\n+++ b/cwltool/schemas/draft-4/salad/schema_salad/flatten.py\n@@ -1,9 +1,9 @@\n import sys\n-if sys.version_info >= (2,7):\n-    import typing\n+from typing import Any, Tuple\n \n # http://rightfootin.blogspot.com/2006/09/more-on-python-flatten.html\n def flatten(l, ltypes=(list, tuple)):\n+    # type: (Any, Any) -> Any\n     if l is None:\n         return []\n     if not isinstance(l, ltypes):\n@@ -21,4 +21,4 @@ def flatten(l, ltypes=(list, tuple)):\n             else:\n                 l[i:i + 1] = l[i]\n         i += 1\n-    return ltype(l)\n+    return ltype(l)  # type: ignore\ndiff --git a/cwltool/schemas/draft-4/salad/schema_salad/jsonld_context.py b/cwltool/schemas/draft-4/salad/schema_salad/jsonld_context.py\n--- a/cwltool/schemas/draft-4/salad/schema_salad/jsonld_context.py\n+++ b/cwltool/schemas/draft-4/salad/schema_salad/jsonld_context.py\n@@ -1,6 +1,11 @@\n+import collections\n import shutil\n import json\n-import yaml\n+import ruamel.yaml as yaml\n+try:\n+    from ruamel.yaml import CSafeLoader as SafeLoader\n+except ImportError:\n+    from ruamel.yaml import SafeLoader  # type: ignore\n import os\n import subprocess\n import copy\n@@ -11,62 +16,74 @@\n from rdflib import Graph, URIRef\n import rdflib.namespace\n from rdflib.namespace import RDF, RDFS\n-try:\n-    import urlparse\n-except ImportError:\n-    import urllib.parse as urlparse\n-    unicode=str\n-    basestring=str\n+import urlparse\n import logging\n from .aslist import aslist\n-if sys.version_info >= (2,7):\n-    import typing\n+from typing import Any, cast, Dict, Iterable, Tuple, Union\n+from .ref_resolver import Loader\n \n _logger = logging.getLogger(\"salad\")\n \n+\n def pred(datatype, field, name, context, defaultBase, namespaces):\n+    # type: (Dict[str, Union[Dict, str]], Dict, str, Loader.ContextType, str, Dict[str, rdflib.namespace.Namespace]) -> Union[Dict, str]\n     split = urlparse.urlsplit(name)\n \n-    v = None\n+    vee = None  # type: Union[str, unicode]\n \n     if split.scheme:\n-        v = name\n-        (ns, ln) = rdflib.namespace.split_uri(unicode(v))\n+        vee = name\n+        (ns, ln) = rdflib.namespace.split_uri(unicode(vee))\n         name = ln\n         if ns[0:-1] in namespaces:\n-            v = unicode(namespaces[ns[0:-1]][ln])\n-        _logger.debug(\"name, v %s %s\", name, v)\n+            vee = unicode(namespaces[ns[0:-1]][ln])\n+        _logger.debug(\"name, v %s %s\", name, vee)\n+\n+    v = None  # type: Any\n \n     if field and \"jsonldPredicate\" in field:\n         if isinstance(field[\"jsonldPredicate\"], dict):\n             v = {}\n             for k, val in field[\"jsonldPredicate\"].items():\n-                v[(\"@\"+k[1:] if k.startswith(\"_\") else k)] = val\n+                v[(\"@\" + k[1:] if k.startswith(\"_\") else k)] = val\n         else:\n             v = field[\"jsonldPredicate\"]\n     elif \"jsonldPredicate\" in datatype:\n-        for d in datatype[\"jsonldPredicate\"]:\n-            if d[\"symbol\"] == name:\n-                v = d[\"predicate\"]\n+        if isinstance(datatype[\"jsonldPredicate\"], collections.Iterable):\n+            for d in datatype[\"jsonldPredicate\"]:\n+                if isinstance(d, dict):\n+                    if d[\"symbol\"] == name:\n+                        v = d[\"predicate\"]\n+                else:\n+                    raise Exception(\n+                        \"entries in the jsonldPredicate List must be \"\n+                        \"Dictionaries\")\n+        else:\n+            raise Exception(\"jsonldPredicate must be a List of Dictionaries.\")\n     # if not v:\n     #     if field and \"jsonldPrefix\" in field:\n     #         defaultBase = field[\"jsonldPrefix\"]\n     #     elif \"jsonldPrefix\" in datatype:\n     #         defaultBase = datatype[\"jsonldPrefix\"]\n \n-    if not v:\n-        v = defaultBase + name\n+    ret = v or vee\n+\n+    if not ret:\n+        ret = defaultBase + name\n \n     if name in context:\n-        if context[name] != v:\n-            raise Exception(\"Predicate collision on %s, '%s' != '%s'\" % (name, context[name], v))\n+        if context[name] != ret:\n+            raise Exception(\"Predicate collision on %s, '%s' != '%s'\" %\n+                            (name, context[name], ret))\n     else:\n-        _logger.debug(\"Adding to context '%s' %s (%s)\", name, v, type(v))\n-        context[name] = v\n+        _logger.debug(\"Adding to context '%s' %s (%s)\", name, ret, type(ret))\n+        context[name] = ret\n+\n+    return ret\n \n-    return v\n \n def process_type(t, g, context, defaultBase, namespaces, defaultPrefix):\n+    # type: (Dict[str, Any], Graph, Loader.ContextType, str, Dict[str, rdflib.namespace.Namespace], str) -> None\n     if t[\"type\"] == \"record\":\n         recordname = t[\"name\"]\n \n@@ -86,12 +103,14 @@ def process_type(t, g, context, defaultBase, namespaces, defaultPrefix):\n             predicate = \"%s:%s\" % (defaultPrefix, recordname)\n \n         if context.get(recordname, predicate) != predicate:\n-            raise Exception(\"Predicate collision on '%s', '%s' != '%s'\" % (recordname, context[recordname], predicate))\n+            raise Exception(\"Predicate collision on '%s', '%s' != '%s'\" % (\n+                recordname, context[recordname], predicate))\n \n         if not recordname:\n             raise Exception()\n \n-        _logger.debug(\"Adding to context '%s' %s (%s)\", recordname, predicate, type(predicate))\n+        _logger.debug(\"Adding to context '%s' %s (%s)\",\n+                      recordname, predicate, type(predicate))\n         context[recordname] = predicate\n \n         for i in t.get(\"fields\", []):\n@@ -119,7 +138,8 @@ def process_type(t, g, context, defaultBase, namespaces, defaultPrefix):\n                 # TODO generate range from datatype.\n \n             if isinstance(i[\"type\"], dict) and \"name\" in i[\"type\"]:\n-                process_type(i[\"type\"], g, context, defaultBase, namespaces, defaultPrefix)\n+                process_type(i[\"type\"], g, context, defaultBase,\n+                             namespaces, defaultPrefix)\n \n         if \"extends\" in t:\n             for e in aslist(t[\"extends\"]):\n@@ -132,31 +152,26 @@ def process_type(t, g, context, defaultBase, namespaces, defaultPrefix):\n \n \n def salad_to_jsonld_context(j, schema_ctx):\n-    context = {}\n+    # type: (Iterable, Dict[str, Any]) -> Tuple[Loader.ContextType, Graph]\n+    context = {}  # type: Loader.ContextType\n     namespaces = {}\n     g = Graph()\n     defaultPrefix = \"\"\n \n-    for k,v in schema_ctx.items():\n+    for k, v in schema_ctx.items():\n         context[k] = v\n         namespaces[k] = rdflib.namespace.Namespace(v)\n \n     if \"@base\" in context:\n-        defaultBase = context[\"@base\"]\n+        defaultBase = cast(str, context[\"@base\"])\n         del context[\"@base\"]\n     else:\n         defaultBase = \"\"\n \n-    for k,v in namespaces.items():\n+    for k, v in namespaces.items():\n         g.bind(k, v)\n \n     for t in j:\n         process_type(t, g, context, defaultBase, namespaces, defaultPrefix)\n \n     return (context, g)\n-\n-if __name__ == \"__main__\":\n-    with open(sys.argv[1]) as f:\n-        j = yaml.load(f)\n-        (ctx, g) = salad_to_jsonld_context(j)\n-        print(json.dumps(ctx, indent=4, sort_keys=True))\ndiff --git a/cwltool/schemas/draft-4/salad/schema_salad/main.py b/cwltool/schemas/draft-4/salad/schema_salad/main.py\n--- a/cwltool/schemas/draft-4/salad/schema_salad/main.py\n+++ b/cwltool/schemas/draft-4/salad/schema_salad/main.py\n@@ -9,31 +9,29 @@\n import json\n from rdflib import Graph, plugin\n from rdflib.serializer import Serializer\n-import yaml\n import os\n-try:\n-    import urlparse\n-except ImportError:\n-    import urllib.parse as urlparse\n+import urlparse\n \n from .ref_resolver import Loader\n from . import validate\n-if sys.version_info >= (2,7):\n-    import typing\n+from typing import Any, Dict, List, Union\n \n _logger = logging.getLogger(\"salad\")\n \n from rdflib.plugin import register, Parser\n-import rdflib_jsonld.parser\n register('json-ld', Parser, 'rdflib_jsonld.parser', 'JsonLDParser')\n \n+\n def printrdf(workflow, wf, ctx, sr):\n-    g = Graph().parse(data=json.dumps(wf), format='json-ld', location=workflow, context=ctx)\n+    # type: (str, Union[List, Dict[Any, Any], str, unicode], Dict[unicode, Any], str) -> None\n+    g = Graph().parse(data=json.dumps(wf), format='json-ld',\n+                      location=workflow, context=ctx)\n     print(g.serialize(format=sr))\n \n-def main(args=None):\n-    if args is None:\n-        args = sys.argv[1:]\n+\n+def main(argsl=None):  # type: (List[str]) -> int\n+    if argsl is None:\n+        argsl = sys.argv[1:]\n \n     parser = argparse.ArgumentParser()\n     parser.add_argument(\"--rdf-serializer\",\n@@ -41,15 +39,23 @@ def main(args=None):\n                         default=\"turtle\")\n \n     exgroup = parser.add_mutually_exclusive_group()\n-    exgroup.add_argument(\"--print-jsonld-context\", action=\"store_true\", help=\"Print JSON-LD context for schema\")\n-    exgroup.add_argument(\"--print-rdfs\", action=\"store_true\", help=\"Print RDF schema\")\n-    exgroup.add_argument(\"--print-avro\", action=\"store_true\", help=\"Print Avro schema\")\n-\n-    exgroup.add_argument(\"--print-rdf\", action=\"store_true\", help=\"Print corresponding RDF graph for document\")\n-    exgroup.add_argument(\"--print-pre\", action=\"store_true\", help=\"Print document after preprocessing\")\n-    exgroup.add_argument(\"--print-index\", action=\"store_true\", help=\"Print node index\")\n-    exgroup.add_argument(\"--print-metadata\", action=\"store_true\", help=\"Print document metadata\")\n-    exgroup.add_argument(\"--version\", action=\"store_true\", help=\"Print version\")\n+    exgroup.add_argument(\"--print-jsonld-context\", action=\"store_true\",\n+                         help=\"Print JSON-LD context for schema\")\n+    exgroup.add_argument(\n+        \"--print-rdfs\", action=\"store_true\", help=\"Print RDF schema\")\n+    exgroup.add_argument(\"--print-avro\", action=\"store_true\",\n+                         help=\"Print Avro schema\")\n+\n+    exgroup.add_argument(\"--print-rdf\", action=\"store_true\",\n+                         help=\"Print corresponding RDF graph for document\")\n+    exgroup.add_argument(\"--print-pre\", action=\"store_true\",\n+                         help=\"Print document after preprocessing\")\n+    exgroup.add_argument(\n+        \"--print-index\", action=\"store_true\", help=\"Print node index\")\n+    exgroup.add_argument(\"--print-metadata\",\n+                         action=\"store_true\", help=\"Print document metadata\")\n+    exgroup.add_argument(\"--version\", action=\"store_true\",\n+                         help=\"Print version\")\n \n     exgroup = parser.add_mutually_exclusive_group()\n     exgroup.add_argument(\"--strict\", action=\"store_true\", help=\"Strict validation (unrecognized or out of place fields are error)\",\n@@ -58,14 +64,17 @@ def main(args=None):\n                          default=True, dest=\"strict\")\n \n     exgroup = parser.add_mutually_exclusive_group()\n-    exgroup.add_argument(\"--verbose\", action=\"store_true\", help=\"Default logging\")\n-    exgroup.add_argument(\"--quiet\", action=\"store_true\", help=\"Only print warnings and errors.\")\n-    exgroup.add_argument(\"--debug\", action=\"store_true\", help=\"Print even more logging\")\n+    exgroup.add_argument(\"--verbose\", action=\"store_true\",\n+                         help=\"Default logging\")\n+    exgroup.add_argument(\"--quiet\", action=\"store_true\",\n+                         help=\"Only print warnings and errors.\")\n+    exgroup.add_argument(\"--debug\", action=\"store_true\",\n+                         help=\"Print even more logging\")\n \n     parser.add_argument(\"schema\", type=str)\n     parser.add_argument(\"document\", type=str, nargs=\"?\", default=None)\n \n-    args = parser.parse_args(args)\n+    args = parser.parse_args(argsl)\n \n     if args.quiet:\n         _logger.setLevel(logging.WARN)\n@@ -89,7 +98,16 @@ def main(args=None):\n     if not urlparse.urlparse(schema_uri)[0]:\n         schema_uri = \"file://\" + os.path.abspath(schema_uri)\n     schema_raw_doc = metaschema_loader.fetch(schema_uri)\n-    schema_doc, schema_metadata = metaschema_loader.resolve_all(schema_raw_doc, schema_uri)\n+\n+    try:\n+        schema_doc, schema_metadata = metaschema_loader.resolve_all(\n+            schema_raw_doc, schema_uri)\n+    except (validate.ValidationException) as e:\n+        _logger.error(\"Schema `%s` failed link checking:\\n%s\",\n+                      args.schema, e, exc_info=(e if args.debug else False))\n+        _logger.debug(\"Index is %s\", metaschema_loader.idx.keys())\n+        _logger.debug(\"Vocabulary is %s\", metaschema_loader.vocab.keys())\n+        return 1\n \n     # Optionally print the schema after ref resolution\n     if not args.document and args.print_pre:\n@@ -100,20 +118,13 @@ def main(args=None):\n         print(json.dumps(metaschema_loader.idx.keys(), indent=4))\n         return 0\n \n-    # Validate links in the schema document\n-    try:\n-        metaschema_loader.validate_links(schema_doc)\n-    except (validate.ValidationException) as e:\n-        _logger.error(\"Schema `%s` failed link checking:\\n%s\", args.schema, e, exc_info=(e if args.debug else False))\n-        _logger.debug(\"Index is %s\", metaschema_loader.idx.keys())\n-        _logger.debug(\"Vocabulary is %s\", metaschema_loader.vocab.keys())\n-        return 1\n-\n     # Validate the schema document against the metaschema\n     try:\n-        schema.validate_doc(metaschema_names, schema_doc, metaschema_loader, args.strict)\n+        schema.validate_doc(metaschema_names, schema_doc,\n+                            metaschema_loader, args.strict)\n     except validate.ValidationException as e:\n-        _logger.error(\"While validating schema `%s`:\\n%s\" % (args.schema, str(e)))\n+        _logger.error(\"While validating schema `%s`:\\n%s\" %\n+                      (args.schema, str(e)))\n         return 1\n \n     # Get the json-ld context and RDFS representation from the schema\n@@ -127,11 +138,18 @@ def main(args=None):\n     # Create the loader that will be used to load the target document.\n     document_loader = Loader(schema_ctx)\n \n-    # Make the Avro validation that will be used to validate the target document\n-    (avsc_names, avsc_obj) = schema.make_avro_schema(schema_doc, document_loader)\n+    # Make the Avro validation that will be used to validate the target\n+    # document\n+    if isinstance(schema_doc, list):\n+        (avsc_names, avsc_obj) = schema.make_avro_schema(\n+            schema_doc, document_loader)\n+    else:\n+        _logger.error(\"Schema `%s` must be a list.\", args.schema)\n+        return 1\n \n     if isinstance(avsc_names, Exception):\n-        _logger.error(\"Schema `%s` error:\\n%s\", args.schema, avsc_names, exc_info=(avsc_names if args.debug else False))\n+        _logger.error(\"Schema `%s` error:\\n%s\", args.schema,\n+                      avsc_names, exc_info=(avsc_names if args.debug else False))\n         if args.print_avro:\n             print(json.dumps(avsc_obj, indent=4))\n         return 1\n@@ -168,7 +186,8 @@ def main(args=None):\n             doc = \"file://\" + os.path.abspath(uri)\n         document, doc_metadata = document_loader.resolve_ref(uri)\n     except (validate.ValidationException, RuntimeError) as e:\n-        _logger.error(\"Document `%s` failed validation:\\n%s\", args.document, e, exc_info=(e if args.debug else False))\n+        _logger.error(\"Document `%s` failed validation:\\n%s\",\n+                      args.document, e, exc_info=(e if args.debug else False))\n         return 1\n \n     # Optionally print the document after ref resolution\n@@ -180,19 +199,13 @@ def main(args=None):\n         print(json.dumps(document_loader.idx.keys(), indent=4))\n         return 0\n \n-    # Validate links in the target document\n-    try:\n-        document_loader.validate_links(document)\n-    except (validate.ValidationException) as e:\n-        _logger.error(\"Document `%s` failed link checking:\\n%s\", args.document, e, exc_info=(e if args.debug else False))\n-        _logger.debug(\"Index is %s\", json.dumps(document_loader.idx.keys(), indent=4))\n-        return 1\n-\n     # Validate the schema document against the metaschema\n     try:\n-        schema.validate_doc(avsc_names, document, document_loader, args.strict)\n+        schema.validate_doc(avsc_names, document,\n+                            document_loader, args.strict)\n     except validate.ValidationException as e:\n-        _logger.error(\"While validating document `%s`:\\n%s\" % (args.document, str(e)))\n+        _logger.error(\"While validating document `%s`:\\n%s\" %\n+                      (args.document, str(e)))\n         return 1\n \n     # Optionally convert the document to RDF\ndiff --git a/cwltool/schemas/draft-4/salad/schema_salad/makedoc.py b/cwltool/schemas/draft-4/salad/schema_salad/makedoc.py\n--- a/cwltool/schemas/draft-4/salad/schema_salad/makedoc.py\n+++ b/cwltool/schemas/draft-4/salad/schema_salad/makedoc.py\n@@ -1,30 +1,23 @@\n import mistune\n from . import schema\n import json\n-import yaml\n import os\n import copy\n import re\n import sys\n-try:\n-    import StringIO\n-except ImportError:\n-    from io import StringIO\n+import StringIO\n import logging\n-try:\n-    import urlparse\n-except ImportError:\n-    import urllib.parse as urlparse\n+import urlparse\n from .aslist import aslist\n from .add_dictlist import add_dictlist\n import re\n import argparse\n-if sys.version_info >= (2,7):\n-    import typing\n+from typing import Any, IO, Union\n \n _logger = logging.getLogger(\"salad\")\n \n-def has_types(items):\n+\n+def has_types(items):  # type: (Any) -> List[basestring]\n     r = []  # type: List\n     if isinstance(items, dict):\n         if items[\"type\"] == \"https://w3id.org/cwl/salad#record\":\n@@ -41,36 +34,46 @@ def has_types(items):\n         return [items]\n     return []\n \n+\n def linkto(item):\n     _, frg = urlparse.urldefrag(item)\n     return \"[%s](#%s)\" % (frg, to_id(frg))\n \n+\n class MyRenderer(mistune.Renderer):\n+\n+    def __init__(self):  # type: () -> None\n+        super(mistune.Renderer, self).__init__()\n+        self.options = {}\n+\n     def header(self, text, level, raw=None):\n         return \"\"\"<h%i id=\"%s\">%s</h%i>\"\"\" % (level, to_id(text), text, level)\n \n-def to_id(text):\n+\n+def to_id(text):  # type: (Union[str, unicode]) -> Union[str, unicode]\n     textid = text\n     if text[0] in (\"0\", \"1\", \"2\", \"3\", \"4\", \"5\", \"6\", \"7\", \"8\", \"9\"):\n         try:\n-            textid = text[text.index(\" \")+1:]\n+            textid = text[text.index(\" \") + 1:]\n         except ValueError:\n             pass\n     textid = textid.replace(\" \", \"_\")\n     return textid\n \n+\n class ToC(object):\n-    def __init__(self):\n+\n+    def __init__(self):  # type: () -> None\n         self.first_toc_entry = True\n         self.numbering = [0]\n         self.toc = \"\"\n         self.start_numbering = True\n \n-    def add_entry(self, thisdepth, title):\n+    def add_entry(self, thisdepth, title):  # type: (int, str) -> str\n         depth = len(self.numbering)\n         if thisdepth < depth:\n             self.toc += \"</ol>\"\n-            for n in range(0, depth-thisdepth):\n+            for n in range(0, depth - thisdepth):\n                 self.numbering.pop()\n                 self.toc += \"</li></ol>\"\n             self.numbering[-1] += 1\n@@ -84,16 +87,17 @@ def add_entry(self, thisdepth, title):\n             self.numbering.append(1)\n \n         if self.start_numbering:\n-            num = \"%i.%s\" % (self.numbering[0], \".\".join([str(n) for n in self.numbering[1:]]))\n+            num = \"%i.%s\" % (self.numbering[0], \".\".join(\n+                [str(n) for n in self.numbering[1:]]))\n         else:\n             num = \"\"\n-        self.toc += \"\"\"<li><a href=\"#%s\">%s %s</a><ol>\\n\"\"\" %(to_id(title),\n-            num, title)\n+        self.toc += \"\"\"<li><a href=\"#%s\">%s %s</a><ol>\\n\"\"\" % (to_id(title),\n+                                                               num, title)\n         return num\n \n-    def contents(self, id):\n+    def contents(self, idn):  # type: (str) -> str\n         c = \"\"\"<h1 id=\"%s\">Table of contents</h1>\n-               <nav class=\"tocnav\"><ol>%s\"\"\" % (id, self.toc)\n+               <nav class=\"tocnav\"><ol>%s\"\"\" % (idn, self.toc)\n         c += \"</ol>\"\n         for i in range(0, len(self.numbering)):\n             c += \"</li></ol>\"\n@@ -111,7 +115,8 @@ def contents(self, id):\n               \"https://w3id.org/cwl/salad#enum\",\n               \"https://w3id.org/cwl/salad#array\")\n \n-def number_headings(toc, maindoc):\n+\n+def number_headings(toc, maindoc):  # type: (ToC, str) -> str\n     mdlines = []\n     skip = False\n     for line in maindoc.splitlines():\n@@ -133,19 +138,27 @@ def number_headings(toc, maindoc):\n     maindoc = '\\n'.join(mdlines)\n     return maindoc\n \n-def fix_doc(doc):\n+\n+def fix_doc(doc):  # type: (Union[List[str], str]) -> str\n     if isinstance(doc, list):\n-        doc = \"\".join(doc)\n-    return \"\\n\".join([re.sub(r\"<([^>@]+@[^>]+)>\", r\"[\\1](mailto:\\1)\", d) for d in doc.splitlines()])\n+        docstr = \"\".join(doc)\n+    else:\n+        docstr = doc\n+    return \"\\n\".join(\n+        [re.sub(r\"<([^>@]+@[^>]+)>\", r\"[\\1](mailto:\\1)\", d)\n+         for d in docstr.splitlines()])\n+\n \n class RenderType(object):\n+\n     def __init__(self, toc, j, renderlist, redirects):\n+        # type: (ToC, List[Dict], str, Dict) -> None\n         self.typedoc = StringIO.StringIO()\n         self.toc = toc\n-        self.subs = {}  # type: Dict\n-        self.docParent = {}  # type: Dict\n-        self.docAfter = {}  # type: Dict\n-        self.rendered = set()  # type: Set\n+        self.subs = {}  # type: Dict[str, str]\n+        self.docParent = {}  # type: Dict[str, List]\n+        self.docAfter = {}  # type: Dict[str, List]\n+        self.rendered = set()  # type: Set[str]\n         self.redirects = redirects\n         self.title = None  # type: str\n \n@@ -153,7 +166,7 @@ def __init__(self, toc, j, renderlist, redirects):\n             if \"extends\" in t:\n                 for e in aslist(t[\"extends\"]):\n                     add_dictlist(self.subs, e, t[\"name\"])\n-                    #if \"docParent\" not in t and \"docAfter\" not in t:\n+                    # if \"docParent\" not in t and \"docAfter\" not in t:\n                     #    add_dictlist(self.docParent, e, t[\"name\"])\n \n             if t.get(\"docParent\"):\n@@ -166,7 +179,7 @@ def __init__(self, toc, j, renderlist, redirects):\n             if t.get(\"docAfter\"):\n                 add_dictlist(self.docAfter, t[\"docAfter\"], t[\"name\"])\n \n-        _, _, metaschema_loader = schema.get_metaschema()\n+        metaschema_loader = schema.get_metaschema()[2]\n         alltypes = schema.extend_and_specialize(j, metaschema_loader)\n \n         self.typemap = {}  # type: Dict\n@@ -187,7 +200,7 @@ def __init__(self, toc, j, renderlist, redirects):\n                                 _, frg2 = urlparse.urldefrag(f[\"name\"])\n                                 self.uses[tp].append((frg1, frg2))\n                             if tp not in basicTypes and tp not in self.record_refs[t[\"name\"]]:\n-                                    self.record_refs[t[\"name\"]].append(tp)\n+                                self.record_refs[t[\"name\"]].append(tp)\n             except KeyError as e:\n                 _logger.error(\"Did not find 'type' in %s\", t)\n                 raise\n@@ -201,6 +214,7 @@ def __init__(self, toc, j, renderlist, redirects):\n                 self.render_type(f, 1)\n \n     def typefmt(self, tp, redirects, nbsp=False):\n+        # type: (Any, Dict[str, str], bool) -> Union[str, unicode]\n         global primitiveType\n         if isinstance(tp, list):\n             if nbsp and len(tp) <= 3:\n@@ -231,8 +245,7 @@ def typefmt(self, tp, redirects, nbsp=False):\n                     tp = frg\n                 return \"\"\"<a href=\"#%s\">%s</a>\"\"\" % (to_id(tp), tp)\n \n-\n-    def render_type(self, f, depth):\n+    def render_type(self, f, depth):  # type: (Dict[str, Any], int) -> None\n         if f[\"name\"] in self.rendered or f[\"name\"] in self.redirects:\n             return\n         self.rendered.add(f[\"name\"])\n@@ -248,6 +261,7 @@ def render_type(self, f, depth):\n             f[\"doc\"] = \"\"\n \n         def extendsfrom(item, ex):\n+            # type: (Dict[str, Any], List[Dict[str, Any]]) -> None\n             if \"extends\" in item:\n                 for e in aslist(item[\"extends\"]):\n                     ex.insert(0, self.typemap[e])\n@@ -262,8 +276,9 @@ def extendsfrom(item, ex):\n                 for i in e[\"doc\"]:\n                     idx = i.find(\":\")\n                     if idx > -1:\n-                        enumDesc[i[:idx]] = i[idx+1:]\n-                e[\"doc\"] = [i for i in e[\"doc\"] if i.find(\":\") == -1 or i.find(\" \") < i.find(\":\")]\n+                        enumDesc[i[:idx]] = i[idx + 1:]\n+                e[\"doc\"] = [i for i in e[\"doc\"] if i.find(\n+                    \":\") == -1 or i.find(\" \") < i.find(\":\")]\n \n         f[\"doc\"] = fix_doc(f[\"doc\"])\n \n@@ -294,15 +309,16 @@ def extendsfrom(item, ex):\n         if f[\"type\"] == \"documentation\":\n             f[\"doc\"] = number_headings(self.toc, f[\"doc\"])\n \n-        #if \"extends\" in f:\n+        # if \"extends\" in f:\n         #    doc += \"\\n\\nExtends \"\n         #    doc += \", \".join([\" %s\" % linkto(ex) for ex in aslist(f[\"extends\"])])\n-        #if f[\"name\"] in self.subs:\n+        # if f[\"name\"] in self.subs:\n         #    doc += \"\\n\\nExtended by\"\n         #    doc += \", \".join([\" %s\" % linkto(s) for s in self.subs[f[\"name\"]]])\n-        #if f[\"name\"] in self.uses:\n+        # if f[\"name\"] in self.uses:\n         #    doc += \"\\n\\nReferenced by\"\n-        #    doc += \", \".join([\" [%s.%s](#%s)\" % (s[0], s[1], to_id(s[0])) for s in self.uses[f[\"name\"]]])\n+        #    doc += \", \".join([\" [%s.%s](#%s)\" % (s[0], s[1], to_id(s[0]))\n+        #       for s in self.uses[f[\"name\"]]])\n \n         doc = doc + \"\\n\\n\" + f[\"doc\"]\n \n@@ -323,16 +339,19 @@ def extendsfrom(item, ex):\n                     opt = True\n \n                 desc = i[\"doc\"]\n-                #if \"inherited_from\" in i:\n+                # if \"inherited_from\" in i:\n                 #    desc = \"%s _Inherited from %s_\" % (desc, linkto(i[\"inherited_from\"]))\n \n-                frg = schema.avro_name(i[\"name\"])\n-                tr = \"<td><code>%s</code></td><td>%s</td><td>%s</td><td>%s</td>\" % (frg, self.typefmt(tp, self.redirects), opt, mistune.markdown(desc))\n+                rfrg = schema.avro_name(i[\"name\"])\n+                tr = \"<td><code>%s</code></td><td>%s</td><td>%s</td>\"\\\n+                    \"<td>%s</td>\" % (\n+                        rfrg, self.typefmt(tp, self.redirects), opt,\n+                        mistune.markdown(desc))\n                 if opt:\n                     required.append(tr)\n                 else:\n                     optional.append(tr)\n-            for i in required+optional:\n+            for i in required + optional:\n                 doc += \"<tr>\" + i + \"</tr>\"\n             doc += \"\"\"</table>\"\"\"\n         elif f[\"type\"] == \"enum\":\n@@ -342,30 +361,34 @@ def extendsfrom(item, ex):\n             for e in ex:\n                 for i in e.get(\"symbols\", []):\n                     doc += \"<tr>\"\n-                    frg = schema.avro_name(i)\n-                    doc += \"<td><code>%s</code></td><td>%s</td>\" % (frg, enumDesc.get(frg, \"\"))\n+                    efrg = schema.avro_name(i)\n+                    doc += \"<td><code>%s</code></td><td>%s</td>\" % (\n+                        efrg, enumDesc.get(efrg, \"\"))\n                     doc += \"</tr>\"\n             doc += \"\"\"</table>\"\"\"\n         f[\"doc\"] = doc\n \n         self.typedoc.write(f[\"doc\"])\n \n-        subs = self.docParent.get(f[\"name\"], []) + self.record_refs.get(f[\"name\"], [])\n+        subs = self.docParent.get(f[\"name\"], []) + \\\n+            self.record_refs.get(f[\"name\"], [])\n         if len(subs) == 1:\n             self.render_type(self.typemap[subs[0]], depth)\n         else:\n             for s in subs:\n-                self.render_type(self.typemap[s], depth+1)\n+                self.render_type(self.typemap[s], depth + 1)\n \n         for s in self.docAfter.get(f[\"name\"], []):\n             self.render_type(self.typemap[s], depth)\n \n+\n def avrold_doc(j, outdoc, renderlist, redirects, brand, brandlink):\n+    # type: (List[Dict[unicode, Any]], IO[Any], str, Dict, str, str) -> None\n     toc = ToC()\n     toc.start_numbering = False\n \n     rt = RenderType(toc, j, renderlist, redirects)\n-    content = rt.typedoc.getvalue()\n+    content = rt.typedoc.getvalue()  # type: unicode\n \n     outdoc.write(\"\"\"\n     <!DOCTYPE html>\n@@ -452,22 +475,24 @@ def avrold_doc(j, outdoc, renderlist, redirects, brand, brandlink):\n \n     args = parser.parse_args()\n \n-    s = []\n+    s = []  # type: List[Dict[unicode, Any]]\n     a = args.schema\n     with open(a) as f:\n         if a.endswith(\"md\"):\n             s.append({\"name\": os.path.splitext(os.path.basename(a))[0],\n-                  \"type\": \"documentation\",\n-                  \"doc\": f.read().decode(\"utf-8\")\n-              })\n+                      \"type\": \"documentation\",\n+                      \"doc\": f.read().decode(\"utf-8\")\n+                      })\n         else:\n             uri = \"file://\" + os.path.abspath(a)\n-            _, _, metaschema_loader = schema.get_metaschema()\n+            metaschema_loader = schema.get_metaschema()[2]\n             j, schema_metadata = metaschema_loader.resolve_ref(uri, \"\")\n             if isinstance(j, list):\n                 s.extend(j)\n-            else:\n+            elif isinstance(j, dict):\n                 s.append(j)\n+            else:\n+                raise ValueError(\"Schema must resolve to a list or a dict\")\n \n     primitiveType = args.primtype\n     redirect = {}\ndiff --git a/cwltool/schemas/draft-4/salad/schema_salad/ref_resolver.py b/cwltool/schemas/draft-4/salad/schema_salad/ref_resolver.py\n--- a/cwltool/schemas/draft-4/salad/schema_salad/ref_resolver.py\n+++ b/cwltool/schemas/draft-4/salad/schema_salad/ref_resolver.py\n@@ -5,31 +5,30 @@\n import logging\n import collections\n import requests\n+import urlparse\n+import re\n+import ruamel.yaml as yaml\n try:\n-    import urlparse\n-except:\n-    import urllib.parse as urlparse\n-import yaml\n+    from ruamel.yaml import CSafeLoader as SafeLoader\n+except ImportError:\n+    from ruamel.yaml import SafeLoader  # type: ignore\n from . import validate\n import pprint\n-try:\n-    from StringIO import StringIO\n-except ImportError:\n-    from io import StringIO\n-    unicode=str\n-    basestring=str\n+from StringIO import StringIO\n from .aslist import aslist\n+from .flatten import flatten\n import rdflib\n from rdflib.namespace import RDF, RDFS, OWL\n+from rdflib.plugins.parsers.notation3 import BadSyntax\n import xml.sax\n-if sys.version_info >= (2,7):\n-    import typing\n-    from typing import Union, Tuple\n+from typing import (Any, AnyStr, Callable, cast, Dict, List, Iterable, Tuple,\n+         TypeVar, Union)\n \n _logger = logging.getLogger(\"salad\")\n \n class NormDict(dict):\n-    def __init__(self, normalize=unicode):\n+\n+    def __init__(self, normalize=unicode):  # type: (type) -> None\n         super(NormDict, self).__init__()\n         self.normalize = normalize\n \n@@ -45,6 +44,7 @@ def __delitem__(self, key):\n     def __contains__(self, key):\n         return super(NormDict, self).__contains__(self.normalize(key))\n \n+\n def merge_properties(a, b):\n     c = {}\n     for i in a:\n@@ -59,22 +59,32 @@ def merge_properties(a, b):\n \n     return c\n \n-def SubLoader(loader):\n-    return Loader(loader.ctx, schemagraph=loader.graph, foreign_properties=loader.foreign_properties, idx=loader.idx, cache=loader.cache)\n+\n+def SubLoader(loader):  # type: (Loader) -> Loader\n+    return Loader(loader.ctx, schemagraph=loader.graph,\n+                  foreign_properties=loader.foreign_properties, idx=loader.idx,\n+                  cache=loader.cache)\n+\n \n class Loader(object):\n-    def __init__(self, ctx, schemagraph=None, foreign_properties=None, idx=None, cache=None):\n+\n+    ContextType = Dict[unicode, Union[Dict, unicode, Iterable[unicode]]]\n+    DocumentType = TypeVar('DocumentType', List, Dict[unicode, Any])\n+\n+    def __init__(self, ctx, schemagraph=None, foreign_properties=None,\n+                 idx=None, cache=None):\n+        # type: (Loader.ContextType, rdflib.Graph, Set[unicode], Dict[unicode, Union[List, Dict[unicode, Any], unicode]], Dict[unicode, Any]) -> None\n         normalize = lambda url: urlparse.urlsplit(url).geturl()\n         if idx is not None:\n             self.idx = idx\n         else:\n             self.idx = NormDict(normalize)\n \n-        self.ctx = {}  # type: Dict[str, Union[str, dict, basestring]]\n+        self.ctx = {}  # type: Loader.ContextType\n         if schemagraph is not None:\n             self.graph = schemagraph\n         else:\n-            self.graph = rdflib.Graph()\n+            self.graph = rdflib.graph.Graph()\n \n         if foreign_properties is not None:\n             self.foreign_properties = foreign_properties\n@@ -86,41 +96,49 @@ def __init__(self, ctx, schemagraph=None, foreign_properties=None, idx=None, cac\n         else:\n             self.cache = {}\n \n-        self.url_fields = set()  # type: Set[str]\n-        self.vocab_fields = set()  # type: Set\n-        self.identifiers = set()  # type: Set\n-        self.identity_links = set()  # type: Set\n-        self.standalone = set()  # type: Set\n-        self.nolinkcheck = set()  # type: Set\n-        self.vocab = {}  # type: Dict\n-        self.rvocab = {}  # type: Dict\n+        self.url_fields = None  # type: Set[unicode]\n+        self.scoped_ref_fields = None  # type: Dict[unicode, int]\n+        self.vocab_fields = None  # type: Set[unicode]\n+        self.identifiers = None  # type: Set[unicode]\n+        self.identity_links = None  # type: Set[unicode]\n+        self.standalone = None  # type: Set[unicode]\n+        self.nolinkcheck = None  # type: Set[unicode]\n+        self.vocab = {}  # type: Dict[unicode, unicode]\n+        self.rvocab = {}  # type: Dict[unicode, unicode]\n+        self.idmap = None  # type: Dict[unicode, Any]\n+        self.mapPredicate = None  # type: Dict[unicode, unicode]\n+        self.type_dsl_fields = None  # type: Set[unicode]\n \n         self.add_context(ctx)\n \n-    def expand_url(self, url, base_url, scoped=False, vocab_term=False):\n-        if url in (\"@id\", \"@type\"):\n+    def expand_url(self, url, base_url, scoped_id=False, vocab_term=False, scoped_ref=None):\n+        # type: (unicode, unicode, bool, bool, int) -> unicode\n+        if url in (u\"@id\", u\"@type\"):\n             return url\n \n         if vocab_term and url in self.vocab:\n             return url\n \n-        if self.vocab and \":\" in url:\n-            prefix = url.split(\":\")[0]\n+        if self.vocab and u\":\" in url:\n+            prefix = url.split(u\":\")[0]\n             if prefix in self.vocab:\n-                url = self.vocab[prefix] + url[len(prefix)+1:]\n+                url = self.vocab[prefix] + url[len(prefix) + 1:]\n \n         split = urlparse.urlsplit(url)\n \n-        if split.scheme or url.startswith(\"$(\") or url.startswith(\"${\"):\n+        if split.scheme or url.startswith(u\"$(\") or url.startswith(u\"${\"):\n             pass\n-        elif scoped and not split.fragment:\n+        elif scoped_id and not split.fragment:\n             splitbase = urlparse.urlsplit(base_url)\n-            frg = \"\"\n+            frg = u\"\"\n             if splitbase.fragment:\n-                frg = splitbase.fragment + \"/\" + split.path\n+                frg = splitbase.fragment + u\"/\" + split.path\n             else:\n                 frg = split.path\n-            url = urlparse.urlunsplit((splitbase.scheme, splitbase.netloc, splitbase.path, splitbase.query, frg))\n+            url = urlparse.urlunsplit(\n+                (splitbase.scheme, splitbase.netloc, splitbase.path, splitbase.query, frg))\n+        elif scoped_ref is not None and not split.fragment:\n+            pass\n         else:\n             url = urlparse.urljoin(base_url, url)\n \n@@ -129,43 +147,56 @@ def expand_url(self, url, base_url, scoped=False, vocab_term=False):\n         else:\n             return url\n \n-    def _add_properties(self, s):\n-        for _, _, rng in self.graph.triples( (s, RDFS.range, None) ):\n-            literal = ((str(rng).startswith(\"http://www.w3.org/2001/XMLSchema#\") and not str(rng) == \"http://www.w3.org/2001/XMLSchema#anyURI\") or\n-                       str(rng) == \"http://www.w3.org/2000/01/rdf-schema#Literal\")\n+    def _add_properties(self, s):  # type: (unicode) -> None\n+        for _, _, rng in self.graph.triples((s, RDFS.range, None)):\n+            literal = ((unicode(rng).startswith(\n+                u\"http://www.w3.org/2001/XMLSchema#\") and\n+                not unicode(rng) == u\"http://www.w3.org/2001/XMLSchema#anyURI\")\n+                or unicode(rng) ==\n+                u\"http://www.w3.org/2000/01/rdf-schema#Literal\")\n             if not literal:\n-                self.url_fields.add(str(s))\n-        self.foreign_properties.add(str(s))\n+                self.url_fields.add(unicode(s))\n+        self.foreign_properties.add(s)\n \n-    def add_namespaces(self, ns):\n+    def add_namespaces(self, ns):  # type: (Dict[unicode, unicode]) -> None\n         self.vocab.update(ns)\n \n     def add_schemas(self, ns, base_url):\n+        # type: (Union[List[unicode], unicode], unicode) -> None\n         for sch in aslist(ns):\n-            try:\n-                self.graph.parse(urlparse.urljoin(base_url, sch), format=\"xml\")\n-            except xml.sax.SAXParseException:\n-                self.graph.parse(urlparse.urljoin(base_url, sch), format=\"turtle\")\n-\n-        for s, _, _ in self.graph.triples( (None, RDF.type, RDF.Property) ):\n+            for fmt in ['xml', 'turtle', 'rdfa']:\n+                try:\n+                    self.graph.parse(urlparse.urljoin(base_url, sch),\n+                                     format=fmt)\n+                    break\n+                except xml.sax.SAXParseException:  # type: ignore\n+                    pass\n+                except TypeError:\n+                    pass\n+                except BadSyntax:\n+                    pass\n+\n+        for s, _, _ in self.graph.triples((None, RDF.type, RDF.Property)):\n             self._add_properties(s)\n-        for s, _, o in self.graph.triples( (None, RDFS.subPropertyOf, None) ):\n+        for s, _, o in self.graph.triples((None, RDFS.subPropertyOf, None)):\n             self._add_properties(s)\n             self._add_properties(o)\n-        for s, _, _ in self.graph.triples( (None, RDFS.range, None) ):\n+        for s, _, _ in self.graph.triples((None, RDFS.range, None)):\n             self._add_properties(s)\n-        for s, _, _ in self.graph.triples( (None, RDF.type, OWL.ObjectProperty) ):\n+        for s, _, _ in self.graph.triples((None, RDF.type, OWL.ObjectProperty)):\n             self._add_properties(s)\n \n-        for s, _, _ in self.graph.triples( (None, None, None) ):\n-            self.idx[str(s)] = True\n-\n+        for s, _, _ in self.graph.triples((None, None, None)):\n+            self.idx[unicode(s)] = None\n \n     def add_context(self, newcontext, baseuri=\"\"):\n+        # type: (Loader.ContextType, unicode) -> None\n         if self.vocab:\n-            raise validate.ValidationException(\"Refreshing context that already has stuff in it\")\n+            raise validate.ValidationException(\n+                \"Refreshing context that already has stuff in it\")\n \n         self.url_fields = set()\n+        self.scoped_ref_fields = {}\n         self.vocab_fields = set()\n         self.identifiers = set()\n         self.identity_links = set()\n@@ -175,39 +206,45 @@ def add_context(self, newcontext, baseuri=\"\"):\n         self.mapPredicate = {}\n         self.vocab = {}\n         self.rvocab = {}\n+        self.type_dsl_fields = set()\n \n-        self.ctx.update(_copy_dict_without_key(newcontext, \"@context\"))\n+        self.ctx.update(_copy_dict_without_key(newcontext, u\"@context\"))\n \n         _logger.debug(\"ctx is %s\", self.ctx)\n \n-        for c in self.ctx:\n-            if self.ctx[c] == \"@id\":\n-                self.identifiers.add(c)\n-                self.identity_links.add(c)\n-            elif isinstance(self.ctx[c], dict) and self.ctx[c].get(\"@type\") == \"@id\":\n-                self.url_fields.add(c)\n-                if self.ctx[c].get(\"identity\", False):\n-                    self.identity_links.add(c)\n-            elif isinstance(self.ctx[c], dict) and self.ctx[c].get(\"@type\") == \"@vocab\":\n-                self.url_fields.add(c)\n-                self.vocab_fields.add(c)\n-\n-            if isinstance(self.ctx[c], dict) and self.ctx[c].get(\"noLinkCheck\"):\n-                self.nolinkcheck.add(c)\n-\n-            if isinstance(self.ctx[c], dict) and self.ctx[c].get(\"mapSubject\"):\n-                self.idmap[c] = self.ctx[c][\"mapSubject\"]\n-\n-            if isinstance(self.ctx[c], dict) and self.ctx[c].get(\"mapPredicate\"):\n-                self.mapPredicate[c] = self.ctx[c][\"mapPredicate\"]\n-\n-            if isinstance(self.ctx[c], dict) and \"@id\" in self.ctx[c]:\n-                self.vocab[c] = self.ctx[c][\"@id\"]\n-            elif isinstance(self.ctx[c], basestring):\n-                self.vocab[c] = self.ctx[c]\n-\n-        for k,v in self.vocab.items():\n-            self.rvocab[self.expand_url(v, \"\", scoped=False)] = k\n+        for key, value in self.ctx.items():\n+            if value == u\"@id\":\n+                self.identifiers.add(key)\n+                self.identity_links.add(key)\n+            elif isinstance(value, dict) and value.get(u\"@type\") == u\"@id\":\n+                self.url_fields.add(key)\n+                if u\"refScope\" in value:\n+                    self.scoped_ref_fields[key] = value[u\"refScope\"]\n+                if value.get(u\"identity\", False):\n+                    self.identity_links.add(key)\n+            elif isinstance(value, dict) and value.get(u\"@type\") == u\"@vocab\":\n+                self.url_fields.add(key)\n+                self.vocab_fields.add(key)\n+                if u\"refScope\" in value:\n+                    self.scoped_ref_fields[key] = value[u\"refScope\"]\n+                if value.get(u\"typeDSL\"):\n+                    self.type_dsl_fields.add(key)\n+            if isinstance(value, dict) and value.get(u\"noLinkCheck\"):\n+                self.nolinkcheck.add(key)\n+\n+            if isinstance(value, dict) and value.get(u\"mapSubject\"):\n+                self.idmap[key] = value[u\"mapSubject\"]\n+\n+            if isinstance(value, dict) and value.get(u\"mapPredicate\"):\n+                self.mapPredicate[key] = value[u\"mapPredicate\"]\n+\n+            if isinstance(value, dict) and u\"@id\" in value:\n+                self.vocab[key] = value[u\"@id\"]\n+            elif isinstance(value, basestring):\n+                self.vocab[key] = value\n+\n+        for k, v in self.vocab.items():\n+            self.rvocab[self.expand_url(v, u\"\", scoped_id=False)] = k\n \n         _logger.debug(\"identifiers is %s\", self.identifiers)\n         _logger.debug(\"identity_links is %s\", self.identity_links)\n@@ -215,29 +252,31 @@ def add_context(self, newcontext, baseuri=\"\"):\n         _logger.debug(\"vocab_fields is %s\", self.vocab_fields)\n         _logger.debug(\"vocab is %s\", self.vocab)\n \n+    def resolve_ref(self, ref, base_url=None, checklinks=True):\n+        # type: (Union[Dict[unicode, Any], unicode], unicode, bool) -> Tuple[Union[List, Dict[unicode, Any], unicode], Dict[unicode, Any]]\n+        base_url = base_url or u'file://%s/' % os.path.abspath('.')\n \n-    def resolve_ref(self, ref, base_url=None):\n-        base_url = base_url or 'file://%s/' % os.path.abspath('.')\n-\n-        obj = None\n+        obj = None  # type: Dict[unicode, Any]\n         inc = False\n \n         # If `ref` is a dict, look for special directives.\n         if isinstance(ref, dict):\n             obj = ref\n-            if \"$import\" in ref:\n+            if u\"$import\" in ref:\n                 if len(obj) == 1:\n-                    ref = obj[\"$import\"]\n+                    ref = obj[u\"$import\"]\n                     obj = None\n                 else:\n-                    raise ValueError(\"'$import' must be the only field in %s\" % (str(obj)))\n-            elif \"$include\" in obj:\n+                    raise ValueError(\n+                        \"'$import' must be the only field in %s\" % (str(obj)))\n+            elif u\"$include\" in obj:\n                 if len(obj) == 1:\n-                    ref = obj[\"$include\"]\n+                    ref = obj[u\"$include\"]\n                     inc = True\n                     obj = None\n                 else:\n-                    raise ValueError(\"'$include' must be the only field in %s\" % (str(obj)))\n+                    raise ValueError(\n+                        \"'$include' must be the only field in %s\" % (str(obj)))\n             else:\n                 ref = None\n                 for identifier in self.identifiers:\n@@ -245,12 +284,13 @@ def resolve_ref(self, ref, base_url=None):\n                         ref = obj[identifier]\n                         break\n                 if not ref:\n-                    raise ValueError(\"Object `%s` does not have identifier field in %s\" % (obj, self.identifiers))\n+                    raise ValueError(\n+                        \"Object `%s` does not have identifier field in %s\" % (obj, self.identifiers))\n \n-        if not isinstance(ref, basestring):\n+        if not isinstance(ref, (str, unicode)):\n             raise ValueError(\"Must be string: `%s`\" % str(ref))\n \n-        url = self.expand_url(ref, base_url, scoped=(obj is not None))\n+        url = self.expand_url(ref, base_url, scoped_id=(obj is not None))\n \n         # Has this reference been loaded already?\n         if url in self.idx:\n@@ -260,6 +300,7 @@ def resolve_ref(self, ref, base_url=None):\n         if inc:\n             return self.fetch_text(url), {}\n \n+        doc = None\n         if obj:\n             for identifier in self.identifiers:\n                 obj[identifier] = url\n@@ -268,136 +309,242 @@ def resolve_ref(self, ref, base_url=None):\n             # Load structured document\n             doc_url, frg = urlparse.urldefrag(url)\n             if doc_url in self.idx:\n-                raise validate.ValidationException(\"Reference `#%s` not found in file `%s`.\" % (frg, doc_url))\n-            obj = self.fetch(doc_url)\n+                raise validate.ValidationException(\n+                    \"Reference `#%s` not found in file `%s`.\" % (frg, doc_url))\n+            doc = self.fetch(doc_url)\n \n         # Recursively expand urls and resolve directives\n-        obj, metadata = self.resolve_all(obj, doc_url)\n+        resolved_obj, metadata = self.resolve_all(\n+            doc if doc else obj, doc_url, checklinks=checklinks)\n \n-        # Requested reference should be in the index now, otherwise it's a bad reference\n+        # Requested reference should be in the index now, otherwise it's a bad\n+        # reference\n         if url is not None:\n             if url in self.idx:\n-                obj = self.idx[url]\n+                resolved_obj = self.idx[url]\n             else:\n-                raise RuntimeError(\"Reference `%s` is not in the index.  Index contains:\\n  %s\" % (url, \"\\n  \".join(self.idx)))\n+                raise RuntimeError(\"Reference `%s` is not in the index. \"\n+                    \"Index contains:\\n  %s\" % (url, \"\\n  \".join(self.idx)))\n \n-        try:\n-            if \"$graph\" in obj:\n-                metadata = _copy_dict_without_key(obj, \"$graph\")\n-                obj = obj[\"$graph\"]\n-                return obj, metadata\n+        if isinstance(resolved_obj, (dict)):\n+            if u\"$graph\" in resolved_obj:\n+                metadata = _copy_dict_without_key(resolved_obj, u\"$graph\")\n+                return resolved_obj[u\"$graph\"], metadata\n             else:\n-                return obj, metadata\n-        except TypeError:\n-            return obj, metadata\n+                return resolved_obj, metadata\n+        else:\n+            return resolved_obj, metadata\n+\n+\n+    def _resolve_idmap(self, document, loader):\n+        # type: (Dict[unicode, Union[Dict[unicode, Dict[unicode, unicode]], List[Dict[unicode, Any]]]], Loader) -> None\n+        # Convert fields with mapSubject into lists\n+        # use mapPredicate if the mapped value isn't a dict.\n+        for idmapField in loader.idmap:\n+            if (idmapField in document):\n+                idmapFieldValue = document[idmapField]\n+                if (isinstance(idmapFieldValue, dict)\n+                        and \"$import\" not in idmapFieldValue\n+                        and \"$include\" not in idmapFieldValue):\n+                    ls = []\n+                    for k in sorted(idmapFieldValue.keys()):\n+                        val = idmapFieldValue[k]\n+                        v = None  # type: Dict[unicode, Any]\n+                        if not isinstance(val, dict):\n+                            if idmapField in loader.mapPredicate:\n+                                v = {loader.mapPredicate[idmapField]: val}\n+                            else:\n+                                raise validate.ValidationException(\n+                                    \"mapSubject '%s' value '%s' is not a dict\"\n+                                    \"and does not have a mapPredicate\", k, v)\n+                        else:\n+                            v = val\n+                        v[loader.idmap[idmapField]] = k\n+                        ls.append(v)\n+                    document[idmapField] = ls\n \n-    def resolve_all(self, document, base_url, file_base=None):\n+    typeDSLregex = re.compile(ur\"^([^[?]+)(\\[\\])?(\\?)?$\")\n+\n+    def _type_dsl(self, t):\n+        # type: (Union[unicode, Dict, List]) -> Union[unicode, Dict[unicode, unicode], List[Union[unicode, Dict[unicode, unicode]]]]\n+        if not isinstance(t, (str, unicode)):\n+            return t\n+\n+        m = Loader.typeDSLregex.match(t)\n+        if not m:\n+            return t\n+        first = m.group(1)\n+        second = third = None\n+        if m.group(2):\n+            second = {u\"type\": u\"array\",\n+                 u\"items\": first}\n+        if m.group(3):\n+            third = [u\"null\", second or first]\n+        return third or second or first\n+\n+    def _resolve_type_dsl(self, document, loader):\n+        # type: (Dict[unicode, Union[unicode, Dict[unicode, unicode], List]], Loader) -> None\n+        for d in loader.type_dsl_fields:\n+            if d in document:\n+                datum = document[d]\n+                if isinstance(datum, (str, unicode)):\n+                    document[d] = self._type_dsl(datum)\n+                elif isinstance(datum, list):\n+                    document[d] = [self._type_dsl(t) for t in datum]\n+                datum2 = document[d]\n+                if isinstance(datum2, list):\n+                    document[d] = flatten(datum2)\n+                    seen = []  # type: List[unicode]\n+                    uniq = []\n+                    for item in document[d]:\n+                        if item not in seen:\n+                            uniq.append(item)\n+                            seen.append(item)\n+                    document[d] = uniq\n+\n+    def _resolve_identifier(self, document, loader, base_url):\n+        # type: (Dict[unicode, unicode], Loader, unicode) -> unicode\n+        # Expand identifier field (usually 'id') to resolve scope\n+        for identifer in loader.identifiers:\n+            if identifer in document:\n+                if isinstance(document[identifer], basestring):\n+                    document[identifer] = loader.expand_url(\n+                        document[identifer], base_url, scoped_id=True)\n+                    if (document[identifer] not in loader.idx\n+                            or isinstance(\n+                                loader.idx[document[identifer]], basestring)):\n+                        loader.idx[document[identifer]] = document\n+                    base_url = document[identifer]\n+                else:\n+                    raise validate.ValidationException(\n+                        \"identifier field '%s' must be a string\"\n+                        % (document[identifer]))\n+        return base_url\n+\n+    def _resolve_identity(self, document, loader, base_url):\n+        # type: (Dict[unicode, List[unicode]], Loader, unicode) -> None\n+        # Resolve scope for identity fields (fields where the value is the\n+        # identity of a standalone node, such as enum symbols)\n+        for identifer in loader.identity_links:\n+            if identifer in document and isinstance(document[identifer], list):\n+                for n, v in enumerate(document[identifer]):\n+                    if isinstance(document[identifer][n], basestring):\n+                        document[identifer][n] = loader.expand_url(\n+                            document[identifer][n], base_url, scoped_id=True)\n+                        if document[identifer][n] not in loader.idx:\n+                            loader.idx[document[identifer][\n+                                n]] = document[identifer][n]\n+\n+    def _normalize_fields(self, document, loader):\n+        # type: (Dict[unicode, unicode], Loader) -> None\n+        # Normalize fields which are prefixed or full URIn to vocabulary terms\n+        for d in document:\n+            d2 = loader.expand_url(d, u\"\", scoped_id=False, vocab_term=True)\n+            if d != d2:\n+                document[d2] = document[d]\n+                del document[d]\n+\n+    def _resolve_uris(self, document, loader, base_url):\n+        # type: (Dict[unicode, Union[unicode, List[unicode]]], Loader, unicode) -> None\n+        # Resolve remaining URLs based on document base\n+        for d in loader.url_fields:\n+            if d in document:\n+                datum = document[d]\n+                if isinstance(datum, (str, unicode)):\n+                    document[d] = loader.expand_url(\n+                        datum, base_url, scoped_id=False,\n+                        vocab_term=(d in loader.vocab_fields),\n+                        scoped_ref=self.scoped_ref_fields.get(d))\n+                elif isinstance(datum, list):\n+                    document[d] = [\n+                        loader.expand_url(\n+                            url, base_url, scoped_id=False,\n+                            vocab_term=(d in loader.vocab_fields),\n+                            scoped_ref=self.scoped_ref_fields.get(d))\n+                        if isinstance(url, (str, unicode))\n+                        else url for url in datum]\n+\n+\n+    def resolve_all(self, document, base_url, file_base=None, checklinks=True):\n+        # type: (DocumentType, unicode, unicode, bool) -> Tuple[Union[List, Dict[unicode, Any], unicode], Dict[unicode, Any]]\n         loader = self\n-        metadata = {}  # type: Dict[str, str]\n+        metadata = {}  # type: Dict[unicode, Any]\n         if file_base is None:\n             file_base = base_url\n \n         if isinstance(document, dict):\n             # Handle $import and $include\n-            if ('$import' in document or '$include' in document):\n-                return self.resolve_ref(document, file_base)\n+            if (u'$import' in document or u'$include' in document):\n+                return self.resolve_ref(document, base_url=file_base, checklinks=checklinks)\n         elif isinstance(document, list):\n             pass\n         else:\n-            return document, metadata\n+            return (document, metadata)\n \n-        newctx = None\n+        newctx = None  # type: Loader\n         if isinstance(document, dict):\n             # Handle $base, $profile, $namespaces, $schemas and $graph\n-            if \"$base\" in document:\n-                base_url = document[\"$base\"]\n+            if u\"$base\" in document:\n+                base_url = document[u\"$base\"]\n \n-            if \"$profile\" in document:\n+            if u\"$profile\" in document:\n                 if not newctx:\n                     newctx = SubLoader(self)\n-                prof = self.fetch(document[\"$profile\"])\n-                newctx.add_namespaces(document.get(\"$namespaces\", {}), document[\"$profile\"])\n-                newctx.add_schemas(document.get(\"$schemas\", []), document[\"$profile\"])\n+                prof = self.fetch(document[u\"$profile\"])\n+                newctx.add_namespaces(document.get(u\"$namespaces\", {}))\n+                newctx.add_schemas(document.get(\n+                    u\"$schemas\", []), document[u\"$profile\"])\n \n-            if \"$namespaces\" in document:\n+            if u\"$namespaces\" in document:\n                 if not newctx:\n                     newctx = SubLoader(self)\n-                newctx.add_namespaces(document[\"$namespaces\"])\n+                newctx.add_namespaces(document[u\"$namespaces\"])\n \n-            if \"$schemas\" in document:\n+            if u\"$schemas\" in document:\n                 if not newctx:\n                     newctx = SubLoader(self)\n-                newctx.add_schemas(document[\"$schemas\"], file_base)\n+                newctx.add_schemas(document[u\"$schemas\"], file_base)\n \n             if newctx:\n                 loader = newctx\n \n-            if \"$graph\" in document:\n-                metadata = _copy_dict_without_key(document, \"$graph\")\n-                document = document[\"$graph\"]\n-                metadata, _ = loader.resolve_all(metadata, base_url, file_base)\n+            if u\"$graph\" in document:\n+                metadata = _copy_dict_without_key(document, u\"$graph\")\n+                document = document[u\"$graph\"]\n+                resolved_metadata = loader.resolve_all(metadata, base_url,\n+                        file_base=file_base, checklinks=False)[0]\n+                if isinstance(resolved_metadata, dict):\n+                    metadata = resolved_metadata\n+                else:\n+                    raise validate.ValidationException(\n+                        \"Validation error, metadata must be dict: %s\"\n+                        % (resolved_metadata))\n \n         if isinstance(document, dict):\n-            for idmapField in loader.idmap:\n-                if idmapField in document and isinstance(document[idmapField], dict):\n-                    ls = []\n-                    for k,v in document[idmapField].items():\n-                        if not isinstance(v, dict):\n-                            if idmapField in loader.mapPredicate:\n-                                v = {loader.mapPredicate[idmapField]: v}\n-                            else:\n-                                raise validate.ValidationException(\"mapSubject '%s' value '%s' is not a dict and does not have a mapPredicate\", k, v)\n-                        v[loader.idmap[idmapField]] = k\n-                        ls.append(v)\n-                    document[idmapField] = ls\n-\n-            for identifer in loader.identifiers:\n-                if identifer in document:\n-                    if isinstance(document[identifer], basestring):\n-                        document[identifer] = loader.expand_url(document[identifer], base_url, scoped=True)\n-                        if document[identifer] not in loader.idx or isinstance(loader.idx[document[identifer]], basestring):\n-                            loader.idx[document[identifer]] = document\n-                        base_url = document[identifer]\n-                    else:\n-                        raise validate.ValidationException(\"identifier field '%s' must be a string\" % (document[identifer]))\n-\n-            for identifer in loader.identity_links:\n-                if identifer in document and isinstance(document[identifer], list):\n-                    for n, v in enumerate(document[identifer]):\n-                        document[identifer][n] = loader.expand_url(document[identifer][n], base_url, scoped=True)\n-                        if document[identifer][n] not in loader.idx:\n-                            loader.idx[document[identifer][n]] = document[identifer][n]\n-                #else:\n-                #    raise validate.ValidationException(\"identity field '%s' must be a string\" % (document[identifer]))\n-\n-            for d in document:\n-                d2 = loader.expand_url(d, \"\", scoped=False, vocab_term=True)\n-                if d != d2:\n-                    document[d2] = document[d]\n-                    del document[d]\n-\n-            for d in loader.url_fields:\n-                if d in document:\n-                    if isinstance(document[d], basestring):\n-                        document[d] = loader.expand_url(document[d], base_url, scoped=False, vocab_term=(d in loader.vocab_fields))\n-                    elif isinstance(document[d], list):\n-                        document[d] = [loader.expand_url(url, base_url, scoped=False, vocab_term=(d in loader.vocab_fields)) if isinstance(url, basestring) else url for url in document[d] ]\n+            self._normalize_fields(document, loader)\n+            self._resolve_idmap(document, loader)\n+            self._resolve_type_dsl(document, loader)\n+            base_url = self._resolve_identifier(document, loader, base_url)\n+            self._resolve_identity(document, loader, base_url)\n+            self._resolve_uris(document, loader, base_url)\n \n             try:\n                 for key, val in document.items():\n-                    document[key], _ = loader.resolve_all(val, base_url, file_base)\n+                    document[key], _ = loader.resolve_all(\n+                        val, base_url, file_base=file_base, checklinks=False)\n             except validate.ValidationException as v:\n                 _logger.debug(\"loader is %s\", id(loader))\n-                raise validate.ValidationException(\"(%s) (%s) Validation error in field %s:\\n%s\" % (id(loader), file_base, key, validate.indent(str(v))))\n+                raise validate.ValidationException(\"(%s) (%s) Validation error in field %s:\\n%s\" % (\n+                    id(loader), file_base, key, validate.indent(str(v))))\n \n         elif isinstance(document, list):\n             i = 0\n             try:\n                 while i < len(document):\n                     val = document[i]\n-                    if isinstance(val, dict) and \"$import\" in val:\n-                        l, _ = loader.resolve_ref(val, file_base)\n-                        if isinstance(l, list):\n+                    if isinstance(val, dict) and u\"$import\" in val:\n+                        l, _ = loader.resolve_ref(val, base_url=file_base, checklinks=False)\n+                        if isinstance(l, list):  # never true?\n                             del document[i]\n                             for item in aslist(l):\n                                 document.insert(i, item)\n@@ -406,27 +553,34 @@ def resolve_all(self, document, base_url, file_base=None):\n                             document[i] = l\n                             i += 1\n                     else:\n-                        document[i], _ = loader.resolve_all(val, base_url, file_base)\n+                        document[i], _ = loader.resolve_all(\n+                            val, base_url, file_base=file_base, checklinks=False)\n                         i += 1\n             except validate.ValidationException as v:\n-                raise validate.ValidationException(\"(%s) (%s) Validation error in position %i:\\n%s\" % (id(loader), file_base, i, validate.indent(str(v))))\n+                raise validate.ValidationException(\"(%s) (%s) Validation error in position %i:\\n%s\" % (\n+                    id(loader), file_base, i, validate.indent(str(v))))\n \n             for identifer in loader.identity_links:\n                 if identifer in metadata:\n-                    if isinstance(metadata[identifer], basestring):\n-                        metadata[identifer] = loader.expand_url(metadata[identifer], base_url, scoped=True)\n+                    if isinstance(metadata[identifer], (str, unicode)):\n+                        metadata[identifer] = loader.expand_url(\n+                            metadata[identifer], base_url, scoped_id=True)\n                         loader.idx[metadata[identifer]] = document\n \n+        if checklinks:\n+            document = self.validate_links(document, u\"\")\n+\n         return document, metadata\n \n     def fetch_text(self, url):\n+        # type: (unicode) -> unicode\n         if url in self.cache:\n             return self.cache[url]\n \n         split = urlparse.urlsplit(url)\n         scheme, path = split.scheme, split.path\n \n-        if scheme in ['http', 'https'] and requests:\n+        if scheme in [u'http', u'https'] and requests:\n             try:\n                 resp = requests.get(url)\n                 resp.raise_for_status()\n@@ -446,18 +600,18 @@ def fetch_text(self, url):\n         else:\n             raise ValueError('Unsupported scheme in url: %s' % url)\n \n-    def fetch(self, url):\n+    def fetch(self, url):  # type: (unicode) -> Any\n         if url in self.idx:\n             return self.idx[url]\n         try:\n             text = self.fetch_text(url)\n             if isinstance(text, bytes):\n-                text = StringIO(text.decode('utf-8'))\n+                textIO = StringIO(text.decode('utf-8'))\n             else:\n-                text = StringIO(text)\n-            text.name = url\n-            result = yaml.load(text)\n-        except yaml.parser.ParserError as e:\n+                textIO = StringIO(text)\n+            textIO.name = url  # type: ignore\n+            result = yaml.load(textIO, Loader=SafeLoader)\n+        except yaml.parser.ParserError as e:  # type: ignore\n             raise validate.ValidationException(\"Syntax error %s\" % (e))\n         if isinstance(result, dict) and self.identifiers:\n             for identifier in self.identifiers:\n@@ -468,58 +622,97 @@ def fetch(self, url):\n             self.idx[url] = result\n         return result\n \n-    def check_file(self, fn):\n+    def check_file(self, fn):  # type: (unicode) -> bool\n         if fn.startswith(\"file://\"):\n             u = urlparse.urlsplit(fn)\n             return os.path.exists(u.path)\n         else:\n             return False\n \n-    def validate_link(self, field, link):\n+    FieldType = TypeVar('FieldType', unicode, List[unicode], Dict[unicode, Any])\n+\n+    def validate_scoped(self, field, link, docid):\n+        # type: (unicode, unicode, unicode) -> unicode\n+        split = urlparse.urlsplit(docid)\n+        sp = split.fragment.split(u\"/\")\n+        n = self.scoped_ref_fields[field]\n+        while n > 0 and len(sp) > 0:\n+            sp.pop()\n+            n -= 1\n+        tried = []\n+        while True:\n+            sp.append(link)\n+            url = urlparse.urlunsplit((\n+                split.scheme, split.netloc, split.path, split.query,\n+                u\"/\".join(sp)))\n+            tried.append(url)\n+            if url in self.idx:\n+                return url\n+            sp.pop()\n+            if len(sp) == 0:\n+                break\n+            sp.pop()\n+        raise validate.ValidationException(\n+            \"Field `%s` contains undefined reference to `%s`, tried %s\" % (field, link, tried))\n+\n+    def validate_link(self, field, link, docid):\n+        # type: (unicode, FieldType, unicode) -> FieldType\n         if field in self.nolinkcheck:\n-            return True\n-        if isinstance(link, basestring):\n+            return link\n+        if isinstance(link, (str, unicode)):\n             if field in self.vocab_fields:\n                 if link not in self.vocab and link not in self.idx and link not in self.rvocab:\n-                    if not self.check_file(link):\n-                        raise validate.ValidationException(\"Field `%s` contains undefined reference to `%s`\" % (field, link))\n+                    if field in self.scoped_ref_fields:\n+                        return self.validate_scoped(field, link, docid)\n+                    elif not self.check_file(link):\n+                        raise validate.ValidationException(\n+                            \"Field `%s` contains undefined reference to `%s`\" % (field, link))\n             elif link not in self.idx and link not in self.rvocab:\n-                if not self.check_file(link):\n-                    raise validate.ValidationException(\"Field `%s` contains undefined reference to `%s`\" % (field, link))\n+                if field in self.scoped_ref_fields:\n+                    return self.validate_scoped(field, link, docid)\n+                elif not self.check_file(link):\n+                    raise validate.ValidationException(\n+                        \"Field `%s` contains undefined reference to `%s`\" % (field, link))\n         elif isinstance(link, list):\n             errors = []\n-            for i in link:\n+            for n, i in enumerate(link):\n                 try:\n-                    self.validate_link(field, i)\n+                    link[n] = self.validate_link(field, i, docid)\n                 except validate.ValidationException as v:\n                     errors.append(v)\n             if errors:\n-                raise validate.ValidationException(\"\\n\".join([str(e) for e in errors]))\n+                raise validate.ValidationException(\n+                    \"\\n\".join([str(e) for e in errors]))\n         elif isinstance(link, dict):\n-            self.validate_links(link)\n-        return True\n+            self.validate_links(link, docid)\n+        else:\n+            raise validate.ValidationException(\"Link must be a str, unicode, \"\n+                                               \"list, or a dict.\")\n+        return link\n \n-    def getid(self, d):\n+    def getid(self, d):  # type: (Any) -> unicode\n         if isinstance(d, dict):\n             for i in self.identifiers:\n                 if i in d:\n-                    if isinstance(d[i], basestring):\n+                    if isinstance(d[i], (str, unicode)):\n                         return d[i]\n         return None\n \n-    def validate_links(self, document):\n+    def validate_links(self, document, base_url):\n+        # type: (DocumentType, unicode) -> DocumentType\n         docid = self.getid(document)\n-        if docid is None:\n-            docid = \"\"\n+        if not docid:\n+            docid = base_url\n \n         errors = []\n+        iterator = None  # type: Any\n         if isinstance(document, list):\n             iterator = enumerate(document)\n         elif isinstance(document, dict):\n             try:\n                 for d in self.url_fields:\n-                    if d not in self.identity_links and d in document:\n-                        self.validate_link(d, document[d])\n+                    if d in document and d not in self.identity_links:\n+                        document[d] = self.validate_link(d, document[d], docid)\n             except validate.ValidationException as v:\n                 errors.append(v)\n             if hasattr(document, \"iteritems\"):\n@@ -527,31 +720,36 @@ def validate_links(self, document):\n             else:\n                 iterator = document.items()\n         else:\n-            return\n+            return document\n \n         for key, val in iterator:\n             try:\n-                self.validate_links(val)\n+                document[key] = self.validate_links(val, docid)  # type: ignore\n             except validate.ValidationException as v:\n                 if key not in self.nolinkcheck:\n-                    docid = self.getid(val)\n-                    if docid:\n-                        errors.append(validate.ValidationException(\"While checking object `%s`\\n%s\" % (docid, validate.indent(str(v)))))\n+                    docid2 = self.getid(val)\n+                    if docid2:\n+                        errors.append(validate.ValidationException(\n+                            \"While checking object `%s`\\n%s\" % (docid2, validate.indent(str(v)))))\n                     else:\n                         if isinstance(key, basestring):\n-                            errors.append(validate.ValidationException(\"While checking field `%s`\\n%s\" % (key, validate.indent(str(v)))))\n+                            errors.append(validate.ValidationException(\n+                                \"While checking field `%s`\\n%s\" % (key, validate.indent(str(v)))))\n                         else:\n-                            errors.append(validate.ValidationException(\"While checking position %s\\n%s\" % (key, validate.indent(str(v)))))\n+                            errors.append(validate.ValidationException(\n+                                \"While checking position %s\\n%s\" % (key, validate.indent(str(v)))))\n \n         if errors:\n             if len(errors) > 1:\n-                raise validate.ValidationException(\"\\n\".join([str(e) for e in errors]))\n+                raise validate.ValidationException(\n+                    \"\\n\".join([str(e) for e in errors]))\n             else:\n                 raise errors[0]\n-        return\n+        return document\n \n \n def _copy_dict_without_key(from_dict, filtered_key):\n+    # type: (Dict, Any) -> Dict\n     new_dict = {}\n     for key, value in from_dict.items():\n         if key != filtered_key:\ndiff --git a/cwltool/schemas/draft-4/salad/schema_salad/schema.py b/cwltool/schemas/draft-4/salad/schema_salad/schema.py\n--- a/cwltool/schemas/draft-4/salad/schema_salad/schema.py\n+++ b/cwltool/schemas/draft-4/salad/schema_salad/schema.py\n@@ -4,49 +4,51 @@\n import sys\n import pprint\n from pkg_resources import resource_stream\n-import yaml\n+import ruamel.yaml as yaml\n+try:\n+    from ruamel.yaml import CSafeLoader as SafeLoader\n+except ImportError:\n+    from ruamel.yaml import SafeLoader  # type: ignore\n import avro.schema\n from . import validate\n import json\n-try:\n-    import urlparse\n-    AvroSchemaFromJSONData=avro.schema.make_avsc_object\n-except ImportError:\n-    import urllib.parse as urlparse\n-    basestring=str\n-    AvroSchemaFromJSONData=avro.schema.SchemaFromJSONData\n+import urlparse\n+AvroSchemaFromJSONData = avro.schema.make_avsc_object\n+# AvroSchemaFromJSONData=avro.schema.SchemaFromJSONData\n from . import ref_resolver\n from .flatten import flatten\n import logging\n from .aslist import aslist\n from . import jsonld_context\n-if sys.version_info >= (2,7):\n-    import typing\n+from typing import Any, AnyStr, cast, Dict, List, Tuple, TypeVar, Union\n \n _logger = logging.getLogger(\"salad\")\n \n salad_files = ('metaschema.yml',\n-              'salad.md',\n-              'field_name.yml',\n-              'import_include.md',\n-              'link_res.yml',\n-              'ident_res.yml',\n-              'vocab_res.yml',\n-              'vocab_res.yml',\n-              'field_name_schema.yml',\n-              'field_name_src.yml',\n-              'field_name_proc.yml',\n-              'ident_res_schema.yml',\n-              'ident_res_src.yml',\n-              'ident_res_proc.yml',\n-              'link_res_schema.yml',\n-              'link_res_src.yml',\n-              'link_res_proc.yml',\n-              'vocab_res_schema.yml',\n-              'vocab_res_src.yml',\n-              'vocab_res_proc.yml')\n+               'metaschema_base.yml',\n+               'salad.md',\n+               'field_name.yml',\n+               'import_include.md',\n+               'link_res.yml',\n+               'ident_res.yml',\n+               'vocab_res.yml',\n+               'vocab_res.yml',\n+               'field_name_schema.yml',\n+               'field_name_src.yml',\n+               'field_name_proc.yml',\n+               'ident_res_schema.yml',\n+               'ident_res_src.yml',\n+               'ident_res_proc.yml',\n+               'link_res_schema.yml',\n+               'link_res_src.yml',\n+               'link_res_proc.yml',\n+               'vocab_res_schema.yml',\n+               'vocab_res_src.yml',\n+               'vocab_res_proc.yml')\n+\n \n def get_metaschema():\n+    # type: () -> Tuple[avro.schema.Names, List[Dict[unicode, Any]], ref_resolver.Loader]\n     loader = ref_resolver.Loader({\n         \"Any\": \"https://w3id.org/cwl/salad#Any\",\n         \"ArraySchema\": \"https://w3id.org/cwl/salad#ArraySchema\",\n@@ -78,21 +80,22 @@ def get_metaschema():\n             \"@id\": \"https://w3id.org/cwl/salad#docAfter\",\n             \"@type\": \"@id\"\n         },\n-        \"docParent\": {\n-            \"@id\": \"https://w3id.org/cwl/salad#docParent\",\n-            \"@type\": \"@id\"\n-        },\n         \"docChild\": {\n             \"@id\": \"https://w3id.org/cwl/salad#docChild\",\n             \"@type\": \"@id\"\n         },\n+        \"docParent\": {\n+            \"@id\": \"https://w3id.org/cwl/salad#docParent\",\n+            \"@type\": \"@id\"\n+        },\n         \"documentRoot\": \"https://w3id.org/cwl/salad#SchemaDefinedType/documentRoot\",\n         \"documentation\": \"https://w3id.org/cwl/salad#documentation\",\n         \"double\": \"http://www.w3.org/2001/XMLSchema#double\",\n         \"enum\": \"https://w3id.org/cwl/salad#enum\",\n         \"extends\": {\n             \"@id\": \"https://w3id.org/cwl/salad#extends\",\n-            \"@type\": \"@id\"\n+            \"@type\": \"@id\",\n+            \"refScope\": 1\n         },\n         \"fields\": \"sld:fields\",\n         \"float\": \"http://www.w3.org/2001/XMLSchema#float\",\n@@ -100,16 +103,20 @@ def get_metaschema():\n         \"int\": \"http://www.w3.org/2001/XMLSchema#int\",\n         \"items\": {\n             \"@id\": \"https://w3id.org/cwl/salad#items\",\n-            \"@type\": \"@vocab\"\n+            \"@type\": \"@vocab\",\n+            \"refScope\": 2\n         },\n         \"jsonldPredicate\": \"sld:jsonldPredicate\",\n         \"long\": \"http://www.w3.org/2001/XMLSchema#long\",\n+        \"mapPredicate\": \"https://w3id.org/cwl/salad#JsonldPredicate/mapPredicate\",\n+        \"mapSubject\": \"https://w3id.org/cwl/salad#JsonldPredicate/mapSubject\",\n         \"name\": \"@id\",\n         \"noLinkCheck\": \"https://w3id.org/cwl/salad#JsonldPredicate/noLinkCheck\",\n         \"null\": \"https://w3id.org/cwl/salad#null\",\n         \"rdf\": \"http://www.w3.org/1999/02/22-rdf-syntax-ns#\",\n         \"rdfs\": \"http://www.w3.org/2000/01/rdf-schema#\",\n         \"record\": \"https://w3id.org/cwl/salad#record\",\n+        \"refScope\": \"https://w3id.org/cwl/salad#JsonldPredicate/refScope\",\n         \"sld\": \"https://w3id.org/cwl/salad#\",\n         \"specialize\": \"https://w3id.org/cwl/salad#SaladRecordSchema/specialize\",\n         \"specializeFrom\": {\n@@ -128,8 +135,11 @@ def get_metaschema():\n         },\n         \"type\": {\n             \"@id\": \"https://w3id.org/cwl/salad#type\",\n-            \"@type\": \"@vocab\"\n+            \"@type\": \"@vocab\",\n+            \"refScope\": 2,\n+            \"typeDSL\": True\n         },\n+        \"typeDSL\": \"https://w3id.org/cwl/salad#JsonldPredicate/typeDSL\",\n         \"xsd\": \"http://www.w3.org/2001/XMLSchema#\"\n     })\n \n@@ -142,62 +152,74 @@ def get_metaschema():\n     loader.cache[\"https://w3id.org/cwl/salad\"] = rs.read()\n     rs.close()\n \n-    j = yaml.load(loader.cache[\"https://w3id.org/cwl/salad\"])\n+    j = yaml.load(loader.cache[\"https://w3id.org/cwl/salad\"],\n+            Loader=SafeLoader)\n     j, _ = loader.resolve_all(j, \"https://w3id.org/cwl/salad#\")\n \n-    #pprint.pprint(j)\n+    # pprint.pprint(j)\n \n     (sch_names, sch_obj) = make_avro_schema(j, loader)\n     if isinstance(sch_names, Exception):\n-        _logger.error(\"Metaschema error, avro was:\\n%s\", json.dumps(sch_obj, indent=4))\n+        _logger.error(\"Metaschema error, avro was:\\n%s\",\n+                      json.dumps(sch_obj, indent=4))\n         raise sch_names\n     validate_doc(sch_names, j, loader, strict=True)\n     return (sch_names, j, loader)\n \n+\n def load_schema(schema_ref, cache=None):\n+    # type: (Union[unicode, Dict[unicode, Any]], Dict) -> Tuple[ref_resolver.Loader, Union[avro.schema.Names, avro.schema.SchemaParseException], Dict[unicode, Any], ref_resolver.Loader]\n     metaschema_names, metaschema_doc, metaschema_loader = get_metaschema()\n     if cache is not None:\n         metaschema_loader.cache = cache\n     schema_doc, schema_metadata = metaschema_loader.resolve_ref(schema_ref, \"\")\n \n+    if not isinstance(schema_doc, list):\n+        raise ValueError(\"Schema reference must resolve to a list.\")\n+\n     validate_doc(metaschema_names, schema_doc, metaschema_loader, True)\n     metactx = schema_metadata.get(\"@context\", {})\n     metactx.update(schema_metadata.get(\"$namespaces\", {}))\n-    (schema_ctx, rdfs) = jsonld_context.salad_to_jsonld_context(schema_doc, metactx)\n+    (schema_ctx, rdfs) = jsonld_context.salad_to_jsonld_context(\n+        schema_doc, metactx)\n \n     # Create the loader that will be used to load the target document.\n     document_loader = ref_resolver.Loader(schema_ctx, cache=cache)\n \n-    # Make the Avro validation that will be used to validate the target document\n+    # Make the Avro validation that will be used to validate the target\n+    # document\n     (avsc_names, avsc_obj) = make_avro_schema(schema_doc, document_loader)\n \n-    return document_loader, avsc_names, schema_metadata\n+    return document_loader, avsc_names, schema_metadata, metaschema_loader\n \n def load_and_validate(document_loader, avsc_names, document, strict):\n+    # type: (ref_resolver.Loader, avro.schema.Names, Union[Dict[unicode, Any], unicode], bool) -> Tuple[Any, Dict[unicode, Any]]\n     if isinstance(document, dict):\n         data, metadata = document_loader.resolve_all(document, document[\"id\"])\n     else:\n         data, metadata = document_loader.resolve_ref(document)\n \n-    document_loader.validate_links(data)\n     validate_doc(avsc_names, data, document_loader, strict)\n     return data, metadata\n \n-def validate_doc(schema_names, validate_doc, loader, strict):\n+\n+def validate_doc(schema_names, doc, loader, strict):\n+    # type: (avro.schema.Names, Union[Dict[unicode, Any], List[Dict[unicode, Any]], unicode], ref_resolver.Loader, bool) -> None\n     has_root = False\n     for r in schema_names.names.values():\n-        if ((hasattr(r, 'get_prop') and r.get_prop(\"documentRoot\")) or (\n-                \"documentRoot\" in r.props)):\n+        if ((hasattr(r, 'get_prop') and r.get_prop(u\"documentRoot\")) or (\n+                u\"documentRoot\" in r.props)):\n             has_root = True\n             break\n \n     if not has_root:\n-        raise validate.ValidationException(\"No document roots defined in the schema\")\n+        raise validate.ValidationException(\n+            \"No document roots defined in the schema\")\n \n-    if isinstance(validate_doc, list):\n-        pass\n-    elif isinstance(validate_doc, dict):\n-        validate_doc = [validate_doc]\n+    if isinstance(doc, list):\n+        validate_doc = doc\n+    elif isinstance(doc, dict):\n+        validate_doc = [doc]\n     else:\n         raise validate.ValidationException(\"Document must be dict or list\")\n \n@@ -206,30 +228,34 @@ def validate_doc(schema_names, validate_doc, loader, strict):\n         errors = []\n         success = False\n         for r in schema_names.names.values():\n-            if ((hasattr(r,\"get_prop\") and r.get_prop(\"documentRoot\")) or (\n-                \"documentRoot\" in r.props)):\n+            if ((hasattr(r, \"get_prop\") and r.get_prop(u\"documentRoot\")) or (\n+                    u\"documentRoot\" in r.props)):\n                 try:\n-                    validate.validate_ex(r, item, loader.identifiers, strict, foreign_properties=loader.foreign_properties)\n+                    validate.validate_ex(\n+                        r, item, loader.identifiers, strict, foreign_properties=loader.foreign_properties)\n                     success = True\n                     break\n                 except validate.ValidationException as e:\n                     if hasattr(r, \"get_prop\"):\n-                        name = r.get_prop(\"name\")\n+                        name = r.get_prop(u\"name\")\n                     elif hasattr(r, \"name\"):\n                         name = r.name\n-                    errors.append(\"Could not validate as `%s` because\\n%s\" % (name, validate.indent(str(e), nolead=False)))\n+                    errors.append(\"Could not validate as `%s` because\\n%s\" % (\n+                        name, validate.indent(str(e), nolead=False)))\n         if not success:\n             objerr = \"Validation error at position %i\" % pos\n             for ident in loader.identifiers:\n                 if ident in item:\n                     objerr = \"Validation error in object %s\" % (item[ident])\n                     break\n-            anyerrors.append(\"%s\\n%s\" % (objerr, validate.indent(\"\\n\".join(errors))))\n+            anyerrors.append(\"%s\\n%s\" %\n+                             (objerr, validate.indent(\"\\n\".join(errors))))\n     if anyerrors:\n         raise validate.ValidationException(\"\\n\".join(anyerrors))\n \n \n def replace_type(items, spec, loader, found):\n+    # type: (Any, Dict[unicode, Any], ref_resolver.Loader, Set[unicode]) -> Any\n     \"\"\" Go through and replace types in the 'spec' mapping\"\"\"\n \n     items = copy.deepcopy(items)\n@@ -252,11 +278,12 @@ def replace_type(items, spec, loader, found):\n     elif isinstance(items, list):\n         # recursively transform list\n         return [replace_type(i, spec, loader, found) for i in items]\n-    elif isinstance(items, basestring):\n+    elif isinstance(items, (str, unicode)):\n         # found a string which is a symbol corresponding to a type.\n         replace_with = None\n         if items in loader.vocab:\n-            # If it's a vocabulary term, first expand it to its fully qualified URI\n+            # If it's a vocabulary term, first expand it to its fully qualified\n+            # URI\n             items = loader.vocab[items]\n \n         if items in spec:\n@@ -267,16 +294,20 @@ def replace_type(items, spec, loader, found):\n             return replace_type(replace_with, spec, loader, found)\n     return items\n \n-def avro_name(url):\n+\n+def avro_name(url):  # type: (AnyStr) -> AnyStr\n     doc_url, frg = urlparse.urldefrag(url)\n     if frg:\n         if '/' in frg:\n-            return frg[frg.rindex('/')+1:]\n+            return frg[frg.rindex('/') + 1:]\n         else:\n             return frg\n     return url\n \n+Avro = TypeVar('Avro', Dict[unicode, Any], List[Any], unicode)\n+\n def make_valid_avro(items, alltypes, found, union=False):\n+    # type: (Avro, Dict[unicode, Dict[unicode, Any]], Set[unicode], bool) -> Union[Avro, Dict]\n     items = copy.deepcopy(items)\n     if isinstance(items, dict):\n         if items.get(\"name\"):\n@@ -284,10 +315,11 @@ def make_valid_avro(items, alltypes, found, union=False):\n \n         if \"type\" in items and items[\"type\"] in (\"https://w3id.org/cwl/salad#record\", \"https://w3id.org/cwl/salad#enum\", \"record\", \"enum\"):\n             if (hasattr(items, \"get\") and items.get(\"abstract\")) or (\"abstract\"\n-                    in items):\n+                                                                     in items):\n                 return items\n             if not items.get(\"name\"):\n-                raise Exception(\"Named schemas must have a non-empty name: %s\" % items)\n+                raise Exception(\n+                    \"Named schemas must have a non-empty name: %s\" % items)\n \n             if items[\"name\"] in found:\n                 return items[\"name\"]\n@@ -295,7 +327,8 @@ def make_valid_avro(items, alltypes, found, union=False):\n                 found.add(items[\"name\"])\n         for n in (\"type\", \"items\", \"values\", \"fields\"):\n             if n in items:\n-                items[n] = make_valid_avro(items[n], alltypes, found, union=True)\n+                items[n] = make_valid_avro(\n+                    items[n], alltypes, found, union=True)\n         if \"symbols\" in items:\n             items[\"symbols\"] = [avro_name(sym) for sym in items[\"symbols\"]]\n         return items\n@@ -304,18 +337,21 @@ def make_valid_avro(items, alltypes, found, union=False):\n         for i in items:\n             ret.append(make_valid_avro(i, alltypes, found, union=union))\n         return ret\n-    if union and isinstance(items, basestring):\n+    if union and isinstance(items, (str, unicode)):\n         if items in alltypes and avro_name(items) not in found:\n-            return make_valid_avro(alltypes[items], alltypes, found, union=union)\n-        items = avro_name(items)\n+            return cast(Dict, make_valid_avro(alltypes[items], alltypes, found,\n+                        union=union))\n+        items = avro_name(items)  # type: ignore\n+        # bug in mypy 0.3.1, fixed in 0.4-dev\n     return items\n \n \n def extend_and_specialize(items, loader):\n+    # type: (List[Dict[unicode, Any]], ref_resolver.Loader) -> List[Dict[unicode, Any]]\n     \"\"\"Apply 'extend' and 'specialize' to fully materialize derived record\n     types.\"\"\"\n \n-    types = {}\n+    types = {}  # type: Dict[unicode, Any]\n     for t in items:\n         types[t[\"name\"]] = t\n     n = []\n@@ -323,22 +359,24 @@ def extend_and_specialize(items, loader):\n     for t in items:\n         t = copy.deepcopy(t)\n         if \"extends\" in t:\n-            spec = {}\n+            spec = {}  # type: Dict[unicode, unicode]\n             if \"specialize\" in t:\n                 for sp in aslist(t[\"specialize\"]):\n                     spec[sp[\"specializeFrom\"]] = sp[\"specializeTo\"]\n \n-            exfields = []  # type: List[str]\n-            exsym = []  # type: List[str]\n+            exfields = []  # type: List[unicode]\n+            exsym = []  # type: List[unicode]\n             for ex in aslist(t[\"extends\"]):\n                 if ex not in types:\n-                    raise Exception(\"Extends %s in %s refers to invalid base type\" % (t[\"extends\"], t[\"name\"]))\n+                    raise Exception(\"Extends %s in %s refers to invalid base type\" % (\n+                        t[\"extends\"], t[\"name\"]))\n \n                 basetype = copy.deepcopy(types[ex])\n \n                 if t[\"type\"] == \"record\":\n                     if spec:\n-                        basetype[\"fields\"] = replace_type(basetype.get(\"fields\", []), spec, loader, set())\n+                        basetype[\"fields\"] = replace_type(\n+                            basetype.get(\"fields\", []), spec, loader, set())\n \n                     for f in basetype.get(\"fields\", []):\n                         if \"inherited_from\" not in f:\n@@ -352,19 +390,13 @@ def extend_and_specialize(items, loader):\n                 exfields.extend(t.get(\"fields\", []))\n                 t[\"fields\"] = exfields\n \n-                fieldnames = set()  # type: Set[str]\n+                fieldnames = set()  # type: Set[unicode]\n                 for field in t[\"fields\"]:\n                     if field[\"name\"] in fieldnames:\n-                        raise validate.ValidationException(\"Field name %s appears twice in %s\" % (field[\"name\"], t[\"name\"]))\n+                        raise validate.ValidationException(\n+                            \"Field name %s appears twice in %s\" % (field[\"name\"], t[\"name\"]))\n                     else:\n                         fieldnames.add(field[\"name\"])\n-\n-                for y in [x for x in t[\"fields\"] if x[\"name\"] == \"class\"]:\n-                    y[\"type\"] = {\"type\": \"enum\",\n-                                 \"symbols\": [r[\"name\"]],\n-                                 \"name\": r[\"name\"]+\"_class\",\n-                    }\n-                    y[\"doc\"] = \"Must be `%s` to indicate this is a %s object.\" % (r[\"name\"], r[\"name\"])\n             elif t[\"type\"] == \"enum\":\n                 exsym.extend(t.get(\"symbols\", []))\n                 t[\"symbol\"] = exsym\n@@ -377,7 +409,7 @@ def extend_and_specialize(items, loader):\n     for t in n:\n         ex_types[t[\"name\"]] = t\n \n-    extended_by = {}  # type: Dict[str, str]\n+    extended_by = {}  # type: Dict[unicode, unicode]\n     for t in n:\n         if \"extends\" in t:\n             for ex in aslist(t[\"extends\"]):\n@@ -385,29 +417,34 @@ def extend_and_specialize(items, loader):\n                     add_dictlist(extended_by, ex, ex_types[t[\"name\"]])\n                     add_dictlist(extended_by, avro_name(ex), ex_types[ex])\n \n+    for t in n:\n+        if t.get(\"abstract\") and t[\"name\"] not in extended_by:\n+            raise validate.ValidationException(\"%s is abstract but missing a concrete subtype\" % t[\"name\"])\n+\n     for t in n:\n         if \"fields\" in t:\n             t[\"fields\"] = replace_type(t[\"fields\"], extended_by, loader, set())\n \n     return n\n \n-def make_avro_schema(j, loader):\n-    names = avro.schema.Names()\n \n-    #pprint.pprint(j)\n+def make_avro_schema(i, loader):\n+    # type: (List[Dict[unicode, Any]], ref_resolver.Loader) -> Tuple[Union[avro.schema.Names,avro.schema.SchemaParseException], List[Dict[unicode, Any]]]\n+    names = avro.schema.Names()\n \n-    j = extend_and_specialize(j, loader)\n+    j = extend_and_specialize(i, loader)\n \n-    name_dict = {}\n+    name_dict = {}  # type: Dict[unicode, Dict[unicode, Any]]\n     for t in j:\n         name_dict[t[\"name\"]] = t\n     j2 = make_valid_avro(j, name_dict, set())\n \n-    j3 = [t for t in j2 if isinstance(t, dict) and not t.get(\"abstract\") and t.get(\"type\") != \"documentation\"]\n+    j3 = [t for t in j2 if isinstance(t, dict) and not t.get(\n+        \"abstract\") and t.get(\"type\") != \"documentation\"]\n \n     try:\n         AvroSchemaFromJSONData(j3, names)\n     except avro.schema.SchemaParseException as e:\n-        names = e\n+        return (e, j3)\n \n     return (names, j3)\ndiff --git a/cwltool/schemas/draft-4/salad/schema_salad/validate.py b/cwltool/schemas/draft-4/salad/schema_salad/validate.py\n--- a/cwltool/schemas/draft-4/salad/schema_salad/validate.py\n+++ b/cwltool/schemas/draft-4/salad/schema_salad/validate.py\n@@ -1,19 +1,14 @@\n import pprint\n import avro.schema\n-import yaml\n import sys\n-try:\n-    import urlparse\n-except:\n-    import urllib.parse as urlparse\n-    basestring=str\n-if sys.version_info >= (2,7):\n-    import typing\n+import urlparse\n+from typing import Any\n \n class ValidationException(Exception):\n     pass\n \n-def validate(expected_schema, datum, identifiers=[], strict=False, foreign_properties=set()):\n+def validate(expected_schema, datum, identifiers=set(), strict=False, foreign_properties=set()):\n+    # type: (avro.schema.Schema, Any, Set[unicode], bool, Set[unicode]) -> bool\n     try:\n         return validate_ex(expected_schema, datum, identifiers, strict=strict, foreign_properties=foreign_properties)\n     except ValidationException:\n@@ -24,13 +19,13 @@ def validate(expected_schema, datum, identifiers=[], strict=False, foreign_prope\n LONG_MIN_VALUE = -(1 << 63)\n LONG_MAX_VALUE = (1 << 63) - 1\n \n-def indent(v, nolead=False):\n+def indent(v, nolead=False):  # type: (str, bool) -> str\n     if nolead:\n         return v.splitlines()[0] + \"\\n\".join([\"  \" + l for l in v.splitlines()[1:]])\n     else:\n         return \"\\n\".join([\"  \" + l for l in v.splitlines()])\n \n-def friendly(v):\n+def friendly(v):  # type: (Any) -> Any\n     if isinstance(v, avro.schema.NamedSchema):\n         return v.name\n     if isinstance(v, avro.schema.ArraySchema):\n@@ -42,21 +37,29 @@ def friendly(v):\n     else:\n         return v\n \n-def multi(v, q=\"\"):\n+def multi(v, q=\"\"):  # type: (str, str) -> str\n     if '\\n' in v:\n         return \"%s%s%s\\n\" % (q, v, q)\n     else:\n         return \"%s%s%s\" % (q, v, q)\n \n-def vpformat(datum):\n+def vpformat(datum):  # type: (Any) -> str\n     a = pprint.pformat(datum)\n     if len(a) > 160:\n         a = a[0:160] + \"[...]\"\n     return a\n \n-def validate_ex(expected_schema, datum, identifiers=set(), strict=False, foreign_properties=set()):\n+def validate_ex(expected_schema, datum, identifiers=None, strict=False,\n+        foreign_properties=None):\n+    # type: (avro.schema.Schema, Any, Set[unicode], bool, Set[unicode]) -> bool\n     \"\"\"Determine if a python datum is an instance of a schema.\"\"\"\n \n+    if not identifiers:\n+        identifiers = set()\n+\n+    if not foreign_properties:\n+        foreign_properties = set()\n+\n     schema_type = expected_schema.type\n \n     if schema_type == 'null':\n@@ -100,12 +103,12 @@ def validate_ex(expected_schema, datum, identifiers=set(), strict=False, foreign\n             return True\n         else:\n             raise ValidationException(\"the value `%s` is not float or double\" % vpformat(datum))\n-    elif schema_type == 'fixed':\n+    elif isinstance(expected_schema, avro.schema.FixedSchema):\n         if isinstance(datum, str) and len(datum) == expected_schema.size:\n             return True\n         else:\n             raise ValidationException(\"the value `%s` is not fixed\" % vpformat(datum))\n-    elif schema_type == 'enum':\n+    elif isinstance(expected_schema, avro.schema.EnumSchema):\n         if expected_schema.name == \"Any\":\n             if datum is not None:\n                 return True\n@@ -115,7 +118,7 @@ def validate_ex(expected_schema, datum, identifiers=set(), strict=False, foreign\n             return True\n         else:\n             raise ValidationException(\"the value `%s`\\n is not a valid symbol in enum %s, expected one of %s\" % (vpformat(datum), expected_schema.name, \"'\" + \"', '\".join(expected_schema.symbols) + \"'\"))\n-    elif schema_type == 'array':\n+    elif isinstance(expected_schema, avro.schema.ArraySchema):\n         if isinstance(datum, list):\n             for i, d in enumerate(datum):\n                 try:\n@@ -125,14 +128,14 @@ def validate_ex(expected_schema, datum, identifiers=set(), strict=False, foreign\n             return True\n         else:\n             raise ValidationException(\"the value `%s` is not a list, expected list of %s\" % (vpformat(datum), friendly(expected_schema.items)))\n-    elif schema_type == 'map':\n+    elif isinstance(expected_schema, avro.schema.MapSchema):\n         if (isinstance(datum, dict) and\n             False not in [isinstance(k, basestring) for k in datum.keys()] and\n             False not in [validate(expected_schema.values, v, strict=strict) for v in datum.values()]):\n             return True\n         else:\n             raise ValidationException(\"`%s` is not a valid map value, expected\\n %s\" % (vpformat(datum), vpformat(expected_schema.values)))\n-    elif schema_type in ['union', 'error_union']:\n+    elif isinstance(expected_schema, avro.schema.UnionSchema):\n         if True in [validate(s, datum, identifiers, strict=strict) for s in expected_schema.schemas]:\n             return True\n         else:\n@@ -144,7 +147,7 @@ def validate_ex(expected_schema, datum, identifiers=set(), strict=False, foreign\n                     errors.append(str(e))\n             raise ValidationException(\"the value %s is not a valid type in the union, expected one of:\\n%s\" % (multi(vpformat(datum), '`'), \"\\n\".join([\"- %s, but\\n %s\" % (friendly(expected_schema.schemas[i]), indent(multi(errors[i]))) for i in range(0, len(expected_schema.schemas))])))\n \n-    elif schema_type in ['record', 'error', 'request']:\n+    elif isinstance(expected_schema, avro.schema.RecordSchema):\n         if not isinstance(datum, dict):\n             raise ValidationException(\"`%s`\\n is not a dict\" % vpformat(datum))\n \ndiff --git a/cwltool/schemas/draft-4/salad/setup.py b/cwltool/schemas/draft-4/salad/setup.py\n--- a/cwltool/schemas/draft-4/salad/setup.py\n+++ b/cwltool/schemas/draft-4/salad/setup.py\n@@ -24,21 +24,24 @@\n     # In tox, it will cover them anyway.\n     requirements = []\n \n-install_requires=[\n-      'requests',\n-      'PyYAML',\n-      'rdflib >= 4.1.0',\n-      'rdflib-jsonld >= 0.3.0',\n-      'mistune',\n-      'typing']\n+install_requires = [\n+    'requests',\n+    'ruamel.yaml',\n+    'rdflib >= 4.1.0',\n+    'rdflib-jsonld >= 0.3.0',\n+    'mistune',\n+    'typing']\n \n-if sys.version_info.major < 3:\n-    install_requires.append(\"avro\")\n-else:\n-    install_requires.append(\"avro-python3\")\n+install_requires.append(\"avro\")  # TODO: remove me once cwltool is\n+# available in Debian Stable, Ubuntu 12.04 LTS\n+\n+# extras_require={                # TODO: uncomment me, same conditions as above\n+#        ':python_version<\"3\"': ['avro'],\n+#        ':python_version>=\"3\"': ['avro-python3']}\n+extras_require = {}               # TODO: to be removed when the above is added\n \n setup(name='schema-salad',\n-      version='1.9',\n+      version='1.12',\n       description='Schema Annotations for Linked Avro Data (SALAD)',\n       long_description=open(README).read(),\n       author='Common workflow language working group',\n@@ -49,6 +52,7 @@\n       packages=[\"schema_salad\"],\n       package_data={'schema_salad': ['metaschema/*']},\n       install_requires=install_requires,\n+      extras_require=extras_require,\n       test_suite='tests',\n       tests_require=[],\n       entry_points={\n@@ -63,7 +67,8 @@\n           \"Operating System :: MacOS :: MacOS X\",\n           \"Development Status :: 4 - Beta\",\n           \"Programming Language :: Python :: 2.7\",\n-          \"Programming Language :: Python :: 3.3\",\n-          \"Programming Language :: Python :: 3.4\",\n-          \"Programming Language :: Python :: 3.5\"]\n+          #\"Programming Language :: Python :: 3.3\",  # TODO: uncomment these\n+          #\"Programming Language :: Python :: 3.4\",  # lines\n+          #\"Programming Language :: Python :: 3.5\"\n+      ]\n       )\ndiff --git a/cwltool/schemas/draft-4/salad/typeshed/2.7/ruamel/__init__.py b/cwltool/schemas/draft-4/salad/typeshed/2.7/ruamel/__init__.py\nnew file mode 100644\ndiff --git a/cwltool/stdfsaccess.py b/cwltool/stdfsaccess.py\n--- a/cwltool/stdfsaccess.py\n+++ b/cwltool/stdfsaccess.py\n@@ -1,4 +1,4 @@\n-from typing import Any, IO\n+from typing import Any, BinaryIO\n from .pathmapper import abspath\n import glob\n import os\n@@ -6,17 +6,17 @@\n \n class StdFsAccess(object):\n \n-    def __init__(self, basedir):  # type: (str) -> None\n+    def __init__(self, basedir):  # type: (unicode) -> None\n         self.basedir = basedir\n \n-    def _abs(self, p):  # type: (str) -> str\n+    def _abs(self, p):  # type: (unicode) -> unicode\n         return abspath(p, self.basedir)\n \n-    def glob(self, pattern):  # type: (str) -> List[str]\n+    def glob(self, pattern):  # type: (unicode) -> List[unicode]\n         return glob.glob(self._abs(pattern))\n \n-    def open(self, fn, mode):  # type: (str, str) -> IO[Any]\n+    def open(self, fn, mode):  # type: (unicode, str) -> BinaryIO\n         return open(self._abs(fn), mode)\n \n-    def exists(self, fn):  # type: (str) -> bool\n+    def exists(self, fn):  # type: (unicode) -> bool\n         return os.path.exists(self._abs(fn))\ndiff --git a/cwltool/update.py b/cwltool/update.py\n--- a/cwltool/update.py\n+++ b/cwltool/update.py\n@@ -341,6 +341,25 @@ def draft3toDraft4dev1(doc, loader, baseuri):\n     \"\"\"Public updater for draft-3 to draft-4.dev1.\"\"\"\n     return (_draft3toDraft4dev1(doc, loader, baseuri), \"draft-4.dev1\")\n \n+def _draft4Dev1toDev2(doc, loader, baseuri):\n+    # type: (Any, Loader, str) -> Any\n+    if isinstance(doc, dict):\n+        if \"class\" in doc and doc[\"class\"] == \"Workflow\":\n+            for out in doc[\"outputs\"]:\n+                out[\"outputSource\"] = out[\"source\"]\n+                del out[\"source\"]\n+        for key, value in doc.items():\n+            doc[key] = _draft4Dev1toDev2(value, loader, baseuri)\n+    elif isinstance(doc, list):\n+        doc = [_draft4Dev1toDev2(item, loader, baseuri) for item in doc]\n+\n+    return doc\n+\n+def draft4Dev1toDev2(doc, loader, baseuri):\n+    # type: (Any, Loader, str) -> Tuple[Any, str]\n+    \"\"\"Public updater for draft-4.dev1 to draft-4.dev2.\"\"\"\n+    return (_draft4Dev1toDev2(doc, loader, baseuri), \"draft-4.dev2\")\n+\n UPDATES = {\n     \"draft-2\": draft2toDraft3dev1,\n     \"draft-3\": draft3toDraft4dev1\n@@ -352,13 +371,14 @@ def draft3toDraft4dev1(doc, loader, baseuri):\n     \"draft-3.dev3\": draftDraft3dev3toDev4,\n     \"draft-3.dev4\": draftDraft3dev4toDev5,\n     \"draft-3.dev5\": draftDraft3dev5toFinal,\n-    \"draft-4.dev1\": None\n+    \"draft-4.dev1\": draft4Dev1toDev2,\n+    \"draft-4.dev2\": None\n } # type: Dict[unicode, Callable[[Any, Loader, str], Tuple[Any, str]]]\n \n ALLUPDATES = UPDATES.copy()\n ALLUPDATES.update(DEVUPDATES)\n \n-LATEST = \"draft-4.dev1\"\n+LATEST = \"draft-4.dev2\"\n \n def identity(doc, loader, baseuri):  # pylint: disable=unused-argument\n     # type: (Any, Loader, str) -> Tuple[Any, Union[str, unicode]]\n@@ -366,19 +386,19 @@ def identity(doc, loader, baseuri):  # pylint: disable=unused-argument\n     return (doc, doc[\"cwlVersion\"])\n \n def checkversion(doc, metadata, enable_dev):\n-    # type: (Union[List, Dict[str, Any]], Dict[str, Any], bool) -> Tuple[Dict[str, Any], Union[str, unicode]]  # pylint: disable=line-too-long\n+    # type: (Union[List[Dict[unicode, Any]], Dict[unicode, Any]], Dict[unicode, Any], bool) -> Tuple[Dict[unicode, Any], unicode]  # pylint: disable=line-too-long\n     \"\"\"Checks the validity of the version of the give CWL document.\n \n     Returns the document and the validated version string.\n     \"\"\"\n     if isinstance(doc, list):\n         metadata = metadata.copy()\n-        metadata[\"$graph\"] = doc\n+        metadata[u\"$graph\"] = doc\n         cdoc = metadata\n     else:\n         cdoc = doc\n \n-    version = cdoc[\"cwlVersion\"]\n+    version = cdoc[u\"cwlVersion\"]\n \n     if version not in UPDATES:\n         if version in DEVUPDATES:\n@@ -398,16 +418,16 @@ def checkversion(doc, metadata, enable_dev):\n     return (cdoc, version)\n \n def update(doc, loader, baseuri, enable_dev, metadata):\n-    # type: (Any, Loader, str, bool, Any) -> Any\n+    # type: (Union[List[Dict[unicode, Any]], Dict[unicode, Any]], Loader, str, bool, Any) -> Dict[unicode, Any]\n \n-    (doc, version) = checkversion(doc, metadata, enable_dev)\n+    (cdoc, version) = checkversion(doc, metadata, enable_dev)\n \n-    nextupdate = identity\n+    nextupdate = identity  # type: Callable[[Any, Loader, str], Tuple[Any, str]]\n \n     while nextupdate:\n-        (doc, version) = nextupdate(doc, loader, baseuri)\n+        (cdoc, version) = nextupdate(cdoc, loader, baseuri)\n         nextupdate = ALLUPDATES[version]\n \n-    doc[\"cwlVersion\"] = version\n+    cdoc[u\"cwlVersion\"] = version\n \n-    return doc\n+    return cdoc\ndiff --git a/cwltool/workflow.py b/cwltool/workflow.py\n--- a/cwltool/workflow.py\n+++ b/cwltool/workflow.py\n@@ -54,7 +54,7 @@ def findfiles(wo, fn=None):  # type: (Any, List) -> List[Dict[str, Any]]\n \n \n def match_types(sinktype, src, iid, inputobj, linkMerge, valueFrom):\n-    # type: (Union[List[str],str], WorkflowStateItem, str, Dict[str, Any], str, str) -> bool\n+    # type: (Union[List[str],str], WorkflowStateItem, str, Dict[unicode, Any], str, str) -> bool\n     if isinstance(sinktype, list):\n         # Sink is union type\n         for st in sinktype:\n@@ -104,25 +104,37 @@ def are_same_type(src, sink):  # type: (Any, Any) -> bool\n         return src == sink\n \n \n-def object_from_state(state, parms, frag_only, supportsMultipleInput):\n-    # type: (Dict[str,WorkflowStateItem], List[Dict[str, Any]], bool, bool) -> Dict[str, str]\n-    inputobj = {}  # type: Dict[str, str]\n+def object_from_state(state, parms, frag_only, supportsMultipleInput, sourceField):\n+    # type: (Dict[unicode, WorkflowStateItem], List[Dict[unicode, Any]], bool, bool, unicode) -> Dict[unicode, Any]\n+    inputobj = {}  # type: Dict[unicode, Any]\n     for inp in parms:\n         iid = inp[\"id\"]\n         if frag_only:\n             iid = shortname(iid)\n-        if \"source\" in inp:\n-            if isinstance(inp[\"source\"], list) and not supportsMultipleInput:\n-                raise WorkflowException(\"Workflow contains multiple inbound links to a single parameter but MultipleInputFeatureRequirement is not declared.\")\n-            connections = aslist(inp[\"source\"])\n+        if sourceField in inp:\n+            if (isinstance(inp[sourceField], list) and not\n+                    supportsMultipleInput):\n+                raise WorkflowException(\n+                        \"Workflow contains multiple inbound links to a single \"\n+                        \"parameter but MultipleInputFeatureRequirement is not \"\n+                        \"declared.\")\n+            connections = aslist(inp[sourceField])\n             for src in connections:\n                 if src in state and state[src] is not None:\n-                    if not match_types(inp[\"type\"], state[src], iid, inputobj,\n-                                            inp.get(\"linkMerge\", (\"merge_nested\" if len(connections) > 1 else None)),\n-                                       valueFrom=inp.get(\"valueFrom\")):\n-                        raise WorkflowException(u\"Type mismatch between source '%s' (%s) and sink '%s' (%s)\" % (src, state[src].parameter[\"type\"], inp[\"id\"], inp[\"type\"]))\n+                    if not match_types(\n+                            inp[\"type\"], state[src], iid, inputobj,\n+                            inp.get(\"linkMerge\", (\"merge_nested\"\n+                                if len(connections) > 1 else None)),\n+                            valueFrom=inp.get(\"valueFrom\")):\n+                        raise WorkflowException(\n+                                u\"Type mismatch between source '%s' (%s) and \"\n+                                \"sink '%s' (%s)\" % (src,\n+                                    state[src].parameter[\"type\"], inp[\"id\"],\n+                                    inp[\"type\"]))\n                 elif src not in state:\n-                    raise WorkflowException(u\"Connect source '%s' on parameter '%s' does not exist\" % (src, inp[\"id\"]))\n+                    raise WorkflowException(\n+                            u\"Connect source '%s' on parameter '%s' does not \"\n+                            \"exist\" % (src, inp[\"id\"]))\n                 else:\n                     return None\n         elif \"default\" in inp:\n@@ -146,7 +158,7 @@ def __init__(self, step):  # type: (Any) -> None\n         self.name = uniquename(u\"step %s\" % shortname(self.id))\n \n     def job(self, joborder, output_callback, **kwargs):\n-        # type: (Dict[str,str], str, functools.partial[None], **Any) -> Generator\n+        # type: (Dict[unicode, unicode], functools.partial[None], **Any) -> Generator\n         kwargs[\"part_of\"] = self.name\n         kwargs[\"name\"] = shortname(self.id)\n         for j in self.step.job(joborder, output_callback, **kwargs):\n@@ -161,7 +173,7 @@ def __init__(self, workflow, **kwargs):\n         self.tool = workflow.tool\n         self.steps = [WorkflowJobStep(s) for s in workflow.steps]\n         self.id = workflow.tool[\"id\"]\n-        self.state = None  # type: Dict[str, WorkflowStateItem]\n+        self.state = None  # type: Dict[unicode, WorkflowStateItem]\n         self.processStatus = None  # type: str\n         if \"outdir\" in kwargs:\n             self.outdir = kwargs[\"outdir\"]\n@@ -198,14 +210,17 @@ def receive_output(self, step, outputparms, jobout, processStatus):\n         step.completed = True\n \n     def try_make_job(self, step, **kwargs):\n-        # type: (WorkflowJobStep, str, **Any) -> Generator\n+        # type: (WorkflowJobStep, **Any) -> Generator\n         inputparms = step.tool[\"inputs\"]\n         outputparms = step.tool[\"outputs\"]\n \n-        supportsMultipleInput = bool(self.workflow.get_requirement(\"MultipleInputFeatureRequirement\")[0])\n+        supportsMultipleInput = bool(self.workflow.get_requirement(\n+            \"MultipleInputFeatureRequirement\")[0])\n \n         try:\n-            inputobj = object_from_state(self.state, inputparms, False, supportsMultipleInput)\n+            inputobj = object_from_state(\n+                    self.state, inputparms, False, supportsMultipleInput,\n+                    \"source\")\n             if inputobj is None:\n                 _logger.debug(u\"[%s] job step %s not ready\", self.name, step.id)\n                 return\n@@ -217,7 +232,9 @@ def try_make_job(self, step, **kwargs):\n \n             callback = functools.partial(self.receive_output, step, outputparms)\n \n-            valueFrom = {i[\"id\"]: i[\"valueFrom\"] for i in step.tool[\"inputs\"] if \"valueFrom\" in i}\n+            valueFrom = {\n+                    i[\"id\"]: i[\"valueFrom\"] for i in step.tool[\"inputs\"]\n+                    if \"valueFrom\" in i}\n \n             if len(valueFrom) > 0 and not bool(self.workflow.get_requirement(\"StepInputExpressionRequirement\")[0]):\n                 raise WorkflowException(\"Workflow step contains valueFrom but StepInputExpressionRequirement not in requirements\")\n@@ -225,8 +242,9 @@ def try_make_job(self, step, **kwargs):\n             vfinputs = {shortname(k): v for k,v in inputobj.iteritems()}\n             def valueFromFunc(k, v):  # type: (Any, Any) -> Any\n                 if k in valueFrom:\n-                    return expression.do_eval(valueFrom[k], vfinputs, self.workflow.requirements,\n-                                       None, None, {}, context=v)\n+                    return expression.do_eval(\n+                            valueFrom[k], vfinputs, self.workflow.requirements,\n+                            None, None, {}, context=v)\n                 else:\n                     return v\n \n@@ -279,7 +297,7 @@ def run(self, **kwargs):\n         _logger.debug(u\"[%s] workflow starting\", self.name)\n \n     def job(self, joborder, output_callback, move_outputs=True, **kwargs):\n-        # type: (Dict[str,str], str, Callable[[Any, Any], Any], bool, **Any) -> Generator[WorkflowJob, None, None]\n+        # type: (Dict[unicode, Any], Callable[[Any, Any], Any], bool, **Any) -> Generator[WorkflowJob, None, None]\n         self.state = {}\n         self.processStatus = \"success\"\n \n@@ -326,7 +344,7 @@ def job(self, joborder, output_callback, move_outputs=True, **kwargs):\n \n         supportsMultipleInput = bool(self.workflow.get_requirement(\"MultipleInputFeatureRequirement\")[0])\n \n-        wo = object_from_state(self.state, self.tool[\"outputs\"], True, supportsMultipleInput)\n+        wo = object_from_state(self.state, self.tool[\"outputs\"], True, supportsMultipleInput, \"outputSource\")\n \n         if wo is None:\n             raise WorkflowException(\"Output for workflow not available\")\n@@ -375,7 +393,7 @@ def job(self, joborder, output_callback, move_outputs=True, **kwargs):\n \n class Workflow(Process):\n     def __init__(self, toolpath_object, **kwargs):\n-        # type: (Dict[str, Any], **Any) -> None\n+        # type: (Dict[unicode, Any], **Any) -> None\n         super(Workflow, self).__init__(toolpath_object, **kwargs)\n \n         kwargs[\"requirements\"] = self.requirements\n@@ -388,7 +406,7 @@ def __init__(self, toolpath_object, **kwargs):\n         # TODO: statically validate data links instead of doing it at runtime.\n \n     def job(self, joborder, output_callback, **kwargs):\n-        # type: (Dict[str,str], str, Callable[[Any, Any], Any], **Any) -> Generator[WorkflowJob, None, None]\n+        # type: (Dict[unicode, unicode], Callable[[Any, Any], Any], **Any) -> Generator[WorkflowJob, None, None]\n         builder = self._init_job(joborder, **kwargs)\n         wj = WorkflowJob(self, **kwargs)\n         yield wj\n@@ -407,7 +425,7 @@ def visit(self, op):\n class WorkflowStep(Process):\n \n     def __init__(self, toolpath_object, pos, **kwargs):\n-        # type: (Dict[str, Any], int, **Any) -> None\n+        # type: (Dict[unicode, Any], int, **Any) -> None\n         if \"id\" in toolpath_object:\n             self.id = toolpath_object[\"id\"]\n         else:\n@@ -486,7 +504,7 @@ def __init__(self, toolpath_object, pos, **kwargs):\n             self.tool[\"outputs\"] = outputparms\n \n     def receive_output(self, output_callback, jobout, processStatus):\n-        # type: (Callable[...,Any], Dict[str, str], str) -> None\n+        # type: (Callable[...,Any], Dict[unicode, str], str) -> None\n         #_logger.debug(\"WorkflowStep output from run is %s\", jobout)\n         output = {}\n         for i in self.tool[\"outputs\"]:\n@@ -498,7 +516,7 @@ def receive_output(self, output_callback, jobout, processStatus):\n         output_callback(output, processStatus)\n \n     def job(self, joborder, output_callback, **kwargs):\n-        # type: (Dict[str, Any], str, Callable[...,Any], **Any) -> Generator\n+        # type: (Dict[unicode, Any], Callable[...,Any], **Any) -> Generator\n         for i in self.tool[\"inputs\"]:\n             p = i[\"id\"]\n             field = shortname(p)\n@@ -555,7 +573,7 @@ def setTotal(self, total):  # type: (int) -> None\n \n \n def dotproduct_scatter(process, joborder, scatter_keys, output_callback, **kwargs):\n-    # type: (WorkflowJobStep, Dict[str, Any], str, List[str], Callable[..., Any], **Any) -> Generator[WorkflowJob, None, None]\n+    # type: (WorkflowJobStep, Dict[unicode, Any], List[str], Callable[..., Any], **Any) -> Generator[WorkflowJob, None, None]\n     l = None\n     for s in scatter_keys:\n         if l is None:\n@@ -581,7 +599,7 @@ def dotproduct_scatter(process, joborder, scatter_keys, output_callback, **kwarg\n \n \n def nested_crossproduct_scatter(process, joborder, scatter_keys, output_callback, **kwargs):\n-    # type: (WorkflowJobStep, Dict[str, Any], str, List[str], Callable[..., Any], **Any) -> Generator[WorkflowJob, None, None]\n+    # type: (WorkflowJobStep, Dict[unicode, Any], List[str], Callable[..., Any], **Any) -> Generator[WorkflowJob, None, None]\n     scatter_key = scatter_keys[0]\n     l = len(joborder[scatter_key])\n     output = {}  # type: Dict[str,List[str]]\n@@ -610,7 +628,7 @@ def nested_crossproduct_scatter(process, joborder, scatter_keys, output_callback\n \n \n def crossproduct_size(joborder, scatter_keys):\n-    # type: (Dict[str, Any], List[str]) -> int\n+    # type: (Dict[unicode, Any], List[str]) -> int\n     scatter_key = scatter_keys[0]\n     if len(scatter_keys) == 1:\n         sum = len(joborder[scatter_key])\n@@ -623,7 +641,7 @@ def crossproduct_size(joborder, scatter_keys):\n     return sum\n \n def flat_crossproduct_scatter(process, joborder, scatter_keys, output_callback, startindex, **kwargs):\n-    # type: (WorkflowJobStep, Dict[str, Any], str, List[str], Union[ReceiveScatterOutput,Callable[..., Any]], int, **Any) -> Generator[WorkflowJob, None, None]\n+    # type: (WorkflowJobStep, Dict[unicode, Any], List[str], Union[ReceiveScatterOutput,Callable[..., Any]], int, **Any) -> Generator[WorkflowJob, None, None]\n     scatter_key = scatter_keys[0]\n     l = len(joborder[scatter_key])\n     rc = None  # type: ReceiveScatterOutput\ndiff --git a/setup.py b/setup.py\n--- a/setup.py\n+++ b/setup.py\n@@ -41,7 +41,7 @@\n           'rdflib >= 4.1.0',\n           'rdflib-jsonld >= 0.3.0',\n           'shellescape',\n-          'schema-salad==1.11.20160524152859',\n+          'schema-salad==1.12.20160610104117',\n           'typing'\n         ],\n       test_suite='tests',\n", "test_patch": "diff --git a/cwltool/schemas/draft-4/salad/tests/Process.yml b/cwltool/schemas/draft-4/salad/tests/Process.yml\nnew file mode 100644\n--- /dev/null\n+++ b/cwltool/schemas/draft-4/salad/tests/Process.yml\n@@ -0,0 +1,36 @@\n+$base: \"https://w3id.org/cwl/cwl#\"\n+\n+$namespaces:\n+  cwl: \"https://w3id.org/cwl/cwl#\"\n+  sld: \"https://w3id.org/cwl/salad#\"\n+\n+$graph:\n+\n+- $import: \"../schema_salad/metaschema/metaschema_base.yml\"\n+\n+- name: InputBinding\n+  type: record\n+  abstract: true\n+  fields:\n+    - name: loadContents\n+      type:\n+        - \"null\"\n+        - boolean\n+      jsonldPredicate: \"cwl:loadContents\"\n+      doc: |\n+        Only valid when `type: File` or is an array of `items: File`.\n+\n+        Read up to the first 64 KiB of text from the file and place it in the\n+        \"contents\" field of the file object for use by expressions.\n+\n+- name: InputRecordField\n+  type: record\n+  extends: \"sld:RecordField\"\n+  fields:\n+    - name: inputBinding\n+      type: [ \"null\", \"#InputBinding\" ]\n+      jsonldPredicate: \"cwl:inputBinding\"\n+\n+- name: Blurb\n+  type: record\n+  extends: InputBinding\n\\ No newline at end of file\ndiff --git a/cwltool/schemas/draft-4/salad/tests/test_examples.py b/cwltool/schemas/draft-4/salad/tests/test_examples.py\n--- a/cwltool/schemas/draft-4/salad/tests/test_examples.py\n+++ b/cwltool/schemas/draft-4/salad/tests/test_examples.py\n@@ -3,25 +3,28 @@\n import schema_salad.main\n import schema_salad.schema\n import rdflib\n-import yaml\n+import ruamel.yaml as yaml\n+try:\n+    from ruamel.yaml import CSafeLoader as SafeLoader\n+except ImportError:\n+    from ruamel.yaml import SafeLoader\n+\n \n class TestSchemas(unittest.TestCase):\n     def test_schemas(self):\n         l = schema_salad.ref_resolver.Loader({})\n \n         ra, _ = l.resolve_all({\n-            \"$schemas\": [\"tests/EDAM.owl\"],\n-            \"$namespaces\": {\"edam\": \"http://edamontology.org/\"},\n-            \"edam:has_format\": \"edam:format_1915\"\n-            }, \"\")\n-\n-        self.assertEqual(ra, {\n-            \"$schemas\": [\"tests/EDAM.owl\"],\n-            \"$namespaces\": {\"edam\": \"http://edamontology.org/\"},\n-            'http://edamontology.org/has_format': 'http://edamontology.org/format_1915'\n-        })\n-\n+            u\"$schemas\": [u\"tests/EDAM.owl\"],\n+            u\"$namespaces\": {u\"edam\": u\"http://edamontology.org/\"},\n+            u\"edam:has_format\": u\"edam:format_1915\"\n+        }, \"\")\n \n+        self.assertEqual({\n+            u\"$schemas\": [u\"tests/EDAM.owl\"],\n+            u\"$namespaces\": {u\"edam\": u\"http://edamontology.org/\"},\n+            u'http://edamontology.org/has_format': u'http://edamontology.org/format_1915'\n+        }, ra)\n \n     # def test_domain(self):\n     #     l = schema_salad.ref_resolver.Loader({})\n@@ -43,12 +46,15 @@ def test_schemas(self):\n     #     })\n \n     def test_self_validate(self):\n-        schema_salad.main.main(args=[\"schema_salad/metaschema/metaschema.yml\"])\n-        schema_salad.main.main(args=[\"schema_salad/metaschema/metaschema.yml\",\n-                                     \"schema_salad/metaschema/metaschema.yml\"])\n+        self.assertEqual(0, schema_salad.main.main(argsl=[\"schema_salad/metaschema/metaschema.yml\"]))\n+        self.assertEqual(0, schema_salad.main.main(argsl=[\"schema_salad/metaschema/metaschema.yml\",\n+                                     \"schema_salad/metaschema/metaschema.yml\"]))\n+\n+    def test_avro_regression(self):\n+        self.assertEqual(0, schema_salad.main.main(argsl=[\"tests/Process.yml\"]))\n \n     def test_jsonld_ctx(self):\n-        ldr, _, _ = schema_salad.schema.load_schema({\n+        ldr, _, _, _ = schema_salad.schema.load_schema({\n             \"$base\": \"Y\",\n             \"name\": \"X\",\n             \"$namespaces\": {\n@@ -80,7 +86,7 @@ def test_idmap(self):\n                 \"@type\": \"@id\",\n                 \"identity\": True,\n             },\n-                         \"id\": \"@id\"})\n+            \"id\": \"@id\"})\n \n         ra, _ = ldr.resolve_all({\n             \"id\": \"stuff\",\n@@ -94,28 +100,154 @@ def test_idmap(self):\n             }\n         }, \"http://example2.com/\")\n \n-        self.assertEqual(ra,\n-                         {\n-                             \"id\": \"http://example2.com/#stuff\",\n-                             'inputs': [{'a': 2, 'id': 'http://example2.com/#stuff/zing'},\n-                                        {'a': 1, 'id': 'http://example2.com/#stuff/zip'}],\n-                             'outputs': ['http://example2.com/#stuff/out'],\n-                             'other': {\n-                                 'n': 9\n-                             }\n-                         }\n-                     )\n+        self.assertEqual(\"http://example2.com/#stuff\", ra[\"id\"])\n+        for item in ra[\"inputs\"]:\n+            if item[\"a\"] == 2:\n+                self.assertEquals('http://example2.com/#stuff/zing', item[\"id\"])\n+            else:\n+                self.assertEquals('http://example2.com/#stuff/zip', item[\"id\"])\n+        self.assertEquals(['http://example2.com/#stuff/out'], ra['outputs'])\n+        self.assertEquals({'n': 9}, ra['other'])\n+\n+    def test_scoped_ref(self):\n+        ldr = schema_salad.ref_resolver.Loader({})\n+        ldr.add_context({\n+            \"scatter\": {\n+                \"@type\": \"@id\",\n+                \"refScope\": 0,\n+            },\n+            \"source\": {\n+                \"@type\": \"@id\",\n+                \"refScope\": 2,\n+            },\n+            \"in\": {\n+                \"mapSubject\": \"id\",\n+                \"mapPredicate\": \"source\"\n+            },\n+            \"out\": {\n+                \"@type\": \"@id\",\n+                \"identity\": True\n+            },\n+            \"inputs\": {\n+                \"mapSubject\": \"id\",\n+                \"mapPredicate\": \"type\"\n+            },\n+            \"outputs\": {\n+                \"mapSubject\": \"id\",\n+            },\n+            \"steps\": {\n+                \"mapSubject\": \"id\"\n+            },\n+            \"id\": \"@id\"})\n+\n+        ra, _ = ldr.resolve_all({\n+            \"inputs\": {\n+                \"inp\": \"string\",\n+                \"inp2\": \"string\"\n+            },\n+            \"outputs\": {\n+                \"out\": {\n+                    \"type\": \"string\",\n+                    \"source\": \"step2/out\"\n+                }\n+            },\n+            \"steps\": {\n+                \"step1\": {\n+                    \"in\": {\n+                        \"inp\": \"inp\",\n+                        \"inp2\": \"#inp2\",\n+                        \"inp3\": [\"inp\", \"inp2\"]\n+                    },\n+                    \"out\": [\"out\"],\n+                    \"scatter\": \"inp\"\n+                },\n+                \"step2\": {\n+                    \"in\": {\n+                        \"inp\": \"step1/out\"\n+                    },\n+                    \"scatter\": \"inp\",\n+                    \"out\": [\"out\"]\n+                }\n+            }\n+        }, \"http://example2.com/\")\n+\n+        self.assertEquals(\n+            {'inputs': [{\n+                'id': 'http://example2.com/#inp',\n+                'type': 'string'\n+            }, {\n+                'id': 'http://example2.com/#inp2',\n+                'type': 'string'\n+            }],\n+             'outputs': [{\n+                'id': 'http://example2.com/#out',\n+                 'type': 'string',\n+                 'source': 'http://example2.com/#step2/out'\n+             }],\n+            'steps': [{\n+                    'id': 'http://example2.com/#step1',\n+                    'scatter': 'http://example2.com/#step1/inp',\n+                    'in': [{\n+                            'id': 'http://example2.com/#step1/inp',\n+                            'source': 'http://example2.com/#inp'\n+                    }, {\n+                            'id': 'http://example2.com/#step1/inp2',\n+                            'source': 'http://example2.com/#inp2'\n+                    }, {\n+                            'id': 'http://example2.com/#step1/inp3',\n+                            'source': ['http://example2.com/#inp', 'http://example2.com/#inp2']\n+                    }],\n+                    \"out\": [\"http://example2.com/#step1/out\"],\n+            }, {\n+                    'id': 'http://example2.com/#step2',\n+                    'scatter': 'http://example2.com/#step2/inp',\n+                    'in': [{\n+                            'id': 'http://example2.com/#step2/inp',\n+                            'source': 'http://example2.com/#step1/out'\n+                    }],\n+                    \"out\": [\"http://example2.com/#step2/out\"],\n+                }]\n+        }, ra)\n+\n \n     def test_examples(self):\n         self.maxDiff = None\n         for a in [\"field_name\", \"ident_res\", \"link_res\", \"vocab_res\"]:\n-            ldr, _, _ = schema_salad.schema.load_schema(\"schema_salad/metaschema/%s_schema.yml\" % a)\n+            ldr, _, _, _ = schema_salad.schema.load_schema(\n+                \"schema_salad/metaschema/%s_schema.yml\" % a)\n             with open(\"schema_salad/metaschema/%s_src.yml\" % a) as src_fp:\n-                src = ldr.resolve_all(yaml.load(src_fp), \"\")[0]\n+                src = ldr.resolve_all(\n+                    yaml.load(src_fp, Loader=SafeLoader), \"\", checklinks=False)[0]\n             with open(\"schema_salad/metaschema/%s_proc.yml\" % a) as src_proc:\n-                proc = yaml.load(src_proc)\n+                proc = yaml.load(src_proc, Loader=SafeLoader)\n             self.assertEqual(proc, src)\n \n+    def test_yaml_float_test(self):\n+        self.assertEqual(yaml.load(\"float-test: 2e-10\")[\"float-test\"], 2e-10)\n+\n+    def test_typedsl_ref(self):\n+        ldr = schema_salad.ref_resolver.Loader({})\n+        ldr.add_context({\n+            \"File\": \"http://example.com/File\",\n+            \"null\": \"http://example.com/null\",\n+            \"array\": \"http://example.com/array\",\n+            \"type\": {\n+                \"@type\": \"@vocab\",\n+                \"typeDSL\": True\n+            }\n+        })\n+\n+        ra, _ = ldr.resolve_all({\"type\": \"File\"}, \"\")\n+        self.assertEqual({'type': 'File'}, ra)\n+\n+        ra, _ = ldr.resolve_all({\"type\": \"File?\"}, \"\")\n+        self.assertEqual({'type': ['null', 'File']}, ra)\n+\n+        ra, _ = ldr.resolve_all({\"type\": \"File[]\"}, \"\")\n+        self.assertEqual({'type': {'items': 'File', 'type': 'array'}}, ra)\n+\n+        ra, _ = ldr.resolve_all({\"type\": \"File[]?\"}, \"\")\n+        self.assertEqual({'type': ['null', {'items': 'File', 'type': 'array'}]}, ra)\n \n if __name__ == '__main__':\n     unittest.main()\n", "problem_statement": "", "hints_text": "", "created_at": "2016-06-08T13:17:05Z"}