import warnings
try: import td1inner as td1
except Exception: warnings.warn(f"timediffz 1.0.9(fractions mode) failed to load correctly :( using any fractions mode related function WOULD give an error and fall because of this, for fix do pip install td1inner")
try: import td2inner as td2
except Exception: warnings.warn(f"""timediffz 1.0.9 (fractionals mode) failed to load correctly :( using any fractionals mode related function WOULD give an error and fall because of this, to fix either/both do steps in fractionalstd2inner readme at this
link 'https://github.com/WeDu-official/fractionalstd2inner' and install td2inner via 'pip install td2inner' """)
def pdiff (s,e,tz_s=0,tz_e=0,unit_factor=1,count_ls_param=True,UTDLS=False,input_utc=True,output_tt=False,apply_gps_rel_s=False,
    apply_gps_rel_e=False,altitude_m_s=20200000,altitude_m_e=20200000,v_m_s_s=3874,v_m_s_e=3874):
    """this function give the difference between the two dates(s and e) in unit_factor, fractions version
    S: is the first date(starting date) and it's a list made off: [Y(year),M(month),D(day),H(hour),MI(minute),S(second),SS(sub-seconds)] and all of these items integers
    E: is the second date(ending date) and it has same format and data type as S
    tz_s: is the timezone where the S date was measured in by default library is set to use greenwich(england) time, and it's an integer value
    tz_e: is the same as tz_s in everything, but it's for E date
    unit_factor: this is the unit to be used, basically the difference between dates would be done in seconds , so you can if you want to get result in minutes for example
    to do that , make it into 60 and the difference would be divided by 60 leading to result being in the unit of minutes, and it's an integer
    count_ls_param: enabling this would count leap-seconds, boolean
    UTDLS: enabling this is useless in all cases except when count_ls_param is True, and it would fetch a list of updated leap seconds from the internet, boolean
    input_utc: this one is by default true, which is when your input is in the UTC system, if it's not make this parameter false
    and your dates would be considered as TAI input, boolean
    output_tt: this one is by default false, which is when you wanna your output to be in TT, boolean
    apply_gps_rel_s: this one is by default false, used only when relativity(for near orbit objects like satellites) is wanted for first timestamp, boolean
    apply_gps_rel_e: this one is by default false, used only when relativity(for near orbit objects like satellites) is wanted for second timestamp, boolean
    altitude_m_s: the height of object of first timestamp like a satellite,needed when relativity is wanted, int
    altitude_m_e: the height of object of second timestamp like a satellite,needed when relativity is wanted, int
    v_m_s_s:the velocity of object of first timestamp like a satellite,needed when relativity is wanted, int
    v_m_s_s:the velocity of object of second timestamp like a satellite,needed when relativity is wanted, int
    """
    return td1._time_difference(s, e, tz_s=tz_s, tz_e=tz_e, unit_factor=unit_factor, input_utc=input_utc, count_ls_param=count_ls_param, UTDLS=UTDLS, output_tt=output_tt,apply_gps_rel_s=apply_gps_rel_s,apply_gps_rel_e=apply_gps_rel_e,altitude_m_s=altitude_m_s,altitude_m_e=altitude_m_e,v_m_s_s=v_m_s_s,v_m_s_e=v_m_s_e)
def cdiff (s,e,tz_s=0,tz_e=0,unit_factor=1,count_ls_param=True,UTDLS=False,input_utc=True,output_tt=False,
    apply_gps_rel_s=False,apply_gps_rel_e=False,altitude_m_s=20200000,altitude_m_e=20200000,v_m_s_s=3874,v_m_s_e=3874):
    """this function give the difference between the two dates(s and e) in unit_factor, fractionals version
    S: is the first date(starting date) and it's a list made off: [Y(year),M(month),D(day),H(hour),MI(minute),S(second),SS(sub-seconds)] and all of these items integers
    E: is the second date(ending date) and it has same format and data type as S
    tz_s: is the timezone where the S date was measured in by default library is set to use greenwich(england) time, and it's an integer value
    tz_e: is the same as tz_s in everything, but it's for E date
    unit_factor: this is the unit to be used, basically the difference between dates would be done in seconds , so you can if you want to get result in minutes for example
    to do that , make it into 60 and the difference would be divided by 60 leading to result being in the unit of minutes, and it's an integer
    count_ls_param: enabling this would count leap-seconds, boolean
    UTDLS: enabling this is useless in all cases except when count_ls_param is True, and it would fetch a list of updated leap seconds from the internet, boolean
    input_utc: this one is by default true, which is when your input is in the UTC system, if it's not make this parameter false
    and your dates would be considered as TAI input, boolean
    output_tt: this one is by default false, which is when you wanna your output to be in TT, boolean
    apply_gps_rel_s: this one is by default false, used only when relativity(for near orbit objects like satellites) is wanted for first timestamp, boolean
    apply_gps_rel_e: this one is by default false, used only when relativity(for near orbit objects like satellites) is wanted for second timestamp, boolean
    altitude_m_s: the height of object of first timestamp like a satellite,needed when relativity is wanted, int
    altitude_m_e: the height of object of second timestamp like a satellite,needed when relativity is wanted, int
    v_m_s_s:the velocity of object of first timestamp like a satellite,needed when relativity is wanted, int
    v_m_s_s:the velocity of object of second timestamp like a satellite,needed when relativity is wanted, int
    """
    return td2._time_difference(s, e, tz_s=tz_s, tz_e=tz_e, unit_factor=unit_factor, input_utc=input_utc, count_ls_param=count_ls_param, UTDLS=UTDLS, output_tt=output_tt,apply_gps_rel_s=apply_gps_rel_s,apply_gps_rel_e=apply_gps_rel_e,altitude_m_s=altitude_m_s,altitude_m_e=altitude_m_e,v_m_s_s=v_m_s_s,v_m_s_e=v_m_s_e)
def pdseconds (s,e,tz_s=0,tz_e=0,count_ls_param=True,UTDLS=False,input_utc=True,output_tt=False,apply_gps_rel_s=False,apply_gps_rel_e=False,altitude_m_s=20200000,altitude_m_e=20200000,v_m_s_s=3874,v_m_s_e=3874):
    """this function give the difference between the two dates(s and e) in seconds, fractions version
    S: is the first date(starting date) and it's a list made off: [Y(year),M(month),D(day),H(hour),MI(minute),S(second),SS(sub-seconds)] and all of these items integers
    E: is the second date(ending date) and it has same format and data type as S
    tz_s: is the timezone where the S date was measured in by default library is set to use greenwich(england) time, and it's an integer value
    tz_e: is the same as tz_s in everything, but it's for E date
    count_ls_param: enabling this would count leap-seconds, boolean
    UTDLS: enabling this is useless in all cases except when count_ls_param is True, and it would fetch a list of updated leap seconds from the internet, boolean
    input_utc: this one is by default true, which is when your input is in the UTC system, if it's not make this parameter false
    and your dates would be considered as TAI input, boolean
    output_tt: this one is by default false, which is when you wanna your output to be in TT, boolean
    apply_gps_rel_s: this one is by default false, used only when relativity(for near orbit objects like satellites) is wanted for first timestamp, boolean
    apply_gps_rel_e: this one is by default false, used only when relativity(for near orbit objects like satellites) is wanted for second timestamp, boolean
    altitude_m_s: the height of object of first timestamp like a satellite,needed when relativity is wanted, int
    altitude_m_e: the height of object of second timestamp like a satellite,needed when relativity is wanted, int
    v_m_s_s:the velocity of object of first timestamp like a satellite,needed when relativity is wanted, int
    v_m_s_s:the velocity of object of second timestamp like a satellite,needed when relativity is wanted, int
    """
    return td1._time_difference(s, e, tz_s=tz_s, tz_e=tz_e, unit_factor=1, input_utc=input_utc, count_ls_param=count_ls_param, UTDLS=UTDLS, output_tt=output_tt,apply_gps_rel_s=apply_gps_rel_s,apply_gps_rel_e=apply_gps_rel_e,altitude_m_s=altitude_m_s,altitude_m_e=altitude_m_e,v_m_s_s=v_m_s_s,v_m_s_e=v_m_s_e)
def cdseconds(s, e, tz_s=0, tz_e=0, count_ls_param=True, UTDLS=False, input_utc=True, output_tt=False,apply_gps_rel_s=False,
              apply_gps_rel_e=False,altitude_m_s=20200000,altitude_m_e=20200000,v_m_s_s=3874,v_m_s_e=3874):
    """this function give the difference between the two dates(s and e) in seconds, fractionals version
        S: is the first date(starting date) and it's a list made off: [Y(year),M(month),D(day),H(hour),MI(minute),S(second),SS(sub-seconds)] and all of these items integers
        E: is the second date(ending date) and it has same format and data type as S
        tz_s: is the timezone where the S date was measured in by default library is set to use greenwich(england) time, and it's an integer value
        tz_e: is the same as tz_s in everything, but it's for E date
        count_ls_param: enabling this would count leap-seconds, boolean
        UTDLS: enabling this is useless in all cases except when count_ls_param is True, and it would fetch a list of updated leap seconds from the internet, boolean
        input_utc: this one is by default true, which is when your input is in the UTC system, if it's not make this parameter false
        and your dates would be considered as TAI input, boolean
        output_tt: this one is by default false, which is when you wanna your output to be in TT, boolean
        apply_gps_rel_s: this one is by default false, used only when relativity(for near orbit objects like satellites) is wanted for first timestamp, boolean
        apply_gps_rel_e: this one is by default false, used only when relativity(for near orbit objects like satellites) is wanted for second timestamp, boolean
        altitude_m_s: the height of object of first timestamp like a satellite,needed when relativity is wanted, int
        altitude_m_e: the height of object of second timestamp like a satellite,needed when relativity is wanted, int
        v_m_s_s:the velocity of object of first timestamp like a satellite,needed when relativity is wanted, int
        v_m_s_s:the velocity of object of second timestamp like a satellite,needed when relativity is wanted, int
        """
    return td2._time_difference(s, e, tz_s=tz_s, tz_e=tz_e, unit_factor=1, input_utc=input_utc, count_ls_param=count_ls_param, UTDLS=UTDLS, output_tt=output_tt,apply_gps_rel_s=apply_gps_rel_s,apply_gps_rel_e=apply_gps_rel_e,altitude_m_s=altitude_m_s,altitude_m_e=altitude_m_e,v_m_s_s=v_m_s_s,v_m_s_e=v_m_s_e)
def pdminutes (s,e,tz_s=0,tz_e=0,count_ls_param=True,UTDLS=False,input_utc=True,output_tt=False,
               apply_gps_rel_s=False,apply_gps_rel_e=False,altitude_m_s=20200000,altitude_m_e=20200000,v_m_s_s=3874,v_m_s_e=3874):
    """this function give the difference between the two dates(s and e) in minutes, fractions version
        S: is the first date(starting date) and it's a list made off: [Y(year),M(month),D(day),H(hour),MI(minute),S(second),SS(sub-seconds)] and all of these items integers
        E: is the second date(ending date) and it has same format and data type as S
        tz_s: is the timezone where the S date was measured in by default library is set to use greenwich(england) time, and it's an integer value
        tz_e: is the same as tz_s in everything, but it's for E date
        count_ls_param: enabling this would count leap-seconds, boolean
        UTDLS: enabling this is useless in all cases except when count_ls_param is True, and it would fetch a list of updated leap seconds from the internet, boolean
        input_utc: this one is by default true, which is when your input is in the UTC system, if it's not make this parameter false
        and your dates would be considered as TAI input, boolean
        output_tt: this one is by default false, which is when you wanna your output to be in TT, boolean
        apply_gps_rel_s: this one is by default false, used only when relativity(for near orbit objects like satellites) is wanted for first timestamp, boolean
        apply_gps_rel_e: this one is by default false, used only when relativity(for near orbit objects like satellites) is wanted for second timestamp, boolean
        altitude_m_s: the height of object of first timestamp like a satellite,needed when relativity is wanted, int
        altitude_m_e: the height of object of second timestamp like a satellite,needed when relativity is wanted, int
        v_m_s_s:the velocity of object of first timestamp like a satellite,needed when relativity is wanted, int
        v_m_s_s:the velocity of object of second timestamp like a satellite,needed when relativity is wanted, int
        """
    return td1._time_difference(s, e, tz_s=tz_s, tz_e=tz_e, unit_factor=60, input_utc=input_utc, count_ls_param=count_ls_param, UTDLS=UTDLS, output_tt=output_tt,apply_gps_rel_s=apply_gps_rel_s,apply_gps_rel_e=apply_gps_rel_e,altitude_m_s=altitude_m_s,altitude_m_e=altitude_m_e,v_m_s_s=v_m_s_s,v_m_s_e=v_m_s_e)
def cdminutes(s, e, tz_s=0, tz_e=0, count_ls_param=True, UTDLS=False, input_utc=True, output_tt=False,
              apply_gps_rel_s=False,apply_gps_rel_e=False,altitude_m_s=20200000,altitude_m_e=20200000,v_m_s_s=3874,v_m_s_e=3874):
    """this function give the difference between the two dates(s and e) in minutes, fractionals version
        S: is the first date(starting date) and it's a list made off: [Y(year),M(month),D(day),H(hour),MI(minute),S(second),SS(sub-seconds)] and all of these items integers
        E: is the second date(ending date) and it has same format and data type as S
        tz_s: is the timezone where the S date was measured in by default library is set to use greenwich(england) time, and it's an integer value
        tz_e: is the same as tz_s in everything, but it's for E date
        count_ls_param: enabling this would count leap-seconds, boolean
        UTDLS: enabling this is useless in all cases except when count_ls_param is True, and it would fetch a list of updated leap seconds from the internet, boolean
        input_utc: this one is by default true, which is when your input is in the UTC system, if it's not make this parameter false
        and your dates would be considered as TAI input, boolean
        output_tt: this one is by default false, which is when you wanna your output to be in TT, boolean
        apply_gps_rel_s: this one is by default false, used only when relativity(for near orbit objects like satellites) is wanted for first timestamp, boolean
        apply_gps_rel_e: this one is by default false, used only when relativity(for near orbit objects like satellites) is wanted for second timestamp, boolean
        altitude_m_s: the height of object of first timestamp like a satellite,needed when relativity is wanted, int
        altitude_m_e: the height of object of second timestamp like a satellite,needed when relativity is wanted, int
        v_m_s_s:the velocity of object of first timestamp like a satellite,needed when relativity is wanted, int
        v_m_s_s:the velocity of object of second timestamp like a satellite,needed when relativity is wanted, int
        """
    return td2._time_difference(s, e, tz_s=tz_s, tz_e=tz_e, unit_factor=60, input_utc=input_utc, count_ls_param=count_ls_param, UTDLS=UTDLS, output_tt=output_tt,apply_gps_rel_s=apply_gps_rel_s,apply_gps_rel_e=apply_gps_rel_e,altitude_m_s=altitude_m_s,altitude_m_e=altitude_m_e,v_m_s_s=v_m_s_s,v_m_s_e=v_m_s_e)
def pdhours (s,e,tz_s=0,tz_e=0,count_ls_param=True,UTDLS=False,input_utc=True,output_tt=False,
             apply_gps_rel_s=False,apply_gps_rel_e=False,altitude_m_s=20200000,altitude_m_e=20200000,v_m_s_s=3874,v_m_s_e=3874):
    """this function give the difference between the two dates(s and e) in hours, fractions version
        S: is the first date(starting date) and it's a list made off: [Y(year),M(month),D(day),H(hour),MI(minute),S(second),SS(sub-seconds)] and all of these items integers
        E: is the second date(ending date) and it has same format and data type as S
        tz_s: is the timezone where the S date was measured in by default library is set to use greenwich(england) time, and it's an integer value
        tz_e: is the same as tz_s in everything, but it's for E date
        count_ls_param: enabling this would count leap-seconds, boolean
        UTDLS: enabling this is useless in all cases except when count_ls_param is True, and it would fetch a list of updated leap seconds from the internet, boolean
        input_utc: this one is by default true, which is when your input is in the UTC system, if it's not make this parameter false
        and your dates would be considered as TAI input, boolean
        output_tt: this one is by default false, which is when you wanna your output to be in TT, boolean
        apply_gps_rel_s: this one is by default false, used only when relativity(for near orbit objects like satellites) is wanted for first timestamp, boolean
        apply_gps_rel_e: this one is by default false, used only when relativity(for near orbit objects like satellites) is wanted for second timestamp, boolean
        altitude_m_s: the height of object of first timestamp like a satellite,needed when relativity is wanted, int
        altitude_m_e: the height of object of second timestamp like a satellite,needed when relativity is wanted, int
        v_m_s_s:the velocity of object of first timestamp like a satellite,needed when relativity is wanted, int
        v_m_s_s:the velocity of object of second timestamp like a satellite,needed when relativity is wanted, int
        """
    return td1._time_difference(s, e, tz_s=tz_s, tz_e=tz_e, unit_factor=3600, input_utc=input_utc, count_ls_param=count_ls_param, UTDLS=UTDLS, output_tt=output_tt,apply_gps_rel_s=apply_gps_rel_s,apply_gps_rel_e=apply_gps_rel_e,altitude_m_s=altitude_m_s,altitude_m_e=altitude_m_e,v_m_s_s=v_m_s_s,v_m_s_e=v_m_s_e)
def cdhours(s, e, tz_s=0, tz_e=0, count_ls_param=True, UTDLS=False, input_utc=True, output_tt=False,
            apply_gps_rel_s=False,apply_gps_rel_e=False,altitude_m_s=20200000,altitude_m_e=20200000,v_m_s_s=3874,v_m_s_e=3874):
    """this function give the difference between the two dates(s and e) in hours, fractionals version
        S: is the first date(starting date) and it's a list made off: [Y(year),M(month),D(day),H(hour),MI(minute),S(second),SS(sub-seconds)] and all of these items integers
        E: is the second date(ending date) and it has same format and data type as S
        tz_s: is the timezone where the S date was measured in by default library is set to use greenwich(england) time, and it's an integer value
        tz_e: is the same as tz_s in everything, but it's for E date
        count_ls_param: enabling this would count leap-seconds, boolean
        UTDLS: enabling this is useless in all cases except when count_ls_param is True, and it would fetch a list of updated leap seconds from the internet, boolean
        input_utc: this one is by default true, which is when your input is in the UTC system, if it's not make this parameter false
        and your dates would be considered as TAI input, boolean
        output_tt: this one is by default false, which is when you wanna your output to be in TT, boolean
        apply_gps_rel_s: this one is by default false, used only when relativity(for near orbit objects like satellites) is wanted for first timestamp, boolean
        apply_gps_rel_e: this one is by default false, used only when relativity(for near orbit objects like satellites) is wanted for second timestamp, boolean
        altitude_m_s: the height of object of first timestamp like a satellite,needed when relativity is wanted, int
        altitude_m_e: the height of object of second timestamp like a satellite,needed when relativity is wanted, int
        v_m_s_s:the velocity of object of first timestamp like a satellite,needed when relativity is wanted, int
        v_m_s_s:the velocity of object of second timestamp like a satellite,needed when relativity is wanted, int
        """
    return td2._time_difference(s, e, tz_s=tz_s, tz_e=tz_e, unit_factor=3600, input_utc=input_utc, count_ls_param=count_ls_param, UTDLS=UTDLS, output_tt=output_tt,apply_gps_rel_s=apply_gps_rel_s,apply_gps_rel_e=apply_gps_rel_e,altitude_m_s=altitude_m_s,altitude_m_e=altitude_m_e,v_m_s_s=v_m_s_s,v_m_s_e=v_m_s_e)
def pddays (s,e,tz_s=0,tz_e=0,count_ls_param=True,UTDLS=False,input_utc=True,output_tt=False,
            apply_gps_rel_s=False,apply_gps_rel_e=False,altitude_m_s=20200000,altitude_m_e=20200000,v_m_s_s=3874,v_m_s_e=3874):
    """this function give the difference between the two dates(s and e) in days, fractions version
        S: is the first date(starting date) and it's a list made off: [Y(year),M(month),D(day),H(hour),MI(minute),S(second),SS(sub-seconds)] and all of these items integers
        E: is the second date(ending date) and it has same format and data type as S
        tz_s: is the timezone where the S date was measured in by default library is set to use greenwich(england) time, and it's an integer value
        tz_e: is the same as tz_s in everything, but it's for E date
        count_ls_param: enabling this would count leap-seconds, boolean
        UTDLS: enabling this is useless in all cases except when count_ls_param is True, and it would fetch a list of updated leap seconds from the internet, boolean
        input_utc: this one is by default true, which is when your input is in the UTC system, if it's not make this parameter false
        and your dates would be considered as TAI input, boolean
        output_tt: this one is by default false, which is when you wanna your output to be in TT, boolean
        apply_gps_rel_s: this one is by default false, used only when relativity(for near orbit objects like satellites) is wanted for first timestamp, boolean
        apply_gps_rel_e: this one is by default false, used only when relativity(for near orbit objects like satellites) is wanted for second timestamp, boolean
        altitude_m_s: the height of object of first timestamp like a satellite,needed when relativity is wanted, int
        altitude_m_e: the height of object of second timestamp like a satellite,needed when relativity is wanted, int
        v_m_s_s:the velocity of object of first timestamp like a satellite,needed when relativity is wanted, int
        v_m_s_s:the velocity of object of second timestamp like a satellite,needed when relativity is wanted, int
        """
    return td1._time_difference(s, e, tz_s=tz_s, tz_e=tz_e, unit_factor=86400, input_utc=input_utc, count_ls_param=count_ls_param, UTDLS=UTDLS, output_tt=output_tt,apply_gps_rel_s=apply_gps_rel_s,apply_gps_rel_e=apply_gps_rel_e,altitude_m_s=altitude_m_s,altitude_m_e=altitude_m_e,v_m_s_s=v_m_s_s,v_m_s_e=v_m_s_e)
def cddays(s, e, tz_s=0, tz_e=0, count_ls_param=True, UTDLS=False, input_utc=True, output_tt=False,
           apply_gps_rel_s=False,apply_gps_rel_e=False,altitude_m_s=20200000,altitude_m_e=20200000,v_m_s_s=3874,v_m_s_e=3874):
    """this function give the difference between the two dates(s and e) in seconds, fractionals version
        S: is the first date(starting date) and it's a list made off: [Y(year),M(month),D(day),H(hour),MI(minute),S(second),SS(sub-seconds)] and all of these items integers
        E: is the second date(ending date) and it has same format and data type as S
        tz_s: is the timezone where the S date was measured in by default library is set to use greenwich(england) time, and it's an integer value
        tz_e: is the same as tz_s in everything, but it's for E date
        count_ls_param: enabling this would count leap-seconds, boolean
        UTDLS: enabling this is useless in all cases except when count_ls_param is True, and it would fetch a list of updated leap seconds from the internet, boolean
        input_utc: this one is by default true, which is when your input is in the UTC system, if it's not make this parameter false
        and your dates would be considered as TAI input, boolean
        output_tt: this one is by default false, which is when you wanna your output to be in TT, boolean
        apply_gps_rel_s: this one is by default false, used only when relativity(for near orbit objects like satellites) is wanted for first timestamp, boolean
        apply_gps_rel_e: this one is by default false, used only when relativity(for near orbit objects like satellites) is wanted for second timestamp, boolean
        altitude_m_s: the height of object of first timestamp like a satellite,needed when relativity is wanted, int
        altitude_m_e: the height of object of second timestamp like a satellite,needed when relativity is wanted, int
        v_m_s_s:the velocity of object of first timestamp like a satellite,needed when relativity is wanted, int
        v_m_s_s:the velocity of object of second timestamp like a satellite,needed when relativity is wanted, int
        """
    return td2._time_difference(s, e, tz_s=tz_s, tz_e=tz_e, unit_factor=86400, input_utc=input_utc, count_ls_param=count_ls_param, UTDLS=UTDLS, output_tt=output_tt,apply_gps_rel_s=apply_gps_rel_s,apply_gps_rel_e=apply_gps_rel_e,altitude_m_s=altitude_m_s,altitude_m_e=altitude_m_e,v_m_s_s=v_m_s_s,v_m_s_e=v_m_s_e)
def pdweeks (s,e,tz_s=0,tz_e=0,count_ls_param=True,UTDLS=False,input_utc=True,output_tt=False,
             apply_gps_rel_s=False,apply_gps_rel_e=False,altitude_m_s=20200000,altitude_m_e=20200000,v_m_s_s=3874,v_m_s_e=3874):
    """this function give the difference between the two dates(s and e) in weeks, fractions version
        S: is the first date(starting date) and it's a list made off: [Y(year),M(month),D(day),H(hour),MI(minute),S(second),SS(sub-seconds)] and all of these items integers
        E: is the second date(ending date) and it has same format and data type as S
        tz_s: is the timezone where the S date was measured in by default library is set to use greenwich(england) time, and it's an integer value
        tz_e: is the same as tz_s in everything, but it's for E date
        count_ls_param: enabling this would count leap-seconds, boolean
        UTDLS: enabling this is useless in all cases except when count_ls_param is True, and it would fetch a list of updated leap seconds from the internet, boolean
        input_utc: this one is by default true, which is when your input is in the UTC system, if it's not make this parameter false
        and your dates would be considered as TAI input, boolean
        output_tt: this one is by default false, which is when you wanna your output to be in TT, boolean
        apply_gps_rel_s: this one is by default false, used only when relativity(for near orbit objects like satellites) is wanted for first timestamp, boolean
        apply_gps_rel_e: this one is by default false, used only when relativity(for near orbit objects like satellites) is wanted for second timestamp, boolean
        altitude_m_s: the height of object of first timestamp like a satellite,needed when relativity is wanted, int
        altitude_m_e: the height of object of second timestamp like a satellite,needed when relativity is wanted, int
        v_m_s_s:the velocity of object of first timestamp like a satellite,needed when relativity is wanted, int
        v_m_s_s:the velocity of object of second timestamp like a satellite,needed when relativity is wanted, int
        """
    return td1._time_difference(s, e, tz_s=tz_s, tz_e=tz_e, unit_factor=86400 * 7, input_utc=input_utc, count_ls_param=count_ls_param, UTDLS=UTDLS, output_tt=output_tt,apply_gps_rel_s=apply_gps_rel_s,apply_gps_rel_e=apply_gps_rel_e,altitude_m_s=altitude_m_s,altitude_m_e=altitude_m_e,v_m_s_s=v_m_s_s,v_m_s_e=v_m_s_e)
def cdweeks(s, e, tz_s=0, tz_e=0, count_ls_param=True, UTDLS=False, input_utc=True, output_tt=False,
            apply_gps_rel_s=False,apply_gps_rel_e=False,altitude_m_s=20200000,altitude_m_e=20200000,v_m_s_s=3874,v_m_s_e=3874):
    """this function give the difference between the two dates(s and e) in weeks, fractionals version
        S: is the first date(starting date) and it's a list made off: [Y(year),M(month),D(day),H(hour),MI(minute),S(second),SS(sub-seconds)] and all of these items integers
        E: is the second date(ending date) and it has same format and data type as S
        tz_s: is the timezone where the S date was measured in by default library is set to use greenwich(england) time, and it's an integer value
        tz_e: is the same as tz_s in everything, but it's for E date
        count_ls_param: enabling this would count leap-seconds, boolean
        UTDLS: enabling this is useless in all cases except when count_ls_param is True, and it would fetch a list of updated leap seconds from the internet, boolean
        input_utc: this one is by default true, which is when your input is in the UTC system, if it's not make this parameter false
        and your dates would be considered as TAI input, boolean
        output_tt: this one is by default false, which is when you wanna your output to be in TT, boolean
        apply_gps_rel_s: this one is by default false, used only when relativity(for near orbit objects like satellites) is wanted for first timestamp, boolean
        apply_gps_rel_e: this one is by default false, used only when relativity(for near orbit objects like satellites) is wanted for second timestamp, boolean
        altitude_m_s: the height of object of first timestamp like a satellite,needed when relativity is wanted, int
        altitude_m_e: the height of object of second timestamp like a satellite,needed when relativity is wanted, int
        v_m_s_s:the velocity of object of first timestamp like a satellite,needed when relativity is wanted, int
        v_m_s_s:the velocity of object of second timestamp like a satellite,needed when relativity is wanted, int
        """
    return td2._time_difference(s, e, tz_s=tz_s, tz_e=tz_e, unit_factor=86400 * 7, input_utc=input_utc, count_ls_param=count_ls_param, UTDLS=UTDLS, output_tt=output_tt,apply_gps_rel_s=apply_gps_rel_s,apply_gps_rel_e=apply_gps_rel_e,altitude_m_s=altitude_m_s,altitude_m_e=altitude_m_e,v_m_s_s=v_m_s_s,v_m_s_e=v_m_s_e)
def pdmonths(s, e, tz_s=0, tz_e=0,month_unit=0, leap_year=False,input_utc=True, output_tt=False,UTDLS=False, count_ls_param=True,use_date_in_leapyears_checking=False,year_for_leapyears_checking=None,reference_year_for_scaling=None,
             apply_gps_rel_s=False,apply_gps_rel_e=False,altitude_m_s=20200000,altitude_m_e=20200000,v_m_s_s=3874,v_m_s_e=3874):
    """this function give the difference between the two dates(s and e) in months, fractions version
        S: is the first date(starting date) and it's a list made off: [Y(year),M(month),D(day),H(hour),MI(minute),S(second),SS(sub-seconds)] and all of these items integers
        E: is the second date(ending date) and it has same format and data type as S
        tz_s: is the timezone where the S date was measured in by default library is set to use greenwich(england) time, and it's an integer value
        tz_e: is the same as tz_s in everything, but it's for E date
        month_unit: is what month you chose to be your unit, like how many junes or how many octobers, it's value corresponds to month it represents, it's an integer
        leap_year: if the year is a leap year or not , useful to determine February's value
        input_utc: this one is by default true, which is when your input is in the UTC system, if it's not make this parameter false
        and your dates would be considered as TAI input, boolean
        output_tt: this one is by default false, which is when you wanna your output to be in TT, boolean
        UTDLS: enabling this is useless in all cases except when count_ls_param is True, and it would fetch a list of updated leap seconds from the internet, boolean
        count_ls_param: enabling this would count leap-seconds, boolean
        use_date_in_leap years_checking: it's an integer value, that would be about to use the year given or written as integer value to determine if year is leap year or not
        year_for_leapyears_checking: it's an integer value, that would be used instead of using the year in starting value to know if to consider
        the year as a leap year or a normal one
        reference_year_for_scaling: it's an boolean value, that would be about if or if not to use the date to determine if year to be used or considered
        is a leap year or not
        apply_gps_rel_s: this one is by default false, used only when relativity(for near orbit objects like satellites) is wanted for first timestamp, boolean
        apply_gps_rel_e: this one is by default false, used only when relativity(for near orbit objects like satellites) is wanted for second timestamp, boolean
        altitude_m_s: the height of object of first timestamp like a satellite,needed when relativity is wanted, int
        altitude_m_e: the height of object of second timestamp like a satellite,needed when relativity is wanted, int
        v_m_s_s:the velocity of object of first timestamp like a satellite,needed when relativity is wanted, int
        v_m_s_s:the velocity of object of second timestamp like a satellite,needed when relativity is wanted, int
        """
    return td1._months_piecewise(s, e, tz_s=tz_s, tz_e=tz_e, month_unit=month_unit, leap_year=leap_year, input_utc=input_utc, UTDLS=UTDLS, count_ls_param=count_ls_param, output_tt=output_tt, use_date_in_leapyears_checking=use_date_in_leapyears_checking, year_for_leapyears_checking=year_for_leapyears_checking, reference_year_for_scaling=reference_year_for_scaling,apply_gps_rel_s=apply_gps_rel_s,apply_gps_rel_e=apply_gps_rel_e,altitude_m_s=altitude_m_s,altitude_m_e=altitude_m_e,v_m_s_s=v_m_s_s,v_m_s_e=v_m_s_e)
def cdmonths(s, e, tz_s=0, tz_e=0,month_unit=0, leap_year=False,input_utc=True, output_tt=False,UTDLS=False, count_ls_param=True,use_date_in_leapyears_checking=False,year_for_leapyears_checking=None,reference_year_for_scaling=None,
             apply_gps_rel_s=False,apply_gps_rel_e=False,altitude_m_s=20200000,altitude_m_e=20200000,v_m_s_s=3874,v_m_s_e=3874):
    """this function give the difference between the two dates(s and e) in months, fractionals version
            S: is the first date(starting date) and it's a list made off: [Y(year),M(month),D(day),H(hour),MI(minute),S(second),SS(sub-seconds)] and all of these items integers
            E: is the second date(ending date) and it has same format and data type as S
            tz_s: is the timezone where the S date was measured in by default library is set to use greenwich(england) time, and it's an integer value
            tz_e: is the same as tz_s in everything, but it's for E date
            month_unit: is what month you chose to be your unit, like how many junes or how many octobers, it's value corresponds to month it represents, it's an integer
            leap_year: if the year is a leap year or not , useful to determine February's value
            input_utc: this one is by default true, which is when your input is in the UTC system, if it's not make this parameter false
            and your dates would be considered as TAI input, boolean
            output_tt: this one is by default false, which is when you wanna your output to be in TT, boolean
            UTDLS: enabling this is useless in all cases except when count_ls_param is True, and it would fetch a list of updated leap seconds from the internet, boolean
            count_ls_param: enabling this would count leap-seconds, boolean
            use_date_in_leap years_checking: it's an integer value, that would be about to use the year given or written as integer value to determine if year is leap year or not
            year_for_leapyears_checking: it's an integer value, that would be used instead of using the year in starting value to know if to consider
            the year as a leap year or a normal one
            reference_year_for_scaling: it's an boolean value, that would be about if or if not to use the date to determine if year to be used or considered
            is a leap year or not
            apply_gps_rel_s: this one is by default false, used only when relativity(for near orbit objects like satellites) is wanted for first timestamp, boolean
            apply_gps_rel_e: this one is by default false, used only when relativity(for near orbit objects like satellites) is wanted for second timestamp, boolean
            altitude_m_s: the height of object of first timestamp like a satellite,needed when relativity is wanted, int
            altitude_m_e: the height of object of second timestamp like a satellite,needed when relativity is wanted, int
            v_m_s_s:the velocity of object of first timestamp like a satellite,needed when relativity is wanted, int
            v_m_s_s:the velocity of object of second timestamp like a satellite,needed when relativity is wanted, int
            """
    return td2._months_piecewise(s, e, tz_s=tz_s, tz_e=tz_e, month_unit=month_unit, leap_year=leap_year, input_utc=input_utc, UTDLS=UTDLS, count_ls_param=count_ls_param, output_tt=output_tt, use_date_in_leapyears_checking=use_date_in_leapyears_checking, year_for_leapyears_checking=year_for_leapyears_checking, reference_year_for_scaling=reference_year_for_scaling,apply_gps_rel_s=apply_gps_rel_s,apply_gps_rel_e=apply_gps_rel_e,altitude_m_s=altitude_m_s,altitude_m_e=altitude_m_e,v_m_s_s=v_m_s_s,v_m_s_e=v_m_s_e)
def pdyears(s, e, tz_s=0, tz_e=0,leap_year=None, uniform_year=False, tropical_year=False, custom_year=None,input_utc=True, output_tt=False,UTDLS=False, count_ls_param=True,year_for_leapyear_checking=None,lock_range_to_reference_year=False,
            apply_gps_rel_s=False,apply_gps_rel_e=False,altitude_m_s=20200000,altitude_m_e=20200000,v_m_s_s=3874,v_m_s_e=3874):
    """this function give the difference between the two dates(s and e) in years, fractions version
                S: is the first date(starting date) and it's a list made off: [Y(year),M(month),D(day),H(hour),MI(minute),S(second),SS(sub-seconds)] and all of these items integers
                E: is the second date(ending date) and it has same format and data type as S
                tz_s: is the timezone where the S date was measured in by default library is set to use greenwich(england) time, and it's an integer value
                tz_e: is the same as tz_s in everything, but it's for E date
                leap_year: if the year unit is a leap year or not , boolean value
                uniform_year: if the year unit is a continuous scale Gregorian year, boolean value
                tropical_year: if the year unit is a tropical years, boolean vale
                custom_year: if not none it would use a custom made year unit, integer value
                input_utc: this one is by default true, which is when your input is in the UTC system, if it's not make this parameter false
                and your dates would be considered as TAI input, boolean
                output_tt: this one is by default false, which is when you wanna your output to be in TT, boolean
                UTDLS: enabling this is useless in all cases except when count_ls_param is True, and it would fetch a list of updated leap seconds from the internet, boolean
                count_ls_param: enabling this would count leap-seconds, boolean
                years_for_leapyear_checking: if to use or not use the year in the date to determine if year is a leap year or not, boolean value
                lock_range_to_reference_year: if true no in between years making the added value to pure difference as zero, while default is max(0, E[0] - S[0] - 1)
                apply_gps_rel_s: this one is by default false, used only when relativity(for near orbit objects like satellites) is wanted for first timestamp, boolean
                apply_gps_rel_e: this one is by default false, used only when relativity(for near orbit objects like satellites) is wanted for second timestamp, boolean
                altitude_m_s: the height of object of first timestamp like a satellite,needed when relativity is wanted, int
                altitude_m_e: the height of object of second timestamp like a satellite,needed when relativity is wanted, int
                v_m_s_s:the velocity of object of first timestamp like a satellite,needed when relativity is wanted, int
                v_m_s_s:the velocity of object of second timestamp like a satellite,needed when relativity is wanted, int
                """
    return td1._years_piecewise(s, e, tz_s=tz_s, tz_e=tz_e, input_utc=input_utc, UTDLS=UTDLS, count_ls_param=count_ls_param, output_tt=output_tt, uniform_year=uniform_year, tropical_year=tropical_year, custom_year=custom_year, leap_year=leap_year, year_for_leapyear_checking=year_for_leapyear_checking, lock_range_to_reference_year=lock_range_to_reference_year,apply_gps_rel_s=apply_gps_rel_s,apply_gps_rel_e=apply_gps_rel_e,altitude_m_s=altitude_m_s,altitude_m_e=altitude_m_e,v_m_s_s=v_m_s_s,v_m_s_e=v_m_s_e)
def cdyears(s, e, tz_s=0, tz_e=0,leap_year=None, uniform_year=False, tropical_year=False, custom_year=None,input_utc=True, output_tt=False,UTDLS=False, count_ls_param=True,year_for_leapyear_checking=None,lock_range_to_reference_year=False,
            apply_gps_rel_s=False,apply_gps_rel_e=False,altitude_m_s=20200000,altitude_m_e=20200000,v_m_s_s=3874,v_m_s_e=3874):
    """this function give the difference between the two dates(s and e) in years, fractionals version
                S: is the first date(starting date) and it's a list made off: [Y(year),M(month),D(day),H(hour),MI(minute),S(second),SS(sub-seconds)] and all of these items integers
                E: is the second date(ending date) and it has same format and data type as S
                tz_s: is the timezone where the S date was measured in by default library is set to use greenwich(england) time, and it's an integer value
                tz_e: is the same as tz_s in everything, but it's for E date
                leap_year: if the year unit is a leap year or not , boolean value
                uniform_year: if the year unit is a continuous scale Gregorian year, boolean value
                tropical_year: if the year unit is a tropical years, boolean vale
                custom_year: if not none it would use a custom made year unit, integer value
                input_utc: this one is by default true, which is when your input is in the UTC system, if it's not make this parameter false
                and your dates would be considered as TAI input, boolean
                output_tt: this one is by default false, which is when you wanna your output to be in TT, boolean
                UTDLS: enabling this is useless in all cases except when count_ls_param is True, and it would fetch a list of updated leap seconds from the internet, boolean
                count_ls_param: enabling this would count leap-seconds, boolean
                years_for_leapyear_checking: if to use or not use the year in the date to determine if year is a leap year or not, boolean value
                lock_range_to_reference_year: if true no in between years making the added value to pure difference as zero, while default is max(0, E[0] - S[0] - 1)
                apply_gps_rel_s: this one is by default false, used only when relativity(for near orbit objects like satellites) is wanted for first timestamp, boolean
                apply_gps_rel_e: this one is by default false, used only when relativity(for near orbit objects like satellites) is wanted for second timestamp, boolean
                altitude_m_s: the height of object of first timestamp like a satellite,needed when relativity is wanted, int
                altitude_m_e: the height of object of second timestamp like a satellite,needed when relativity is wanted, int
                v_m_s_s:the velocity of object of first timestamp like a satellite,needed when relativity is wanted, int
                v_m_s_s:the velocity of object of second timestamp like a satellite,needed when relativity is wanted, int
                """
    return td2._years_piecewise(s, e, tz_s=tz_s, tz_e=tz_e, input_utc=input_utc, UTDLS=UTDLS, count_ls_param=count_ls_param, output_tt=output_tt, uniform_year=uniform_year, tropical_year=tropical_year, custom_year=custom_year, leap_year=leap_year, year_for_leapyear_checking=year_for_leapyear_checking, lock_range_to_reference_year=lock_range_to_reference_year,apply_gps_rel_s=apply_gps_rel_s,apply_gps_rel_e=apply_gps_rel_e,altitude_m_s=altitude_m_s,altitude_m_e=altitude_m_e,v_m_s_s=v_m_s_s,v_m_s_e=v_m_s_e)
def pddecades(s, e, tz_s=0, tz_e=0,leap_year=None, uniform_year=False, tropical_year=False, custom_year=None,input_utc=True, output_tt=False,UTDLS=False, count_ls_param=True,year_for_leapyear_checking=None,lock_range_to_reference_year=False,
              apply_gps_rel_s=False,apply_gps_rel_e=False,altitude_m_s=20200000,altitude_m_e=20200000,v_m_s_s=3874,v_m_s_e=3874):
    """this function give the difference between the two dates(s and e) in decades, fractions version
                    S: is the first date(starting date) and it's a list made off: [Y(year),M(month),D(day),H(hour),MI(minute),S(second),SS(sub-seconds)] and all of these items integers
                    E: is the second date(ending date) and it has same format and data type as S
                    tz_s: is the timezone where the S date was measured in by default library is set to use greenwich(england) time, and it's an integer value
                    tz_e: is the same as tz_s in everything, but it's for E date
                    leap_year: if the year unit is a leap year or not , boolean value
                    uniform_year: if the year unit is a continuous scale Gregorian year, boolean value
                    tropical_year: if the year unit is a tropical years, boolean vale
                    custom_year: if not none it would use a custom made year unit, integer value
                    input_utc: this one is by default true, which is when your input is in the UTC system, if it's not make this parameter false
                    and your dates would be considered as TAI input, boolean
                    output_tt: this one is by default false, which is when you wanna your output to be in TT, boolean
                    UTDLS: enabling this is useless in all cases except when count_ls_param is True, and it would fetch a list of updated leap seconds from the internet, boolean
                    count_ls_param: enabling this would count leap-seconds, boolean
                    years_for_leapyear_checking: if to use or not use the year in the date to determine if year is a leap year or not, boolean value
                    lock_range_to_reference_year: if true no in between years making the added value to pure difference as zero, while default is max(0, E[0] - S[0] - 1)
                    apply_gps_rel_s: this one is by default false, used only when relativity(for near orbit objects like satellites) is wanted for first timestamp, boolean
                    apply_gps_rel_e: this one is by default false, used only when relativity(for near orbit objects like satellites) is wanted for second timestamp, boolean
                    altitude_m_s: the height of object of first timestamp like a satellite,needed when relativity is wanted, int
                    altitude_m_e: the height of object of second timestamp like a satellite,needed when relativity is wanted, int
                    v_m_s_s:the velocity of object of first timestamp like a satellite,needed when relativity is wanted, int
                    v_m_s_s:the velocity of object of second timestamp like a satellite,needed when relativity is wanted, int
                    """
    return td1._years_piecewise(s, e, tz_s=tz_s, tz_e=tz_e, input_utc=input_utc, UTDLS=UTDLS, count_ls_param=count_ls_param, output_tt=output_tt, uniform_year=uniform_year, tropical_year=tropical_year, custom_year=custom_year, leap_year=leap_year, year_for_leapyear_checking=year_for_leapyear_checking, lock_range_to_reference_year=lock_range_to_reference_year,apply_gps_rel_s=apply_gps_rel_s,apply_gps_rel_e=apply_gps_rel_e,altitude_m_s=altitude_m_s,altitude_m_e=altitude_m_e,v_m_s_s=v_m_s_s,v_m_s_e=v_m_s_e)/10
def cddecades(s, e, tz_s=0, tz_e=0,leap_year=None, uniform_year=False, tropical_year=False, custom_year=None,input_utc=True, output_tt=False,UTDLS=False, count_ls_param=True,year_for_leapyear_checking=None,lock_range_to_reference_year=False,
              apply_gps_rel_s=False,apply_gps_rel_e=False,altitude_m_s=20200000,altitude_m_e=20200000,v_m_s_s=3874,v_m_s_e=3874):
    """this function give the difference between the two dates(s and e) in decades, fractionals version
                    S: is the first date(starting date) and it's a list made off: [Y(year),M(month),D(day),H(hour),MI(minute),S(second),SS(sub-seconds)] and all of these items integers
                    E: is the second date(ending date) and it has same format and data type as S
                    tz_s: is the timezone where the S date was measured in by default library is set to use greenwich(england) time, and it's an integer value
                    tz_e: is the same as tz_s in everything, but it's for E date
                    leap_year: if the year unit is a leap year or not , boolean value
                    uniform_year: if the year unit is a continuous scale Gregorian year, boolean value
                    tropical_year: if the year unit is a tropical years, boolean vale
                    custom_year: if not none it would use a custom made year unit, integer value
                    input_utc: this one is by default true, which is when your input is in the UTC system, if it's not make this parameter false
                    and your dates would be considered as TAI input, boolean
                    output_tt: this one is by default false, which is when you wanna your output to be in TT, boolean
                    UTDLS: enabling this is useless in all cases except when count_ls_param is True, and it would fetch a list of updated leap seconds from the internet, boolean
                    count_ls_param: enabling this would count leap-seconds, boolean
                    years_for_leapyear_checking: if to use or not use the year in the date to determine if year is a leap year or not, boolean value
                    lock_range_to_reference_year: if true no in between years making the added value to pure difference as zero, while default is max(0, E[0] - S[0] - 1)
                    apply_gps_rel_s: this one is by default false, used only when relativity(for near orbit objects like satellites) is wanted for first timestamp, boolean
                    apply_gps_rel_e: this one is by default false, used only when relativity(for near orbit objects like satellites) is wanted for second timestamp, boolean
                    altitude_m_s: the height of object of first timestamp like a satellite,needed when relativity is wanted, int
                    altitude_m_e: the height of object of second timestamp like a satellite,needed when relativity is wanted, int
                    v_m_s_s:the velocity of object of first timestamp like a satellite,needed when relativity is wanted, int
                    v_m_s_s:the velocity of object of second timestamp like a satellite,needed when relativity is wanted, int
                    """
    return td2._years_piecewise(s, e, tz_s=tz_s, tz_e=tz_e, input_utc=input_utc, UTDLS=UTDLS, count_ls_param=count_ls_param, output_tt=output_tt, uniform_year=uniform_year, tropical_year=tropical_year, custom_year=custom_year, leap_year=leap_year, year_for_leapyear_checking=year_for_leapyear_checking, lock_range_to_reference_year=lock_range_to_reference_year,apply_gps_rel_s=apply_gps_rel_s,apply_gps_rel_e=apply_gps_rel_e,altitude_m_s=altitude_m_s,altitude_m_e=altitude_m_e,v_m_s_s=v_m_s_s,v_m_s_e=v_m_s_e)/10
def pdcenturies(s, e, tz_s=0, tz_e=0,leap_year=None, uniform_year=False, tropical_year=False, custom_year=None,input_utc=True, output_tt=False,UTDLS=False, count_ls_param=True,year_for_leapyear_checking=None,lock_range_to_reference_year=False,
                apply_gps_rel_s=False,apply_gps_rel_e=False,altitude_m_s=20200000,altitude_m_e=20200000,v_m_s_s=3874,v_m_s_e=3874):
    """this function give the difference between the two dates(s and e) in centuries, fractions version
                    S: is the first date(starting date) and it's a list made off: [Y(year),M(month),D(day),H(hour),MI(minute),S(second),SS(sub-seconds)] and all of these items integers
                    E: is the second date(ending date) and it has same format and data type as S
                    tz_s: is the timezone where the S date was measured in by default library is set to use greenwich(england) time, and it's an integer value
                    tz_e: is the same as tz_s in everything, but it's for E date
                    leap_year: if the year unit is a leap year or not , boolean value
                    uniform_year: if the year unit is a continuous scale Gregorian year, boolean value
                    tropical_year: if the year unit is a tropical years, boolean vale
                    custom_year: if not none it would use a custom made year unit, integer value
                    input_utc: this one is by default true, which is when your input is in the UTC system, if it's not make this parameter false
                    and your dates would be considered as TAI input, boolean
                    output_tt: this one is by default false, which is when you wanna your output to be in TT, boolean
                    UTDLS: enabling this is useless in all cases except when count_ls_param is True, and it would fetch a list of updated leap seconds from the internet, boolean
                    count_ls_param: enabling this would count leap-seconds, boolean
                    years_for_leapyear_checking: if to use or not use the year in the date to determine if year is a leap year or not, boolean value
                    lock_range_to_reference_year: if true no in between years making the added value to pure difference as zero, while default is max(0, E[0] - S[0] - 1)
                    apply_gps_rel_s: this one is by default false, used only when relativity(for near orbit objects like satellites) is wanted for first timestamp, boolean
                    apply_gps_rel_e: this one is by default false, used only when relativity(for near orbit objects like satellites) is wanted for second timestamp, boolean
                    altitude_m_s: the height of object of first timestamp like a satellite,needed when relativity is wanted, int
                    altitude_m_e: the height of object of second timestamp like a satellite,needed when relativity is wanted, int
                    v_m_s_s:the velocity of object of first timestamp like a satellite,needed when relativity is wanted, int
                    v_m_s_s:the velocity of object of second timestamp like a satellite,needed when relativity is wanted, int
                    """
    return td1._years_piecewise(s, e, tz_s=tz_s, tz_e=tz_e, input_utc=input_utc, UTDLS=UTDLS, count_ls_param=count_ls_param, output_tt=output_tt, uniform_year=uniform_year, tropical_year=tropical_year, custom_year=custom_year, leap_year=leap_year, year_for_leapyear_checking=year_for_leapyear_checking, lock_range_to_reference_year=lock_range_to_reference_year,apply_gps_rel_s=apply_gps_rel_s,apply_gps_rel_e=apply_gps_rel_e,altitude_m_s=altitude_m_s,altitude_m_e=altitude_m_e,v_m_s_s=v_m_s_s,v_m_s_e=v_m_s_e)/100
def cdcenturies(s, e, tz_s=0, tz_e=0,leap_year=None, uniform_year=False, tropical_year=False, custom_year=None,input_utc=True, output_tt=False,UTDLS=False, count_ls_param=True,year_for_leapyear_checking=None,lock_range_to_reference_year=False,
                apply_gps_rel_s=False,apply_gps_rel_e=False,altitude_m_s=20200000,altitude_m_e=20200000,v_m_s_s=3874,v_m_s_e=3874):
    """this function give the difference between the two dates(s and e) in centuries, fractionals version
                    S: is the first date(starting date) and it's a list made off: [Y(year),M(month),D(day),H(hour),MI(minute),S(second),SS(sub-seconds)] and all of these items integers
                    E: is the second date(ending date) and it has same format and data type as S
                    tz_s: is the timezone where the S date was measured in by default library is set to use greenwich(england) time, and it's an integer value
                    tz_e: is the same as tz_s in everything, but it's for E date
                    leap_year: if the year unit is a leap year or not , boolean value
                    uniform_year: if the year unit is a continuous scale Gregorian year, boolean value
                    tropical_year: if the year unit is a tropical years, boolean vale
                    custom_year: if not none it would use a custom made year unit, integer value
                    input_utc: this one is by default true, which is when your input is in the UTC system, if it's not make this parameter false
                    and your dates would be considered as TAI input, boolean
                    output_tt: this one is by default false, which is when you wanna your output to be in TT, boolean
                    UTDLS: enabling this is useless in all cases except when count_ls_param is True, and it would fetch a list of updated leap seconds from the internet, boolean
                    count_ls_param: enabling this would count leap-seconds, boolean
                    years_for_leapyear_checking: if to use or not use the year in the date to determine if year is a leap year or not, boolean value
                    lock_range_to_reference_year: if true no in between years making the added value to pure difference as zero, while default is max(0, E[0] - S[0] - 1)
                    apply_gps_rel_s: this one is by default false, used only when relativity(for near orbit objects like satellites) is wanted for first timestamp, boolean
                    apply_gps_rel_e: this one is by default false, used only when relativity(for near orbit objects like satellites) is wanted for second timestamp, boolean
                    altitude_m_s: the height of object of first timestamp like a satellite,needed when relativity is wanted, int
                    altitude_m_e: the height of object of second timestamp like a satellite,needed when relativity is wanted, int
                    v_m_s_y_gps_rel_e: this one is by default false, used only when relativity(for near orbit objects like satellites) is wanted for second timestamp, boolean
                    altitude_m_s: the height of object of first timestamp like a satellite,needed when relativity is wanted, int
                    altitude_m_e: the height of object of second timestamp like a satellite,needed when relativity is wanted, int
                    v_m_s_s:the velocity of object of first timestamp like a satellite,needed when relativity is wanted, int
                    v_m_s_s:s:the velocity of object of first timestamp like a satellite,needed when relativity is wanted, int
                    v_m_s_s:the velocity of object of second timestamp like a satellite,needed when relativity is wanted, int
                    """
    return td2._years_piecewise(s, e, tz_s=tz_s, tz_e=tz_e, input_utc=input_utc, UTDLS=UTDLS, count_ls_param=count_ls_param, output_tt=output_tt, uniform_year=uniform_year, tropical_year=tropical_year, custom_year=custom_year, leap_year=leap_year, year_for_leapyear_checking=year_for_leapyear_checking, lock_range_to_reference_year=lock_range_to_reference_year,apply_gps_rel_s=apply_gps_rel_s,apply_gps_rel_e=apply_gps_rel_e,altitude_m_s=altitude_m_s,altitude_m_e=altitude_m_e,v_m_s_s=v_m_s_s,v_m_s_e=v_m_s_e)/100
def pdmillennia(s, e, tz_s=0, tz_e=0,leap_year=None, uniform_year=False, tropical_year=False, custom_year=None,input_utc=True, output_tt=False,UTDLS=False, count_ls_param=True,year_for_leapyear_checking=None,lock_range_to_reference_year=False,
                apply_gps_rel_s=False,apply_gps_rel_e=False,altitude_m_s=20200000,altitude_m_e=20200000,v_m_s_s=3874,v_m_s_e=3874):
    """this function give the difference between the two dates(s and e) in millennia, fractions version
                        S: is the first date(starting date) and it's a list made off: [Y(year),M(month),D(day),H(hour),MI(minute),S(second),SS(sub-seconds)] and all of these items integers
                        E: is the second date(ending date) and it has same format and data type as S
                        tz_s: is the timezone where the S date was measured in by default library is set to use greenwich(england) time, and it's an integer value
                        tz_e: is the same as tz_s in everything, but it's for E date
                        leap_year: if the year unit is a leap year or not , boolean value
                        uniform_year: if the year unit is a continuous scale Gregorian year, boolean value
                        tropical_year: if the year unit is a tropical years, boolean vale
                        custom_year: if not none it would use a custom made year unit, integer value
                        input_utc: this one is by default true, which is when your input is in the UTC system, if it's not make this parameter false
                        and your dates would be considered as TAI input, boolean
                        output_tt: this one is by default false, which is when you wanna your output to be in TT, boolean
                        UTDLS: enabling this is useless in all cases except when count_ls_param is True, and it would fetch a list of updated leap seconds from the internet, boolean
                        count_ls_param: enabling this would count leap-seconds, boolean
                        years_for_leapyear_checking: if to use or not use the year in the date to determine if year is a leap year or not, boolean value
                        lock_range_to_reference_year: if true no in between years making the added value to pure difference as zero, while default is max(0, E[0] - S[0] - 1)
                        apply_gps_rel_s: this one is by default false, used only when relativity(for near orbit objects like satellites) is wanted for first timestamp, boolean
                        apply_gps_rel_e: this one is by default false, used only when relativity(for near orbit objects like satellites) is wanted for second timestamp, boolean
                        altitude_m_s: the height of object of first timestamp like a satellite,needed when relativity is wanted, int
                        altitude_m_e: the height of object of second timestamp like a satellite,needed when relativity is wanted, int
                        v_m_s_s:the velocity of object of first timestamp like a satellite,needed when relativity is wanted, int
                        v_m_s_s:the velocity of object of second timestamp like a satellite,needed when relativity is wanted, int
                        """
    return td1._years_piecewise(s, e, tz_s=tz_s, tz_e=tz_e, input_utc=input_utc, UTDLS=UTDLS, count_ls_param=count_ls_param, output_tt=output_tt, uniform_year=uniform_year, tropical_year=tropical_year, custom_year=custom_year, leap_year=leap_year, year_for_leapyear_checking=year_for_leapyear_checking, lock_range_to_reference_year=lock_range_to_reference_year,apply_gps_rel_s=apply_gps_rel_s,apply_gps_rel_e=apply_gps_rel_e,altitude_m_s=altitude_m_s,altitude_m_e=altitude_m_e,v_m_s_s=v_m_s_s,v_m_s_e=v_m_s_e)/1000
def cdmillennia(s, e, tz_s=0, tz_e=0,leap_year=None, uniform_year=False, tropical_year=False, custom_year=None,input_utc=True, output_tt=False,UTDLS=False, count_ls_param=True,year_for_leapyear_checking=None,lock_range_to_reference_year=False,
                apply_gps_rel_s=False,apply_gps_rel_e=False,altitude_m_s=20200000,altitude_m_e=20200000,v_m_s_s=3874,v_m_s_e=3874):
    """this function give the difference between the two dates(s and e) in millennia, fractionals version
                        S: is the first date(starting date) and it's a list made off: [Y(year),M(month),D(day),H(hour),MI(minute),S(second),SS(sub-seconds)] and all of these items integers
                        E: is the second date(ending date) and it has same format and data type as S
                        tz_s: is the timezone where the S date was measured in by default library is set to use greenwich(england) time, and it's an integer value
                        tz_e: is the same as tz_s in everything, but it's for E date
                        leap_year: if the year unit is a leap year or not , boolean value
                        uniform_year: if the year unit is a continuous scale Gregorian year, boolean value
                        tropical_year: if the year unit is a tropical years, boolean vale
                        custom_year: if not none it would use a custom made year unit, integer value
                        input_utc: this one is by default true, which is when your input is in the UTC system, if it's not make this parameter false
                        and your dates would be considered as TAI input, boolean
                        output_tt: this one is by default false, which is when you wanna your output to be in TT, boolean
                        UTDLS: enabling this is useless in all cases except when count_ls_param is True, and it would fetch a list of updated leap seconds from the internet, boolean
                        count_ls_param: enabling this would count leap-seconds, boolean
                        years_for_leapyear_checking: if to use or not use the year in the date to determine if year is a leap year or not, boolean value
                        lock_range_to_reference_year: if true no in between years making the added value to pure difference as zero, while default is max(0, E[0] - S[0] - 1)
                        apply_gps_rel_s: this one is by default false, used only when relativity(for near orbit objects like satellites) is wanted for first timestamp, boolean
                        apply_gps_rel_e: this one is by default false, used only when relativity(for near orbit objects like satellites) is wanted for second timestamp, boolean
                        altitude_m_s: the height of object of first timestamp like a satellite,needed when relativity is wanted, int
                        altitude_m_e: the height of object of second timestamp like a satellite,needed when relativity is wanted, int
                        v_m_s_s:the velocity of object of first timestamp like a satellite,needed when relativity is wanted, int
                        v_m_s_s:the velocity of object of second timestamp like a satellite,needed when relativity is wanted, int
                        """
    return td2._years_piecewise(s, e, tz_s=tz_s, tz_e=tz_e, input_utc=input_utc, UTDLS=UTDLS, count_ls_param=count_ls_param, output_tt=output_tt, uniform_year=uniform_year, tropical_year=tropical_year, custom_year=custom_year, leap_year=leap_year, year_for_leapyear_checking=year_for_leapyear_checking, lock_range_to_reference_year=lock_range_to_reference_year,apply_gps_rel_s=apply_gps_rel_s,apply_gps_rel_e=apply_gps_rel_e,altitude_m_s=altitude_m_s,altitude_m_e=altitude_m_e,v_m_s_s=v_m_s_s,v_m_s_e=v_m_s_e)/1000
def pdsubseconds(s,e,tz_s=0,tz_e=0,subunit=10**6,count_ls_param=True,UTDLS=False,input_utc=True,output_tt=False,
                 apply_gps_rel_s=False,apply_gps_rel_e=False,altitude_m_s=20200000,altitude_m_e=20200000,v_m_s_s=3874,v_m_s_e=3874):
    """this function give the difference between the two dates(s and e) in subseconds, fractions version
        S: is the first date(starting date) and it's a list made off: [Y(year),M(month),D(day),H(hour),MI(minute),S(second),SS(sub-seconds)] and all of these items integers
        E: is the second date(ending date) and it has same format and data type as S
        tz_s: is the timezone where the S date was measured in by default library is set to use greenwich(england) time, and it's an integer value
        tz_e: is the same as tz_s in everything, but it's for E date
        subunit: basically is the number that seconds would be divided upon to get difference in as specific unit like 10**6 for micro or 10**9 nano seconds, the default is 10**6 and it's an integer
        count_ls_param: enabling this would count leap-seconds, boolean
        UTDLS: enabling this is useless in all cases except when count_ls_param is True, and it would fetch a list of updated leap seconds from the internet, boolean
        input_utc: this one is by default true, which is when your input is in the UTC system, if it's not make this parameter false
        and your dates would be considered as TAI input, boolean
        output_tt: this one is by default false, which is when you wanna your output to be in TT, boolean
        apply_gps_rel_s: this one is by default false, used only when relativity(for near orbit objects like satellites) is wanted for first timestamp, boolean
        apply_gps_rel_e: this one is by default false, used only when relativity(for near orbit objects like satellites) is wanted for second timestamp, boolean
        altitude_m_s: the height of object of first timestamp like a satellite,needed when relativity is wanted, int
        altitude_m_e: the height of object of second timestamp like a satellite,needed when relativity is wanted, int
        v_m_s_s:the velocity of object of first timestamp like a satellite,needed when relativity is wanted, int
        v_m_s_s:the velocity of object of second timestamp like a satellite,needed when relativity is wanted, int
        """
    return td1._time_difference(s, e, tz_s=tz_s, tz_e=tz_e, unit_factor=1, input_utc=input_utc, count_ls_param=count_ls_param, UTDLS=UTDLS, output_tt=output_tt,apply_gps_rel_s=apply_gps_rel_s,apply_gps_rel_e=apply_gps_rel_e,altitude_m_s=altitude_m_s,altitude_m_e=altitude_m_e,v_m_s_s=v_m_s_s,v_m_s_e=v_m_s_e)/(1/subunit)
def cdsubseconds(s,e,tz_s=0,tz_e=0,subunit=10**6,count_ls_param=True,UTDLS=False,input_utc=True,output_tt=False,
                 apply_gps_rel_s=False,apply_gps_rel_e=False,altitude_m_s=20200000,altitude_m_e=20200000,v_m_s_s=3874,v_m_s_e=3874):
    """this function give the difference between the two dates(s and e) in subseconds, fractionals version
            S: is the first date(starting date) and it's a list made off: [Y(year),M(month),D(day),H(hour),MI(minute),S(second),SS(sub-seconds)] and all of these items integers
            E: is the second date(ending date) and it has same format and data type as S
            tz_s: is the timezone where the S date was measured in by default library is set to use greenwich(england) time, and it's an integer value
            tz_e: is the same as tz_s in everything, but it's for E date
            subunit: basically is the number that seconds would be divided upon to get difference in as specific unit like 10**6 for micro or 10**9 nano seconds, the default is 10**6 and it's an integer
            count_ls_param: enabling this would count leap-seconds, boolean
            UTDLS: enabling this is useless in all cases except when count_ls_param is True, and it would fetch a list of updated leap seconds from the internet, boolean
            input_utc: this one is by default true, which is when your input is in the UTC system, if it's not make this parameter false
            and your dates would be considered as TAI input, boolean
            output_tt: this one is by default false, which is when you wanna your output to be in TT, boolean
            apply_gps_rel_s: this one is by default false, used only when relativity(for near orbit objects like satellites) is wanted for first timestamp, boolean
            apply_gps_rel_e: this one is by default false, used only when relativity(for near orbit objects like satellites) is wanted for second timestamp, boolean
            altitude_m_s: the height of object of first timestamp like a satellite,needed when relativity is wanted, int
            altitude_m_e: the height of object of second timestamp like a satellite,needed when relativity is wanted, int
            v_m_s_s:the velocity of object of first timestamp like a satellite,needed when relativity is wanted, int
            v_m_s_s:the velocity of object of second timestamp like a satellite,needed when relativity is wanted, int
            """
    return td2._time_difference(s, e, tz_s=tz_s, tz_e=tz_e, unit_factor=1, input_utc=input_utc, count_ls_param=count_ls_param, UTDLS=UTDLS, output_tt=output_tt,apply_gps_rel_s=apply_gps_rel_s,apply_gps_rel_e=apply_gps_rel_e,altitude_m_s=altitude_m_s,altitude_m_e=altitude_m_e,v_m_s_s=v_m_s_s,v_m_s_e=v_m_s_e)/(1/subunit)
def ptimestamp(d,unit_factor=1,count_ls_param=True, UTDLS=False, input_utc=True,unix_epoch=False,custom_epoch_as_utc=True,custom_epoch_as_tt=False,custom_epoch=None,input_tt=False,output_tt=False,
               apply_gps_rel_s=False,apply_gps_rel_e=False,altitude_m_s=20200000,altitude_m_e=20200000,v_m_s_s=3874,v_m_s_e=3874):
    """this function give the date as timestamp, fractions version
    d: is the date and it's a list made off: [Y(year),M(month),D(day),H(hour),MI(minute),S(second),SS(sub-seconds)] and all of these items integers
    unit_factor: this is the unit to be used, basically the difference between dates would be done in seconds , so you can if you want to get result in minutes for example
    to do that , make it into 60 and the difference would be divided by 60 leading to result being in the unit of minutes, and it's an integer
    count_ls_param: enabling this would count leap-seconds, boolean
    UTDLS: enabling this is useless in all cases except when count_ls_param is True, and it would fetch a list of updated leap seconds from the internet, boolean
    input_utc: this one is by default true, which is when your input is in the UTC system, if it's not make this parameter false
    and your dates would be considered as TAI input, boolean
    unix_epoch: this option is False by default and it's a boolean value setting it as true would give you timestamp relative to unix epoch
    custom_epoch_as_utc: this option is True by default and it's a boolean value setting it as false would give you timestamp relative to custom epoch as TAI
    custom_epoch_as_tt: this option is False by default and it's a boolean value setting it as true would give you timestamp relative to custom epoch as TT
    custom_epoch: this option is None by default and it's a list made off: [Y(year),M(month),D(day),H(hour),MI(minute),S(second),SS(sub-seconds)] and all of these items integers
    input_tt: this one is by default false, which is when you wanna your input to be in TT, boolean
    output_tt: this one is by default false, which is when you wanna your output to be in TT, boolean
    apply_gps_rel: this one is by default false, used only when relativity(for near orbit objects like satellites) is wanted for the timestamp, boolean
    altitude_m: the height of object of the timestamp like a satellite,needed when relativity is wanted, int
    v_m_s:the velocity of object of the timestamp like a satellite,needed when relativity is wanted, int
    """
    return td1._timestampinner(*d, count_ls_param=count_ls_param, UTDLS=UTDLS, input_utc=input_utc, unix_epoch=unix_epoch, custom_epoch_as_utc=custom_epoch_as_utc, custom_epoch_as_tt=custom_epoch_as_tt, custom_epoch=custom_epoch, input_tt=input_tt, output_tt=output_tt,apply_gps_rel_s=apply_gps_rel_s,apply_gps_rel_e=apply_gps_rel_e,altitude_m_s=altitude_m_s,altitude_m_e=altitude_m_e,v_m_s_s=v_m_s_s,v_m_s_e=v_m_s_e) / unit_factor
def ctimestamp(d,unit_factor=1,count_ls_param=True, UTDLS=False, input_utc=True,unix_epoch=False,custom_epoch_as_utc=True,custom_epoch_as_tt=False,custom_epoch=None,input_tt=False,output_tt=False,
               apply_gps_rel_s=False,apply_gps_rel_e=False,altitude_m_s=20200000,altitude_m_e=20200000,v_m_s_s=3874,v_m_s_e=3874):
    """this function give the date as timestamp, fractionals version
    d: is the date and it's a list made off: [Y(year),M(month),D(day),H(hour),MI(minute),S(second),SS(sub-seconds)] and all of these items integers
    unit_factor: this is the unit to be used, basically the difference between dates would be done in seconds , so you can if you want to get result in minutes for example
    to do that , make it into 60 and the difference would be divided by 60 leading to result being in the unit of minutes, and it's an integer
    count_ls_param: enabling this would count leap-seconds, boolean
    UTDLS: enabling this is useless in all cases except when count_ls_param is True, and it would fetch a list of updated leap seconds from the internet, boolean
    input_utc: this one is by default true, which is when your input is in the UTC system, if it's not make this parameter false
    and your dates would be considered as TAI input, boolean
    unix_epoch: this option is False by default and it's a boolean value setting it as true would give you timestamp relative to unix epoch
    custom_epoch_as_utc: this option is True by default and it's a boolean value setting it as false would give you timestamp relative to custom epoch as TAI
    custom_epoch_as_tt: this option is False by default and it's a boolean value setting it as true would give you timestamp relative to custom epoch as TT
    custom_epoch: this option is None by default and it's a list made off: [Y(year),M(month),D(day),H(hour),MI(minute),S(second),SS(sub-seconds)] and all of these items integers
    input_tt: this one is by default false, which is when you wanna your input to be in TT, boolean
    output_tt: this one is by default false, which is when you wanna your output to be in TT, boolean
    apply_gps_rel: this one is by default false, used only when relativity(for near orbit objects like satellites) is wanted for the timestamp, boolean
    altitude_m: the height of object of the timestamp like a satellite,needed when relativity is wanted, int
    v_m_s:the velocity of object of the timestamp like a satellite,needed when relativity is wanted, int
    """
    return td2._timestampinner(*d, count_ls_param=count_ls_param, UTDLS=UTDLS, input_utc=input_utc, unix_epoch=unix_epoch, custom_epoch_as_utc=custom_epoch_as_utc, custom_epoch_as_tt=custom_epoch_as_tt, custom_epoch=custom_epoch, input_tt=input_tt, output_tt=output_tt,apply_gps_rel_s=apply_gps_rel_s,apply_gps_rel_e=apply_gps_rel_e,altitude_m_s=altitude_m_s,altitude_m_e=altitude_m_e,v_m_s_s=v_m_s_s,v_m_s_e=v_m_s_e) / unit_factor
def ptseconds(d,count_ls_param=True, UTDLS=False, input_utc=True,unix_epoch=False,custom_epoch_as_utc=True,custom_epoch_as_tt=False,custom_epoch=None,input_tt=False,output_tt=False,
              apply_gps_rel_s=False,apply_gps_rel_e=False,altitude_m_s=20200000,altitude_m_e=20200000,v_m_s_s=3874,v_m_s_e=3874):
    """this function give the date as timestamp, fractions version
    d: is the date and it's a list made off: [Y(year),M(month),D(day),H(hour),MI(minute),S(second),SS(sub-seconds)] and all of these items integers
    count_ls_param: enabling this would count leap-seconds, boolean
    UTDLS: enabling this is useless in all cases except when count_ls_param is True, and it would fetch a list of updated leap seconds from the internet, boolean
    input_utc: this one is by default true, which is when your input is in the UTC system, if it's not make this parameter false
    and your dates would be considered as TAI input, boolean
    unix_epoch: this option is False by default and it's a boolean value setting it as true would give you timestamp relative to unix epoch
    custom_epoch_as_utc: this option is True by default and it's a boolean value setting it as false would give you timestamp relative to custom epoch as TAI
    custom_epoch_as_tt: this option is False by default and it's a boolean value setting it as true would give you timestamp relative to custom epoch as TT
    custom_epoch: this option is None by default and it's a list made off: [Y(year),M(month),D(day),H(hour),MI(minute),S(second),SS(sub-seconds)] and all of these items integers
    input_tt: this one is by default false, which is when you wanna your input to be in TT, boolean
    output_tt: this one is by default false, which is when you wanna your output to be in TT, boolean
    apply_gps_rel: this one is by default false, used only when relativity(for near orbit objects like satellites) is wanted for the timestamp, boolean
    altitude_m: the height of object of the timestamp like a satellite,needed when relativity is wanted, int
    v_m_s:the velocity of object of the timestamp like a satellite,needed when relativity is wanted, int
    """
    return td1._timestampinner(*d, count_ls_param=count_ls_param, UTDLS=UTDLS, input_utc=input_utc, unix_epoch=unix_epoch, custom_epoch_as_utc=custom_epoch_as_utc, custom_epoch_as_tt=custom_epoch_as_tt, custom_epoch=custom_epoch, input_tt=input_tt, output_tt=output_tt,apply_gps_rel_s=apply_gps_rel_s,apply_gps_rel_e=apply_gps_rel_e,altitude_m_s=altitude_m_s,altitude_m_e=altitude_m_e,v_m_s_s=v_m_s_s,v_m_s_e=v_m_s_e)
def ctseconds(d,count_ls_param=True, UTDLS=False, input_utc=True,unix_epoch=False,custom_epoch_as_utc=True,custom_epoch_as_tt=False,custom_epoch=None,input_tt=False,output_tt=False,
              apply_gps_rel_s=False,apply_gps_rel_e=False,altitude_m_s=20200000,altitude_m_e=20200000,v_m_s_s=3874,v_m_s_e=3874):
    """this function give the date as timestamp, fractionals version
    d: is the date and it's a list made off: [Y(year),M(month),D(day),H(hour),MI(minute),S(second),SS(sub-seconds)] and all of these items integers
    count_ls_param: enabling this would count leap-seconds, boolean
    UTDLS: enabling this is useless in all cases except when count_ls_param is True, and it would fetch a list of updated leap seconds from the internet, boolean
    input_utc: this one is by default true, which is when your input is in the UTC system, if it's not make this parameter false
    and your dates would be considered as TAI input, boolean
    unix_epoch: this option is False by default and it's a boolean value setting it as true would give you timestamp relative to unix epoch
    custom_epoch_as_utc: this option is True by default and it's a boolean value setting it as false would give you timestamp relative to custom epoch as TAI
    custom_epoch_as_tt: this option is False by default and it's a boolean value setting it as true would give you timestamp relative to custom epoch as TT
    custom_epoch: this option is None by default and it's a list made off: [Y(year),M(month),D(day),H(hour),MI(minute),S(second),SS(sub-seconds)] and all of these items integers
    input_tt: this one is by default false, which is when you wanna your input to be in TT, boolean
    output_tt: this one is by default false, which is when you wanna your output to be in TT, boolean
    apply_gps_rel: this one is by default false, used only when relativity(for near orbit objects like satellites) is wanted for the timestamp, boolean
    altitude_m: the height of object of the timestamp like a satellite,needed when relativity is wanted, int
    v_m_s:the velocity of object of the timestamp like a satellite,needed when relativity is wanted, int
    """
    return td2._timestampinner(*d, count_ls_param=count_ls_param, UTDLS=UTDLS, input_utc=input_utc, unix_epoch=unix_epoch, custom_epoch_as_utc=custom_epoch_as_utc, custom_epoch_as_tt=custom_epoch_as_tt, custom_epoch=custom_epoch, input_tt=input_tt, output_tt=output_tt,apply_gps_rel_s=apply_gps_rel_s,apply_gps_rel_e=apply_gps_rel_e,altitude_m_s=altitude_m_s,altitude_m_e=altitude_m_e,v_m_s_s=v_m_s_s,v_m_s_e=v_m_s_e)
def ptminutes(d,count_ls_param=True, UTDLS=False, input_utc=True,unix_epoch=False,custom_epoch_as_utc=True,custom_epoch_as_tt=False,custom_epoch=None,input_tt=False,output_tt=False,
              apply_gps_rel_s=False,apply_gps_rel_e=False,altitude_m_s=20200000,altitude_m_e=20200000,v_m_s_s=3874,v_m_s_e=3874):
    """this function give the date as timestamp in minutes, fractions version
    d: is the date and it's a list made off: [Y(year),M(month),D(day),H(hour),MI(minute),S(second),SS(sub-seconds)] and all of these items integers
    count_ls_param: enabling this would count leap-seconds, boolean
    UTDLS: enabling this is useless in all cases except when count_ls_param is True, and it would fetch a list of updated leap seconds from the internet, boolean
    input_utc: this one is by default true, which is when your input is in the UTC system, if it's not make this parameter false
    and your dates would be considered as TAI input, boolean
    unix_epoch: this option is False by default and it's a boolean value setting it as true would give you timestamp relative to unix epoch
    custom_epoch_as_utc: this option is True by default and it's a boolean value setting it as false would give you timestamp relative to custom epoch as TAI
    custom_epoch_as_tt: this option is False by default and it's a boolean value setting it as true would give you timestamp relative to custom epoch as TT
    custom_epoch: this option is None by default and it's a list made off: [Y(year),M(month),D(day),H(hour),MI(minute),S(second),SS(sub-seconds)] and all of these items integers
    input_tt: this one is by default false, which is when you wanna your input to be in TT, boolean
    output_tt: this one is by default false, which is when you wanna your output to be in TT, boolean
    apply_gps_rel: this one is by default false, used only when relativity(for near orbit objects like satellites) is wanted for the timestamp, boolean
    altitude_m: the height of object of the timestamp like a satellite,needed when relativity is wanted, int
    v_m_s:the velocity of object of the timestamp like a satellite,needed when relativity is wanted, int
    """
    return td1._timestampinner(*d, count_ls_param=count_ls_param, UTDLS=UTDLS, input_utc=input_utc, unix_epoch=unix_epoch, custom_epoch_as_utc=custom_epoch_as_utc, custom_epoch_as_tt=custom_epoch_as_tt, custom_epoch=custom_epoch, input_tt=input_tt, output_tt=output_tt,apply_gps_rel_s=apply_gps_rel_s,apply_gps_rel_e=apply_gps_rel_e,altitude_m_s=altitude_m_s,altitude_m_e=altitude_m_e,v_m_s_s=v_m_s_s,v_m_s_e=v_m_s_e)/60
def ctminutes(d,count_ls_param=True, UTDLS=False, input_utc=True,unix_epoch=False,custom_epoch_as_utc=True,custom_epoch_as_tt=False,custom_epoch=None,input_tt=False,output_tt=False,
              apply_gps_rel_s=False,apply_gps_rel_e=False,altitude_m_s=20200000,altitude_m_e=20200000,v_m_s_s=3874,v_m_s_e=3874):
    """this function give the date as timestamp in minutes, fractionals version
    d: is the date and it's a list made off: [Y(year),M(month),D(day),H(hour),MI(minute),S(second),SS(sub-seconds)] and all of these items integers
    count_ls_param: enabling this would count leap-seconds, boolean
    UTDLS: enabling this is useless in all cases except when count_ls_param is True, and it would fetch a list of updated leap seconds from the internet, boolean
    input_utc: this one is by default true, which is when your input is in the UTC system, if it's not make this parameter false
    and your dates would be considered as TAI input, boolean
    unix_epoch: this option is False by default and it's a boolean value setting it as true would give you timestamp relative to unix epoch
    custom_epoch_as_utc: this option is True by default and it's a boolean value setting it as false would give you timestamp relative to custom epoch as TAI
    custom_epoch_as_tt: this option is False by default and it's a boolean value setting it as true would give you timestamp relative to custom epoch as TT
    custom_epoch: this option is None by default and it's a list made off: [Y(year),M(month),D(day),H(hour),MI(minute),S(second),SS(sub-seconds)] and all of these items integers
    input_tt: this one is by default false, which is when you wanna your input to be in TT, boolean
    output_tt: this one is by default false, which is when you wanna your output to be in TT, boolean
    apply_gps_rel: this one is by default false, used only when relativity(for near orbit objects like satellites) is wanted for the timestamp, boolean
    altitude_m: the height of object of the timestamp like a satellite,needed when relativity is wanted, int
    v_m_s:the velocity of object of the timestamp like a satellite,needed when relativity is wanted, int
    """
    return td2._timestampinner(*d, count_ls_param=count_ls_param, UTDLS=UTDLS, input_utc=input_utc, unix_epoch=unix_epoch, custom_epoch_as_utc=custom_epoch_as_utc, custom_epoch_as_tt=custom_epoch_as_tt, custom_epoch=custom_epoch, input_tt=input_tt, output_tt=output_tt,apply_gps_rel_s=apply_gps_rel_s,apply_gps_rel_e=apply_gps_rel_e,altitude_m_s=altitude_m_s,altitude_m_e=altitude_m_e,v_m_s_s=v_m_s_s,v_m_s_e=v_m_s_e)/60
def pthours(d,count_ls_param=True, UTDLS=False, input_utc=True,unix_epoch=False,custom_epoch_as_utc=True,custom_epoch_as_tt=False,custom_epoch=None,input_tt=False,output_tt=False,
            apply_gps_rel_s=False,apply_gps_rel_e=False,altitude_m_s=20200000,altitude_m_e=20200000,v_m_s_s=3874,v_m_s_e=3874):
    """this function give the date as timestamp in hours, fractions version
    d: is the date and it's a list made off: [Y(year),M(month),D(day),H(hour),MI(minute),S(second),SS(sub-seconds)] and all of these items integers
    count_ls_param: enabling this would count leap-seconds, boolean
    UTDLS: enabling this is useless in all cases except when count_ls_param is True, and it would fetch a list of updated leap seconds from the internet, boolean
    input_utc: this one is by default true, which is when your input is in the UTC system, if it's not make this parameter false
    and your dates would be considered as TAI input, boolean
    unix_epoch: this option is False by default and it's a boolean value setting it as true would give you timestamp relative to unix epoch
    custom_epoch_as_utc: this option is True by default and it's a boolean value setting it as false would give you timestamp relative to custom epoch as TAI
    custom_epoch_as_tt: this option is False by default and it's a boolean value setting it as true would give you timestamp relative to custom epoch as TT
    custom_epoch: this option is None by default and it's a list made off: [Y(year),M(month),D(day),H(hour),MI(minute),S(second),SS(sub-seconds)] and all of these items integers
    input_tt: this one is by default false, which is when you wanna your input to be in TT, boolean
    output_tt: this one is by default false, which is when you wanna your output to be in TT, boolean
    apply_gps_rel: this one is by default false, used only when relativity(for near orbit objects like satellites) is wanted for the timestamp, boolean
    altitude_m: the height of object of the timestamp like a satellite,needed when relativity is wanted, int
    v_m_s:the velocity of object of the timestamp like a satellite,needed when relativity is wanted, int
    """
    return td1._timestampinner(*d, count_ls_param=count_ls_param, UTDLS=UTDLS, input_utc=input_utc, unix_epoch=unix_epoch, custom_epoch_as_utc=custom_epoch_as_utc, custom_epoch_as_tt=custom_epoch_as_tt, custom_epoch=custom_epoch, input_tt=input_tt, output_tt=output_tt,apply_gps_rel_s=apply_gps_rel_s,apply_gps_rel_e=apply_gps_rel_e,altitude_m_s=altitude_m_s,altitude_m_e=altitude_m_e,v_m_s_s=v_m_s_s,v_m_s_e=v_m_s_e)/3600
def cthours(d,count_ls_param=True, UTDLS=False, input_utc=True,unix_epoch=False,custom_epoch_as_utc=True,custom_epoch_as_tt=False,custom_epoch=None,input_tt=False,output_tt=False,
            apply_gps_rel_s=False,apply_gps_rel_e=False,altitude_m_s=20200000,altitude_m_e=20200000,v_m_s_s=3874,v_m_s_e=3874):
    """this function give the date as timestamp in hours, fractionals version
    d: is the date and it's a list made off: [Y(year),M(month),D(day),H(hour),MI(minute),S(second),SS(sub-seconds)] and all of these items integers
    count_ls_param: enabling this would count leap-seconds, boolean
    UTDLS: enabling this is useless in all cases except when count_ls_param is True, and it would fetch a list of updated leap seconds from the internet, boolean
    input_utc: this one is by default true, which is when your input is in the UTC system, if it's not make this parameter false
    and your dates would be considered as TAI input, boolean
    unix_epoch: this option is False by default and it's a boolean value setting it as true would give you timestamp relative to unix epoch
    custom_epoch_as_utc: this option is True by default and it's a boolean value setting it as false would give you timestamp relative to custom epoch as TAI
    custom_epoch_as_tt: this option is False by default and it's a boolean value setting it as true would give you timestamp relative to custom epoch as TT
    custom_epoch: this option is None by default and it's a list made off: [Y(year),M(month),D(day),H(hour),MI(minute),S(second),SS(sub-seconds)] and all of these items integers
    input_tt: this one is by default false, which is when you wanna your input to be in TT, boolean
    output_tt: this one is by default false, which is when you wanna your output to be in TT, boolean
    apply_gps_rel: this one is by default false, used only when relativity(for near orbit objects like satellites) is wanted for the timestamp, boolean
    altitude_m: the height of object of the timestamp like a satellite,needed when relativity is wanted, int
    v_m_s:the velocity of object of the timestamp like a satellite,needed when relativity is wanted, int
    """
    return td2._timestampinner(*d, count_ls_param=count_ls_param, UTDLS=UTDLS, input_utc=input_utc, unix_epoch=unix_epoch, custom_epoch_as_utc=custom_epoch_as_utc, custom_epoch_as_tt=custom_epoch_as_tt, custom_epoch=custom_epoch, input_tt=input_tt, output_tt=output_tt,apply_gps_rel_s=apply_gps_rel_s,apply_gps_rel_e=apply_gps_rel_e,altitude_m_s=altitude_m_s,altitude_m_e=altitude_m_e,v_m_s_s=v_m_s_s,v_m_s_e=v_m_s_e)/3600
def pcdays(d,count_ls_param=True, UTDLS=False, input_utc=True,unix_epoch=False,custom_epoch_as_utc=True,custom_epoch_as_tt=False,custom_epoch=None,input_tt=False,output_tt=False,
           apply_gps_rel_s=False,apply_gps_rel_e=False,altitude_m_s=20200000,altitude_m_e=20200000,v_m_s_s=3874,v_m_s_e=3874):
    """this function give the date as timestamp in days, fractions version
    d: is the date and it's a list made off: [Y(year),M(month),D(day),H(hour),MI(minute),S(second),SS(sub-seconds)] and all of these items integers
    count_ls_param: enabling this would count leap-seconds, boolean
    UTDLS: enabling this is useless in all cases except when count_ls_param is True, and it would fetch a list of updated leap seconds from the internet, boolean
    input_utc: this one is by default true, which is when your input is in the UTC system, if it's not make this parameter false
    and your dates would be considered as TAI input, boolean
    unix_epoch: this option is False by default and it's a boolean value setting it as true would give you timestamp relative to unix epoch
    custom_epoch_as_utc: this option is True by default and it's a boolean value setting it as false would give you timestamp relative to custom epoch as TAI
    custom_epoch_as_tt: this option is False by default and it's a boolean value setting it as true would give you timestamp relative to custom epoch as TT
    custom_epoch: this option is None by default and it's a list made off: [Y(year),M(month),D(day),H(hour),MI(minute),S(second),SS(sub-seconds)] and all of these items integers
    input_tt: this one is by default false, which is when you wanna your input to be in TT, boolean
    output_tt: this one is by default false, which is when you wanna your output to be in TT, boolean
    apply_gps_rel: this one is by default false, used only when relativity(for near orbit objects like satellites) is wanted for the timestamp, boolean
    altitude_m: the height of object of the timestamp like a satellite,needed when relativity is wanted, int
    v_m_s:the velocity of object of the timestamp like a satellite,needed when relativity is wanted, int
    """
    return td1._timestampinner(*d, count_ls_param=count_ls_param, UTDLS=UTDLS, input_utc=input_utc, unix_epoch=unix_epoch, custom_epoch_as_utc=custom_epoch_as_utc, custom_epoch_as_tt=custom_epoch_as_tt, custom_epoch=custom_epoch, input_tt=input_tt, output_tt=output_tt,apply_gps_rel_s=apply_gps_rel_s,apply_gps_rel_e=apply_gps_rel_e,altitude_m_s=altitude_m_s,altitude_m_e=altitude_m_e,v_m_s_s=v_m_s_s,v_m_s_e=v_m_s_e)/86400
def ctdays(d,count_ls_param=True, UTDLS=False, input_utc=True,unix_epoch=False,custom_epoch_as_utc=True,custom_epoch_as_tt=False,custom_epoch=None,input_tt=False,output_tt=False,
           apply_gps_rel_s=False,apply_gps_rel_e=False,altitude_m_s=20200000,altitude_m_e=20200000,v_m_s_s=3874,v_m_s_e=3874):
    """this function give the date as timestamp in days, fractionals version
    d: is the date and it's a list made off: [Y(year),M(month),D(day),H(hour),MI(minute),S(second),SS(sub-seconds)] and all of these items integers
    count_ls_param: enabling this would count leap-seconds, boolean
    UTDLS: enabling this is useless in all cases except when count_ls_param is True, and it would fetch a list of updated leap seconds from the internet, boolean
    input_utc: this one is by default true, which is when your input is in the UTC system, if it's not make this parameter false
    and your dates would be considered as TAI input, boolean
    unix_epoch: this option is False by default and it's a boolean value setting it as true would give you timestamp relative to unix epoch
    custom_epoch_as_utc: this option is True by default and it's a boolean value setting it as false would give you timestamp relative to custom epoch as TAI
    custom_epoch_as_tt: this option is False by default and it's a boolean value setting it as true would give you timestamp relative to custom epoch as TT
    custom_epoch: this option is None by default and it's a list made off: [Y(year),M(month),D(day),H(hour),MI(minute),S(second),SS(sub-seconds)] and all of these items integers
    input_tt: this one is by default false, which is when you wanna your input to be in TT, boolean
    output_tt: this one is by default false, which is when you wanna your output to be in TT, boolean
    apply_gps_rel: this one is by default false, used only when relativity(for near orbit objects like satellites) is wanted for the timestamp, boolean
    altitude_m: the height of object of the timestamp like a satellite,needed when relativity is wanted, int
    v_m_s:the velocity of object of the timestamp like a satellite,needed when relativity is wanted, int
    """
    return td2._timestampinner(*d, count_ls_param=count_ls_param, UTDLS=UTDLS, input_utc=input_utc, unix_epoch=unix_epoch, custom_epoch_as_utc=custom_epoch_as_utc, custom_epoch_as_tt=custom_epoch_as_tt, custom_epoch=custom_epoch, input_tt=input_tt, output_tt=output_tt,apply_gps_rel_s=apply_gps_rel_s,apply_gps_rel_e=apply_gps_rel_e,altitude_m_s=altitude_m_s,altitude_m_e=altitude_m_e,v_m_s_s=v_m_s_s,v_m_s_e=v_m_s_e)/86400
def ptweeks(d,count_ls_param=True, UTDLS=False, input_utc=True,unix_epoch=False,custom_epoch_as_utc=True,custom_epoch_as_tt=False,custom_epoch=None,input_tt=False,output_tt=False,
            apply_gps_rel_s=False,apply_gps_rel_e=False,altitude_m_s=20200000,altitude_m_e=20200000,v_m_s_s=3874,v_m_s_e=3874):
    """this function give the date as timestamp in weeks, fractions version
    d: is the date and it's a list made off: [Y(year),M(month),D(day),H(hour),MI(minute),S(second),SS(sub-seconds)] and all of these items integers
    count_ls_param: enabling this would count leap-seconds, boolean
    UTDLS: enabling this is useless in all cases except when count_ls_param is True, and it would fetch a list of updated leap seconds from the internet, boolean
    input_utc: this one is by default true, which is when your input is in the UTC system, if it's not make this parameter false
    and your dates would be considered as TAI input, boolean
    unix_epoch: this option is False by default and it's a boolean value setting it as true would give you timestamp relative to unix epoch
    custom_epoch_as_utc: this option is True by default and it's a boolean value setting it as false would give you timestamp relative to custom epoch as TAI
    custom_epoch_as_tt: this option is False by default and it's a boolean value setting it as true would give you timestamp relative to custom epoch as TT
    custom_epoch: this option is None by default and it's a list made off: [Y(year),M(month),D(day),H(hour),MI(minute),S(second),SS(sub-seconds)] and all of these items integers
    input_tt: this one is by default false, which is when you wanna your input to be in TT, boolean
    output_tt: this one is by default false, which is when you wanna your output to be in TT, boolean
    apply_gps_rel: this one is by default false, used only when relativity(for near orbit objects like satellites) is wanted for the timestamp, boolean
    altitude_m: the height of object of the timestamp like a satellite,needed when relativity is wanted, int
    v_m_s:the velocity of object of the timestamp like a satellite,needed when relativity is wanted, int
    """
    return td1._timestampinner(*d, count_ls_param=count_ls_param, UTDLS=UTDLS, input_utc=input_utc, unix_epoch=unix_epoch, custom_epoch_as_utc=custom_epoch_as_utc, custom_epoch_as_tt=custom_epoch_as_tt, custom_epoch=custom_epoch, input_tt=input_tt, output_tt=output_tt,apply_gps_rel_s=apply_gps_rel_s,apply_gps_rel_e=apply_gps_rel_e,altitude_m_s=altitude_m_s,altitude_m_e=altitude_m_e,v_m_s_s=v_m_s_s,v_m_s_e=v_m_s_e)/(86400 * 7)
def ctweeks(d,count_ls_param=True, UTDLS=False, input_utc=True,unix_epoch=False,custom_epoch_as_utc=True,custom_epoch_as_tt=False,custom_epoch=None,input_tt=False,output_tt=False,
            apply_gps_rel_s=False,apply_gps_rel_e=False,altitude_m_s=20200000,altitude_m_e=20200000,v_m_s_s=3874,v_m_s_e=3874):
    """this function give the date as timestamp in weeks, fractionals version
    d: is the date and it's a list made off: [Y(year),M(month),D(day),H(hour),MI(minute),S(second),SS(sub-seconds)] and all of these items integers
    count_ls_param: enabling this would count leap-seconds, boolean
    UTDLS: enabling this is useless in all cases except when count_ls_param is True, and it would fetch a list of updated leap seconds from the internet, boolean
    input_utc: this one is by default true, which is when your input is in the UTC system, if it's not make this parameter false
    and your dates would be considered as TAI input, boolean
    unix_epoch: this option is False by default and it's a boolean value setting it as true would give you timestamp relative to unix epoch
    custom_epoch_as_utc: this option is True by default and it's a boolean value setting it as false would give you timestamp relative to custom epoch as TAI
    custom_epoch_as_tt: this option is False by default and it's a boolean value setting it as true would give you timestamp relative to custom epoch as TT
    custom_epoch: this option is None by default and it's a list made off: [Y(year),M(month),D(day),H(hour),MI(minute),S(second),SS(sub-seconds)] and all of these items integers
    input_tt: this one is by default false, which is when you wanna your input to be in TT, boolean
    output_tt: this one is by default false, which is when you wanna your output to be in TT, boolean
    apply_gps_rel: this one is by default false, used only when relativity(for near orbit objects like satellites) is wanted for the timestamp, boolean
    altitude_m: the height of object of the timestamp like a satellite,needed when relativity is wanted, int
    v_m_s:the velocity of object of the timestamp like a satellite,needed when relativity is wanted, int
    """
    return td2._timestampinner(*d, count_ls_param=count_ls_param, UTDLS=UTDLS, input_utc=input_utc, unix_epoch=unix_epoch, custom_epoch_as_utc=custom_epoch_as_utc, custom_epoch_as_tt=custom_epoch_as_tt, custom_epoch=custom_epoch, input_tt=input_tt, output_tt=output_tt,
                               apply_gps_rel_s=apply_gps_rel_s,apply_gps_rel_e=apply_gps_rel_e,altitude_m_s=altitude_m_s,altitude_m_e=altitude_m_e,v_m_s_s=v_m_s_s,v_m_s_e=v_m_s_e)/(86400 * 7)
def ptmonths(d,count_ls_param=True, UTDLS=False, input_utc=True,unix_epoch=False,custom_epoch_as_utc=True,custom_epoch_as_tt=False,custom_epoch=None,input_tt=False,output_tt=False,month_unit=0,use_date_in_leapyears_checking=False,leap_year=False,year_for_leapyears_checking=None,apply_gps_rel_s=False,apply_gps_rel_e=False,altitude_m_s=20200000,altitude_m_e=20200000,v_m_s_s=3874,v_m_s_e=3874):
    """this function give the date as timestamp in months, fractions version
    d: is the date and it's a list made off: [Y(year),M(month),D(day),H(hour),MI(minute),S(second),SS(sub-seconds)] and all of these items integers
    count_ls_param: enabling this would count leap-seconds, boolean
    UTDLS: enabling this is useless in all cases except when count_ls_param is True, and it would fetch a list of updated leap seconds from the internet, boolean
    input_utc: this one is by default true, which is when your input is in the UTC system, if it's not make this parameter false
    and your dates would be considered as TAI input, boolean
    unix_epoch: this option is False by default and it's a boolean value setting it as true would give you timestamp relative to unix epoch
    custom_epoch_as_utc: this option is True by default and it's a boolean value setting it as false would give you timestamp relative to custom epoch as TAI
    custom_epoch_as_tt: this option is False by default and it's a boolean value setting it as true would give you timestamp relative to custom epoch as TT
    custom_epoch: this option is None by default and it's a list made off: [Y(year),M(month),D(day),H(hour),MI(minute),S(second),SS(sub-seconds)] and all of these items integers
    input_tt: this one is by default false, which is when you wanna your input to be in TT, boolean
    output_tt: this one is by default false, which is when you wanna your output to be in TT, boolean
    month_unit: is what month you chose to be your unit, like how many junes or how many octobers, it's value corresponds to month it represents, it's an integer
    use_date_in_leapyears_checking: this option is False by default and it's a boolean value setting it as true would make the function use the date in leapyears checking
    leap_year: if the year is a leap year or not , useful to determine February's value
    year_for_leapyears_checking: it's an integer value, that would be used instead of using the year in starting value to know if to consider
    the year as a leap year or a normal one
    apply_gps_rel: this one is by default false, used only when relativity(for near orbit objects like satellites) is wanted for the timestamp, boolean
    altitude_m: the height of object of the timestamp like a satellite,needed when relativity is wanted, int
    v_m_s:the velocity of object of the timestamp like a satellite,needed when relativity is wanted, int
    """
    return td1._timestampinner(*d, count_ls_param=count_ls_param, UTDLS=UTDLS, input_utc=input_utc, unix_epoch=unix_epoch, custom_epoch_as_utc=custom_epoch_as_utc, custom_epoch_as_tt=custom_epoch_as_tt, custom_epoch=custom_epoch, input_tt=input_tt, output_tt=output_tt,
                               apply_gps_rel_s=apply_gps_rel_s,apply_gps_rel_e=apply_gps_rel_e,altitude_m_s=altitude_m_s,altitude_m_e=altitude_m_e,v_m_s_s=v_m_s_s,v_m_s_e=v_m_s_e) / td1._get_month_seconds(d[0], d[1], month_unit, td1.is_leap((d[0] if use_date_in_leapyears_checking else year_for_leapyears_checking), leap_year))
def ctmonths(d,count_ls_param=True, UTDLS=False, input_utc=True,unix_epoch=False,custom_epoch_as_utc=True,custom_epoch_as_tt=False,custom_epoch=None,input_tt=False,output_tt=False,month_unit=0,use_date_in_leapyears_checking=False,leap_year=False,year_for_leapyears_checking=None,apply_gps_rel_s=False,apply_gps_rel_e=False,altitude_m_s=20200000,altitude_m_e=20200000,v_m_s_s=3874,v_m_s_e=3874):
    """this function give the date as timestamp in months, fractionals version
    d: is the date and it's a list made off: [Y(year),M(month),D(day),H(hour),MI(minute),S(second),SS(sub-seconds)] and all of these items integers
    count_ls_param: enabling this would count leap-seconds, boolean
    UTDLS: enabling this is useless in all cases except when count_ls_param is True, and it would fetch a list of updated leap seconds from the internet, boolean
    input_utc: this one is by default true, which is when your input is in the UTC system, if it's not make this parameter false
    and your dates would be considered as TAI input, boolean
    unix_epoch: this option is False by default and it's a boolean value setting it as true would give you timestamp relative to unix epoch
    custom_epoch_as_utc: this option is True by default and it's a boolean value setting it as false would give you timestamp relative to custom epoch as TAI
    custom_epoch_as_tt: this option is False by default and it's a boolean value setting it as true would give you timestamp relative to custom epoch as TT
    custom_epoch: this option is None by default and it's a list made off: [Y(year),M(month),D(day),H(hour),MI(minute),S(second),SS(sub-seconds)] and all of these items integers
    input_tt: this one is by default false, which is when you wanna your input to be in TT, boolean
    output_tt: this one is by default false, which is when you wanna your output to be in TT, boolean
    month_unit: is what month you chose to be your unit, like how many junes or how many octobers, it's value corresponds to month it represents, it's an integer
    use_date_in_leapyears_checking: this option is False by default and it's a boolean value setting it as true would make the function use the date in leapyears checking
    leap_year: if the year is a leap year or not , useful to determine February's value
    year_for_leapyears_checking: it's an integer value, that would be used instead of using the year in starting value to know if to consider
    the year as a leap year or a normal one
    apply_gps_rel: this one is by default false, used only when relativity(for near orbit objects like satellites) is wanted for the timestamp, boolean
    altitude_m: the height of object of the timestamp like a satellite,needed when relativity is wanted, int
    v_m_s:the velocity of object of the timestamp like a satellite,needed when relativity is wanted, int
    """
    return td2._timestampinner(*d, count_ls_param=count_ls_param, UTDLS=UTDLS, input_utc=input_utc, unix_epoch=unix_epoch, custom_epoch_as_utc=custom_epoch_as_utc, custom_epoch_as_tt=custom_epoch_as_tt, custom_epoch=custom_epoch, input_tt=input_tt, output_tt=output_tt,
                               apply_gps_rel_s=apply_gps_rel_s,apply_gps_rel_e=apply_gps_rel_e,altitude_m_s=altitude_m_s,altitude_m_e=altitude_m_e,v_m_s_s=v_m_s_s,v_m_s_e=v_m_s_e) / td2._get_month_seconds(d[0], d[1], month_unit, td2.is_leap((d[0] if use_date_in_leapyears_checking else year_for_leapyears_checking), leap_year))
def ptyears(d, count_ls_param=True, UTDLS=False, input_utc=True, unix_epoch=False, custom_epoch_as_utc=True, custom_epoch_as_tt=False,custom_epoch=None, input_tt=False, output_tt=False,uniform_year=False, tropical_year=False, custom_year=None, year_for_leapyear_checking=None,
            apply_gps_rel_s=False,apply_gps_rel_e=False,altitude_m_s=20200000,altitude_m_e=20200000,v_m_s_s=3874,v_m_s_e=3874):
    """this function give the date as timestamp in years, fractions version
    d: is the date and it's a list made off: [Y(year),M(month),D(day),H(hour),MI(minute),S(second),SS(sub-seconds)] and all of these items integers
    count_ls_param: enabling this would count leap-seconds, boolean
    UTDLS: enabling this is useless in all cases except when count_ls_param is True, and it would fetch a list of updated leap seconds from the internet, boolean
    input_utc: this one is by default true, which is when your input is in the UTC system, if it's not make this parameter false
    and your dates would be considered as TAI input, boolean
    unix_epoch: this option is False by default and it's a boolean value setting it as true would give you timestamp relative to unix epoch
    custom_epoch_as_utc: this option is True by default and it's a boolean value setting it as false would give you timestamp relative to custom epoch as TAI
    custom_epoch_as_tt: this option is False by default and it's a boolean value setting it as true would give you timestamp relative to custom epoch as TT
    custom_epoch: this option is None by default and it's a list made off: [Y(year),M(month),D(day),H(hour),MI(minute),S(second),SS(sub-seconds)] and all of these items integers
    input_tt: this one is by default false, which is when you wanna your input to be in TT, boolean
    output_tt: this one is by default false, which is when you wanna your output to be in TT, boolean
    uniform_year: this option is False by default and it's a boolean value setting it as true would make the function use the uniform year
    tropical_year: this option is False by default and it's a boolean value setting it as true would make the function use the tropical year
    custom_year: this option is False by default and it's a boolean value setting it as true would make the function use the custom year
    year_for_leapyears_checking: it's an integer value, that would be used instead of using the year in starting value to know if to consider
    the year as a leap year or a normal one
    apply_gps_rel: this one is by default false, used only when relativity(for near orbit objects like satellites) is wanted for the timestamp, boolean
    altitude_m: the height of object of the timestamp like a satellite,needed when relativity is wanted, int
    v_m_s:the velocity of object of the timestamp like a satellite,needed when relativity is wanted, int
    """
    return td1._timestampinner(*d, count_ls_param=count_ls_param, UTDLS=UTDLS, input_utc=input_utc, unix_epoch=unix_epoch, custom_epoch_as_utc=custom_epoch_as_utc, custom_epoch_as_tt=custom_epoch_as_tt, custom_epoch=custom_epoch, input_tt=input_tt, output_tt=output_tt,apply_gps_rel_s=apply_gps_rel_s,apply_gps_rel_e=apply_gps_rel_e,altitude_m_s=altitude_m_s,altitude_m_e=altitude_m_e,v_m_s_s=v_m_s_s,v_m_s_e=v_m_s_e)/ td1._seconds_in_year(d[0] if year_for_leapyear_checking is None else year_for_leapyear_checking, uniform_year=uniform_year, tropical_year=tropical_year, custom_year=custom_year)
def ctyears(d, count_ls_param=True, UTDLS=False, input_utc=True, unix_epoch=False, custom_epoch_as_utc=True, custom_epoch_as_tt=False,custom_epoch=None, input_tt=False, output_tt=False,uniform_year=False, tropical_year=False, custom_year=None, year_for_leapyear_checking=None,
            apply_gps_rel_s=False,apply_gps_rel_e=False,altitude_m_s=20200000,altitude_m_e=20200000,v_m_s_s=3874,v_m_s_e=3874):
    """this function give the date as timestamp in years, fractionals version
    d: is the date and it's a list made off: [Y(year),M(month),D(day),H(hour),MI(minute),S(second),SS(sub-seconds)] and all of these items integers
    count_ls_param: enabling this would count leap-seconds, boolean
    UTDLS: enabling this is useless in all cases except when count_ls_param is True, and it would fetch a list of updated leap seconds from the internet, boolean
    input_utc: this one is by default true, which is when your input is in the UTC system, if it's not make this parameter false
    and your dates would be considered as TAI input, boolean
    unix_epoch: this option is False by default and it's a boolean value setting it as true would give you timestamp relative to unix epoch
    custom_epoch_as_utc: this option is True by default and it's a boolean value setting it as false would give you timestamp relative to custom epoch as TAI
    custom_epoch_as_tt: this option is False by default and it's a boolean value setting it as true would give you timestamp relative to custom epoch as TT
    custom_epoch: this option is None by default and it's a list made off: [Y(year),M(month),D(day),H(hour),MI(minute),S(second),SS(sub-seconds)] and all of these items integers
    input_tt: this one is by default false, which is when you wanna your input to be in TT, boolean
    output_tt: this one is by default false, which is when you wanna your output to be in TT, boolean
    uniform_year: this option is False by default and it's a boolean value setting it as true would make the function use the uniform year
    tropical_year: this option is False by default and it's a boolean value setting it as true would make the function use the tropical year
    custom_year: this option is False by default and it's a boolean value setting it as true would make the function use the custom year
    year_for_leapyears_checking: it's an integer value, that would be used instead of using the year in starting value to know if to consider
    the year as a leap year or a normal one
    apply_gps_rel: this one is by default false, used only when relativity(for near orbit objects like satellites) is wanted for the timestamp, boolean
    altitude_m: the height of object of the timestamp like a satellite,needed when relativity is wanted, int
    v_m_s:the velocity of object of the timestamp like a satellite,needed when relativity is wanted, int
    """
    return td2._timestampinner(*d, count_ls_param=count_ls_param, UTDLS=UTDLS, input_utc=input_utc, unix_epoch=unix_epoch, custom_epoch_as_utc=custom_epoch_as_utc, custom_epoch_as_tt=custom_epoch_as_tt, custom_epoch=custom_epoch, input_tt=input_tt, output_tt=output_tt,apply_gps_rel_s=apply_gps_rel_s,apply_gps_rel_e=apply_gps_rel_e,altitude_m_s=altitude_m_s,altitude_m_e=altitude_m_e,v_m_s_s=v_m_s_s,v_m_s_e=v_m_s_e)/ td2._seconds_in_year(d[0] if year_for_leapyear_checking is None else year_for_leapyear_checking, uniform_year=uniform_year, tropical_year=tropical_year, custom_year=custom_year)
def ptdecades(d, count_ls_param=True, UTDLS=False, input_utc=True, unix_epoch=False, custom_epoch_as_utc=True, custom_epoch_as_tt=False,custom_epoch=None, input_tt=False, output_tt=False,uniform_year=False, tropical_year=False, custom_year=None, year_for_leapyear_checking=None,
              apply_gps_rel_s=False,apply_gps_rel_e=False,altitude_m_s=20200000,altitude_m_e=20200000,v_m_s_s=3874,v_m_s_e=3874):
    """this function give the date as timestamp in decades, fractions version
    d: is the date and it's a list made off: [Y(year),M(month),D(day),H(hour),MI(minute),S(second),SS(sub-seconds)] and all of these items integers
    count_ls_param: enabling this would count leap-seconds, boolean
    UTDLS: enabling this is useless in all cases except when count_ls_param is True, and it would fetch a list of updated leap seconds from the internet, boolean
    input_utc: this one is by default true, which is when your input is in the UTC system, if it's not make this parameter false
    and your dates would be considered as TAI input, boolean
    unix_epoch: this option is False by default and it's a boolean value setting it as true would give you timestamp relative to unix epoch
    custom_epoch_as_utc: this option is True by default and it's a boolean value setting it as false would give you timestamp relative to custom epoch as TAI
    custom_epoch_as_tt: this option is False by default and it's a boolean value setting it as true would give you timestamp relative to custom epoch as TT
    custom_epoch: this option is None by default and it's a list made off: [Y(year),M(month),D(day),H(hour),MI(minute),S(second),SS(sub-seconds)] and all of these items integers
    input_tt: this one is by default false, which is when you wanna your input to be in TT, boolean
    output_tt: this one is by default false, which is when you wanna your output to be in TT, boolean
    uniform_year: this option is False by default and it's a boolean value setting it as true would make the function use the uniform year
    tropical_year: this option is False by default and it's a boolean value setting it as true would make the function use the tropical year
    custom_year: this option is False by default and it's a boolean value setting it as true would make the function use the custom year
    year_for_leapyears_checking: it's an integer value, that would be used instead of using the year in starting value to know if to consider
    the year as a leap year or a normal one
    apply_gps_rel: this one is by default false, used only when relativity(for near orbit objects like satellites) is wanted for the timestamp, boolean
    altitude_m: the height of object of the timestamp like a satellite,needed when relativity is wanted, int
    v_m_s:the velocity of object of the timestamp like a satellite,needed when relativity is wanted, int
    """
    return (
            td1._timestampinner(*d, count_ls_param=count_ls_param, UTDLS=UTDLS, input_utc=input_utc, unix_epoch=unix_epoch, custom_epoch_as_utc=custom_epoch_as_utc, custom_epoch_as_tt=custom_epoch_as_tt, custom_epoch=custom_epoch, input_tt=input_tt, output_tt=output_tt,apply_gps_rel_s=apply_gps_rel_s,apply_gps_rel_e=apply_gps_rel_e,altitude_m_s=altitude_m_s,altitude_m_e=altitude_m_e,v_m_s_s=v_m_s_s,v_m_s_e=v_m_s_e) / td1._seconds_in_year(d[0] if year_for_leapyear_checking is None else year_for_leapyear_checking, uniform_year=uniform_year, tropical_year=tropical_year, custom_year=custom_year))/10
def ctdecades(d, count_ls_param=True, UTDLS=False, input_utc=True, unix_epoch=False, custom_epoch_as_utc=True, custom_epoch_as_tt=False,custom_epoch=None, input_tt=False, output_tt=False,uniform_year=False, tropical_year=False, custom_year=None, year_for_leapyear_checking=None,
              apply_gps_rel_s=False,apply_gps_rel_e=False,altitude_m_s=20200000,altitude_m_e=20200000,v_m_s_s=3874,v_m_s_e=3874):
    """this function give the date as timestamp in decades, fractionals version
    d: is the date and it's a list made off: [Y(year),M(month),D(day),H(hour),MI(minute),S(second),SS(sub-seconds)] and all of these items integers
    count_ls_param: enabling this would count leap-seconds, boolean
    UTDLS: enabling this is useless in all cases except when count_ls_param is True, and it would fetch a list of updated leap seconds from the internet, boolean
    input_utc: this one is by default true, which is when your input is in the UTC system, if it's not make this parameter false
    and your dates would be considered as TAI input, boolean
    unix_epoch: this option is False by default and it's a boolean value setting it as true would give you timestamp relative to unix epoch
    custom_epoch_as_utc: this option is True by default and it's a boolean value setting it as false would give you timestamp relative to custom epoch as TAI
    custom_epoch_as_tt: this option is False by default and it's a boolean value setting it as true would give you timestamp relative to custom epoch as TT
    custom_epoch: this option is None by default and it's a list made off: [Y(year),M(month),D(day),H(hour),MI(minute),S(second),SS(sub-seconds)] and all of these items integers
    input_tt: this one is by default false, which is when you wanna your input to be in TT, boolean
    output_tt: this one is by default false, which is when you wanna your output to be in TT, boolean
    uniform_year: this option is False by default and it's a boolean value setting it as true would make the function use the uniform year
    tropical_year: this option is False by default and it's a boolean value setting it as true would make the function use the tropical year
    custom_year: this option is False by default and it's a boolean value setting it as true would make the function use the custom year
    year_for_leapyears_checking: it's an integer value, that would be used instead of using the year in starting value to know if to consider
    the year as a leap year or a normal one
    apply_gps_rel: this one is by default false, used only when relativity(for near orbit objects like satellites) is wanted for the timestamp, boolean
    altitude_m: the height of object of the timestamp like a satellite,needed when relativity is wanted, int
    v_m_s:the velocity of object of the timestamp like a satellite,needed when relativity is wanted, int
    """
    return (td2._timestampinner(*d, count_ls_param=count_ls_param, UTDLS=UTDLS, input_utc=input_utc, unix_epoch=unix_epoch, custom_epoch_as_utc=custom_epoch_as_utc, custom_epoch_as_tt=custom_epoch_as_tt, custom_epoch=custom_epoch, input_tt=input_tt, output_tt=output_tt,apply_gps_rel_s=apply_gps_rel_s,apply_gps_rel_e=apply_gps_rel_e,altitude_m_s=altitude_m_s,altitude_m_e=altitude_m_e,v_m_s_s=v_m_s_s,v_m_s_e=v_m_s_e) / td2._seconds_in_year(d[0] if year_for_leapyear_checking is None else year_for_leapyear_checking, uniform_year=uniform_year, tropical_year=tropical_year, custom_year=custom_year))/10
def ptcenturies(d, count_ls_param=True, UTDLS=False, input_utc=True, unix_epoch=False, custom_epoch_as_utc=True, custom_epoch_as_tt=False,custom_epoch=None, input_tt=False, output_tt=False,uniform_year=False, tropical_year=False, custom_year=None, year_for_leapyear_checking=None,
                apply_gps_rel_s=False,apply_gps_rel_e=False,altitude_m_s=20200000,altitude_m_e=20200000,v_m_s_s=3874,v_m_s_e=3874):
    """this function give the date as timestamp in centuries, fractions version
    d: is the date and it's a list made off: [Y(year),M(month),D(day),H(hour),MI(minute),S(second),SS(sub-seconds)] and all of these items integers
    count_ls_param: enabling this would count leap-seconds, boolean
    UTDLS: enabling this is useless in all cases except when count_ls_param is True, and it would fetch a list of updated leap seconds from the internet, boolean
    input_utc: this one is by default true, which is when your input is in the UTC system, if it's not make this parameter false
    and your dates would be considered as TAI input, boolean
    unix_epoch: this option is False by default and it's a boolean value setting it as true would give you timestamp relative to unix epoch
    custom_epoch_as_utc: this option is True by default and it's a boolean value setting it as false would give you timestamp relative to custom epoch as TAI
    custom_epoch_as_tt: this option is False by default and it's a boolean value setting it as true would give you timestamp relative to custom epoch as TT
    custom_epoch: this option is None by default and it's a list made off: [Y(year),M(month),D(day),H(hour),MI(minute),S(second),SS(sub-seconds)] and all of these items integers
    input_tt: this one is by default false, which is when you wanna your input to be in TT, boolean
    output_tt: this one is by default false, which is when you wanna your output to be in TT, boolean
    uniform_year: this option is False by default and it's a boolean value setting it as true would make the function use the uniform year
    tropical_year: this option is False by default and it's a boolean value setting it as true would make the function use the tropical year
    custom_year: this option is False by default and it's a boolean value setting it as true would make the function use the custom year
    year_for_leapyears_checking: it's an integer value, that would be used instead of using the year in starting value to know if to consider
    the year as a leap year or a normal one
    apply_gps_rel: this one is by default false, used only when relativity(for near orbit objects like satellites) is wanted for the timestamp, boolean
    altitude_m: the height of object of the timestamp like a satellite,needed when relativity is wanted, int
    v_m_s:the velocity of object of the timestamp like a satellite,needed when relativity is wanted, int
    """
    return (td1._timestampinner(*d, count_ls_param=count_ls_param, UTDLS=UTDLS, input_utc=input_utc, unix_epoch=unix_epoch, custom_epoch_as_utc=custom_epoch_as_utc, custom_epoch_as_tt=custom_epoch_as_tt, custom_epoch=custom_epoch, input_tt=input_tt, output_tt=output_tt,apply_gps_rel_s=apply_gps_rel_s,apply_gps_rel_e=apply_gps_rel_e,altitude_m_s=altitude_m_s,altitude_m_e=altitude_m_e,v_m_s_s=v_m_s_s,v_m_s_e=v_m_s_e) / td1._seconds_in_year(d[0] if year_for_leapyear_checking is None else year_for_leapyear_checking, uniform_year=uniform_year, tropical_year=tropical_year, custom_year=custom_year))/100
def ctcenturies(d, count_ls_param=True, UTDLS=False, input_utc=True, unix_epoch=False, custom_epoch_as_utc=True, custom_epoch_as_tt=False,custom_epoch=None, input_tt=False, output_tt=False,uniform_year=False, tropical_year=False, custom_year=None, year_for_leapyear_checking=None,
                apply_gps_rel_s=False,apply_gps_rel_e=False,altitude_m_s=20200000,altitude_m_e=20200000,v_m_s_s=3874,v_m_s_e=3874):
    """this function give the date as timestamp in centuries, fractionals version
    d: is the date and it's a list made off: [Y(year),M(month),D(day),H(hour),MI(minute),S(second),SS(sub-seconds)] and all of these items integers
    count_ls_param: enabling this would count leap-seconds, boolean
    UTDLS: enabling this is useless in all cases except when count_ls_param is True, and it would fetch a list of updated leap seconds from the internet, boolean
    input_utc: this one is by default true, which is when your input is in the UTC system, if it's not make this parameter false
    and your dates would be considered as TAI input, boolean
    unix_epoch: this option is False by default and it's a boolean value setting it as true would give you timestamp relative to unix epoch
    custom_epoch_as_utc: this option is True by default and it's a boolean value setting it as false would give you timestamp relative to custom epoch as TAI
    custom_epoch_as_tt: this option is False by default and it's a boolean value setting it as true would give you timestamp relative to custom epoch as TT
    custom_epoch: this option is None by default and it's a list made off: [Y(year),M(month),D(day),H(hour),MI(minute),S(second),SS(sub-seconds)] and all of these items integers
    input_tt: this one is by default false, which is when you wanna your input to be in TT, boolean
    output_tt: this one is by default false, which is when you wanna your output to be in TT, boolean
    uniform_year: this option is False by default and it's a boolean value setting it as true would make the function use the uniform year
    tropical_year: this option is False by default and it's a boolean value setting it as true would make the function use the tropical year
    custom_year: this option is False by default and it's a boolean value setting it as true would make the function use the custom year
    year_for_leapyears_checking: it's an integer value, that would be used instead of using the year in starting value to know if to consider
    the year as a leap year or a normal one
    apply_gps_rel: this one is by default false, used only when relativity(for near orbit objects like satellites) is wanted for the timestamp, boolean
    altitude_m: the height of object of the timestamp like a satellite,needed when relativity is wanted, int
    v_m_s:the velocity of object of the timestamp like a satellite,needed when relativity is wanted, int
    """
    return (td2._timestampinner(*d, count_ls_param=count_ls_param, UTDLS=UTDLS, input_utc=input_utc, unix_epoch=unix_epoch, custom_epoch_as_utc=custom_epoch_as_utc, custom_epoch_as_tt=custom_epoch_as_tt, custom_epoch=custom_epoch, input_tt=input_tt, output_tt=output_tt,apply_gps_rel_s=apply_gps_rel_s,apply_gps_rel_e=apply_gps_rel_e,altitude_m_s=altitude_m_s,altitude_m_e=altitude_m_e,v_m_s_s=v_m_s_s,v_m_s_e=v_m_s_e) / td2._seconds_in_year(d[0] if year_for_leapyear_checking is None else year_for_leapyear_checking, uniform_year=uniform_year, tropical_year=tropical_year, custom_year=custom_year))/100
def ptmillennia(d, count_ls_param=True, UTDLS=False, input_utc=True, unix_epoch=False, custom_epoch_as_utc=True, custom_epoch_as_tt=False,custom_epoch=None, input_tt=False, output_tt=False,uniform_year=False, tropical_year=False, custom_year=None, year_for_leapyear_checking=None,
                apply_gps_rel_s=False,apply_gps_rel_e=False,altitude_m_s=20200000,altitude_m_e=20200000,v_m_s_s=3874,v_m_s_e=3874):
    """this function give the date as timestamp in millennia, fractions version
    d: is the date and it's a list made off: [Y(year),M(month),D(day),H(hour),MI(minute),S(second),SS(sub-seconds)] and all of these items integers
    count_ls_param: enabling this would count leap-seconds, boolean
    UTDLS: enabling this is useless in all cases except when count_ls_param is True, and it would fetch a list of updated leap seconds from the internet, boolean
    input_utc: this one is by default true, which is when your input is in the UTC system, if it's not make this parameter false
    and your dates would be considered as TAI input, boolean
    unix_epoch: this option is False by default and it's a boolean value setting it as true would give you timestamp relative to unix epoch
    custom_epoch_as_utc: this option is True by default and it's a boolean value setting it as false would give you timestamp relative to custom epoch as TAI
    custom_epoch_as_tt: this option is False by default and it's a boolean value setting it as true would give you timestamp relative to custom epoch as TT
    custom_epoch: this option is None by default and it's a list made off: [Y(year),M(month),D(day),H(hour),MI(minute),S(second),SS(sub-seconds)] and all of these items integers
    input_tt: this one is by default false, which is when you wanna your input to be in TT, boolean
    output_tt: this one is by default false, which is when you wanna your output to be in TT, boolean
    uniform_year: this option is False by default and it's a boolean value setting it as true would make the function use the uniform year
    tropical_year: this option is False by default and it's a boolean value setting it as true would make the function use the tropical year
    custom_year: this option is False by default and it's a boolean value setting it as true would make the function use the custom year
    year_for_leapyears_checking: it's an integer value, that would be used instead of using the year in starting value to know if to consider
    the year as a leap year or a normal one
    apply_gps_rel: this one is by default false, used only when relativity(for near orbit objects like satellites) is wanted for the timestamp, boolean
    altitude_m: the height of object of the timestamp like a satellite,needed when relativity is wanted, int
    v_m_s:the velocity of object of the timestamp like a satellite,needed when relativity is wanted, int
    """
    return (td1._timestampinner(*d, count_ls_param=count_ls_param, UTDLS=UTDLS, input_utc=input_utc, unix_epoch=unix_epoch, custom_epoch_as_utc=custom_epoch_as_utc, custom_epoch_as_tt=custom_epoch_as_tt, custom_epoch=custom_epoch, input_tt=input_tt, output_tt=output_tt,apply_gps_rel_s=apply_gps_rel_s,apply_gps_rel_e=apply_gps_rel_e,altitude_m_s=altitude_m_s,altitude_m_e=altitude_m_e,v_m_s_s=v_m_s_s,v_m_s_e=v_m_s_e) / td1._seconds_in_year(d[0] if year_for_leapyear_checking is None else year_for_leapyear_checking, uniform_year=uniform_year, tropical_year=tropical_year, custom_year=custom_year))/1000
def ctmillennia(d, count_ls_param=True, UTDLS=False, input_utc=True, unix_epoch=False, custom_epoch_as_utc=True, custom_epoch_as_tt=False,custom_epoch=None, input_tt=False, output_tt=False,uniform_year=False, tropical_year=False, custom_year=None, year_for_leapyear_checking=None,
                apply_gps_rel_s=False,apply_gps_rel_e=False,altitude_m_s=20200000,altitude_m_e=20200000,v_m_s_s=3874,v_m_s_e=3874):
    """this function give the date as timestamp in millennia, fractionals version
    d: is the date and it's a list made off: [Y(year),M(month),D(day),H(hour),MI(minute),S(second),SS(sub-seconds)] and all of these items integers
    count_ls_param: enabling this would count leap-seconds, boolean
    UTDLS: enabling this is useless in all cases except when count_ls_param is True, and it would fetch a list of updated leap seconds from the internet, boolean
    input_utc: this one is by default true, which is when your input is in the UTC system, if it's not make this parameter false
    and your dates would be considered as TAI input, boolean
    unix_epoch: this option is False by default and it's a boolean value setting it as true would give you timestamp relative to unix epoch
    custom_epoch_as_utc: this option is True by default and it's a boolean value setting it as false would give you timestamp relative to custom epoch as TAI
    custom_epoch_as_tt: this option is False by default and it's a boolean value setting it as true would give you timestamp relative to custom epoch as TT
    custom_epoch: this option is None by default and it's a list made off: [Y(year),M(month),D(day),H(hour),MI(minute),S(second),SS(sub-seconds)] and all of these items integers
    input_tt: this one is by default false, which is when you wanna your input to be in TT, boolean
    output_tt: this one is by default false, which is when you wanna your output to be in TT, boolean
    uniform_year: this option is False by default and it's a boolean value setting it as true would make the function use the uniform year
    tropical_year: this option is False by default and it's a boolean value setting it as true would make the function use the tropical year
    custom_year: this option is False by default and it's a boolean value setting it as true would make the function use the custom year
    year_for_leapyears_checking: it's an integer value, that would be used instead of using the year in starting value to know if to consider
    the year as a leap year or a normal one
    apply_gps_rel: this one is by default false, used only when relativity(for near orbit objects like satellites) is wanted for the timestamp, boolean
    altitude_m: the height of object of the timestamp like a satellite,needed when relativity is wanted, int
    v_m_s:the velocity of object of the timestamp like a satellite,needed when relativity is wanted, int
    """
    return (td2._timestampinner(*d, count_ls_param=count_ls_param, UTDLS=UTDLS, input_utc=input_utc, unix_epoch=unix_epoch, custom_epoch_as_utc=custom_epoch_as_utc, custom_epoch_as_tt=custom_epoch_as_tt, custom_epoch=custom_epoch, input_tt=input_tt, output_tt=output_tt,apply_gps_rel_s=apply_gps_rel_s,apply_gps_rel_e=apply_gps_rel_e,altitude_m_s=altitude_m_s,altitude_m_e=altitude_m_e,v_m_s_s=v_m_s_s,v_m_s_e=v_m_s_e) / td2._seconds_in_year(d[0] if year_for_leapyear_checking is None else year_for_leapyear_checking, uniform_year=uniform_year, tropical_year=tropical_year, custom_year=custom_year))/1000
def ptsubseconds(d,subunit=10**6,count_ls_param=True, UTDLS=False, input_utc=True,unix_epoch=False,custom_epoch_as_utc=True,custom_epoch_as_tt=False,custom_epoch=None,input_tt=False,output_tt=False,
                 apply_gps_rel_s=False,apply_gps_rel_e=False,altitude_m_s=20200000,altitude_m_e=20200000,v_m_s_s=3874,v_m_s_e=3874):
    """this function give the date as timestamp in subseconds, fractions version
    d: is the date and it's a list made off: [Y(year),M(month),D(day),H(hour),MI(minute),S(second),SS(sub-seconds)] and all of these items integers
    subunit: basically is the number that seconds would be divided upon to get difference in as specific unit like 10**6 for micro or 10**9 nano seconds, the default is 10**6 and it's an integer
    count_ls_param: enabling this would count leap-seconds, boolean
    UTDLS: enabling this is useless in all cases except when count_ls_param is True, and it would fetch a list of updated leap seconds from the internet, boolean
    input_utc: this one is by default true, which is when your input is in the UTC system, if it's not make this parameter false
    and your dates would be considered as TAI input, boolean
    unix_epoch: this option is False by default and it's a boolean value setting it as true would give you timestamp relative to unix epoch
    custom_epoch_as_utc: this option is True by default and it's a boolean value setting it as false would give you timestamp relative to custom epoch as TAI
    custom_epoch_as_tt: this option is False by default and it's a boolean value setting it as true would give you timestamp relative to custom epoch as TT
    custom_epoch: this option is None by default and it's a list made off: [Y(year),M(month),D(day),H(hour),MI(minute),S(second),SS(sub-seconds)] and all of these items integers
    input_tt: this one is by default false, which is when you wanna your input to be in TT, boolean
    output_tt: this one is by default false, which is when you wanna your output to be in TT, boolean
    apply_gps_rel: this one is by default false, used only when relativity(for near orbit objects like satellites) is wanted for the timestamp, boolean
    altitude_m: the height of object of the timestamp like a satellite,needed when relativity is wanted, int
    v_m_s:the velocity of object of the timestamp like a satellite,needed when relativity is wanted, int
    """
    return td1._timestampinner(*d, count_ls_param=count_ls_param, UTDLS=UTDLS, input_utc=input_utc, unix_epoch=unix_epoch, custom_epoch_as_utc=custom_epoch_as_utc, custom_epoch_as_tt=custom_epoch_as_tt, custom_epoch=custom_epoch, input_tt=input_tt, output_tt=output_tt,apply_gps_rel_s=apply_gps_rel_s,apply_gps_rel_e=apply_gps_rel_e,altitude_m_s=altitude_m_s,altitude_m_e=altitude_m_e,v_m_s_s=v_m_s_s,v_m_s_e=v_m_s_e)/(1 / subunit)
def ctsubseconds(d,subunit=10**6,count_ls_param=True, UTDLS=False, input_utc=True,unix_epoch=False,custom_epoch_as_utc=True,custom_epoch_as_tt=False,custom_epoch=None,input_tt=False,output_tt=False,
                 apply_gps_rel_s=False,apply_gps_rel_e=False,altitude_m_s=20200000,altitude_m_e=20200000,v_m_s_s=3874,v_m_s_e=3874):
    """this function give the date as timestamp in subseconds, fractionals version
    d: is the date and it's a list made off: [Y(year),M(month),D(day),H(hour),MI(minute),S(second),SS(sub-seconds)] and all of these items integers
    subunit: basically is the number that seconds would be divided upon to get difference in as specific unit like 10**6 for micro or 10**9 nano seconds, the default is 10**6 and it's an integer
    count_ls_param: enabling this would count leap-seconds, boolean
    UTDLS: enabling this is useless in all cases except when count_ls_param is True, and it would fetch a list of updated leap seconds from the internet, boolean
    input_utc: this one is by default true, which is when your input is in the UTC system, if it's not make this parameter false
    and your dates would be considered as TAI input, boolean
    unix_epoch: this option is False by default and it's a boolean value setting it as true would give you timestamp relative to unix epoch
    custom_epoch_as_utc: this option is True by default and it's a boolean value setting it as false would give you timestamp relative to custom epoch as TAI
    custom_epoch_as_tt: this option is False by default and it's a boolean value setting it as true would give you timestamp relative to custom epoch as TT
    custom_epoch: this option is None by default and it's a list made off: [Y(year),M(month),D(day),H(hour),MI(minute),S(second),SS(sub-seconds)] and all of these items integers
    input_tt: this one is by default false, which is when you wanna your input to be in TT, boolean
    output_tt: this one is by default false, which is when you wanna your output to be in TT, boolean
    apply_gps_rel: this one is by default false, used only when relativity(for near orbit objects like satellites) is wanted for the timestamp, boolean
    altitude_m: the height of object of the timestamp like a satellite,needed when relativity is wanted, int
    v_m_s:the velocity of object of the timestamp like a satellite,needed when relativity is wanted, int
    """
    return td2._timestampinner(*d, count_ls_param=count_ls_param, UTDLS=UTDLS, input_utc=input_utc, unix_epoch=unix_epoch, custom_epoch_as_utc=custom_epoch_as_utc, custom_epoch_as_tt=custom_epoch_as_tt, custom_epoch=custom_epoch, input_tt=input_tt, output_tt=output_tt,apply_gps_rel_s=apply_gps_rel_s,apply_gps_rel_e=apply_gps_rel_e,altitude_m_s=altitude_m_s,altitude_m_e=altitude_m_e,v_m_s_s=v_m_s_s,v_m_s_e=v_m_s_e)/(1 / subunit)
def pmonthscal(s,e):
    """this function give the number of months between two dates, fractions version
    s: is the first date(starting date) and it's a list made off: [Y(year),M(month),D(day),H(hour),MI(minute),S(second),SS(sub-seconds)] and all of these items integers
    e: is the second date(ending date) and it has same format and data type as s
    """
    return  td1._monthscalner(s, e)
def cmonthscal(s,e):
    """this function give the number of months between two dates, fractionals version
    s: is the first date(starting date) and it's a list made off: [Y(year),M(month),D(day),H(hour),MI(minute),S(second),SS(sub-seconds)] and all of these items integers
    e: is the second date(ending date) and it has same format and data type as s
    """
    return  td2._monthscalner(s, e)
def pyearscal(s,e):
    """this function give the number of years between two dates, fractions version
    s: is the first date(starting date) and it's a list made off: [Y(year),M(month),D(day),H(hour),MI(minute),S(second),SS(sub-seconds)] and all of these items integers
    e: is the second date(ending date) and it has same format and data type as s
    """
    return  td1._yearscalner(s, e)
def cyearscal(s,e):
    """this function give the number of years between two dates, fractionals version
    s: is the first date(starting date) and it's a list made off: [Y(year),M(month),D(day),H(hour),MI(minute),S(second),SS(sub-seconds)] and all of these items integers
    e: is the second date(ending date) and it has same format and data type as s
    """
    return  td2._yearscalner(s, e)