Field calculating a unique date and time

Question

I want to field calculate a field to be have a have the date and time (down to the second) and two letters after (to be assigned by user).

For example, if the record was created on September 8th, 2016 at 7:15 am and 03 seconds it would look like this: 090816071503XX

I also need this to be unique though, in some cases this field calculate will be performed on over 5000 records. By doing a complete field calculate in real-time, this means all 5000 records would show the same time. So I need a code that will field calculate a "fake", but realistic time (i.e. can't have hour 25). I don't care that this time is incorrect, but I do want the date to be correct.

I imagine this is something that can be scripted in Python?

I have a VBA (.cal) script I can load into the field calculator which will calculate the date and time, but as I said, I need it to return unique times.

'enter your initials  
INIT="XX"  

'month string - add zero  
If LEN(DatePart ("m", Now (  ) ))=1 then  
    MO = "0"&DatePart ("m", Now (  ) )  
Else  
    MO = DatePart ("m", Now (  ) )  
end if  


'day string - add zero  
If LEN(DatePart ("d", Now (  ) ))=1 then  
    DA = "0"&DatePart ("d", Now (  ) )  
Else  
    DA = DatePart ("d", Now (  ) )  
end if  

'year string - two digits  
YR = RIght(DatePart ("YYYY", Now (  ) ),2)  

'HR string - two digits  
If LEN (DatePart ("h", Now (  ) ))=1 then  
    HR = "0"&DatePart ("h", Now (  ) )  
Else  
    HR = DatePart ("h", Now (  ) )  
End if  

'MN string - two digits  
If LEN (DatePart ("n", Now (  ) ))=1 then  
    MN = "0"&DatePart ("n", Now (  ) )  
Else  
    MN = DatePart ("n", Now (  ) )  
End if  

'SS string - two digits  
If LEN (DatePart ("s", Now (  ) ))=1 then  
    SS = "0"&DatePart ("s", Now (  ) )  
Else  
    SS = DatePart ("s", Now (  ) )  
End if  

Answer 1

The above answer works, but seems a bit overcomplicated. Why not just this:

Code Block:

import datetime
dateSet = set()

def set_date(timestamp, suffix):
    date = datetime.datetime.strptime(timestamp, "%m/%d/%Y %H:%M:%S")
    global dateSet

    while date in dateSet:
        date += datetime.timedelta(0,1)
    dateSet.add(date)
    return datetime.datetime.strftime(date, "%m%d%y%H%M%S{}".format(suffix)) 

And the expression:

set_date("09/16/2016 14:22:57", "MM")

This printed out '091616142257MM' for me. It is also worth noting, if you have an actual Date Field, it should return a datetime.datetime() and you could skip the conversion from the string timestamp by just using datetime.datetime.strftime(date, "%m%d%Y%H%M%S{}".format(suffix)).

Here's the screenshot:

EDIT:

I see part of the OP is asking for a unique time. I borrowed from @Midavalo's answer to add the time delta to make it unique.

Answer 2

Using the field calculator with python parser:

In the Code Block:

import datetime
initials = 'MM'
dateSet = set()

def set_date(thedate):
    def date_string(myDate):
        myYear = str(myDate.year)[2:]
        myMonth = str(myDate.month).zfill(2)
        myDay = str(myDate.day).zfill(2)
        myHour = str(myDate.hour).zfill(2)
        myMinute = str(myDate.minute).zfill(2)
        mySecond = str(myDate.second).zfill(2)
        return {'Year': myYear, 'Month': myMonth, 'Day': myDay, 'Hour': myHour, 'Minute': myMinute, 'Second': mySecond}

    global dateSet
    myDate = datetime.datetime.strptime(thedate, '%m/%d/%Y %H:%M:%S')

    dd = date_string(myDate)
    dateStr = "{0}{1}{2}{3}{4}{5}".format(dd['Month'], dd['Day'], dd['Year'], dd['Hour'], dd['Minute'], dd['Second'])

    while dateStr in dateSet:
        myDate += datetime.timedelta(0,1) 
        dd = date_string(myDate)
        dateStr = "{0}{1}{2}{3}{4}{5}".format(dd['Month'], dd['Day'], dd['Year'], dd['Hour'], dd['Minute'], dd['Second'])
    dateSet.add(dateStr)

    return "{}{}".format(dateStr, initials)

And in the Expression:

set_date('09/16/2016 14:22:57')

(where 09/16/2016 14:22:57 is the date you want to add to the field)

Calculate Field tool:

Result:

This just adds a second to the time if it has already been used.