system-wide unique incrementing string or number

[Skaperen]

i want to get either a string or a number which:
1. always sorts in time order even if the system reboots
2. no 2 calls by any user or process can ever get the same result
3. is portable across across Windows and all POSIX compliant systems

obviously this depends on the system having capability. if a system only has a one-second clock event, the OS would need to compensate such as by appending a call counter. does Python provide such a thing? if this can be done by some amount of user space C code that is portable enough (system test code is OK) then i would expect there to be a way to do it in Python.

i have been using int(time.time()*3906250) on recent Linux. that number (10**9/2**8) shifts the significant bits in floating point time that Linux provides to be whole numbers. i do not have Windows to test on.

[Gribouillis]

A few years ago I wrote a code snippet to generate unique words based on computer time, this could perhaps give you some ideas.

#!/usr/bin/env python
# -*-coding: utf8-*-
# Title: newword.py
# Author: Gribouillis for the python forum at www.daniweb.com
# Created: 2015 March 21
# License: Public Domain
# Use this code freely.
# History:
#   0.3.1 bugfix
#   0.3.0 The 3 first letters of words now indicate the day the word
#         was created. Words can now have more than 11 characters
#         (currently 3 + 11 = 14) which should allow a better time
#         granularity if a faster machine is used. Generated words
#         will be ordered until year 2354
#   0.2.2 bugfix
#   0.2.1 sort letters to generate ordered words
#   0.2.0 bugfix for python 3
#   0.1.0 first version
'''This module defines a function to generate unique words
'''
from __future__ import (absolute_import, division,
                        print_function, unicode_literals)

__version__ = '0.3.1'

class new_word(object):
    from struct import pack, unpack
    from string import ascii_letters
    ascii_letters = str('').join(sorted(ascii_letters))
    import time
    from datetime import datetime
    origin = datetime(year=1970, month=1, day=1)
    day_length = 24 * 3600.0
    
    if hasattr(time, 'perf_counter'):
        perf_counter = time.perf_counter
    else:
        import timeit
        perf_counter = timeit.default_timer
    
    def int_from_float(self, x):
        u, v = self.unpack(">LL", self.pack(">d", x))
        return (u << 32) | v
    
    def __init__(self):
        self.day_init()
        self.result = ''
    
    def day_init(self):
        now = self.datetime.now()
        today = self.datetime(year=now.year, month=now.month, day=now.day)
        days = (today - self.origin).days
        self.prefix = self.days_prefix(days)
        self.offset = (now - today).total_seconds()
        self.zero = self.perf_counter()
    
    def days_prefix(self, n):
        L = [None, None, None]
        for i in range(3):
            n, r = divmod(n, 52)
            L[2-i] = self.ascii_letters[r]
        return ''.join(L)
    
    def new_int(self):
        while True:
            c = self.perf_counter()
            offset = self.offset + (c - self.zero)
            if offset > self.day_length:
                self.day_init()
            elif offset > self.offset:
                self.zero = c
                self.offset = offset
                return self.int_from_float(offset)
    
    def gen_letter(self):
        ivalue = self.new_int()
        for i in range(11):
            ivalue, r = divmod(ivalue, 52)
            yield self.ascii_letters[r]
    
    def new_word(self, nchar=14):
        """new_word(nchar=14) --> a new word containing only ascii letters
        
        The word is a unique str instance, based on the machine time. Unlikely
        collisions can occur if the computer's clock is reset to a time in
        the past.
        
        new in version 0.3.0:
            argument nchar indicates maximum number of characters (up to 14)
        
        Example:
        
            >>> new_word()
            'GLAgSFyTODBfRd'
            
        Remark:
        
            The output can be reverse-engineered to discover when the
            word was generated, according to the generating computer's clock.
        """
        while True:
            result = (self.prefix + str('').join(self.gen_letter())[::-1])[:nchar]
            if result > self.result:
                self.result = result
                return result

new_word = new_word().new_word

if __name__ == '__main__':
    L = [] 
    for i in range(5):
        L. append(new_word())
    for w in L:
        print(w)

""" my output -->
GLAgSGaBhFOkxy
GLAgSGaBhFqvOe
GLAgSGaBhGGbKu
GLAgSGaBhGSVMm
GLAgSGaBhGcKLK
"""

[Yoriz]

Maybe you could use UUID

[Gribouillis]

UUID is not sorted in time order...

[Yoriz]

The time attribute looks sortable

import uuid

for _ in range(10):
    print(uuid.uuid1().time)

Output:
138134349496775452
138134349496825456
138134349496825457
138134349496825458
138134349496825459
138134349496825460
138134349496835458
138134349496835459
138134349496835460
138134349496835461

[casevh]

I would look at time.monotonic() and some related functions. They are designed to monotonically increase even if NTP is used to adjust the time. I don't know how they behave after a system reboot if time is adjusted before the operating system boots.

[Gribouillis]

@Yoriz I didn't know that. Can you find this time() member again once the UUID instance has been converted to an string ? Does it represent the moment the uuid was created?

>>> import uuid
>>> u = uuid.uuid1()
>>> u
UUID('a6374978-c086-11ea-9c52-0c54a50d680a')
>>> s = str(u)
>>> s
'a6374978-c086-11ea-9c52-0c54a50d680a'

[Yoriz]

Yes current time is used to create a timestamp in uuid1

uuid.uuid1(node=None, clock_seq=None)
Generate a UUID from a host ID, sequence number, and the current time. If node is not given, getnode() is used to obtain the hardware address. If clock_seq is given, it is used as the sequence number; otherwise a random 14-bit sequence number is chosen.

The following is from inside the def of uuid1

import time
nanoseconds = int(time.time() * 1e9)
# 0x01b21dd213814000 is the number of 100-ns intervals between the
# UUID epoch 1582-10-15 00:00:00 and the Unix epoch 1970-01-01 00:00:00.
timestamp = int(nanoseconds/100) + 0x01b21dd213814000

I would just keep a reference to the generated UUID then you can access the string or the time or any other method/attribute.

[Gribouillis]

I would just keep a reference to the generated UUID then you can access the string or the time or any other method/attribute.

But you may want to use the UUID for a more persistent purpose. For example you could use it to create a file name or a database entry. If you do so, can you compare old uuid1's based on this time value ?

[Yoriz]

You can turn the UUID string back into a UUID

import uuid
import datetime

my_uuid = uuid.uuid1()
print(datetime.datetime(1582, 10, 15) +
      datetime.timedelta(microseconds=my_uuid.time//10))

ustring = str(my_uuid)
print(f'{type(ustring)} {ustring}')

back_to_uuid = uuid.UUID(ustring)
print(f'{type(my_uuid)} {my_uuid}')
print(f'{type(back_to_uuid)} {back_to_uuid}')
print(my_uuid == back_to_uuid)
print(datetime.datetime(1582, 10, 15) +
      datetime.timedelta(microseconds=back_to_uuid.time//10))

Output:
2020-07-07 20:07:14.264177
<class 'str'> 7320546e-c08d-11ea-89fb-0c9d92c73acb
<class 'uuid.UUID'> 7320546e-c08d-11ea-89fb-0c9d92c73acb
<class 'uuid.UUID'> 7320546e-c08d-11ea-89fb-0c9d92c73acb
True
2020-07-07 20:07:14.264177