from typing import Optional

from datetime import datetime

def convert_timestamp_string_to_epoch(timestamp: str) -> Optional[int]:
    epoch_time = None
    time_obj = datetime.strptime(timestamp, "%Y-%m-%d %H:%M:%S.%f")
    epoch_time = int((time_obj - datetime(1970, 1, 1)).total_seconds() * 1000)
    return epoch_time


print(int(convert_timestamp_string_to_epoch("2025-08-01 13:11:47.171")))
#above outputs 1754053907171.0

#how to I remove the .0 ?

#Python 3: Fibonacci series up to n
def fib(n):
 a, b = 0, 1
 while a < n:
     print(a, end=' ')
     a, b = b, a+b
 print()
fib(1000)

import anytree as at
import random as rm

# Generate a tree with node_count many nodes. Each has a number key that shows when it was made and a randomly selected color, red or white.
def random_tree(node_count):
    
    # Generates the list of nodes
    nodes = []
    for i in range(node_count):
        test = rm.randint(1,2)
        if test == 1:
            nodes.append(at.Node(str(i),color="white"))
        else:
            nodes.append(at.Node(str(i),color="red"))
    
    #Creates the various main branches
    for i in range(node_count):
        for j in range(i, len(nodes)):
            test = rm.randint(1,len(nodes))
            if test == 1 and nodes[j].parent == None and (not nodes[i] == nodes[j]):
                nodes[j].parent = nodes[i]
    
    #Collects all the main branches into a single tree with the first node being the root
    for i in range(1, node_count):
        if nodes[i].parent == None and (not nodes[i] == nodes[0]):
            nodes[i].parent = nodes[0]

    return nodes[0]

primes=[]
products=[]

def prime(num):
    if num > 1:
        for i in range(2,num):
            if (num % i) == 0:
                return False
        else:
            primes.append(num)
            return True

for n in range(30,1000):
    if len(primes) >= 20:
        break;
    else:
        prime(n)

for previous, current in zip(primes[::2], primes[1::2]):
    products.append(previous * current)
    
print (products)

import string

def caesar(text, shift, alphabets):
	def shift_alphabet(alphabet):
	    return alphabet[shift:] + alphabet[:shift]
	
	shifted_alphabets = tuple(map(shift_alphabet, alphabets))
	final_alphabet = "".join(alphabets)
	final_shifted_alphabet = "".join(shifted_alphabets)
	table = str.maketrans(final_alphabet, final_shifted_alphabet)
	return text.translate(table)

plain_text = "Hey Skrome, welcome to CodeCatch"
print(caesar(plain_text, 8, [string.ascii_lowercase, string.ascii_uppercase, string.punctuation]))

#Original
def output_json_log_data_to_file(filename, record_dictionary_list):
    with open(filename, 'w') as outputFile:
        for record in record_dictionary_list:
            json.dump(record, outputFile)
            outputFile.write('\n')


#Atomic
def output_json_log_data_to_file(filename, record_dictionary_list):
    # Use atomic file operations to prevent race conditions with readers
    # Write to temporary file first, then atomically rename to target file
    tmp_filename = filename + '.tmp'
    with open(tmp_filename, 'w') as outputFile:
        for record in record_dictionary_list:
            json.dump(record, outputFile)
            outputFile.write('\n')
    # Atomic rename - this prevents readers from seeing partial writes
    shutil.move(tmp_filename, filename)