Das deutsche Python-Forum

Code: Alles auswählen

import os

class Variable:
        def __init__(self, path, name, inputValue = "ValueIsNA"):
                self.executerpath = path
                self.variabledirectory = os.path.join(self.executerpath,"VariableData")
                self.name = str(name)                                                                #variable name
                self.impData()
                #the system finds out which of these actions happened, and sets itself to the corresponding value
                if inputValue == "ValueIsNA" and self.importedValue == "ValueIsNA":
                        #completely new to the system
                        self.value="ValueIsNA"
                elif inputValue != "ValueIsNA":
                        #declare a new variable
                        self.value=inputValue
                        self.save()
                elif inputValue == "ValueIsNA" and self.importedValue != "ValueIsNA":
                        #imports the variable
                        self.value=self.importedValue
                        
                
        def impData(self):                                                                       #imports variable data
                self.varNamePath = os.path.join(self.executerpath,"VariableData","varName.lcs")
                self.varDataPath = os.path.join(self.executerpath,"VariableData","varData.lcs")

                #create directories, if they don't exist
                if os.path.exists(self.variabledirectory) == False:
                        os.makedirs(self.variabledirectory)
                        self.varNameP = open(self.varNamePath, "a")
                        self.varDataP = open(self.varDataPath, "a")
                        self.varNameP.close()
                        self.varDataP.close()
                        
                self.varNameP = open(self.varNamePath,"r")
                self.varNameI = self.varNameP.readlines()
                if (self.name+"\n") in self.varNameI: #sees if a variable with this name exists
                        self.index=self.varNameI.index(self.name+"\n")
                        #finds out index and returns the value for the index			
                        self.varDataP = open(self.varDataPath,"r")
                        self.varDataI = self.varDataP.readlines()
                        self.importedValue=self.varDataI[int(self.index)]
                        self.varDataP.close()
                else:   #if variable does not exists, the return value is "ValueIsNA"
                        self.importedValue="ValueIsNA"
                        self.index="X"
                self.varNameP.close()

        def save(self): #saves the variable
                if self.index == "X":
                        #for new variables: appends it onto the end
                        self.varNameP = open(self.varNamePath,"a")
                        self.varDataP = open(self.varDataPath,"a")
                        self.varNameP.write(str(self.name )+ "\n")
                        self.varDataP.write(str(self.value)+ "\n")
                        self.varNameP.close()
                        self.varDataP.close()
                        #finds itself in the list and sets it's own index
                        self.varNameP=open(self.varNamePath,"r")
                        self.varNameI=self.varNameP.readlines()
                        self.index=self.varNameI.index(self.name+"\n")
                        self.varNameP.close()
                else:
                        #opens the file, copies the data, replaces itself and saves it again
                        self.varDataP= open(self.varDataPath,"r")
                        self.varDataRaw=self.varDataP.readlines()
                        self.varDataP.close()
                        
                        self.varDataP= open(self.varDataPath,"w")
                        self.varDataRaw[self.index]=str(self.value)+"\n"
                        self.varDataP.writelines(self.varDataRaw)
                        self.varDataP.close()
                        
        def setValue(self, value):    #sets itself to a value
                self.value=value
                self.save()

        def delete(self):           #deletes variable
                #imports raw values from the files
                self.varNameP = open(self.varNamePath,"r")
                self.varDataP = open(self.varDataPath,"r")
                self.varNameRaw=self.varNameP.readlines()
                self.varDataRaw=self.varDataP.readlines()
                self.varNameP.close()
                self.varDataP.close()
                #removes itself from the list
                del self.varNameRaw[self.index]
                del self.varDataRaw[self.index]
                #saves the altered raw data back into the file
                self.varNameP = open(self.varNamePath,"w")
                self.varDataP = open(self.varDataPath,"w")
                self.varNameP.writelines(self.varNameRaw)
                self.varDataP.writelines(self.varDataRaw)
                self.varNameP.close()
                self.varDataP.close()
                

Code: Alles auswählen

import os,json
import os,json

naValue = "ValueIsNA"

class Var:
    def __init__(self, path, name, inputValue = naValue):
        ##sets it basic values
        self.inputValue = inputValue
        self.savedir =os.path.join(path,"VariableData")
        self.savepath=os.path.join(path,"VariableData","VD.lcs")
        self.name = str(name)
        self.importedValue = naValue
        self.indexInFile = naValue
        self.value = naValue
        ##imports the values from the file
        self.impData()
        if self.inputValue != naValue:
            self.value = self.inputValue
        elif self.importedValue != naValue:
            self.value = self.importedValue
        ##saves it's new datavalue
        self.save()

    def impData(self):
        ##creates directory if it does not exist
        if not os.path.exists(self.savedir):
            os.makedirs(self.savedir)
            self.VDfile=open(self.savepath,'a')
            self.VDfile.close()
            with open(self.savepath, 'w') as self.VDfile:
                self.VDfile.write("[]")
        ##reads data from file
        with open(self.savepath, 'r') as self.VDfile:
            self.fileData=json.loads(self.VDfile.readline())
        ##retrieves data from file
        self.fileVarTitles = []
        for self.i in self.fileData:
            self.fileVarTitles.append(self.i.items()[0][0])
        if self.name in self.fileVarTitles:
            self.indexInFile = self.fileVarTitles.index(self.name)
            self.importedValue = self.fileData[self.indexInFile][self.name]
            
    def save(self):
        ##retrieves the data from the file (in case it was changed)
        with open(self.savepath, 'r') as self.VDfile:
            self.fileData=json.loads(self.VDfile.readline())
        if self.indexInFile is naValue:     ##adds onto the list, if it does not exist yet
            self.fileData.append({self.name:self.value})
        else:                               ##changes the value at for itself, if it already exists
            self.fileData[self.indexInFile][self.name] = self.value
        ##saves itself to the file
        with open(self.savepath, 'w') as self.VDfile:
            self.VDfile.write(json.dumps(self.fileData))

    def setValue(self, value):
        self.value = value
        self.save()

    def delete(self):
        ##loads data from file
        with open(self.savepath, 'r') as self.VDfile:
            self.fileData=json.loads(self.VDfile.readline())
        ##removes itself
        self.fileData.remove({self.name:self.value})
        ##saves itself
        with open(self.savepath, 'w') as self.VDfile:
            self.VDfile.write(json.dumps(self.fileData))

Code: Alles auswählen

["a":1,"b":2]

Code: Alles auswählen

import os, json

"""
most of the def's are created for a list with following format:

[{"titleOne":valueOne},{"titleTwo":valueTwo},{"titleThree":valueThree}]

however:
-createFile
-read
-write
should work for any json formatted data

createFile(path, filename)          creates a file with name FILENAME at PATH
read(path)                          returns the read out text from file PATH            must be valid json
write(path, data)                   writes DATA in the file PATH                        must be valid json
titleList(data)                     returns a list with the titles in DATA. format:     see above
indexInList(data, title)            returns the index of TITLE in DATA. format:         see above
getValue(data, title)               returns the value of TITLE in DATA. format:         see above
removeFromList(data, title)         removes TITLE from DATA. format:                    see above
inList(data, title)                 returns True if TITLE is in DATA. format:           see above
setValue(data, title, value)        sets TITLE in DATA to VALUE. format:                see above
addToList(data, title, value)       adds TITLE with value VALUE to DATA. format:        see above
rename(data, title, newTitle)       renames TITLE in DATA to NEWTITLE. format:          see above

created by kamik423
"""


def createFile(path, filename):   ##creates a file
    filepath=os.path.join(path, filename)
    if os.path.isfile(filepath):
        print "error: file " + str(filepath) + " already exists"
    else:
        if not os.path.exists(path):
            os.makedirs(path)
        VDfile=open(filepath,'a')
        VDfile.close()
        with open(filepath, 'w') as VDfile:
            VDfile.write("[]")

def read(path):   ## reads json from file
    if os.path.isfile(path):
        with open(path, 'r') as VDfile:
            try:
                fileData=json.loads(VDfile.readline())
                return fileData
            except:
                print "error, file " + str(path) + " contains incorrect json, it might be damaged"
                return []
    else:
        print "error: file " + str(path) + " does not exist"
        return []

def write(path, data):   ## saves into file
    if os.path.isfile(path):
        with open(path, 'w') as VDfile:
            try:
                VDfile.write(json.dumps(data))
            except:
                print "error, can't write: " + str(data) + " since it is not correct json"
    else:
        print "error: can't write file " + str(path) + " since it does not exist"

def titleList(data):            ##returns a list with all the titles
    titles = []
    if type(data) is list:
        for i in data:
            if type(i) is dict:
                titles.append(i.items()[0][0])
            else:
                print "error, " + str(data) + " is not dict type"
                title.append(None)
        return titles
    else:
        print "error, " + str(data) + " is not a list, could not decode"
        return []

def indexInList(data, title):   ##returns the index in a list of type titleList
    listOfTitles = titleList(data)
    if inList(data,title):
        return listOfTitles.index(title)
    else:
        print "error, " + str(title) + " is not in " + str(listOfTitles)
        return 0

def getValue(data, title):   ## returns the value in titleList
    titleIndex = indexInList(data, title)
    if inList(data,title):
        if type(data[titleIndex]) is dict:
            value = data[titleIndex][title]
            return value
        else:
            print "error, invalid datatype of " + str(data[titleIndex]) + " in " + str(data)
    else:
        print "error, " + str(title) + " is not in " + str(data)
        return -1

def removeFromList(data, title):            ##removes title from list
    if inList(data,title):
        titleIndex = indexInList(data, title)
        value = getValue(data,title)
        dictValue = {title:value}
        data.remove(dictValue)
        return data
    else:
        print "error, can't remove " + str(title) + " from " + str(data) + " since it is not in it"
        return data

def inList(data, title): ##returns true if title is in list
    return title in titleList(data)

def setValue(data, title, value):
    if inList(data, title):
        data[indexInList(data,title)][title]=value
    else:
        print "error, " + str(title) + " could not be set to " + str(value) + " because it is not in " + str(data)
    return data

def addToList(data, title, value):   ##adds a new element to the list
    if inList(data, title):
        print "error, " + str(title) + " is already in " + str(data) + " but it will be set to " + str(value) + " anyways"
        data = setValue(data, title, value)
    else:
        data.append({title: value})
    return data

def rename(data, title, newTitle):  ## renames an item in the list
    if inList(data, title):
        value = getValue(data,title)
        data = removeFromList(data,title)
        data = addToList(data, str(newTitle), value)
    else:
        print "error, " + str(title) + " is not in " + str(data) + " so it can not be renamed to " + str(newTitle)
    return data

Code: Alles auswählen

VDfile=open(filepath,'a')
VDfile.close()
with open(filepath, 'w') as VDfile:
    VDfile.write("[]")

Code: Alles auswählen

import os
import json

"""
most of the def's are created for a list with following format:

{"titleOne":valueOne,"titleTwo":valueTwo,"titleThree":valueThree}

however:
-createFile
-read
-write
should work for any json formatted data

createFile(path, filename)          creates a file with name FILENAME at PATH
read(filePath)                      returns the read out text from file PATH            must be valid json
write(filePath, data)               writes DATA in the file PATH                        must be valid json
titleList(data)                     returns a list with the titles in DATA. format:     see above
indexInList(data, title)            returns the index of TITLE in DATA. format:         see above
getValue(data, title)               returns the value of TITLE in DATA. format:         see above
removeFromList(data, title)         removes TITLE from DATA. format:                    see above
inList(data, title)                 returns True if TITLE is in DATA. format:           see above
setValue(data, title, value)        sets TITLE in DATA to VALUE. format:                see above
addToList(data, title, value)       adds TITLE with value VALUE to DATA. format:        see above
rename(data, title, newTitle)       renames TITLE in DATA to NEWTITLE. format:          see above

created by kamik423
"""


def createFile(path, filename): 
    filepath=os.path.join(path, filename)
    if os.path.isfile(filepath):
        print "error: file " + str(filepath) + " already exists"
    else:
        if not os.path.exists(path):
            os.makedirs(path)
        with open(filepath, 'w') as VDfile:
            VDfile.write("{}")

def read(filePath):  
    if os.path.isfile(filePath):
        with open(filePath, 'r') as VDfile:
            try:
                fileData=json.loads(VDfile.readline())
                return fileData
            except:
                print "error, file " + filePath + " contains incorrect json, it might be damaged"
                return []
    else:
        print "error: file " + filePath + " does not exist"
        return []

def write(filePath, data):
    if os.path.isfile(filePath):
        with open(filePath, 'w') as VDfile:
            try:
                VDfile.write(json.dumps(data))
            except:
                print "error, can't write: " + str(data) + " since it is not correct json"
    else:
        print "error: can't write file " + filePath + " since it does not exist"

def titleList(data):
    titles = []
    if type(data) is dict:
        dataItems = data.items()
        for i in dataItems:
            titles.append(i[0])
        return titles
    else:
        print "error, " + str(data) + " is not a dict, could not decode"
        return []

def indexInList(data, title):
    listOfTitles = titleList(data)
    if inList(data,title):
        return listOfTitles.index(title)
    else:
        print "error, " + str(title) + " is not in " + str(listOfTitles)
        return 0

def getValue(data, title):
    titleIndex = indexInList(data, title)
    if inList(data,title):
        value = data.items()[titleIndex][1]
        return value
    else:
        print "error, " + str(title) + " is not in " + str(data)
        return -1

def removeFromList(data, title):
    if inList(data,title):
        titleIndex = indexInList(data, title)
        value = getValue(data,title)
        dictValue = {title:value}
        data.pop(title)
        return data
    else:
        print "error, can't remove " + str(title) + " from " + str(data) + " since it is not in it"
        return data

def inList(data, title):
    return title in titleList(data)

def setValue(data, title, value):
    if inList(data, title):
        print data[title]
        data[title]=value
    else:
        print "error, " + str(title) + " could not be set to " + str(value) + " because it is not in " + str(data)
    return data

def addToList(data, title, value):
    if inList(data, title):
        print "error, " + str(title) + " is already in " + str(data) + " but it will be set to " + str(value) + " anyways"
    data[title]=value
    return data

def rename(data, title, newTitle):
    if inList(data, title):
        value = getValue(data,title)
        data = removeFromList(data,title)
        data = addToList(data, str(newTitle), value)
    else:
        print "error, " + str(title) + " is not in " + str(data) + " so it can not be renamed to " + str(newTitle)
    return data