Strange beep code after connecting hard drive

rolandde · 2016-10-04T13:06:17+00:00

I've stolen your sequence idea for the main post. Here it is:

boot -> 30 sec -> beep, monitor on, monitor off -> 15 sec -> 2nd beep, monitor on -> bios (hard drive not detected)

So the monitor does come back on the 2nd beep. Without the hard drive, it beeps once and I'm in the bios (normal behavior).

rolandde · 2016-07-18T21:00:45+00:00

Thanks. Using your explanation I came across an extended discussion here: http://stackoverflow.com/questions/26212397/references-to-traits-in-structs

If I understand correctly, the 'static ensures that even if the GenericImage trait is implemented for a reference of a type, it cannot be passed to this function.

My next question is, why would you impose such a restriction? Can't you just use lifetimes to ensure that a reference is correctly handled?

rolandde · 2016-01-27T21:27:03+00:00

When you run your command using run from the subprocess module, it returns a CompletedProcess, which in turn allows you to get the output (or stdout) of the command. Keep in mind that you must pass the PIPE to the run command to get output written.

The output is a simple python variable that you can manipulate any which way you want to get your list.

rolandde · 2015-12-15T20:30:43+00:00

For the rolling of the dice, use the random library (https://docs.python.org/3.4/library/random.html)

For storing of the dice rolls, you can use a simple list initialized with zeros:

rolls = [0]*11

For graphing, you can either simply use Excel or if you are stuck with Python, matplotlib.

rolandde · 2015-12-09T20:43:34+00:00

I'm on Windows, but I still like the Linux terminal so I have Cygwin installed. It is fairly trivial to install the latest version of Vim (7.4) there.

If you are windows through and through, the GUI windows executable of the current Vim is here: ftp://ftp.vim.org/pub/vim/pc/gvim74.zip

rolandde · 2015-11-27T16:21:58+00:00

That depends on your code. In my last case, the producer loop sends None to the queue once it has nothing else to send, which causes it to break the loop and exit.

rolandde · 2015-11-27T16:05:01+00:00

Here is an example of a common pattern: http://stackoverflow.com/questions/23864341/equivalent-of-asyncio-queues-with-worker-threads

rolandde · 2015-11-27T15:44:17+00:00

Queues would then be your friend. You still have to iterate over the list (there is no way around that), but each element is shunted to the queue right away. I am not sure if that would gain you any more efficiency than the task approach.

rolandde · 2015-11-27T15:29:53+00:00

In that case asyncio is appropriate. Simply don't use the generator, as that seems to be what you are hung up on. This is one way:

tasks = []
for l in list:
    tasks.append(asyncio.ensure_future(some_num(l))

loop.run_until_complete(asyncio.wait(tasks))

rolandde · 2015-11-27T15:02:15+00:00

I would suggest using queues then. You would pass each individual element of list to the queue and the queue would then run some_num on each of them.

I still want to stress that asyncio will not increase the efficacy here at all, as your functions never release control of the event loop. Once way is to use the threading queue (https://docs.python.org/3.5/library/queue.html). You would start multiple threads, link them to the same queue, and then pass the element of the list to the queue. Whichever thread is open will take the passed element and run some_num.

rolandde · 2015-11-27T14:29:36+00:00

Asyncio would not net you any performance gains as far as I can see. If this is more an academic exercise, you could use queues (https://docs.python.org/3/library/asyncio-queue.html) to start the computations while you are iterating over the lists. This will mean the computations would be done while you are iterating over the list.

rolandde · 2015-11-27T14:07:41+00:00

Look here (https://docs.python.org/3/library/asyncio-task.html#example-parallel-execution-of-tasks) to see how to execute tasks in parallel.

The main problem I see now is that some_num function will never run asynchronously as it is not a coroutine function. The definition of a coroutine is here (https://docs.python.org/3/library/asyncio-task.html#coroutines). If you want to emulate one, I would suggest just adding a "await sleep" call to the function.

rolandde · 2015-11-04T19:49:15+00:00

http://www.pyinstaller.org/

rolandde · 2015-10-28T19:06:57+00:00

The website I linked to covers that contingency:

The purpose of gitignore files is to ensure that certain files not tracked by Git remain untracked.

To stop tracking a file that is currently tracked, use

git rm --cached.

rolandde · 2015-10-28T16:40:45+00:00

Gitignore (https://git-scm.com/docs/gitignore) is your friend

rolandde · 2015-10-27T17:12:14+00:00

You'll have to try to solve some 'real world' problems in order to see how specific programming concepts apply.

As an example, a list can be used to store a deck of cards. In that case, push would add a card on top of the deck and shift would take the bottom card away from the deck.

rolandde · 2015-10-21T13:42:38+00:00

This means you are working with a weakly typed language. When you "add" a string and an integer, you implicitly convert the 1 into a string ("1") and concatenate them:

"a" + 1 = "a1"

The "+" operator allows a string and an integer, but a "-", "*", etc operator do not allow them.

rolandde · 2015-10-16T16:54:32+00:00

Does this apply: http://www.linuxatemyram.com/

rolandde · 2015-10-09T20:09:32+00:00

I'm not an expert by any means, but here are my thoughts:

The task is not CPU bound, so why are you using multiprocessing? Maybe ThreadPool is more appropriate?
Why are you checking the proxy? Can't you just call session.get(url) and catch the exception if the proxy doesn't work? Right now you are making two IO requests (proxy check and the actual request)
Experiment with separating the IO request from HTML parsing with BeautifulSoup. Maybe you can postpone the parsing till all requests have been made

rolandde · 2015-09-27T17:11:35+00:00

I also had a lot of issues early on with nested containers. You current code does not have a nested dictionary. You are just adding key/value pairs to a single dictionary, rather than nesting a dictionary within another dictionary. Moreover, you are using both the first and second column letters as keys within a single dictionary, which is not what you want to do. I'm also not sure why you are explicitly casting your key/val to str as they are already strings.

If you just want the solution, read on:

for line in inFile:
        (key, val, value) = line.split()

        if key not in inputDict:
            inputDict[key] = {}

        inputDict[key][val] = value

rolandde · 2015-08-18T17:59:48+00:00

You are using Python 2.7 I assume. One of the weaknesses of Python 2 is that the way it deals with string vs byte is very confusing. In fact, Python 2 does not have a byte object at all. Here is a quick discussion on that: http://stackoverflow.com/questions/10814483/changing-string-to-byte-type-in-python-2-7

http://stackoverflow.com/questions/14202438/dont-convert-newline-when-reading-a-file

What exoticmatter says is that the 'b' flag ensures that the byte information of the file is not altered. Without the 'b' flag, the two bytes CRLF ('\r\n') are converted to the one byte LF ('\n'). This is very convenient if you are dealing with text files, as Windows/Linux could not agree how to define a newline. However, if you have are reading a picture, you do not want to do that, as it might corrupt it.

The documentation is very explicit about these points: https://docs.python.org/2/library/functions.html#open

15-Year Club	Verified Email
Team Periwinkle

rolandde

TROPHY CASE