Event_Generation.go

func get_events(account_count int, event_count int) []Event {
	events := make([]Event, 0, account_count*event_count)
	event_counter := make(map[string]int)
	for i := 0; i < account_count*event_count; i++ {
		keyA := string(97 + rand.Intn(account_count-1))
		keyB := string(97 + rand.Intn(account_count-1))
		for {
			if keyA != keyB {
				break
			}
			keyB = string(97 + rand.Intn(account_count-1))
		}
		_, exists := event_counter[keyA]
		if !exists {
			event_counter[keyA] = 0
		}
		_, exists = event_counter[keyB]
		if !exists {
			event_counter[keyB] = 0
		}
		event := Event{Source_key: keyA, Source_sequence_number: event_counter[keyA], Destination_key: keyB, Destination_sequence_number: event_counter[keyB]}
		event_counter[keyA] += 1
		event_counter[keyB] += 1
		events = append(events, event)
	}
	return events
}

func shuffle(events []Event) {
	rand.Seed(time.Now().UnixNano())
	rand.Shuffle(len(events), func(i, j int) { (events)[i], (events)[j] = (events)[j], (events)[i] })
}

func generate(account_count int, event_count int) []Event {
	events := get_events(account_count, event_count)
	shuffle(events)
	return events
}

func main(){
  events := generate(20, 1000)
}

Validate_Event_order.py

from dataclasses import dataclass
import json

@dataclass
class Event:
    source_key: str
    source_sequence_number: int
    destination_key: str
    destination_sequence_number: int

def test_order(l):
    keys = []
    for event in l:
        if event.source_key not in keys:
            keys.append(event.source_key)
        if event.destination_key not in keys:
            keys.append(event.destination_key)
    partitions = dict(zip(keys, [[] for _ in range(len(keys))]))

    for event in l:
        partitions[event.source_key].append(event.source_sequence_number)
        partitions[event.destination_key].append(event.destination_sequence_number)
        #print(event.source_key, event.source_sequence_number, event.destination_key, event.destination_sequence_number)

    ordered = True
    for _, value in partitions.items():
        sorted_check = value == sorted(value)
        if not sorted_check:
            ordered = False
        #print(key, sorted_check, value)
    return ordered

if __name__ == "__main__":
    with open("./sorted.json", 'r') as f:
        l = json.load(f)
    l = [Event(**x) for x in l]
    print(len(l))
    print("ordered: ", test_order(l))