From 195165fda2d7a5834fb60f5b7047bf0238c81b5e Mon Sep 17 00:00:00 2001
From: Simon Beyzerov <simon.beyzerov@point72.com>
Date: Thu, 31 Jul 2025 14:40:20 -0400
Subject: [PATCH 1/8] add preliminary unset field semantics (disc #536)

annotate Struct fields as optional and Structs as strict

add validation logic

add preliminary testing

Signed-off-by: Simon Beyzerov <simon.beyzerov@point72.com>
---
 cpp/csp/adapters/kafka/KafkaInputAdapter.cpp  |   2 +
 .../parquet/ParquetReaderColumnAdapter.cpp    |   1 +
 .../utils/JSONMessageStructConverter.cpp      |   3 +
 .../adapters/websocket/ClientInputAdapter.cpp |   1 +
 cpp/csp/cppnodes/baselibimpl.cpp              |   3 +-
 cpp/csp/engine/Struct.cpp                     |  48 ++-
 cpp/csp/engine/Struct.h                       |  45 ++-
 cpp/csp/python/PyStruct.cpp                   |  99 ++++-
 cpp/csp/python/PyStruct.h                     |   2 +-
 csp/impl/struct.py                            |  18 +-
 csp/impl/types/typing_utils.py                |  14 +
 csp/impl/wiring/edge.py                       |   4 +
 csp/tests/test_strict_structs.py              | 353 ++++++++++++++++++
 13 files changed, 549 insertions(+), 44 deletions(-)
 create mode 100644 csp/tests/test_strict_structs.py

diff --git a/cpp/csp/adapters/kafka/KafkaInputAdapter.cpp b/cpp/csp/adapters/kafka/KafkaInputAdapter.cpp
index 296df8daa..6cbeb8335 100644
--- a/cpp/csp/adapters/kafka/KafkaInputAdapter.cpp
+++ b/cpp/csp/adapters/kafka/KafkaInputAdapter.cpp
@@ -113,6 +113,8 @@ void KafkaInputAdapter::processMessage( RdKafka::Message* message, bool live, cs
         if( m_tickTimestampField )
             msgTime = m_tickTimestampField->value<DateTime>(tick.get());
 
+        tick.get() -> validate();
+
         bool pushLive = shouldPushLive(live, msgTime);
         if( shouldProcessMessage( pushLive, msgTime ) )
             pushTick(pushLive, msgTime, std::move(tick), batch);
diff --git a/cpp/csp/adapters/parquet/ParquetReaderColumnAdapter.cpp b/cpp/csp/adapters/parquet/ParquetReaderColumnAdapter.cpp
index b8380ce53..73837d0cb 100644
--- a/cpp/csp/adapters/parquet/ParquetReaderColumnAdapter.cpp
+++ b/cpp/csp/adapters/parquet/ParquetReaderColumnAdapter.cpp
@@ -520,6 +520,7 @@ void ParquetStructAdapter::dispatchValue( const utils::Symbol *symbol, bool isNu
         {
             fieldSetter( s );
         }
+        s -> validate();
         dispatchedValue = &s;
     }
 
diff --git a/cpp/csp/adapters/utils/JSONMessageStructConverter.cpp b/cpp/csp/adapters/utils/JSONMessageStructConverter.cpp
index 574f21084..5f81b2aac 100644
--- a/cpp/csp/adapters/utils/JSONMessageStructConverter.cpp
+++ b/cpp/csp/adapters/utils/JSONMessageStructConverter.cpp
@@ -145,6 +145,8 @@ StructPtr JSONMessageStructConverter::convertJSON( const char * fieldname, const
             } );
     }
 
+    struct_ -> validate();
+
     return struct_;
 }
 
@@ -251,6 +253,7 @@ csp::StructPtr JSONMessageStructConverter::asStruct( void * bytes, size_t size )
             }
         );
     }
+    // root struct validation (validate()) deferred to adapter level
 
     return data;
 }
diff --git a/cpp/csp/adapters/websocket/ClientInputAdapter.cpp b/cpp/csp/adapters/websocket/ClientInputAdapter.cpp
index e4b0b7ff7..d413b9dd1 100644
--- a/cpp/csp/adapters/websocket/ClientInputAdapter.cpp
+++ b/cpp/csp/adapters/websocket/ClientInputAdapter.cpp
@@ -31,6 +31,7 @@ void ClientInputAdapter::processMessage( void* c, size_t t, PushBatch* batch )
     if( dataType() -> type() == CspType::Type::STRUCT )
     {
         auto tick = m_converter -> asStruct( c, t );
+        tick.get() -> validate();
         pushTick( std::move(tick), batch );
     } else if ( dataType() -> type() == CspType::Type::STRING )
     {
diff --git a/cpp/csp/cppnodes/baselibimpl.cpp b/cpp/csp/cppnodes/baselibimpl.cpp
index 52a5537d9..9f4e1636f 100644
--- a/cpp/csp/cppnodes/baselibimpl.cpp
+++ b/cpp/csp/cppnodes/baselibimpl.cpp
@@ -705,6 +705,7 @@ DECLARE_CPPNODE( struct_fromts )
                 );
         }
 
+        out.get() -> validate( );
         CSP_OUTPUT( std::move( out ) );
     }
 
@@ -758,7 +759,7 @@ DECLARE_CPPNODE( struct_collectts )
                            }
                 );
         }
-
+        out.get() -> validate( );
         CSP_OUTPUT( std::move( out ) );
     }
 
diff --git a/cpp/csp/engine/Struct.cpp b/cpp/csp/engine/Struct.cpp
index 42830357e..9e5e884fe 100644
--- a/cpp/csp/engine/Struct.cpp
+++ b/cpp/csp/engine/Struct.cpp
@@ -1,12 +1,14 @@
 #include <csp/core/System.h>
 #include <csp/engine/Struct.h>
 #include <algorithm>
+#include <ranges>
+#include <string>
 
 namespace csp
 {
 
 StructField::StructField( CspTypePtr type, const std::string & fieldname, 
-                          size_t size, size_t alignment ) :
+                          size_t size, size_t alignment, bool isOptional ) :
     m_fieldname( fieldname ),
     m_offset( 0 ),
     m_size( size ),
@@ -14,7 +16,8 @@ StructField::StructField( CspTypePtr type, const std::string & fieldname,
     m_maskOffset( 0 ),
     m_maskBit( 0 ),
     m_maskBitMask( 0 ),
-    m_type( type )
+    m_type( type ),
+    m_isOptional( isOptional )
 {
 }
 
@@ -33,8 +36,8 @@ and adjustments required for the hidden fields
 
 */
 
-StructMeta::StructMeta( const std::string & name, const Fields & fields,
-                        std::shared_ptr<StructMeta> base ) : m_name( name ), m_base( base ), m_fields( fields ),
+StructMeta::StructMeta( const std::string & name, const Fields & fields, bool isStrict,
+                        std::shared_ptr<StructMeta> base ) : m_name( name ), m_base( base ), m_isStrict( isStrict ), m_fields( fields ), 
                                                              m_size( 0 ), m_partialSize( 0 ), m_partialStart( 0 ), m_nativeStart( 0 ), m_basePadding( 0 ),
                                                              m_maskLoc( 0 ), m_maskSize( 0 ), m_firstPartialField( 0 ), m_firstNativePartialField( 0 ),
                                                              m_isPartialNative( true ), m_isFullyNative( true )
@@ -494,6 +497,43 @@ void StructMeta::destroy( Struct * s ) const
         m_base -> destroy( s );
 }
 
+void StructMeta::validate( const Struct * s ) const
+{
+    bool encountered_non_strict = false;
+    
+    for( const StructMeta * cur = this; cur; cur = cur -> m_base.get() )
+    {
+        encountered_non_strict |= !cur -> isStrict();
+        if( !cur -> isStrict() ) {
+            continue;
+        }
+        
+        // rule 1: a non-strict struct may not inherit (directly or indirectly) from a strict base
+        if (encountered_non_strict)
+                CSP_THROW( ValueError, "Struct '" << s -> meta() -> name() << "' has non-strict inheritance of strict base '" << cur -> name() << "'" );
+
+        // rule 2: all local fields are set
+        std::string missing_fields;
+        for(const auto& field : cur->m_fields) {
+            if(!field->isSet(s)) {
+                if(missing_fields.empty()) {
+                    missing_fields = field->fieldname();
+                } else {
+                    missing_fields += ", " + field->fieldname();
+                }
+            }
+        }
+        
+        // raise error if any fields are missing
+        if (!missing_fields.empty()) {
+            CSP_THROW(ValueError,
+                     "Strict struct '" << cur->name() << "' missing required fields: " << missing_fields);
+        }
+    }
+}
+
+
+
 Struct::Struct( const std::shared_ptr<const StructMeta> & meta )
 {
     //Initialize meta shared_ptr
diff --git a/cpp/csp/engine/Struct.h b/cpp/csp/engine/Struct.h
index 64b51ecae..ff78f7b0c 100644
--- a/cpp/csp/engine/Struct.h
+++ b/cpp/csp/engine/Struct.h
@@ -35,6 +35,8 @@ class StructField
 
     bool isNative() const                 { return m_type -> type() <= CspType::Type::MAX_NATIVE_TYPE; }
 
+    bool isOptional() const               { return m_isOptional; }
+
     void setOffset( size_t off )          { m_offset = off; }
     void setMaskOffset( size_t off, uint8_t bit  )
     {
@@ -75,7 +77,7 @@ class StructField
 protected:
 
     StructField( CspTypePtr type, const std::string & fieldname,
-                 size_t size, size_t alignment );
+                 size_t size, size_t alignment, bool isOptional );
 
     void setIsSet( Struct * s ) const
     {
@@ -108,6 +110,7 @@ class StructField
     uint8_t      m_maskBit;
     uint8_t      m_maskBitMask;
     CspTypePtr   m_type;
+    const bool   m_isOptional;
 };
 
 using StructFieldPtr = std::shared_ptr<StructField>;
@@ -120,7 +123,7 @@ class NativeStructField : public StructField
 
 public:
     NativeStructField() {}
-    NativeStructField( const std::string & fieldname ) : NativeStructField( CspType::fromCType<T>::type(), fieldname )
+    NativeStructField( const std::string & fieldname, bool isOptional ) : NativeStructField( CspType::fromCType<T>::type(), fieldname, isOptional )
     {
     }
 
@@ -157,7 +160,7 @@ class NativeStructField : public StructField
     }
 
 protected:
-    NativeStructField( CspTypePtr type, const std::string & fieldname ) : StructField( type, fieldname, sizeof( T ), alignof( T ) )
+    NativeStructField( CspTypePtr type, const std::string & fieldname, bool isOptional ) : StructField( type, fieldname, sizeof( T ), alignof( T ), isOptional )
     {}
 };
 
@@ -179,7 +182,8 @@ using TimeStructField      = NativeStructField<Time>;
 class CspEnumStructField final : public NativeStructField<CspEnum>
 {
 public:
-    CspEnumStructField( CspTypePtr type, const std::string & fieldname ) : NativeStructField( type, fieldname )
+    CspEnumStructField( CspTypePtr type, const std::string & fieldname, bool isOptional ) : NativeStructField( type, 
+    fieldname, isOptional )
     {}
 };
 
@@ -218,8 +222,8 @@ class NotImplementedStructField : public StructField
 class NonNativeStructField : public StructField
 {
 public:
-    NonNativeStructField( CspTypePtr type, const std::string &fieldname, size_t size, size_t alignment ) :
-        StructField( type, fieldname, size, alignment )
+    NonNativeStructField( CspTypePtr type, const std::string &fieldname, size_t size, size_t alignment, bool isOptional ) :
+        StructField( type, fieldname, size, alignment, isOptional )
     {}
 
     virtual void initialize( Struct * s ) const = 0;
@@ -244,8 +248,8 @@ class StringStructField final : public NonNativeStructField
 public:
     using CType = csp::CspType::StringCType;
 
-    StringStructField( CspTypePtr type, const std::string & fieldname ) :
-        NonNativeStructField( type, fieldname, sizeof( CType ), alignof( CType ) )
+    StringStructField( CspTypePtr type, const std::string & fieldname, bool isOptional ) :
+        NonNativeStructField( type, fieldname, sizeof( CType ), alignof( CType ), isOptional )
     {}
 
     void initialize( Struct * s ) const override
@@ -343,8 +347,8 @@ class ArrayStructField : public NonNativeStructField
     }
 
 public:
-    ArrayStructField( CspTypePtr arrayType, const std::string & fieldname ) :
-        NonNativeStructField( arrayType, fieldname, sizeof( CType ), alignof( CType ) )
+    ArrayStructField( CspTypePtr arrayType, const std::string & fieldname, bool isOptional ) :
+        NonNativeStructField( arrayType, fieldname, sizeof( CType ), alignof( CType ), isOptional )
     {}
 
     const CType & value( const Struct * s ) const
@@ -421,8 +425,8 @@ class ArrayStructField : public NonNativeStructField
 class DialectGenericStructField : public NonNativeStructField
 {
 public:
-    DialectGenericStructField( const std::string & fieldname, size_t size, size_t alignment ) :
-        NonNativeStructField( CspType::DIALECT_GENERIC(), fieldname, size, alignment )
+    DialectGenericStructField( const std::string & fieldname, size_t size, size_t alignment, bool isOptional ) :
+        NonNativeStructField( CspType::DIALECT_GENERIC(), fieldname, size, alignment, isOptional )
     {}
 
     const DialectGenericType & value( const Struct * s ) const
@@ -587,7 +591,7 @@ class StructMeta : public std::enable_shared_from_this<StructMeta>
     using FieldNames = std::vector<std::string>;
 
     //Fields will be re-arranged and assigned their offsets in StructMeta for optimal performance
-    StructMeta( const std::string & name, const Fields & fields, std::shared_ptr<StructMeta> base = nullptr );
+    StructMeta( const std::string & name, const Fields & fields, bool isStrict, std::shared_ptr<StructMeta> base = nullptr );
     virtual ~StructMeta();
 
     const std::string & name() const          { return m_name; }
@@ -595,6 +599,7 @@ class StructMeta : public std::enable_shared_from_this<StructMeta>
     size_t partialSize() const                { return m_partialSize; }
 
     bool isNative() const                     { return m_isFullyNative; }
+    bool isStrict() const                     { return m_isStrict; }
 
     const Fields & fields() const             { return m_fields; }
     const FieldNames & fieldNames() const     { return m_fieldnames; }
@@ -602,6 +607,8 @@ class StructMeta : public std::enable_shared_from_this<StructMeta>
     size_t maskLoc() const                    { return m_maskLoc; }
     size_t maskSize() const                   { return m_maskSize; }
 
+    void validate( const Struct * s ) const;
+
     const StructFieldPtr & field( const char * name ) const
     {
         static StructFieldPtr s_empty;
@@ -652,7 +659,8 @@ class StructMeta : public std::enable_shared_from_this<StructMeta>
     std::shared_ptr<StructMeta> m_base;
     StructPtr                   m_default;
     FieldMap                    m_fieldMap;
-
+    bool                        m_isStrict;          
+    
     //fields in order, memory owners of field objects which in turn own the key memory
     //m_fields includes all base fields as well. m_fieldnames maintains the proper iteration order of fields
     Fields                      m_fields;
@@ -738,6 +746,11 @@ class Struct
         return meta() -> allFieldsSet( this );
     }
 
+    void validate() const
+    {
+        meta() -> validate( this );
+    }
+
 
     //used to cache dialect representations of this struct, if needed
     void * dialectPtr() const      { return hidden() -> dialectPtr; }
@@ -822,8 +835,8 @@ bool TypedStructPtr<T>::operator==( const TypedStructPtr<T> & rhs ) const
 class StructStructField final : public NonNativeStructField
 {
 public:
-    StructStructField( CspTypePtr cspType, const std::string &fieldname ) :
-        NonNativeStructField( cspType, fieldname, sizeof( StructPtr ), alignof( StructPtr ) )
+    StructStructField( CspTypePtr cspType, const std::string &fieldname, bool isOptional ) :
+        NonNativeStructField( cspType, fieldname, sizeof( StructPtr ), alignof( StructPtr ), isOptional )
     {
         CSP_ASSERT( cspType -> type() == CspType::Type::STRUCT );
         m_meta = std::static_pointer_cast<const CspStructType>( cspType ) -> meta();
diff --git a/cpp/csp/python/PyStruct.cpp b/cpp/csp/python/PyStruct.cpp
index 037e3f63a..094cc87a7 100644
--- a/cpp/csp/python/PyStruct.cpp
+++ b/cpp/csp/python/PyStruct.cpp
@@ -20,8 +20,9 @@ class PyObjectStructField final : public DialectGenericStructField
 public:
     using BASE = DialectGenericStructField;
     PyObjectStructField( const std::string & name,
-                         PyTypeObjectPtr pytype ) : DialectGenericStructField( name, sizeof( PyObjectPtr ), alignof( PyObjectPtr ) ),
-                                                    m_pytype( pytype )
+                        PyTypeObjectPtr pytype,
+                        bool isOptional ) : BASE( name, sizeof( PyObjectPtr ), alignof( PyObjectPtr ), isOptional ),
+                                          m_pytype( pytype )
     {}
 
 
@@ -42,8 +43,8 @@ class PyObjectStructField final : public DialectGenericStructField
 };
 
 DialectStructMeta::DialectStructMeta( PyTypeObject * pyType, const std::string & name,
-                                      const Fields & flds, std::shared_ptr<StructMeta> base ) :
-    StructMeta( name, flds, base ),
+                                      const Fields & flds, bool isStrict, std::shared_ptr<StructMeta> base ) :
+    StructMeta( name, flds, isStrict, base ),
     m_pyType( pyType )
 {
 }
@@ -110,12 +111,21 @@ static PyObject * PyStructMeta_new( PyTypeObject *subtype, PyObject *args, PyObj
     {
         PyObject *key, *type;
         Py_ssize_t pos = 0;
+        PyObject *optional_fields = PyDict_GetItemString( dict, "__optional_fields__" );
+
+
         while( PyDict_Next( metadata, &pos, &key, &type ) )
         {
             const char * keystr = PyUnicode_AsUTF8( key );
             if( !keystr )
                 CSP_THROW( PythonPassthrough, "" );
 
+            if (!PySet_Check(optional_fields)) {
+                CSP_THROW( TypeError, "Struct metadata for key " << keystr << " expected a set, got " << PyObjectPtr::incref( optional_fields ) );
+            }
+
+            bool isOptional = PySet_Contains( optional_fields, key ) == 1;
+
             if( !PyType_Check( type ) && !PyList_Check( type ) )
                 CSP_THROW( TypeError, "Struct metadata for key " << keystr << " expected a type, got " << PyObjectPtr::incref( type ) );
 
@@ -124,30 +134,30 @@ static PyObject * PyStructMeta_new( PyTypeObject *subtype, PyObject *args, PyObj
 
             switch( csptype -> type() )
             {
-                case csp::CspType::Type::BOOL:      field = std::make_shared<BoolStructField>( keystr ); break;
-                case csp::CspType::Type::INT64:     field = std::make_shared<Int64StructField>( keystr ); break;
-                case csp::CspType::Type::DOUBLE:    field = std::make_shared<DoubleStructField>( keystr ); break;
-                case csp::CspType::Type::DATETIME:  field = std::make_shared<DateTimeStructField>( keystr ); break;
-                case csp::CspType::Type::TIMEDELTA: field = std::make_shared<TimeDeltaStructField>( keystr ); break;
-                case csp::CspType::Type::DATE:      field = std::make_shared<DateStructField>( keystr ); break;
-                case csp::CspType::Type::TIME:      field = std::make_shared<TimeStructField>( keystr ); break;
-                case csp::CspType::Type::STRING:    field = std::make_shared<StringStructField>( csptype, keystr ); break;
-                case csp::CspType::Type::ENUM:      field = std::make_shared<CspEnumStructField>( csptype, keystr ); break;
-                case csp::CspType::Type::STRUCT:    field = std::make_shared<StructStructField>( csptype, keystr ); break;
+                case csp::CspType::Type::BOOL:      field = std::make_shared<BoolStructField>( keystr, isOptional ); break;
+                case csp::CspType::Type::INT64:     field = std::make_shared<Int64StructField>( keystr, isOptional ); break;
+                case csp::CspType::Type::DOUBLE:    field = std::make_shared<DoubleStructField>( keystr, isOptional ); break;
+                case csp::CspType::Type::DATETIME:  field = std::make_shared<DateTimeStructField>( keystr, isOptional ); break;
+                case csp::CspType::Type::TIMEDELTA: field = std::make_shared<TimeDeltaStructField>( keystr, isOptional ); break;
+                case csp::CspType::Type::DATE:      field = std::make_shared<DateStructField>( keystr, isOptional ); break;
+                case csp::CspType::Type::TIME:      field = std::make_shared<TimeStructField>( keystr, isOptional ); break;
+                case csp::CspType::Type::STRING:    field = std::make_shared<StringStructField>( csptype, keystr, isOptional ); break;
+                case csp::CspType::Type::ENUM:      field = std::make_shared<CspEnumStructField>( csptype, keystr, isOptional ); break;
+                case csp::CspType::Type::STRUCT:    field = std::make_shared<StructStructField>( csptype, keystr, isOptional ); break;
                 case csp::CspType::Type::ARRAY:
                 {
                     const CspArrayType & arrayType = static_cast<const CspArrayType&>( *csptype );
-                    field = ArraySubTypeSwitch::invoke( arrayType.elemType(), [csptype,keystr]( auto tag ) -> std::shared_ptr<StructField>
+                    field = ArraySubTypeSwitch::invoke( arrayType.elemType(), [csptype,keystr,isOptional]( auto tag ) -> std::shared_ptr<StructField>
                     {
                         using CElemType = typename decltype(tag)::type;
                         using CType = typename CspType::Type::toCArrayType<CElemType>::type;
-                        return std::make_shared<ArrayStructField<CType>>( csptype, keystr );
+                        return std::make_shared<ArrayStructField<CType>>( csptype, keystr, isOptional );
                     } );
 
                     break;
                 }
 
-                case csp::CspType::Type::DIALECT_GENERIC: field = std::make_shared<PyObjectStructField>( keystr, PyTypeObjectPtr::incref( ( PyTypeObject * ) type ) ); break;
+                case csp::CspType::Type::DIALECT_GENERIC: field = std::make_shared<PyObjectStructField>( keystr, PyTypeObjectPtr::incref( ( PyTypeObject * ) type ), isOptional ); break;
                 default:
                     CSP_THROW( ValueError, "Unexpected csp type " << csptype -> type() << " on struct " << name );
             }
@@ -188,7 +198,12 @@ static PyObject * PyStructMeta_new( PyTypeObject *subtype, PyObject *args, PyObj
                                   |                              |
                               PyStruct  --------------------------
     */
-    auto structMeta = std::make_shared<DialectStructMeta>( ( PyTypeObject * ) pymeta, name, fields, metabase );
+    
+    PyObject * strict_enabled = PyDict_GetItemString( dict, "__strict_enabled__" );
+    if( !strict_enabled )
+        CSP_THROW( KeyError, "StructMeta missing __strict_enabled__" );
+    bool isStrict = strict_enabled == Py_True;
+    auto structMeta = std::make_shared<DialectStructMeta>( ( PyTypeObject * ) pymeta, name, fields, isStrict, metabase );
 
     //Setup fast attr dict lookup
     pymeta -> attrDict = PyObjectPtr::own( PyDict_New() );
@@ -347,9 +362,31 @@ static PyObject * PyStructMeta_metadata_info( PyStructMeta * m )
     return out.release();
 }
 
+int PyStruct_init( PyStruct * self, PyObject * args, PyObject * kwargs, bool validate );
+
+static PyObject * PyStructMeta_unvalidated__call__( PyObject * self, PyObject * args, PyObject * kwargs )
+{
+    CSP_BEGIN_METHOD;
+    PyTypeObject * type = (PyTypeObject*)self;
+
+    PyObject* instance = type->tp_new( type, args, kwargs );
+    if( !instance )
+        CSP_THROW( PythonPassthrough, "" );
+
+    if( PyStruct_init( (PyStruct*) instance, args, kwargs, false ) < 0 )
+    {
+        Py_DECREF( instance );
+        CSP_THROW( PythonPassthrough, "" );
+    }
+
+    return instance;
+    CSP_RETURN_NULL;
+}
+
 static PyMethodDef PyStructMeta_methods[] = {
     {"_layout",        (PyCFunction) PyStructMeta_layout,        METH_NOARGS,  "debug view of structs internal mem layout"},
     {"_metadata_info", (PyCFunction) PyStructMeta_metadata_info, METH_NOARGS,  "provide detailed information about struct layout"},
+    {"_unvalidated__call__", (PyCFunction) PyStructMeta_unvalidated__call__, METH_VARARGS | METH_KEYWORDS, "create and initialize a struct without underlying validation"},
     {NULL}
 };
 
@@ -456,6 +493,9 @@ void PyStruct::setattr( Struct * s, PyObject * attr, PyObject * value )
     if( !field )
         CSP_THROW( AttributeError, "'" << s -> meta() -> name() << "' object has no attribute '" << PyUnicode_AsUTF8( attr ) << "'" );
 
+    if( (s -> meta() -> isStrict()) && (value == nullptr) )
+        CSP_THROW( AttributeError, "Strict struct " << s -> meta() -> name() << " does not allow the deletion of field " << PyUnicode_AsUTF8( attr ) );
+
     try
     {
         switchCspType( field -> type(), [field,&struct_=s,value]( auto tag )
@@ -790,15 +830,33 @@ void PyStruct_setattrs( PyStruct * self, PyObject * args, PyObject * kwargs, con
     }
 }
 
-int PyStruct_init( PyStruct * self, PyObject * args, PyObject * kwargs )
+PyObject * PyStruct_validate( PyStruct * self ) {
+    CSP_BEGIN_METHOD
+    self -> struct_ -> validate();
+    CSP_RETURN_NONE;
+}
+
+int PyStruct_init( PyStruct * self, PyObject * args, PyObject * kwargs, bool validate )
 {
     CSP_BEGIN_METHOD;
 
     PyStruct_setattrs( self, args, kwargs, "__init__" );
+    if( validate )
+    {
+        PyObject * rv = PyStruct_validate( self );
+        if( !rv )
+            return -1;
+        Py_DECREF( rv );
+    }
 
     CSP_RETURN_INT;
 }
 
+static int PyStruct_init_validated( PyStruct * self, PyObject * args, PyObject * kwargs )
+{
+    return PyStruct_init( self, args, kwargs, true );
+}
+
 PyObject * PyStruct_update( PyStruct * self, PyObject * args, PyObject * kwargs )
 {
     CSP_BEGIN_METHOD;
@@ -1002,6 +1060,7 @@ static PyMethodDef PyStruct_methods[] = {
     { "update_from",    (PyCFunction) PyStruct_update_from,    METH_O,      "update from struct. struct must be same type or a derived type. unset fields will be not be copied" },
     { "update",         (PyCFunction) PyStruct_update,         METH_VARARGS | METH_KEYWORDS, "update from key=val.  given fields will be set on struct.  other fields will remain as is in struct" },
     { "all_fields_set", (PyCFunction) PyStruct_all_fields_set, METH_NOARGS, "return true if all fields on the struct are set" },
+    { "validate",       (PyCFunction) PyStruct_validate,       METH_NOARGS, "validate the struct (strict struct fields set, etc...)" },
     { "to_dict",        (PyCFunction) PyStruct_to_dict,        METH_VARARGS | METH_KEYWORDS, "return a python dict of the struct by recursively converting struct members into python dicts" },
     { "to_json",        (PyCFunction) PyStruct_to_json,        METH_VARARGS | METH_KEYWORDS, "return a json string of the struct by recursively converting struct members into json format" },
     { NULL}
@@ -1044,7 +1103,7 @@ PyTypeObject PyStruct::PyType = {
     0,                         /* tp_descr_get */
     0,                         /* tp_descr_set */
     0,                         /* tp_dictoffset */
-    ( initproc ) PyStruct_init,  /* tp_init */
+    ( initproc ) PyStruct_init_validated,  /* tp_init */
     PyType_GenericAlloc,       /* tp_alloc */
     ( newfunc ) PyStruct_new,    /* tp_new */
     PyObject_GC_Del,           /* tp_free */
diff --git a/cpp/csp/python/PyStruct.h b/cpp/csp/python/PyStruct.h
index 2034268b8..2c794cdd9 100644
--- a/cpp/csp/python/PyStruct.h
+++ b/cpp/csp/python/PyStruct.h
@@ -25,7 +25,7 @@ class CSPTYPESIMPL_EXPORT DialectStructMeta : public StructMeta
 {
 public:
     DialectStructMeta( PyTypeObject * pyType, const std::string & name, 
-                       const Fields & fields, std::shared_ptr<StructMeta> base = nullptr );
+                       const Fields & fields, bool isStrict, std::shared_ptr<StructMeta> base = nullptr );
     ~DialectStructMeta() {}
 
     PyTypeObject * pyType() const { return m_pyType; }
diff --git a/csp/impl/struct.py b/csp/impl/struct.py
index 30b201285..9f8a4ac56 100644
--- a/csp/impl/struct.py
+++ b/csp/impl/struct.py
@@ -15,7 +15,7 @@
 
 
 class StructMeta(_csptypesimpl.PyStructMeta):
-    def __new__(cls, name, bases, dct):
+    def __new__(cls, name, bases, dct, allow_unset=True):
         full_metadata = {}
         full_metadata_typed = {}
         metadata = {}
@@ -29,12 +29,15 @@ def __new__(cls, name, bases, dct):
                 defaults.update(base.__defaults__)
 
         annotations = dct.get("__annotations__", None)
+        optional_fields = set()
         if annotations:
             for k, v in annotations.items():
                 actual_type = v
                 # Lists need to be normalized too as potentially we need to add a boolean flag to use FastList
                 if v == FastList:
                     raise TypeError(f"{v} annotation is not supported without args")
+                if CspTypingUtils.is_optional_type(v):
+                    optional_fields.add(k)
                 if (
                     CspTypingUtils.is_generic_container(v)
                     or CspTypingUtils.is_union_type(v)
@@ -72,6 +75,8 @@ def __new__(cls, name, bases, dct):
         dct["__full_metadata_typed__"] = full_metadata_typed
         dct["__metadata__"] = metadata
         dct["__defaults__"] = defaults
+        dct["__optional_fields__"] = optional_fields
+        dct["__strict_enabled__"] = not allow_unset
 
         res = super().__new__(cls, name, bases, dct)
         # This is how we make sure we construct the pydantic schema from the new class
@@ -174,6 +179,14 @@ def metadata(cls, typed=False):
         else:
             return cls.__full_metadata__
 
+    @classmethod
+    def optional_fields(cls):
+        return cls.__optional_fields__
+
+    @classmethod
+    def is_strict(cls):
+        return cls.__strict_enabled__
+
     @classmethod
     def fromts(cls, trigger=None, /, **kwargs):
         """convert valid inputs into ts[ struct ]
@@ -237,12 +250,13 @@ def _obj_from_python(cls, json, obj_type):
         elif issubclass(obj_type, Struct):
             if not isinstance(json, dict):
                 raise TypeError("Representation of struct as json is expected to be of dict type")
-            res = obj_type()
+            res = obj_type._unvalidated__call__()
             for k, v in json.items():
                 expected_type = obj_type.__full_metadata_typed__.get(k, None)
                 if expected_type is None:
                     raise KeyError(f"Unexpected key {k} for type {obj_type}")
                 setattr(res, k, cls._obj_from_python(v, expected_type))
+            res.validate()
             return res
         else:
             if isinstance(json, obj_type):
diff --git a/csp/impl/types/typing_utils.py b/csp/impl/types/typing_utils.py
index f852168d2..753686b9c 100644
--- a/csp/impl/types/typing_utils.py
+++ b/csp/impl/types/typing_utils.py
@@ -83,6 +83,13 @@ def is_numpy_nd_array_type(cls, typ):
     def is_union_type(cls, typ):
         return isinstance(typ, typing._GenericAlias) and typ.__origin__ is typing.Union
 
+    @classmethod
+    def is_optional_type(cls, typ):
+        if cls.is_union_type(typ):
+            args = typing.get_args(typ)
+            return type(None) in args
+        return False
+
     @classmethod
     def is_literal_type(cls, typ):
         return isinstance(typ, typing._GenericAlias) and typ.__origin__ is typing.Literal
@@ -123,6 +130,13 @@ def is_union_type(cls, typ):
                 typ, types.UnionType
             )
 
+        @classmethod
+        def is_optional_type(cls, typ):
+            if cls.is_union_type(typ):
+                args = typing.get_args(typ)
+                return type(None) in args
+            return False
+
     CspTypingUtils = CspTypingUtils310
 
 
diff --git a/csp/impl/wiring/edge.py b/csp/impl/wiring/edge.py
index 072b0a424..a33570149 100644
--- a/csp/impl/wiring/edge.py
+++ b/csp/impl/wiring/edge.py
@@ -202,6 +202,10 @@ def __getattr__(self, key):
             elemtype = typ.metadata(typed=True).get(key)
             if elemtype is None:
                 raise AttributeError("'%s' object has no attribute '%s'" % (self.tstype.typ.__name__, key))
+            if key in typ.optional_fields():
+                raise AttributeError(
+                    "Cannot access optional field '%s' on object '%s' at graph time" % (key, self.tstype.typ.__name__)
+                )
             return csp.struct_field(self, key, elemtype)
 
         raise AttributeError("'Edge' object has no attribute '%s'" % (key))
diff --git a/csp/tests/test_strict_structs.py b/csp/tests/test_strict_structs.py
new file mode 100644
index 000000000..769584354
--- /dev/null
+++ b/csp/tests/test_strict_structs.py
@@ -0,0 +1,353 @@
+import unittest
+from datetime import datetime, timedelta
+from typing import Optional
+
+import csp
+from csp import ts
+from csp.impl.wiring.base_parser import CspParseError
+
+
+class TestStrictStructs(unittest.TestCase):
+    def test_backwards_compatibility(self):
+        """quick test that existing struct behavior is unchanged"""
+
+        class OldStruct(csp.Struct, allow_unset=True):
+            a: int
+            b: str
+
+        s = OldStruct(a=5)
+        self.assertFalse(hasattr(s, "b"))
+        with self.assertRaisesRegex(AttributeError, "b"):
+            _ = s.b
+        del s.a
+        self.assertFalse(hasattr(s, "a"))
+
+    def test_strict_struct_initialization(self):
+        """test initialization rules for strict structs.
+
+        notably,
+        * Setting fields works as expected
+        * Initialize all non-default fields (including Optional)
+        * Missing required fields fail
+        """
+
+        class MyStrictStruct(csp.Struct, allow_unset=False):
+            req_int: int
+            opt_str: Optional[str]
+            def_int: int = 123
+            opt_str_2: Optional[str] = None
+
+        # Valid initialization
+        s1 = MyStrictStruct(req_int=10, opt_str="hello")
+        self.assertEqual(s1.req_int, 10)
+        self.assertEqual(s1.opt_str, "hello")
+        self.assertEqual(s1.def_int, 123)
+        self.assertIsNone(s1.opt_str_2)
+
+        # Error on missing required fields
+        with self.assertRaisesRegex(ValueError, "Strict struct 'MyStrictStruct' missing required fields: req_int"):
+            MyStrictStruct(opt_str="world")
+
+        with self.assertRaisesRegex(ValueError, "Strict struct 'MyStrictStruct' missing required fields: opt_str"):
+            MyStrictStruct(req_int=1)
+
+        with self.assertRaisesRegex(
+            ValueError, "Strict struct 'MyStrictStruct' missing required fields: opt_str, req_int"
+        ):
+            MyStrictStruct()
+
+    def test_strict_struct_hasattr_delattr(self):
+        """test hasattr and delattr behavior for strict structs"""
+
+        class MyStrictStruct1(csp.Struct, allow_unset=False):
+            req_int: int
+            opt_str: Optional[str]
+
+        class MyStrictStruct2(csp.Struct, allow_unset=False):
+            req_int: int
+            opt_str: Optional[str] = None
+
+        s = MyStrictStruct1(req_int=10, opt_str="hello")
+        r = MyStrictStruct2(req_int=5)
+
+        # hasattr will always be True for all defined fields
+        self.assertTrue(hasattr(s, "req_int"))
+        self.assertTrue(hasattr(s, "opt_str"))
+        self.assertTrue(hasattr(r, "req_int"))
+        self.assertTrue(hasattr(r, "opt_str"))
+
+        # delattr is forbidden
+        with self.assertRaisesRegex(
+            AttributeError, "Strict struct MyStrictStruct1 does not allow the deletion of field req_int"
+        ):
+            del s.req_int
+
+        with self.assertRaisesRegex(
+            AttributeError, "Strict struct MyStrictStruct1 does not allow the deletion of field opt_str"
+        ):
+            del s.opt_str
+
+    def test_strict_struct_serialization(self):
+        """test to_dict and from_dict behavior"""
+
+        class MyStrictStruct(csp.Struct, allow_unset=False):
+            req_int: int
+            opt_str: Optional[str] = None
+            def_int: int = 100
+            req_opt_str: Optional[str]
+
+        s = MyStrictStruct(req_int=50, req_opt_str="NoneStr")
+        expected_dict = {"req_int": 50, "opt_str": None, "def_int": 100, "req_opt_str": "NoneStr"}
+        self.assertEqual(s.to_dict(), expected_dict)
+
+        with self.assertRaisesRegex(
+            ValueError, "Strict struct 'MyStrictStruct' missing required fields: req_opt_str, req_int"
+        ):
+            MyStrictStruct.from_dict({"opt_str": "hello", "def_int": 13})
+
+        MyStrictStruct.from_dict({"req_int": 60, "opt_str": None, "req_opt_str": None})
+        s2 = MyStrictStruct.from_dict({"req_int": 60, "req_opt_str": None})
+        self.assertEqual(s2.req_int, 60)
+        self.assertIsNone(s2.opt_str)
+        self.assertEqual(s2.def_int, 100)
+
+    def test_strict_struct_wiring_access_1(self):
+        """test accessing fields on a time series at graph wiring time"""
+
+        class MyStrictStruct(csp.Struct, allow_unset=False):
+            req_int: int
+            opt_str: Optional[str] = None
+
+        # check that at graph and wire time we are able to access required fields just fine:
+
+        @csp.node
+        def ok_node(x: csp.ts[MyStrictStruct]):
+            int_val = x.req_int
+
+        @csp.graph
+        def g():
+            s_ts = csp.const(MyStrictStruct(req_int=1))
+            req_ts = s_ts.req_int
+            csp.add_graph_output("req_ts", req_ts)
+
+        res = csp.run(g, starttime=datetime(2023, 1, 1))
+        self.assertEqual(res["req_ts"][0][1], 1)
+
+        # check that at graph time we cannot access optional fields:
+
+        @csp.graph
+        def g_fail():
+            s_ts = csp.const(MyStrictStruct(req_int=1))
+            opt_ts = s_ts.opt_str
+
+        with self.assertRaisesRegex(
+            AttributeError,
+            "Cannot access optional field 'opt_str' on object 'MyStrictStruct' at graph time",
+        ):
+            csp.run(g_fail, starttime=datetime(2023, 1, 1))
+
+    def test_strict_struct_fromts(self):
+        """fromts requires all non-defaulted fields to tick together"""
+
+        class MyStrictStruct(csp.Struct, allow_unset=False):
+            req_int1: int
+            req_int2: int
+            opt_str: Optional[str] = None
+            req_default_str: str = "default"
+
+        @csp.node
+        def make_ts(x: csp.ts[int]) -> csp.ts[int]:
+            if x % 2 == 0:
+                return x
+
+        @csp.graph
+        def g():
+            ts1 = make_ts(csp.const(2))
+            ts2 = make_ts(csp.const(1))
+
+            # ts1 and ts2 don't tick together
+            s_ts = MyStrictStruct.fromts(req_int1=ts1, req_int2=ts2)
+            csp.add_graph_output("output", s_ts)
+
+        with self.assertRaisesRegex(ValueError, "Strict struct 'MyStrictStruct' missing required fields: req_int2"):
+            csp.run(g, starttime=datetime(2023, 1, 1))
+
+        @csp.graph
+        def g_ok():
+            ts1 = csp.const(2)
+            ts2 = csp.const(4)
+
+            # ts1 and ts2 tick together
+            s_ts = MyStrictStruct.fromts(req_int1=ts1, req_int2=ts2)
+            csp.add_graph_output("output", s_ts)
+
+        csp.run(g_ok, starttime=datetime(2023, 1, 1))
+
+        @csp.graph
+        def g_ok_with_optional():
+            beat = csp.timer(timedelta(days=1))
+            even = csp.eq(csp.mod(csp.count(beat), csp.const(2)), csp.const(0))
+
+            int_ts1 = csp.sample(even, csp.const(1))
+            int_ts2 = csp.sample(even, csp.const(2))
+            str_ts = csp.sample(even, csp.const("Hello"))
+
+            s_ts = MyStrictStruct.fromts(req_int1=int_ts1, req_int2=int_ts2, req_default_str=str_ts)
+            csp.add_graph_output("output", s_ts)
+
+        csp.run(g_ok_with_optional, starttime=datetime(2025, 1, 1), endtime=datetime(2025, 1, 5))
+
+    def test_strict_struct_inheritance_and_nested(self):
+        class BaseStrict(csp.Struct, allow_unset=False):
+            base_req: int
+
+        class DerivedStrict(BaseStrict, allow_unset=False):
+            derived_req: int
+
+        d_ok = DerivedStrict(base_req=1, derived_req=2)
+        self.assertEqual(d_ok.base_req, 1)
+        self.assertEqual(d_ok.derived_req, 2)
+
+        with self.assertRaisesRegex(ValueError, "Strict struct 'DerivedStrict' missing required fields: derived_req"):
+            DerivedStrict(base_req=10)
+        with self.assertRaisesRegex(ValueError, "Strict struct 'DerivedStrict' missing required fields: base_req"):
+            DerivedStrict(derived_req=20)
+
+        # loose base & strict child:
+        class LooseBase(csp.Struct, allow_unset=True):
+            loose_req: int
+
+        class StrictChild(LooseBase, allow_unset=False):
+            child_req: int
+
+        sc_ok = StrictChild(child_req=5, loose_req=10)
+        self.assertEqual(sc_ok.child_req, 5)
+
+        with self.assertRaisesRegex(
+            ValueError, "Strict struct 'StrictChild' missing required fields: loose_req, child_req"
+        ):
+            StrictChild()
+        with self.assertRaisesRegex(ValueError, "Strict struct 'StrictChild' missing required fields: child_req"):
+            StrictChild(loose_req=10)
+        with self.assertRaisesRegex(ValueError, "Strict struct 'StrictChild' missing required fields: loose_req"):
+            StrictChild(child_req=5)
+
+        # nested struct fields:
+        class InnerStrict(csp.Struct, allow_unset=False):
+            val: int
+
+        class OuterStrict(csp.Struct, allow_unset=False):
+            inner: InnerStrict
+
+        os_ok = OuterStrict(inner=InnerStrict(val=42))
+        self.assertEqual(os_ok.inner.val, 42)
+
+        with self.assertRaisesRegex(ValueError, "Strict struct 'InnerStrict' missing required fields: val"):
+            OuterStrict(inner=InnerStrict())
+
+        # nested loose struct inside strict:
+        class InnerLoose(csp.Struct, allow_unset=True):
+            val: int
+
+        class OuterStrict2(csp.Struct, allow_unset=False):
+            inner: InnerLoose
+
+        ol_ok = OuterStrict2(inner=InnerLoose())
+        self.assertIsInstance(ol_ok.inner, InnerLoose)
+
+        with self.assertRaisesRegex(ValueError, "Strict struct 'OuterStrict2' missing required fields: inner"):
+            OuterStrict2()
+
+    def test_nonstrict_cannot_inherit_strict(self):
+        """non-strict structs inheriting from strict bases should raise"""
+
+        class StrictBase(csp.Struct, allow_unset=False):
+            base_val: int
+
+        class NonStrictChild1(StrictBase, allow_unset=True):
+            child_val1: Optional[int] = None
+
+        class NonStrictChild2(NonStrictChild1, allow_unset=True):
+            child_val2: Optional[int] = None
+
+        class NonStrictChild3(NonStrictChild2, allow_unset=True):
+            child_val3: Optional[int] = None
+
+        with self.assertRaisesRegex(ValueError, "non-strict inheritance of strict base"):
+            NonStrictChild1(base_val=1, child_val1=2)
+
+        with self.assertRaisesRegex(ValueError, "non-strict inheritance of strict base"):
+            NonStrictChild2(base_val=3, child_val1=4, child_val2=5)
+
+        with self.assertRaisesRegex(ValueError, "non-strict inheritance of strict base"):
+            NonStrictChild3(base_val=6, child_val1=7, child_val2=8, child_val3=9)
+
+    def test_nonstrict_strict_nonstrict_inheritance_order(self):
+        """inheritance order NonStrict -> Strict -> NonStrict raises an error"""
+
+        class NonStrictBase(csp.Struct, allow_unset=True):
+            base_val: int
+
+        class StrictMiddle(NonStrictBase, allow_unset=False):
+            middle_val: int
+
+        class NonStrictChild(StrictMiddle, allow_unset=True):
+            child_val: Optional[int] = None
+
+        with self.assertRaisesRegex(ValueError, "non-strict inheritance of strict base"):
+            NonStrictChild(base_val=1, middle_val=2, child_val=3)
+
+    def test_nested_struct_serialization(self):
+        """to_dict / from_dict work with nested strict & non-strict structs"""
+
+        class InnerStrict(csp.Struct, allow_unset=False):
+            x: int
+
+        class InnerLoose(csp.Struct, allow_unset=True):
+            y: Optional[int] = None
+
+        class OuterStruct(csp.Struct, allow_unset=False):
+            strict_inner: InnerStrict
+            loose_inner: InnerLoose
+
+        o = OuterStruct(strict_inner=InnerStrict(x=5), loose_inner=InnerLoose())
+        expected_dict = {"strict_inner": {"x": 5}, "loose_inner": {"y": None}}
+        self.assertEqual(o.to_dict(), expected_dict)
+
+        o2 = OuterStruct.from_dict({"strict_inner": {"x": 10}, "loose_inner": {"y": 20}})
+        self.assertEqual(o2.strict_inner.x, 10)
+        self.assertIsNotNone(o2.loose_inner)
+        self.assertEqual(o2.loose_inner.y, 20)
+
+        with self.assertRaisesRegex(ValueError, "Strict struct 'OuterStruct' missing required fields: strict_inner"):
+            OuterStruct.from_dict({"loose_inner": {"y": 1}})
+
+        with self.assertRaisesRegex(ValueError, "Strict struct 'InnerStrict' missing required fields: x"):
+            OuterStruct.from_dict({"strict_inner": {}, "loose_inner": {"y": None}})
+
+    def test_strict_struct_wiring_access_2(self):
+        class Test(csp.Struct, allow_unset=False):
+            name: str
+            age: int
+            is_active: Optional[bool]
+
+            def greet(self):
+                return f"Hello, my name is {self.name} and I am {self.age} years old."
+
+        @csp.node
+        def test() -> csp.ts[Test]:
+            return Test(name="John", age=30, is_active=True)
+
+        @csp.graph
+        def main_graph():
+            res = test().is_active
+            csp.print("", res)
+
+        with self.assertRaisesRegex(
+            AttributeError, "Cannot access optional field 'is_active' on object 'Test' at graph time"
+        ):
+            csp.build_graph(main_graph)
+
+
+if __name__ == "__main__":
+    unittest.main()

From 345f37f1be3aa3ed0ad64c25a4c16fc9189a675c Mon Sep 17 00:00:00 2001
From: Simon Beyzerov <simon.beyzerov@point72.com>
Date: Wed, 13 Aug 2025 11:22:40 -0400
Subject: [PATCH 2/8] style nits

Signed-off-by: Simon Beyzerov <simon.beyzerov@point72.com>
---
 cpp/csp/engine/Struct.cpp      | 43 ++++++++++++++++++----------------
 cpp/csp/engine/Struct.h        |  3 +--
 cpp/csp/python/PyStruct.cpp    |  8 +++----
 csp/impl/types/typing_utils.py |  7 ------
 4 files changed, 28 insertions(+), 33 deletions(-)

diff --git a/cpp/csp/engine/Struct.cpp b/cpp/csp/engine/Struct.cpp
index 9e5e884fe..5ba43d251 100644
--- a/cpp/csp/engine/Struct.cpp
+++ b/cpp/csp/engine/Struct.cpp
@@ -501,34 +501,37 @@ void StructMeta::validate( const Struct * s ) const
 {
     bool encountered_non_strict = false;
     
-    for( const StructMeta * cur = this; cur; cur = cur -> m_base.get() )
+    for ( const StructMeta * cur = this; cur; cur = cur -> m_base.get() )
     {
         encountered_non_strict |= !cur -> isStrict();
-        if( !cur -> isStrict() ) {
+        if ( !cur -> isStrict() )
             continue;
-        }
         
-        // rule 1: a non-strict struct may not inherit (directly or indirectly) from a strict base
-        if (encountered_non_strict)
-                CSP_THROW( ValueError, "Struct '" << s -> meta() -> name() << "' has non-strict inheritance of strict base '" << cur -> name() << "'" );
-
-        // rule 2: all local fields are set
+        // Rule 1: A non-strict struct may not inherit (directly or indirectly) from a strict base
+        if ( encountered_non_strict )
+            CSP_THROW( ValueError, 
+                    "Struct '" << s -> meta() -> name() 
+                    << "' has non-strict inheritance of strict base '" 
+                    << cur -> name() << "'" );
+
+        // Rule 2: All local fields are set
         std::string missing_fields;
-        for(const auto& field : cur->m_fields) {
-            if(!field->isSet(s)) {
-                if(missing_fields.empty()) {
-                    missing_fields = field->fieldname();
-                } else {
-                    missing_fields += ", " + field->fieldname();
-                }
+        for ( const auto & field : cur -> m_fields )
+        {
+            if ( !field -> isSet( s ) )
+            {
+                if ( missing_fields.empty() )
+                    missing_fields = field -> fieldname();
+                else
+                    missing_fields += ", " + field -> fieldname();
             }
         }
         
-        // raise error if any fields are missing
-        if (!missing_fields.empty()) {
-            CSP_THROW(ValueError,
-                     "Strict struct '" << cur->name() << "' missing required fields: " << missing_fields);
-        }
+        // Raise error if any fields are missing
+        if ( !missing_fields.empty() )
+            CSP_THROW( ValueError, 
+                    "Strict struct '" << cur -> name() 
+                    << "' missing required fields: " << missing_fields );
     }
 }
 
diff --git a/cpp/csp/engine/Struct.h b/cpp/csp/engine/Struct.h
index ff78f7b0c..3daae2bff 100644
--- a/cpp/csp/engine/Struct.h
+++ b/cpp/csp/engine/Struct.h
@@ -182,8 +182,7 @@ using TimeStructField      = NativeStructField<Time>;
 class CspEnumStructField final : public NativeStructField<CspEnum>
 {
 public:
-    CspEnumStructField( CspTypePtr type, const std::string & fieldname, bool isOptional ) : NativeStructField( type, 
-    fieldname, isOptional )
+    CspEnumStructField( CspTypePtr type, const std::string & fieldname, bool isOptional ) : NativeStructField( type, fieldname, isOptional )
     {}
 };
 
diff --git a/cpp/csp/python/PyStruct.cpp b/cpp/csp/python/PyStruct.cpp
index 094cc87a7..9c531fd14 100644
--- a/cpp/csp/python/PyStruct.cpp
+++ b/cpp/csp/python/PyStruct.cpp
@@ -20,9 +20,9 @@ class PyObjectStructField final : public DialectGenericStructField
 public:
     using BASE = DialectGenericStructField;
     PyObjectStructField( const std::string & name,
-                        PyTypeObjectPtr pytype,
-                        bool isOptional ) : BASE( name, sizeof( PyObjectPtr ), alignof( PyObjectPtr ), isOptional ),
-                                          m_pytype( pytype )
+                         PyTypeObjectPtr pytype,
+                         bool isOptional ) : BASE( name, sizeof( PyObjectPtr ), alignof( PyObjectPtr ), isOptional ),
+                                             m_pytype( pytype )
     {}
 
 
@@ -493,7 +493,7 @@ void PyStruct::setattr( Struct * s, PyObject * attr, PyObject * value )
     if( !field )
         CSP_THROW( AttributeError, "'" << s -> meta() -> name() << "' object has no attribute '" << PyUnicode_AsUTF8( attr ) << "'" );
 
-    if( (s -> meta() -> isStrict()) && (value == nullptr) )
+    if ( s -> meta() -> isStrict() && value == nullptr )
         CSP_THROW( AttributeError, "Strict struct " << s -> meta() -> name() << " does not allow the deletion of field " << PyUnicode_AsUTF8( attr ) );
 
     try
diff --git a/csp/impl/types/typing_utils.py b/csp/impl/types/typing_utils.py
index 753686b9c..3511888b2 100644
--- a/csp/impl/types/typing_utils.py
+++ b/csp/impl/types/typing_utils.py
@@ -130,13 +130,6 @@ def is_union_type(cls, typ):
                 typ, types.UnionType
             )
 
-        @classmethod
-        def is_optional_type(cls, typ):
-            if cls.is_union_type(typ):
-                args = typing.get_args(typ)
-                return type(None) in args
-            return False
-
     CspTypingUtils = CspTypingUtils310
 
 

From 4acbb08a9c14cd89cdcf436e18b4659d8de52047 Mon Sep 17 00:00:00 2001
From: Simon Beyzerov <simon.beyzerov@point72.com>
Date: Wed, 13 Aug 2025 13:34:12 -0400
Subject: [PATCH 3/8] revert and simplify optional field interface

---
 cpp/csp/engine/Struct.cpp   |  4 +-
 cpp/csp/engine/Struct.h     | 35 ++++++++++--------
 cpp/csp/python/PyStruct.cpp | 74 +++++++++++--------------------------
 csp/impl/struct.py          |  6 +--
 4 files changed, 46 insertions(+), 73 deletions(-)

diff --git a/cpp/csp/engine/Struct.cpp b/cpp/csp/engine/Struct.cpp
index 5ba43d251..3fe45b1ea 100644
--- a/cpp/csp/engine/Struct.cpp
+++ b/cpp/csp/engine/Struct.cpp
@@ -8,7 +8,7 @@ namespace csp
 {
 
 StructField::StructField( CspTypePtr type, const std::string & fieldname, 
-                          size_t size, size_t alignment, bool isOptional ) :
+                          size_t size, size_t alignment ) :
     m_fieldname( fieldname ),
     m_offset( 0 ),
     m_size( size ),
@@ -17,7 +17,7 @@ StructField::StructField( CspTypePtr type, const std::string & fieldname,
     m_maskBit( 0 ),
     m_maskBitMask( 0 ),
     m_type( type ),
-    m_isOptional( isOptional )
+    m_isOptional( 1 )
 {
 }
 
diff --git a/cpp/csp/engine/Struct.h b/cpp/csp/engine/Struct.h
index 3daae2bff..ae8485f95 100644
--- a/cpp/csp/engine/Struct.h
+++ b/cpp/csp/engine/Struct.h
@@ -47,6 +47,11 @@ class StructField
         m_maskBitMask = 1 << bit;
     }
 
+    void setRequired()
+    {
+        m_isOptional = false;
+    }
+
     bool isSet( const Struct * s ) const
     {
         const uint8_t * m = reinterpret_cast<const uint8_t *>( s ) + m_maskOffset;
@@ -77,7 +82,7 @@ class StructField
 protected:
 
     StructField( CspTypePtr type, const std::string & fieldname,
-                 size_t size, size_t alignment, bool isOptional );
+                 size_t size, size_t alignment );
 
     void setIsSet( Struct * s ) const
     {
@@ -110,7 +115,7 @@ class StructField
     uint8_t      m_maskBit;
     uint8_t      m_maskBitMask;
     CspTypePtr   m_type;
-    const bool   m_isOptional;
+    bool         m_isOptional;
 };
 
 using StructFieldPtr = std::shared_ptr<StructField>;
@@ -123,7 +128,7 @@ class NativeStructField : public StructField
 
 public:
     NativeStructField() {}
-    NativeStructField( const std::string & fieldname, bool isOptional ) : NativeStructField( CspType::fromCType<T>::type(), fieldname, isOptional )
+    NativeStructField( const std::string & fieldname ) : NativeStructField( CspType::fromCType<T>::type(), fieldname )
     {
     }
 
@@ -160,7 +165,7 @@ class NativeStructField : public StructField
     }
 
 protected:
-    NativeStructField( CspTypePtr type, const std::string & fieldname, bool isOptional ) : StructField( type, fieldname, sizeof( T ), alignof( T ), isOptional )
+    NativeStructField( CspTypePtr type, const std::string & fieldname ) : StructField( type, fieldname, sizeof( T ), alignof( T ) )
     {}
 };
 
@@ -182,7 +187,7 @@ using TimeStructField      = NativeStructField<Time>;
 class CspEnumStructField final : public NativeStructField<CspEnum>
 {
 public:
-    CspEnumStructField( CspTypePtr type, const std::string & fieldname, bool isOptional ) : NativeStructField( type, fieldname, isOptional )
+    CspEnumStructField( CspTypePtr type, const std::string & fieldname ) : NativeStructField( type, fieldname )
     {}
 };
 
@@ -221,8 +226,8 @@ class NotImplementedStructField : public StructField
 class NonNativeStructField : public StructField
 {
 public:
-    NonNativeStructField( CspTypePtr type, const std::string &fieldname, size_t size, size_t alignment, bool isOptional ) :
-        StructField( type, fieldname, size, alignment, isOptional )
+    NonNativeStructField( CspTypePtr type, const std::string &fieldname, size_t size, size_t alignment ) :
+        StructField( type, fieldname, size, alignment )
     {}
 
     virtual void initialize( Struct * s ) const = 0;
@@ -247,8 +252,8 @@ class StringStructField final : public NonNativeStructField
 public:
     using CType = csp::CspType::StringCType;
 
-    StringStructField( CspTypePtr type, const std::string & fieldname, bool isOptional ) :
-        NonNativeStructField( type, fieldname, sizeof( CType ), alignof( CType ), isOptional )
+    StringStructField( CspTypePtr type, const std::string & fieldname ) :
+        NonNativeStructField( type, fieldname, sizeof( CType ), alignof( CType ) )
     {}
 
     void initialize( Struct * s ) const override
@@ -346,8 +351,8 @@ class ArrayStructField : public NonNativeStructField
     }
 
 public:
-    ArrayStructField( CspTypePtr arrayType, const std::string & fieldname, bool isOptional ) :
-        NonNativeStructField( arrayType, fieldname, sizeof( CType ), alignof( CType ), isOptional )
+    ArrayStructField( CspTypePtr arrayType, const std::string & fieldname ) :
+        NonNativeStructField( arrayType, fieldname, sizeof( CType ), alignof( CType ) )
     {}
 
     const CType & value( const Struct * s ) const
@@ -424,8 +429,8 @@ class ArrayStructField : public NonNativeStructField
 class DialectGenericStructField : public NonNativeStructField
 {
 public:
-    DialectGenericStructField( const std::string & fieldname, size_t size, size_t alignment, bool isOptional ) :
-        NonNativeStructField( CspType::DIALECT_GENERIC(), fieldname, size, alignment, isOptional )
+    DialectGenericStructField( const std::string & fieldname, size_t size, size_t alignment ) :
+        NonNativeStructField( CspType::DIALECT_GENERIC(), fieldname, size, alignment )
     {}
 
     const DialectGenericType & value( const Struct * s ) const
@@ -834,8 +839,8 @@ bool TypedStructPtr<T>::operator==( const TypedStructPtr<T> & rhs ) const
 class StructStructField final : public NonNativeStructField
 {
 public:
-    StructStructField( CspTypePtr cspType, const std::string &fieldname, bool isOptional ) :
-        NonNativeStructField( cspType, fieldname, sizeof( StructPtr ), alignof( StructPtr ), isOptional )
+    StructStructField( CspTypePtr cspType, const std::string &fieldname ) :
+        NonNativeStructField( cspType, fieldname, sizeof( StructPtr ), alignof( StructPtr ) )
     {
         CSP_ASSERT( cspType -> type() == CspType::Type::STRUCT );
         m_meta = std::static_pointer_cast<const CspStructType>( cspType ) -> meta();
diff --git a/cpp/csp/python/PyStruct.cpp b/cpp/csp/python/PyStruct.cpp
index 9c531fd14..016265ede 100644
--- a/cpp/csp/python/PyStruct.cpp
+++ b/cpp/csp/python/PyStruct.cpp
@@ -20,8 +20,7 @@ class PyObjectStructField final : public DialectGenericStructField
 public:
     using BASE = DialectGenericStructField;
     PyObjectStructField( const std::string & name,
-                         PyTypeObjectPtr pytype,
-                         bool isOptional ) : BASE( name, sizeof( PyObjectPtr ), alignof( PyObjectPtr ), isOptional ),
+                         PyTypeObjectPtr pytype ) : BASE( name, sizeof( PyObjectPtr ), alignof( PyObjectPtr ) ),
                                              m_pytype( pytype )
     {}
 
@@ -120,9 +119,8 @@ static PyObject * PyStructMeta_new( PyTypeObject *subtype, PyObject *args, PyObj
             if( !keystr )
                 CSP_THROW( PythonPassthrough, "" );
 
-            if (!PySet_Check(optional_fields)) {
+            if (!PySet_Check(optional_fields)) 
                 CSP_THROW( TypeError, "Struct metadata for key " << keystr << " expected a set, got " << PyObjectPtr::incref( optional_fields ) );
-            }
 
             bool isOptional = PySet_Contains( optional_fields, key ) == 1;
 
@@ -134,33 +132,36 @@ static PyObject * PyStructMeta_new( PyTypeObject *subtype, PyObject *args, PyObj
 
             switch( csptype -> type() )
             {
-                case csp::CspType::Type::BOOL:      field = std::make_shared<BoolStructField>( keystr, isOptional ); break;
-                case csp::CspType::Type::INT64:     field = std::make_shared<Int64StructField>( keystr, isOptional ); break;
-                case csp::CspType::Type::DOUBLE:    field = std::make_shared<DoubleStructField>( keystr, isOptional ); break;
-                case csp::CspType::Type::DATETIME:  field = std::make_shared<DateTimeStructField>( keystr, isOptional ); break;
-                case csp::CspType::Type::TIMEDELTA: field = std::make_shared<TimeDeltaStructField>( keystr, isOptional ); break;
-                case csp::CspType::Type::DATE:      field = std::make_shared<DateStructField>( keystr, isOptional ); break;
-                case csp::CspType::Type::TIME:      field = std::make_shared<TimeStructField>( keystr, isOptional ); break;
-                case csp::CspType::Type::STRING:    field = std::make_shared<StringStructField>( csptype, keystr, isOptional ); break;
-                case csp::CspType::Type::ENUM:      field = std::make_shared<CspEnumStructField>( csptype, keystr, isOptional ); break;
-                case csp::CspType::Type::STRUCT:    field = std::make_shared<StructStructField>( csptype, keystr, isOptional ); break;
+                case csp::CspType::Type::BOOL:      field = std::make_shared<BoolStructField>( keystr ); break;
+                case csp::CspType::Type::INT64:     field = std::make_shared<Int64StructField>( keystr ); break;
+                case csp::CspType::Type::DOUBLE:    field = std::make_shared<DoubleStructField>( keystr ); break;
+                case csp::CspType::Type::DATETIME:  field = std::make_shared<DateTimeStructField>( keystr ); break;
+                case csp::CspType::Type::TIMEDELTA: field = std::make_shared<TimeDeltaStructField>( keystr ); break;
+                case csp::CspType::Type::DATE:      field = std::make_shared<DateStructField>( keystr ); break;
+                case csp::CspType::Type::TIME:      field = std::make_shared<TimeStructField>( keystr ); break;
+                case csp::CspType::Type::STRING:    field = std::make_shared<StringStructField>( csptype, keystr ); break;
+                case csp::CspType::Type::ENUM:      field = std::make_shared<CspEnumStructField>( csptype, keystr ); break;
+                case csp::CspType::Type::STRUCT:    field = std::make_shared<StructStructField>( csptype, keystr ); break;
                 case csp::CspType::Type::ARRAY:
                 {
                     const CspArrayType & arrayType = static_cast<const CspArrayType&>( *csptype );
-                    field = ArraySubTypeSwitch::invoke( arrayType.elemType(), [csptype,keystr,isOptional]( auto tag ) -> std::shared_ptr<StructField>
+                    field = ArraySubTypeSwitch::invoke( arrayType.elemType(), [csptype,keystr]( auto tag ) -> std::shared_ptr<StructField>
                     {
                         using CElemType = typename decltype(tag)::type;
                         using CType = typename CspType::Type::toCArrayType<CElemType>::type;
-                        return std::make_shared<ArrayStructField<CType>>( csptype, keystr, isOptional );
+                        return std::make_shared<ArrayStructField<CType>>( csptype, keystr );
                     } );
 
                     break;
                 }
 
-                case csp::CspType::Type::DIALECT_GENERIC: field = std::make_shared<PyObjectStructField>( keystr, PyTypeObjectPtr::incref( ( PyTypeObject * ) type ), isOptional ); break;
+                case csp::CspType::Type::DIALECT_GENERIC: field = std::make_shared<PyObjectStructField>( keystr, PyTypeObjectPtr::incref( ( PyTypeObject * ) type ) ); break;
                 default:
                     CSP_THROW( ValueError, "Unexpected csp type " << csptype -> type() << " on struct " << name );
             }
+            
+            if ( !isOptional )
+                field -> setRequired( );
 
             fields.emplace_back( field );
         }
@@ -362,31 +363,10 @@ static PyObject * PyStructMeta_metadata_info( PyStructMeta * m )
     return out.release();
 }
 
-int PyStruct_init( PyStruct * self, PyObject * args, PyObject * kwargs, bool validate );
-
-static PyObject * PyStructMeta_unvalidated__call__( PyObject * self, PyObject * args, PyObject * kwargs )
-{
-    CSP_BEGIN_METHOD;
-    PyTypeObject * type = (PyTypeObject*)self;
-
-    PyObject* instance = type->tp_new( type, args, kwargs );
-    if( !instance )
-        CSP_THROW( PythonPassthrough, "" );
-
-    if( PyStruct_init( (PyStruct*) instance, args, kwargs, false ) < 0 )
-    {
-        Py_DECREF( instance );
-        CSP_THROW( PythonPassthrough, "" );
-    }
-
-    return instance;
-    CSP_RETURN_NULL;
-}
 
 static PyMethodDef PyStructMeta_methods[] = {
     {"_layout",        (PyCFunction) PyStructMeta_layout,        METH_NOARGS,  "debug view of structs internal mem layout"},
     {"_metadata_info", (PyCFunction) PyStructMeta_metadata_info, METH_NOARGS,  "provide detailed information about struct layout"},
-    {"_unvalidated__call__", (PyCFunction) PyStructMeta_unvalidated__call__, METH_VARARGS | METH_KEYWORDS, "create and initialize a struct without underlying validation"},
     {NULL}
 };
 
@@ -836,27 +816,16 @@ PyObject * PyStruct_validate( PyStruct * self ) {
     CSP_RETURN_NONE;
 }
 
-int PyStruct_init( PyStruct * self, PyObject * args, PyObject * kwargs, bool validate )
+int PyStruct_init( PyStruct * self, PyObject * args, PyObject * kwargs )
 {
     CSP_BEGIN_METHOD;
 
     PyStruct_setattrs( self, args, kwargs, "__init__" );
-    if( validate )
-    {
-        PyObject * rv = PyStruct_validate( self );
-        if( !rv )
-            return -1;
-        Py_DECREF( rv );
-    }
+    self -> struct_ -> validate();
 
     CSP_RETURN_INT;
 }
 
-static int PyStruct_init_validated( PyStruct * self, PyObject * args, PyObject * kwargs )
-{
-    return PyStruct_init( self, args, kwargs, true );
-}
-
 PyObject * PyStruct_update( PyStruct * self, PyObject * args, PyObject * kwargs )
 {
     CSP_BEGIN_METHOD;
@@ -1060,7 +1029,6 @@ static PyMethodDef PyStruct_methods[] = {
     { "update_from",    (PyCFunction) PyStruct_update_from,    METH_O,      "update from struct. struct must be same type or a derived type. unset fields will be not be copied" },
     { "update",         (PyCFunction) PyStruct_update,         METH_VARARGS | METH_KEYWORDS, "update from key=val.  given fields will be set on struct.  other fields will remain as is in struct" },
     { "all_fields_set", (PyCFunction) PyStruct_all_fields_set, METH_NOARGS, "return true if all fields on the struct are set" },
-    { "validate",       (PyCFunction) PyStruct_validate,       METH_NOARGS, "validate the struct (strict struct fields set, etc...)" },
     { "to_dict",        (PyCFunction) PyStruct_to_dict,        METH_VARARGS | METH_KEYWORDS, "return a python dict of the struct by recursively converting struct members into python dicts" },
     { "to_json",        (PyCFunction) PyStruct_to_json,        METH_VARARGS | METH_KEYWORDS, "return a json string of the struct by recursively converting struct members into json format" },
     { NULL}
@@ -1103,7 +1071,7 @@ PyTypeObject PyStruct::PyType = {
     0,                         /* tp_descr_get */
     0,                         /* tp_descr_set */
     0,                         /* tp_dictoffset */
-    ( initproc ) PyStruct_init_validated,  /* tp_init */
+    ( initproc ) PyStruct_init,  /* tp_init */
     PyType_GenericAlloc,       /* tp_alloc */
     ( newfunc ) PyStruct_new,    /* tp_new */
     PyObject_GC_Del,           /* tp_free */
diff --git a/csp/impl/struct.py b/csp/impl/struct.py
index 9f8a4ac56..0dec4842e 100644
--- a/csp/impl/struct.py
+++ b/csp/impl/struct.py
@@ -250,13 +250,13 @@ def _obj_from_python(cls, json, obj_type):
         elif issubclass(obj_type, Struct):
             if not isinstance(json, dict):
                 raise TypeError("Representation of struct as json is expected to be of dict type")
-            res = obj_type._unvalidated__call__()
+            obj_args = {}
             for k, v in json.items():
                 expected_type = obj_type.__full_metadata_typed__.get(k, None)
                 if expected_type is None:
                     raise KeyError(f"Unexpected key {k} for type {obj_type}")
-                setattr(res, k, cls._obj_from_python(v, expected_type))
-            res.validate()
+                obj_args[k] = cls._obj_from_python(v, expected_type)
+            res = obj_type(**obj_args)
             return res
         else:
             if isinstance(json, obj_type):

From 2af2edf77de008ad9ac64099be70f48f07bb8fc7 Mon Sep 17 00:00:00 2001
From: Simon Beyzerov <simon.beyzerov@point72.com>
Date: Wed, 13 Aug 2025 13:38:33 -0400
Subject: [PATCH 4/8] fix minor bugs in validation logic

---
 cpp/csp/engine/Struct.cpp        | 49 ++++++++++++++++----------------
 csp/impl/wiring/edge.py          |  5 ++--
 csp/tests/test_strict_structs.py | 28 +++++-------------
 3 files changed, 35 insertions(+), 47 deletions(-)

diff --git a/cpp/csp/engine/Struct.cpp b/cpp/csp/engine/Struct.cpp
index 3fe45b1ea..e9306bb93 100644
--- a/cpp/csp/engine/Struct.cpp
+++ b/cpp/csp/engine/Struct.cpp
@@ -131,6 +131,18 @@ StructMeta::StructMeta( const std::string & name, const Fields & fields, bool is
         if( !rv.second )
             CSP_THROW( ValueError, "csp Struct " << name << " attempted to add existing field " << m_fields[ idx ] -> fieldname() );
     }
+    
+    // A non-strict struct may not inherit (directly or indirectly) from a strict base
+    bool encountered_non_strict = false;
+    for ( const StructMeta * cur = this; cur; cur = cur -> m_base.get() )
+    {
+        encountered_non_strict |= !cur -> isStrict();
+        if ( encountered_non_strict && cur -> isStrict() )
+            CSP_THROW( ValueError, 
+                    "Strict '" << m_name 
+                    << "' has non-strict inheritance of strict base '" 
+                    << cur -> name() << "'" );
+    }
 }
 
 StructMeta::~StructMeta()
@@ -498,40 +510,29 @@ void StructMeta::destroy( Struct * s ) const
 }
 
 void StructMeta::validate( const Struct * s ) const
-{
-    bool encountered_non_strict = false;
-    
+{    
     for ( const StructMeta * cur = this; cur; cur = cur -> m_base.get() )
     {
-        encountered_non_strict |= !cur -> isStrict();
         if ( !cur -> isStrict() )
             continue;
-        
-        // Rule 1: A non-strict struct may not inherit (directly or indirectly) from a strict base
-        if ( encountered_non_strict )
-            CSP_THROW( ValueError, 
-                    "Struct '" << s -> meta() -> name() 
-                    << "' has non-strict inheritance of strict base '" 
-                    << cur -> name() << "'" );
 
-        // Rule 2: All local fields are set
-        std::string missing_fields;
-        for ( const auto & field : cur -> m_fields )
+        if ( !cur -> allFieldsSet( s ) )
         {
-            if ( !field -> isSet( s ) )
+            std::string missing_fields;
+            for ( const auto & field : cur -> m_fields )
             {
-                if ( missing_fields.empty() )
-                    missing_fields = field -> fieldname();
-                else
-                    missing_fields += ", " + field -> fieldname();
+                if ( !field -> isSet( s ) )
+                {
+                    if ( missing_fields.empty() )
+                        missing_fields = field -> fieldname();
+                    else
+                        missing_fields += ", " + field -> fieldname();
+                }
             }
-        }
-        
-        // Raise error if any fields are missing
-        if ( !missing_fields.empty() )
             CSP_THROW( ValueError, 
-                    "Strict struct '" << cur -> name() 
+                    "Strict struct '" << s -> meta() -> name() 
                     << "' missing required fields: " << missing_fields );
+        }
     }
 }
 
diff --git a/csp/impl/wiring/edge.py b/csp/impl/wiring/edge.py
index a33570149..8ebf460e7 100644
--- a/csp/impl/wiring/edge.py
+++ b/csp/impl/wiring/edge.py
@@ -202,9 +202,10 @@ def __getattr__(self, key):
             elemtype = typ.metadata(typed=True).get(key)
             if elemtype is None:
                 raise AttributeError("'%s' object has no attribute '%s'" % (self.tstype.typ.__name__, key))
-            if key in typ.optional_fields():
+            if (key in typ.optional_fields()) and (typ.is_strict()):
                 raise AttributeError(
-                    "Cannot access optional field '%s' on object '%s' at graph time" % (key, self.tstype.typ.__name__)
+                    "Cannot access optional field '%s' on strict struct object '%s' at graph time"
+                    % (key, self.tstype.typ.__name__)
                 )
             return csp.struct_field(self, key, elemtype)
 
diff --git a/csp/tests/test_strict_structs.py b/csp/tests/test_strict_structs.py
index 769584354..9d93dc414 100644
--- a/csp/tests/test_strict_structs.py
+++ b/csp/tests/test_strict_structs.py
@@ -142,7 +142,7 @@ def g_fail():
 
         with self.assertRaisesRegex(
             AttributeError,
-            "Cannot access optional field 'opt_str' on object 'MyStrictStruct' at graph time",
+            "Cannot access optional field 'opt_str' on strict struct object 'MyStrictStruct' at graph time",
         ):
             csp.run(g_fail, starttime=datetime(2023, 1, 1))
 
@@ -264,23 +264,10 @@ def test_nonstrict_cannot_inherit_strict(self):
         class StrictBase(csp.Struct, allow_unset=False):
             base_val: int
 
-        class NonStrictChild1(StrictBase, allow_unset=True):
-            child_val1: Optional[int] = None
-
-        class NonStrictChild2(NonStrictChild1, allow_unset=True):
-            child_val2: Optional[int] = None
-
-        class NonStrictChild3(NonStrictChild2, allow_unset=True):
-            child_val3: Optional[int] = None
-
-        with self.assertRaisesRegex(ValueError, "non-strict inheritance of strict base"):
-            NonStrictChild1(base_val=1, child_val1=2)
-
         with self.assertRaisesRegex(ValueError, "non-strict inheritance of strict base"):
-            NonStrictChild2(base_val=3, child_val1=4, child_val2=5)
 
-        with self.assertRaisesRegex(ValueError, "non-strict inheritance of strict base"):
-            NonStrictChild3(base_val=6, child_val1=7, child_val2=8, child_val3=9)
+            class NonStrictChild1(StrictBase, allow_unset=True):
+                child_val1: Optional[int] = None
 
     def test_nonstrict_strict_nonstrict_inheritance_order(self):
         """inheritance order NonStrict -> Strict -> NonStrict raises an error"""
@@ -291,11 +278,10 @@ class NonStrictBase(csp.Struct, allow_unset=True):
         class StrictMiddle(NonStrictBase, allow_unset=False):
             middle_val: int
 
-        class NonStrictChild(StrictMiddle, allow_unset=True):
-            child_val: Optional[int] = None
-
         with self.assertRaisesRegex(ValueError, "non-strict inheritance of strict base"):
-            NonStrictChild(base_val=1, middle_val=2, child_val=3)
+
+            class NonStrictChild(StrictMiddle, allow_unset=True):
+                child_val: Optional[int] = None
 
     def test_nested_struct_serialization(self):
         """to_dict / from_dict work with nested strict & non-strict structs"""
@@ -344,7 +330,7 @@ def main_graph():
             csp.print("", res)
 
         with self.assertRaisesRegex(
-            AttributeError, "Cannot access optional field 'is_active' on object 'Test' at graph time"
+            AttributeError, "Cannot access optional field 'is_active' on strict struct object 'Test' at graph time"
         ):
             csp.build_graph(main_graph)
 

From 685bf7365c6cbde85c49e6f88fd6b91ee84cef89 Mon Sep 17 00:00:00 2001
From: Simon Beyzerov <simon.beyzerov@point72.com>
Date: Thu, 14 Aug 2025 16:44:36 -0400
Subject: [PATCH 5/8] nodiscard bool on validate

Signed-off-by: Simon Beyzerov <simon.beyzerov@point72.com>
---
 cpp/csp/adapters/kafka/KafkaInputAdapter.cpp  |  4 +-
 .../parquet/ParquetReaderColumnAdapter.cpp    |  3 +-
 .../utils/JSONMessageStructConverter.cpp      |  3 +-
 .../adapters/websocket/ClientInputAdapter.cpp |  3 +-
 cpp/csp/cppnodes/baselibimpl.cpp              |  9 +++-
 cpp/csp/engine/Struct.cpp                     | 23 +++------
 cpp/csp/engine/Struct.h                       |  6 +--
 cpp/csp/python/PyStruct.cpp                   |  9 +---
 csp/tests/test_strict_structs.py              | 50 +++++++++++++------
 9 files changed, 63 insertions(+), 47 deletions(-)

diff --git a/cpp/csp/adapters/kafka/KafkaInputAdapter.cpp b/cpp/csp/adapters/kafka/KafkaInputAdapter.cpp
index 6cbeb8335..bbef00584 100644
--- a/cpp/csp/adapters/kafka/KafkaInputAdapter.cpp
+++ b/cpp/csp/adapters/kafka/KafkaInputAdapter.cpp
@@ -113,7 +113,9 @@ void KafkaInputAdapter::processMessage( RdKafka::Message* message, bool live, cs
         if( m_tickTimestampField )
             msgTime = m_tickTimestampField->value<DateTime>(tick.get());
 
-        tick.get() -> validate();
+        if (!tick.get() -> validate())
+            CSP_THROW( ValueError, "Struct validation failed for Kafka message, fields missing" );
+        
 
         bool pushLive = shouldPushLive(live, msgTime);
         if( shouldProcessMessage( pushLive, msgTime ) )
diff --git a/cpp/csp/adapters/parquet/ParquetReaderColumnAdapter.cpp b/cpp/csp/adapters/parquet/ParquetReaderColumnAdapter.cpp
index 73837d0cb..b62b13a2d 100644
--- a/cpp/csp/adapters/parquet/ParquetReaderColumnAdapter.cpp
+++ b/cpp/csp/adapters/parquet/ParquetReaderColumnAdapter.cpp
@@ -520,7 +520,8 @@ void ParquetStructAdapter::dispatchValue( const utils::Symbol *symbol, bool isNu
         {
             fieldSetter( s );
         }
-        s -> validate();
+        if (!s -> validate())
+            CSP_THROW( ValueError, "Struct validation failed for Parquet message, some fields are missing" );
         dispatchedValue = &s;
     }
 
diff --git a/cpp/csp/adapters/utils/JSONMessageStructConverter.cpp b/cpp/csp/adapters/utils/JSONMessageStructConverter.cpp
index 5f81b2aac..585b3ee6d 100644
--- a/cpp/csp/adapters/utils/JSONMessageStructConverter.cpp
+++ b/cpp/csp/adapters/utils/JSONMessageStructConverter.cpp
@@ -145,7 +145,8 @@ StructPtr JSONMessageStructConverter::convertJSON( const char * fieldname, const
             } );
     }
 
-    struct_ -> validate();
+    if( !struct_ -> validate() )
+        CSP_THROW( ValueError, "JSON conversion of struct " << sType.meta() -> name() << " failed; some required fields were not set" );
 
     return struct_;
 }
diff --git a/cpp/csp/adapters/websocket/ClientInputAdapter.cpp b/cpp/csp/adapters/websocket/ClientInputAdapter.cpp
index d413b9dd1..b727341ed 100644
--- a/cpp/csp/adapters/websocket/ClientInputAdapter.cpp
+++ b/cpp/csp/adapters/websocket/ClientInputAdapter.cpp
@@ -31,7 +31,8 @@ void ClientInputAdapter::processMessage( void* c, size_t t, PushBatch* batch )
     if( dataType() -> type() == CspType::Type::STRUCT )
     {
         auto tick = m_converter -> asStruct( c, t );
-        tick.get() -> validate();
+        if (!tick.get() -> validate())
+            CSP_THROW( ValueError, "Struct validation failed for WebSocket message, fields missing" );
         pushTick( std::move(tick), batch );
     } else if ( dataType() -> type() == CspType::Type::STRING )
     {
diff --git a/cpp/csp/cppnodes/baselibimpl.cpp b/cpp/csp/cppnodes/baselibimpl.cpp
index 9f4e1636f..5530bb446 100644
--- a/cpp/csp/cppnodes/baselibimpl.cpp
+++ b/cpp/csp/cppnodes/baselibimpl.cpp
@@ -705,7 +705,9 @@ DECLARE_CPPNODE( struct_fromts )
                 );
         }
 
-        out.get() -> validate( );
+        if( !out.get() -> validate( ) )
+            CSP_THROW( ValueError, "Struct " << cls.value() -> name() << " is not valid; some required fields did not tick" );
+
         CSP_OUTPUT( std::move( out ) );
     }
 
@@ -759,7 +761,10 @@ DECLARE_CPPNODE( struct_collectts )
                            }
                 );
         }
-        out.get() -> validate( );
+        
+        if( !out.get() -> validate( ) )
+            CSP_THROW( ValueError, "Struct " << cls.value() -> name() << " is not valid; some required fields did not tick" );
+
         CSP_OUTPUT( std::move( out ) );
     }
 
diff --git a/cpp/csp/engine/Struct.cpp b/cpp/csp/engine/Struct.cpp
index e9306bb93..877b6592f 100644
--- a/cpp/csp/engine/Struct.cpp
+++ b/cpp/csp/engine/Struct.cpp
@@ -509,31 +509,20 @@ void StructMeta::destroy( Struct * s ) const
         m_base -> destroy( s );
 }
 
-void StructMeta::validate( const Struct * s ) const
+[[nodiscard]] bool StructMeta::validate( const Struct * s ) const
 {    
     for ( const StructMeta * cur = this; cur; cur = cur -> m_base.get() )
     {
         if ( !cur -> isStrict() )
             continue;
 
+        // Note that we do not recursively validate nested struct.
+        // We assume after any creation on the C++ side, these structs 
+        // are validated properly prior to being set as field values 
         if ( !cur -> allFieldsSet( s ) )
-        {
-            std::string missing_fields;
-            for ( const auto & field : cur -> m_fields )
-            {
-                if ( !field -> isSet( s ) )
-                {
-                    if ( missing_fields.empty() )
-                        missing_fields = field -> fieldname();
-                    else
-                        missing_fields += ", " + field -> fieldname();
-                }
-            }
-            CSP_THROW( ValueError, 
-                    "Strict struct '" << s -> meta() -> name() 
-                    << "' missing required fields: " << missing_fields );
-        }
+            return false;
     }
+    return true;
 }
 
 
diff --git a/cpp/csp/engine/Struct.h b/cpp/csp/engine/Struct.h
index ae8485f95..844b6c666 100644
--- a/cpp/csp/engine/Struct.h
+++ b/cpp/csp/engine/Struct.h
@@ -611,7 +611,7 @@ class StructMeta : public std::enable_shared_from_this<StructMeta>
     size_t maskLoc() const                    { return m_maskLoc; }
     size_t maskSize() const                   { return m_maskSize; }
 
-    void validate( const Struct * s ) const;
+    [[nodiscard]] bool validate( const Struct * s ) const;
 
     const StructFieldPtr & field( const char * name ) const
     {
@@ -750,9 +750,9 @@ class Struct
         return meta() -> allFieldsSet( this );
     }
 
-    void validate() const
+    [[nodiscard]] bool validate() const
     {
-        meta() -> validate( this );
+        return meta() -> validate( this );
     }
 
 
diff --git a/cpp/csp/python/PyStruct.cpp b/cpp/csp/python/PyStruct.cpp
index 016265ede..41849a073 100644
--- a/cpp/csp/python/PyStruct.cpp
+++ b/cpp/csp/python/PyStruct.cpp
@@ -810,18 +810,13 @@ void PyStruct_setattrs( PyStruct * self, PyObject * args, PyObject * kwargs, con
     }
 }
 
-PyObject * PyStruct_validate( PyStruct * self ) {
-    CSP_BEGIN_METHOD
-    self -> struct_ -> validate();
-    CSP_RETURN_NONE;
-}
-
 int PyStruct_init( PyStruct * self, PyObject * args, PyObject * kwargs )
 {
     CSP_BEGIN_METHOD;
 
     PyStruct_setattrs( self, args, kwargs, "__init__" );
-    self -> struct_ -> validate();
+    if( !self -> struct_ -> validate() )
+        CSP_THROW( ValueError, "Struct " << self -> struct_ -> meta() -> name() << " is not valid; some required fields were not set on init" );
 
     CSP_RETURN_INT;
 }
diff --git a/csp/tests/test_strict_structs.py b/csp/tests/test_strict_structs.py
index 9d93dc414..f8c4ffd6d 100644
--- a/csp/tests/test_strict_structs.py
+++ b/csp/tests/test_strict_structs.py
@@ -45,14 +45,18 @@ class MyStrictStruct(csp.Struct, allow_unset=False):
         self.assertIsNone(s1.opt_str_2)
 
         # Error on missing required fields
-        with self.assertRaisesRegex(ValueError, "Strict struct 'MyStrictStruct' missing required fields: req_int"):
+        with self.assertRaisesRegex(
+            ValueError, "Struct MyStrictStruct is not valid; some required fields were not set on init"
+        ):
             MyStrictStruct(opt_str="world")
 
-        with self.assertRaisesRegex(ValueError, "Strict struct 'MyStrictStruct' missing required fields: opt_str"):
+        with self.assertRaisesRegex(
+            ValueError, "Struct MyStrictStruct is not valid; some required fields were not set on init"
+        ):
             MyStrictStruct(req_int=1)
 
         with self.assertRaisesRegex(
-            ValueError, "Strict struct 'MyStrictStruct' missing required fields: opt_str, req_int"
+            ValueError, "Struct MyStrictStruct is not valid; some required fields were not set on init"
         ):
             MyStrictStruct()
 
@@ -101,7 +105,7 @@ class MyStrictStruct(csp.Struct, allow_unset=False):
         self.assertEqual(s.to_dict(), expected_dict)
 
         with self.assertRaisesRegex(
-            ValueError, "Strict struct 'MyStrictStruct' missing required fields: req_opt_str, req_int"
+            ValueError, "Struct MyStrictStruct is not valid; some required fields were not set on init"
         ):
             MyStrictStruct.from_dict({"opt_str": "hello", "def_int": 13})
 
@@ -169,7 +173,9 @@ def g():
             s_ts = MyStrictStruct.fromts(req_int1=ts1, req_int2=ts2)
             csp.add_graph_output("output", s_ts)
 
-        with self.assertRaisesRegex(ValueError, "Strict struct 'MyStrictStruct' missing required fields: req_int2"):
+        with self.assertRaisesRegex(
+            ValueError, "Struct MyStrictStruct is not valid; some required fields did not tick"
+        ):
             csp.run(g, starttime=datetime(2023, 1, 1))
 
         @csp.graph
@@ -208,9 +214,13 @@ class DerivedStrict(BaseStrict, allow_unset=False):
         self.assertEqual(d_ok.base_req, 1)
         self.assertEqual(d_ok.derived_req, 2)
 
-        with self.assertRaisesRegex(ValueError, "Strict struct 'DerivedStrict' missing required fields: derived_req"):
+        with self.assertRaisesRegex(
+            ValueError, "Struct DerivedStrict is not valid; some required fields were not set on init"
+        ):
             DerivedStrict(base_req=10)
-        with self.assertRaisesRegex(ValueError, "Strict struct 'DerivedStrict' missing required fields: base_req"):
+        with self.assertRaisesRegex(
+            ValueError, "Struct DerivedStrict is not valid; some required fields were not set on init"
+        ):
             DerivedStrict(derived_req=20)
 
         # loose base & strict child:
@@ -224,12 +234,16 @@ class StrictChild(LooseBase, allow_unset=False):
         self.assertEqual(sc_ok.child_req, 5)
 
         with self.assertRaisesRegex(
-            ValueError, "Strict struct 'StrictChild' missing required fields: loose_req, child_req"
+            ValueError, "Struct StrictChild is not valid; some required fields were not set on init"
         ):
             StrictChild()
-        with self.assertRaisesRegex(ValueError, "Strict struct 'StrictChild' missing required fields: child_req"):
+        with self.assertRaisesRegex(
+            ValueError, "Struct StrictChild is not valid; some required fields were not set on init"
+        ):
             StrictChild(loose_req=10)
-        with self.assertRaisesRegex(ValueError, "Strict struct 'StrictChild' missing required fields: loose_req"):
+        with self.assertRaisesRegex(
+            ValueError, "Struct StrictChild is not valid; some required fields were not set on init"
+        ):
             StrictChild(child_req=5)
 
         # nested struct fields:
@@ -242,7 +256,9 @@ class OuterStrict(csp.Struct, allow_unset=False):
         os_ok = OuterStrict(inner=InnerStrict(val=42))
         self.assertEqual(os_ok.inner.val, 42)
 
-        with self.assertRaisesRegex(ValueError, "Strict struct 'InnerStrict' missing required fields: val"):
+        with self.assertRaisesRegex(
+            ValueError, "Struct InnerStrict is not valid; some required fields were not set on init"
+        ):
             OuterStrict(inner=InnerStrict())
 
         # nested loose struct inside strict:
@@ -255,7 +271,9 @@ class OuterStrict2(csp.Struct, allow_unset=False):
         ol_ok = OuterStrict2(inner=InnerLoose())
         self.assertIsInstance(ol_ok.inner, InnerLoose)
 
-        with self.assertRaisesRegex(ValueError, "Strict struct 'OuterStrict2' missing required fields: inner"):
+        with self.assertRaisesRegex(
+            ValueError, "Struct OuterStrict2 is not valid; some required fields were not set on init"
+        ):
             OuterStrict2()
 
     def test_nonstrict_cannot_inherit_strict(self):
@@ -305,10 +323,14 @@ class OuterStruct(csp.Struct, allow_unset=False):
         self.assertIsNotNone(o2.loose_inner)
         self.assertEqual(o2.loose_inner.y, 20)
 
-        with self.assertRaisesRegex(ValueError, "Strict struct 'OuterStruct' missing required fields: strict_inner"):
+        with self.assertRaisesRegex(
+            ValueError, "Struct OuterStruct is not valid; some required fields were not set on init"
+        ):
             OuterStruct.from_dict({"loose_inner": {"y": 1}})
 
-        with self.assertRaisesRegex(ValueError, "Strict struct 'InnerStrict' missing required fields: x"):
+        with self.assertRaisesRegex(
+            ValueError, "Struct InnerStrict is not valid; some required fields were not set on init"
+        ):
             OuterStruct.from_dict({"strict_inner": {}, "loose_inner": {"y": None}})
 
     def test_strict_struct_wiring_access_2(self):

From a8751cff764a2677119b2e9b732b51a2faede30b Mon Sep 17 00:00:00 2001
From: Simon Beyzerov <simon.beyzerov@point72.com>
Date: Thu, 14 Aug 2025 16:57:47 -0400
Subject: [PATCH 6/8] validate autogen'ed dynamic structs

Signed-off-by: Simon Beyzerov <simon.beyzerov@point72.com>
---
 cpp/csp/engine/BasketInfo.cpp | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/cpp/csp/engine/BasketInfo.cpp b/cpp/csp/engine/BasketInfo.cpp
index f43e425e9..327ecec66 100644
--- a/cpp/csp/engine/BasketInfo.cpp
+++ b/cpp/csp/engine/BasketInfo.cpp
@@ -161,6 +161,8 @@ void DynamicOutputBasketInfo::addShapeChange( const DialectGenericType & key, bo
     {
         auto events = autogen::DynamicBasketEvents::create();
         events -> set_events( {} );
+        if( !events -> validate() )
+            CSP_THROW( ValueError, "DynamicBasketEvents struct is not valid; some required fields were not set" );
         m_shapeTs.outputTickTyped<StructPtr>( m_parentNode -> rootEngine() -> cycleCount(), 
                                               m_parentNode -> rootEngine() -> now(), 
                                               events, false );
@@ -171,6 +173,8 @@ void DynamicOutputBasketInfo::addShapeChange( const DialectGenericType & key, bo
     auto event = autogen::DynamicBasketEvent::create();
     event -> set_key( key );
     event -> set_added( added );
+    if( !event -> validate() )
+        CSP_THROW( ValueError, "DynamicBasketEvent struct is not valid; some required fields were not set" );
 
     const_cast<std::vector<autogen::DynamicBasketEvent::Ptr> &>( events ).emplace_back( event );
 }

From 6816484bdbfb7d4063fe664c2741923d1f48c5a3 Mon Sep 17 00:00:00 2001
From: Simon Beyzerov <simon.beyzerov@point72.com>
Date: Thu, 14 Aug 2025 17:06:01 -0400
Subject: [PATCH 7/8] disallow non-defaulted optional fields on strict structs

Signed-off-by: Simon Beyzerov <simon.beyzerov@point72.com>
---
 cpp/csp/engine/Struct.cpp        |  3 +--
 cpp/csp/engine/Struct.h          |  8 --------
 cpp/csp/python/PyStruct.cpp      |  4 ----
 csp/impl/struct.py               |  2 ++
 csp/tests/test_strict_structs.py | 28 +++++++++++++---------------
 5 files changed, 16 insertions(+), 29 deletions(-)

diff --git a/cpp/csp/engine/Struct.cpp b/cpp/csp/engine/Struct.cpp
index 877b6592f..3b501036b 100644
--- a/cpp/csp/engine/Struct.cpp
+++ b/cpp/csp/engine/Struct.cpp
@@ -16,8 +16,7 @@ StructField::StructField( CspTypePtr type, const std::string & fieldname,
     m_maskOffset( 0 ),
     m_maskBit( 0 ),
     m_maskBitMask( 0 ),
-    m_type( type ),
-    m_isOptional( 1 )
+    m_type( type )
 {
 }
 
diff --git a/cpp/csp/engine/Struct.h b/cpp/csp/engine/Struct.h
index 844b6c666..f3b0b63bf 100644
--- a/cpp/csp/engine/Struct.h
+++ b/cpp/csp/engine/Struct.h
@@ -35,8 +35,6 @@ class StructField
 
     bool isNative() const                 { return m_type -> type() <= CspType::Type::MAX_NATIVE_TYPE; }
 
-    bool isOptional() const               { return m_isOptional; }
-
     void setOffset( size_t off )          { m_offset = off; }
     void setMaskOffset( size_t off, uint8_t bit  )
     {
@@ -47,11 +45,6 @@ class StructField
         m_maskBitMask = 1 << bit;
     }
 
-    void setRequired()
-    {
-        m_isOptional = false;
-    }
-
     bool isSet( const Struct * s ) const
     {
         const uint8_t * m = reinterpret_cast<const uint8_t *>( s ) + m_maskOffset;
@@ -115,7 +108,6 @@ class StructField
     uint8_t      m_maskBit;
     uint8_t      m_maskBitMask;
     CspTypePtr   m_type;
-    bool         m_isOptional;
 };
 
 using StructFieldPtr = std::shared_ptr<StructField>;
diff --git a/cpp/csp/python/PyStruct.cpp b/cpp/csp/python/PyStruct.cpp
index 41849a073..9fedd486d 100644
--- a/cpp/csp/python/PyStruct.cpp
+++ b/cpp/csp/python/PyStruct.cpp
@@ -122,7 +122,6 @@ static PyObject * PyStructMeta_new( PyTypeObject *subtype, PyObject *args, PyObj
             if (!PySet_Check(optional_fields)) 
                 CSP_THROW( TypeError, "Struct metadata for key " << keystr << " expected a set, got " << PyObjectPtr::incref( optional_fields ) );
 
-            bool isOptional = PySet_Contains( optional_fields, key ) == 1;
 
             if( !PyType_Check( type ) && !PyList_Check( type ) )
                 CSP_THROW( TypeError, "Struct metadata for key " << keystr << " expected a type, got " << PyObjectPtr::incref( type ) );
@@ -160,9 +159,6 @@ static PyObject * PyStructMeta_new( PyTypeObject *subtype, PyObject *args, PyObj
                     CSP_THROW( ValueError, "Unexpected csp type " << csptype -> type() << " on struct " << name );
             }
             
-            if ( !isOptional )
-                field -> setRequired( );
-
             fields.emplace_back( field );
         }
     }
diff --git a/csp/impl/struct.py b/csp/impl/struct.py
index 0dec4842e..f1580434a 100644
--- a/csp/impl/struct.py
+++ b/csp/impl/struct.py
@@ -37,6 +37,8 @@ def __new__(cls, name, bases, dct, allow_unset=True):
                 if v == FastList:
                     raise TypeError(f"{v} annotation is not supported without args")
                 if CspTypingUtils.is_optional_type(v):
+                    if (not allow_unset) and (k not in dct):
+                        raise TypeError(f"Optional field {k} must have a default value")
                     optional_fields.add(k)
                 if (
                     CspTypingUtils.is_generic_container(v)
diff --git a/csp/tests/test_strict_structs.py b/csp/tests/test_strict_structs.py
index f8c4ffd6d..817ec7d2b 100644
--- a/csp/tests/test_strict_structs.py
+++ b/csp/tests/test_strict_structs.py
@@ -33,7 +33,7 @@ def test_strict_struct_initialization(self):
 
         class MyStrictStruct(csp.Struct, allow_unset=False):
             req_int: int
-            opt_str: Optional[str]
+            opt_str: Optional[str] = None
             def_int: int = 123
             opt_str_2: Optional[str] = None
 
@@ -44,17 +44,6 @@ class MyStrictStruct(csp.Struct, allow_unset=False):
         self.assertEqual(s1.def_int, 123)
         self.assertIsNone(s1.opt_str_2)
 
-        # Error on missing required fields
-        with self.assertRaisesRegex(
-            ValueError, "Struct MyStrictStruct is not valid; some required fields were not set on init"
-        ):
-            MyStrictStruct(opt_str="world")
-
-        with self.assertRaisesRegex(
-            ValueError, "Struct MyStrictStruct is not valid; some required fields were not set on init"
-        ):
-            MyStrictStruct(req_int=1)
-
         with self.assertRaisesRegex(
             ValueError, "Struct MyStrictStruct is not valid; some required fields were not set on init"
         ):
@@ -65,7 +54,7 @@ def test_strict_struct_hasattr_delattr(self):
 
         class MyStrictStruct1(csp.Struct, allow_unset=False):
             req_int: int
-            opt_str: Optional[str]
+            opt_str: Optional[str] = None
 
         class MyStrictStruct2(csp.Struct, allow_unset=False):
             req_int: int
@@ -98,7 +87,7 @@ class MyStrictStruct(csp.Struct, allow_unset=False):
             req_int: int
             opt_str: Optional[str] = None
             def_int: int = 100
-            req_opt_str: Optional[str]
+            req_opt_str: Optional[str] = None
 
         s = MyStrictStruct(req_int=50, req_opt_str="NoneStr")
         expected_dict = {"req_int": 50, "opt_str": None, "def_int": 100, "req_opt_str": "NoneStr"}
@@ -337,7 +326,7 @@ def test_strict_struct_wiring_access_2(self):
         class Test(csp.Struct, allow_unset=False):
             name: str
             age: int
-            is_active: Optional[bool]
+            is_active: Optional[bool] = None
 
             def greet(self):
                 return f"Hello, my name is {self.name} and I am {self.age} years old."
@@ -356,6 +345,15 @@ def main_graph():
         ):
             csp.build_graph(main_graph)
 
+    def test_strict_struct_optional_field_validation_no_default(self):
+        """test that strict structs cannot have Optional fields without defaults"""
+
+        with self.assertRaisesRegex(TypeError, "Optional field bad_field must have a default value"):
+
+            class InvalidStrictStruct(csp.Struct, allow_unset=False):
+                req_field: int
+                bad_field: Optional[str]
+
 
 if __name__ == "__main__":
     unittest.main()

From 2603e737a9a044bc1b87574d0ac00cd6e85f31d1 Mon Sep 17 00:00:00 2001
From: Simon Beyzerov <simon.beyzerov@point72.com>
Date: Fri, 15 Aug 2025 16:17:43 -0400
Subject: [PATCH 8/8] catch adapter exceptions

Signed-off-by: Simon Beyzerov <simon.beyzerov@point72.com>
---
 .../adapters/parquet/ParquetReaderColumnAdapter.cpp   |  5 +++--
 cpp/csp/adapters/websocket/ClientAdapterManager.cpp   | 11 +++++++++--
 2 files changed, 12 insertions(+), 4 deletions(-)

diff --git a/cpp/csp/adapters/parquet/ParquetReaderColumnAdapter.cpp b/cpp/csp/adapters/parquet/ParquetReaderColumnAdapter.cpp
index b62b13a2d..f95ff6704 100644
--- a/cpp/csp/adapters/parquet/ParquetReaderColumnAdapter.cpp
+++ b/cpp/csp/adapters/parquet/ParquetReaderColumnAdapter.cpp
@@ -520,8 +520,9 @@ void ParquetStructAdapter::dispatchValue( const utils::Symbol *symbol, bool isNu
         {
             fieldSetter( s );
         }
-        if (!s -> validate())
-            CSP_THROW( ValueError, "Struct validation failed for Parquet message, some fields are missing" );
+        
+        CSP_TRUE_OR_THROW_RUNTIME( s -> validate(), "Struct validation failed for Parquet message, some fields are missing" );
+        
         dispatchedValue = &s;
     }
 
diff --git a/cpp/csp/adapters/websocket/ClientAdapterManager.cpp b/cpp/csp/adapters/websocket/ClientAdapterManager.cpp
index 423f2a234..e472357d8 100644
--- a/cpp/csp/adapters/websocket/ClientAdapterManager.cpp
+++ b/cpp/csp/adapters/websocket/ClientAdapterManager.cpp
@@ -52,8 +52,15 @@ void ClientAdapterManager::start( DateTime starttime, DateTime endtime )
     if( m_inputAdapter ) {
         m_endpoint -> setOnMessage(
             [ this ]( void* c, size_t t ) {
-                PushBatch batch( m_engine -> rootEngine() );
-                m_inputAdapter -> processMessage( c, t, &batch );
+                try
+                {
+                    PushBatch batch( m_engine -> rootEngine() );
+                    m_inputAdapter -> processMessage( c, t, &batch );
+                }
+                catch( csp::Exception & err )
+                {
+                    pushStatus( StatusLevel::ERROR, ClientStatusType::GENERIC_ERROR, err.what() );
+                }
             }
         );
     } else {