feat: Add pyhf.workspace.build

src/pyhf/exceptions/__init__.py

@@ -22,9 +22,10 @@ class InvalidSpecification(Exception):
     InvalidSpecification is raised when a specification does not validate against the given schema.
     """
 
-    def __init__(self, ValidationError):
+    def __init__(self, ValidationError, schema=None):
         self.exc_info = sys.exc_info()
         self.parent = ValidationError
+        self.schema = schema
         self.path = ''
         for item in ValidationError.path:
             if isinstance(item, int):
@@ -33,8 +34,8 @@ def __init__(self, ValidationError):
                 self.path += '.{}'.format(item)
         self.path = self.path.lstrip('.')
         self.instance = ValidationError.instance
-        message = '{0}.\n\tPath: {1}\n\tInstance: {2}'.format(
-            ValidationError.message, self.path, self.instance
+        message = '{0}.\n\tPath: {1}\n\tInstance: {2} Schema: {3}'.format(
+            ValidationError.message, self.path, self.instance, self.schema
         )
         # Call the base class constructor with the parameters it needs
         super().__init__(message)

src/pyhf/mixins.py

@@ -42,3 +42,10 @@ def __init__(self, *args, **kwargs):
         self.samples = sorted(list(set(self.samples)))
         self.parameters = sorted(list(set(self.parameters)))
         self.modifiers = sorted(list(set(self.modifiers)))
+
+        self.channel_slices = {}
+        begin = 0
+        for c in self.channels:
+            end = begin + self.channel_nbins[c]
+            self.channel_slices[c] = slice(begin, end)
+            begin = end

src/pyhf/utils.py

@@ -50,7 +50,7 @@ def validate(spec, schema_name, version=None):
         )
         return validator.validate(spec)
     except jsonschema.ValidationError as err:
-        raise InvalidSpecification(err)
+        raise InvalidSpecification(err, schema_name)
 
 
 def options_from_eqdelimstring(opts):

src/pyhf/workspace.py

@@ -743,3 +743,42 @@ def sorted(cls, workspace):
         newspec['observations'].sort(key=lambda e: e['name'])
 
         return cls(newspec)
+
+    @classmethod
+    def build(cls, model, data, name='measurement'):
+        """
+        Build a workspace from model and data.
+
+        Args:
+            model (~pyhf.pdf.Model): A model to store into a workspace
+            data (tensor): A array holding observations to store into a workspace
+            name (str): The name of the workspace measurement
+
+        Returns:
+            ~pyhf.workspace.Workspace: A new workspace object
+
+        """
+        workspace = copy.deepcopy(dict(channels=model.spec['channels']))
+        workspace['version'] = '1.0.0'
+        workspace['measurements'] = [
+            {
+                'name': name,
+                'config': {
+                    'poi': model.config.poi_name,
+                    'parameters': [
+                        {
+                            "bounds": [list(x) for x in v['paramset'].suggested_bounds],
+                            "inits": v['paramset'].suggested_init,
+                            "fixed": v['paramset'].fixed,
+                            "name": k,
+                        }
+                        for k, v in model.config.par_map.items()
+                    ],
+                },
+            }
+        ]
+        workspace['observations'] = [
+            {'name': k, 'data': list(data[model.config.channel_slices[k]])}
+            for k in model.config.channels
+        ]
+        return cls(workspace)

tests/test_workspace.py

@@ -4,6 +4,8 @@
 import pyhf.exceptions
 import json
 import logging
+import pyhf.workspace
+import pyhf.utils
 
 
 @pytest.fixture(
@@ -721,3 +723,27 @@ def test_sorted(workspace_factory):
     for channel in new_ws['channels']:
         # check sort
         assert channel['samples'][-1]['name'] == 'zzzzlast'
+
+
+def test_closure_over_workspace_build():
+    model = pyhf.simplemodels.hepdata_like(
+        signal_data=[12.0, 11.0], bkg_data=[50.0, 52.0], bkg_uncerts=[3.0, 7.0]
+    )
+    data = [51, 48]
+    one = pyhf.infer.hypotest(1.0, data + model.config.auxdata, model)
+
+    workspace = pyhf.Workspace.build(model, data)
+
+    assert json.dumps(workspace)
+
+    newmodel = workspace.model()
+    newdata = workspace.data(newmodel)
+    two = pyhf.infer.hypotest(1.0, newdata, newmodel)
+
+    assert one == two
+
+    newworkspace = pyhf.Workspace.build(newmodel, newdata)
+
+
+
+    assert pyhf.utils.digest(newworkspace) == pyhf.utils.digest(workspace)