Ah.

I actually have some Python code that should retrieve the data from an .8x* variable:

def get8xdata(filename):
"""Opens a TI-8x data variable and returns a tuple of its internal name and of its data"""
try:
file = open(filename, 'rb')
except:
print "Can't open file: ", filename
raise IOError

output = file.read()
file.close()
end = len(output) - 2
data = output[72:end]
name = output[60:68]
return data, name
Not entirely certain if the data retrieval works (the name retrieval does), but the data should begin at index 72. (If it doesn't you can just change that number).

Yeah, I'd say Python is good for a complete beginner.

However, that does not mean it's a language only for beginners. I don't see a reason why you'd "need" to transition to another language.

Though, maybe you'd want to learn C, because you'd learn more about programming (it's at a lower level).

Unless you actually needed to know another language for a specific reason (i.e. you're trying to program on a platform only supporting one language, or you're trying to modify something written using another language), you really don't "need" to move to Java or C++.

But that's just the opinion of someone who dislikes Java and C++ and does most of his programming in Python, C, and VB .NET.

Could you make it poll the new files xml feed to get new data?

If it doesn't at least know the last file in the xml feed, assume the data is old and needs updated, and prompt?

Hmm... I could, yes. But it would mean I'd need to make at least two web requests (one to the feed, one to the fileinfo page of the last file) each time it runs. Before, the only thing that was making web requests was the updating and the downloading (to save on bandwith).

What I could do is add an opt switch to do this when it starts. Or an opt switch to stop it from doing this.

Quote from: DJ Omnimaga on December 19, 2010, 11:53:31 am

Cool! When it is finished someone could indeed make a GUI. Not that it's fully necessary, though. I like the features so far.

The GUI will basically be an easier way to choose options (a choice list, you can choose 1,2, or 3 options at the same time), a text control to input text, and a button that lists, allows download and counts, all the features in one button

Well, easier is subjective. But yes.

Also, the GUI will just be a choice- the command-line program will still work separately.

I'm glad you're getting a 84 again TC01. Does this means you will develop z80 stuff again soon?

Hopefully. I plan to at least use all the new z80 stuff that's been developed since the summer.

I don't really have any ideas as to what I'd make yet though.

I picked Complete, though as I said on ticalc.org, I think that a lot of these are really good.

NewProg is cool fundamentally, but it is true that no one seems to be using it. (Unless there's a secret NewProg development community out there or something. ) I think the main reason is that 68k Basic is already more powerful than 83+ Basic, and that C is much better for developing complex stuff than 68k assembly. Whereas in the z80 world, there was just Basic (and libs), or assembly (and things like BBC Basic) until Axe.

All the games are great of course, especially Pacman.

And AMS Extender is useful too.

I've been working on a new version lately. Here are some of the changes:

A list switch (-f) which lets you search for the file name rather than the program name. For instance, if you want to search for all ticalc.org files containing "quadratic" in the filename rather than the name of the program, you'd use -f with list.

I've been typing "search" instead of "list", so I've redirected the "search" command to "list"- both calcpkg.py search and calcpkg.py list will do the same things.

The searching options can now be ran with calcpkg.py get as well.

I also added a logging system, so if you run it with the -l switch every text message printed to the terminal will also be written to calcpkg.log (with a note indicating the date ran).

I added a "clean" command that deletes all .tar.gz and .zip files from the folder that calcpkg.py is in (it also removes the calcpkg.log file). Please note: the files are not sent to the recycle bin/trash, so they're deleted for good.

And finally, I added options to disable the confirmation prompts when running calcpkg.py get (-n) and calcpkg.py update (-p). I'd have preferred them to be the same letter but optparse wouldn't let me.

For people who wish to use calcpkg as part of another program (*cough* making a GUI *cough*), there are several other changes.

The options are now parsed in main(), and then passed as boolean or string arguments to various functions (unlike before, when the opts object was passed directly to each function using it). This will make it easier for another program to search using options.

Finally, I rewrote the text output system. An end user shouldn't notice any changes, but you will if you look at the code. (This is a bit complex). Python will let you redirect print to any object with a write() function. I've done the following:

1. Changed (almost) all instances of "print" to "printcalcpkg()", a custom-defined function.
2. printcalcpkg() will print it's text to whatever object is stored in "calcpkg.output" (the global variable output from inside the program)
3. Set the default output to a "calcpkgOutput" object I've included- which prints to the terminal and has an option to also log output to a logfile (how logging works)

If you want to see an example of how to make a custom "printing" object look at the code.

What does this mean? It means that you could redirect all the print statements to some kind of GUI- a big textbox or something.

Does he code or play some unstable games like Mario? 9 per day seems like a bit much otherwise!

DJ, it's how many times SirCmpwn's RAM cleared. 

His friend was keeping track for him.

Also, the new version has been uploaded to ticalc.org here. And there's a version with the Unix line endings here. (Copies are also available in Cemetech's archives- and I'll replace the one in the first post in a second).