Posts by woooee

The problem is more one of viewpoint, not coding. You want to get away from the word processing mentality. There is no such thing as lines in a document in a folder (unless the programmer first creates them). We have data (bytes) in two files that we can use or order in any way we want. You want to use the longest file as the primary file and couple that with the records in the shorter file, as far as they will go anyway. Eliminating all of the other code in your program, which is difficult to decipher because there is no explanation of anything anywhere, we could use something like the following.

## simulate reading a file with readlines()
hotel_txt_list = [ "Best Western\n",
                   "Holiday Inn" ]

res_txt_list = [ "Denny's\n",
                 "Applebee's\n",
                 "IHOP\n",
                 "Black Angus" ]

## find the longest list and use it as the primary list
first_list = []
second_list = []
if len(hotel_txt_list) > len(res_txt_list):
    first_list = hotel_txt_list  ## this is a reference, not a copy
    second_list = res_txt_list
else:
    first_list = res_txt_list
    second_list = hotel_txt_list

##  loop through all of the records of the longest list and match
##  them to the records of the shorter list
stop_2 = len(second_list)
for ctr, rec in enumerate(first_list):
    if ctr < stop_2:   ## matching record found in 2nd list
        print "%-20s" % (second_list[ctr].strip()),
    else:
        print "No matching record  ", 
    print first_list[ctr].strip()

Memory was referred to as "core" because iron core rings were used instead of semi-conductors.

You have to find some unique combination that you can split on. If SV= is always the final string then you can split on that. You could also split on finding X number of capital letters in a row.

## an easy way to create the string from the post
seq = ["sp|P20905|5HT1R_DROME 5-hydroxytryptamine receptor 1", 
"OS=Drosophila melanogaster GN=5-HT7 PE=2 SV=1 ",
"MALSGQDWRRHQSHRQHRNHRTQGNHQKLISTATLTLFVLFLSSWIAYAAGKATVPAPLV",
"EGETESATSQDFNSSSAFLGAIASASSTGSGSGSGSGSGSGSGSGSYGLASMNSSPIAIV",
"SYQGITSSNLGDSNTTLVPLSDTPLLLEEFAAGEFVLPPLTSIFVSIVLLIVILGTVVGN",
"VLVCIAVCMVRKLRRPCNYLLVSLALSDLCVALLVMPMALLYEVLEKWNFGPLLCDIWVS",
"FDVLCCTASILNLCAISVDRYLAITKPLEYGVKRTPRRMMLCVGIVWLAAACISLPPLLI",
"LGNEHEDEEGQPICTVCQNFAYQIYATLGSFYIPLSVMLFVYYQIFRAARRIVLEEKRAQ",
"THLQQALNGTGSPSAPQAPPLGHTELASSGNGQRHSSVGNTSLTYSTCGGLSSGGGALAG",
"HGSGGGVSGSTGLLGSPHHKKLRFQLAKEKKASTTLGIIMSAFTVCWLPFFILALIRPFE",
"TMHVPASLSSLFLWLGYANSLLNPIIYATLNRDFRKPFQEILYFRCSSLNTMMRENYYQD",
"QYGEPPSQRVMLGDERHGARESFLD"]

seq_str = "".join(seq)
result = seq_str.find("SV=")
if result > -1:     ## 'SV=' found 
    result += 5     ## skip over SV=
    print seq_str[:result]
    print
    print seq_str[result:]

To get a matrix, you would have to split each record in the file. The file will be read in as a single dimension list if each record has a newline. You then have to split each record on the individual fields to get a matrix that you can access. This program creates a file first, with comma delimited fields and then reads it back in, splits into fields on the commas, and then looks up individuals. If you only want to look up first name you would use a dictionary instead of a list-of-lists/matrix.

def print_name(rec):
    print
    print "first name =", rec[0]
    print "last name = ", rec[1]
    print "street =    ", rec[2]
    print "city =      ", rec[3]
    print "state =     ", rec[4]


## output the file
fname = "./test_name"
fp_out = open(fname, "w")
fp_out.write("Bill,Smith,132 Main St.,Anytown,MI\n")
fp_out.write("Mary,Jones,456 Elm Ave.,Metropolis,NY\n")
fp_out.write("Jered,Weaver,2000 Gene Autry Way,Anaheim,CA")
fp_out.close()

## read it using readlines to get a list of records
fp = open(fname, "r")
single_list = fp.readlines()
print single_list

## split each record and store in a separate list
list_of_items = []
for rec in single_list:
    rec = rec.strip()
    one_rec_list = rec.split(",")
    print one_rec_list
    list_of_items.append(one_rec_list)

## look up first name = "Mary"
for rec in list_of_items:
    if rec[0] == "Mary":
        print_name(rec)

## look up city = "Anaheim"
for rec in list_of_items:
    if rec[3] == "Anaheim":
        print_name(rec)

Three more links: http://hetland.org/writing/instant-python.html
http://python-eggs.org/
http://www.doughellmann.com/PyMOTW/ (more of a reference)

Try it with the complete path name.

reader = csv.reader(open("/path/to/mesaure.csv", "rb"))

After running the file on a Terminal I get the results I want but is no working when running the same file, measured.py, on the editor.

This is too vague to comment on. What does "not working" mean?

Hopefully we will evolve and continue the journey at some other "Earth", i.e. the end of humanity on this Earth. Perhaps not even in this time/space single continuum. We should also start a poll on what the next catastrophe will be once 2012 has passed.

Is self.storeli a list or a dictionary? I would suggest that you print self.counter and len(self.storeli) before the line in question. +1 on Beat_Slayer's suggestion.

Does everyone know about Doug Hellmann's Python Module Of The Week. A good source for basic learning.
http://www.doughellmann.com/PyMOTW/threading/index.html#module-threading
http://www.doughellmann.com/PyMOTW/about.html

The following part of your code doesn't make sense. You should go back to where ever the code came from and double check that it was copied correctly, and that you copied all of the code supplied. Also, print the dictionary to see what it contains.

clist= {}
for word in wordsdict:
    if word in times:
       average = wordsdict[word] / times[word]
       clist = {word:average} [

Edit: This probably doesn't do what you think either. Start by breaking it down into simple steps and then code each step.

if word not in wordsdict:
             wordsdict[word] = cvalue
             times[word] = 1
         else:
             times[word] = 1
             wordsdict[word] = sum([cvalue,wordsdict[word]]) 
             times[word] = times[word] + 1

while not len(guess) == len(secretWord) and guessAlpha== True: 
# will run as long as its not same length
            print "That is not the same length of the secret word!"
            guess = raw_input ("\nMake a guess again: ")

This will exit the loop if either of the conditions evaluates False. So you can have a guess that is not alpha, but if len(guess) == len(secretWord) you will still exit the while loop. Instead of checking for false entries, exit the loop only if the entry is "True", i.e. meets all of the conditions. The following code will not print both messages for a wrong length that is also a non-alpha entry, but you can decide if you want more detailed messages or not.

while True:
    if len(guess) == len(secretWord):
        if guess.isalpha():
            break     ## exit while loop
        else:
            print "Enter letters only"
    else:
        print "That is not the length of the secret word!"

Lists work better IMHO because you can alter each element (letter) individually. This is an example of how you could code a solution using lists. Hopefully some print statements will be enough to append the hyphenated string portion of your code. If not post back with questions. There are some flaws in the logic of the following code, because it is a simple example, but the general idea is what you want.

secret_word = "myrrh"
guessed_word = "mryrr"

secret_list = list(secret_word)
guessed_list = list(guessed_word)

count_right_place = 0
count_wrong_place = 0
incorrect_letter = 0
for ctr in range(0, len(secret_list)):
    guess_ltr = guessed_list[ctr]

    ## if letter is not found, no need to go further
    if guess_ltr in secret_list:
       ## if in correct place
       if guess_ltr == secret_list[ctr]:
           count_right_place += 1
           secret_list[ctr] = "*"       ## eliminate this letter
       else:
           count_wrong_place += 1

    else:
       incorrect_letter += 1

print "%d  correct letter(s) in the wrong place" % (count_wrong_place)
print "%d  correct letter(s) in the correct place" % (count_right_place)
print "%d  incorrect letter(s) guessed" % (incorrect_letter)

I also tried to add the part where it checks user input if its all letters.. but it keeps erroring when i add that

"Error" is not a verb. And you'll have to post some code for help on that.

You would have to use threading or multiprocessing. One thread/process would run festival, while another process would capture some input and send a notice (change a variable) in the first process. Obviously you would have to communicate between the two processes.

Using EasyGUI http://easygui.sourceforge.net/download/current_version/tutorial/ is a simple solution and should solve the problem

There was even a commercial spoofing the tennis players. They did things like push the button for the cross walk with a loud grunt, lift a beer, take a drink, and put it down with a grunt, etc. The commercials weren't on very long, which makes one wonder if they brought up a lot of negative comments/discussion regarding the practice in general. Of course, when you make that much money you don't care. If it is only a distraction for your opponent, and not a necessary part of your game, players will continue to do it to gain an edge as it is doubtful that it will ever be penalized.

It will be difficult (and I assume inefficient) to test every word in my list to non-stop words

There is no other way to do it no matter what method is used. Every word has to be checked somehow. 200 words is not worth worrying over. 200,000 words would require some tweaking. If you are concerned about the amount of time it will take, then consider using a set or dictionary as they are indexed via a hash.

The general way to create a dictionary is to split the text file records into a key and data, then

if key not in the_dictionary:
    the_dictionary[key] = []     ## this is a list but you can use whatever type you want
the_dictionary[key].append(data)

For additional help you should post some of the input file and how you want to store each record.

Python has a CSV reader/writer http://docs.python.org/release/2.5.2/lib/csv-examples.html. I would suggest you start with reading the file and printing individual rows and columns so you discover how to access them individually. Google is your friend here.

This is trivial without regular expressions. Read one record, split into words, and test each word; read the next record, etc. Note that the following two lines probably don't do anything as Original_File_Content is one, long string. See Section 7.2.1 for clarification http://docs.python.org/release/2.5.2/tut/node9.html#SECTION009200000000000000000. If it is a very large file, then converting to a set and comparing to a set of stop words using set.difference() would be faster.

Temp.append("".join(Original_File_Content))
 
FileString = "".join(Temp)

Gedit is going to use whatever locale the OS is set up for. I'm sure you can probably change the UTF for gedit alone, although I don't use it so don't know. You can also change the locale which would make the change system wide, but how you do this would depend on which distro you are using so it is best to ask that question on your distro's forum.

Somebody should Google disk cache. This is the doc for flushing write commands.

file.flush()

Flush the internal buffer, like stdio‘s fflush(). This may be a no-op on some file-like objects.
Note: flush() does not necessarily write the file’s data to disk. Use flush() followed by os.fsync() to ensure this behavior.

A RAM cache used for reading would probably be OS specific and so you would have to turn it off via the OS( in Linux you can clear it by writing to proc/sys/vm/drop_caches) but I don't know how to turn it off. A cache is also part of the drive itself for relatively recent drives. This is a random choice just to see what size of a cache a modern drive has; this one is 32MB (500 Gig is only $59.99. Damn) http://www.tigerdirect.com/applications/SearchTools/item-details.asp?EdpNo=4914330&CatId=2459

+1 I didn't know that either.

Backquotes are supposed to be eliminated in Python 3, but who knows for sure.

You use the same StringVar() if I understand what you want to do. Take a look at the following code and note how the StringVar() is declared and then attached to the second Label() and the Entry() box. Note that when the Entry() box changes the second Label() changes because they both use the same StringVar(), so no refreshing is required.

import Tkinter

class EntryTest:
   """ shows using the same StringVar in the second list box
       and in the entry box
   """
   def __init__(self):
      self.top = Tkinter.Tk()
      self.top.title("Test of Entry")
      self.top.geometry("200x125+10+10")

      self.str_1 = Tkinter.StringVar()
      label_lit = Tkinter.StringVar()

      label_1 = Tkinter.Label(self.top, textvariable = label_lit )
      label_1.pack()
      label_lit.set( "Test of Label")

      label_2 = Tkinter.Label(self.top, textvariable = self.str_1 )
      label_2.pack()

      entry_1 = Tkinter.Entry(self.top, textvariable=self.str_1)
      entry_1.pack()
      self.str_1.set( "Entry Initial Value" )

      print_button = Tkinter.Button(self.top, text='PRINT CONTENTS',
                     command=self.getit, bg='blue', fg='white' )
      print_button.pack(fill=Tkinter.X, expand=1)

      exit_button= Tkinter.Button(self.top, text='EXIT',
                   command=self.top.quit, bg='red', fg='white' )
      exit_button.pack(fill=Tkinter.X, expand=1)

      entry_1.focus_set()
      self.top.mainloop()

   ##-----------------------------------------------------------------
   def getit(self) :
      print "getit: variable passed =", self.str_1.get()


##===============================================================
if "__main__" == __name__  :
   ET=EntryTest()
   print "under __main__ =", ET.str_1.get()

You can manually update a label also. This example is from somewhere on the web and should use a class like above, but should show you the technique to be used.

from Tkinter import *
root=Tk()

def changeLabel():
    myString.set("I'm, a-fraid we're fresh out of red Leicester, sir. ")
    
myString=StringVar()
Label(root,textvariable=myString).pack()
myString.set("Well, eh, how about a little red Leicester.")
Button(root,text='Click Me',command=changeLabel).pack()
root.mainloop()

Actually this is more a function of the desktop, each of which has wrappers to perform this function. KDocker for KDE is only one that comes to mind right now but there are sure to be more, perhaps one or two that are not desktop specific.

A simple test of the following code posted above shows that it will only find 'DTP' if it is at the beginning of the line. It should read as indicated.

f_in = ["xyz", "abcDTPxyz", "DTPabc"]
for line in f_in:

    ## the if statement should read
    ## if line.find('DTP') > -1: as line.find() returns the position found
    if line.find('DTP') == 0:
        print "DTP found in", line

""" 
prints
DTP found in DTPabc
only
"""

The answer is to develop good habits, one of which is to always use the complete path. It makes everything obvious. This also helps when you come back years later to debug a program because someone has moved something.

There are so many examples on the web that I doubt anyone will respond. Try this link http://lmgtfy.org/?q=tkinter+update+time

True. And someone should have caught this thread earlier and asked some questions about what the OP wanted to do, as the program basically returns variables only. Oh well.

there is no main

Python does not require a "main" function. I would be better the say that no instance of the class has been called/created. This is a link to the instant python tutorial which includes classes http://hetland.org/writing/instant-python.html If you copied this program and want to modify it, I would suggest you find some other way as it is obviously more than you understand about Python. On the other hand, if you do make some changes and get an error, feel free to post back for assistance.

my code hangs or somehow don't write in the file

Add some print statements to see where that is. A guess would be that it hangs because it can't find an address or something. There is nothing else to say as we don't even know what you mean by "client" or "server". Are you running a process on the same machine (like a mail or SQL client server) or somehow connecting to another machine? A simple program to demonstrate would be the next step.

Your queries look fine, although I didn't go through all of the code. You may be looking for something that is not in the SQLite file. Design a smaller test program that looks for known items in the file so you can tell if it is the query language or if nothing is found.

From the PySQLite docs, a rather dated example; it allows case insensitive column access by name:

Highly optimized row_factory for column access by name
======================================================

A new function has been implemented that allows for case-insensitive
column access by name with minimal performance and memory impact,
unlike a dictionary or db_row-based approach.

To enable it, set the row_factory attribute of your connection to
sqlite.Row:

from pysqlite2 import dbapi2 as sqlite
    con = sqlite.connect(...)
    con.row_factory = sqlite.Row
    cur = con.cursor()
    cur.execute("select name_last, age from people")
    for row in cur:
        print row["Name_Last"], row[1]

The string "127558161.23" would not convert using the time module because it is not a 9 digit integer. Truncating the decimals yields the following result using gmtime() but is not close to the desired date and time. So it appears that the format is not "epoch second" which means a custom conversion routine will have to be used. I don't know if this comes from a Symbian platform or not, but the question should probably be asked on the phone maker's forum. Once the format is known, it can then be converted using Python or any other programming language.

time.struct_time(tm_year=1974, tm_mon=1, tm_mday=16, tm_hour=8, tm_min=49, tm_sec=21, tm_wday=2, tm_yday=16, tm_isdst=0)

You would use threads, although I use multiprocessing so am not that familiar with threading but here is a link to Doug Hellmann's examples http://www.doughellmann.com/PyMOTW/threading/index.html The kicker is that the variable used to store the downloaded link must be visible to all threads so the progress bar can calculate the downloaded_size / total_download and display that in the progress bar every second or so. The GUI "freezes" in the current code because it has to wait until
DL = DownloadLink(x, DownloadLink.abbrs2[str(self.system)])
is completely finished to return to the for() loop and update the GUI.

I would suggest using a dictionary with the individual records in file1 as the key pointing to a list of items found in the other files.

The problem you pointed out, woooee, wasn't actually a problem. It recognizes both sticky=E and sticky="e" as valid, and they both work in exactly the same way.

E is recognized if you do a
from tkinter import *
which you can not rely on as normally "import tkinter" is used in my experience, especially if you are modifying someone else's code, and you are betting that E was not declared as a variable somewhere else in the program. "e" is always a good bet. Effbot's grid doc is a good reference http://effbot.org/tkinterbook/grid.htm And consider a function for all of those labels, passing the text, row, column, etc. to it. The same for the entry boxes, or one function to create the label and entry since entry column is always label column+1.

And how else would you do it? Every character has to be checked in the underlying code no matter what method is used. The time difference would be because of code efficiency or speed of using C versus Python, but would not change the logic. Finally, a program that is fast but doesn't work properly is of no value. The old adage, first you make it work, then you make it fast, then you make it pretty, holds in pretty much every case.

I think bit checking would slow it down significantly.

It would be best to check this first before making the statement.

It's not that difficult to roll your own. Check each character one at a time in each line and split and append to a list of lists as appropriate.

for ch in record:
    if ch.lower() in ["x", "y", "z"]:
        ## etc

When someone presses the "Run" button, the callback would execute the code from the text-based program, either calling a function or class. You would of course have to import the other program as well. See the button widget here http://effbot.org/tkinterbook/ for info on callbacks.

yet choose the filename and directory to save the file.

Google for Tkinter File Dialog. It is a built-in function to do that.

Look up the docs for sticky (you have to learn to help yourself). A hint is that there are no variables in your program named E, NE, etc.

Try adding some print statements as below.

def file1(filename):
    d1 = dict()
    fp = open(filename)
    for line in fp:
        print "processing file1 line =", line
        process_line1(line, d1)
        return d1
 
def file2(filename):
    d2 = dict()
    fp = open(filename)
    for line in fp:
        print "processing file2 line =", line
        process_line(line, d2)
        return d2

When you really, really appreciate a good nap.

Problem: I get a double popped up dialog. Why is that?

You would have to be calling it twice but without any code no one can help. Post a simple example.

There was something similar on planet.python.org recently, and the suggestion was to help upgrade the documentation to get your feet wet and then move on to bug fixes. Contributing to the core of the language always looks good, as opposed to wrapping something that hasn't been done yet, i.e. it hasn't been done because it isn't in demand, and is usually just some variation of other software projects that have a Python wrapper. In addition, there are several projects with the port to Python 3.0 still in progress. WxPython comes to mind although I haven't checked recently. The links to the "help us with the docs" portion of the wiki.
http://www.python.org/moin/ModulesThatNeedDocs
http://www.python.org/moin/MissingFromDocumentation

Pass the class instance to the GUI program. An example with all classes in the same program.

import random
 
class GUIClass:
 
    def __init__(self, class_instance):
        # create a text area named "textArea"
        # bind the function "OnEnterDown" to the Enter key
        self.ci = class_instance
        print self.ci.my_number, self.ci.my_word
        print "\n calling on_enter_down() within the class"
        self.on_enter_down()

    def on_enter_down(self):
        # Call the function 'combine' in MyScript.py
        self.ci.combine()
        
class MyClass:
 
    def __init__(self):
        self.my_number = random.randint(1, 10)
        self.my_word = "Hello"
 
    def combine(self): # I want this function to be called when the Enter key is pressed
        phrase = "%s %d" % (self.my_word, self.my_number)
        print phrase

MC = MyClass()
GC = GUIClass(MC)
print "\n calling on_enter_down() outside the class"
GC.on_enter_down()

Try these simple functions, which just contain general SQL statements, and see what you get. This assumes that the table name is "postgres" (from your code") and the user name field is named "username" (again from your code). Since we don't know the table name or layout it is impossible to post specific code.

def get_connection():
        connection = pgdb.connect(
            user="postgres",
            password="gobears07",
            database="postgres")
 
        cursor = connection.cursor()

        return connection, cursor

def select_all(cursor):
    cursor.execute("select * from postgres")
    recs_found = cursor.fetchall()

    ## I don't know what type of object pgdb returns
    print type(recs_found)
    print len(recs_found)

def select_user(cursor)
    """ replace 'abc' with a user name that is in the DB
    """
    cursor.execute('select username, password from postgres where username="abc"')
    rec = cursor.fetchone()
    print list(rec)
 
try:
    con, cur = get_connection()
    select_all(cur)
    select_user(cur)
except:
    import traceback
    traceback.print_exc()
    raise

Some things that I see in datapull()

def datapull (username, password):
 
    ##--------------------------------------------------------------
    ## cursor is never passed to the function
    ## and there isn't any db table named 'users'
    cursor.execute('select %s from users') % username

    ##--------------------------------------------------------------
    ## dbcur is never passed to the function
    #
    ## and, username and password would have to be associated with one
    ## another so would be separate fields in the same record
    dbname = dbcur.fetchone()

    if dbname == username:

        ##--------------------------------------------------------------
        ## username and password would have to be associated with one
        ## another so would be separate fields in the same record
        cursor.execute('select %s from password') % password
        dbpass = dbcur.fetchone()

        ##-----------------------------------------------------------
        ## there is no function named password()
        if dbpass == password():
            dbpass = dbcur.fetchone()

            ##-------------------------------------------------------
            ## pesto has not been declared
            pesto.response.redirect('/admin-entry', 'POST')

            ##-------------------------------------------------------
            ## there is no return for a successful lookup so how does
            ## the calling function know that the lookup was successful
        else:
            return "Password is invalid or does not exist."
            logging.error("Invalid Password Input.")
    else:
        return "We are sorry, there is no user matching that name in our database."
        logging.error("Invalid user name.")

Time to Google for some tutorials. I doubt there will be many response to this thread as this code appears to be hacked together to present some code so someone else will write this for you (with the emphasis on "appears"). Start by opening the database successfully. Then print all records, if the DB is not too large, and/or lookup a known user and password …

I still have a punch, to cut the second read/write notch when flipping 5 1/4 inch floppies in an appleIIe

Time to do some cleaning dude. Actually the 8 inch and 5 1/4 were called floppies. The 3.5 inch version was sometimes a floppy and sometimes not. I think Apple wanted to distance its hard case floppy from the others and emphasize the perceived superiority of their product so tried to create a separate product group for it. Today it would be the iFloppy. There were also 3 inch and at least one in the 2 inch category which were attempts to lock in people to one specific vendor. Today you'll have to contact almostbob to find one.

Mechanize is an easier way IMHO to do this. This link explains how to log in with a user name and password to a remote site
http://stockrt.github.com/p/emulating-a-browser-in-python-with-mechanize/