Site Sponsors:
Fast & Easy: Managing SQL Data in Python 3! 
While serving as the Principal Software Development Engineer at Informix, I wrote several articles for BYTE Magazine. Aside from coining the term "DLL Hell" in 1991, I was honoured to work with the same teams that created the Wingz Spreadsheet, as well as what remains the fastest databases on the planet.

Believe it or leave it, for we storage-access enthusiasts times have not changed very much since those days. What has changed has been the massively cool way that we can EASILY add a free SQL Database to our applications.

Database Arsenal: SQL

While I have grown very fond of Microsoft's LINQ, Hibernate, Spring, and even MyBatis, to date nothing comes even close to the quick-and-easy way that we can add the power of SQL to our Pythonic undertakings.

To convince any nay-sayers, submitted for your approval please try out the following 'nifty little demonstration program:

#!/usr/bin/env python3
import sqlite3
""" Log arbitrary "two string" information to an sqlite3 database """

class LogDB:

def __init__(self):
self.bOpen = False

def open(self):
""" Connect to the LOCAL database """
if self.bOpen == True:
self.conn = sqlite3.connect('PyLog.sqlt3')
self.curs = self.conn.cursor()
self.bOpen = True

def createTable(self):
""" Create a table for the logged messages """
cmd = 'create table logged \
(timestr char(20), message char(256))'

def dropTable(self):
""" Remove the table from the database """
cmd = 'drop table logged'

def insertRow(self, timestr, message):
""" Insert an arbitrary logge prefix & message """
self.curs.execute('insert into logged values(?,?)', [timestr, message])

def selectMessages(self):
""" Generator to enumerate thru selected values """
self.curs.execute('select * from logged')
for tstr, msg in self.curs.fetchall():
yield tstr, msg

def close(self):
""" Safe coding is no accident ... """
if self.bOpen:
self.bOpen = False

if __name__ == "__main__":
db = LogDB()
for ss in range(10):
db.insertRow("MyTime" + str(ss), "Message " + str(ss + 1))
for zt, mgs in db.selectMessages():
print(zt, mgs)

Designed for more than re-use under SQLite & built around the simple SQL concepts of CREATE TABLE, Insert Data ("row"), Read Row, and DROP TABLE, about the only things lacking in the above is the (1) Update Row (not important in the logging metaphor), as well as (2) a way to unlink() the external database file itself.

The "Pick Two" Dilemma

The above demonstration was also designed for fast & inexpensive data collection activities. In order to satisfy the pedantic, we must therefore surely take a moment to note also that - whenever we plan to manage such entries - for example in relation to another set of database tables - that (3) adding a unique, auto-generated primary key is also recommended.

Come to that, also note how parsing & normalizing data (such as the date & time) might also be something to consider when (4) aggregating these rapidly-collected data into an enterprise schema. (Hence the grand division between "time," "quality" and "cost" for data collection activities in the database world.... but that is another story!)

So while knowing something is great, more than ever before in our modern times have far too many discovered that knowing when to use it (i.e. "pick 2:3") is often quite another story!

It is a "knowledge" (i.e. showing off what we know) versus "wisdom" (showing off how well our product works) type-of thing.

Enjoy the journey,



[ view entry ] ( 1095 views )   |  permalink  |  related link
Time Formatting & Conversion in Python 3 
For those of yooze-guys whom may not know, Python 3.5 came out last month.


To commemorate the event, I thought that I would share a little time-conversion ditty I wrote.

Indeed, the need to understand this particular time-conversion task is so common that I remain amazed that there are - at the time of this writing - absolutely NO decent articles on converting between "military" and "civilian" time on the Internet using Python3.

Short on time as I am, please allow me to post and go - for the moment we'll let 'google do the rest:

from datetime import datetime as zdatetime
from datetime import timezone

class LogEntry():

""" Manage a GMT (i.e. Non-naive timezone) log-entry """
def _hack(self, message):
znow =
self.utc_date = znow.strftime(format=self.UFORMAT)
self.message = str(message)

def __init__(self, message):
""" Taking care of beez-nice """
self.UFORMAT = '%Y-%m-%d %H:%M:%S [%z]'
self.LFORMAT = '%Y-%m-%d %I:%M:%S %p'

def __repr__(self):
""" Get the UTC-0 (i.e. non-naive + military-time) format """
return self.utc_date + "\t" + self.message

def __str__(self):
""" Get the LOCAL (naive + civilian-time) format """
st_time = zdatetime.strptime(self.utc_date,self.UFORMAT)
ltime = st_time.astimezone()
return "[" + \
ltime.strftime(format=self.LFORMAT) + "] " \
+ self.message

def hack(self, message):
""" Update the time, as well as the message """

if __name__ == '__main__':
""" Basic proof of concept """
ent = LogEntry('This is a test')

Here is the proof of concept:

>>> ================================ RESTART ================================
2015-10-25 00:04:12 [+0000] This is a test
[2015-10-24 08:04:12 PM] This is a test



p.s: Just for the record, when logging / storing events of any worth onto servers, the anticipated & common convention remains to store said textual line-entries in a GMT / UTC-0 time format.


[ view entry ] ( 1038 views )   |  permalink
HTTP Forma As-a Service Transfer (F.A.S.T) 
When creating a new web presence, as a set of architectural guidelines using JSON and REST is a good way to go.

However, sometimes we need to manage data on the Internet in such a way as to automate existing HTTP Forms.


Such was the case when I created "The Wiki Recipe Club." Like you, I am often working as "an army of one." When time and costs are so limited, we need to transfer data as quickly & efficiently as possible. -In my case, I simply wanted to pump 180,000+ recipes into an Open Source WIKI using HTTP Forms.

Because classic web forms only need a GET or a POST, I created EasyHTTP.

Followers of this blog might recall that EasyHTTP is the reference implementation of our "Business / Enterprise State Transfer" (B.E.S.T) architectural guideline. Curiously however, a few years back that framework - along with half of my other projects - mysteriously disappeared from Sourceforge.

New Moniker for Old Services

While restoring the content of EasyHTTP to Sourceforge today, I realized - in today's Web 2+ world - that the classic HTTP way of creating, reading, updating, or deleting data from our web sites should have it's own "service oriented" moniker.

Indeed, in as much as forms-encoded data smells allot like JSON, that Web 1.0 way of moving data back-and-forth between those classic, HTTP-centric, web-based set of maintenance operations could also be referred to as "Forms As-a Service Transfer," or F.A.S.T.

Enjoy the journey!


[ view entry ] ( 1146 views )   |  permalink  |  related link

<<First <Back | 31 | 32 | 33 | 34 | 35 | 36 | 37 | 38 | 39 | 40 | Next> Last>>