Refactoring Branch

.github/workflows/test.yml

@@ -14,7 +14,7 @@ jobs:
     strategy:
       matrix:
         os: [macos-latest, ubuntu-latest, windows-latest]
-        python-version: ['3.10', '3.11', '3.12']
+        python-version: ['3.12']
       fail-fast: false
 
     steps:

sasdata/checklist.txt

@@ -0,0 +1,3 @@
+Things to check once everything is in place:
+
+1) Do any centigrade fields read in incorrectly?

sasdata/data.py

@@ -0,0 +1,42 @@
+from enum import Enum
+from typing import TypeVar, Any, Self
+from dataclasses import dataclass
+
+from quantities.quantity import NamedQuantity
+from sasdata.metadata import Metadata
+from sasdata.quantities.accessors import AccessorTarget
+from sasdata.data_backing import Group, key_tree
+
+
+class SasData:
+    def __init__(self, name: str, data_contents: list[NamedQuantity], raw_metadata: Group, verbose: bool=False):
+        self.name = name
+        self._data_contents = data_contents
+        self._raw_metadata = raw_metadata
+        self._verbose = verbose
+
+        self.metadata = Metadata(AccessorTarget(raw_metadata, verbose=verbose))
+
+        # TO IMPLEMENT
+
+        # abscissae: list[NamedQuantity[np.ndarray]]
+        # ordinate: NamedQuantity[np.ndarray]
+        # other: list[NamedQuantity[np.ndarray]]
+        #
+        # metadata: Metadata
+        # model_requirements: ModellingRequirements
+
+    def summary(self, indent = "  ", include_raw=False):
+        s = f"{self.name}\n"
+
+        for data in self._data_contents:
+            s += f"{indent}{data}\n"
+
+        s += f"Metadata:\n"
+        s += "\n"
+        s += self.metadata.summary()
+
+        if include_raw:
+            s += key_tree(self._raw_metadata)
+
+        return s

sasdata/data_backing.py

@@ -0,0 +1,126 @@
+from typing import TypeVar, Self
+from dataclasses import dataclass
+from enum import Enum
+
+from sasdata.quantities.quantity import NamedQuantity
+
+DataType = TypeVar("DataType")
+
+""" Sasdata metadata tree """
+
+def shorten_string(string):
+    lines = string.split("\n")
+    if len(lines) <= 1:
+        return string
+    else:
+        return lines[0][:30] + " ... " + lines[-1][-30:]
+
+@dataclass
+class Dataset[DataType]:
+    name: str
+    data: DataType
+    attributes: dict[str, Self | str]
+
+    def summary(self, indent_amount: int = 0, indent: str = "  ") -> str:
+
+        s = f"{indent*indent_amount}{self.name.split("/")[-1]}:\n"
+        s += f"{indent*(indent_amount+1)}{shorten_string(str(self.data))}\n"
+        for key in self.attributes:
+            value = self.attributes[key]
+            if isinstance(value, (Group, Dataset)):
+                value_string = value.summary(indent_amount+1, indent)
+            else:
+                value_string = f"{indent * (indent_amount+1)}{key}: {shorten_string(repr(value))}\n"
+
+            s += value_string
+
+        return s
+
+@dataclass
+class Group:
+    name: str
+    children: dict[str, Self | Dataset]
+
+    def summary(self, indent_amount: int=0, indent="  "):
+        s = f"{indent*indent_amount}{self.name.split("/")[-1]}:\n"
+        for key in self.children:
+            s += self.children[key].summary(indent_amount+1, indent)
+
+        return s
+
+class Function:
+    """ Representation of a (data driven) function, such as I vs Q """
+
+    def __init__(self, abscissae: list[NamedQuantity], ordinate: NamedQuantity):
+        self.abscissae = abscissae
+        self.ordinate = ordinate
+
+
+class FunctionType(Enum):
+    """ What kind of function is this, should not be relied upon to be perfectly descriptive
+
+    The functions might be parametrised by more variables than the specification
+    """
+    UNKNOWN = 0
+    SCATTERING_INTENSITY_VS_Q = 1
+    SCATTERING_INTENSITY_VS_Q_2D = 2
+    SCATTERING_INTENSITY_VS_Q_3D = 3
+    SCATTERING_INTENSITY_VS_ANGLE = 4
+    UNKNOWN_METADATA = 20
+    TRANSMISSION = 21
+    POLARISATION_EFFICIENCY = 22
+    UNKNOWN_REALSPACE = 30
+    SESANS = 31
+    CORRELATION_FUNCTION_1D = 32
+    CORRELATION_FUNCTION_2D = 33
+    CORRELATION_FUNCTION_3D = 34
+    INTERFACE_DISTRIBUTION_FUNCTION = 35
+    PROBABILITY_DISTRIBUTION = 40
+    PROBABILITY_DENSITY = 41
+
+def function_type_identification_key(names):
+    """ Create a key from the names of data objects that can be used to assign a function type"""
+    return ":".join([s.lower() for s in sorted(names)])
+
+function_fields_to_type = [
+    (["Q"], "I", FunctionType.SCATTERING_INTENSITY_VS_Q),
+    (["Qx", "Qy"], "I", FunctionType.SCATTERING_INTENSITY_VS_Q_2D),
+    (["Qx", "Qy", "Qz"], "I", FunctionType.SCATTERING_INTENSITY_VS_Q_3D),
+    (["Z"], "G", FunctionType.SESANS),
+    (["lambda"], "T", FunctionType.TRANSMISSION)
+]
+
+function_fields_lookup = {
+    function_type_identification_key(inputs + [output]): function_type for inputs, output, function_type in function_fields_to_type
+}
+
+def build_main_data(data: list[NamedQuantity]) -> Function:
+    names = [datum.name for datum in data]
+    identifier = function_type_identification_key(names)
+
+    if identifier in function_fields_lookup:
+        function_type = function_fields_lookup[identifier]
+    else:
+        function_type = FunctionType.UNKNOWN
+
+    match function_type:
+        case FunctionType.UNKNOWN:
+            pass
+        case _:
+            raise NotImplementedError("Unknown ")
+
+def key_tree(data: Group | Dataset, indent_amount=0, indent: str = "  ") -> str:
+    """ Show a metadata tree, showing the names of they keys used to access them"""
+    s = ""
+    if isinstance(data, Group):
+        for key in data.children:
+            s += indent*indent_amount + key + "\n"
+            s += key_tree(data.children[key], indent_amount=indent_amount+1, indent=indent)
+
+    if isinstance(data, Dataset):
+        s += indent*indent_amount + "[data]\n"
+        for key in data.attributes:
+            s += indent*indent_amount + key + "\n"
+            s += key_tree(data.attributes[key], indent_amount=indent_amount+1, indent=indent)
+
+    return s

sasdata/dataset_types.py

@@ -0,0 +1,79 @@
+""" Information used for providing guesses about what text based files contain """
+
+from dataclasses import dataclass
+
+import sasdata.quantities.units as units
+
+#
+#   VERY ROUGH DRAFT - FOR PROTOTYPING PURPOSES
+#
+
+@dataclass
+class DatasetType:
+    name: str
+    required: list[str]
+    optional: list[str]
+    expected_orders: list[list[str]]
+
+
+one_dim = DatasetType(
+            name="1D I vs Q",
+            required=["Q", "I"],
+            optional=["dI", "dQ", "shadow"],
+            expected_orders=[
+                ["Q", "I", "dI"],
+                ["Q", "dQ", "I", "dI"]])
+
+two_dim = DatasetType(
+            name="2D I vs Q",
+            required=["Qx", "Qy", "I"],
+            optional=["dQx", "dQy", "dI", "Qz", "shadow"],
+            expected_orders=[
+                ["Qx", "Qy", "I"],
+                ["Qx", "Qy", "I", "dI"],
+                ["Qx", "Qy", "dQx", "dQy", "I", "dI"]])
+
+sesans = DatasetType(
+    name="SESANS",
+    required=["z", "G"],
+    optional=["stuff", "other stuff", "more stuff"],
+    expected_orders=[["z", "G"]])
+
+dataset_types = {dataset.name for dataset in [one_dim, two_dim, sesans]}
+
+
+#
+# Some default units, this is not how they should be represented, some might not be correct
+#
+# The unit options should only be those compatible with the field
+#
+
+unit_kinds = {
+    "Q": units.inverse_length,
+    "I": units.inverse_length,
+    "Qx": units.inverse_length,
+    "Qy": units.inverse_length,
+    "Qz": units.inverse_length,
+    "dI": units.inverse_length,
+    "dQ": units.inverse_length,
+    "dQx": units.inverse_length,
+    "dQy": units.inverse_length,
+    "dQz": units.inverse_length,
+    "z": units.length,
+    "G": units.area,
+    "shadow": units.dimensionless,
+    "temperature": units.temperature,
+    "magnetic field": units.magnetic_flux_density
+}
+
+#
+# Other possible fields. Ultimately, these should come out of the metadata structure
+#
+
+metadata_fields = [
+    "temperature",
+    "magnetic field",
+]
+
+
+

sasdata/distributions.py

@@ -0,0 +1,11 @@
+
+
+class DistributionModel:
+
+
+    @property
+    def is_density(self) -> bool:
+        return False
+
+    def standard_deviation(self) -> Quantity:
+        return NotImplementedError("Variance not implemented yet")