kernel

type CommClose struct {
	// CommId is a UUID that identify this "comm" channel.
	CommId string `json:"comm_id"`

	// Data  key is always a dict and can be any extra JSON information used
	// in initialization of the comm.
	Data map[string]any `json:"data"`
}

type CommInfoReply struct {
	// Status should be set to 'ok' if the request succeeded or 'error',
	// or with error information as in all other replies.
	Status string `json:"status"`

	// Comms is a dictionary of comm_id (uuids) to a dictionary of fields.
	// The only field documented is "target_name".
	Comms map[string]map[string]string `json:"comms"`
}

type CommMsg struct {
	// CommId is a UUID that identify this "comm" channel.
	CommId string `json:"comm_id"`

	// Data  key is always a dict and can be any extra JSON information used
	// in initialization of the comm.
	Data map[string]any `json:"data"`
}

type CommOpen struct {
	// CommId is a UUID that identify this new "comm" channel being opened (?).
	// Documentation is not clear how these should be used.
	CommId string `json:"comm_id"`

	// TargetName: documentation is not clear what it is, but it says:
	// - If the target_name key is not found on the receiving side,
	//   then it should immediately reply with a comm_close message to avoid an
	//   inconsistent state.
	TargetName string `json:"target_name"`

	// Data key is always a dict and can be any extra JSON information used
	// in initialization of the comm.
	Data map[string]any `json:"data"`
}

type CompleteReply struct {
	Status      string   `json:"status"`
	Matches     []string `json:"matches"`
	CursorStart int      `json:"cursor_start"`
	CursorEnd   int      `json:"cursor_end"`
	Metadata    MIMEMap  `json:"metadata"`
}

type ComposedMsg struct {
	Header       zmqMsgHeader
	ParentHeader zmqMsgHeader
	Metadata     map[string]any
	Content      any
}

type Data = struct {
	Data      MIMEMap
	Metadata  MIMEMap
	Transient MIMEMap
}

type HelpLink struct {
	Text string `json:"text"`
	URL  string `json:"url"`
}

type InspectReply struct {
	Status   string  `json:"status"`
	Found    bool    `json:"found"`
	Data     MIMEMap `json:"data"`
	Metadata MIMEMap `json:"metadata"`
}

type InterruptFn func(id SubscriptionId)

type InvalidSignatureError struct{}

type Kernel struct {

	// ExecCounter is incremented each time we run user code in the notebook.
	ExecCounter int

	// Interrupted indicates whether cell/shell currently being executed was Interrupted.
	Interrupted atomic.Bool

	// JupyterKernelId is a unique id associated to the kernel by Jupyter.
	// It's different from the id created by goexec.State to identify the temporary Go
	// code compilation.
	// The use so far, besides to match Jupyter logs, is also to create URL to websocket port
	// for the session (see `dispatcher/comm.go`).
	JupyterKernelId string

	// KnownBlockIds are display data blocks with a "display_id" that have already been created, and
	// hence should be updated (instead of created anew) in calls to PublishUpdate
	KnownBlockIds common.Set[string]
	// contains filtered or unexported fields
}

type KernelInfo struct {
	ProtocolVersion       string             `json:"protocol_version"`
	Implementation        string             `json:"implementation"`
	ImplementationVersion string             `json:"implementation_version"`
	LanguageInfo          KernelLanguageInfo `json:"language_info"`
	Banner                string             `json:"banner"`
	HelpLinks             []HelpLink         `json:"help_links"`
}

type KernelLanguageInfo struct {
	Name              string `json:"name"`
	Version           string `json:"version"`
	MIMEType          string `json:"mimetype"`
	FileExtension     string `json:"file_extension"`
	PygmentsLexer     string `json:"pygments_lexer"`
	CodeMirrorMode    string `json:"codemirror_mode"`
	NBConvertExporter string `json:"nbconvert_exporter"`
}

type MIMEMap = map[string]any

type Message interface {
	// Error returns the error receiving the message, or nil if no error.
	Error() error

	// Ok returns whether there were no errors receiving the message.
	Ok() bool

	// ComposedMsg that started the current Message -- it's contained by Message.
	ComposedMsg() ComposedMsg

	// Kernel returns reference to the Kernel connections from where this Message was created.
	Kernel() *Kernel

	// Publish creates a new ComposedMsg and sends it back to the return identities over the
	// IOPub channel.
	Publish(msgType string, content interface{}) error

	// PromptInput sends a request for input from the front-end. The text in prompt is shown
	// to the user, and password indicates whether the input is a password (input shouldn't
	// be echoed in terminal).
	//
	// onInputFn is the callback function. It receives the original shell execute
	// message (m) and the message with the incoming input value.
	PromptInput(prompt string, password bool, onInput OnInputFn) error

	// CancelInput will cancel any `input_request` message sent by PromptInput.
	CancelInput() error

	// DeliverInput should be called if a message is received in Stdin channel. It will
	// check if there is any running process listening to it, in which case it is forwarded
	// (usually to the caller of PromptInput).
	// Still the dispatcher has to handle its delivery by calling this function.
	DeliverInput() error

	// Reply creates a new ComposedMsg and sends it back to the return identities over the
	// Shell channel.
	Reply(msgType string, content interface{}) error
}

type MessageImpl struct {
	Composed   ComposedMsg
	Identities [][]byte
	// contains filtered or unexported fields
}

type MsgOrError struct {
	Msg zmq4.Msg
	Err error
}

type OnInputFn func(original, input *MessageImpl) error

type SocketGroup struct {
	ShellSocket   SyncSocket
	ControlSocket SyncSocket
	StdinSocket   SyncSocket
	IOPubSocket   SyncSocket
	HBSocket      SyncSocket
	Key           []byte
}

type SubscriptionId *list.Element

type SyncSocket struct {
	Socket zmq4.Socket
	Lock   sync.Mutex
}