ortools.sat.cp_model_service_pb2

498  def init(self, **kwargs):
499    self._cached_byte_size = 0
500    self._cached_byte_size_dirty = len(kwargs) > 0
501    self._fields = {}
502    # Contains a mapping from oneof field descriptors to the descriptor
503    # of the currently set field in that oneof field.
504    self._oneofs = {}
505
506    # _unknown_fields is () when empty for efficiency, and will be turned into
507    # a list if fields are added.
508    self._unknown_fields = ()
509    self._is_present_in_parent = False
510    self._listener = message_listener_mod.NullMessageListener()
511    self._listener_for_children = _Listener(self)
512    for field_name, field_value in kwargs.items():
513      field = _GetFieldByName(message_descriptor, field_name)
514      if field is None:
515        raise TypeError('%s() got an unexpected keyword argument "%s"' %
516                        (message_descriptor.name, field_name))
517      if field_value is None:
518        # field=None is the same as no field at all.
519        continue
520      if field.label == _FieldDescriptor.LABEL_REPEATED:
521        field_copy = field._default_constructor(self)
522        if field.cpp_type == _FieldDescriptor.CPPTYPE_MESSAGE:  # Composite
523          if _IsMapField(field):
524            if _IsMessageMapField(field):
525              for key in field_value:
526                field_copy[key].MergeFrom(field_value[key])
527            else:
528              field_copy.update(field_value)
529          else:
530            for val in field_value:
531              if isinstance(val, dict):
532                field_copy.add(**val)
533              else:
534                field_copy.add().MergeFrom(val)
535        else:  # Scalar
536          if field.cpp_type == _FieldDescriptor.CPPTYPE_ENUM:
537            field_value = [_GetIntegerEnumValue(field.enum_type, val)
538                           for val in field_value]
539          field_copy.extend(field_value)
540        self._fields[field] = field_copy
541      elif field.cpp_type == _FieldDescriptor.CPPTYPE_MESSAGE:
542        field_copy = field._default_constructor(self)
543        new_val = None
544        if isinstance(field_value, message_mod.Message):
545          new_val = field_value
546        elif isinstance(field_value, dict):
547          if field.message_type.full_name == _StructFullTypeName:
548            field_copy.Clear()
549            if len(field_value) == 1 and 'fields' in field_value:
550              try:
551                field_copy.update(field_value)
552              except:
553                # Fall back to init normal message field
554                field_copy.Clear()
555                new_val = field.message_type._concrete_class(**field_value)
556            else:
557              field_copy.update(field_value)
558          else:
559            new_val = field.message_type._concrete_class(**field_value)
560        elif hasattr(field_copy, '_internal_assign'):
561          field_copy._internal_assign(field_value)
562        else:
563          raise TypeError(
564              'Message field {0}.{1} must be initialized with a '
565              'dict or instance of same class, got {2}.'.format(
566                  message_descriptor.name,
567                  field_name,
568                  type(field_value).__name__,
569              )
570          )
571
572        if new_val:
573          try:
574            field_copy.MergeFrom(new_val)
575          except TypeError:
576            _ReraiseTypeErrorWithFieldName(message_descriptor.name, field_name)
577        self._fields[field] = field_copy
578      else:
579        if field.cpp_type == _FieldDescriptor.CPPTYPE_ENUM:
580          field_value = _GetIntegerEnumValue(field.enum_type, field_value)
581        try:
582          setattr(self, field_name, field_value)
583        except TypeError:
584          _ReraiseTypeErrorWithFieldName(message_descriptor.name, field_name)

1361  def MergeFrom(self, msg):
1362    if not isinstance(msg, cls):
1363      raise TypeError(
1364          'Parameter to MergeFrom() must be instance of same class: '
1365          'expected %s got %s.' % (_FullyQualifiedClassName(cls),
1366                                   _FullyQualifiedClassName(msg.__class__)))
1367
1368    assert msg is not self
1369    self._Modified()
1370
1371    fields = self._fields
1372
1373    for field, value in msg._fields.items():
1374      if field.label == LABEL_REPEATED:
1375        field_value = fields.get(field)
1376        if field_value is None:
1377          # Construct a new object to represent this field.
1378          field_value = field._default_constructor(self)
1379          fields[field] = field_value
1380        field_value.MergeFrom(value)
1381      elif field.cpp_type == CPPTYPE_MESSAGE:
1382        if value._is_present_in_parent:
1383          field_value = fields.get(field)
1384          if field_value is None:
1385            # Construct a new object to represent this field.
1386            field_value = field._default_constructor(self)
1387            fields[field] = field_value
1388          field_value.MergeFrom(value)
1389      else:
1390        self._fields[field] = value
1391        if field.containing_oneof:
1392          self._UpdateOneofState(field)
1393
1394    if msg._unknown_fields:
1395      if not self._unknown_fields:
1396        self._unknown_fields = []
1397      self._unknown_fields.extend(msg._unknown_fields)

1420def _Clear(self):
1421  # Clear fields.
1422  self._fields = {}
1423  self._unknown_fields = ()
1424
1425  self._oneofs = {}
1426  self._Modified()

1486  def Modified(self):
1487    """Sets the _cached_byte_size_dirty bit to true,
1488    and propagates this to our listener iff this was a state change.
1489    """
1490
1491    # Note:  Some callers check _cached_byte_size_dirty before calling
1492    #   _Modified() as an extra optimization.  So, if this method is ever
1493    #   changed such that it does stuff even when _cached_byte_size_dirty is
1494    #   already true, the callers need to be updated.
1495    if not self._cached_byte_size_dirty:
1496      self._cached_byte_size_dirty = True
1497      self._listener_for_children.dirty = True
1498      self._is_present_in_parent = True
1499      self._listener.Modified()

1262  def IsInitialized(self, errors=None):
1263    """Checks if all required fields of a message are set.
1264
1265    Args:
1266      errors:  A list which, if provided, will be populated with the field
1267               paths of all missing required fields.
1268
1269    Returns:
1270      True iff the specified message has all required fields set.
1271    """
1272
1273    # Performance is critical so we avoid HasField() and ListFields().
1274
1275    for field in required_fields:
1276      if (field not in self._fields or
1277          (field.cpp_type == _FieldDescriptor.CPPTYPE_MESSAGE and
1278           not self._fields[field]._is_present_in_parent)):
1279        if errors is not None:
1280          errors.extend(self.FindInitializationErrors())
1281        return False
1282
1283    for field, value in list(self._fields.items()):  # dict can change size!
1284      if field.cpp_type == _FieldDescriptor.CPPTYPE_MESSAGE:
1285        if field.label == _FieldDescriptor.LABEL_REPEATED:
1286          if (field.message_type._is_map_entry):
1287            continue
1288          for element in value:
1289            if not element.IsInitialized():
1290              if errors is not None:
1291                errors.extend(self.FindInitializationErrors())
1292              return False
1293        elif value._is_present_in_parent and not value.IsInitialized():
1294          if errors is not None:
1295            errors.extend(self.FindInitializationErrors())
1296          return False
1297
1298    return True

1177  def MergeFromString(self, serialized):
1178    serialized = memoryview(serialized)
1179    length = len(serialized)
1180    try:
1181      if self._InternalParse(serialized, 0, length) != length:
1182        # The only reason _InternalParse would return early is if it
1183        # encountered an end-group tag.
1184        raise message_mod.DecodeError('Unexpected end-group tag.')
1185    except (IndexError, TypeError):
1186      # Now ord(buf[p:p+1]) == ord('') gets TypeError.
1187      raise message_mod.DecodeError('Truncated message.')
1188    except struct.error as e:
1189      raise message_mod.DecodeError(e)
1190    return length   # Return this for legacy reasons.

1130  def SerializeToString(self, **kwargs):
1131    # Check if the message has all of its required fields set.
1132    if not self.IsInitialized():
1133      raise message_mod.EncodeError(
1134          'Message %s is missing required fields: %s' % (
1135          self.DESCRIPTOR.full_name, ','.join(self.FindInitializationErrors())))
1136    return self.SerializePartialToString(**kwargs)

1143  def SerializePartialToString(self, **kwargs):
1144    out = BytesIO()
1145    self._InternalSerialize(out.write, **kwargs)
1146    return out.getvalue()

848  def ListFields(self):
849    all_fields = [item for item in self._fields.items() if _IsPresent(item)]
850    all_fields.sort(key = lambda item: item[0].number)
851    return all_fields

872  def HasField(self, field_name):
873    try:
874      field = hassable_fields[field_name]
875    except KeyError as exc:
876      raise ValueError('Protocol message %s has no non-repeated field "%s" '
877                       'nor has presence is not available for this field.' % (
878                           message_descriptor.full_name, field_name)) from exc
879
880    if isinstance(field, descriptor_mod.OneofDescriptor):
881      try:
882        return HasField(self, self._oneofs[field].name)
883      except KeyError:
884        return False
885    else:
886      if field.cpp_type == _FieldDescriptor.CPPTYPE_MESSAGE:
887        value = self._fields.get(field)
888        return value is not None and value._is_present_in_parent
889      else:
890        return field in self._fields

897  def ClearField(self, field_name):
898    try:
899      field = message_descriptor.fields_by_name[field_name]
900    except KeyError:
901      try:
902        field = message_descriptor.oneofs_by_name[field_name]
903        if field in self._oneofs:
904          field = self._oneofs[field]
905        else:
906          return
907      except KeyError:
908        raise ValueError('Protocol message %s has no "%s" field.' %
909                         (message_descriptor.name, field_name))
910
911    if field in self._fields:
912      # To match the C++ implementation, we need to invalidate iterators
913      # for map fields when ClearField() happens.
914      if hasattr(self._fields[field], 'InvalidateIterators'):
915        self._fields[field].InvalidateIterators()
916
917      # Note:  If the field is a sub-message, its listener will still point
918      #   at us.  That's fine, because the worst than can happen is that it
919      #   will call _Modified() and invalidate our byte size.  Big deal.
920      del self._fields[field]
921
922      if self._oneofs.get(field.containing_oneof, None) is field:
923        del self._oneofs[field.containing_oneof]
924
925    # Always call _Modified() -- even if nothing was changed, this is
926    # a mutating method, and thus calling it should cause the field to become
927    # present in the parent message.
928    self._Modified()

1403  def WhichOneof(self, oneof_name):
1404    """Returns the name of the currently set field inside a oneof, or None."""
1405    try:
1406      field = message_descriptor.oneofs_by_name[oneof_name]
1407    except KeyError:
1408      raise ValueError(
1409          'Protocol message has no oneof "%s" field.' % oneof_name)
1410
1411    nested_field = self._oneofs.get(field, None)
1412    if nested_field is not None and self.HasField(nested_field.name):
1413      return nested_field.name
1414    else:
1415      return None

1435def _DiscardUnknownFields(self):
1436  self._unknown_fields = []
1437  for field, value in self.ListFields():
1438    if field.cpp_type == _FieldDescriptor.CPPTYPE_MESSAGE:
1439      if _IsMapField(field):
1440        if _IsMessageMapField(field):
1441          for key in value:
1442            value[key].DiscardUnknownFields()
1443      elif field.label == _FieldDescriptor.LABEL_REPEATED:
1444        for sub_message in value:
1445          sub_message.DiscardUnknownFields()
1446      else:
1447        value.DiscardUnknownFields()

1098  def ByteSize(self):
1099    if not self._cached_byte_size_dirty:
1100      return self._cached_byte_size
1101
1102    size = 0
1103    descriptor = self.DESCRIPTOR
1104    if descriptor._is_map_entry:
1105      # Fields of map entry should always be serialized.
1106      key_field = descriptor.fields_by_name['key']
1107      _MaybeAddEncoder(cls, key_field)
1108      size = key_field._sizer(self.key)
1109      value_field = descriptor.fields_by_name['value']
1110      _MaybeAddEncoder(cls, value_field)
1111      size += value_field._sizer(self.value)
1112    else:
1113      for field_descriptor, field_value in self.ListFields():
1114        _MaybeAddEncoder(cls, field_descriptor)
1115        size += field_descriptor._sizer(field_value)
1116      for tag_bytes, value_bytes in self._unknown_fields:
1117        size += len(tag_bytes) + len(value_bytes)
1118
1119    self._cached_byte_size = size
1120    self._cached_byte_size_dirty = False
1121    self._listener_for_children.dirty = False
1122    return size

826  def FromString(s):
827    message = cls()
828    message.MergeFromString(s)
829    return message

767  def getter(self):
768    field_value = self._fields.get(field)
769    if field_value is None:
770      # Construct a new object to represent this field.
771      field_value = field._default_constructor(self)
772
773      # Atomically check if another thread has preempted us and, if not, swap
774      # in the new object we just created.  If someone has preempted us, we
775      # take that object and discard ours.
776      # WARNING:  We are relying on setdefault() being atomic.  This is true
777      #   in CPython but we haven't investigated others.  This warning appears
778      #   in several other locations in this file.
779      field_value = self._fields.setdefault(field, field_value)
780    return field_value

767  def getter(self):
768    field_value = self._fields.get(field)
769    if field_value is None:
770      # Construct a new object to represent this field.
771      field_value = field._default_constructor(self)
772
773      # Atomically check if another thread has preempted us and, if not, swap
774      # in the new object we just created.  If someone has preempted us, we
775      # take that object and discard ours.
776      # WARNING:  We are relying on setdefault() being atomic.  This is true
777      #   in CPython but we haven't investigated others.  This warning appears
778      #   in several other locations in this file.
779      field_value = self._fields.setdefault(field, field_value)
780    return field_value

1302  def FindInitializationErrors(self):
1303    """Finds required fields which are not initialized.
1304
1305    Returns:
1306      A list of strings.  Each string is a path to an uninitialized field from
1307      the top-level message, e.g. "foo.bar[5].baz".
1308    """
1309
1310    errors = []  # simplify things
1311
1312    for field in required_fields:
1313      if not self.HasField(field.name):
1314        errors.append(field.name)
1315
1316    for field, value in self.ListFields():
1317      if field.cpp_type == _FieldDescriptor.CPPTYPE_MESSAGE:
1318        if field.is_extension:
1319          name = '(%s)' % field.full_name
1320        else:
1321          name = field.name
1322
1323        if _IsMapField(field):
1324          if _IsMessageMapField(field):
1325            for key in value:
1326              element = value[key]
1327              prefix = '%s[%s].' % (name, key)
1328              sub_errors = element.FindInitializationErrors()
1329              errors += [prefix + error for error in sub_errors]
1330          else:
1331            # ScalarMaps can't have any initialization errors.
1332            pass
1333        elif field.label == _FieldDescriptor.LABEL_REPEATED:
1334          for i in range(len(value)):
1335            element = value[i]
1336            prefix = '%s[%d].' % (name, i)
1337            sub_errors = element.FindInitializationErrors()
1338            errors += [prefix + error for error in sub_errors]
1339        else:
1340          prefix = name + '.'
1341          sub_errors = value.FindInitializationErrors()
1342          errors += [prefix + error for error in sub_errors]
1343
1344    return errors