brynq-sdk-brynq 4.0.7__tar.gz → 4.0.9__tar.gz

{brynq_sdk_brynq-4.0.7 → brynq_sdk_brynq-4.0.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 1.0
 Name: brynq_sdk_brynq
-Version: 4.0.7
+Version: 4.0.9
 Summary: BrynQ SDK for the BrynQ.com platform
 Home-page: UNKNOWN
 Author: BrynQ

{brynq_sdk_brynq-4.0.7 → brynq_sdk_brynq-4.0.9}/brynq_sdk_brynq/scenarios.py

@@ -80,6 +80,8 @@ from brynq_sdk_functions import Functions
 
 from .schemas.scenarios import FieldProperties, ParsedScenario, Scenario
 
+# TOOD: Value mapping return string None if empty, should be a real None
+# TODO: employee_id, id and person_id are always kept when renaming fields, but thats only relevant for HiBob.
 
 class Scenarios():
     """
@@ -274,7 +276,7 @@ class Scenarios():
             return df, set()
 
         source_to_value_mappings = scenario.source_to_value_mappings
-        alias_to_pythonic = scenario.alias_to_pythonic
+        alias_to_pythonic = scenario.alias_to_pythonic or {}
         handled_source_fields = set()
 
         # Process each source field that has value mappings
@@ -288,6 +290,9 @@ class Scenarios():
             all_fields_exist = True
             for field_alias in source_field_aliases:
                 pythonic_field = alias_to_pythonic.get(field_alias, field_alias)
+                if pythonic_field not in df.columns and field_alias in df.columns:
+                    # Dataframe already uses pythonic naming; fall back to the alias itself
+                    pythonic_field = field_alias
                 if pythonic_field not in df.columns or pythonic_field is None:
                     warnings.warn(f"Source field {field_alias.strip()} not found in dataframe.")
                     all_fields_exist = False

{brynq_sdk_brynq-4.0.7 → brynq_sdk_brynq-4.0.9}/brynq_sdk_brynq/schemas/scenarios.py

@@ -50,14 +50,30 @@ class CustomSourceTarget(BaseModel):
         populate_by_name = True
 
 
+class LibraryFieldDescriptor(BaseModel):
+    """Rich metadata describing a library field target."""
+    id: Optional[int] = None
+    uuid: Optional[str] = None
+    required: Optional[bool] = None
+    field: Optional[str] = None
+    field_label: Optional[Dict[str, str]] = Field(default=None, alias="fieldLabel")
+    app_id: Optional[int] = Field(default=None, alias="appId")
+    category: Optional[Dict[str, Any]] = None
+
+    class Config:
+        frozen = True
+        strict = True
+        populate_by_name = True
+
+
 class LibrarySourceTarget(BaseModel):
     type: Literal["LIBRARY"] = Field(
         "LIBRARY",
         description="Discriminator—fixed value for library look-ups"
     )
-    data: List[str] = Field(
+    data: List[Union[str, LibraryFieldDescriptor]] = Field(
         ...,
-        description="List of library field identifiers"
+        description="List of library field identifiers or metadata objects"
     )
 
     class Config:
@@ -128,8 +144,9 @@ class ScenarioDetail(BaseModel):
 
     source: SourceTarget = Field(..., description="Source definition")
     target: SourceTarget = Field(..., description="Target definition")
-    mapping: ScenarioMappingConfiguration = Field(
-        ..., description="Mapping/value-translation configuration"
+    mapping: Optional[ScenarioMappingConfiguration] = Field(
+        default=None,
+        description="Mapping/value-translation configuration (may be absent)"
     )
 
     class Config:
@@ -266,45 +283,43 @@ class ParsedScenario(BaseModel):
         props: Dict[str, FieldProperties] = {}
         source_to_value_maps: Dict[str, List[ScenarioMappingConfiguration]] = defaultdict(list)
 
-        def _extract_name(path: dict, data_type: str = "LIBRARY") -> Optional[str]:
-            """Extracts a name from a path object based on its data type."""
-            # Process dictionary-based paths.
-            if isinstance(path, dict):
-                if data_type == "CUSTOM":
-                    return path.get("technical_name")
-                if data_type == "LIBRARY":
-                    return path.get("data")
-                else:
-                    return None
-                # For data_type == "FIXED" or any other unhandled type, implicitly return None.
-            elif isinstance(path, str): #string-based paths
-                if data_type != "FIXED":
-                    return path.split("-")[-1]
-                else:
-                    return None
-            else:
-                return None
+        def _extract_names_from_branch(branch: SourceTarget) -> Set[str]:
+            """Normalise source/target branch data into canonical field names."""
+            if isinstance(branch, CustomSourceTarget):
+                names = {item.technical_name for item in branch.data if item.technical_name}
+                if names:
+                    return names
+                return {item.uuid for item in branch.data if getattr(item, "uuid", None)}
+            if isinstance(branch, LibrarySourceTarget):
+                names: Set[str] = set()
+                for entry in branch.data:
+                    if isinstance(entry, str):
+                        names.add(entry)
+                    else:
+                        if entry.field:
+                            names.add(entry.field)
+                        elif entry.uuid:
+                            names.add(entry.uuid)
+                return names
+            if isinstance(branch, FixedSourceTarget):
+                return set()
+            return set()
 
         for detail in details:
-            source_data = detail.get("source", {}).get("data", [])
-            source_type = detail.get("source", {}).get("type", "LIBRARY")
-            target_data = detail.get("target", {}).get("data", [])
-            target_type = detail.get("target", {}).get("type", "LIBRARY")
+            detail_model = ScenarioDetail.model_validate(detail)
 
-            source_names = {name for p in source_data for name in [ _extract_name(p, source_type) ] if name is not None}
-            target_names = {name for p in target_data for name in [ _extract_name(p, target_type) ] if name is not None}
+            source_names = _extract_names_from_branch(detail_model.source)
+            target_names = _extract_names_from_branch(detail_model.target)
 
             for s_name in source_names:
                 src_map[s_name].update(target_names)
             for t_name in target_names:
                 tgt_map[t_name].update(source_names)
 
-            mapping_config_data = detail.get("mapping")
-            if mapping_config_data:
-                mapping_config = ScenarioMappingConfiguration.model_validate(mapping_config_data)
-                if mapping_config.values:
-                    key = '|'.join(source_names)
-                    source_to_value_maps[key].append(mapping_config)
+            mapping_config = detail_model.mapping
+            if mapping_config and mapping_config.values:
+                key = '|'.join(sorted(source_names)) if source_names else detail_model.id
+                source_to_value_maps[key].append(mapping_config)
 
             base_props = FieldProperties.model_validate(detail)
 

{brynq_sdk_brynq-4.0.7 → brynq_sdk_brynq-4.0.9}/brynq_sdk_brynq.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 1.0
 Name: brynq-sdk-brynq
-Version: 4.0.7
+Version: 4.0.9
 Summary: BrynQ SDK for the BrynQ.com platform
 Home-page: UNKNOWN
 Author: BrynQ

{brynq_sdk_brynq-4.0.7 → brynq_sdk_brynq-4.0.9}/setup.py

@@ -2,7 +2,7 @@ from setuptools import find_namespace_packages, setup
 
 setup(
     name='brynq_sdk_brynq',
-    version='4.0.7',
+    version='4.0.9',
     description='BrynQ SDK for the BrynQ.com platform',
     long_description='BrynQ SDK for the BrynQ.com platform',
     author='BrynQ',