brynq-sdk-brynq 4.0.8__tar.gz → 4.0.10__tar.gz

{brynq_sdk_brynq-4.0.8 → brynq_sdk_brynq-4.0.10}/PKG-INFO

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

{brynq_sdk_brynq-4.0.8 → brynq_sdk_brynq-4.0.10}/brynq_sdk_brynq/scenarios.py

@@ -244,14 +244,8 @@ class Scenarios():
                 source_type = value.source['type']
                 if source_type == 'FIXED':
                     source_value = value.source['data']
-                    parts = value.target['data'][0].split('-')
-                    if len(parts) > 1:
-                        target_field = parts[-1] # Taking the last part is safest.
-                        df_with_fixed[target_field] = source_value
-                    else:
-                        warnings.warn(f"Target field of {parts} not found in dataframe due to unexpected format of target field (should be sdkmethod-field).")
-                    if target_field not in df_with_fixed.columns:
-                        warnings.warn(f"Target field {target_field} not found in dataframe.")
+                    target_field = value.target['data'][0]['field']
+                    df_with_fixed[target_field] = source_value
             except Exception as e:
                 warnings.warn(f"Error adding fixed value to dataframe: {e}")
                 continue
@@ -331,11 +325,17 @@ class Scenarios():
                     # Handle different cases for source and target mapping
                     if source_map_val and target_map_val and len(target_map_val) == 1:
                         target_val = list(target_map_val.values())[0]
+                        # Strip whitespace and newline characters from target value
+                        target_val = target_val.strip()
 
                         # Case 1: Single source field to single target field
                         if len(source_map_val) == 1:
                             source_val = list(source_map_val.values())[0]
 
+                            # Strip whitespace and newline characters from both values
+                            source_val = source_val.strip()
+                            target_val = target_val.strip()
+
                             # Clean the mapping values to handle different delimiters
                             if (fix_source_val) and ('-' in source_val or ':' in source_val):
                                 source_val = source_val.replace('-', ':').split(':')[0]
@@ -361,6 +361,8 @@ class Scenarios():
                             for field_alias in source_field_aliases:
                                 if field_alias in transformed_source_map:
                                     field_val = transformed_source_map[field_alias]
+                                    # Strip whitespace and newline characters
+                                    field_val = field_val.strip()
                                     # Clean the mapping values
                                     if (fix_source_val) and ('-' in field_val or ':' in field_val):
                                         field_val = field_val.replace('-', ':').split(':')[0]
@@ -370,6 +372,9 @@ class Scenarios():
                             if len(source_values) == len(source_field_aliases):
                                 combined_source_val = '|'.join(source_values)
 
+                                # Strip whitespace and newline characters from target value
+                                target_val = target_val.strip()
+
                                 # Clean target value
                                 if (fix_target_val) and ('-' in target_val or ':' in target_val):
                                     target_val = target_val.replace('-', ':').split(':')[0]

{brynq_sdk_brynq-4.0.8 → brynq_sdk_brynq-4.0.10}/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.8 → brynq_sdk_brynq-4.0.10}/brynq_sdk_brynq.egg-info/PKG-INFO

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

{brynq_sdk_brynq-4.0.8 → brynq_sdk_brynq-4.0.10}/setup.py

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