2025/10/16-やったことリスト

except Exception as e:
    print("[commandName] ERROR: error message")
    print(e)

async def errorResponse(websocket,request:dict,errorMessage:str,variablesList:list,exception = None):
    print("{} ERROR: {}".format(request["command"],errorMessage))

    variableState = {}
    print("{} ERROR: variable state --------------------------".format(request["command"]))
    for aVar in variablesList:
        # print variable name and data
        # https://stackoverflow.com/questions/18425225/getting-the-name-of-a-variable-as-a-string
        # f'{aaa=}'.split("=")[0]
        varName = f'{aVar=}'.split("=")[0]
        print("{}:\n{}\n".format(varName,aVar))
        variableState[varName] = str(aVar)
    print("{} ERROR: variable state end --------------------------".format(request["command"]))
    print("{} ERROR: exception message --------------------------".format(request["command"]))
    print(exception)
    print("{} ERROR: exception message end --------------------------".format(request["command"]))

    responseString = json.dumps({
        "status"        : "error",
        "errorMessage"  : errorMessage,
        "UUID"          : request["UUID"],
        "command"       : request["command"],
        "data"          : variableState
    })
    await websocket.send(responseString)
    print(">>> " + responseString)

# arg:
#   absoluteFolderPath : full folder path to create
# return value
#   OK      : False
#   Error   : True will be returned when failed to create folder.
def mkdir(absoluteFolderPath:str):

    if(checkTheAbsolutePath(absoluteFolderPath)):
        print("mkdir helper: This is malformed path")
        print(absoluteFolderPath)
        return True

    if(platform.system() == "Windows"):
        winpath = absoluteFolderPath.replace("//","/").replace("/","\\")
        command = ["mkdir",winpath]
        print("winpath     : " + winpath)
    else:
        command = ["mkdir -p " + absoluteFolderPath]
    result = subprocess.run(command,shell=True,capture_output=True)
    print("folder path : " + absoluteFolderPath)

    if(result.returncode != 0):
        print("mkdir helper: Unable to create the folder.")
        print(str(result.stdout))
        print(str(result.stderr))
        return True

    return False

# arg:
#   absolutePath    : file or folder path
# return value
#   OK      : False will be returned.
#   Error   : True  will be returned when the path is malformed.
def checkTheAbsolutePath(absolutePath:str):
    # check the absoluteDataPath is something malisuous or not.
    if(absolutePath == "/" or absolutePath == "C:\\"):
        print("checkTheAbsolutePath: Failed. Try to delete root directory.")
        return True
    
    # check the absoluteDataPath is relative path or not.
    if(absolutePath[0] == "."):
        print("checkTheAbsolutePath: Failed. A relative path is specified. Use absolute path.")
        return True

    # check the absoluteDataPath try to delete outside content of the notebooks or not.
    isNotebookPath = False
    for aNotebookStoreRoot in loadSettings.settings["NotebookRootFolder"]:
        if(aNotebookStoreRoot in absolutePath):
            isNotebookPath = True
            break
    if(not isNotebookPath):
        print("checkTheAbsolutePath: Failed. The absoluteDataPath is outside of the notebook store.")
        return True
    
    return False

...
    variableState = {}
    print("{} ERROR: variable state --------------------------".format(request["command"]))
    for aVar in variablesList:
        # print variable name and data
        # https://stackoverflow.com/questions/18425225/getting-the-name-of-a-variable-as-a-string
        # f'{aaa=}'.split("=")[0]
        varName = f'{aVar=}'.split("=")[0]
        print("{}:\n{}\n".format(varName,aVar))
        variableState[varName] = str(aVar)
...

...
    variableState = []
    print("{} ERROR: variable state --------------------------".format(request["command"]))
    for aVar in variablesList:
        # print variable name and data
        # https://stackoverflow.com/questions/18425225/getting-the-name-of-a-variable-as-a-string
        # f'{aaa=}'.split("=")[0]
        print("{}\n".format(aVar))
        variableState.append(str(aVar))
...

// TODO: create buffer store for each page
// TODO: make all pages use the buffer store to prevent from losing the unsaved data.
// TODO: if there are unsaved buffers, ask the user to save or throw away the data before the frontend is closed.
// https://developer.mozilla.org/ja/docs/Web/JavaScript/Reference/Global_Objects/Date
// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Temporal
export type AnUnsavedBuffer = {
    notebookName        : string,
    pageID              : string,
    pageType            : string,
    UUID                : string, // to identify each buffers.
    timestamp           : Date,
    bufferContentString : string,
}

// NOTE: normally single page will add single buffer and update constantly if there are any modification.
export type unsavedBuffers = {
    buffers             : AnUnsavedBuffer[],
    addBuffer           : (unsavedBuffer:AnUnsavedBuffer) => void,
    removeBuffer        : (unsavedBuffer:AnUnsavedBuffer) => void,
    updateBuffer        : (unsavedBuffer:AnUnsavedBuffer) => void,      // not to create buffer, to update exist buffer
    getBuffers          : (pageID:string) => AnUnsavedBuffer[],
    getUnsavedPageList  : () => string[],                               // for selector compornent.
}

export const useUnsavedBuffersStore = create<unsavedBuffers>((set,get) => ({
    buffers: [],
    addBuffer: (unsavedBuffer:AnUnsavedBuffer) => {
        const oldBuffer = get().buffers
        const newBuffer = []
        for(const aBuffer of oldBuffer){
            // when the buffer has already existed, abort the update
            if(aBuffer.UUID == unsavedBuffer.UUID) return
            newBuffer.push(aBuffer) 
        }
        newBuffer.push(unsavedBuffer)
        set({buffers:newBuffer})    
    },
    removeBuffer: (unsavedBuffer:AnUnsavedBuffer) => {
        const oldBuffer = get().buffers
        const newBuffer = []
        for(const aBuffer of oldBuffer){
            if(aBuffer.UUID == unsavedBuffer.UUID) continue
            newBuffer.push(aBuffer) 
        }
        newBuffer.push(unsavedBuffer)
        set({buffers:newBuffer}) 
    },
    getBuffers: (pageID:string) => {
        const allBuffer = get().buffers
        const buffers = []
        for(const aBuffer of allBuffer){
            if(aBuffer.pageID == pageID) 
                buffers.push(aBuffer) 
        }
        return buffers
    },
    updateBuffer: (unsavedBuffer:AnUnsavedBuffer) => {
        const oldBuffer = get().buffers
        const newBuffer = []
        for(const aBuffer of oldBuffer){
            // update
            if(aBuffer.UUID == unsavedBuffer.UUID) {
                // make sure the timestamp is the time of the last modify.
                unsavedBuffer.timestamp = new Date()
                newBuffer.push(unsavedBuffer)
                continue
            }
            newBuffer.push(aBuffer) 
        }
        newBuffer.push(unsavedBuffer)
        set({buffers:newBuffer})    
    },
    getUnsavedPageList: () => {
        const buffers = get().buffers
        const pageIDlist:string[] = []

        for(const aBuffer of buffers){
            let find = false
            for(const pageIDname of pageIDlist){
                if(pageIDname == aBuffer.pageID){
                    find = true
                    break
                }
            }
            if(find) continue
            pageIDlist.push(aBuffer.pageID)
        }
        
        return pageIDlist
    }
}))