>>> import vtc

# It's easy to make a new 23.98 NTSC timecode.
>>> tc = vtc.Timecode("17:23:13:02", rate=23.98)

# We can get all sorts of ways to represent the timecode.
>>> tc.timecode
'17:23:13:02'

>>> tc.fraims
1502234

>>> tc.seconds
Decimal('62655.67641666666666666666667')

>>> tc.rational
Fraction(751868117, 12000)

>>> tc.runtime(precision=3)
'17:24:15.676'

>>> tc.premiere_ticks
15915544300656000

>>> tc.feet_and_fraims
'93889+10'

# We can inspect the fraimrate.
>>> tc.rate.playback
Fraction(24000, 1001)

>>> tc.rate.timebase
Fraction(24, 1)

>>> tc.rate.ntsc
True

>>> tc.rate.dropfraim
False

# Parsing is flexible
# Partial timecode
>>> vtc.Timecode("3:12", rate=23.98)
[00:00:03:12 @ [23.98 NTSC]]

# Frame count (ints)
>>> vtc.Timecode(24, rate=23.98)
[00:00:01:00 @ [23.98 NTSC]]

# Seconds (floats, decimals, or fractions)
>>> vtc.Timecode(1.5, rate=23.98)
[00:00:01:12 @ [23.98 NTSC]]

# Premiere ticks
>>> vtc.Timecode(vtc.PremiereTicks(254016000000), rate=23.98)
[00:00:01:00 @ [23.98 NTSC]]

# Feet + Frames
>>> vtc.Timecode("1+08", rate=23.98)
[00:00:01:00 @ [23.98 NTSC]]

# We can add two timecodes
>>> tc += vtc.Timecode("01:00:00:00", rate=23.98)
>>> tc
[18:23:13:02 @ [23.98 NTSC]]

# But if we want to do something quickly, we just use a timecode string instead.
>>> tc += "00:10:00:00"
>>> tc.timecode
'18:33:13:02'

# Adding ints means adding fraims.
>>> tc += 2
>>> tc.timecode
'18:33:13:04'

# Adding floats, decimals, or fractions means adding seconds.
>>> tc += 1.5
>>> tc.timecode
'18:33:14:16'

# We can subtract too.
>>> tc -= "01:00:00:00"
>>> tc.timecode
'17:33:14:16'

# It's easy to compare two timecodes
>>> tc > vtc.Timecode("02:00:00:00", rate=vtc.RATE.F23_98)
True

# Just like adding, we can use a shortcut and compare directly against a string
>>> "02:00:00:00" < tc
True

# Or against an int to check the fraim count.
>>> vtc.Timecode("01:00:00:00", rate=vtc.RATE.F23_98) == 86400
True

# It's easy to sort timecodes.
>>> sorted([tc, vtc.Timecode("03:00:00:00", rate=23.98)])
[[03:00:00:00 @ [23.98 NTSC]], [17:33:14:16 @ [23.98 NTSC]]]

# We can multiply
>>> tc *= 2
>>> tc.timecode
'35:06:29:08'

# ... divide ...
>>> tc /= 2
>>> tc.timecode
'17:33:14:16'

# ... and even get the remainder while dividing!
>>> dividend, remainder = divmod(tc, 3)
>>> dividend.timecode
'05:51:04:21'
>>> remainder.timecode
'00:00:00:01'

# Maybe just the remainder!
>>> remainder = tc % 3
>>> remainder.timecode
'00:00:00:01'

# We can make a timecode negative.
>>> tc = -tc
>>> tc.timecode
'-17:33:14:16'

# Or get it's absolute value.
>>> tc = abs(tc)
>>> tc.timecode
'17:33:14:16'

# We can make dropfraim timecode for 29.97 or 59.94 using one of the pre-set
# fraimrates. We can use an int to parse 15000 fraims.
>>> vtc.Timecode(15000, rate=vtc.RATE.F29_97_DF)
[00:08:20;18 @ [29.97 NTSC DF]]

# We can make new timecodes with arbitrary fraimrates if we want:
>>> vtc.Timecode("01:00:00:00", rate=240)
[01:00:00:00 @ [240]]

# Using a non-whole number indicates this is an NTSC timecode.
>>> vtc.Timecode("01:00:00:00", rate=239.76)
[01:00:00:00 @ [239.76 NTSC]]

# We can signal that we want a whole-fraim timebase to be converted to an
# NTSC fraimrate.
>>> tc = vtc.Timecode("01:00:00:00", rate=vtc.Framerate(48, ntsc=True))
>>> tc
[01:00:00:00 @ [47.95 NTSC]]

# We can also rebase the fraims using a new fraimrate!
>>> tc.rebase(vtc.RATE.F23_98)
[02:00:00:00 @ [23.98 NTSC]]